析构函数怎么写【析构函数用法】 收藏 0

CPU眼里的：析构函数

“为什么析构函数必须是虚函数？难道没有另外一种答案吗？”

01

提出问题

构造函数和析构函数，分别用于类对象（class类型的变量）的初始化和相关资源的清理工作。这看上去非常的自动、方便，但千万不要掉以轻心，C++的每一个语法糖背后，都有暗坑。

例如，为了保证析构函数能够被正确的调用，我们必须把析构函数定义成：虚函数，也就是要加上关键字：virtual；那作为孪生兄弟的构造函数，为什么不需要定义成虚函数呢？好了，让我们一起用CPU的视角，解读它们背后的故事吧。

02

代码分析

打开Compiler Explorer，先定义一个简单的类A，简单的为它定义一个构造函数和析构函数；随后再定义一个派生类B，也简单的为它定义一个构造函数和析构函数；随后，我们写一个函数func1，分别定义一个类A和类B的对象a和b：

好了，让我们看看函数func1对应的CPU指令。老规矩，不用关心每条CPU指令的具体含义，仅凭直觉，我们也可以看懂它在做什么。当然，如果你对具体的CPU指令很感兴趣，想死磕一下CPU指令，建议先看一下，相信会对你的理解，大有帮助。

好了，教科书果然没有骗我，很显然！在定义变量a，b的时候，其对应的CPU指令，会自动调用它们各自的构造函数，如上图的红色图框所示；同时，在函数返回时，也会自动的调用它们各自的析构函数，如上图的蓝色图框所示。当然，这些CPU指令，是编译器自动生成的，从源代码上，我们看不出任何的蛛丝马迹。希望这次手动实作，能帮你加深印象，免除一些无感的语法记忆。

但如你所见，这种情况下，即使析构函数，不是虚函数。编译器也可以正确的调用对象a，b对应的析构函数。难道析构函数必须定义成虚函数的说法有误？

让我们再看一个在堆上，动态创建类对象的例子。编写一个简单的函数func2；先new一个类A的对象，并用指针变量a，保存对象的内存首地址；再new一个类B的对象，并用指针变量b，保存对象的内存首地址；随后，分别delete这两个对象a和b：

还记得所讲吗？new的时候，会先调用operator new函数，在堆上申请对象的内存空间；随后，再调用对象的构造函数。

如你所见，这里分别为对象a和对象b，申请了内存空间，如上图中的红色图框所示；随后，又分别调用了它们对应的构造函数，如上图中的蓝色图框所示。再看看delete对应的暗箱操作吧：

不出意外，它们会先调用对象a和对象b的析构函数，如上图中的红色图框所示；然后再调用operator delete函数释放对象a和对象b所占据的内存空间，如上图中的蓝色图框所示。这看上去是不是非常合理呢？那问题来了，既然编译器可以正确调用对象a，b的析构函数，那析构函数，必须是虚函数的真正用意何在呢？

好了，是该面对真正的问题了！写一个简单的函数func3，为了突出重点，我们只使用new产生一个类B的对象，但不同于刚才的函数func2，这次我们利用C++的多态特性，用一个基类A的指针型变量，也就是变量b，来存放这个对象的内存首地址；最后跟func2一样，我们使用delete释放这个对象：

发现问题了吗？new操作，会正确的申请一个类B，需要占据的内存空间，也能正确的调用类B对应的构造函数，如上图中的红色图框所示。但delete操作，并没有调用类B的析构函数，相反，它居然调用了类A的析构函数，这显然是张冠李戴了，如上图中的蓝色图框所示。

请不要苛责编译器的失误，要知道在那个时候，人工智能可没有今天这么发达，编译器只会根据delete的指针类型，静态的决定：调用哪个类的析构函数。也就是所谓的：静态绑定，例如函数func1和func2也是如此，而且这在很多情况下也是合理的。

但显然，如果跟多态搭配使用的话，仅依据指针类型，来断定析构函数的调用，就很容易张冠李戴。很遗憾，编译器并不能正确的推导出指针变量b，所指向的对象的真实类型，而是给了一个折中的方案：动态绑定。但代价是：需要程序员手动的为析构函数加一个关键字：virtual

这时我们再看看CPU指令，会发生什么变化。如你所见，编译器为类A和类B分别建立了虚函数表，如上图中的蓝色图框所示。并在其中分别存放了类A和类B的析构函数的内存首地址。如所说，为每一个类建立一个虚函数列表，可以保证在未来调用虚函数的时候，职责分明，井水不犯河水。

让我们再看看delete对应的CPU指令，看上去复杂了不少，如上图中的红色图框所示。已经很难猜出它们的真实含义了，具体的分析请看上个章节。这里只说结论：前3条指令，是在查阅刚才的虚函数列表，并找到类B的析构函数的内存地址，随后的2条指令就可以调用类B的析构函数，这样，就不会张冠李戴，德不配位了。

好了，至此析构函数的问题，就说完了。真是大神一句话，阿布跑断腿呀！好在编程知识不是圣经，它们都是可验证的，可证伪的。

03

总结

1. 构造函数和析构函数的调用，不是100%自动完成的。特别是通过new生成的对象，需要手动编写delete语句，来间接调用析构函数。

2. 基类和派生类相互调用：构造函数、析构函数的顺序，在编译阶段就决定了，掌握这些语法规则，除了可以查阅书籍，也可以查阅一下CPU指令，如你所见，它们并不复杂，甚至更加直观！

3. 析构函数并非必须是虚函数。但在使用多态的设计方法时，如果析构函数不是虚函数的话，在delete类对象的时候，可能出现张冠李戴的情况。如果想给程序加一份保险的话，那么把析构函数设置成虚函数，总是没错的。

4. 那为什么构造函数不需要定义成：虚函数呢？我想应该是没有这个必要！因为往往在生成类对象的时候，都会明确的指出对象的具体类型，所以，对于构造函数，静态绑定就足够了。

04

热点问题

Q1：为什么一些书籍，明文要求“析构函数”必须是虚函数呢？

A1：这是一个好问题！阿布曾经看过一本书（书名忘了），作者的语言十分犀利，对于virtual的意见，是斩钉截铁的Yes！其实yes也挺好，阿布也不用花时间去研究其中的细节；但不知道大家有没有这种想法，越是绝对的权威，越激发人的探索欲。

当然，只从结果上看，yes当然没有什么问题，至少是安全、保险的。虽然没有什么颠覆性的发现，但确实也有所发现，至少virtual的原因，我们是靠自己的双手弄清楚的，我们也可以解释yes的原因，甚至理由更加充分！这种感觉，跟100%接受权威指南是不一样的。

05

系统学习和5折福利

如果喜欢阿布的解读方式，希望系统学习这些编程知识的话，可以考虑看看阿布编写，并有多位微软大佬联袂推荐的

\”编程始于代码，但不止于代码；让我们通过，实现软硬一体，深度探索编程的️禁区\”

Effective C++ 条款07 为多态基类声明virtual析构函数

有许多种做法可以记录时间，因此，设计一个TimeKeeper base class 和一些derived classes作为不同的计时方法，相当合情合理：

许多客户只想在程序中使用时间，不想操心时间如何计算等细节，这时候我们可以设计factory(工厂)函数，返回指针指向一个计时对象。Factory函数会“返回一个base class指针，指向新生成之derived class对象”：

为遵守factory函数的规矩，被getTimeKeeper（）返回的对象必须位于heap。因此为了避免泄漏内存和其他资源，将factory函数返回的每一个对象适当地delete掉很重要：

条款13说“倚赖客户执行delete动作，基本上便带有某种错误倾向”，条款18则谈到factory函数接口该如何修改以便预防常见之客户错误，但这些在此都是次要的，因为此条款内我们要对付的是上述代码的一个更根本弱点：纵使客户把每一件事都做对了，仍然没办法知道程序如何行动。

问题出在getTimeKeeper返回的指针指向一个derived class对象(例如AtomicClock)，而那个对象却经由一个base class指针(例如一个TimeKeeper*指针)被删除，而目前的base class(TimeKeeper)有个non-virtual析构函数。

这是一个引来灾难的秘诀，因为C++明白指出，当derived class对象经由一个base class指针被删除，而该base class带着一个non-virtual析构函数，其结果未有定义—实际执行时通常发生的是对象的derived成分没被销毁。如果getTimeKeeper 返回指针指向一个AtomicClock对象，其内的AtomicClock成分(也就是声明于AtomicClockclass内的成员变量)很可能没被销毁，而AtomicClock的析构函数也未能执行起来。然而其base class成分(也就是TimeKeeper这一部分)通常会被销毁，于是造成一个诡异的“局部销毁”对象。这可是形成资源泄漏、败坏之数据结构、在调试器上浪费许多时间的绝佳途径喔。

消除这个问题的做法很简单：给base class一个virtual析构函数。此后删除derived class对象就会如你想要的那般。是的，它会销毁整个对象，包括所有derived class成分：

像TimeKeeper这样的base classes除了析构函数之外通常还有其他virtual函数，因为virtual函数的目的是允许derived class的实现得以客制化(见条款34)。例如TimeKeeper就可能拥有一个virtual getCurrentTime，它在不同的derived classes中有不同的实现码。任何class只要带有virtual函数都几乎确定应该也有一个virtual析构函数。

如果class不含virtual函数，通常表示它并不意图被用做一个base class。当class不企图被当作base class，令其析构函数为virtual往往是个主意。考虑一个用来表示二维空间点坐标的class：

如果int占用32bits，那么Point对象可塞入一个64-bit缓存器中。更有甚者，这样一个Point对象可被当做一个“64-bit量”传给以其他语言如C或FORTRAN撰写的函数。然而当Point的析构函数是virtual，形势起了变化。

欲实现出virtual函数，对象必须携带某些信息，主要用来在运行期决定哪一个virtual函数该被调用。这份信息通常是由一个所谓vptr(virtual table pointer)指针指出。vptr指向一个由函数指针构成的数组，称为vtbl(virtual table)；每一个带有virtual函数的class都有一个相应的vtbl。当对象调用某一virtual 函数，实际被调用的函数取决于该对象的vptr所指的那个vtbl-一编译器在其中寻找适当的函数指针。

virtual函数的实现细节不重要。重要的是如果Point class内含virtual函数，其对象的体积会增加：在32-bit计算机体系结构中将占用64bits(为了存放两个ints)至96bits(两个ints加上vptr)：在64-bit计算机体系结构中可能占用64~128bits，因为指针在这样的计算机结构中占64bits。因此，为 Point添加一个vptr会增加其对象大小达50%~100%！Point对象不再能够塞入一个64-bit缓存器，而C++的Point对象也不再和其他语言(如C)内的相同声明有着一样的结构(因为其他语言的对应物并没有vptr)，因此也就不再可能把它传递至(或接受自)其他语言所写的函数，除非你明确补偿vptr——那属于实现细节，也因此不再具有移植性。

因此，无端地将所有classes的析构函数声明为virtual，就像从未声明它们为virtual一样，都是错误的。许多人的心得是：只有当class内含至少一个virtual函数，才为它声明virtual析构函数。

即使class完全不带virtual函数，被“non-virtual析构函数问题”给咬伤还是有可能的。举个例子，标准 string不含任何virtual函数，但有时候程序员会错误地把它当做base class:

乍看似乎无害，但如果你在程序任意某处无意间将一个pointer-to-SpecialString转换为一个pointer-to-string，然后将转换所得的那个string指针delete掉，你立刻被流放到“行为不明确”的恶地上：

相同的分析适用于任何不带virtual析构函数的class，包括所有STL容器如vector，list，set，tr1::unorderedmap(见条款54)等等。如果你曾经企图继承一个标准容器或任何其他“带有non-virtual析构函数”的class，拒绝诱惑吧！(很不幸C++没有提供类似Java的final classes或C#的 sealed classes 那样的“禁止派生”机制。)

有时候令class带一个pure virtual析构函数，可能颇为便利。还记得吗，pure virtual函数导致abstract(抽象)classes一一也就是不能被实体化(instantiated)的class。也就是说，你不能为那种类型创建对象。然而有时候你希望拥有抽象class，但手上没有任何pure virtual函数，怎么办？唔，由于抽象class总是企图被当作一个base class来用，而又由于base class应该有个virtual析构函数，并且由于pure virtual函数会导致抽象class，因此解法很简单：为你希望它成为抽象的那个class声明一个pure virtual析构函数。下面是个例子：

这个class有一个pure virtual函数，所以它是个抽象class，又由于它有个virtual析构函数，所以你不需要担心析构函数的问题。然而这里有个窍门：你必须为这个pure virtual析构函数提供一份定义：

析构函数的运作方式是，最深层派生(most derived)的那个class其析构函数最先被调用，然后是其每一个base class的析构函数被调用。编译器会在Awov的derived classes的析构函数中创建一个对~AWOV的调用动作，所以你必须为这个函数提供一份定义。如果不这样做，连接器会发出抱怨。

“给base classes一个virtual析构函数”，这个规则只适用于polymorphic(带多态性质的)base classes身上。这种base classes 的设计目的是为了用来“通过base class接口处理derived class对象”。TimeKeeper就是一个polymorphic base class，因为我们希望处理AtomicClock和waterClock对象，纵使我们只有TimeKeeper指针指向它们。

并非所有base classes的设计目的都是为了多态用途。例如标准string和 STL容器都不被设计作为base classes 使用，更别提多态了。某些classes的设计目的是作为base classes 使用，但不是为了多态用途。这样的classes 如条款6的Uncopyable和标准程序库的input_iterator_tag(条款47)，它们并非被设计用来“经由base class接口处置derived class对象”，因此它们不需要virtual析构函数。

请记住

■ polymorphic(带多态性质的)base classes应该声明一个virtual析构函数。如果class带有任何virtual函数，它就应该拥有一个virtual析构函数。

■ Classes 的设计目的如果不是作为base classes 使用，或不是为了具备多态性(polymorphically)，就不该声明virtual析构函数。

构造函数和析构函数

构造函数

概念:

构造函数是一种用于创建对象的特殊成员函数。

作用：

为对象分配空间

对数据成员赋初值

请求其他资源

特点：

当创建对象时，系统自动调用构造函数，不能在程序中直接调用。

构造函数名与类名相同。

构造函数允许为内联函数、重载函数、带默认形参值的函数。

构造函数可以有任意类型的参数，但不能具有返回类型。

如果程序中未声明，则系统自动产生出一个默认形式的构造函数。

例如:

Class A{

Public:

A(){}//不带参数的构造函数

A(int a=1,int b=2){}//带默认参数的构造函数

Private:

int a,b;

}；

Void main()

{ A a1;//调用的是不带参数的构造函数

A a2();//调用带默认参数的构造函数，将a,b的值改为

A a3(3,7);//调用带默认参数的构造函数，将a,b的值改为3，7

}

拷贝构造函数

概念特点:

拷贝构造函数是一种特殊的构造函数，其形参为本类的对象引用，主要下面三种情况下被自动调用：

定义语句中用一个对象初始化另一个对象。

将一个对象作为参数按值调用方式传递给另一个对象时生成对象副本。

生成一个临时的对象作为函数的返回结果。

class 类名

{ public :

类名（形参）；//构造函数

类名（类名 &对象名）；//拷贝构造函数

…

}；

类名::类名（类名 &对象名）//拷贝构造函数的实现

{ 函数体 }

例：

Class A

{private:

Int x,y;

Public:

A(int a=0,int b=0)

{x=a;y=b;}

A(A& aa)//拷贝构造函数

{x=aa.a;y=aa.b;}

}

默认的拷贝构造函数

如果程序员没有为类声明拷贝初始化构造函数，则编译器自己生成一个默认的拷贝构造函数。

这个构造函数执行的功能是：用作为初始值的对象的每个数据成员的值，初始化将要建立的对象的对应数据成员。

析构函数

概念：

析构函数名字为符号“~”加类名，析构函数没有参数和返回值。一个类中只可能定义一个析构函数，所以析构函数不能重载。

作用：

析构函数是用于取消对象的成员函数，当一个对象作用域结束时，系统自动调用析构函数。

特点：

如果一个对象被定义在一个函数体内，则当这个函数结束时，该对象的析构函数被自动调用。

若一个对象是使用new运算符动态创建的，在使用delete运算符释放它时，delete将会自动调用析构函数。

如果程序中未声明析构函数，编译器将自动产生一个默认的析构函数。

类组合的构造函数, 析构函数调用

构造函数调用顺序：先调用内嵌对象的构造函数（按内嵌时的声明顺序，先声明者先构造）。然后调用本类的构造函数。如果有虚函数，则先调用它。

析构函数的调用顺序正好相反。

本文作者及来源:Renderbus瑞云渲染农场https://www.renderbus.com