链表的情况下=运算符重载的意义

Question

我试图在C++的链表中使用overload = operator并编写下面的代码.

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)需要远远超过你现在正确做的.例如,您目前执行operator =将导致双缺失时L1和L2的析构函数赋值后运行.在析构函数中需要某种引用计数和附加逻辑,以确保不删除Node仍在使用的内容,但也不会泄漏内存.

旁注:Node不应该是模板,因为它永远不应该存储除了a之外的东西T.