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

最新推荐文章于 2024-01-17 14:53:07 发布
最新推荐文章于 2024-01-17 14:53:07 发布
阅读量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
pandaxcl
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
C++的类什么时候需要虚析构函数
个人博客
10-25 1391
在看《C++沉思录》的时候，看到这段话： 2018版-第4章-类设计者的核查表-第40页 什么时候类需要虚析构函数？ 1.不会用作基类的类是不需要虚析构函数。 2.如果会使用基类指针并delete，那么需要使用虚析构函数，即使类里没有任何成员函数，否则delete会产生内存泄漏 书里提到的这件事情我之前没有注意过，于是写了测试代码如下： class A { int a; }; cla...
c++中虚析构函数的使用
fpcc的专栏
08-09 566
c++中虚析构函数的使用 一、为什么使用虚拟析构函数 在c++中，为了实现里氏替换原则，父子类可以通过虚拟函数来实现特异化的不同，即常说的动态绑定机制。正常情况下，构造函数是无法声明成virtual的，但是一般来说，推荐析构函数默认为virtual。也就是说，析构函数使用虚拟函数是常态情况，不使用是非常态。那么，为什么析构函数要声明为virtual呢？ c++是一种静态编译语言，也就是说，绝大多数情况下，在编译期，各编译单元就完成了编译的运作，在实际运行时，装载器只是装载链接相关地址即可。但是由于c++支持
C++ 虚析构函数-(一个带有虚函数功能的类,则它需要一个虚析构函数)
阳光梦的专栏
05-09 1232
#include using namespace std; class ClxBase { public: ClxBase() {cout << "i am ClxBase! create" << endl;}; virtual ~ClxBase() {cout << "i am ClxBase! destroy" << endl;}; virtual void
类需要一个虚析构函数吗？
likun_tech的专栏
05-17 676
绝不会用作基类的类是不需要虚析构函数的：任何虚函数只在继承的情况下才有用。 假设，你设计了一个A类，并且B是A的继承，你在使用的时候，你可能会将实际指向B类的指针指向基类A的指针，并且调用了delete函数。 代码如下： #include using namespace std; struct A{ string a; virtual ~A() //~A()
C++——什么时候析构函数需要写成虚函数
qq_44745063的博客
05-29 847
作者：小 琛 欢迎转载，请标明出处 引言：什么情况下析构函数最好定义为虚函数？为什么？ 答：在实现多态时。 在实现多态时，当一个类被作为基类并且该基类对派生类的对象进行操作，在析构时防止只析构基类而不析构派生类的状况发生。把基类的析构函数设计为虚函数可以在基类的指针指向派生类对象时，用基类的指针删除派生类对象，避免内存泄漏。 举例分析 #include <iostream> class A { public: ~A() { std::cout << "delete A" &l
C++：什么情况下需要将析构函数定义为虚函数？
好儿郎~志在四方
10-17 1676
C++：什么情况下需要将析构函数定义为虚函数。
C++ 虚拟析构函数 (virtual destructor)
我是小白呀的博客
05-23 6605
C++ 虚拟析构函数 (virtual destructor). 虚拟析构函数的用法以及使用场景.
C++中基类的析构函数为什么要用virtual虚析构函数
最新发布
adminstate的博客
01-17 1407
基类的析构函数添加virtual关键字
C++虚析构函数的使用分析
09-05
虚拟析构函数的重要性体现在处理动态分配的成员变量上。假设`Base`类有一个指针成员`pB`，在构造函数中动态分配内存，而在析构函数中释放。派生类`Derived`也有一个指针成员`pD`，同样动态分配和释放内存。如果不...
全面解析C++中的析构函数
09-02
默认情况下，析构函数是公有的，可以在析构函数体内自由调用类成员函数和访问类成员数据。 析构函数调用的顺序是逆向的，首先调用析构函数自身，然后按照类声明中非静态成员对象的顺序逆序调用它们的析构函数。对于...
C++类的练习_c++类综合练习_C++_c++类练习_
09-29
在这个"C++类的练习"主题中，我们将深入探讨类的基本构造、成员变量、成员函数、访问修饰符、构造函数、析构函数、对象的创建与销毁、友元函数、继承、多态等关键知识点。 1. **类的定义与声明**：类是用来定义对象...
深入解析C++编程中基类与基类的继承的相关知识
01-21
基类 继承过程将创建一个新的派生类，它由基类的成员加上派生类添加的任何新成员组成。在多重继承中，可以构建一个继承关系图，...若要消除此冗余，可以在继承此类类时将其声明为虚拟基类。 多个基类 如多重继承中所
C++经典语法以及类的编写与应用实例
03-15
C++经典语法与应用，类的编写与应用，构造与析构函数，函数的重载，类的继承，函数覆盖，基类与派生类的构造函数、析构函数先后调用顺序，如何在派生类构造函数中向基类的构造函数传递参数，this成员变量，类型转换...
C++中使用STL轻松实现序列化
热门推荐
04-03 1万+
#if 0 在用C++编写应用程序的过程中，经常涉及到序列化的问题，但是序列化的问题通常都会有非常繁琐的过程代码需要书写，本文中就是通过简单的步骤实现了程序的序列化问题，简单直接，和其它的序列化方案有着很大的不同。 首先来看看简单的数据写入文件和从文件读入数据的代码： 特别注解：本人特别喜欢用STL来书写代码，一方面是便于移植，但是另一方却是在于用STL书写的代码简单直接，可读性
C++中模板构造函数和模板转义运算符的妙用
07-06 3415
#if 0 在C++中我们会遇到如何让一个函数能够接收任意的类型的参数的问题，在C语言中解决这个问题的方法是使用省略号作为函数的原型，但是省略号参数并不能指定参数具体的数量因此存在着一定的安全隐患，最近在研究Loki库的可继承性静态代码的时候发现在C++中还存在另外一种C++特有的方法，那就是采用模板构造函数和模板转换运算符。 现在来看看具体的代码：#endif#include #in
自动化C++程序设计---分析C++类结构
10-23 3364
/*<![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 2926
/*<![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 2362
/*<![CDATA[*/body { color: #000; background-color: #fff; margin: 0px 10%; min-width: 720px; font-family: 新宋体; counter-reset: chapter section subsection subsubsection paragraph lchapt
C++什么是虚析构函数
03-26
虚析构函数是在基类中声明的虚函数，用于确保在删除基类指针时调用适当的析构函数，即先调用派生类的析构函数，然后再调用基类的析构函数。这样可以防止内存泄漏和未定义行为。虚析构函数用于释放使用虚拟函数创建的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值