c++ - 我对 std::list 的实现给出了很多错误

Question

我已经编写了 List 模板的实现，其工作方式类似于 std::list。这是一个 List.h 文件:

#include <memory>

template<typename T>
class List {

    class Node {
    public:
    T data;
    Node *previous;
    Node *next; //is that T needed?
    Node(T &d, Node *p, Node *n) : data(d), next(n) { };
    };

private:

    Node *head; //first element
    Node *tail;

    void create() { head = tail = NULL; }

    void create(const List &rhs);

    void uncreate();
public:
    typedef T *iterator;
    typedef const T *const_iterator;
    typedef size_t size_type;
    typedef T value_type;

    List() { create(); };

    List &operator=(const List &rhs);

    List(const List &rhs) { create(rhs); };

    ~List() { uncreate(); };

    T *begin() { return head->data; };

    T *end() { return tail->next->data; };

    T front() { return head->data; };

    T back() { return tail->data; };

    bool empty() {return head==NULL;}

    size_type size() { return tail - head + 1; }; //add one here?

    T &operator[](size_type i);

//    const T &operator[](size_type i) const; //how to implement and do not duplicate code?

    T *push_back(T &data);

    T *push_front(T &data);

    void pop_front();

    void pop_back();


};

这是我的List.cpp文件

#include "List.h"
#include <cassert>
#include <iterator>

template<typename T, class Node>
class iterator : public std::iterator<std::bidirectional_iterator_tag, Node*, Node&>{
    Node* underlying;

public:
    explicit iterator(Node *n):underlying(n){};
    iterator():underlying(nullptr){};

    iterator& operator++() { //preinc
    assert(underlying != nullptr && "Out-of-bounds iterator increment!");
    underlying = underlying->next;
    return *this;
    }

    iterator operator++(int) { //postinc
    assert(underlying != nullptr && "Out-of-bounds iterator increment!");
    iterator temp(*this);
    ++(*this);
    return temp;
    }

    iterator& operator--() { //predec
    assert(underlying != nullptr && "Out-of-bounds iterator decrement!");
    underlying = underlying->previous;
    return *this;
    }

    iterator operator--(int) { //postdec
    assert(underlying != nullptr && "Out-of-bounds iterator decrement!");
    iterator temp(*this);
    --(*this);
    return temp;
    }

    bool operator== (const iterator& rhs)
    {
    return underlying == rhs.underlying;

    }
    bool operator!= (const iterator& rhs)
    {
    return underlying != rhs.underlying;

    }
    T& operator*() {
    return underlying->data;
    }
};

void List::create(const List &rhs) {
    iterator this_iter = head;
    iterator rhs_iter = rhs.head;
    while(rhs_iter!=NULL){
    this_iter->data = (rhs_iter++)->data;
    ++this_iter;
    }
}

List::value_type &List::operator[](List::size_type i) {
    if (i < size() && i >= 0) {
    Node *temp = head;
    while (i > 0) {
        temp = temp->next;
        i--;
    }
    return temp->data;
    }
    throw std::out_of_range("Index out of range");
}

List &List::operator=(const List &rhs) {
    if (&rhs != this) {
    uncreate();
    create(rhs);
    }
    return *this;
}


List::value_type *List::push_back(List::value_type &data) {
    Node *n = new Node(data, tail, 0);
    tail->next = n;
    tail = tail->next;
    if(head==0) //if it was the first element added
    head = tail;
    return tail;
}

List::value_type *List::push_front(List::value_type &data) {
    Node *n = new Node(data, 0, head);
    head->previous = n;
    head = n;
    if(tail==0) //if it was the first element added
    tail = head;
    return head;
}


void List::pop_front() {
    Node* new_head = head->next;
    delete head->data; //delete, erase or what?
    head = new_head;
}

void List::pop_back() {
    delete tail->data; //delete, erase or what?
    tail = tail->previous;
}

void List::uncreate() {
    Node* temp = head;
    while(temp!=NULL){
    delete temp->data;
    temp = temp->next;
    }
    head = tail = NULL;
}

我还创建了一个简单的 main.cpp:

#include "List.h"
int main(){
    List<int> l;
    l.push_back(1);
    l.push_back(2);
    l.push_back(3);
}

但是我有很多错误:

    main.cpp:5:5: error: ‘l’ was not declared in this scope
         l.push_back(1);
         ^
    List.cpp:58:11: error: ‘T’ was not declared in this scope
     void List<T>::create(const List &rhs) {
           ^
    List.cpp:58:12: error: template argument 1 is invalid
     void List<T>::create(const List &rhs) {
            ^
    List.cpp:58:28: error: invalid use of template-name ‘List’ without an argument list
     void List<T>::create(const List &rhs) {
                            ^
    List.cpp: In function ‘void create(const int&)’:
    List.cpp:59:14: error: missing template arguments before ‘this_iter’
         iterator this_iter = head;
              ^
    List.cpp:60:14: error: missing template arguments before ‘rhs_iter’
         iterator rhs_iter = rhs.head;
              ^
    List.cpp:61:11: error: ‘rhs_iter’ was not declared in this scope
         while(rhs_iter!=NULL){
           ^
    List.cpp:62:9: error: ‘this_iter’ was not declared in this scope
         this_iter->data = (rhs_iter++)->data;
         ^
    List.cpp: At global scope:
    List.cpp:67:1: error: invalid use of template-name ‘List’ without an argument list
     List::value_type &List::operator[](List::size_type i) {
     ^
    List.cpp:79:1: error: invalid use of template-name ‘List’ without an argument list
     List &List::operator=(const List &rhs) {
     ^
    List.cpp:88:1: error: invalid use of template-name ‘List’ without an argument list
     List::value_type *List::push_back(List::value_type &data) {
     ^
    List.cpp:97:1: error: invalid use of template-name ‘List’ without an argument list
     List::value_type *List::push_front(List::value_type &data) {
     ^
    List.cpp:107:6: error: ‘template<class T> class List’ used without template parameters
     void List::pop_front() {
          ^
    List.cpp: In function ‘void pop_front()’:
    List.cpp:108:5: error: ‘Node’ was not declared in this scope
         Node* new_head = head->next;
         ^
    List.cpp:108:11: error: ‘new_head’ was not declared in this scope
         Node* new_head = head->next;
           ^
    List.cpp:108:22: error: ‘head’ was not declared in this scope
         Node* new_head = head->next;
                      ^
    List.cpp: At global scope:
    List.cpp:113:6: error: ‘template<class T> class List’ used without template parameters
     void List::pop_back() {
          ^
    List.cpp: In function ‘void pop_back()’:
    List.cpp:114:12: error: ‘tail’ was not declared in this scope
         delete tail->data; //delete, erase or what?
            ^
    List.cpp: At global scope:
    List.cpp:118:6: error: ‘template<class T> class List’ used without template parameters
     void List::uncreate() {
          ^
    List.cpp: In function ‘void uncreate()’:
    List.cpp:119:5: error: ‘Node’ was not declared in this scope
         Node* temp = head;
         ^
    List.cpp:119:11: error: ‘temp’ was not declared in this scope
         Node* temp = head;
           ^
    List.cpp:119:18: error: ‘head’ was not declared in this scope
         Node* temp = head;
                  ^
    List.cpp:124:12: error: ‘tail’ was not declared in this scope
         head = tail = NULL;

我知道我的实现不会工作，但我什至无法检查哪里出了问题，因为我无法运行它。谁能帮我解决这个问题？

Answer 1

void List::create(const List &rhs) {
    ...
}

你必须添加模板来定义列表

template<typename T>
void List<T>::create(const List<T> &rhs) {
    ...
}

在这里声明

T *push_back(T &data);

但是后来定义为

List::value_type *List::push_back(List::value_type &data) 
{
    ...
}

修复它的简单方法是将声明和定义放在一起。因此，将 T *push_back(T &data); 更改为:

T *push_back(T &data)
{
    Node *n = new Node(data, tail, 0);
    tail->next = n;
    tail = tail->next;
    if (head == 0) //if it was the first element added
        head = tail;
    return tail;
}

---

---

编辑:

即使这个编译它有许多其他错误和泄漏。下面是 List

的简化版本

定义复制构造函数和赋值运算符也需要更多的工作。他们必须使用 List::push_back 复制另一个列表。目前我们使它们不可访问(通过将它们声明为私有(private))，这样它们就不会被意外使用。

template<typename T>
class List
{
private:
    List &operator=(const List &rhs);
    List(const List &rhs);

public:
    class Node
    {
    public:
        T data;
        Node *prev, *next;
        Node(T dataT)
        {
            data = dataT;
            next = prev = NULL;
        };
    };
protected:
    Node *head, *tail;
public:
    Node *get_head() { return head; };
    Node *get_tail() { return tail; };

    List()
    {
        head = tail = NULL;
    };

    ~List()
    {
        while (head)
            remove(head);
    };

    //Node *push_back(T dataT) //use this for older compilers
    Node *push_back(const T &&dataT) //for C++ 14
    {
        Node *node = new Node(dataT);
        if (head == NULL)
        {
            //adding first item to list
            head = tail = node;
        }
        else
        {
            //adding item to end of the list
            node->prev = tail;
            tail->next = node;
            tail = node;
        }
        return node;
    }

    void remove(Node *node)
    {
        if (!node) return;
        if (node == tail && node == head)
        {
            //deleting the only node, nothing will be left
            head = tail = NULL;
        }
        else if (node == tail)
        {
            tail = node->prev;
            tail->next = NULL;
        }
        else if (node == head)
        {
            head = node->next;
            head->prev = NULL;
        }
        else
        {
            //deleting a node in the mid
            node->prev->next = node->next;
            node->next->prev = node->prev;
        }
        delete node;
    }

    size_t size()
    {
        size_t i = 0;
        Node *node = head;
        while (node)
        {
            node = node->next;
            i++;
        }
        return i;
    }

    T &operator[](size_t i);
};

用法:

int main() 
{
    List<int> list;
    list.push_back(1);
    list.push_back(2);
    list.push_back(3);
    for (size_t i = 0; i < list.size(); i++)
        std::cout << list[i] << "\n";
}