关于virtual的一个基本定义是它确定类的成员函数是否可以在其派生类中被覆盖。

类的D-tor基本上在作用域的末尾被调用，但存在一个问题，例如，当我们在堆（动态分配）上定义一个实例时，我们应该手动删除它。

一旦指令被执行，就会调用基类析构函数，但不会调用派生的析构函数。

一个实际的例子是，在控制场中，你必须操纵效应器和致动器。

在范围结束时，如果没有调用其中一个动力元件（执行器）的析构函数，将产生致命的后果。

#include <iostream>

class Mother{

public:

    Mother(){

          std::cout<<"Mother Ctor"<<std::endl;
    }

    virtual~Mother(){

        std::cout<<"Mother D-tor"<<std::endl;
    }


};

class Child: public Mother{

    public:

    Child(){

        std::cout<<"Child C-tor"<<std::endl;
    }

    ~Child(){

         std::cout<<"Child D-tor"<<std::endl;
    }
};

int main()
{

    Mother *c = new Child();
    delete c;

    return 0;
}

当您可能通过指向基类的指针删除派生类的实例时，虚拟析构函数非常有用：

class Base 
{
    // some virtual methods
};

class Derived : public Base
{
    ~Derived()
    {
        // Do some important cleanup
    }
};

在这里，您会注意到我没有将Base的析构函数声明为虚拟。现在，让我们看一下以下片段：

Base *b = new Derived();
// use b
delete b; // Here's the problem!

由于Base的析构函数不是虚拟的，而b是指向派生对象的Base*，因此删除b具有未定义的行为：

[在delete b]中，如果要删除的对象与其动态类型不同，静态类型应为对象的动态类型的基类删除，静态类型应具有虚拟析构函数或行为未定义。

在大多数实现中，对析构函数的调用将像任何非虚拟代码一样被解析，这意味着将调用基类的析构函数，而不是派生类的析构器，从而导致资源泄漏。

总之，当基类的析构函数要以多态方式操作时，请始终将其设为虚拟。

如果要防止通过基类指针删除实例，可以使基类析构函数受保护且非虚拟；通过这样做，编译器不会允许您在基类指针上调用delete。

在本文中，您可以从HerbSutter了解更多关于虚拟性和虚拟基类析构函数的信息。

虚拟构造函数是不可能的，但虚拟析构函数是可能的。让我们做个实验。。。。。。。

#include <iostream>

using namespace std;

class Base
{
public:
    Base(){
        cout << "Base Constructor Called\n";
    }
    ~Base(){
        cout << "Base Destructor called\n";
    }
};

class Derived1: public Base
{
public:
    Derived1(){
        cout << "Derived constructor called\n";
    }
    ~Derived1(){
        cout << "Derived destructor called\n";
    }
};

int main()
{
    Base *b = new Derived1();
    delete b;
}

上述代码输出以下内容：

Base Constructor Called
Derived constructor called
Base Destructor called

派生对象的构造遵循构造规则，但当我们删除“b”指针（基指针）时，我们发现只有基析构函数被调用。但这绝不能发生。为了做适当的事情，我们必须使基析构函数虚拟化。现在让我们看看以下情况：

#include <iostream>

using namespace std;

class Base
{ 
public:
    Base(){
        cout << "Base Constructor Called\n";
    }
    virtual ~Base(){
        cout << "Base Destructor called\n";
    }
};

class Derived1: public Base
{
public:
    Derived1(){
        cout << "Derived constructor called\n";
    }
    ~Derived1(){
        cout << "Derived destructor called\n";
    }
};

int main()
{
    Base *b = new Derived1();
    delete b;
}

输出变化如下：

Base Constructor Called
Derived Constructor called
Derived destructor called
Base destructor called

因此，基指针的销毁（对派生对象进行分配！）遵循销毁规则，即首先是派生指针，然后是基指针。另一方面，没有什么像虚拟构造函数。

还要注意，在没有虚拟析构函数时删除基类指针将导致未定义的行为。我最近学到的东西：

C++中重写删除应该如何操作？

我已经使用C++多年了，但我还是设法自杀了。

我认为这个问题的核心是关于虚拟方法和多态性，而不是具体的析构函数。下面是一个更清晰的例子：

class A
{
public:
    A() {}
    virtual void foo()
    {
        cout << "This is A." << endl;
    }
};

class B : public A
{
public:
    B() {}
    void foo()
    {
        cout << "This is B." << endl;
    }
};

int main(int argc, char* argv[])
{
    A *a = new B();
    a->foo();
    if(a != NULL)
    delete a;
    return 0;
}

将打印出：

This is B.

如果没有虚拟，它将打印出：

This is A.

现在您应该了解何时使用虚拟析构函数。

我喜欢思考接口和接口的实现。在C++中，speak接口是纯虚拟类。析构函数是接口的一部分，需要实现。因此析构函数应该是纯虚拟的。构造函数呢？构造函数实际上不是接口的一部分，因为对象总是显式实例化的。