C++入门学习——虚函数表介绍

分类： 【C/C++】

C++ 入门教程 多态 虚函数 虚函数表

目录(?)[+]

多态

多态是指使用相同的函数名来访问函数不同的实现方法，可以简单概括为“一种接口，多种方法”。

C++支持编译时多态（也叫静态多态）和运行时多态（也叫动态多态），运算符重载和函数重载就是编译时多态，而派生类和虚函数实现运行时多态。

静态多态与动态多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用，在编译器编译期间就可以确定函数的调用地址，并生产代码，是静态多态（编译时多态），就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定，需要在运行时才确定，这就属于晚绑定，是动态多态（运行时多态）。

这里，我们探究的是动态多态。

C++动态多态性是通过虚函数来实现的，虚函数允许子类（派生类）重新定义父类（基类）成员函数，而子类（派生类）重新定义父类（基类）虚函数的做法称为覆盖(override)，或者称为重写。

最常见的用法是：父类（基类）指针，基类指针可以指向任何子类（派生类）对象（实例），然后通过基类的指针调用实际派生类的成员函数，示例如下：

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.    
4. class Base   
5. {   
6. public:   
7.     void f(int x){ cout << "Base::f(int) " << x << endl; }   
8.     void f(float x){ cout << "Base::f(float) " << x << endl; }  
9.     // 必须有virtual关键字，此为虚函数  
10.     virtual void g(void){ cout << "Base::g(void)" << endl;}   
11. };   
12. class Derive: public Base   
13. {   
14. public:   
15.     // virtual关键字，可有可无，此为虚函数  
16.     virtual void g(void){ cout << "Derived::g(void)" << endl;}   
17. };   
18.   
19. int main(void)   
20. {   
21.     Derive d;   
22.     Base *pb = &d;   
23.     pb->f(42);     // 运行结果: Base::f(int) 42   
24.     pb->f(3.14f);  // 运行结果: Base::f(float) 3.14   
25.     pb->g();       // 运行结果: Derived::g(void)   
26.       
27.     return 0;  
28. }   

虚函数表

C++ 中的虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的，简称为V-Table。每个含有虚函数的类有一张虚函数表，表中每一项是一个虚函数的地址， 也就是说，虚函数表的每一项是一个虚函数的指针。 没有虚函数的C++类，是不会有虚函数表的。

下面通过一些示例简单介绍虚函数表：

[cpp]  view plain copy

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

Base的实例（即对象b）的虚函数表如下：

注意：在上面这个图中，虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“\0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。

无虚函数覆盖的虚函数表

下面，再让我们来看看继承时的虚函数表是什么样的。


假设有如下所示的一个继承关系：

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.    
4. class Base   
5. {  
6. public:  
7.     virtual void f() { cout << "Base::f" << endl; }  
8.     virtual void g() { cout << "Base::g" << endl; }  
9.     virtual void h() { cout << "Base::h" << endl; }  
10.    
11. };  
12.   
13. class Derive:public Base  
14. {  
15. public:  
16.     virtual void f1() { cout << "Derive::f1" << endl; }  
17.     virtual void g1() { cout << "Derive::g1" << endl; }  
18.     virtual void h1() { cout << "Derive::h1" << endl; }  
19.           
20. };  
21.   
22. int main(void)   
23. {   
24.     Derive d; //派生类对象  
25.       
26.     return 0;  
27. }  

请注意，在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例（Derive d）中，其虚函数表如下所示：

无虚函数覆盖的虚函数表特点如下：

1）虚函数按照其声明顺序放于表中。

2）父类（派生类）的虚函数在子类（基类）的虚函数前面。

有虚函数覆盖的虚函数表

没有覆盖父类的虚函数是毫无意义的。之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。

下面，我们来看一下，如果子类中有重载了父类的虚函数，会是一个什么样子？

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.    
4. class Base   
5. {  
6. public:  
7.     virtual void f() { cout << "Base::f" << endl; }  
8.     virtual void g() { cout << "Base::g" << endl; }  
9.     virtual void h() { cout << "Base::h" << endl; }  
10.    
11. };  
12.   
13. class Derive:public Base  
14. {  
15. public:  
16.     //重写父类的f()虚函数  
17.     virtual void f() { cout << "Derive::f" << endl; }  
18.     virtual void g1() { cout << "Derive::g1" << endl; }  
19.     virtual void h1() { cout << "Derive::h1" << endl; }  
20.           
21. };  
22.   
23. int main(void)   
24. {   
25.     Base *p = NULL; //父类指针  
26.     Base b;     //父类对象  
27.     Derive d;   //子类对象  
28.       
29.     p = &b; //父类指针指向父类对象  
30.     p->f(); //运行结果："Base::f"  
31.       
32.     p = &d; //父类指针指向子类对象  
33.     p->f(); //运行结果："Derive::f"  
34.       
35.     return 0;  
36. }  

为了让大家看到被继承过后的效果，在这个类的设计中，只覆盖了父类的一个虚函数：f()。那么，对于派生类的实例，其虚函数表会是下面的一个样子：

有虚函数覆盖的虚函数表特点如下：

1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。

2）没有被覆盖的函数依旧。

本例中：

Base *p = NULL; //父类指针

p = &d; //父类指针指向子类对象

p->f();   //运行结果："Derive::f"

由 p（即 &d）所指的内存中的父类虚函数表的 f() 的位置已经被实际子类Derive::f()函数地址所取代，于是在实际调用发生时，是 Derive::f() 被调用了。这就实现了多态。