虚函数

一、虚函数是这么实现的

解析：

　　简单的说，虚函数是通过虚函数表实现的，那么什么是虚函数表呢？

　　事实上，如果一个类中含有虚函数表，则系统会为这个类分配一个指针成员指向一张虚函数表（vtbl），表中每一项指向一个虚函数的地址，实际上就是一个函数指针的数组。为了说明虚函数表，请看程序：

[cpp] view plain copy

1. class Parent  
2. {  
3. public:  
4.     virtual void foo1() {}  
5.     virtual void foo2() {}  
6.     void foo3();  
7. };  
8.   
9. class Child1 : public Parent  
10. {  
11. public:  
12.     void foo1() {}  
13.     void foo3();  
14. };  
15.   
16. class Child2 : public Parent  
17. {  
18. public:  
19.     void foo1() {}  
20.     void foo2() {}  
21.     void foo3();  
22. };  

下面列出了各个类的虚函数表

Parent类的vtbl：Parent::foo1()的地址、Parent::foo2()。

Child1类的vtbl：Child1::foo1()的地址、Parent::foo2()。

Child2类的vtbl：Child2::foo1()的地址、Child2::foo2()。

　　可以看出，虚函数表既有继承性，又有多态性。每个派生类的vtbl继承了它各个基类的vtbl，如果基类vtbl中包含某一项，则其派生类的vtbl中也包含同样一项，但是两项的值可能不同。如果派生类覆盖（override）了该项对应的虚函数，则派生类vtbl的该项指向重载后的虚函数，如果没有重载的话，则沿用基类的值。

　　在类对象的内存布局中，首先是vtbl指针，然后才是对象的数据。在通过对象指针调用一个虚函数时，编译器生成的代码将先获取对象类的vtbl指针，然后调用vtbl中对应的项。对于通过对象调用指针的情况，在编译期间无法确定指针指向的是基类对象还是派生类对象，或者是哪个派生类对象。但是在运行期间执行到调用语句时，这一点已经确定，编译后的调用代码能够根据具体对象获取正确的vtbl，调用正确的虚函数，从而实现多态性。

　　分析一下这里的思想所在，问题的实质是这样，对于发出虚函数调用的这个对象指针，在编译期间缺乏更多的信息，而在运行期间具备足够的信息，但那时已不再进行绑定了，怎么在二者之间做一个过渡呢？把绑定所需的信息用一种通用的数据结构记录下来，该数据结构可以同对象指针相联系，在编译时只需要使用这个数据结构进行抽象的绑定，而在运行期间将会得到真正的绑定。这个数据结构就是vtbl。可以看到，实现用户所需的抽象和多态需要进行后绑定，而编译器又是通过抽象和多态实现后绑定的。

二、构造函数调用虚函数

[cpp] view plain copy

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class A  
6. {  
7. public:  
8.     A() { doSth(); }                //构造函数调用虚函数  
9.     virtual void doSth()  
10.     {  
11.         printf("I am A");  
12.     }  
13. };  
14.   
15. class B : public A  
16. {  
17. public:  
18.     virtual void doSth()  
19.     {  
20.         printf("I am B");  
21.     }  
22. };  
23.   
24. int main()  
25. {  
26.     B b;  
27.       
28.     return 0;  
29. }  

执行结果是什么？为什么？

　　在构造函数中，虚拟机制不会发生作用，因为基类的构造函数在派生类构造函数之前执行，当基类构造函数执行时，派生类数据成员还没有被初始化。如果基类构造函数期间调用的虚函数向下匹配到派生类，派生类的函数理所应当会涉及本地数据成员，但是那些数据成员还没有被初始化，而调用涉及一个对象还没有被初始化的部分自然是危险的，所以c++会提示此路不通。因此，虚函数不会向下匹配到派生类，而是直接执行基类的函数。

结果：

[cpp] view plain copy

1. I am A  

三、看代码写输出——虚函数的作用

[cpp] view plain copy

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. class A  
6. {  
7. public:  
8.     virtual void print(void)  
9.     {  
10.         cout<<"A::print()"<<endl;  
11.     }  
12. };  
13.   
14. class B : public A  
15. {  
16. public:  
17.     virtual void print(void)  
18.     {  
19.         cout<<"B::print()"<<endl;  
20.     }  
21. };  
22.   
23. class C : public A  
24. {  
25. public:  
26.     void print(void)  
27.     {  
28.         cout<<"C::print()"<<endl;  
29.     }  
30. };  
31.   
32. void print(A a)  
33. {  
34.     a.print();  
35. }  
36.   
37. int main()  
38. {  
39.     A a, *pa, *pb, *pc;  
40.     B b;  
41.     C c;  
42.       
43.     pa = &a;  
44.     pb = &b;  
45.     pc = &c;  
46.       
47.     a.print();  
48.     b.print();  
49.     c.print();  
50.       
51.     pa->print();  
52.     pb->print();  
53.     pc->print();  
54.       
55.     print(a);  
56.     print(b);  
57.     print(c);  
58.       
59.     return 0;  
60. }  

代码第47~49行，分别使用类A、类B、类C的各个对象来调用其print()成员函数，因此执行的是各个类的print()函数。

代码第51~53行，使用了3个类A的指针来调用print成员函数，而这3个指针分别指向类A、类B和类C的3个对象。由于print函数是虚函数，因此这里有多态，执行的是各个类的print函数。

代码第55~58行，全局的print函数的参数是使用传值的方式（注意与传引用的区别，如果是引用，则又是多态），在对象a、b、c分别传入时，在函数栈中会分别生成类A的临时对象，因此执行的都是类A的print成员函数。

执行结果：

[cpp] view plain copy

1. A::print()  
2. B::print()  
3. C::print()  
4. A::print()  
5. B::print()  
6. C::print()  
7. A::print()  
8. A::print()  
9. A::print()