析构函数默默地做什么？

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 上没有析构函数，follower 指向的对象永远不会被删除。

Answer 2

首先，我们希望这是为了练习，否则 std::forward_list 似乎更合适（并且 vector 可能会更好）。

其次，析构函数的作用简单来说就是执行你放入其中的代码，这里的作用是释放follower获取的资源。

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

• 调用follower的析构函数
• ，然后释放follower所在的内存> 被存储

如果没有调用delete，就会出现内存泄漏。

注意：

• 您的类缺少复制构造函数和赋值运算符
• 在 main 中，没有必要new A 的实例。

Answer 3

这段代码看起来析构函数确实做了真正的工作：它删除了跟随者指针，该指针调用 ~A()，而 ~A() 又将删除其跟随者，依此类推。

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