Что деструктор делает молча?

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.

Answer 3

Этот код выглядит так, как будто деструктор действительно выполняет свою работу: он удаляет указатель подписчика, который вызывает ~ A (), который, в свою очередь, удаляет его подписчик и т. Д.выделенные узлы не будут удалены.