我对大多数OOP理论都有很好的理解,但最让我困惑的是虚拟析构函数。

我以为析构函数总是被调用,不管是什么,也不管是链中的每个对象。

你打算什么时候让它们虚拟化?为什么?


当前回答

当您需要从基类调用派生类析构函数时。您需要在基类中声明虚拟基类析构函数。

其他回答

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

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

#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

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

关于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;
}

任何公开继承的类,无论是否多态,都应该有一个虚拟析构函数。换句话说,如果它可以被基类指针指向,那么它的基类应该有一个虚拟析构函数。

如果是虚拟的,则调用派生类析构函数,然后调用基类析构函数。如果不是虚拟的,则只调用基类析构函数。

我认为这里的大多数答案都没有抓住重点,除了公认的答案,这是一件好事。然而,让我再补充一个对这个问题有不同看法的问题:如果你想多态地删除这个类的实例,你需要一个虚拟析构函数。

这种方式回避了这个问题,所以让我详细说明一下:正如许多人所指出的,如果调用delete base_ptr并且析构函数不是虚拟的,就会出现不希望的行为。然而,有几个假设需要明确:

如果您的类不是基类,那么希望您不会编写这样的代码。在本例中,我不是指手动内存管理,它本身就很糟糕,而是从这个类中公开派生出来的。不应继承未设计为基类的类,例如std::string。C++可以让你射自己的脚。这是你的错,而不是基类没有虚拟析构函数。如果析构函数不可访问(受保护的或私有的),则此代码不会编译,因此不会出现不希望的行为。有一个受保护的析构函数是有用的,特别是对于mixin,但对于接口(在较小程度上)也是有用的。除非您实际使用了虚拟函数,否则您不希望产生虚拟函数的开销。相反,使析构函数受到保护可以防止不期望的行为,但不会限制您的行为。如果您实际上编写了一个应该派生自的类,那么通常都会有虚拟函数。作为它们的用户,通常只能通过指向基类的指针来使用它们。当这种使用包括处理它们时,它也需要是多态的。当您应该将析构函数设为虚拟时,就会出现这种情况。

对于这个主题的一个类似的不同观点,也可以阅读“什么时候不应该使用虚拟析构函数?”?