c++ 虚函数的实现机制

2012-12-28 10:20 17人阅读 评论(0) 收藏 举报

1、c++实现多态的方法
其实很多人都知道，虚函数在c++中的实现机制就是用虚表和虚指针，但是具体是怎样的呢？从more effecive c++其中一篇文章里面可以知道：是每个类用了一个虚表，每个类的对象用了一个虚指针。具体的用法如下：
class A
{
public:
    virtual void f();
    virtual void g();
private:
    int a
};
class B : public A
{
public:
    void g();
private:
    int b;
};
//A，B的实现省略
因为A有virtual void f（），和g（），所以编译器为A类准备了一个虚表vtableA，内容如下：

A::f 的地址

A::g 的地址

B因为继承了A，所以编译器也为B准备了一个虚表vtableB，内容如下：

A::f 的地址

B::g 的地址

注意：因为B::ｇ是重写了的，所以B的虚表的g放的是B::g的入口地址，但是f是从上面的A继承下来的，所以f的地址是A::f的入口地址。

然后某处有语句 B bB;的时候，编译器分配空间时，除了A的int a，B的成员int b；以外，还分配了一个虚指针vptr，指向B的虚表vtableB，bB的布局如下：

vptr ： 指向B的虚表vtableB

int a： 继承A的成员

int b： B成员

当如下语句的时候：
A *pa = &bB;

pa的结构就是A的布局（就是说用pa只能访问的到bB对象的前两项，访问不到第三项int b）

那么pa->g()中，编译器知道的是，g是一个声明为virtual的成员函数，而且其入口地址放在表格（无论是vtalbeA表还是vtalbeB表）的第2项，那么编译器编译这条语句的时候就如是转换：call *(pa->vptr)[1]（C语言的数组索引从0开始哈~）。
这一项放的是B：：g()的入口地址，则就实现了多态。（注意bB的vptr指向的是B的虚表vtableB）
另外要注意的是，如上的实现并不是唯一的，C++标准只要求用这种机制实现多态，至于虚指针vptr到底放在一个对象布局的哪里，标准没有要求，每个编译器自己决定。我以上的结果是根据g++ 4.3.4经过反汇编分析出来的。

2、两种多态实现机制及其优缺点
除了c++的这种多态的实现机制之外，还有另外一种实现机制，也是查表，不过是按名称查表，是smalltalk等语言的实现机制。这两种方法的优缺点如下：
（1）、按照绝对位置查表，这种方法由于编译阶段已经做好了索引和表项(如上面的call *(pa->vptr[1]） )，所以运行速度比较快;缺点是：当A的virtual成员比较多（比如1000个），而B重写的成员比较少（比如2个），这种时候，B的vtableＢ的剩下的998个表项都是放Ａ中的ｖｉｒｔｕａｌ成员函数的指针，如果这个派生体系比较大的时候，就浪费了很多的空间。
比如：ＧＵＩ库，以ＭＦＣ库为例，ＭＦＣ有很多类，都是一个继承体系；而且很多时候每个类只是１，２个成员函数需要在派生类重写，如果用Ｃ＋＋的虚函数机制，每个类有一个虚表，每个表里面有大量的重复，就会造成空间利用率不高。于是ＭＦＣ的消息映射机制不用虚函数，而用第二种方法来实现多态，那就是：
（２）、按照函数名称查表，这种方案可以避免如上的问题；但是由于要比较名称，有时候要遍历所有的继承结构，时间效率性能不是很高。（关于ＭＦＣ的消息映射的实现，看下一篇文章）

３、总结：
如果继承体系的基类的virtual成员不多，而且在派生类要重写的部分占了其中的大多数时候，用Ｃ＋＋的虚函数机制是比较好的；
但是如果继承体系的基类的virtual成员很多，或者是继承体系比较庞大的时候，而且派生类中需要重写的部分比较少，那就用名称查找表，这样效率会高一些，很多的ＧＵＩ库都是这样的，比如ＭＦＣ，ＱＴ
ＰＳ. 其实，自从计算机出现之后，时间和空间就成了永恒的主题，因为两者在98%的情况下都无法协调，此长彼消；这个就是计算机科学中的根本瓶颈之所在。软件科学和算法的发展，就看能不能突破这对时空权衡了。呵呵

何止计算机科学如此，整个宇宙又何尝不是如此呢？最基本的宇宙之谜，还是时间和空间~

在《深度探索C++对象模型》里，有一个问题，也是去公司面试的时候那些技术人员常问的问题：在C++中，obj是一个类的对象，p是指向obj的指针，该类里面有个数据成员mem，请问obj.mem和p->mem在实现和效率上有什么不同。
答案是：只有一种情况下才有重大差异，该情况必须满足以下3个条件：
（1）、obj 是一个虚拟继承的派生类的对象
（2）、mem是从虚拟基类派生下来的成员
（3）、p是基类类型的指针
当这种情况下，p->mem会比obj.mem多了两个中间层。（也就是说在这种情况下，p->mem比obj.mem要明显的慢，呵呵）
WHY？
如果好奇心比较重的话，请往下看 :)
1、虚基类的使用，和为多态而实现的虚函数不同，是为了解决多重继承的二义性问题。
举例如下：
class A
{
public:
    int a;
};

class B : virtual public A
{
public:
   int b;
};

class C :virtual public A
{
public:
   int c; 
};

class D : public B, public C
{
public:
   int d;
};

上面这种菱形的继承体系中，如果没有virtual继承，那么D中就有两个A的成员int a；继承下来，使用的时候，就会有很多二义性。而加了virtual继承，在D中就只有A的成员int a；的一份拷贝，该拷贝不是来自B，也不是来自C，而是一份单独的拷贝，那么，编译器是怎么实现的呢？？

在回答这个问题之前，先想一下，sizeof(A),sizeof(B),sizeof(C),sizeof(D)是多少？（在32位x86的linux2.6下面，或者在vc2005下面）

在linux2.6下面，结果如下：sizeof(A) = 4; sizeof(B) = 12; sizeof(C) = 12; sizeof(D) = 24

sizeof（B）为什么是12呢，那是因为多了一个指针（这一点和虚函数的实现一样），那个指针是干嘛的呢？

那么sizeof(D)为什么是24呢？那是因为除了继承B中的b，C中的c，A中的a,和D自己的成员d之外，还继承了B，C多出来的2个指针（B和C分别有一个）。再强调一遍，D中的int a不是来自B也不是来自C，而是另外的一份从A直接靠过来的成员。

如果声明了D的对象d： D d；
那么d的内存布局如下：

vb_ptr: 继承自B的指针

int b： 继承自B公有成员

vc_ptr：继承自C的指针

int c： 继承自C的共有成员

int d： D自己的公有成员

int a： 继承自A的公有成员

那么以下的用法会发生什么事呢？
D dD;
B *pb = &dD;
pb->a;

上面说过，dD中的int a不是继承自B的，也不是继承自C的，那么这个B中的pb->a又会怎么知道指向的是dD内存中的第六项呢？

那就是指针vb_ptr的妙用了。原理如下：(其实g++3.4.3的实现更加复杂，我不知道是出于什么考虑，而我这里只说原理，所以把过程和内容简单化了)

首先，vb_ptr指向一个整数的地址，里面放的整数是那个int a的距离dD开始处的位移（在这里vb_ptr指向的地址里面放的是20，以字节为单位）。编译器是这样做的：

首先，找到vb_ptr(这个不用找，因为在g++中，vb_ptr就是B*中的第一项，呵呵)，然后取得vb_ptr指向的地址的内容（这个例子是20），最后把这个内容与指针pb相加，就得到pb->a的地址了。

所以说这种时候，用指针转换多了两个中间层才能找到基类的成员，而且是运行期间。

由此也可以推知dD中的vb_ptr和vc_ptr的内容都是一样的，都是指向同一个地址，该地址就放20（在本例中）

如下的语句呢：

A *pa = &dD;
pa->a = 4;

这个语句不用转换了，因为编译器在编译期间就知道他把A中的成员插在dD中的那个地方了（在本例中是末尾），所以这个语句中的运行效率和dD.a是一样的（至少也是差不多的）

这就是虚基类实现的基本原理。

注意的是：那些指针的位置和基类成员在派生类成员中的内存布局是不确定的，也就是说标准里面没有规定int a必须要放在最后，只不过g++编译器的实现而已。c++标准大概只规定了这套机制的原理，至于具体的实现，比如各成员的排放顺序和优化，由各个编译器厂商自己定~