C++小结:多态(1) --实现原理

多      态

     1、动态多态的实现原理

    2、多态的类别及实现方法

    3、动态多态的四种情况

（1）动态多态实现原理（类的多态性、运行时多态）

1.1 多态:一个接口，多种方法

1.2 动态多态主要由继承和虚函数实现，通过父类的指针或引用，指向子类的对象，在调用函数时可以调用到正确的版本

1.3 存在虚函数的类都有一个一维的虚函数表叫做虚表。类的对象有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的

1.4 虚函数被调用的时候，到底调用哪个版本，在编译的时候无法确定，只有在执行时才能确定，称为动态绑定

1.5 纯虚函数，没有函数体，不需要实现，在子类中实现纯虚函数的具体功能（虚函数 = 0）

1.6 拥有纯虚函数的类，称为抽象类，抽象类提供了不同种类对象的一个通用接口。

1.7 不能创建抽象类的对象，因为抽象类里面的纯虚函数没有实现。

举例（无虚函数）

#include <iostream>
using namespace std;  
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 f;  
       Animal *a=&f; // 隐式类型转换  
       a -> breathe();  
}  

输出：Animal breathe

 一般情况下（没有涉及virtual函数），当我们用一个指针/引用调用一个函数的时候，被调用的函数是取决于这个指针/引用的类型。即如果这个指针/引用是基类对象的指针/引用就调用基类的方法；如果指针/引用是派生类对象的指针/引用就调用派生类的方法，当然如果派生类中没有此方法，就会向上到基类里面去寻找相应的方法。这些调用在编译阶段就确定了。

a是Animal的指针，指向子类Fish的对象f，使用a调用breathe,则调用的是父类版本，原因如下：

1、编译角度

C++编译器在编译的时候，要确定每个对象调用的函数（此时要求此函数是非虚函数）的地址，这称为早期绑定（early binding），当我们将Fish类的对象f的地址赋给a时，C++编译器进行了类型转换，此时C++编译器认为指针变量a保存的就是Animal对象的地址。当在main()函数中执行a->breathe()时，调用的当然就是Animal的breathe函数。

2、内存角度

Fish对象内存模型，如下图所示：

       构造Fish类的对象时，首先要调用Animal类的构造函数去构造继承自Animal类的对象，然后才调用Fish类的构造函数完成自身扩展部分的构造，从而构造出一个完整的Fish对象。当将Fish类的对象转换为Animal类型时，该对象就被认为是原对象整个内存模型的上半部分，也就是图中的“animal的对象所占内存”。那么当利用类型转换后的对象指针去调用它的方法时，当然也就是调用它所在的内存中的方法。因此，输出Animal breathe。
++++++++++++++++++++-------------------------------+++++++++++++++++++++++
        前面输出的结果是因为编译器在编译的时候，就已经确定了对象调用的函数的地址，要解决这个问题就要使用迟绑定（late binding）技术。当编译器使用迟绑定时，就会在运行时再去确定对象的类型以及正确的调用函数。而要让编译器采用迟绑定，就要在基类中声明函数时使用virtual关键字，这样的函数称为虚函数。一旦某个函数在基类中声明为virtual，那么在所有的派生类中该函数都是virtual，而不需要再显式地声明为virtual。

举例（有虚函数）

#include <iostream>
using namespace std;  
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 f;  
       Animal *a=&f; // 隐式类型转换  
       a -> breathe();  
}  

编译器在编译的时候，发现Animal类中有虚函数，此时编译器会为每个包含虚函数的类创建一个虚表（即vtable），该表是一个一维数组，在这个数组中存放每个虚函数的地址。对于上例程序，Animal和Fish类都包含了一个虚函数breathe()，因此编译器会为这两个类都建立一个虚表，（即使子类里面没有virtual函数，但是其父类里面有，所以子类中也有了）如下图所示:

        那么如何定位虚表呢？编译器另外还为每个类的对象提供了一个虚表指针（即vptr），这个指针指向了对象所属类的虚表。在程序运行时，根据对象的类型去初始化vptr，从而让vptr正确的指向所属类的虚表，从而在调用虚函数时，就能够找到正确的函数。由于a实际指向的对象类型是Fish，因此vptr指向Fish类的vtable，当调用a->breathe()时，根据虚表中的函数地址找到的就是Fish类的breathe()函数。
       正是由于每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了虚表指针的正确初始化是非常重要的。换句话说，在虚表指针没有正确初始化之前，我们不能够去调用虚函数。那么虚表指针在什么时候，或者说在什么地方初始化呢？
       答案是在构造函数中进行虚表的创建和虚表指针的初始化。在构造子类对象时，要先调用父类的构造函数，此时编译器只“看到了”父类，并不知道后面是否还有继承者，它初始化父类对象的虚表指针，该虚表指针指向父类的虚表。当执行子类的构造函数时，子类对象的虚表指针被初始化，指向自身的虚表。当Fish类的f对象构造完毕后，其内部的虚表指针也就被初始化为指向Fish类的虚表。在类型转换后，调用a->breathe()，由于a实际指向的是Fish类的对象，该对象内部的虚表指针指向的是Fish类的虚表，因此最终调用的是Fish类的breathe()函数。

要注意：对于虚函数调用来说，每一个对象内部都有一个虚表指针，该虚表指针被初始化为本类的虚表。所以在程序中，不管你的对象类型如何转换，但该对象内部的虚表指针是固定的，所以才能实现动态的对象函数调用，这就是C++多态性实现的原理。