C++: чистый виртуальный деструктор в абстрактном классе с членами

В приведенном вами примере вы на самом деле не все правильно уничтожаете. В соответствии

delete[] animalArray;

вы удаляете массив Animal*s. Обратите внимание, что это не уничтожает автоматически объекты, на которые указывает указатель! Вам нужно будет сделать:

for(int i = 0; i < 3; ++i)
    delete animalArray[i];
delete[] animalArray;

Это уничтожает каждый элемент, затем уничтожает контейнер.

Теперь ваш фактический вопрос заключается в том, будут ли закрытые переменные-члены полностью уничтожены. Ответ положительный: после запуска вашего деструктора компилятор также вызовет деструкторы любых статически размещенных переменных. Это их обязанность убирать за собой. Когда вы выполняете полиморфизм, как в вашем примере, (пустой) деструктор Animal::~Animal действительно будет вызываться.

Обратите внимание, что это содержит то же предупреждение, что и приведенный выше код: если вместо этого у вас есть

string* _name;

который вы динамически выделяете в конструкторе (с new), то string* будет уничтожен, но указанный string не будет. Так что в этом случае вам придется вручную вызывать delete для правильной очистки.

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

Деструктор Animal вызовет деструктор для каждого из своих членов в обратном порядке инициализации (т. е. сначала уничтожит _name, а потом _age) и тем самым удостоверится, что все правильно освобождено.

Согласно Хербу Саттеру, вы не можете создать экземпляр класса с помощью чисто виртуального деструктора, если он также не имеет тело. Причина в том, что любой производный класс должен будет вызвать этот деструктор после того, как его собственный деструктор завершится.

Мы можем проверить это хотя бы с одним компилятором: http://ideone.com/KcwL8W.

#include <string>

class Animal
{
    public:
    virtual ~Animal() = 0;

    std::string _name;
};

class Dog : public Animal
{
};

int main() {
    Animal* pet = new Dog;
    delete pet;
    return 0;
}

/home/abDVbj/cc8ghrZk.o: In function `Dog::~Dog()':
prog.cpp:(.text._ZN3DogD2Ev[_ZN3DogD5Ev]+0xb): undefined reference to `Animal::~Animal()'
/home/abDVbj/cc8ghrZk.o: In function `Dog::~Dog()':
prog.cpp:(.text._ZN3DogD0Ev[_ZN3DogD0Ev]+0x12): undefined reference to `Animal::~Animal()'

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

Я пытаюсь найти образец, чтобы доказать

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

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

он выводит:

constructor is called
constructor is called
constructor is called
operator constructor is called
destructor is called
operator constructor is called
destructor is called
virtual ~Dog()
virtual ~Animal()
destructor is called

это показывает, что когда вызывается виртуальный ~Animal(), вызывается деструктор строкового объекта в классе Animal.

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

#include <iostream>
#include <string.h>

using namespace std;


class String{
public:
    String(const char *str = NULL);
    String(const String &str);
    ~String();
    String operator+(const String & str);
    String & operator=(const String &str);
    bool operator==(const String &str);
    int Length();
    friend ostream & operator<<(ostream &o,const String &str);
    String SubStr(int start, int end);
private:
    char * charArray;
};

String::String(const char *str)
{
    if(str == NULL){
        charArray=new char[1];
        charArray[0]='\0';
    }else{
        charArray=new char[strlen(str)+1];
        strcpy(charArray,str);
    }
    std::cout<< "constructor is called" << std::endl;
}
String::String(const String &str)
{
    std::cout<< "constructor is called" << std::endl;
    charArray = new char[strlen(str.charArray)+1];
    strcpy(charArray,str.charArray);
}
String::~String()
{
    std::cout<< "destructor is called" << std::endl;
    delete [] charArray;
}
String String::operator+(const String &str)
{
    String res;
    delete [] res.charArray;
    res.charArray = new char[strlen(charArray)+strlen(str.charArray)+1];
    strcpy(res.charArray,charArray);
    strcpy(res.charArray+strlen(charArray),str.charArray);
    return res;
}
String & String::operator=(const String &str)
{
    if(charArray == str.charArray)
        return *this;
    delete [] charArray;
    charArray = new char[strlen(str.charArray)+1];
    strcpy(charArray,str.charArray);
    std::cout<< "operator constructor is called" << std::endl;
    return *this;
}
bool String::operator==(const String &str)
{
    return strcmp(charArray,str.charArray) == 0;
}
int String::Length()
{
    return strlen(charArray);
}
ostream & operator<<(ostream &o, const String &str)
{
    o<<str.charArray;
    return o;
}

String String::SubStr(int start, int end)
{
    String res;
    delete [] res.charArray;
    res.charArray = new char[end-start+1];
    for(int i=0; i+start<end; i++){
        res.charArray[i]=charArray[start+i];
    }
    res.charArray[end-start] = '\0';
    return res;
}


class Animal {
public:
    Animal();
    virtual ~Animal()=0;
    Animal(String name, int age);

public:
    int _age;
    String _name;
};
Animal::~Animal(){
    std::cout << "Animal::~Animal()" << std::endl;
}
Animal::Animal(String name, int age)
{
    this->_name = name;
    this->_age = age;
}

class Dog :public Animal
{
public:
    virtual ~Dog() {
         std::cout << "virtual ~Dog()" << std::endl;
    };
    Dog(String name, int age):Animal(name,age)
    {
        this->_name = name;
        this->_age = age;
    }
};

int main(){
   Animal* p = new Dog( String("dog"),1);
   delete p;
   return 0;
}