C++多态性（二）

C++多态性
    两种表现形式：静态多态性 通过一般的函数重载来实现。
                             动态多态性 通过虚函数来实现。

    静态多态性比较简单，主要动态多态性比较难理解。

    动态多态性有两个条件：
    1、在基类中必须使用虚函数、纯虚函数 
   2、调用函数时要使用基类的指针或引用。

    只要在基类的成员函数前加上virtual，该成员函数就是虚函数，从基类派生出来的类的同名成员函数，不管前面是否有virtual，同样是虚函数，在虚函数的实现时，前面不能加virtual。

    内联函数不能是虚函数，因为内联函数不能在运行时动态确定位置，即使虚函数在类的内部定义，但在编译的时候仍然看做是非内联的。
    只有类的成员函数才能声明为虚函数，普通函数不能声明为虚函数。
    静态成员函数不能是虚函数。

    虚函数的原理:

     普通函数的处理：
     一个特定的函数都会映射到特定的代码，无论时编译阶段还是连接阶段，编译器都能计算出这个函数的地址，调用即可。

    虚函数的处理：
    被调用的函数不仅依据调用的特定函数，还依据调用的对象的种类。通常是由虚函数表(vtable)来实现的。

    虚函数表的结构：
    它是一个函数指针表，每一个表项都指向一个函数。任何一个包含虚函数的类都会有这样一张表。需要注意的是vtable只包含虚函数的指针，没有函数体。实现上是一个函数指针的数组。

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

    每一个类只有唯一的一个vtable，不是每个对象都有一个vtable，每个对象都有一个指针，这个指针指向该类的vtable（当然，前提是这个类包含虚函数）。

    那么，每个对象只额外增加了一个指针的大小，一般说来是4字节。
    在类对象的内存布局中，首先是该类的vtable指针，然后才是对象数据。

    在通过对象指针调用一个虚函数时，编译器生成的代码将先获取对象类的vtable指针，然后调用vtable中对应的项。

    对于通过对象指针调用的情况，在编译期间无法确定指针指向的是基类对象还是派生类对象，或者是哪个派生类的对象

    但是在运行期间执行到调用语句时，这一点已经确定，编译后的调用代码能够根据具体对象获取正确的vtable，调用正确的虚函数，从而实现多态性。

下面是通过基类的指针来调用虚函数时，所发生的一切：
step 1:开始执行调用 pA->run();（pA为基类指针,这里能判断到底是哪个对象）
step 2:取得对象的vtable的指针
step 3:从vtable那里获得函数入口的偏移量，即得到要调用的函数的指针
step 4:根据vtable的地址找到函数，并调用函数。
step 1和step 4对于一般函数是一样的，虚函数只是多了step 2和step 3。

   基类和派生类是共用一表,还是各有各的表(物理上)？

   答：基类和派生类是各有各的表,也就是说他们的物理地址是分开的,基类和派生类的虚表的唯一关联是:当派生类没有实现基类虚函数的重载时,派生类会直接把自己表的该函数地址值写为基类的该函数地址值.

C++的多态性实现机制剖析 
――即VC++视频第三课this指针详细说明 
作者：孙鑫   时间：2006年1月12日星期四 
要更好地理解C++的多态性，我们需要弄清楚函数覆盖的调用机制，因此，首先我们介绍一下函数的覆盖。 
1. 函数的覆盖 
我们先看一个例子： 
例1-   1 
#include   <iostream.h> 
class   animal 
{ 
public: 
void   sleep() 
{ 
cout < < "animal   sleep " < <endl; 
} 
void   breathe() 
{ 
cout < < "animal   breathe " < <endl; 
} 
}; 
class   fish:public   animal 
{ 
public: 
void   breathe() 
{ 
cout < < "fish   bubble " < <endl; 
} 
}; 
void   main() 
{ 
fish   fh; 
animal   *pAn=&fh; 
pAn-> breathe(); 
} 
注意，在例1-1的程序中没有定义虚函数。考虑一下例1-1的程序执行的结果是什么？ 
答案是输出：animal   breathe 
在类fish中重写了breathe()函数，我们可以称为函数的覆盖。在main()函数中首先定义了一个fish对象fh，接着定义了一个指向animal的指针变量pAn，将fh的地址赋给了指针变量pAn，然后利用该变量调用pAn-> breathe()。许多学员往往将这种情况和C++的多态性搞混淆，认为fh实际上是fish类的对象，应该是调用fish类的breathe()，输出“fish   bubble”，然后结果却不是这样。下面我们从两个方面来讲述原因。 
1、 编译的角度 
C++编译器在编译的时候，要确定每个对象调用的函数的地址，这称为早期绑定（early   binding），当我们将fish类的对象fh的地址赋给pAn时，C++编译器进行了类型转换，此时C++编译器认为变量pAn保存就是animal对象的地址。当在main()函数中执行pAn-> breathe()时，调用的当然就是animal对象的breathe函数。 
2、 内存模型的角度 
我们给出了fish对象内存模型，如下图所示： 


图1-   1   fish类对象的内存模型 

我们构造fish类的对象时，首先要调用animal类的构造函数去构造animal类的对象，然后才调用fish类的构造函数完成自身部分的构造，从而拼接出一个完整的fish对象。当我们将fish类的对象转换为animal类型时，该对象就被认为是原对象整个内存模型的上半部分，也就是图1-1中的“animal的对象所占内存”。那么当我们利用类型转换后的对象指针去调用它的方法时，当然也就是调用它所在的内存中的方法。因此，出现图2.13所示的结果，也就顺理成章了。 
2. 多态性和虚函数 
正如很多学员所想，在例1-1的程序中，我们知道pAn实际指向的是fish类的对象，我们希望输出的结果是鱼的呼吸方法，即调用fish类的breathe方法。这个时候，就该轮到虚函数登场了。 
前面输出的结果是因为编译器在编译的时候，就已经确定了对象调用的函数的地址，要解决这个问题就要使用迟绑定（late   binding）技术。当编译器使用迟绑定时，就会在运行时再去确定对象的类型以及正确的调用函数。而要让编译器采用迟绑定，就要在基类中声明函数时使用virtual关键字（注意，这是必须的，很多学员就是因为没有使用虚函数而写出很多错误的例子），这样的函数我们称为虚函数。一旦某个函数在基类中声明为virtual，那么在所有的派生类中该函数都是virtual，而不需要再显示的声明为virtual。 
下面修改例1-1的代码，将animal类中的breathe()函数声明为virtual，如下： 
例1-   2 
#include   <iostream.h> 
class   animal 
{ 
public: 
void   sleep() 
{ 
cout < < "animal   sleep " < <endl; 
} 
virtual   void   breathe() 
{ 
cout < < "animal   breathe " < <endl; 
} 
}; 
class   fish:public   animal 
{ 
public: 
void   breathe() 
{ 
cout < < "fish   bubble " < <endl; 
} 
}; 
void   main() 
{ 
fish   fh; 
animal   *pAn=&fh; 
pAn-> breathe(); 
} 
大家可以再次运行这个程序，你会发现结果是“fish   bubble”，也就是根据对象的类型调用了正确的函数。 
那么当我们将breathe()声明为virtual时，在背后发生了什么呢？ 
编译器在编译的时候，发现animal类中有虚函数，此时编译器会为每个包含虚函数的类创建一个虚表（即vtable），该表是一个一维数组，在这个数组中存放每个虚函数的地址。对于例1-2的程序，animal和fish类都包含了一个虚函数breathe()，因此编译器会为这两个类都建立一个虚表，如下图所示： 


图1-   2   animal类和fish类的虚表 
那么如何定位虚表呢？编译器另外还为每个类提供了一个虚表指针（即vptr），这个指针指向了对象的虚表。在程序运行时，根据对象的类型去初始化vptr，从而让vptr正确的指向所属类的虚表，从而在调用虚函数时，就能够找到正确的函数。对于例1-2的程序，由于pAn实际指向的对象类型是fish，因此vptr指向的fish类的vtable，当调用pAn-> breathe()时，根据虚表中的函数地址找到的就是fish类的breathe()函数。 
正是由于每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了虚表指针的正确初始化是非常重要的。换句话说，在虚表指针没有正确初始化之前，我们不能够去调用虚函数。那么虚表指针在什么时候，或者说在什么地方初始化呢？ 
答案是在构造函数中进行虚表的创建和虚表指针的初始化。还记得构造函数的调用顺序吗，在构造子类对象时，要先调用父类的构造函数，此时编译器只“看到了”父类，并不知道后面是否后还有继承者，它初始化父类的虚表指针，该虚表指针指向父类的虚表。当执行子类的构造函数时，子类的虚表指针被初始化，指向自身的虚表。对于例2-2的程序来说，当fish类的fh对象构造完毕后，其内部的虚表指针也就被初始化为指向fish类的虚表。在类型转换后，调用pAn-> breathe()，由于pAn实际指向的是fish类的对象，该对象内部的虚表指针指向的是fish类的虚表，因此最终调用的是fish类的breathe()函数。 
要注意：对于虚函数调用来说，每一个对象内部都有一个虚表指针，该虚表指针被初始化为本类的虚表。所以在程序中，不管你的对象类型如何转换，但该对象内部的虚表指针是固定的，所以呢，才能实现动态的对象函数调用，这就是C++多态性实现的原理。 
总结（基类有虚函数）： 
1、 每一个类都有虚表。 
2、 虚表可以继承，如果子类没有重写虚函数，那么子类虚表中仍然会有该函数的地址，只不过这个地址指向的是基类的虚函数实现。如果基类3个虚函数，那么基类的虚表中就有三项（虚函数地址），派生类也会有虚表，至少有三项，如果重写了相应的虚函数，那么虚表中的地址就会改变，指向自身的虚函数实现。如果派生类有自己的虚函数，那么虚表中就会添加该项。 
3、 派生类的虚表中虚函数地址的排列顺序和基类的虚表中虚函数地址排列顺序相同。 
3. VC视频第三课this指针说明 
我在论坛的VC教学视频版面发了帖子，是模拟MFC类库的例子写的，主要是说明在基类的构造函数中保存的this指针是指向子类的，我们在看一下这个例子： 
例1-   3 
#include   <iostream.h> 

class   base; 

base   *   pbase; 

class   base 
{ 
public: 
base() 
{ 
pbase=this; 

} 
virtual   void   fn() 
{ 
cout < < "base " < <endl; 
} 
}; 

class   derived:public   base 
{ 
void   fn() 
{ 
cout < < "derived " < <endl; 
} 
}; 

derived   aa; 
void   main() 
{ 
pbase-> fn(); 
} 
我在base类的构造函数中将this指针保存到pbase全局变量中。在定义全局对象aa，即调用derived   aa;时，要调用基类的构造函数，先构造基类的部分，然后是子类的部分，由这两部分拼接出完整的对象aa。这个this指针指向的当然也就是aa对象，那么我们main()函数中利用pbase调用fn()，因为pbase实际指向的是aa对象，而aa对象内部的虚表指针指向的是自身的虚表，最终调用的当然是derived类中的fn()函数。 
在这个例子中，由于我的疏忽，在derived类中声明fn()函数时，忘了加public关键字，导致声明为了private（默认为private），但通过前面我们所讲述的虚函数调用机制，我们也就明白了这个地方并不影响它输出正确的结果。不知道这算不算C++的一个Bug，因为虚函数的调用是在运行时确定调用哪一个函数，所以编译器在编译时，并不知道pbase指向的是aa对象，所以导致这个奇怪现象的发生。如果你直接用aa对象去调用，由于对象类型是确定的（注意aa是对象变量，不是指针变量），编译器往往会采用早期绑定，在编译时确定调用的函数，于是就会发现fn()是私有的，不能直接调用。：） 
许多学员在写这个例子时，直接在基类的构造函数中调用虚函数，前面已经说了，在调用基类的构造函数时，编译器只“看到了”父类，并不知道后面是否后还有继承者，它只是初始化父类的虚表指针，让该虚表指针指向父类的虚表，所以你看到结果当然不正确。只有在子类的构造函数调用完毕后，整个虚表才构建完毕，此时才能真正应用C++的多态性。换句话说，我们不要在构造函数中去调用虚函数，当然如果你只是想调用本类的函数，也无所谓。 
4. 参考资料： 
1、文章《在VC6.0中虚函数的实现方法》，作者：backer   ，网址： 
http://www.mybole.com.cn/bbs/dispbbs.asp?boardid=4&id=1012&star=1 
2、书《C++编程思想》   机械工业出版社 
5. 后记 

本想再写详细些，发现时间不够，总是有很多事情，在加上水平也有限，想想还是以后再说吧。不过我相信，这些内容也能够帮助大家很好的理解了。也欢迎网友能够继续补充，大家可以鼓动鼓动backer，让他从汇编的角度再给一个说明，哈哈，别说我说的。 




///////////////////////////////////////////另//////////////
其实这里涉及到的一个概念就是C++   Object   Model。从 <Inside   C++   Object   Model> 我们可以看出，具体的实现是和具体的编译器相关的，而且随着时间的推移，同一个编译器也有所改变。我们所作的很多都是猜测，或者局限于具体的编译器，换个编译器可能就有所不同。 
建议：如果想对C++   Object   Model有全面的了解，看 <Inside   C++   Object   Model> 
如果想了解Visual   C++是怎么实现C++   Object   Model的，这里有一篇文章： <C++   under   the   hood> ，文章的作者就是写Viual   C++   Compiler的作者，应该比较权威。我用Visual   C++测试了一下，具体的实现也确实和文章所说的一致。