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= 内部相同的Nodes 列表，并且当a2 超出范围时，它会释放分配的内存正确地为每个节点。

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

编辑： 我不是要求更好或更正确的方法来编写此代码，我只是要求解释为什么这会导致内存泄漏。

Answer 1

一方面，operator= 需要返回 T&。您正在泄漏 aCopy 指向的内存。你根本不需要那个。你应该这样做：

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