Question

我开始学习C ++，并且作为练习决定实现一个简单的LinkedList类（下面是部分代码）。我有一个关于应该如何实现复制构造函数的问题以及应该访问原始LinkedList上的数据的最佳方式。

    template <typename T>
    class LinkedList {

        struct Node {
            T data;
            Node *next;

            Node(T t, Node *n) : data(t), next(n) {};
        };

    public:
        LinkedList();
        LinkedList(const LinkedList&);
        ~LinkedList();

        //member functions
        int size() const;              //done
        bool empty() const;            //done
        void append(const T&);         //done
        void prepend(const T&);        //done
        void insert(const T&, int i); 
        bool contains(const T&) const; //done
        bool removeOne(const T&);      //done
        int  removeAll(const T&);      //done
        void clear();                  //done
        T& last();                     //done
        const T& last() const;         //done
        T& first();                    //done
        const T& first() const;        //done
        void removeFirst();            //done
        T takeFirst();                 //done
        void removeLast();
        T takeLast();


        //delete when finished
        void print();                  
        //end delete

        //operators
        bool operator ==(const LinkedList<T> &other) const;    //done
        bool operator !=(const LinkedList<T> &other) const;    //done
        LinkedList<T>& operator =(const LinkedList<T> &other); //done


    private:
        Node* m_head;
        Node* m_tail;
        int   m_size;

    };

    template<typename T>
    LinkedList<T>::LinkedList() : m_head(0), m_tail(0), m_size(0) {

    }
...

我的复制构造函数是否应该直接访问原始LinkedList的每个节点上的数据？

template<typename T>
LinkedList<T>::LinkedList(const LinkedList& l) {

    m_head = 0;
    m_tail = 0;
    m_size = 0;

    Node *n = l.m_head;

    // construct list from given list
    while(n) {
        append(n->data);
        n = n->next;
    }
}

或者我应该通过相应的访问者访问数据？（我知道我没有定义访问者）。

另外，我打算创建一个自定义迭代器，以便可以迭代LinkedList。我应该在复制构造函数中使用来访问每个节点上的数据吗？

另一个问题（完全偏离主题，我知道），何时和/或为什么我们应该声明指向LinkedList

的指针

LinkedList<int> *l = new LinkedList<int>();

而不是

LinkedList<int> l;

Answer 1

我认为追加会正确处理最初的头/尾细节，是吗？如果是这样，你现在拥有的是非常简单的：浏览其他列表，并获取其项目并将副本添加到我的列表中。完美。

好吧，差不多。使用初始化列表初始化成员变量：

template<typename T>
LinkedList<T>::LinkedList(const LinkedList& l) :
m_head(0), m_tail(0), m_size(0)
{
 // ...
}

另外，也许是风格问题，这不是一个循环：

// construct list from given list
for (Node *n = l.m_head; n != 0; n = n->next)
    append(m->data);

事实上，我建议这样做。当你有迭代器时，你会做类似的事情：

for (const_iterator iter = l.begin(); iter != l.end(); ++iter)
    append(*iter);

它更符合for循环的风格。（初始化一些东西，检查一下，做点什么）。虽然对于迭代器来说，它可能会有所不同。（稍后）

或者我应该通过相应的访问者访问数据？（我知道我没有定义访问者）。

另外，我打算创建一个自定义迭代器，以便可以迭代LinkedList。我应该在复制构造函数中使用来访问每个节点上的数据吗？

那些迭代器是你的访问者。你不想暴露你的内部头尾指针，这是一个灾难的秘诀。该类的目的是不公开细节。也就是说，迭代器是围绕这些细节的抽象包装器。

一旦有了迭代器，就可以使用它们迭代列表而不是指针算法。这最近与asked question有关。通常，您应该使用抽象来处理数据。一旦你拥有了迭代器，那就是了在适当的位置，您应该使用它们来迭代数据。

大多数提供迭代器的类也提供了一种在给定开始和结束迭代器的情况下插入数据的方法。这通常称为insert，如下所示：insert(iterBegin, iterEnd)。这循环遍历迭代器，将其数据附加到列表中。

如果你有这样的功能，你的拷贝构造函数就是：

insert(l.begin(), l.end()); // insert the other list's entire range

实现insert的地方就像我们上面的for循环一样。

另一个问题（完全偏离主题，我知道），何时和/或为什么要声明指向LinkedList的指针

LinkedList * l = new LinkedList（）;而不是LinkedList l;

第一个是动态分配，第二个是自动（堆栈）分配。你应该更喜欢堆栈分配。它几乎总是更快，更安全（因为你不需要删除任何东西）。事实上，一个名为RAII的概念依赖于自动存储，因此保证了析构函数的运行。

仅在必要时使用动态分配。

Answer 2

我认为实现你自己的链表仍然是一个非常有价值的练习，因为它可以帮助你学习指针，数据结构等的细节。确保不要在实际代码中使用你的链表类，因为它有许多已经编写和测试的现有库。最好的代码是您不必编写的代码。请参阅std::list。

我认为您实现复制构造函数的方式没有问题。您可能最好将代码移动到专用的复制函数，然后从构造函数中调用它，以便您需要维护的代码更少。但是一般来说，在类中使用类的实现细节不仅是可以接受的，而且在许多情况下是首选，因为它会尽可能快。

至于使用new创建列表并在堆栈上创建它，这个决定不仅适用于您的类，而且适用于一般的数据结构。过度简化的经验法则：如果可以的话，在堆栈上进行分配，如果需要，可以在堆上进行分配。例如，如果您需要列表以比创建它的函数更长，则需要。

再次回到不用手动编写自己的代码，如果你决定使用new在堆上分配，你应该使用智能指针而不是自己管理内存。现在就养成这种习惯。不要等到你正在处理“真正的”代码。在您搜索编写更好的代码时，您遇到的许多人都会对您无益，并坚持“只使用new”。

LinkedList复制构造函数实现细节

2 个答案: