链表时= =运算符重载的意义

Question

我试图在C ++中的链表中重载=运算符，并编写了以下代码。

template<class T>
class List {

    public:
        List();
        List (T t_data);
 List& operator=(const List<T> &L);
 private:
        template<class L>
            class Node {

                public:
                    L data;
                    Node *next;
                    Node *prev;
                    Node(T t_data) {
                        data = t_data;
                        next = prev = NULL;
                    }
            };

        Node<T> *head;


};

template<class T>
List&  List<T>::operator=(const List<T> &L) {
    Node<T> *t_head = head;
    Node<T> *t_tail = head->prev;
    Node<T> *temp;
    while(t_head ! = t_tail) {
        temp = t_head;
        t_head = t_next;
        delete temp;

    }
    head = L.head;
    t_head = t_tail = temp = NULL;

    return *this;
}

我编写此代码只是为了练习模板，指针和运算符重载，但我想知道在这种情况下=运算符的重要性。 就好像我用它一样

List L1(2);
List L2(3);
L1 = L2;

现在，L1中反映的任何更改都将反映在L2中，因此我们可以做的不是

List L1(2);
List *L2 = &L1;

这也将解决上述目的。 那么，为什么许多文章和书籍中的链表的=运算符会重载？

编辑 ：@TC关于您的注释，如果我不将Node声明为模板，则代码将如下所示

class List {
public:
    List();
    List (T t_data);
    List& operator=(const List<T> &L);
private:
    class Node {
    public:
        T data;
        Node *next;
        Node *prev;
        Node(T t_data) {
            data = t_data;
            next = prev = NULL;
        }
    };
    Node *head;
};

现在，如果我在如下所示的成员函数中声明Node的对象

void List::func() {
    Node temp;
    …..
}

然后，如何确定该“临时”对象的数据成员“数据”的类型是什么。 请告诉我。

Answer 1

在C ++中，通常的做法是具有值语义，即在L1 = L2; ，则对L1更改将在L2 不可见，反之亦然。

因此，您对operator =的实现是错误的。 它应该做的是：

1. 复制另一个链表中存储的节点。
2. 销毁存储在当前链接列表中的所有节点
3. 将步骤1中制作的副本存储到当前链接列表中

一个常见的成语是复制和交换成语：您创建另一个链表的临时副本（第1点），将当前链表的内容与该临时副本交换（第3点），当赋值函数返回时，临时副本和分配给它的链接列表的先前内容一起被破坏（第2点）。

你能做些不同吗？ 可以，但是（1）非常简单，而（2）所需的工作远远超出您现在要正确完成的工作。 例如，当分配后L1和L2的析构函数运行时，当前的operator =实现将导致双重删除。 您需要某种析构函数中的引用计数和其他逻辑，以确保您不删除仍在使用的Node ，而且不会泄漏内存。

旁注： Node不应该是模板，因为它绝不能存储T以外的东西。