【C/C++】析构函数需要定义为虚函数

析构函数需要定义为虚函数

下面给出两个例子来证明为什么析构函数需要定义为虚函数。

1. 内存泄漏问题

假设有一个基类 Animal 和一个派生类 Dog，其中 Animal 中定义了一个指针类型的成员变量 p，并在构造函数中为其分配了内存，而在析构函数中释放该内存。如果 Animal 的析构函数不是虚函数，那么在销毁一个 Dog 对象时，只会调用 Animal 的析构函数，而不会调用 Dog 的析构函数。这就会导致 Dog 中的成员变量 p 没有被正确地释放，从而导致内存泄漏。

class Animal {
public:
    Animal() {
        p = new int;
    }
    ~Animal() {	// 正确写法: virtual ~Animal() {}
        delete p;
    }
private:
    int* p;
};

class Dog : public Animal {
public:
    ~Dog() {
        cout << "Dog destructor" << endl;
    }
};

int main() {
    Animal* animal = new Dog();	// 这个为什么要使用Animal类型指针的指向Dog对象？
    delete animal; // 只会调用 Animal 的析构函数，导致内存泄漏
    return 0;
}

在上面的例子中，首先定义了一个基类 Animal 和一个派生类 Dog，其中 Animal 中定义了一个指针类型的成员变量 p，并在构造函数中为其分配了内存，而在析构函数中释放该内存。然后在 main() 函数中，创建了一个 Dog 对象，并将其赋值给 Animal 类型的指针 animal。最后通过 delete animal 销毁该对象，由于 Animal 的析构函数不是虚函数，只会调用 Animal 的析构函数，而不会调用 Dog 的析构函数，导致 Dog 中的成员变量 p 没有被正确地释放，从而导致内存泄漏。

2. 对象切片问题

假设有一个基类 Animal 和两个派生类 Dog 和 Cat，其中 Animal 中定义了一个虚函数 makeSound()，而 Dog 和 Cat 分别重写了该函数以实现不同的行为。如果 Animal 的析构函数不是虚函数，那么在销毁一个 Dog 或 Cat 对象时，只会调用 Animal 的析构函数，而不会调用 Dog 或 Cat 的析构函数。这就会导致对象切片问题，即派生类中的成员变量没有被正确地销毁，从而导致程序出现未定义的行为。

非虚函数析构函数的对象切割（Object Slicing）是指在 C++ 中，如果一个类的析构函数不是虚函数，那么当通过一个基类指针删除一个派生类对象时，只会调用基类的析构函数，而不会调用派生类的析构函数。这是因为在编译时，编译器只知道这个指针的类型是基类类型，而不知道它所指向的对象的真实类型是派生类类型，因此只会调用基类的析构函数。

如果一个类的析构函数不是虚函数，那么在通过基类指针删除派生类对象时，只会调用基类的析构函数，而不会调用派生类的析构函数。这种行为可能会导致派生类中的资源无法被正确地释放，从而出现内存泄漏等问题。

因此，如果在使用继承时，派生类中有资源需要在析构函数中释放，应该将基类的析构函数声明为虚函数，以确保在删除派生类对象时能够正确地调用派生类的析构函数。

所以，如果我们通过一个 Dog 指针删除一个 Dog 对象，而 Dog 的析构函数不是虚函数，那么只会调用 Dog 的析构函数，不会调用 Animal 的析构函数。如果你说会调用 Animal 的析构函数，那可能是因为在 Dog 的析构函数中调用了 Animal 的析构函数，或者是因为你使用了错误的指针类型来删除对象。

class Animal {
public:
    virtual void makeSound() {
        cout << "This is an animal." << endl;
    }
    ~Animal() {
        cout << "Animal destructor" << endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() {
        cout << "This is a dog." << endl;
    }
    ~Dog() {
        cout << "Dog destructor" << endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() {
        cout << "This is a cat." << endl;
    }
    ~Cat() {
        cout << "Cat destructor" << endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();
    delete animal1; // 只会调用 Animal 的析构函数，导致对象切片问题
    delete animal2; // 只会调用 Animal 的析构函数，导致对象切片问题
    return 0;
}

在上面的例子中，首先定义了一个基类 Animal 和两个派生类 Dog 和 Cat，其中 Animal 中定义了一个虚函数 makeSound()，而 Dog 和 Cat 分别重写了该函数以实现不同的行为。然后在 main() 函数中，创建了一个 Dog 对象和一个 Cat 对象，并将它们分别赋值给 Animal 类型的指针 animal1 和 animal2。最后通过 delete animal1 和 delete animal2 销毁这两个对象，由于 Animal 的析构函数不是虚函数，只会调用 Animal 的析构函数，而不会调用 Dog 或 Cat 的析构函数，导致派生类中的成员变量没有被正确地销毁，从而导致对象切片问题。

析构函数未定义为虚函数时，对象切割与内存泄漏有什么区别？

在C++中，如果一个类有虚函数，那么它的析构函数应该被定义为虚函数。如果一个类的析构函数未定义为虚函数，那么在使用基类指针或引用删除派生类对象时，可能会发生对象切割的问题。

对象切割是指当使用基类指针或引用删除派生类对象时，只会调用基类的析构函数，而不会调用派生类的析构函数。这会导致派生类对象中的资源没有被正确释放，从而导致内存泄漏。

为什么对象切割会导致程序行为不可测？

对象切割会导致行为不可测，因为它会导致派生类对象中的资源没有被正确释放，从而可能导致程序的行为不符合预期。具体来说，如果派生类对象中有一些资源（如堆内存、文件句柄等）没有被正确释放，那么这些资源可能会被其他部分的代码所使用，从而导致程序的行为不可预测。

例如，假设有一个基类Animal和一个派生类Dog，其中Dog类中有一个指向堆内存的指针。如果在使用基类指针删除Dog对象时，只调用了基类的析构函数而没有调用Dog类的析构函数，那么Dog对象中的指针所指向的堆内存就没有被正确释放。如果后续的代码中使用了这块未释放的堆内存，那么程序就会出现未定义的行为。

因此，为了避免对象切割导致的行为不可测，应该将基类的析构函数定义为虚函数，以确保正确地调用派生类的析构函数，从而正确地释放派生类对象中的资源。

与内存泄漏相比，对象切割的问题更加严重，因为它会导致程序的行为不可预测，可能会导致程序崩溃或产生其他严重的后果。因此，在使用基类指针或引用删除派生类对象时，应该将基类的析构函数定义为虚函数，以确保正确地调用派生类的析构函数，从而避免对象切割的问题。

解疑：为什么要使用 Animal 类型指针指向 Dog 对象，而不是使用 Dog 类型指针进行指向？

将 Dog 对象赋值给 Dog 类型的指针，与将 Dog 对象赋值给 Animal 类型的指针是有区别的。具体来说，将 Dog 对象赋值给 Dog 类型的指针，只能调用 Dog 类中定义的函数，而不能调用 Animal 类中定义的函数。而将 Dog 对象赋值给 Animal 类型的指针，则可以根据对象的实际类型来调用相应的函数，从而实现对 Dog 对象的多态访问。

下面是一个示例代码，其中 Animal 类中定义了一个虚函数 makeSound()，而 Dog 类重写了该函数：

class Animal {
public:
    virtual void makeSound() {
        cout << "This is an animal." << endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() {
        cout << "This is a dog." << endl;
    }
};

int main() {
    Dog* dog1 = new Dog();
    dog1->makeSound(); // 输出 "This is a dog."

    Animal* animal = dog1;
    animal->makeSound(); // 输出 "This is a dog."

    Dog* dog2 = (Dog*)animal;
    dog2->makeSound(); // 输出 "This is a dog."

    delete dog1;
    return 0;
}

在上面的代码中，首先定义了一个基类 Animal 和一个派生类 Dog，其中 Animal 中定义了一个虚函数 makeSound()，而 Dog 重写了该函数以实现不同的行为。然后在 main() 函数中，创建了一个 Dog 对象 dog1，并调用了 dog1->makeSound() 函数，输出 “This is a dog.”。接着将 dog1 赋值给 Animal 类型的指针 animal，并调用了 animal->makeSound() 函数，输出 “This is a dog.”。最后将 animal 强制转换为 Dog 类型的指针 dog2，并调用了 dog2->makeSound() 函数，输出 “This is a dog.”。

在上面的代码中，将 Dog 对象赋值给 Dog 类型的指针 dog1，只能调用 Dog 类中定义的函数，而不能调用 Animal 类中定义的函数。而将 Dog 对象赋值给 Animal 类型的指针 animal，可以根据对象的实际类型来调用相应的函数，从而实现对 Dog 对象的多态访问。