(转)C++多态性与虚函数

 
C++多态性：虚函数的调用原理
多态性给我们带来了好处：多态使得我们可以通过基类的引用或指针来指明一个对象（包含其派生类的对象），当调用函数时可以自动判断调用的是哪个对象的函数。
一个函数说明为虚函数，表明在继承的类中重载这个函数时，当调用这个函数时应当查看以确定调用哪个对象的这个函数。
普通函数的处理：一个特定的函数都会映射到特定的代码，无论时编译阶段还是连接阶段，编译器都能计算出这个函数的地址，调用即可。
虚函数的处理：被调用的函数不仅依据调用的特定函数，还依据调用的对象的种类。通常是由虚函数表（vtable）来实现的。
虚函数表的结构：它是一个函数指针表，每一个表项都指向一个函数。任何一个包含至少一个虚函数的类都会有这样一张表。需要注意的是vtable只包含虚函数的指针，没有函数体。实现上是一个函数指针的数组。虚函数表既有继承性又有多态性。每个派生类的vtable继承了它各个基类的vtable，如果基类vtable中包含某一项，则其派生类的vtable中也将包含同样的一项，但是两项的值可能不同。如果派生类重载(override)了该项对应的虚函数，则派生类vtable的该项指向重载后的虚函数，没有重载的话，则沿用基类的值。
每一个类只有唯一的一个vtable，不是每个对象都有一个vtable，恰恰是每个同一个类的对象都有一个指针，这个指针指向该类的vtable（当然，前提是这个类包含虚函数）。那么，每个对象只额外增加了一个指针的大小，一般说来是4字节。

在类对象的内存布局中，首先是该类的vtable指针，然后才是对象数据。

在通过对象指针调用一个虚函数时，编译器生成的代码将先获取对象类的vtable指针，然后调用vtable中对应的项。对于通过对象指针调用的情况，在编译期间无法确定指针指向的是基类对象还是派生类对象，或者是哪个派生类的对象(见代码中的函数f在编译期间是无法判断的)。但是在运行期间执行到调用语句时，这一点已经确定，编译后的调用代码能够根据具体对象获取正确的vtable，调用正确的虚函数，从而实现多态性。

给出实例代码：
class A {
public :
virtual void run (){......}
}
class B :public A{
public:
void run(){......}
}
int f (A *pA){
pA->run();
}
分析一下这里的思想所在，问题的实质是这样，对于发出虚函数调用的这个对象指针，在编译期间缺乏更多的信息，而在运行期间具备足够的信息，但那时已不再进行绑定了而是直接执行好了，怎么在二者之间作一个过渡呢？把绑定所需的信息用一种通用的数据结构记录下来，该数据结构可以同对象指针相联系，在编译时只需要使用这个数据结构进行抽象的绑定，而在运行期间将会得到真正的绑定。这个数据结构就是vtable，也就是编译期间建立vtable表，执行期间查表执行。可以看到，实现用户所需的抽象和多态需要进行后绑定，而编译器又是通过抽象和多态而实现后绑定的。
下面是通过基类的指针来调用虚函数时，所发生的一切：
step 1:开始执行调用 pA->run();（这里能判断到底是哪个对象）
step 2:取得对象的vtable的指针
step 3:从vtable那里获得函数入口的偏移量，即得到要调用的函数的指针
step 4:根据vtable的地址找到函数，并调用函数。
step 1和step 4对于一般函数是一样的，虚函数只是多了step 2和step 3。
解惑：
1基类和派生类是共用一表,还是各有各的表(物理上)
答：基类和派生类是各有各的表,也就是说他们的物理地址是分开的,基类和派生类的虚表的唯一关联是:当派生类没有实现基类虚函数的重载时,派生类会直接把自己表的该函数地址值写为基类的该函数地址值.
 
 
 
 
 
 
  C++编程语言是一款应用广泛，支持多种程序设计的计算机编程语言。我们今天就会为大家详细介绍其中C++多态性的一些基本知识，以方便大家在学习过程中对此能够有一个充分的掌握。
　　多态性可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。多态(polymorphisn)，字面意思多种形状。
　　C++多态性是通过虚函数来实现的，虚函数允许子类重新定义成员函数，而子类重新定义父类的做法称为覆盖(override)，或者称为重写。（这里我觉得要补充，重写的话可以有两种，直接重写成员函数和重写虚函数，只有重写了虚函数的才能算作是体现了C++多态性）而重载则是允许有多个同名的函数，而这些函数的参数列表不同，允许参数个数不同，参数类型不同，或者两者都不同。编译器会根据这些函数的不同列表，将同名的函数的名称做修饰，从而生成一些不同名称的预处理函数，来实现同名函数调用时的重载问题。但这并没有体现多态性。
　　多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用，在编译器编译期间就可以确定函数的调用地址，并生产代码，是静态的，就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定，需要在运行时才确定，这就属于晚绑定。
　　那么多态的作用是什么呢，封装可以使得代码模块化，继承可以扩展已存在的代码，他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说，不论传递过来的究竟是那个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。

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

笔试题目：

[cpp] view plaincopy
 
  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 plaincopy
 
  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、抽象类 
  包含纯虚函数的类称为抽象类。由于抽象类包含了没有定义的纯虚函数，所以不能定义抽象类的对象。
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/xubenben/p/3023232.html