多重继承中的虚析构函数

最新推荐文章于 2024-02-23 18:20:39 发布

weixin_33875839

最新推荐文章于 2024-02-23 18:20:39 发布

阅读量292

点赞数 1

文章标签： c/c++

原文链接：https://my.oschina.net/qihh/blog/57685

版权

为什么80%的码农都做不了架构师？>>>

class A
{
public:
    A(){cout<<"A constructor"<<endl;}
    virtual ~A(){cout<<"A destructor"<<endl;}//输出改为virtual
};

class B
{
public:
    B(){cout<<"B constructor"<<endl;}
    virtual ~B(){cout<<"B destructor"<<endl;}
};

class C:public A,public B
{
public:
    C(){cout<<"C constructor"<<endl;}
    ~C(){cout<<"C destructor"<<endl;}
};

class D:public B,public A
{
public:
    D(){cout<<"D constructor"<<endl;}
    ~D(){cout<<"D destructor"<<endl;}
};

int main(int argc, char* argv[])
{
    A* pa = new C;
    delete pa;

    cout << "===========" << endl;

    B* pb = new D;
    delete pb;
    return 0;
}

/* 首先基类A,B均有虚析构函数，所以会沿着析构函数链进行析构，不会存在对象部分析构的情况。

另外，请注意多重继承中声明次序和构造/析构的次序

class C:public A,public B===>

A constructor 构造次序：先基类，后子类；基类的构造次序为先A，后B

B constructor

C constructor

C destructor 析构次序：先子类，后基类；基类的析构次序为先B，后A

B destructor

A destructor

===========

class D:public B,public A===>

B constructor 构造次序：先基类，后子类；基类的构造次序为先B，后A

A constructor

D constructor

D destructor 析构次序：先子类，后基类；基类的析构次序为先A，后B

A destructor

B destructor

几种可能：

A，B类中均没有虚析构函数

class A
{
public:
    A(){cout<<"A constructor"<<endl;}
    virtual ~A(){cout<<"A destructor"<<endl;}//输出改为virtual
};

class B
{
public:
    B(){cout<<"B constructor"<<endl;}
    virtual ~B(){cout<<"B destructor"<<endl;}
};

A* pt = new C;
delete pt;

输出结果：

A constructor

B constructor

C constructor

C destructor

B destructor

A destructor

只在其中一个类中存在虚析构函数

class A
{
public:
    A(){cout<<"A constructor"<<endl;}
    ~A(){cout<<"A destructor"<<endl;}
};

class B
{
public:
    B(){cout<<"B constructor"<<endl;}
    virtual ~B(){cout<<"B destructor"<<endl;}
};

class C:public A,public B
{
public:
    C(){cout<<"C constructor"<<endl;}
    ~C(){cout<<"C destructor"<<endl;}
};

B* pa = new C;
delete pa;

输出结果：

A constructor

B constructor

C constructor

C destructor

B destructor

A destructor

============================

class A
{
public:
    A(){cout<<"A constructor"<<endl;}
     ~A(){cout<<"A destructor"<<endl;}//输出改为virtual
};

class B
{
public:
    B(){cout<<"B constructor"<<endl;}
    virtual ~B(){cout<<"B destructor"<<endl;}
};

class C:public A,public B
{
public:
    C(){cout<<"C constructor"<<endl;}
    ~C(){cout<<"C destructor"<<endl;}
};

int main(int argc, char* argv[])
{
    A* pa = new C;
    delete pa;
    return 0;
}

输出结果：

A constructor

B constructor

C constructor

A destructor

观察输出，我们可以得到如下结论：

无论多重继承中的基类任然需要遵循Effective C++中基类的设计原则---如果一个类被作为基类使用，需要提供虚析构函数。

对于多重继承中没有虚析构的基类，如果用基类指针操作子类对象那么会出现资源泄露。

转载于:https://my.oschina.net/qihh/blog/57685