【转】面向对象多态的理解

     最近老师一直讲起虚函数表和多态，在网上搜了很多文章，结合老师的课程暂时入了门，把看到的一些好文章转过来，方便以后查阅，有不对的地方，欢迎指正！

     参考文章地址：http://blog.csdn.net/haoel/article/details/1948051/

                        http://blog.sina.com.cn/s/blog_68ff96b70101cmnz.html

一、多态 

     多态性可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。多态(polymorphisn)，字面意思多种形状。

     C++多态性是通过虚函数来实现的，虚函数允许子类重新定义成员函数，而子类重新定义父类的做法称为覆盖(override)，或者称为重写。（这里我觉得要补充，重写的话可以有两种，直接重写成员函数和重写虚函数，只有重写了虚函数的才能算作是体现了C++多态性）而重载则是允许有多个同名的函数，而这些函数的参数列表不同，允许参数个数不同，参数类型不同，或者两者都不同。编译器会根据这些函数的不同列表，将同名的函数的名称做修饰，从而生成一些不同名称的预处理函数，来实现同名函数调用时的重载问题。但这并没有体现多态性。

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

     那么多态的作用是什么呢，封装可以使得代码模块化，继承可以扩展已存在的代码，他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说，不论传递过来的究竟是那个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。、

二、C++中的虚函数

     C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。

     对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）和一个指向虚函数表的指针（vptr）来实现的。虚函数表，简称为vtbl，虚函数表表对实现多态起着至关重要的作用。在这个表中，主要保存了一个类中的虚函数的地址，这张表解决了继承、覆盖的问题，保证其内容能真实反应实际的函数。每一个包含虚函数的类的实例都包含一个vptr指针，指向虚函数表的首地址。我们可以通过这个指针找到要访问的虚函数的，完成虚函数的调用主要包括：找到虚函数表的首地址（vptr），通过cptr找到要使用虚函数地址，调用虚函数。那么使用虚函数大家总要考虑效率的问题，实际上为了提高效率，C++的编译器是保证虚函数表的指针存在于对象实例中最前面的位置，这是为了保证取到虚函数表的有最高的性能，这意味着我们通过对象实例的地址得到这张虚函数表，然后通过遍历表就可以找到其中的虚函数的地址，然后调用相应的函数。

三、多态的实现原理

     1. 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。
     2. 存在虚函数的类都有一个一维的虚函数表叫做虚表。类的对象有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。
     3. 多态性是一个接口多种实现，是面向对象的核心。分为类的多态性和函数的多态性。
     4. 多态用虚函数来实现，结合动态绑定。
     5. 纯虚函数是虚函数再加上= 0。
     6. 抽象类是指包括至少一个纯虚函数的类。

我们先看一段代码

#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 fh;  
       animal *pAn=&fh; // 隐式类型转换  
       pAn->breathe();  
}

     这段代码的输出是 animal breath 。定义了一个fish的对象fh，然后将fh的地址指向了animal类的指针变量pAn。这里输出了 animal breath ，而不是fish bubble ，分析原因：

1、编译器的角度

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

2、 内存模型的角度

     下面给出fish的内存模型，下图：

     我们构造fish类的对象时，首先要调用animal类的构造函数去构造animal类的对象，然后才调用fish类的构造函数完成自身部分的构造，从而拼接出一个完整的fish对象。当我们将fish类的对象转换为animal类型时，该对象就被认为是原对象整个内存模型的上半部分，也就是上图中的“animal的对象所占内存”。那么当我们利用类型转换后的对象指针去调用它的方法时，当然也就是调用它所在的内存中的方法。因此，输出animal breathe，也就顺理成章了。

     正如我们所想，我们想要调用fish中的breath函数，这就需要虚函数来实现了。

     前面输出的结果是因为编译器在编译的时候，就已经确定了对象调用的函数的地址，要解决这个问题就要使用迟绑定（late binding）技术。当编译器使用迟绑定时，就会在运行时再去确定对象的类型以及正确的调用函数。而要让编译器采用迟绑定，就要在基类中声明函数时使用virtual关键字，这样的函数我们称为虚函数。一旦某个函数在基类中声明为virtual，那么在所有的派生类中该函数都是virtual，而不需要再显式地声明为virtual。

下面修改代码，将animal类中的breathe()函数声明为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 fh;  
       animal *pAn=&fh; // 隐式类型转换  
       pAn->breathe();  
}

     输出为fish bubble，具体原因如下：

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

     那么如何定位虚表呢？编译器另外还为每个类的对象提供了一个虚表指针（即vptr），这个指针指向了对象所属类的虚表。在程序运行时，根据对象的类型去初始化vptr，从而让vptr正确的指向所属类的虚表，从而在调用虚函数时，就能够找到正确的函数。对于例2的程序，由于pAn实际指向的对象类型是fish，因此vptr指向的fish类的vtable，当调用pAn->breathe()时，根据虚表中的函数地址找到的就是fish类的breathe()函数。

     正是由于每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了虚表指针的正确初始化是非常重要的。换句话说，在虚表指针没有正确初始化之前，我们不能够去调用虚函数。那么虚表指针在什么时候，或者说在什么地方初始化呢？

     答案是在构造函数中进行虚表的创建和虚表指针的初始化。还记得构造函数的调用顺序吗，在构造子类对象时，要先调用父类的构造函数，此时编译器只“看到了”父类，并不知道后面是否后还有继承者，它初始化父类对象的虚表指针，该虚表指针指向父类的虚表。当执行子类的构造函数时，子类对象的虚表指针被初始化，指向自身的虚表。对于例2的程序来说，当fish类的fh对象构造完毕后，其内部的虚表指针也就被初始化为指向fish类的虚表。在类型转换后，调用pAn->breathe()，由于pAn实际指向的是fish类的对象，该对象内部的虚表指针指向的是fish类的虚表，因此最终调用的是fish类的breathe()函数。
     要注意：对于虚函数调用来说，每一个对象内部都有一个虚表指针，该虚表指针被初始化为本类的虚表。所以在程序中，不管你的对象类型如何转换，但该对象内部的虚表指针是固定的，所以呢，才能实现动态的对象函数调用，这就是C++多态性实现的原理。

3、总结（基类有虚函数）：

    1. 每一个类都有虚表。
    2. 虚表可以继承，如果子类没有重写虚函数，那么子类虚表中仍然会有该函数的地址，只不过这个地址指向的是基类的虚函数实现。如果基类有3个虚函数，那么基类的虚表中就有三项（虚函数地址），派生类也会有虚表，至少有三项，如果重写了相应的虚函数，那么虚表中的地址就会改变，指向自身的虚函数实现。如果派生类有自己的虚函数，那么虚表中就会添加该项。
    3. 派生类的虚表中虚函数地址的排列顺序和基类的虚表中虚函数地址排列顺序相同。

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

     当设计到多态性的时候，采用了虚函数和动态绑定，此时的调用就不会在编译时候确定而是在运行时确定。不在单独考虑指针/引用的类型而是看指针/引用的对象的类型来判断函数的调用，根据对象中虚指针指向的虚表中的函数的地址来确定调用哪个函数。

四、虚函数表的实现

     可以看看虚函数表的图是怎么画的：

      都知道，多态是通过继承实现的，那么我们要说说虚函数继承的问题。继承就涉及到了虚函数的覆盖了，实际上不被覆盖的虚函数和多态又有什么联系呢？这里我们讨论有覆盖的虚函数表是什么样的，假设存在下面的继承关系：

     看看虚函数表示什么样的：

     可以发现，Base::f（）被覆盖了，这样若把Derive的实例赋值给一个基类Base指针pBase，通过pBase->f()；则访问的是子类中的f（）也就是完成了多态。那么虚函数表中的内容到底是怎么样的呢？可以看看下面的四句话就会明白！

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

     2.父类的虚函数在子类的虚函数前面。

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

     4.没有被覆盖的函数依旧。