虚析构函数（总结帖子）

iloveoracle

浏览: 114361 次
性别:
来自: 南京

最近访客更多访客>>

jinyucangfeng

zhangzoli

knight_black_bob

Strongyuzhixie

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

java
虚析构函数（总结帖子）

虚析构函数（总结帖子）java 工作

一. 虚析构函数 
我们知道，为了能够正确的调用对象的析构函数，一般要求具有层次结构的顶级类定义其析构函数为虚函数。因为在delete一个抽象类指针时候，必须要通过虚函数找到真正的析构函数。 
如： 
<div class="code" style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px;">
 <div style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 4px; padding-right: 5px; padding-bottom: 4px; padding-left: 4px; border-right-color: rgb(204,204,204); border-right-width: 1px; border-right-style: solid; border-top-color: rgb(204,204,204); border-top-width: 1px; border-top-style: solid; font-size: 13px; border-left-color: rgb(204,204,204); border-left-width: 1px; border-left-style: solid; width: 946px; border-bottom-color: rgb(204,204,204); border-bottom-width: 1px; border-bottom-style: solid; background-color: rgb(238,238,238);">
classBase 
{ public: 
Base(){} virtual~Base(){} 
}; classDerived:publicBase 
{ public: 
Derived(){<img alt="" src="http://www.cnblogs.com/Images/dot.gif" style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; border-top-width: 0px; border-right-width: 0px; border-bottom-width: 0px; border-left-width: 0px; border-color: initial; border-color: initial;">}; ~Derived(){<img alt="" src="http://www.cnblogs.com/Images/dot.gif" style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; border-top-width: 0px; border-right-width: 0px; border-bottom-width: 0px; border-left-width: 0px; border-color: initial; border-color: initial;">}; 
} voidfoo() 
{ 
Base*pb; 
pb=newDerived; 
deletepb; 
}

这是正确的用法，会发生动态绑定，它会先调用Derived的析构函数，然后是Base的析构函数 
如果析构函数不加virtual，delete pb只会执行Base的析构函数，而不是真正的Derived析构函数。 
因为不是virtual函数，所以调用的函数依赖于指向静态类型，即Base 
二. 纯虚析构函数 
现在的问题是，我们想把Base做出抽象类，不能直接构造对象，需要在其中定义一个纯虚函数。如果其中没有其他合适的函数，可以把析构函数定义为纯虚的，即将前面的CObject定义改成： <div style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 4px; padding-right: 5px; padding-bottom: 4px; padding-left: 4px; border-right-color: rgb(204,204,204); border-right-width: 1px; border-right-style: solid; border-top-color: rgb(204,204,204); border-top-width: 1px; border-top-style: solid; font-size: 13px; border-left-color: rgb(204,204,204); border-left-width: 1px; border-left-style: solid; width: 946px; border-bottom-color: rgb(204,204,204); border-bottom-width: 1px; border-bottom-style: solid; background-color: rgb(238,238,238);">
classBase 
{ public: 
Base(){} virtual~Base()=0 
};

<div class="code" style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px;">
可是，这段代码不能通过编译，通常是link错误，不能找到~Base()的引用(gcc的错误报告)。这是因为，析构函数、构造函数和其他内部函数不一样，在调用时，编译器需要产生一个调用链。也就是，Derived的析构函数里面隐含调用了Base的析构函数。而刚才的代码中，缺少～Base()的函数体，当然会出现错误。 
这里面有一个误区，有人认为，virtual f()=0这种纯虚函数语法就是没有定义体的语义。 
其实，这是不对的。这种语法只是表明这个函数是一个纯虚函数，因此这个类变成了抽象类，不能产生对象。我们<span style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; line-height: 1.5; background-color: yellow;">完全可以为纯虚函数指定函数体<span style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; line-height: 1.5; background-color: rgb(255,255,255);">(<span style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; line-height: 1.5; background-color: rgb(255,255,255);">http://www.research.att.com/~bs/bs_faq2.html#pure-virtual)。通常的纯虚函数不需要函数体，是因为我们一般不会调用抽象类的这个函数，只会调用派生类的对应函数。这样，我们就有了一个纯虚析构函数的函数体，上面的代码需要改成： 

<div style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 4px; padding-right: 5px; padding-bottom: 4px; padding-left: 4px; border-right-color: rgb(204,204,204); border-right-width: 1px; border-right-style: solid; border-top-color: rgb(204,204,204); border-top-width: 1px; border-top-style: solid; font-size: 13px; border-left-color: rgb(204,204,204); border-left-width: 1px; border-left-style: solid; width: 946px; border-bottom-color: rgb(204,204,204); border-bottom-width: 1px; border-bottom-style: solid; background-color: rgb(238,238,238);">
classBase 
{ public: 
Base() 
{ 
} virtual~Base()=0;//purevirtual }; 
Base::~Base()//functionbody { 
}

 
从语法角度来说，不可以将上面的析构函数直接写入类声明中（内联函数的写法）。这或许是一个不正交化的地方。但是这样做的确显得有点累赘 
这个问题看起来有些学术化，因为一般我们完全可以在Base中找到一个更加适合的函数，通过将其定义为没有实现体的纯虚函数，而将整个类定义为抽象类。但这种技术也有一些应用，如这个例子： <div class="code" style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px;">
<div style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 4px; padding-right: 5px; padding-bottom: 4px; padding-left: 4px; border-right-color: rgb(204,204,204); border-right-width: 1px; border-right-style: solid; border-top-color: rgb(204,204,204); border-top-width: 1px; border-top-style: solid; font-size: 13px; border-left-color: rgb(204,204,204); border-left-width: 1px; border-left-style: solid; width: 946px; border-bottom-color: rgb(204,204,204); border-bottom-width: 1px; border-bottom-style: solid; background-color: rgb(238,238,238);">
classBase//abstractclass { public: virtual~Base(){};//virtual,notpure virtualvoidHiberarchy()const=0;//purevirtual }; voidBase::Hiberarchy()const//purevirtualalsocanhavefunctionbody { 
std::cout<<"Base::Hiberarchy"; 
} classDerived:publicBase 
{ public: 
Derived(){} virtualvoidHiberarchy()const 
{ 
CB::Hiberarchy(); 
std::cout<<"Derived::Hiberarchy"; 
} virtualvoidfoo(){} 
}; intmain(){ 
Base*pb=newDerived(); 
pb->Hiberarchy(); 
pb->Base::Hiberarchy(); return0; 
} 

 
在这个例子中，我们试图打印出类的继承关系。在根基类中定义了虚函数Hiberarchy，然后在每个派生类中都重载此函数。我们再一次看到，由于想把Base做成个抽象类，而这个类中没有其他合适的方法成员可以定义为纯虚的，我们还是只好将Hiberarchy定义为纯虚的。（当然，完全可以定义～Base函数，这就和上面的讨论一样了。^_^） 
另外，可以看到，在main中有两种调用方法，第一种是普通的方式，进行动态链接，执行虚函数，得到结果"Derived::Hiberarchy"；第二种是指定类的方式，就不再执行虚函数的动态链接过程了，结果是"Base::Hiberarchy"。 
通过上面的分析可以看出，定义纯虚函数的真正目的是为了定义抽象类，而并不是函数本身。与之对比，在java中，定义抽象类的语法是
abstract class，也就是在类的一级作指定（当然虚函数还是也要加上abstract关键字）。是不是这种方式更好一些呢？在Stroustrup的《C++语言的设计与演化》中我找到这样一段话： 
“我选择的是将个别的函数描述为纯虚的方式，没有采用将完整的类声明定义为抽象的形式，这是因为纯虚函数的概念更加灵活一些。我很看重能够分阶段定义类的能力；也就是说，我发现预先定义一些纯虚函数，并把另外一些留给进一步的派生类去定义也是很有用的”。 
我还没有完全理解后一句话，我想从另外一个角度来阐述这个概念。那就是，在一个多层复杂类结构中，中间层次的类应该具体化一些抽象函数，但很可能并不是所有的。中间类没必要知道是否具体化了所有的虚函数，以及其祖先已经具体化了哪些函数，只要关注自己的职责就可以了。也就是说，中间类没必要知道自己是否是一个真正的抽象类，设计者也就不用考虑是否需要在这个中间类的类级别上加上类似abstract的说明了。 
当然，一个语言的设计有多种因素，好坏都是各个方面的。这只是一个解释而已。 
最后，总结一下关于虚函数的一些常见问题： 
1) 虚函数是动态绑定的，也就是说，使用虚函数的指针和引用能够正确找到实际类的对应函数，而不是执行定义类的函数。这是虚函数的基本功能，就不再解释了。 
2)构造函数不能是虚函数。而且，在构造函数中调用虚函数，实际执行的是父类的对应函数，因为自己还没有构造好,
多态是被disable的。 
3)析构函数可以是虚函数，而且，在一个复杂类结构中，这往往是必须的。 
4) 将一个函数定义为纯虚函数，实际上是将这个类定义为抽象类，不能实例化对象。 
5)纯虚函数通常没有定义体，但也完全可以拥有。 
6) 析构函数可以是纯虚的，但<span style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; color: rgb(0,0,0); background-color: yellow;">纯虚析构函数必须有定义体，因为析构函数的调用是在子类中隐含的。 
7) 非纯的虚函数必须有定义体，不然是一个错误。 
8) 派生类的override虚函数定义必须和父类完全一致。除了一个特例，如果父类中返回值是一个指针或引用，子类override时可以返回这个指针（或引用）的派生。例如，在上面的例子中，在Base中定义了
virtual Base* clone(); 在Derived中可以定义为 virtual Derived* clone()。可以看到，这种放松对于Clone模式是非常有用的。 其他，有待补充。

[size=24px;]重要扩展（不该声明虚析构函数乱声明后果很严重）[/size]

[size=14px;] 确定基类有虚析构函数[/size] [size=14px;]有时，一个类想跟踪它有多少个对象存在。一个简单的方法是创建一个静态类成员来统计对象的个数。这个成员被初始化为0，在构造函数里加1，析构函数里减1。（条款m26里说明了如何把这种方法封装起来以便很容易地添加到任何类中，“my article on counting objects”提供了对这个技术的另外一些改进）[/size] [size=14px;]设想在一个军事应用程序里，有一个表示敌人目标的类：[/size] [size=14px;]class enemytarget {[/size] [size=14px;]public:[/size] [size=14px;] enemytarget() { ++numtargets; }[/size] [size=14px;] enemytarget(const enemytarget&) { ++numtargets; }[/size] [size=14px;] ~enemytarget() { --numtargets; }[/size] [size=14px;] static size_t numberoftargets()[/size] [size=14px;] { return numtargets; }[/size] [size=14px;] virtual bool destroy(); // 摧毁enemytarget对象后[/size] [size=14px;] // 返回成功[/size] [size=14px;]private:[/size] [size=14px;] static size_t numtargets; // 对象计数器[/size] [size=14px;]};[/size] [size=14px;]// 类的静态成员要在类外定义;[/size] [size=14px;]// 缺省初始化为0[/size] [size=14px;]size_t enemytarget::numtargets;[/size] [size=14px;]这个类不会为你赢得一份政府防御合同，它离国防部的要求相差太远了，但它足以满足我们这儿说明问题的需要。[/size] [size=14px;]敌人的坦克是一种特殊的敌人目标，所以会很自然地想到将它抽象为一个以公有继承方式从enemytarget派生出来的类（参见条款35及m33）。因为不但要关心敌人目标的总数，也要关心敌人坦克的总数，所以和基类一样，在派生类里也采用了上面提到的同样的技巧：[/size] [size=14px;]class enemytank: public enemytarget {[/size] [size=14px;]public:[/size] [size=14px;] enemytank() { ++numtanks; }[/size] [size=14px;] enemytank(const enemytank& rhs)[/size] [size=14px;] : enemytarget(rhs)[/size] [size=14px;] { ++numtanks; }[/size] [size=14px;] ~enemytank() { --numtanks; }[/size] [size=14px;] static size_t numberoftanks()[/size] [size=14px;] { return numtanks; }[/size] [size=14px;] virtual bool destroy();[/size] [size=14px;]private:[/size] [size=14px;] static size_t numtanks; // 坦克对象计数器[/size] [size=14px;]};[/size] [size=14px;]（写完以上两个类的代码后，你就更能够理解条款m26对这个问题的通用解决方案了。）[/size] [size=14px;]最后，假设程序的其他某处用new动态创建了一个enemytank对象，然后用delete删除掉：[/size] [size=14px;]enemytarget *targetptr = new enemytank;[/size] [size=14px;]...[/size] [size=14px;]delete targetptr;[/size] [size=14px;]到此为止所做的一切好象都很正常：两个类在析构函数里都对构造函数所做的操作进行了清除；应用程序也显然没有错误，用new生成的对象在最后也用delete删除了。然而这里却有很大的问题。程序的行为是不可预测的——无法知道将会发生什么。[/size] [size=14px;]c++语言标准关于这个问题的阐述非常清楚：当通过基类的指针去删除派生类的对象，而基类又没有虚析构函数时，结果将是不可确定的。这意味着编译器生成的代码将会做任何它喜欢的事：重新格式化你的硬盘，给你的老板发电子邮件，把你的程序源代码传真给你的对手，无论什么事都可能发生。（实际运行时经常发生的是，派生类的析构函数永远不会被调用。在本例中，这意味着当targetptr 删除时，enemytank的数量值不会改变，那么，敌人坦克的数量就是错的，这对需要高度依赖精确信息的部队来说，会造成什么后果？）[/size] [size=14px;]为了避免这个问题，只需要使enemytarget的析构函数为virtual。声明析构函数为虚就会带来你所希望的运行良好的行为：对象内存释放时，enemytank和enemytarget的析构函数都会被调用。 [/size] [size=14px;]和绝大部分基类一样，现在enemytarget类包含一个虚函数。虚函数的目的是让派生类去定制自己的行为（见条款36），所以几乎所有的基类都包含虚函数。[/size] [size=14px;]如果某个类不包含虚函数，那一般是表示它将不作为一个基类来使用。当一个类不准备作为基类使用时，使析构函数为虚一般是个坏主意。请看下面的例子，这个例子基于arm(“the annotated c++ reference manual”)一书的一个专题讨论。[/size] [size=14px;]// 一个表示2d点的类[/size] [size=18px; color: #ff0000;]class point { 
public: 
point(short int xcoord, short int ycoord); 
~point(); 
private: 
short int x, y; 
};[/size] [size=14px;]如果一个short int占16位，一个point对象将刚好适合放进一个32位的寄存器中。另外，一个point对象可以作为一个32位的数据传给用c或fortran等其他语言写的函数中。但如果point的析构函数为虚，情况就会改变。[/size] [size=14px;]实现虚函数需要对象附带一些额外信息，以使对象在运行时可以确定该调用哪个虚函数。对大多数编译器来说，这个额外信息的具体形式是一个称为vptr（虚函数表指针）的指针。vptr指向的是一个称为vtbl（虚函数表）的函数指针数组。每个有虚函数的类都附带有一个vtbl。当对一个对象的某个虚函数进行请求调用时，实际被调用的函数是根据指向vtbl的vptr在vtbl里找到相应的函数指针来确定的。[/size] [size=14px;]虚函数实现的细节不重要（当然，如果你感兴趣，可以阅读条款m24），重要的是，如果point类包含一个虚函数，它的对象的体积将不知不觉地翻番，从2个16位的short变成了2个16位的short加上一个32位的vptr！point对象再也不能放到一个32位寄存器中去了。而且，c++中的point对象看起来再也不具有和其他语言如c中声明的那样相同的结构了，因为这些语言里没有vptr。所以，用其他语言写的函数来传递point也不再可能了，除非专门去为它们设计vptr，而这本身是实现的细节，会导致代码无法移植。[/size] [size=14px;]所以基本的一条是，无故的声明虚析构函数和永远不去声明一样是错误的。实际上，很多人这样总结：当且仅当类里包含至少一个虚函数的时候才去声明虚析构函数。[/size] [size=14px;]这是一个很好的准则，大多数情况都适用。但不幸的是，当类里没有虚函数的时候，也会带来非虚析构函数问题。例如，条款13里有个实现用户自定义数组下标上下限的类模板。假设你（不顾条款m33的建议）决定写一个派生类模板来表示某种可以命名的数组(即每个数组有一个名字)。[/size] [size=14px;]template <class t> // 基类模板[/size] [size=14px;]class array { // (来自条款13)[/size] [size=14px;]public:[/size] [size=14px;] array(int lowbound, int highbound);[/size] [size=14px;] ~array();[/size] [size=14px;]private:[/size] [size=14px;] vector <t> data;[/size] [size=14px;] size_t size;[/size] [size=14px;] int lbound, hbound;[/size] [size=14px;]};[/size] [size=14px;]template <class t>[/size] [size=14px;]class namedarray: public array <t> {[/size] [size=14px;]public:[/size] [size=14px;] namedarray(int lowbound, int highbound, const string& name);[/size] [size=14px;] ...[/size] [size=14px;]private:[/size] [size=14px;] string arrayname;[/size] [size=14px;]};[/size] [size=14px;]如果在应用程序的某个地方你将指向namedarray类型的指针转换成了array类型的指针，然后用delete来删除array指针，那你就会立即掉进“不确定行为”的陷阱中。[/size] [size=14px;]namedarray <int> *pna =[/size] [size=14px;] new namedarray <int> (10, 20, "impending doom ");[/size] [size=14px;]array <int> *pa;[/size] [size=14px;]...[/size] [size=14px;]pa = pna; // namedarray <int> * -> array <int> *[/size] [size=14px;]...[/size] [size=14px;]delete pa; // 不确定! 实际中，pa-> arrayname[/size] [size=14px;] // 会造成泄漏，因为*pa的namedarray[/size] [size=14px;] // 永远不会被删除[/size] [size=14px;]现实中，这种情形出现得比你想象的要频繁。让一个现有的类做些什么事，然后从它派生一个类做和它相同的事，再加上一些特殊的功能，这在现实中不是不常见。namedarray没有重定义array的任何行为——它继承了array的所有功能而没有进行任何修改——它只是增加了一些额外的功能。但非虚析构函数的问题依然存在（还有其他问题，参见m33）[/size] [size=14px;]最后，值得指出的是，在某些类里声明纯虚析构函数很方便。纯虚函数将产生抽象类——不能实例化的类（即不能创建此类型的对象）。有些时候，你想使一个类成为抽象类，但刚好又没有任何纯虚函数。怎么办？因为抽象类是准备被用做基类的，基类必须要有一个虚析构函数，纯虚函数会产生抽象类，所以方法很简单：在想要成为抽象类的类里声明一个纯虚析构函数。[/size] [size=14px;]这里是一个例子：[/size] [size=14px;]class awov { // awov = "abstract w/o[/size] [size=14px;] // virtuals "[/size] [size=14px;]public:[/size] [size=14px;] virtual ~awov() = 0; // 声明一个纯虚析构函数[/size] [size=14px;] [/size] [size=14px;]};[/size] [size=14px;]这个类有一个纯虚函数，所以它是抽象的，而且它有一个虚析构函数，所以不会产生析构函数问题。但这里还有一件事：必须提供纯虚析构函数的定义：[/size] [size=14px;]awov::~awov() {} // 纯虚析构函数的定义[/size] [size=14px;]这个定义是必需的，因为虚析构函数工作的方式是：最底层的派生类的析构函数最先被调用，然后各个基类的析构函数被调用。这就是说，即使是抽象类，编译器也要产生对~awov的调用，所以要保证为它提供函数体。如果不这么做，链接器就会检测出来，最后还是得回去把它添上。[/size] [size=14px;]可以在函数里做任何事，但正如上面的例子一样，什么事都不做也不是不常见。如果是这种情况，那很自然地会想到将析构函数声明为内联函数，从而避免对一个空函数的调用所产生的开销。这是一个很好的方法，但有一件事要清楚。[/size] [size=14px;]因为析构函数为虚，它的地址必须进入到类的vtbl（见条款m24）。但内联函数不是作为独立的函数存在的（这就是“内联”的意思），所以必须用特殊的方法得到它们的地址。条款33对此做了全面的介绍，其基本点是：如果声明虚析构函数为inline，将会避免调用它们时产生的开销，但编译器还是必然会在什么地方产生一个此函数的拷贝。[/size] [size=14px;]构造函数是用初始化类能者对象的，是不允许用虚函数的。[/size]

0
顶

1
踩

分享到：

c语言中去除const修饰 | 手机防盗软件实现(源码)

2011-12-21 09:54
浏览 665
评论(0)
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论