C++虚函数的底层实现原理

原文链接：https://blog.csdn.net/u011000290/article/details/50498683

在C++中，多态是利用虚函数来实现的。比如说，有如下代码：

[cpp]  view plain  copy

1. #include <iostream>  
2. using namespace std;  
3. class Animal  
4. {  
5. public:  
6.     void Cry()  
7.     {  
8.         cout << "Animal cry!" << endl;  
9.     }  
10. };  
11. class Dog :public Animal  
12. {  
13. public:  
14.     void Cry()  
15.     {  
16.         cout << "Wang wang!" << endl;  
17.     }  
18. };  
19. void MakeAnimalCry(Animal& animal)  
20. {  
21.     animal.Cry();  
22. }  
23. int main()  
24. {  
25.     Dog dog;  
26.     dog.Cry();  
27.     MakeAnimalCry(dog);  
28.     return 0;  
29. }  

输出如下图：

这里定义了一个Animal类，Dog类继承该类，并覆盖了它的Cry方法。有一个MakeAnimalCry方法，传入了Animal的引用，传入了dog对象，但是输出确是Animal的输出。理想的情况下，用户希望传入的是dog对象，就该调用dog的Cry方法。要实现这种多态行为，需要将Animal::Cry()声明为虚函数。可以通过Animal指针或者Animal引用来访问Animal对象，这种指针或者引用可以指向Animal、Dog、Cat对象，而不需要关心它们具体指向的是哪种对象。修改代码如下：

[cpp]  view plain  copy

1. #include <iostream>  
2. using namespace std;  
3. class Animal  
4. {  
5. public:  
6.     virtual void Cry()  
7.     {  
8.         cout << "Animal cry!" << endl;  
9.     }  
10. };  
11. class Dog :public Animal  
12. {  
13. public:  
14.     void Cry()  
15.     {  
16.         cout << "Wang wang!" << endl;  
17.     }  
18. };  
19. class Cat:public Animal  
20. {  
21. public:  
22.     void Cry()  
23.     {  
24.         cout << "Meow meow" << endl;  
25.     }  
26. };  
27. void MakeAnimalCry(Animal& animal)  
28. {  
29.     animal.Cry();  
30. }  
31. int main()  
32. {  
33.     Dog dog;  
34.     Cat cat;  
35.     //dog.Cry();  
36.     MakeAnimalCry(dog);  
37.     MakeAnimalCry(cat);  
38.     return 0;  
39. }  

修改后的输出如下：

这就是多态的效果，将派生类对象视为基类对象，并执行派生类的Cry实现。如果基类指针指向的是派生类对象，通过该指针调用运算符delete时，即对于使用new在自由存储区中实例化的派生类对象，如果将其赋给基类指针，并通过该指针调用delete，将不会调用派生类的析构函数。这可能会导致资源未释放、内存泄露等问题，为了避免这种问题，可以将基类的析构函数声明为虚函数。

在上面的程序中，演示了多态的效果，即在函数MakeAnimalCry中，虽然通过Animal引用调用Cry方法，但是实际调用的确是Dog::Cry或者Cat::Cry方法。在编译阶段，编译器并不知道将要传递给该函数的是哪种对象，无法确保在不同的情况下执行不同的Cry方法。应该调用哪个Cry方法显然是在运行阶段决定的。这是使用多态的不可见逻辑实现的，而这种逻辑是编译器在编译阶段提供的。下面详细地说明一下虚函数的底层实现原理。

比如说有下面的基类Base，它声明了N个虚函数：

[cpp]  view plain  copy

1. class Base  
2. {  
3. public:  
4.     virtual void Func1()  
5.     {  
6.         //Func1的实现代码   
7.     }  
8.     virtual void Func2()  
9.     {  
10.         //Func2的实现代码   
11.     }  
12.     //Func3、Func4等虚函数的实现   
13.     virtual void FuncN()  
14.     {  
15.         //FuncN的实现代码   
16.     }  
17. };  

下面的Derived类继承了Base类，并且覆盖了除Func2之外的其他所有虚函数，

[cpp]  view plain  copy

1. class Derived:public Base  
2. {  
3. public:  
4.     virtual void Func1()  
5.     {  
6.         //Func2覆盖Base类的Func1代码   
7.     }  
8.     //除去Func2的其他所有虚函数的实现代码   
9.     virtual void FuncN()  
10.     {  
11.         //FuncN覆盖Base类的FuncN代码   
12.     }  
13. };  

编译器见到这种继承层次结构后，知道Base定义了虚函数，并且在Derived类中覆盖了这些函数。在这种情况下，编译器将为实现了虚函数的基类和覆盖了虚函数的派生类分别创建一个虚函数表(Virtual Function Table,VFT)。也就是说Base和Derived类都将有自己的虚函数表。实例化这些类的对象时，将创建一个隐藏的指针VFT*，它指向相应的VFT。可将VFT视为一个包含函数指针的静态数组，其中每个指针都指向相应的虚函数。Base类和Derived类的虚函数表如下图所示：

每个虚函数表都由函数指针组成，其中每个指针都指向相应虚函数的实现。在类Derived的虚函数表中，除一个函数指针外，其他所有的函数指针都指向本地的虚函数实现。Derived没有覆盖Base::Func2，因此相应的虚函数指针指向Base类的Func2的实现。这就意味着，当执行下面的代码时，编译器将查找Derived类的VFT，确保调用Base::Func2的实现：

[cpp]  view plain  copy

1. Derived objDerived;  
2. objDerived.Func2();  

调用被覆盖的方法时，也是这样：

[cpp]  view plain  copy

1. void DoSomething(Base& objBase)  
2. {  
3.     objBase.Func1();  
4. }  
5. int main()  
6. {  
7.     Derived objDerived;  
8.     DoSomething(objDerived);  
9. }  

在这种情况下，虽然将objDerived传递给了objBase，进而被解读成一个Base实例，但该实例的VFT指针仍然指向Derived类的虚函数表，因此通过该VFT执行的是Derived::Func1.虚函数表就是通过上面的方式来实现C++的多态。

要验证虚函数表的存在其实也很简单，可以通过比较同一个类，一个包含虚函数，一个不包含，对比其大小就知道了。

[cpp]  view plain  copy

1. #include <iostream>  
2. using namespace std;  
3. class Test   
4. {  
5. public:  
6.     int a,b;  
7.     void DoSomething()  
8.     {   }   
9. };  
10. class Base  
11. {  
12. public:  
13.     int a,b;  
14.     virtual void DoSomething()  
15.     {   }   
16. };  
17. int main()  
18. {  
19.     cout<<"sizeof(Test):"<<sizeof(Test)<<endl;  
20.     cout<<"sizeof(Base):"<<sizeof(Base)<<endl;  
21.     return 0;  
22. }  

执行输出如下：

虽然两个类几乎相同，因为Base中的DoSomething方法是一个虚函数，编译器为Base类生成了一个虚函数表，并为其虚函数表指针预留空间，所以Base类占用的内存空间比Test类多了8个字节。