链表中=操作符重载的意义

我试图在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;

这也将解决上述目的。那么，为什么在许多文章和书籍中，链表的=操作符被重载了呢?

编辑: @T.C。参考您的说明，如果我不将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;
    …..
}

那么如何解决这个"temp"对象的数据成员"data"的类型是什么?