Question

考虑到以下代码看起来析构函数没有做任何实际工作，valgrind清楚地告诉我它没有使用析构函数就有内存泄漏。任何机构都可以解释一下析构函数在这种情况下做了什么？

#include <iostream>                                                                    
using namespace std;                                                                   

class A                                                                                
{                                                                                      
private:                                                                               
    int value;                                                                         
    A* follower;                                                                       
public:                                                                                
    A(int);                                                                            
    ~A();                                                                        
    void insert(int);                                                                  
};                                                                                     

A::A(int n)                                                                            
{                                                                                      
    value = n;                                                                         
    follower = NULL;                                                                   
}                                                                                      

A::~A()                                                                             
{                                                                                   
     if (follower != NULL)                                                           
         delete follower;                                                               
     cout << "do nothing!" << endl;                                             
}                                                                                   

void A::insert(int n)                                                                  
{                                                                                      
    if (this->follower == NULL) {                                                      
        A* f = new A(n);                                                               
        this->follower = f;                                                            
    }                                                                                  
    else                                                                               
        this->follower->insert(n);                                                     
}                                                                                      

int main(int argc, char* argv[])                                                       
{                                                                                      
    A* objectA = new A(1);                                                             

    int i;                                                                             
    for (i = 0; i < 10; i++)                                                           
        objectA->insert(i);                                                            

    delete objectA;                                                                    
}

Answer 1

insert（）方法在堆上创建新的A，并使用跟随指针将其链接到下一个元素。因此，如果没有A上的析构函数，跟随者指向的对象永远不会被删除。

Answer 2

首先，让我们希望这是锻炼，否则std::forward_list<int>似乎更充足（而vector<int>可能会更好）。

其次，析构函数角色只是执行您放入其中的代码，这里是关于释放follower获取的资源。

对delete follower的调用会做两件事：

它调用follower
然后释放存储follower的内存

如果没有调用delete，就会发生内存泄漏。

注意：

您的课程缺少复制构造函数和赋值运算符
在main中new A的{{1}}实例没有必要。

Answer 3

这段代码看起来像析构函数确实有效：它删除了跟随者指针，它调用~A（），然后删除它的跟随者等等。

如果省略析构函数，则不会删除所有已分配的节点。

析构函数默默地做了什么？

3 个答案: