Question

我想知道在单链表上调用delete时是否确保我没有泄漏内存（手动执行，顺便说一下）。

我创建了这些超级基本list，node和person类，以使自己更清晰一些。

你走了：

class person {
public:
    person();
    //something to do like sets gets etc...
    virtual ~person();
private:
    int id;
    person* pplArr[5]; //Dynamically allocated person objs.
};
person::person(){
    pplArr[5] = NULL;
}
person::~person(){
    for(int i = 0; i < 5; i++)
        delete pplArr[i];
}

#include "person.h"
class node {
public:
    node(person*, node*);
    person* getData();
    node*   getNext();
    void    setNext(node*);

    virtual ~node();
private:

    person* data;
    node*   next;
};

node::node(person* p, node* n){
    data = p;
    next = n;
}
person* node::getData(){
    return data;
}

node* node::getNext(){
    return next;
}

void node::setNext(node* nxt){
    next = nxt;
}

node::~node(){
    //nothing to delete "manually".
}

#include "node.h"

class list {
public:
    list();

    node* getFirst();
    void  insert(person*);

    virtual ~list();
private:

    node* first;
};

node* list::getFirst(){
    return first;
}
void list::insert(person* p){
    if(first){
        first->setNext(new node(p, NULL));
    }
    else {
        first = new node(p, NULL);
    }
}
list::~list(){
    node* aux;
    while (first){
        aux = first->getNext();
        delete first;
        first = aux;
    }
}

好的，你可以看到我们有这三个类：

person包含一组5人对象，动态分配：

node包含指向next节点的指针，data包含实际的person对象。和，

list包含nodes并管理它们。

为了成功释放所有内存，我需要调用delete listName，此行将进入每个节点，并为每个delete调用node，这将调用delete {1}} person。

人的delete将进入每个数组插槽并调用这些人的'删除'以释放该内存。

之后，它将执行正在等待的其他删除。从下到上。

这是对的吗？我的析构函数是否正确？

如果有一个包含具有动态分配内存的对象的节点的单链表，我想知道如何完全释放我分配的内存。

我很困惑，如果这是无意义或完全糟糕的实施，我道歉。

PS：我不知道这个列表是否有效，我只想制作一个基本的链表，看看你们是否可以帮助我理解，所以希望我能在实际的，更复杂的列表中掌握这个概念。我知道图书馆上有链接列表和其他数据结构，但大学教师要求我们先这样做。

C ++这个析构函数会泄漏资源吗？

0 个答案: