C++类什么情况下需要虚拟析构函数

最新推荐文章于 2024-04-15 07:00:00 发布
最新推荐文章于 2024-04-15 07:00:00 发布
阅读量3k 收藏 7
点赞数 1
分类专栏： C++基础 文章标签： c++ delete iostream class 测试 microsoft
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pandaxcl/article/details/648896
版权 

//特别需要指出的是，本文中的所有的测试结果都是在g++编译器和VC8编译器下测试的结果。
//各自的版本信息如下所示：
//g++
/*******************************************************************************
Reading specs from D:/Dev-Cpp/bin/../lib/gcc/mingw32/3.4.2/specs
Configured with: ../gcc/configure --with-gcc --with-gnu-ld --with-gnu-as
--host=mingw32 --target=mingw32 --prefix=/mingw --enable-threads --disable-nls
--enable-languages=c,c++,f77,ada,objc,java --disable-win32-registry
--disable-shared --enable-sjlj-exceptions --enable-libgcj --disable-java-awt
--without-x --enable-java-gc=boehm --disable-libgcj-debug --enable-interpreter
--enable-hash-synchronization --enable-libstdcxx-debug
Thread model: win32
gcc version 3.4.2 (mingw-special)
*******************************************************************************/
//VC8
/*******************************************************************************
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 14.00.50727.42 for 80x86
Copyright (C) Microsoft Corporation.  All rights reserved.

usage: cl [ option... ] filename... [ /link linkoption... ]
*******************************************************************************/

#if CODE1
#include <iostream>
//给出一个没有虚拟析构函数的基类
class Base
{
public:
        Base()
        {
                std::cout<<"Base::Base()"<<std::endl;
        }
        ~Base()
        {
                std::cout<<"Base::~Base()"<<std::endl;
        }
};
//给出一个没有虚拟析构函数的继承类
class Derived:public Base
{
public:
        Derived()
        {
                std::cout<<"Derived::Derived()"<<std::endl;
        }
        ~Derived()
        {
                std::cout<<"Derived::~Derived()"<<std::endl;
        }
};
//下面的测试代码
int main()
{
        {//堆栈变量的情况
                std::cout << "----------[Derived d;]----------" << std::endl;
                Derived d;
        }
        {//堆内存分配，并且删除派生类对象指针的情况
                std::cout << "----------[Derived *pd = new Derived();]----------" << std::endl;
                Derived *pd = new Derived();
                std::cout << "----------[delete pd;]----------" << std::endl;
                delete pd;//这里会调用派生类和基类的析构函数，虽然派生类和基类的析构函数不是虚拟的
        }
        {//堆内存分配，并且删除基类对象指针的情况
                std::cout << "----------[Base *pb = new Derived();]----------" << std::endl;
                Base *pb = new Derived();
                std::cout << "----------[delete pb;]----------" << std::endl;
                delete pb;//这里就不会调用派生类的析构函数
        }
        return 0;
}

//运行结果如下所示:
/*******************************************************************************
----------[Derived d;]----------
Base::Base()
Derived::Derived()
Derived::~Derived()
Base::~Base()
----------[Derived *pd = new Derived();]----------
Base::Base()
Derived::Derived()
----------[delete pd;]----------
Derived::~Derived()
Base::~Base()
----------[Base *pb = new Derived();]----------
Base::Base()
Derived::Derived()
----------[delete pb;]----------
Base::~Base()
*******************************************************************************/

#if 0
    从上面的讨论中可以看出，只有最后一种情况才会对析构函数是否是虚拟的有要求，在
后面的讨论中将会只讨论这种情况。
#endif
#endif//CODE1
#if CODE2
#include <iostream>
//给出一个没有虚拟析构函数的基类
class Base
{
public:
        Base()
        {
                std::cout<<"Base::Base()"<<std::endl;
        }
        ~Base()
        {
                std::cout<<"Base::~Base()"<<std::endl;
        }
};
//给出一个有虚拟析构函数的继承类
class Derived:public Base
{
public:
        Derived()
        {
                std::cout<<"Derived::Derived()"<<std::endl;
        }
        virtual~Derived()
        {
                std::cout<<"Derived::virtual~Derived()"<<std::endl;
        }
};
//下面的测试代码
int main()
{
        //堆内存分配，并且删除基类对象指针的情况
        std::cout << "----------[Base *pb = new Derived();]----------" << std::endl;
        Base *pb = new Derived();
        std::cout << "----------[delete pb;]----------" << std::endl;
        delete pb;//这里就不会调用派生类的析构函数
        return 0;
}

//运行结果如下所示:
/*******************************************************************************
----------[Base *pb = new Derived();]----------
Base::Base()
Derived::Derived()
----------[delete pb;]----------
Base::~Base()
*******************************************************************************/

#if 0
    很明显并没有调用派生类的虚拟析构函数。
#endif
#endif//CODE2
#if CODE3
#include <iostream>
//给出一个有虚拟析构函数的基类
class Base
{
public:
        Base()
        {
                std::cout<<"Base::Base()"<<std::endl;
        }
        virtual~Base()
        {
                std::cout<<"Base::virtual~Base()"<<std::endl;
        }
};
//给出一个没有虚拟析构函数的继承类
class Derived:public Base
{
public:
        Derived()
        {
                std::cout<<"Derived::Derived()"<<std::endl;
        }
        ~Derived()
        {
                std::cout<<"Derived::~Derived()"<<std::endl;
        }
};
//下面的测试代码
int main()
{
        //堆内存分配，并且删除基类对象指针的情况
        std::cout << "----------[Base *pb = new Derived();]----------" << std::endl;
        Base *pb = new Derived();
        std::cout << "----------[delete pb;]----------" << std::endl;
        delete pb;//这里会调用派生类的析构函数
        return 0;
}

//运行结果如下所示:
/*******************************************************************************
----------[Base *pb = new Derived();]----------
Base::Base()
Derived::Derived()
----------[delete pb;]----------
Derived::~Derived()
Base::virtual~Base()
*******************************************************************************/

#if 0
    很明显调用派生类的虚拟析构函数。但是这里值得注意的是：派生类的析构函数并不
是虚拟的，为了说明派生类的虚拟析构函数是否一定要是虚拟的，还需要更多的测试。
#endif
#endif//CODE3
#if CODE4
#include <iostream>
//给出一个有虚拟析构函数的基类
class Base
{
public:
        Base()
        {
                std::cout<<"Base::Base()"<<std::endl;
        }
        virtual~Base()
        {
                std::cout<<"Base::virtual~Base()"<<std::endl;
        }
};
//给出一个有虚拟析构函数的继承类
class Derived:public Base
{
public:
        Derived()
        {
                std::cout<<"Derived::Derived()"<<std::endl;
        }
        virtual~Derived()
        {
                std::cout<<"Derived::virtual~Derived()"<<std::endl;
        }
};
//下面的测试代码
int main()
{
        //堆内存分配，并且删除基类对象指针的情况
        std::cout << "----------[Base *pb = new Derived();]----------" << std::endl;
        Base *pb = new Derived();
        std::cout << "----------[delete pb;]----------" << std::endl;
        delete pb;//这里会调用派生类的析构函数
        return 0;
}

//运行结果如下所示:
/*******************************************************************************
----------[Base *pb = new Derived();]----------
Base::Base()
Derived::Derived()
----------[delete pb;]----------
Derived::virtual~Derived()
Base::virtual~Base()
*******************************************************************************/

#if 0
    很明显调用派生类的虚拟析构函数。通过CODE3和CODE4可以看出只要基类的析构函数
是虚拟的则派生类的析构函数不论是否是虚拟的都将在删除基类指针的时候调用派生类的
析构函数。不过CODE3和CODE4仅仅讨论的是一次一重继承的情况。对于多次多重继承的情
况则需要另外的单独讨论。还是先讨论多次继承的情况，然后再讨论多重继承的情况，最
后讨论多次多重继承的情况。
#endif
#endif//CODE4
#if CODE5
//测试多次继承的情况
#include <iostream>
//给出一个有虚拟析构函数的基类
class Base
{
public:
        Base()
        {
                std::cout<<"Base::Base()"<<std::endl;
        }
        virtual~Base()
        {
                std::cout<<"Base::virtual~Base()"<<std::endl;
        }
};
//给出一个没有虚拟析构函数的继承类
class Derived1:public Base
{
public:
        Derived1()
        {
                std::cout<<"Derived1::Derived1()"<<std::endl;
        }
        ~Derived1()
        {
                std::cout<<"Derived1::~Derived1()"<<std::endl;
        }
};
//给出另一个没有虚拟析构函数的继承类
class Derived2:public Derived1
{
public:
        Derived2()
        {
                std::cout<<"Derived2::Derived2()"<<std::endl;
        }
        ~Derived2()
        {
                std::cout<<"Derived2::~Derived2()"<<std::endl;
        }
};
//下面的测试代码
int main()
{
        //堆内存分配，并且删除基类对象指针的情况
        {
                std::cout << "----------[Base *pb = new Derived2();]----------" << std::endl;
                Base *pb = new Derived2();
                std::cout << "----------[delete pb;]----------" << std::endl;
                delete pb;//这里会调用派生类的析构函数
        }
        {
                std::cout << "----------[Base *pd1 = new Derived1();]----------" << std::endl;
                Derived1 *pd1 = new Derived2();
                std::cout << "----------[delete pd1;]----------" << std::endl;
                delete pd1;//这里会调用派生类的析构函数
        }
        return 0;
}

//运行结果如下所示:
/*******************************************************************************
----------[Base *pb = new Derived2();]----------
Base::Base()
Derived1::Derived1()
Derived2::Derived2()
----------[delete pb;]----------
Derived2::~Derived2()
Derived1::~Derived1()
Base::virtual~Base()
----------[Base *pd1 = new Derived1();]----------
Base::Base()
Derived1::Derived1()
Derived2::Derived2()
----------[delete pd1;]----------
Derived2::~Derived2()
Derived1::~Derived1()
Base::virtual~Base()
*******************************************************************************/

#if 0
    很明显调用了所有派生类的虚拟析构函数。但是这里值得注意的是：派生类的析构函
数并不是虚拟的。可以看出只要有基类的析构函数是虚拟的，那么所有的派生类不管是否
明确的写了虚拟析构函数，派生了的析构函数一定是虚拟的。
#endif
#endif//CODE5
#if CODE6
//测试多重继承的情况
#include <iostream>
//给出一个有虚拟析构函数的基类
class Base1
{
public:
        Base1()
        {
                std::cout<<"Base1::Base1()"<<std::endl;
        }
        virtual~Base1()
        {
                std::cout<<"Base1::virtual~Base1()"<<std::endl;
        }
};
class Base2
{
public:
        Base2()
        {
                std::cout<<"Base2::Base2()"<<std::endl;
        }
        virtual~Base2()
        {
                std::cout<<"Base2::virtual~Base2()"<<std::endl;
        }
};
//给出一个没有虚拟析构函数的继承类
class Derived:public Base1,public Base2
{
public:
        Derived()
        {
                std::cout<<"Derived::Derived()"<<std::endl;
        }
        ~Derived()
        {
                std::cout<<"Derived::~Derived()"<<std::endl;
        }
};
//下面的测试代码
int main()
{
        //堆内存分配，并且删除基类对象指针的情况
        {
                std::cout << "----------[Base *pb = new Derived();]----------" << std::endl;
                Base1 *pb = new Derived();
                std::cout << "----------[delete pb;]----------" << std::endl;
                delete pb;//这里会调用派生类的析构函数
        }
        {
                std::cout << "----------[Base *pb = new Derived();]----------" << std::endl;
                Base2 *pb = new Derived();
                std::cout << "----------[delete pb;]----------" << std::endl;
                delete pb;//这里会调用派生类的析构函数
        }
        return 0;
}

//运行结果如下所示:
/*******************************************************************************
----------[Base *pb = new Derived();]----------
Base1::Base1()
Base2::Base2()
Derived::Derived()
----------[delete pb;]----------
Derived::~Derived()
Base2::virtual~Base2()
Base1::virtual~Base1()
----------[Base *pb = new Derived();]----------
Base1::Base1()
Base2::Base2()
Derived::Derived()
----------[delete pb;]----------
Derived::~Derived()
Base2::virtual~Base2()
Base1::virtual~Base1()
*******************************************************************************/

#if 0
    很明显调用了所有派生类的析构函数和基类的析构函数。另外还可以看出只要有了多重
继承的任意一个基类的指针都可以通过这个指针将整个对象删除。另外还需要考虑一下某个
基类的析构函数不是虚拟的情况。
#endif
#endif//CODE6
#if CODE7
//测试多重继承的情况
#include <iostream>
//给出一个有虚拟析构函数的基类
class Base1
{
public:
        Base1()
        {
                std::cout<<"Base1::Base1()"<<std::endl;
        }
        virtual~Base1()
        {
                std::cout<<"Base1::virtual~Base1()"<<std::endl;
        }
};
class Base2
{
public:
        Base2()
        {
                std::cout<<"Base2::Base2()"<<std::endl;
        }
        ~Base2()
        {
                std::cout<<"Base2::~Base2()"<<std::endl;
        }
};
//给出一个没有虚拟析构函数的继承类
class Derived:public Base1,public Base2
{
public:
        Derived()
        {
                std::cout<<"Derived::Derived()"<<std::endl;
        }
        ~Derived()
        {
                std::cout<<"Derived::~Derived()"<<std::endl;
        }
};
//下面的测试代码
int main()
{
        //堆内存分配，并且删除基类对象指针的情况
        {
                std::cout << "----------[Base *pb = new Derived();]----------" << std::endl;
                Base1 *pb = new Derived();
                std::cout << "----------[delete pb;]----------" << std::endl;
                delete pb;//这里会调用派生类的析构函数
        }
        {
                std::cout << "----------[Base *pb = new Derived();]----------" << std::endl;
                Base2 *pb = new Derived();
                std::cout << "----------[delete pb;]----------" << std::endl;
                delete pb;//这里不会调用派生类的析构函数
        }
        return 0;
}

//运行结果如下所示:
/*******************************************************************************
----------[Base *pb = new Derived();]----------
Base1::Base1()
Base2::Base2()
Derived::Derived()
----------[delete pb;]----------
Derived::~Derived()
Base2::~Base2()
Base1::virtual~Base1()
----------[Base *pb = new Derived();]----------
Base1::Base1()
Base2::Base2()
Derived::Derived()
----------[delete pb;]----------
Base2::~Base2()
*******************************************************************************/

#if 0
    很明显，是否调用所有派生类的析构函数和基类的析构函数，取决于删除的基类指针的
基类的析构函数是否是虚拟的，如果指针的析构函数是虚拟的，那么将会调用所有的派生类
的析构函数和所有的其它基类的析构函数，否则就会象上面的第二种情况一样仅仅删除了基
类自身而已，导致对象没有完全释放。
#endif
#endif//CODE7
C++中的虚析构函数
digitalkee的博客
12-13 7272
Cpp中的虚析构函数 1.虚析构函数的作用：为了避免内存泄漏，而且是当子类中会有指针成员变量时才会使用到。即虚析构函数使得在删除指向子类对象的基类指针时，可以调用子类的析构函数来实现释放子类中堆内存的目的，从而防止内存泄漏。 2.C++中开发中，基类中的析构函数一般都是虚函数，如下面的例子： #include <iostream> using namespace std; // 基类 class Base{ public: ...
c 语言中析构函数,全面解析C++中的析构函数
weixin_42202078的博客
05-20 1542
“析构函数”是构造函数的反向函数。在销毁(释放)对象时将调用它们。通过在类名前面放置一个波形符 (~) 将函数指定为类的析构函数。例如，声明 String 类的析构函数：~String()。在 /clr 编译中，析构函数在释放托管和非托管资源方面发挥了特殊作用。析构函数通常用于在不再需要某个对象时“清理”此对象。请考虑 String 类的以下声明：// spec1_destructors.cpp#...
c++中虚析构函数的使用
fpcc的专栏
08-09 600
c++中虚析构函数的使用 一、为什么使用虚拟析构函数 在c++中，为了实现里氏替换原则，父子类可以通过虚拟函数来实现特异化的不同，即常说的动态绑定机制。正常情况下，构造函数是无法声明成virtual的，但是一般来说，推荐析构函数默认为virtual。也就是说，析构函数使用虚拟函数是常态情况，不使用是非常态。那么，为什么析构函数要声明为virtual呢？ c++是一种静态编译语言，也就是说，绝大多数情况下，在编译期，各编译单元就完成了编译的运作，在实际运行时，装载器只是装载链接相关地址即可。但是由于c++支持
类需要一个虚析构函数吗？
likun_tech的专栏
05-17 715
绝不会用作基类的类是不需要虚析构函数的：任何虚函数只在继承的情况下才有用。 假设，你设计了一个A类，并且B是A的继承，你在使用的时候，你可能会将实际指向B类的指针指向基类A的指针，并且调用了delete函数。 代码如下： #include using namespace std; struct A{ string a; virtual ~A() //~A()
C++ 虚析构函数-(一个带有虚函数功能的类,则它需要一个虚析构函数)
阳光梦的专栏
05-09 1261
#include using namespace std; class ClxBase { public: ClxBase() {cout << "i am ClxBase! create" << endl;}; virtual ~ClxBase() {cout << "i am ClxBase! destroy" << endl;}; virtual void
C++的类什么时候需要虚析构函数
个人博客
10-25 1430
在看《C++沉思录》的时候，看到这段话： 2018版-第4章-类设计者的核查表-第40页 什么时候类需要虚析构函数？ 1.不会用作基类的类是不需要虚析构函数。 2.如果会使用基类指针并delete，那么需要使用虚析构函数，即使类里没有任何成员函数，否则delete会产生内存泄漏 书里提到的这件事情我之前没有注意过，于是写了测试代码如下： class A { int a; }; cla...
C++——什么时候析构函数需要写成虚函数
qq_44745063的博客
05-29 906
作者：小 琛 欢迎转载，请标明出处 引言：什么情况下析构函数最好定义为虚函数？为什么？ 答：在实现多态时。 在实现多态时，当一个类被作为基类并且该基类对派生类的对象进行操作，在析构时防止只析构基类而不析构派生类的状况发生。把基类的析构函数设计为虚函数可以在基类的指针指向派生类对象时，用基类的指针删除派生类对象，避免内存泄漏。 举例分析 #include <iostream> class A { public: ~A() { std::cout << "delete A" &l
C++：什么情况下需要将析构函数定义为虚函数？
好儿郎~志在四方
10-17 1740
C++：什么情况下需要将析构函数定义为虚函数。
C++析构函数
最新发布
qq_74013365的博客
04-15 1810
类的6个默认成员函数：如果一个类中什么成员都没有，简称为空类。空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。
C++ 虚拟析构函数 (virtual destructor)
我是小白呀的博客
05-23 7011
C++ 虚拟析构函数 (virtual destructor). 虚拟析构函数的用法以及使用场景.
C++虚析构函数的使用分析
09-05
虚拟析构函数的重要性体现在处理动态分配的成员变量上。假设`Base`类有一个指针成员`pB`，在构造函数中动态分配内存，而在析构函数中释放。派生类`Derived`也有一个指针成员`pD`，同样动态分配和释放内存。如果不...
全面解析C++中的析构函数
09-02
默认情况下，析构函数是公有的，可以在析构函数体内自由调用类成员函数和访问类成员数据。 析构函数调用的顺序是逆向的，首先调用析构函数自身，然后按照类声明中非静态成员对象的顺序逆序调用它们的析构函数。对于...
C++中使用STL轻松实现序列化
热门推荐
04-03 1万+
#if 0 在用C++编写应用程序的过程中，经常涉及到序列化的问题，但是序列化的问题通常都会有非常繁琐的过程代码需要书写，本文中就是通过简单的步骤实现了程序的序列化问题，简单直接，和其它的序列化方案有着很大的不同。 首先来看看简单的数据写入文件和从文件读入数据的代码： 特别注解：本人特别喜欢用STL来书写代码，一方面是便于移植，但是另一方却是在于用STL书写的代码简单直接，可读性
C++中模板构造函数和模板转义运算符的妙用
07-06 3431
#if 0 在C++中我们会遇到如何让一个函数能够接收任意的类型的参数的问题，在C语言中解决这个问题的方法是使用省略号作为函数的原型，但是省略号参数并不能指定参数具体的数量因此存在着一定的安全隐患，最近在研究Loki库的可继承性静态代码的时候发现在C++中还存在另外一种C++特有的方法，那就是采用模板构造函数和模板转换运算符。 现在来看看具体的代码：#endif#include #in
自动化C++程序设计---分析C++类结构
10-23 3416
/*<![CDATA[*/body { color: #000; background-color: #fff; margin: 0px 10%; min-width: 720px; font-family: 新宋体; counter-reset: chapter section subsection subsubsection paragraph lchapt
自动化C++程序设计---C++里的模板语言
10-23 2973
/*<![CDATA[*/body { color: #000; background-color: #fff; margin: 0px 10%; min-width: 720px; font-family: 新宋体; counter-reset: chapter section subsection subsubsection paragraph lchapt
自动化C++程序设计---分析C++类层次
10-23 2409
/*<![CDATA[*/body { color: #000; background-color: #fff; margin: 0px 10%; min-width: 720px; font-family: 新宋体; counter-reset: chapter section subsection subsubsection paragraph lchapt
配合STL算法编写类的成员函数
02-05 2315
配合STL算法编写类的成员函数 我们在使用C++的开发工作中，经常会编写许许多多的类，当然也会编写大量的成员函数。但是对于如何设计类的结构，如何确定类的成员，这将会是一个艰难的抉择过程。在编写C++类的过程中，我们都希望是我们的成员函数集合最小化，但是常常很难做到这一点。本文就来详细的讨论一下这个问题！在游戏开发中有一个单元类： class Unit{public:
C++虚拟析构函数：关键讲解与应用
虚拟析构函数是C++中的一个重要概念，它在处理基类指针引用子类对象时发挥着关键作用。当试图通过父类指针删除一个子类对象时，如果没有明确指定析构函数为虚函数，其行为是未定义的，可能会导致潜在的内存问题。...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值