C++为什么这会导致内存泄漏

Question

如果我们有以下简单的双链表：

class Node{
    //...
    Node* next;
    Node* previous;
    int data;
};
class A{
    //...
    A(const A&);
    ~A(); //goes through list and deletes each node
    A& operator=(const A&);
    Node* begin;
    Node* end;
    int id;
};
A::A(const A& copyThis)
{
    //creates a new list that represnets the same data as copyThis's list
    //but is not the same list
    //Example for clarification:
    //if copyThis represented a list of nodes each containing the values 1-10 respectively
    //this constructor would make a new list of nodes each containing the values 1-10
    //and make the invoking object's members point to the beginning and end of it
    //assume this does not create any memory leaks
}
A& A::operator=(const A& a) //this causes a memory leak
{
    A* aCopy = new A(a); //now 'a' and 'this' should represent the same
    //values but point to different lists
    this->begin = aCopy->begin;
    this->end = aCopy->end;
    this->id = aCopy->id;
    //code here that deletes list that invoking object used to point to
    //assume it does correctly and without memory leak
    return *this;
}

假设我们有这个功能：

void foo()
{
    A a1(); 
    //put some data into a1
    A a2();
    {a2=a1;}
}

我的问题是，为什么这会导致内存泄漏，因为a2应该代表与aCopy在operator=内部相同的Node列表，并且当a2超出范围时，它会正确释放为每个节点分配的内存。

编辑：好吧，所以我在发布这个问题几分钟后才意识到，也许用new创建aCopy会为它所代表的Node分配更多的内存，而且内存永远不会被释放。这是正确的吗？

编辑：我并不是在要求一个更好或正确的方式来编写这段代码，我只是要求解释为什么这会导致内存泄漏

Answer 1

首先，operator=需要返回T&。你正在泄露一份副本指向的内存。你根本不需要。你应该做这样的事情：

A& A::operator=(const A& a)
{
    this->begin = a.begin;
    //etc.
    return *this;
}