对c++多态的理解

转自：http://blog.csdn.net/hackbuteer1/article/details/7475622

1 什么是多态？
多态性可以简单的概括为“1个接口，多种方法”，在程序运行的过程中才决定调用的机制
程序实现上是这样，通过父类指针调用子类的函数，可以让父类指针有多种形态。
2 实现机制
举一个例子：
#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();
}
答案是输出：animal breathe
结果分析：
1从编译的角度
C++编译器在编译的时候，要确定每个对象调用的函数的地址，这称为早期绑定（early binding），当我们将fish类的对象fh的地址赋给pAn时，C++编译器进行了类型转换，此时C++编译器认为变量pAn保存的就是animal对象的地址。当在main()函数中执行pAn->breathe()时，调用的当然就是animal对象的breathe函数。
2 内存模型的角度
我们构造fish类的对象时，首先要调用animal类的构造函数去构造animal类的对象，然后才调用fish类的构造函数完成自身部分的构造，从而拼接出一个完整的fish对象。当我们将fish类的对象转换为animal类型时，该对象就被认为是原对象整个内存模型的上半部分，也就是图1-1中的“animal的对象所占内存”。那么当我们利用类型转换后的对象指针去调用它的方法时，当然也就是调用它所在的内存中的方法。因此，输出animal breathe，也就顺理成章了。

为了得到我们想要的结果，就要使用虚函数

前面输出的结果是因为编译器在编译的时候，就已经确定了对象调用的函数的地址，要解决这个问题就要使用迟绑定（late binding）技术。当编译器使用迟绑定时，就会在运行时再去确定对象的类型以及正确的调用函数。而要让编译器采用迟绑定，就要在基类中声明函数时使用virtual关键字（注意，这是必须的，很多学员就是因为没有使用虚函数而写出很多错误的例子），这样的函数我们称为虚函数。一旦某个函数在基类中声明为virtual，那么在所有的派生类中该函数都是virtual，而不需要再显式地声明为virtual。
 
下面我们将上面一段代码进行部分修改

virtual void breathe()
{
cout<<"animal breathe"<<endl;
}
运行结果：fish bubble
结果分析
编译器为每个类的对象提供一个虚表指针，这个指针指向对象所属类的虚表。在程序运行时，根据对象的类型去初始化vptr，从而让vptr正确的指向所属类的虚表，从而在调用虚函数时，就能够找到正确的函数。

    由于pAn实际指向的对象类型是fish，因此vptr指向的fish类的vtable，当调用pAn->breathe()时，根据虚表中的函数地址找到的就是fish类的breathe()函数。

正是由于每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了虚表指针的正确初始化是非常重要的。换句话说，在虚表指针没有正确初始化之前，我们不能够去调用虚函数。那么虚表指针在什么时候，或者说在什么地方初始化呢？
答案是在构造函数中进行虚表的创建和虚表指针的初始化。还记得构造函数的调用顺序吗，在构造子类对象时，要先调用父类的构造函数，此时编译器只“看到了”父类，并不知道后面是否后还有继承者，它初始化父类对象的虚表指针，该虚表指针指向父类的虚表。当执行子类的构造函数时，子类对象的虚表指针被初始化，指向自身的虚表。

     当fish类的fh对象构造完毕后，其内部的虚表指针也就被初始化为指向fish类的虚表。在类型转换后，调用pAn->breathe()，由于pAn实际指向的是fish类的对象，该对象内部的虚表指针指向的是fish类的虚表，因此最终调用的是fish类的breathe()函数。
 

为了更加清楚的说明内存分布：下面详细的介绍内存的分布

1 基类的内存分布情况

请看下面的sample
class A
{
void g(){.....}
};
则sizeof(A)=1；
如果改为如下：
class A
{
public:
    virtual void f()
    {
       ......
    }
    void g(){.....}
}
则sizeof(A)=4! 这是因为在类A中存在virtual function,为了实现多态，每个含有virtual function的类中都隐式包含着一个静态虚指针vfptr指向该类的静态虚表vtable, vtable中的表项指向类中的每个virtual function的入口地址
例如 我们declare 一个A类型的object :
    A c;
    A d;
则编译后其内存分布如下：


    
从 vfptr所指向的vtable可以看出，每个virtual function都占有一个entry,例如本例中的f函数。而g函数因为不是virtual类型，故不在vtable的表项之内。说明：vtab属于类成员静态pointer，而vfptr属于对象pointer
2 继承类的内存分布状况
假设代码如下：
public B:public A
{
public :
    int f() //override virtual function
    {
        return 3;
    }
};
则
A c;
A d;
B e;
编译后，其内存分布如下：

从中我们可以看出,B类型的对象e有一个vfptr指向vtable address：0x00400030 ,而A类型的对象c和d共同指向类的vtable address:0x00400050a
3 动态绑定过程的实现
    我们说多态是在程序进行动态绑定得以实现的，而不是编译时就确定对象的调用方法的静态绑定。
    其过程如下：
    程序运行到动态绑定时，通过基类的指针所指向的对象类型，通过vfptr找到其所指向的vtable，然后调用其相应的方法，即可实现多态。
例如：
A c;
B e;
A *pc=&e; //设置breakpoint，运行到此处
pc=&c;
此时内存中各指针状况如下：

可以看出，此时pc指向类B的虚表地址，从而调用对象e的方法。

继续运行，当运行至pc=&c时候，此时pc的vptr值为0x00420050,即指向类A的vtable地址，从而调用c的方法。
这就是动态绑定！(dynamic binding)或者叫做迟后联编（lazy compile)。

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

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



2 一个很好的例子 （this指针是指向子类）
#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++的多态性。换句话说，我们不要在构造函数中去调用虚函数，当然如果你只是想调用本类的函数，也无所谓。

   谈到虚函数，不防将虚函数和纯虚函数做个比较

 

   虚函数

 引入原因：为了方便使用多态特性，我们常常需要在基类中定义虚函数。

  纯虚函数
 引入原因：为了实现多态性，纯虚函数有点像Java中的接口，自己不去实现过程，让继承他的子类去实现。

    在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。 这时我们就将动物类定义成抽象类，也就是包含纯虚函数的类
    纯虚函数就是基类只定义了函数体，没有实现过程定义方法如下

  virtual void Eat() = 0; 直接=0 不要 在cpp中定义就可以了 
虚函数和纯虚函数的区别
1虚函数中的函数是实现的哪怕是空实现，它的作用是这个函数在子类里面可以被重载，运行时动态绑定实现动态
纯虚函数是个接口，是个函数声明，在基类中不实现，要等到子类中去实现
2 虚函数在子类里可以不重载，但是虚函数必须在子类里去实现。

转自： http://blog.csdn.net/zyq0335/article/details/7657465

 C++编程语言是一款应用广泛，支持多种程序设计的计算机编程语言。我们今天就会为大家详细介绍其中C++多态性的一些基本知识，以方便大家在学习过程中对此能够有一个充分的掌握。
　　多态性可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。多态(polymorphism)，字面意思多种形状。
　　C++多态性是通过虚函数来实现的，虚函数允许子类重新定义成员函数，而子类重新定义父类的做法称为覆盖(override)，或者称为重写。（这里我觉得要补充，重写的话可以有两种，直接重写成员函数和重写虚函数，只有重写了虚函数的才能算作是体现了C++多态性）而重载则是允许有多个同名的函数，而这些函数的参数列表不同，允许参数个数不同，参数类型不同，或者两者都不同。编译器会根据这些函数的不同列表，将同名的函数的名称做修饰，从而生成一些不同名称的预处理函数，来实现同名函数调用时的重载问题。但这并没有体现多态性。
　　多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用，在编译器编译期间就可以确定函数的调用地址，并生产代码，是静态的，就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定，需要在运行时才确定，这就属于晚绑定。
　　那么多态的作用是什么呢，封装可以使得代码模块化，继承可以扩展已存在的代码，他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说，不论传递过来的究竟是那个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。

　　最常见的用法就是声明基类的指针，利用该指针指向任意一个子类对象，调用相应的虚函数，可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话，即没有利用C++多态性，则利用基类指针调用相应的函数的时候，将总被限制在基类函数本身，而无法调用到子类中被重写过的函数。因为没有多态性，函数调用的地址将是一定的，而固定的地址将始终调用到同一个函数，这就无法实现一个接口，多种方法的目的了。

笔试题目：

[cpp] view plain copy

 

1. #include<iostream>  
2. using namespace std;  
3.   
4. class A  
5. {  
6. public:  
7.     void foo()  
8.     {  
9.         printf("1\n");  
10.     }  
11.     virtual void fun()  
12.     {  
13.         printf("2\n");  
14.     }  
15. };  
16. class B : public A  
17. {  
18. public:  
19.     void foo()  
20.     {  
21.         printf("3\n");  
22.     }  
23.     void fun()  
24.     {  
25.         printf("4\n");  
26.     }  
27. };  
28. int main(void)  
29. {  
30.     A a;  
31.     B b;  
32.     A *p = &a;  
33.     p->foo();  
34.     p->fun();  
35.     p = &b;  
36.     p->foo();  
37.     p->fun();  
38.     return 0;  
39. }  

      第一个p->foo()和p->fuu()都很好理解，本身是基类指针，指向的又是基类对象，调用的都是基类本身的函数，因此输出结果就是1、2。
 　  第二个输出结果就是1、4。p->foo()和p->fuu()则是基类指针指向子类对象，正式体现多态的用法，p->foo()由于指针是个基类指针，指向是一个固定偏移量的函数，因此此时指向的就只能是基类的foo()函数的代码了，因此输出的结果还是1。而p->fun()指针是基类指针，指向的fun是一个虚函数，由于每个虚函数都有一个虚函数列表，此时p调用fun()并不是直接调用函数，而是通过虚函数列表找到相应的函数的地址，因此根据指向的对象不同，函数地址也将不同，这里将找到对应的子类的fun()函数的地址，因此输出的结果也会是子类的结果4。
　　笔试的题目中还有一个另类测试方法。即
       B *ptr = (B *)&a;  ptr->foo();  ptr->fun();
　　问这两调用的输出结果。这是一个用子类的指针去指向一个强制转换为子类地址的基类对象。结果，这两句调用的输出结果是3，2。
　　并不是很理解这种用法，从原理上来解释，由于B是子类指针，虽然被赋予了基类对象地址，但是ptr->foo()在调用的时候，由于地址偏移量固定，偏移量是子类对象的偏移量，于是即使在指向了一个基类对象的情况下，还是调用到了子类的函数，虽然可能从始到终都没有子类对象的实例化出现。
　　而ptr->fun()的调用，可能还是因为C++多态性的原因，由于指向的是一个基类对象，通过虚函数列表的引用，找到了基类中fun()函数的地址，因此调用了基类的函数。由此可见多态性的强大，可以适应各种变化，不论指针是基类的还是子类的，都能找到正确的实现方法。

[cpp] view plain copy

 

1. //小结：1、有virtual才可能发生多态现象  
2. // 2、不发生多态（无virtual）调用就按原类型调用  
3. #include<iostream>  
4. using namespace std;  
5.   
6. class Base  
7. {  
8. public:  
9.     virtual void f(float x)  
10.     {  
11.         cout<<"Base::f(float)"<< x <<endl;  
12.     }  
13.     void g(float x)  
14.     {  
15.         cout<<"Base::g(float)"<< x <<endl;  
16.     }  
17.     void h(float x)  
18.     {  
19.         cout<<"Base::h(float)"<< x <<endl;  
20.     }  
21. };  
22. class Derived : public Base  
23. {  
24. public:  
25.     virtual void f(float x)  
26.     {  
27.         cout<<"Derived::f(float)"<< x <<endl;   //多态、覆盖  
28.     }  
29.     void g(int x)  
30.     {  
31.         cout<<"Derived::g(int)"<< x <<endl;     //隐藏  
32.     }  
33.     void h(float x)  
34.     {  
35.         cout<<"Derived::h(float)"<< x <<endl;   //隐藏  
36.     }  
37. };  
38. int main(void)  
39. {  
40.     Derived d;  
41.     Base *pb = &d;  
42.     Derived *pd = &d;  
43.     // Good : behavior depends solely on type of the object  
44.     pb->f(3.14f);   // Derived::f(float) 3.14  
45.     pd->f(3.14f);   // Derived::f(float) 3.14  
46.   
47.     // Bad : behavior depends on type of the pointer  
48.     pb->g(3.14f);   // Base::g(float)  3.14  
49.     pd->g(3.14f);   // Derived::g(int) 3   
50.   
51.     // Bad : behavior depends on type of the pointer  
52.     pb->h(3.14f);   // Base::h(float) 3.14  
53.     pd->h(3.14f);   // Derived::h(float) 3.14  
54.     return 0;  
55. }  

令人迷惑的隐藏规则
本来仅仅区别重载与覆盖并不算困难，但是C++的隐藏规则使问题复杂性陡然增加。
这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual
关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual
关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。
上面的程序中：
（1）函数Derived::f(float)覆盖了Base::f(float)。
（2）函数Derived::g(int)隐藏了Base::g(float)，而不是重载。
（3）函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。

C++纯虚函数
 一、定义
  纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0” 
  virtual void funtion()=0 
二、引入原因
   1、为了方便使用多态特性，我们常常需要在基类中定义虚拟函数。 
   2、在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。 
  为了解决上述问题，引入了纯虚函数的概念，将函数定义为纯虚函数（方法：virtual ReturnType Function()= 0;），则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。这样就很好地解决了上述两个问题。
三、相似概念
   1、多态性 
  指相同对象收到不同消息或不同对象收到相同消息时产生不同的实现动作。C++支持两种多态性：编译时多态性，运行时多态性。 
  a、编译时多态性：通过重载函数实现 
  b、运行时多态性：通过虚函数实现。 
  2、虚函数 
  虚函数是在基类中被声明为virtual，并在派生类中重新定义的成员函数，可实现成员函数的动态覆盖（Override）
  3、抽象类 
  包含纯虚函数的类称为抽象类。由于抽象类包含了没有定义的纯虚函数，所以不能定义抽象类的对象。