Effective C++ 阅读心得-条款07：为多态基类声明virtual析构函数

重要的话说在前面

• polymorphic(带多态性质的）base classes应该声明一个virtual析构函数。如果class带有任何virtual函数，它就应该拥有一个virtual析构函数。
• classes的设计目的如果不是作为base classes使用，或不是为了具备多态性(polymorphically)，就不该声明virtual析构函数。

1. 如果一个基类被设计为可多态的（polymorphic），那么它应该拥有一个虚析构函数

1.1 多态是啥玩意

• “可多态”（polymorphic）指的是一个类具有多种形态。废话。
• 在C++中，通常使用继承和虚函数实现多态。
• 多态性的主要特征是同一种操作作用于不同的对象，产生不同的结果。
• 具体形式：在多态中，父类的指针可以指向子类对象，通过指针调用的方法，根据实际指向的对象来确定方法的实现，这种机制被称为运行时多态或动态多态。
• 举个栗子：

#include <iostream>

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

    virtual ~Animal() {
        std::cout << "Animal is delete" << std::endl;
    };
};

class Dog : public Animal {
public:
    virtual void makeSound() const {
        std::cout << "Woof! Woof!" << std::endl;
    }

    virtual ~Dog() {	//不加virtual也可以
        std::cout << "Dog is delete" << std::endl;
    };
};

class Cat : public Animal {
public:
    virtual void makeSound() const {
        std::cout << "Meow! Meow!" << std::endl;
    }

    virtual ~Cat() {	//不加virtual也可以
        std::cout << "Cat is delete" << std::endl;
    };
};

void Sound(const Animal* animal) {
    animal->makeSound();//动物叫
}

int main() {
    Animal* animal = new Animal();
    Sound(animal);

    Animal* dog = new Dog();
    Sound(dog); // Output: Woof! Woof!

    Animal* cat = new Cat();
    Sound(cat); // Output: Meow! Meow!

    delete animal;
    delete dog;
    delete cat;

    return 0;
}

以上的代码输出是什么呢？

This is an animal.
Woof! Woof!
Meow! Meow!
Animal is delete
Dog is delete
Animal is delete
Cat is delete
Animal is delete

可以看出所有的对象都已经被析构，多态的性质也体现出来，只用了一个函数，就可以对多个类进行相同操作，且操作结果与实际类对象的实现有关。

1.2 为什么需要多态中的基类需要virtual析构函数

• 思考一下，如果上面的Animal类并没有提供virtual的析构函数，输出结果是什么呢？

This is an animal.
Woof! Woof!
Meow! Meow!
Animal is delete
Animal is delete
Animal is delete

可以看出，如果Animal类没有提供virtual析构函数，则在使用delete释放动态分配的Dog对象和Cat对象的内存时，只会调用 Animal的析构函数，而不会调用子类的析构函数。这将导致子类对象内存中未被释放的成员变量或资源，从而可能引起内存泄漏或资源泄漏等问题。

1.3 我想在多态中将基类的析构函数设置为virtual函数，但是我忘了怎么办？

• 道理我都懂，可是我忘了怎么办？
• 一旦出错，那不还是会出现资源泄漏，败坏数据结构，增加调试难度的问题么？
• override值得你的拥有！
  • override关键字在C++11标准中引入，用于显式声明派生类的虚函数覆盖基类的虚函数，以便编译器能够在编译时检查该函数是否成功覆盖了基类的虚函数。
  • 当派生类的虚函数不小心或者错误地没有覆盖基类的虚函数时，编译器会给出错误提示，避免了在程序运行时发生潜在的错误。
  • 比如你想在子类中继承foo()函数，但是你不小心写成fo()函数，如果你加上 override关键字，那么编译器将告诉你你并没有成功覆盖基类虚函数。
• 子类析构函数一样，虽然和父类的析构函数并不是同样的名称，但是子类的析构函数也可以使用override修饰，用来显式地覆盖基类虚函数。

2. 如果一个类并不是用作多态用途，那千万不要使用virtual对其析构函数进行修饰

2.1 如果一个没有virtual函数的类，使用virtual对其析构函数进行修饰会发生什么呢？

• 当一个类原本没有virtual修饰的函数，但非要在析构函数上进行修饰的话，这个类就会包含了至少一个virtual函数。废话。
• 但是编译器会为至少包含一个virtual函数的类生成一个虚函数表（Virtual Table，简称vtbl）。
• 虚函数表是一个指针数组，它存储了这个类中所有虚函数的地址。这个指针数组是在编译阶段生成的，存储在类对象的内存布局中，同时也是全局可见的。
• 当一个对象被创建时，它会拥有一个指向虚函数表的指针（称为虚函数指针,vptr）。这个指针会被初始化为指向这个类的虚函数表。当调用一个虚函数时，实际调用的是虚函数表中对应函数指针所指向的函数。
• 到此为止：可以看出一旦使用virtual，类对象的体积会增加，结构会变化，不再具有移植性（对象不会像其他语言，如C语言，相同声明有着相同的结构）。

2.2 继承时虚函数表和虚函数指针的变化

• 当一个类被继承时，子类会继承父类的虚函数表指针，并且可能添加新的虚函数或者重载父类的虚函数。
• 如果子类中没有新增虚函数或者重载父类的虚函数，那么子类会直接使用父类的虚函数表。否则，子类的虚函数表中会新增或者替换父类虚函数表中对应的函数指针。
• 虚函数优缺点
  • 每个类对象都拥有一个虚函数指针，所以虚函数的调用开销相对于普通函数来说要大一些。
  • 虚函数调用需要在运行时才能确定调用哪个函数，因此也可能会带来一些性能上的损失。
  • 虚函数使得多态成为可能，使得代码的可扩展性和灵活性更高，因此在需要使用多态时，虚函数是非常有用的特性。

2.3 不要企图继承一个不具有non-virtual函数的class，它会让你很难过的

• 如1.2中所讲，如果继承了一个不具有non-virtual函数的class，甚至不具有virtual的析构函数的class，你很有可能会遇到资源泄露的问题。
• 所以你千万不可以继承string，STL容器等等不具有non-virtual函数的class。

2.4 使用pure virtual析构函数来作为基类实现多态，是个不错的主意

• 使用了pure virtual函数的类就是抽象类了，抽象类不能被实体化，使用它有很多好处。
  • 它可以定义一些方法并强制要求其子类去实现这些方法，这有助于确保在子类中实现了基本的操作。
  • 抽象类中的纯虚函数相当于一个契约，子类必须实现这些函数，否则编译器会报错。
  • 抽象类也提供了一个通用的接口，它可以被用于对不同的子类进行抽象化操作。这可以帮助开发者更好地进行模块化开发，提高代码的可维护性和可重用性。
  • 抽象类还可以用于限制外部使用者的访问权限，只暴露一部分接口给外部使用者，防止外部使用者误操作或者滥用类的功能。
• 注意：
  • 在使用pure virtual析构函数时，需要实现其定义，否则连接器报错的。
  • 因为在多态中，使用抽象基类指向子类对象，在delete时，析构函数会由子类层层向上调用，调用到这个抽象类时，也会调用它的析构，但是如果你并没有定义，那么就会出问题滴。
  • 下面举个栗子：

#include <iostream>

class Animal {
public:
    virtual void makeSound() const = 0;

    virtual ~Animal() = 0;
};

Animal::~Animal() { std::cout << "Animal is delete" << std::endl; }

class Dog : public Animal {
public:
    virtual void makeSound() const override {
        std::cout << "Woof! Woof!" << std::endl;
    }

    ~Dog() override {
        std::cout << "Dog is delete" << std::endl;
    };
};

class Cat : public Animal {
public:
    virtual void makeSound() const {
        std::cout << "Meow! Meow!" << std::endl;
    }

    ~Cat() {
        std::cout << "Cat is delete" << std::endl;
    };
};

void Sound(const Animal* animal) {
    animal->makeSound();//动物叫
}

int main() {

    Animal* dog = new Dog();
    Sound(dog); // Output: Woof! Woof!

    Animal* cat = new Cat();
    Sound(cat); // Output: Meow! Meow!


    delete dog;
    delete cat;

    return 0;
}

看看输出：

Woof! Woof!
Meow! Meow!
Dog is delete
Animal is delete
Cat is delete
Animal is delete

打完收工！看到这了，点个赞再走呗~