C++的一个特征是多太，其中多态主要表现在
1.编译时多态 函数overload实现
2.运行是多态 虚函数override实现
其中虚函数包括 一般虚函数 和纯虚函数。定义的区别为是否在函数后面添加‘＝0’
一般虚函数
virtual void fun（）；
virtual void fun（）const；
纯虚函数
virtual void fun（） ＝0；
virtual void fun（）const ＝0；
其中
1. 一般虚函数 必须有默认实现
2. 纯虚函数 可有可无默认实现
两者区别主要是 子类是否必须override该虚函数函数才能进行实例化：纯虚函数是必须，一般虚函数不必
纯虚函数还不能为inline ，虚函数和内联函数在使用目的上是矛盾的，前者是在运行时刻决定调用哪个函数，后者是在编译时候要知道调用哪个函数。同样也不能为static
纯虚函数的默认实现可以通过基类名访问，即使有默认实现的纯虚函数依然不能实例化，这是由C++面向对象的逻辑要求。
子类均可以不override虚函数。但当继承抽象类（含纯虚函数的类）的子类不override基类的纯虚函数时，其自身也为抽象类，不能实例化。
是否可以override虚函数与类成员函数的访问权限无关。
什么时候使用虚函数？
1.首先看成员函数所在的类是否会作为基类.然后看成员不得类的继承后有无可能被更改功能,若希望那个更改部份功能则声明为虚函数
2.如果成员函数在类被继承后功能不需要修改,或派生类用不到该函数,则不要声明为虚函数
3.考虑对成员函数的调用是通过对象名还是通过基类指针或引用去访问---声明为虚函数
全部包含纯虚函数的基类 即为接口；或者可以说，如果你想为外界提供一些接口，你可以定义一个纯虚函数的类（抽象类），把需要的接口定义在里面。
另外 如果希望子类能多态，最好提供析构函数的虚函数版本。effiective C++中有说明原因。
二， 虚函数是如何做到的
（如果你没有看过《Inside The C++ Object Model》这本书，但又急切想知道，那你就应该从这里开始）
虚函数是如何做到因对象的不同而调用其相应的函数的呢？现在我们就来剖析虚函数。我们先定义两个类
class A{ //虚函数示例代码
public:
virtual void fun(){cout<<1<<endl;}
virtual void fun2(){cout<<2<<endl;}
};
class B:public A{
public:
void fun(){cout<<3<<endl;}
void fun2(){cout<<4<<endl;}
};
由于这两个类中有虚函数存在，所以编译器就会为他们两个分别插入一段你不知道的数据，并为他们分别创建一个表。那段数据叫做vptr指针，指向那个表。那个表叫做vtbl，每个类都有自己的vtbl，vtbl的作用就是保存自己类中虚函数的地址，我们可以把vtbl形象地看成一个数组，这个数组的每个元素存放的就是虚函数的地址，请看图
通过左图，可以看到这两个vtbl分别为class A和class B服务。现在有了这个模型之后，我们来分析下面的代码
A *p=new A;
p->fun();
毫无疑问，调用了A::fun()，但是A::fun()是如何被调用的呢？它像普通函数那样直接跳转到函数的代码处吗？No，其实是这样的，首先是取出vptr的值，这个值就是vtbl的地址，再根据这个值来到vtbl这里，由于调用的函数A::fun()是第一个虚函数，所以取出vtbl第一个slot里的值，这个值就是A::fun()的地址了，最后调用这个函数。现在我们可以看出来了，只要vptr不同，指向的vtbl就不同，而不同的vtbl里装着对应类的虚函数地址，所以这样虚函数就可以完成它的任务。
而对于class A和class B来说，他们的vptr指针存放在何处呢？其实这个指针就放在他们各自的实例对象里。由于class A和class B都没有数据成员，所以他们的实例对象里就只有一个vptr指针。通过上面的分析，现在我们来实作一段代码，来描述这个带有虚函数的类的简单模型。
#include<iostream>
using namespace std;
//将上面“虚函数示例代码”添加在这里
int main(){
void (*fun)(A*);
A *p=new B;
long lVptrAddr;
memcpy(&lVptrAddr,p,4);
memcpy(&fun,reinterpret_cast<long*>(lVptrAddr),4);
fun(p);
delete p;
system("pause");
}
用VC或Dev-C++编译运行一下，看看结果是不是输出3，如果不是，那么太阳明天肯定是从西边出来。现在一步一步开始分析
void (*fun)(A*); 这段定义了一个函数指针名字叫做fun，而且有一个A*类型的参数，这个函数指针待会儿用来保存从vtbl里取出的函数地址
A* p=new B; new B是向内存(内存分5个区:全局名字空间,自由存储区,寄存器,代码空间,栈)自由存储区申请一个内存单元的地址然后隐式地保存在一个指针中.然后把这个地址赋值给A类型的指针P.
.
long lVptrAddr; 这个long类型的变量待会儿用来保存vptr的值
memcpy(&lVptrAddr,p,4); 前面说了，他们的实例对象里只有vptr指针，所以我们就放心大胆地把p所指的4bytes内存里的东西复制到lVptrAddr中，所以复制出来的4bytes内容就是vptr的值，即vtbl的地址
现在有了vtbl的地址了，那么我们现在就取出vtbl第一个slot里的内容
memcpy(&fun,reinterpret_cast<long*>(lVptrAddr),4); 取出vtbl第一个slot里的内容，并存放在函数指针fun里。需要注意的是lVptrAddr里面是vtbl的地址，但lVptrAddr不是指针，所以我们要把它先转变成指针类型
fun(p); 这里就调用了刚才取出的函数地址里的函数，也就是调用了B::fun()这个函数，也许你发现了为什么会有参数p,其实类成员函数调用时，会有个this指针，这个p就是那个this指针，只是在一般的调用中编译器自动帮你处理了而已，而在这里则需要自己处理。
delete p; 释放由p指向的自由空间;
system("pause"); 屏幕暂停;
如果调用B::fun2()怎么办？那就取出vtbl的第二个slot里的值就行了
memcpy(&fun,reinterpret_cast<long*>(lVptrAddr+4),4); 为什么是加4呢？因为一个指针的长度是4bytes，所以加4。或者memcpy(&fun,reinterpret_cast<long*>(lVptrAddr)+1,4); 这更符合数组的用法，因为lVptrAddr被转成了long*型别，所以+1就是往后移sizeof(long)的长度
三， 以一段代码开始
#include<iostream>
using namespace std;
class A{ //虚函数示例代码2
public:
virtual void fun(){ cout<<"A::fun"<<endl;}
virtual void fun2(){cout<<"A::fun2"<<endl;}
};
class B:public A{
public:
void fun(){ cout<<"B::fun"<<endl;}
void fun2(){ cout<<"B::fun2"<<endl;}
}; //end//虚函数示例代码2
int main(){
void (A::*fun)(); //定义一个函数指针
A *p=new B;
fun=&A::fun;
(p->*fun)();
fun = &A::fun2;
(p->*fun)();
delete p;
system("pause");
}
你能估算出输出结果吗？如果你估算出的结果是A::fun和A::fun2，呵呵，恭喜恭喜，你中圈套了。其实真正的结果是B::fun和B::fun2，如果你想不通就接着往下看。给个提示，&A::fun和&A::fun2是真正获得了虚函数的地址吗？
首先我们回到第二部分，通过段实作代码，得到一个“通用”的获得虚函数地址的方法
#include<iostream>
using namespace std;
//将上面“虚函数示例代码2”添加在这里
void CallVirtualFun(void* pThis,int index=0){
void (*funptr)(void*);
long lVptrAddr;
memcpy(&lVptrAddr,pThis,4);
memcpy(&funptr,reinterpret_cast<long*>(lVptrAddr)+index,4);
funptr(pThis); //调用
}
int main(){
A* p=new B;
CallVirtualFun(p); //调用虚函数p->fun()
CallVirtualFun(p,1);//调用虚函数p->fun2()
system("pause");
}
CallVirtualFun方法
现在我们拥有一个“通用”的CallVirtualFun方法。
这个通用方法和第三部分开始处的代码有何联系呢？联系很大。由于A::fun()和A::fun2()是虚函数，所以&A::fun和&A::fun2获得的不是函数的地址，而是一段间接获得虚函数地址的一段代码的地址，我们形象地把这段代码看作那段CallVirtualFun。编译器在编译时，会提供类似于CallVirtualFun这样的代码，当你调用虚函数时，其实就是先调用的那段类似CallVirtualFun的代码，通过这段代码，获得虚函数地址后，最后调用虚函数，这样就真正保证了多态性。同时大家都说虚函数的效率低，其原因就是，在调用虚函数之前，还调用了获得虚函数地址的代码。
四、带虚函数类的sizeof
上面两节介绍了虚函数的实现。下面我们再看看关于sizeof的情况。我们知道空类sizeof为1，有了上面介绍，那下面情况也就清楚了
sizeof（A) ＝ 1；
sizeof（B) ＝ 4；
sizeof（C) ＝ 4；
sizeof（D) ＝ 4；
可以发现对含有虚函数基类继承的子类中，不关是否有新的虚函数。都只使用了一个虚函数指针，即对于D类中继承的基类的虚函数指针和其自己定义的虚函数指针都放在同一个虚函数表（Vtable）中，并且类的实例之用保存这个唯一的虚函数表的地址就可以了，所以B和D的大小都是4.这是单类继承时共享虚表指针。
实际情况是，虚函数表指针保存在对象的第一个位置上，之后是成员变量。子类虚函数指针依次附加到基类后面。 注意区分虚指针（虚函数指针）和虚表指针（虚函数表指针），前者是虚函数的地址，后者是存放虚函数地址的列表的指针（表头地址）
多继承时：
sizeof(A) = 4；
sizeof（B) ＝ 4；
sizeof（C) ＝ 8；
sizeof（D) ＝ 8；
sizeof（E) ＝ 8；
在多重继承时，继承了几个含 虚函数的基类则会产生几个虚函数表的指针，并且每个基类都有一张自己的虚函数表。例如继承3个含虚函数的基类时，不管自身是否定义了虚函数，都将只有3个虚函数表指针。即虚函数相关占用的空间为3*sizeof（*VP）。如果子类也定义了新的虚函数，将虚函数地址依次放入第一个基类的虚函数表的末尾。
关于虚函数表的图型表述更详细信息，参考：详解虚函数表详
五、虚继承的情况
虚继承即 继承虚基类：
虚继承是为了在多重继承时，继承了个同一个基类的多个类能共享这个基类的对象，而不产生多于的副本，以似的数据保持一致。如上面代码。继承关系为
base
/ /
A B
/ /
D
如果A B中有一个不是虚拟继承的base则继承关系如下：
base base
/ /
A B
/ /
D
此时在D的对象中将存在两个base对象，可能的错误是base不同步，虚继承则是设计为解决上面这种继承关系。
A，B不一定要有虚函数。
GCC都是将虚表指针在整个继承关系中共享的，不共享的是指向虚基类的指针。C除了继承A的大小还会产生虚基类指针。
其中需要注意的是：
sizeof（C1) ＝ 4；//没有其它成员，虚基类指针同虚函数指针共享
sizeof（C2) ＝ 12；//存在其它成员，虚基类指针不能同 虚函数表指针共享，需要单独占用空间
sizeof（D1) ＝ 8；
sizeof(D2) = 12;
sizeof（X) ＝ 自身成员大小+父类大小；
普通继承：
单继承：虚函数将放在同一个虚函数表，不管是父类还子类，所以共享虚函数表指针（）
多继承：为每一个含虚函数的基类产生一个虚函数表指针。自身的虚函数地址放入基类虚函数表中。
虚继承：
一般是多重继承体现：若通过不同继承渠道有相同的父类，渠道含虚继承则只得到一套此父类的成员，不含虚继承则可能得到若干套此父类的成员
关于虚函数表 还可以参考http://hzhping350.blog.163.com/blog/static/83120736200881795548754/ 虚拟函数、多继承、虚基类(转)
1746
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
