如何防止广义链表中的内存泄漏?

Question

我已经实现了自己的链表数据结构。数据存储在结构Node内。代码如下

// NODE
template <typename T>
struct Node
{
T data;
Node<T> *next;
Node(T);
};
template <typename T>
Node<T>::Node(T d) : data(d), next(NULL) {}

// LIST
#include "node.cpp"
template <typename T>
class List
{
Node<T> *head;
int size;
public:
List();                       // Default constructor
List(const List &);           // Copy constructor
void push_back(const T &);    // Insert element to the end of the list
int get_size() const;         // Get the current size of the list
T &operator[](int) const;     // Overload [] operator
void operator=(const List &); // Overload = operator
~List();                      // Destructor
};
template <typename T>
List<T>::List() : head(NULL), size(0) {}
template <typename T>
List<T>::List(const List &list) : head(NULL), size(0)
{
for (int i = 0; i < list.size; i++)
push_back(list[i]);
}
template <typename T>
void List<T>::push_back(const T &data)
{
// Create new Node with data
Node<T> *nn = new Node<T>(data);
// Find insert position
if (head == NULL)
{
head = nn;
size++;
return;
}
Node<T> *traverse = head;
while (traverse->next)
traverse = traverse->next;
// Traverse points to end of the list
traverse->next = nn;
size++;
}
template <typename T>
int List<T>::get_size() const
{
return size;
}
template <typename T>
T &List<T>::operator[](int index) const
{
int count = 0;
Node<T> *traverse = head;
while (traverse && count < index)
{
traverse = traverse->next;
count++;
}
return traverse->data;
}
template <typename T>
void List<T>::operator=(const List<T> &list)
{
Node<T> *traverse = head;
while (head)
{
traverse = head;
head = head->next;
delete traverse;
}
size = 0;
for (int i = 0; i < list.getSize(); i++)
push_back(list[i]);
}
template <typename T>
List<T>::~List()
{
Node<T> *traverse = head;
while (head)
{
traverse = head;
head = head->next;
delete traverse;
}
}

内存泄漏问题。请考虑以下main文件

#include "list.cpp"
using namespace std;
List<int *> l;
void func()
{
int *i = new int[2];
i[0] = 1;
i[1] = 2;
l.push_back(i);
}
int main()
{
func();
return 0;
}

根据瓦尔格林德的说法，该程序有内存泄漏。这是因为该Node没有析构函数，因此无法删除其中的data。但是，我无法向Node添加析构函数，因为假设我正在使用List<int>因此删除未动态分配的内容是错误的。简而言之，每当我为List使用动态分配的数据类型时，我都会得到内存泄漏。我怎样才能克服这种情况？谢谢。

Answer 1

示例中的泄漏与列表无关。您泄漏相同：

void func()
{
int *i = new int[2];
i[0] = 1;
i[1] = 2;
}

您必须delete您通过new创建的内容，并delete[]您通过new[]创建的内容。要修复泄漏：

void func()
{
int *i = new int[2];
i[0] = 1;
i[1] = 2;
l.push_back(i);
delete [] i;
}

但是，请注意，在delete[]之后，列表中有一个悬空的指针。

当您将原始指针推送到对象时，删除对象并不是List。该列表无法知道这些是否拥有指针。例如：

void func()
{
int i = 0;
l.push_back(&i);
}

无需在此处删除任何内容。(不过，这里也一样：一旦函数返回，列表中就会有一个悬空的指针(

这两个 abvove 都不是真正的"好"。不要使用原始拥有指针！请改用智能指针。如果你想要一个整数列表，那么使用一个List<int>(或者更确切地说是一个std::list<int>(。

Answer 2

使用std::unique_ptr作为节点的数据类型，例如：

List<std::unique_ptr<int[]>> l;

当每个节点被销毁时，其析构函数将销毁其unique_ptr数据，进而在其持有的int*指针上调用delete[]。