Вопрос о деструкторах C++

Question

Что касается примера кода ниже, почему деструктор для базового класса называется дважды?

class Base { 
public: 
    Base() { 
     std::cout << "Base::Base()" << std::endl; 
    } 

    ~Base() { 
     std::cout << "Base::~Base()" << std::endl; 
    } 
}; 

class Derived : public Base { 
public: 
    Derived() { 
     std::cout << "Derived::Derived()" << std::endl; 
    } 

    ~Derived() { 
     std::cout << "Derived::~Derived()" << std::endl; 
    } 
}; 

int main() { 
    Base a = Derived(); 
    return EXIT_SUCCESS; 
} 

Вот пример вывода при выполнении программы:

Base::Base() 
Derived::Derived() 
Derived::~Derived() 
Base::~Base() 
Base::~Base() 

Answer 1

Что происходит, называется нарезкой. Вы инициализируете объект типа Base с объектом типа Derived. Так как любой объект типа Derived также имеет объект типа Base, содержащий (называемый «суб-объект базового класса»), в программе будут два объекта Base и один объект Derived. Объект Derived (и его под-объект базового класса типа Base) существует только для времени инициализации, тогда как оставшийся объект Base существует до конца main.

Поскольку есть два базовых объекта и один производный объект, вы также увидите, как запускается еще один деструктор базы.

Answer 2

Вам нужен virtual destructor.

Answer 3

Когда вы говорите Derived() в main(), он создает временный объект, который затем копируется в объект a. Следовательно, есть два объекта, из-за которых деструктор вызывается дважды. Кроме того, как указывали другие, деструктор базового класса должен быть виртуальным.

Answer 4

Используется копировальный конструктор. Если вы хотите посмотреть, что происходит, запишите также конструктор копирования:

Base(const Base &) { 
     std::cout << "Base::Base(const Base &)" << std::endl; 
    } 

и аналогичным образом для производного.

Обратите внимание, что это НИЧЕГО не связано с тем, что деструкторы не являются виртуальными.

Answer 5

Потому что вы создаете временное типа Derived перед копированием a с ним. Так что это в основном то, что происходит:

Derived d(); // Your temporary of type Derived is created 
Base a(d); // The temporary is used to call a's copy constructor 
d.Derived::~Derived(); // The temporary is destroyed, calling both ~Derived and ~Base 
a.Base::~Base(); // The nonvirtual destructor on a is called, so ~Base is called, but not ~Derived 

Так кроме ненужного копирования в начале (что компилятор может оптимизировать прочь), фактическую ошибки является то, что ~ Base не является виртуальной.

Редактировать Ой, полностью пропустил срез, который имеет место при указании на указанную лампочку. Вместо этого прочитайте его ответ:

Answer 6

У вас есть одна переменная стека, а одна временная - общая сумма двух объектов, построенных - так что логично, чтобы деструктор вызывался дважды.

Answer 7

Добавление в дальнейшем будет сделать программу более понятной:

Base(const Base& base){ 
     std::cout << "Base::Base(const Base& base)" << std::endl; 
} 

компилятор автоматически создает конструктор копирования для вас.Определяя его самостоятельно (и, добавив в печати), вы можете увидеть, что количество конструкторов и деструкторов матч

Base::Base() 
Derived::Derived() 
Base::Base(const Base& base) 
Derived::~Derived() 
Base::~Base() 
Base::~Base() 

Answer 8

1) Временный объект производного типа построен (Derived :: Derived() и база :: База() называются)

2) объект темп копируется в "а"

3) временный объект уничтожается (Derived :: ~ Derived() и Base :: ~ Base() называются)

4) возвращение EXIT_SUCCESS;

5) «a» разрушен, поэтому Base :: ~ Base() называется