C++虚函数及虚函数表解析
来源：博客园
1.虚函数的定义
　　虚函数必须是类的非静态成员函数(且非构造函数)，其访问权限是public（可以定义为private or proteceted, 但是对于多态来说，没有意义。），在基类的类定义中定义虚函数的一般形式：　　　　　　virtual 函数返回值类型 虚函数名（形参表）　　　　　　{ 函数体 }
虚函数的作用是实现动态联编，也就是在程序的运行阶段动态地选择合适的成员函数，在定义了虚函数后，可以在基类的派生类中对虚函数重新定义（形式也是：virtual 函数返回值类型 虚函数名（形参表）{ 函数体 }），在派生类中重新定义的函数应与虚函数具有相同的形参个数和形参类型。以实现统一的接口，不同定义过程。如果在派生类中没有对虚函数重新定义，则它继承其基类的虚函数。当程序发现虚函数名前的关键字virtual后，会自动将其作为动态联编处理，即在程序运行时动态地选择合适的成员
实现动态联编需要三个条件：
　　1、 必须把需要动态联编的行为定义为类的公共属性的虚函数。　　2、 类之间存在子类型关系，一般表现为一个类从另一个类公有派生而来。　　3、 必须先使用基类指针指向子类型的对象，然后直接或者间接使用基类指针调用虚函数。
定义虚函数的限制：
　　（1）非类的成员函数不能定义为虚函数，类的成员函数中静态成员函数和构造函数也不能定义为虚函数，但可以将析构函数定义为虚函数。实际上，优秀的程序员常常把基类的析构函数定义为虚函数。因为，将基类的析构函数定义为虚函数后，当利用delete删除一个指向派生类定义的对象指针时，系统会调用相应的类的析构函数。而不将析构函数定义为虚函数时，只调用基类的析构函数。　　（2）只需要在声明函数的类体中使用关键字“virtual”将函数声明为虚函数，而定义函数时不需要使用关键字“virtual”。　　（3）如果声明了某个成员函数为虚函数，则在该类中不能出现和这个成员函数同名并且返回值、参数个数、参数类型都相同的非虚函数。在以该类为基类的派生类中，也不能出现这种非虚的同名同返回值同参数个数同参数类型函数。
 
为什么虚函数必须是类的成员函数：
虚函数诞生的目的就是为了实现多态，在类外定义虚函数毫无实际用处。
 
为什么类的静态成员函数不能为虚函数：
如果定义为虚函数，那么它就是动态绑定的，也就是在派生类中可以被覆盖的，这与静态成员函数的定义（：在内存中只有一份拷贝；通过类名或对象引用访问静态成员）本身就是相矛盾的。
 
为什么构造函数不能为虚函数：
 　　因为如果构造函数为虚函数的话，它将在执行期间被构造，而执行期则需要对象已经建立，构造函数所完成的工作就是为了建立合适的对象，因此在没有构建好的对象上不可能执行多态（虚函数的目的就在于实现多态性）的工作。在继承体系中，构造的顺序就是从基类到派生类，其目的就在于确保对象能够成功地构建。构造函数同时承担着虚函数表的建立，如果它本身都是虚函数的话，如何确保vtbl的构建成功呢？
　　注意：当基类的构造函数内部有虚函数时，会出现什么情况呢？结果是在构造函数中，虚函数机制不起作用了，调用虚函数如同调用一般的成员函数一样。当基类的析构函数内部有虚函数时，又如何工作呢？与构造函数相同，只有“局部”的版本被调用。但是，行为相同，原因是不一样的。构造函数只能调用“局部”版本，是因为调用时还没有派生类版本的信息。析构函数则是因为派生类版本的信息已经不可靠了。我们知道，析构函数的调用顺序与构造函数相反，是从派生类的析构函数到基类的析构函数。当某个类的析构函数被调用时，其派生类的析构函数已经被调用了，相应的数据也已被丢失，如果再调用虚函数的派生类的版本，就相当于对一些不可靠的数据进行操作，这是非常危险的。因此，在析构函数中，虚函数机制也是不起作用的。
 
　　C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码(Or 不变的 接口)来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。
关于虚函数的使用方法，我在这里不做过多的阐述。大家可以看看相关的C++的书籍。在这篇文章中，我只想从虚函数的实现机制上面为大家 一个清晰的剖析。
当然，相同的文章在网上也出现过一些了，但我总感觉这些文章不是很容易阅读，大段大段的代码，没有图片，没有详细的说明，没有比较，没有举一反三。不利于学习和阅读，所以这是我想写下这篇文章的原因。也希望大家多给我提意见。
言归正传，让我们一起进入虚函数的世界。
2.虚函数表
　　对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。 在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例（注：抽象类即有纯虚函数的类不能被实例化。）中这个表被分配在了这个实例的内存中（注：一个类的虚函数表是静态的，也就是说对这个类的每个实例，他的虚函数表的是固定的，不会为每个实例生成一个相应的虚函数表。），所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。
这里我们着重看一下这张虚函数表。在C++的标准规格说明书中说到，编译器必需要保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证正确取到虚函数的偏移量）。 这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。
 
假设我们有这样的一个类：
class Base {
public:
virtual void f() { cout && "Base::f" && }
virtual void g() { cout && "Base::g" && }
virtual void h() { cout && "Base::h" && }
};
按照上面的说法，我们可以通过Base的实例来得到Base的虚函数表。 下面是实际例程：
{
...
typedef void(*Fun)(void);
B
Fun pFun = NULL;
cout && "虚函数表地址：" && (int*)(&b) &&
cout && "虚函数表 — 第一个函数地址：" && (int*)*(int*)(&b) &&
// Invoke the first virtual function
pFun = (Fun)*((int*)*(int*)(&b));
pFun();
...
}
实际运行经果如下(Windows XP+VS2003, Linux 2.6.22 + GCC 4.1.3) ：
虚函数表地址：0012FED4
虚函数表 — 第一个函数地址：
Base::f
 
　　通过这个示例，我们可以看到，我们可以通过强行把&b转成int *，取得虚函数表的地址，然后，再次取址就可以得到第一个虚函数的地址了，也就是Base::f()，这在上面的程序中得到了验证（把int* 强制转成了函数指针）。通过这个示例，我们就可以知道如果要调用Base::g()和Base::h()，其代码如下：
(Fun)*((int*)*(int*)(&b)+0); // Base::f()
(Fun)*((int*)*(int*)(&b)+1); // Base::g()
(Fun)*((int*)*(int*)(&b)+2); // Base::h()
 
画个图解释一下。如下所示：
 
注意：在上面这个图中，我在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“/0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。
在WinXP+VS2003下，这个值是NULL。
而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。
 
下面，我将分别说明“无覆盖”和“有覆盖”时的子类虚函数表的样子。没有覆盖父类的虚函数是毫无意义的。我之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。
一般继承（无虚函数覆盖）
下面，再让我们来看看继承时的虚函数表是什么样的。假设有如下所示的一个继承关系：
 
请注意，在这个继承关系中，子类没有重写任何父类的函数。那么，在派生类的实例的虚函数表如下所示：
对于实例：D 的虚函数表如下： （overload（重载） 和 override（重写），重载就是所谓的名同而签名不同，重写就是对子类对虚函数的重新实现。）
 
我们可以看到下面几点：
1）虚函数按照其声明顺序放于表中。
2）父类的虚函数在子类的虚函数前面。
 
一般继承（有虚函数覆盖）
覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。下面，我们来看一下，如果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，我们有下面这样的一个继承关系。
 
为了让大家看到被继承过后的效果，在这个类的设计中，我只覆盖了父类的一个函数：f()。那么，对于派生类的实例的虚函数表会是下面的样子：
 
我们从表中可以看到下面几点，
1）覆盖的f()函数被放到了子类虚函数表中原来父类虚函数的位置。
2）没有被覆盖的函数依旧。
这样，我们就可以看到对于下面这样的程序，
Base *b = new Derive();
b-&f();
由b所指的内存中的虚函数表（子类的虚函数表）的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。
多重继承（无虚函数覆盖）
下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有覆盖父类的函数。
 
对于子类实例中的虚函数表，是下面这个样子：
 
我们可以看到：
1） 每个父类都有自己的虚表。
2） 子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）
这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。
多重继承（有虚函数覆盖）
下面我们再来看看，如果发生虚函数覆盖的情况。
下图中，我们在子类中覆盖了父类的f()函数。
 
下面是对于子类实例中的虚函数表的图：
 
我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以用任一个父类指针来指向子类，并调用子类的f()了。如：
D
Base1 *b1 = &d;
Base2 *b2 = &d;
Base3 *b3 = &d;
b1-&f(); //Derive::f()
b2-&f(); //Derive::f()
b3-&f(); //Derive::f()
b1-&g(); //Base1::g()
b2-&g(); //Base2::g()
b3-&g(); //Base3::g()
 
 
3.安全性
每次写C++的文章，总免不了要批判一下C++。这篇文章也不例外。通过上面的讲述，相信我们对虚函数表有一个比较细致的了解了。水可载舟，亦可覆舟。下面，让我们来看看我们可以用虚函数表来干点什么坏事吧。
 
尝试：通过父类型的指针（指向子类对象）访问子类自己的虚函数
我们知道，子类没有重载父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重载的。虽然在上面的图中我们可以看到子类的虚表中有Derive自己的虚函数，但我们根本不可能使用基类的指针来调用子类的自有虚函数：
Base1 *b1 = new Derive();
b1-&f1(); //编译出错
任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法，所以，这样的程序根本无法编译通过。
但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。
 
尝试：通过父类型的指针（指向子类对象）访问父类的non-public虚函数
另外，如果父类的虚函数是private或是protected的，但这些非public的虚函数同样会存在于子类虚函数表中，所以我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数，这是很容易做到的。
如：
class Base {
private:
virtual void f() { cout && "Base::f" && }
};
 
class Derive : public Base{
};
typedef void(*Fun)(void);
void main() {
D
Fun pFun = (Fun)*((int*)*(int*)(&d)+0);
pFun();
}
4.结束语
C++这门语言是一门Magic的语言，对于程序员来说，我们似乎永远摸不清楚这门语言背着我们在干了什么。需要熟悉这门语言，我们就必需要了解C++里面的那些东西，需要去了解C++中那些危险的东西。不然，这是一种搬起石头砸自己脚的编程语言。
 
注:原文链接
免责声明：本站部分内容、图片、文字、视频等来自于互联网，仅供大家学习与交流。相关内容如涉嫌侵犯您的知识产权或其他合法权益，请向本站发送有效通知，我们会及时处理。反馈邮箱&&&&。
学生服务号
在线咨询，奖学金返现，名师点评，等你来互动1.&虚函数和纯虚函数可以定义在同一个类(class)中，含有纯虚函数的类被称为抽象类(abstract&class)，而只含有虚函数的类(class)不能被称为抽象类(abstract&class)。
2.&虚函数可以被直接使用，也可以被子类(sub&class)重载以后以多态的形式调用，而纯虚函数必须在子类(sub&class)中实现该函数才可以使用，因为纯虚函数在基类(base&class)只有声明而没有定义。
3.&虚函数和纯虚函数都可以在子类(sub&class)中被重载，以多态的形式被调用。
4.&虚函数和纯虚函数通常存在于抽象基类(abstract&base&class&-ABC)之中，被继承的子类重载，目的是提供一个统一的接口。
5.&虚函数的定义形式：virtual&{method&body}
　　纯虚函数的定义形式：virtual&{&}&=&0;
在虚函数和纯虚函数的定义中不能有static标识符，原因很简单，被static修饰的函数在编译时候要求前期bind,然而虚函数却是动态绑定(run-time&bind)，而且被两者修饰的函数生命周期(life&recycle)也不一样。
6.&虚函数必须实现，如果不实现，编译器将报错，错误提示为：
error&LNK****:&unresolved&external&symbol&"public:&virtual&void&__thiscallClassName::virtualFunctionName(void)"
7.&对于虚函数来说，父类和子类都有各自的版本。由多态方式调用的时候动态绑定。
8.&实现了纯虚函数的子类，该纯虚函数在子类中就编程了虚函数，子类的子类即孙子类可以覆盖
该虚函数，由多态方式调用的时候动态绑定。
9.&虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的
10.&多态性指相同对象收到不同消息或不同对象收到相同消息时产生不同的实现动作。C++支持两种多态性：编译时多态性，运行时多态性。a.编译时多态性：通过重载函数实现b&运行时多态性：通过虚函数实现。
11.&如果一个类中含有纯虚函数，那么任何试图对该类进行实例化的语句都将导致错误的产生，因为抽象基类(ABC)是不能被直接调用的。必须被子类继承重载以后，根据要求调用其子类的方法。
1 　　//father class
3 　　class Virtualbase
7 　　public:
9 　　virtual void Demon()= 0; //prue virtual function
11 　　virtual void Base() {cout&&"this is farther class"&};
15 　　//sub class
17 　　class SubVirtual :public Virtualbase
21 　　public:
23 　　void Demon() { cout&&" this is SubVirtual!"&
25 　　void Base() { cout&&"this is subclass Base"&
31 　　instance class and sample
35 　　void main()
39 　　Virtualbase* inst = new SubVirtual(); //multstate pointer
41 　　inst-&Demon();
43 　　inst-&Base();
45 　　// inst = new Virtualbase();
47 　　// inst-&Base()
49 　　return ;
这篇文章分析了虚函数的底层实现，大家可以看看。
这篇讲的还算简单明了吧。
阅读(...) 评论()C++虚函数及虚函数表解析
已有 135 次阅读
|系统分类:
　　中心提示：虚函数必需是类的非静态成员函数(且非结构函数)， 其访问权限是public（可以定义为privateorproteceted, 但是关于多态来说， 在基类的类定义中定义虚函数的普通形式　　虚函数的定义：　　虚函数必需是类的非静态成员函数(且非结构函数)， 其访问权限是public（可以定义为privateorproteceted, 没有意义。 ）， 在基类的类定义中定义虚函数的普通形式：　　virtual函数前往值类型虚函数名（形参表）　　虚函数的作用是实现静态联编， 也就是在程序的运转阶段静态地选择适宜的成员函数， 　　可以在基类的派生类中对虚函数重新定义（形式也是：virtual函数前往值类型虚函数名（形参表）{函数体}）， 以实现一致的接口， 当程序发现虚函数名前的关键字virtual后， 会自动将其作为静态联编处理， 　　实现静态联编需要三个条件：　　1、必需把需要静态联编的行为定义为类的公共属性的虚函数。 普通表现为一个类从另一个类公有派生而来。 　　3、必需先使用基类指针指向子类型的对象， 然后直接或许直接使用基类指针调用虚函数。 ?）非类的成员函数不能定义为虚函数， 但可以将析构函数定义为虚函数。 实践上， 因为， 当应用delete删除一个指向派生类定义的对象指针时， 系统会调用相应的类的析构函数。 　　??）只需要在声明函数的类体中使用关键字“virtual”将函数声明为虚函数， 而定义函数时不需要使用关键字“virtual”。 　　?　　为什么虚函数必需是类的成员函数：　　虚函数诞生的目的就是为了实现多态， 在类外定义虚函数毫无实践用途。 那么它就是静态绑定的， 这与静态成员函数的定义（：在内存中只要一份拷贝；经过类名或对象援用访问静态成员）本身就是相矛盾的。 　　为什么结构函数不能为虚函数：　　因为假如结构函数为虚函数的话， 而执行期则需要对象已经树立， 在承继体系中， 其目的就在于确保对象能够成功地构建。 结构函数同时承当着虚函数表的树立， 假如它本身都是虚函数的话， 当基类的析构函数外部有虚函数时， 又如何工作呢？与结构函数相反， 行为相反， 缘由是不一样的。 结构函数只能调用“局部”版本， 是因为调用时还没有派生类版本的信息。 析构函数则是因为派生类版本的信息已经不牢靠了。 我们知道， 析构函数的调用顺序与结构函数相反， 其派生类的析构函数已经被调用了， 相应的数据也已被丧失， 就相当于对一些不牢靠的数据进行操作， 因而， 在析构函数中， 关于多态， 简而言之就是用父类型别的指针指向其子类的实例， 然后经过父类的指针调用实践子类的成员函数。 说白了就是试图使用不变的代码(Or不变的接口)来实现可变的算法。 比如：模板技术， RTTI技术， 要么是试图做到在编译时决议， 要么试图做到运转时决议。 　　关于虚函数的使用方法， 我在这里不做过多的阐述。 　　当然， 相反的文章在网上也出现过一些了， 没有图片， 不利于学习和阅读， 所以这是我想写下这篇文章的缘由。 　　言归正传， 让我们一同进入虚函数的世界。 简称为V-Table。 主是要一个类的虚函数的地址表， 这张表处理了承继、覆盖的问题， ）中这个表被分配在了这个实例的内存中（注：一个类的虚函数表是静态的， 也就是说对这个类的每个实例， ）， 所以， 当我们用父类的指针来操作一个子类的时候， 这张虚函数表就显得由为重要了， 指明了实践所应该调用的函数。 　　这里我们着重看一下这张虚函数表。 编译器必需要保证虚函数表的指针存在于对象实例中最后面的地位（这是为了保证正确取到虚函数的偏移量）。 这意味着我们经过对象实例的地址失掉这张虚函数表， 并调用相应的函数。 　　假设我们有这样的一个类：　　依照下面的说法， 我们可以经过Base的实例来失掉Base的虚函数表。 我们可以看到， 我们可以经过强行把&b转成int， 取得虚函数表的地址， 然后， 再次取址就可以失掉第一个虚函数的地址了， 也就是Base::f()， 这在下面的程序中失掉了验证（把int强制转成了函数指针）。 经过这个示例， 我们就可以知道假如要调用Base::g()和Base::h()， 如下所示：　　注意：在下面这个图中， 这是虚函数表的结束结点， 就像字符串的结束符“\0”一样， 　　而在　　下面， 我之所以要讲述没有覆盖的情况， 在比较之下， 我们可以愈加清楚地知道其外部的详细实现。 　　普通承继（无虚函数覆盖）　　下面， 再让我们来看看承继时的虚函数表是什么样的。 假设有如下所示的一个承继关系：　　请注意， 子类没有重写任何父类的函数。 那么， ）　　我们可以看到下面几点：　　1）虚函数依照其声明顺序放于表中。 　　2）父类的虚函数在子类的虚函数后面。 　　普通承继（有虚函数覆盖）　　覆盖父类的虚函数是很显然的事情， 虚函数就变得毫有意义。 下面， 会是一个什么样子？假设， 我们有下面这样的一个承继关系。 　　1）覆盖的f()函数被放到了子类虚函数表中原来父类虚函数的地位。 　　这样， 我们就可以看到关于下面这样的程序， 　　由b所指的内存中的虚函数表（子类的虚函数表）的f()的地位已经被Derive::f()函数地址所取代， 是Derive::f()被调用了。 这就实现了多态。 　　多重承继（无虚函数覆盖）　　下面， 再让我们来看看多重承继中的情况， 假设有下面这样一个类的承继关系。 　　2）子类的成员函数被放到了第一个父类的表中。 （所谓的第C++一个父类是依照声明顺序来判别的）　　这样做就是为了处理不同的父类类型的指针指向同一个子类实例， 　　多重承继（有虚函数覆盖）　　下面我们再来看看， 假如发作虚函数覆盖的情况。 三个父类虚函数表中的f()的地位被交流成了子类的函数指针。 这样， 并调用子类的f()了。 总免不了要批判一下C++。 这篇文章也不例外。 让我们来看看我们可以用虚函数表来干点什么好事吧。 但我们根本不能够使用基类的指针来调用子类的自有虚函数：　　任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法， 这样的程序根本无法编译经过。 我们可以经过指针的方式访问虚函数表来达到违反C++语义的行为。 　　二、尝试：经过父类型的指针（指向子类对象）访问父类的non-public虚函数　　另外， 但这些非public的虚函数异样会存在于子类虚函数表中， 这是很容易做到的。 　　如：　　结束语　　C++这门语言是一门Magic的语言， 关于程序员来说， 我们似乎永远摸不清楚这门语言背着我们在干了什么。 需要熟习这门语言， 需要去了解C++中那些风险的东西。 不然， 这是一种搬起石头砸自己脚的编程语言。
转载本文请联系原作者获取授权，同时请注明本文来自李飞科学网博客。链接地址：
上一篇：下一篇：
当前推荐数：0
评论 ( 个评论)
扫一扫，分享此博文
作者的其他最新博文
热门博文导读
Powered by
Copyright &