Effective c++学习笔记——条款09：绝不在构造和析构过程中调用virtual函数

 Never call virtual functions during construction or destruction

    这是本条款的核心，不该在构造函数和析构函数期间调用virtual函数，因为存在不可预期的结果。为什么会这么说呢？首先看一下下面的例子：

   

view plain copy to clipboard print ?

1. // never_call_vir.cpp : 定义控制台应用程序的入口点。   
2.   
3. //2011/9/10 by wallwind    
4.   
5.   
6. #include "stdafx.h"   
7.   
8. #include <iostream>   
9.   
10. using namespace std;  
11.   
12.   
13. class Base  
14.   
15. {  
16.   
17. public:  
18.   
19.     Base()  
20.   
21.     {  
22.   
23.         print();  
24.   
25.     }  
26.   
27.     virtual void print()  
28.   
29.     {  
30.   
31.         cout<<"Base()~print()"<<endl;  
32.   
33.     }  
34.   
35. };  
36.   
37.   
38. class Derived:public Base  
39.   
40. {  
41.   
42. public:  
43.   
44.     Derived()  
45.   
46.     {  
47.   
48.         cout<<"Derived()"<<endl;  
49.   
50.     }  
51.   
52.     virtual void print()  
53.   
54.     {  
55.   
56.         cout<<"Derived()~print()"<<endl;  
57.   
58.           
59.   
60.     }  
61.   
62. };  
63.   
64.   
65. int _tmain(int argc, _TCHAR* argv[])  
66.   
67. {  
68.   
69.     Derived der;  
70.   
71.     return 0;  
72.   
73. }  

// never_call_vir.cpp : 定义控制台应用程序的入口点。 //2011/9/10 by wallwind #include "stdafx.h" #include <iostream> using namespace std; class Base { public: Base() { print(); } virtual void print() { cout<<"Base()~print()"<<endl; } }; class Derived:public Base { public: Derived() { cout<<"Derived()"<<endl; } virtual void print() { cout<<"Derived()~print()"<<endl; } }; int _tmain(int argc, _TCHAR* argv[]) { Derived der; return 0; }

        首先有个基类base，其次Derived是其子类，print虚函数覆盖了父类函数。那么当Derived der创建的时候，会调用哪个print呢？下面上输出结果

---

        从生成的结果可以看到，基类Base的print。基类型构造期间virtual函数绝对不会下降到派生类型阶层，也就是说virtual函数并不是virtual的。由于base class构造函数的执行更早于derived class构造函数，当base class构造函数执行时derived class的成员变量尚未初始化。如果此期间调用的virtual函数下降至derived class阶层，要知道derived class的函数几乎必然取用local成员变量，而那些成员变量尚未初始化。这将是一张通往不明确行为和彻夜调试大会串的直达车票。“要求使用对象内部尚未初始化的成分”是危险的代名词，所以C++不让你走这条路。

             其实还有比上述理由根本的原因：在derived class对象的base class构造期间，对象的类型是base class而不是derived class。不只virtual函数会被编译器解析至(resolve to)base class，若使用运行期类型信息(runtime type information，例如dynamic_cast(见条款27)和typeid)，也会把对象视为base class类型。本例之中，当derived 构造函数正执行起来打算初始化“derived 对象内的base class成分”时，该对象的类型是base 。那是每一个C++成分(见条款1)的态度，而这样的对待是合理的：这个对象呢你的“derived 专属成分”尚未初始化，所以面对它们，最安全的做法就是视它们不存在。对象在derived class构造函数开始执行前不会成为一个derived class对象。

        相同道理也适用于析构函数。一旦derived class析构函数开始执行，对象内的derived class成员变量便呈现未定义值，所以C++的任何部分包括virtual函数，dynamic_casts等等也就那么看待它。

    但是假设这样的调用virtual函数放在non-virtual函数里，而non-virtual函数则在构造函数和析构函数里调用，那么编译器很难检测到这样的情况。假设X定义的是pure virtual，，但运行时则会crash（如果你很愿意看的话）。

如下代码，就会出现问题

view plain copy to clipboard print ?

1. // never_call_vir.cpp : 定义控制台应用程序的入口点。   
2.   
3. //2011/9/10 by wallwind    
4.   
5.   
6. #include "stdafx.h"   
7.   
8. #include <iostream>   
9.   
10. using namespace std;  
11.   
12.   
13. class Base {  
14.   
15. public:  
16.   
17.     Base() {   
18.   
19.         Init();  
20.   
21.     }  
22.   
23.     void Init(void) {   
24.   
25.         Print();  
26.   
27.     }  
28.   
29.     virtual void Print(void) const = 0;  
30.   
31. };  
32.   
33.   
34. class Derived : public Base {  
35.   
36. public:  
37.   
38.     virtual void Print(void) const {  
39.   
40.         cout << "Derived Print" << endl;  
41.   
42.     }  
43.   
44. };  
45.   
46.   
47. int _tmain(int argc, _TCHAR* argv[])  
48.   
49. {  
50.   
51.     Derived der;  
52.   
53.     return 0;  
54.   
55. }  

// never_call_vir.cpp : 定义控制台应用程序的入口点。 //2011/9/10 by wallwind #include "stdafx.h" #include <iostream> using namespace std; class Base { public: Base() { Init(); } void Init(void) { Print(); } virtual void Print(void) const = 0; }; class Derived : public Base { public: virtual void Print(void) const { cout << "Derived Print" << endl; } }; int _tmain(int argc, _TCHAR* argv[]) { Derived der; return 0; }

从图中可以看到，在pure virtual 函数被调用的时候，程序是会终止的。

所以确定你的构造函数和析构函数都没有(在对象被创建和销毁期间)调用virtual函数，而它们调用的所有函数也都服从同一约束

    下面我们来讨论解决方案，像本条款书中所说：一种做法是在基类中内将函数改为non-virtual，然后要求derived class构造函数传递必要信息给基类构造函数，而后那个构造函数便可安全地调用non-virtual 函数。书中的例子有些不懂，编译不正确，等到我弄懂啦，在修正之。

请记住：

在构造和析构期间不要调用virtual函数，因为这类调用从不下降至derived class(比起当前执行构造和析构函数的那层)。