C++虚函数详解&实现机制&多态性

目录：

PART1

PART2

PART3

PART1转载：http://blog.chinaunix.net/uid-24178783-id-370328.html

PART2转载：http://blog.csdn.net/jiangnanyouzi/article/details/3720807

PART1

说到虚函数的实现方法，我们就不得不说到动态联编（dynamic binding）和静态联编(static binding)。静态联编意味着编译器能够直接将标识符和存储的物理地址联系在一起。每一个函数都有一个唯一的物理地址，当编译器遇到一个函数调用时，它将用一个机械语言说明来替代函数调用，用来告诉CPU跳至这个函数的地址，然后对此函数进行操作。这个过程是在编译过程中完成的（注：调用的函数在编译时必须能够确定），所以静态联编也叫前期联编（early binding）。但是，如果使用哪个函数不能在编译时确定，则需要采用动态联编的方式，在程序运行时在调用函数，所以动态联编也叫后期联编（late
binding）。

在C++继承多态中，如若要在派生类中重新定义基类的方法，则要把它声明为虚函数，并且用指针或者引用去调用它的方法，实现动态联编，否则编译器默认的将是静态联编。小看一下这个例子：

Example1:

#include <iostream>
using namespace std;

class A
{
public:
void f() { cout << "A" << endl; } //注意此处的函数不是虚函数

};

class B : public A
{
public:
void f() { cout << "B" << endl;}
};
int main (void)
{

A     a, *pa;
B     b;

a = b; //将子类对象赋给基类对象
a.f();
pa = &b; //用子类的对象的地址给基类指针初始化（符合赋值兼容规则）
pa->f();

return 0;
}

运行结果：

A A

原因：编译器默认为静态联编方式，所以函数f(),在编译过程中就已经定死了，在子类中尽管你重新定义了f（）的方法，但是编译器不知道应该调用哪个函数，所以就只会用的静态联编时的函数方法。

Example 2:

#include <iostream>
using namespace std;

class A
{
public:
virtual void f() { cout << "A" << endl; } //注意此处声明了虚函数

};

class B : public A
{
public:
void f()    { cout << "B" << endl;}
};
int main (void)
{
A     a, *pa;
B    b;

a = b; //将子类对象赋给基类对象，这样做不能实现动态联编,虚函数特性失效
a.f();
b.f()；
pa = &b;
pa->f();
A &aa = b; //定义成引用类型也是可以的
aa.f ();

return 0;
}

运行结果：

AB B B

先总结一下两个程序，若基类不声明为虚函数，则在A a = b时，或者 A &a
= b, A *a = &b，创建并初始化对象时，是根据引用或指针的类型来选择方法的。这也就是我们第一个程序运行的结果的具体解释（觉得自己上面说的静态联编有点抽象，不知道这样说明会不会更容易理解一些。。O(∩_∩)O~）。若使用了virtual声明为虚函数，则程序将根据引用或指针指向的对像的类型来选择方法。这就程序二运行结果的原因。
对比两个结果就能很清楚的看到虚函数的作用。但是它具体的实现原理是什么呢？
C++采用了动态联编的一种特殊形式去实现虚函数，称为虚函数表。虚函数表是一张函数查找表，用以解决以动态联编方式调用函数。它为每个可以被类对象调用的虚函数提供一个入口，这样当我们用基类的指针或者引用来操作子类的对象时，这张虚函数表就提供了编译器实际调用的函数。虚函数表其实是存储了为类对象进行声明的虚函数地址。当我们创建一个类对象时，编译器会自动的生成一个指针*__vptr(一个隐藏指针)，该指针指向这个类中所有虚函数的地址表。（实际上，虚函数表就是一个函数地址数组表。）,请注意，*__vptr和*this指针不同，*this是一个被编译器用作解决自引用的函数参数，而*__vptr则是一个真正的指针。
每一个类，不管是基类还是子类都有一个自己的virtual table，而*__vptr也是被继承过来的。（更正：vptr只有一个，除非使用了多继承）
我们再看一个例子：

Example:

#include <iostream>
using namespace std;

class A
{
public:
virtual void f()   { cout << "A’s f()" << endl; } //f()被声明为虚函数
virtual void g()   { cout << "A’s g()"<< endl; } //g()被声明为虚函数
};

class B : public A
{
public:
void f()    { cout << "B’s f()" << endl; }
};

class C : public A
{
public:
void g()    { cout << "C’s g()" << endl; }
};
int main (void)
{
A     *pa;
B     b;
C     c;

pa = &b;
pa -> f();
pa -> g();
pa = &c;
pa -> f();
pa -> g();

return 0;
}

运行结果：

B’s f() A’s g() A’s f() C’s g()

这个程序就能够反映出虚函数是怎样通过virtual table实现的，自己绘了一张图：应该能比较清楚的反映情况（借鉴于learnCpp.com）


通过这些virtual table，编译器和程序就能够确定调用合适的虚函数，即使你仅仅使用了一个指针或者引用指向了基类。很方便吧~~还有一点，若子类定义了新的虚函数，则该函数的地址也将被添加到virtual
table中。
但是，调用一个虚函数比调用一个非虚函数的速度要慢一些，原因：首先，我们必须使用*__vptr去获得合适的virtual table,然后通过这张virtual
table的索引才可以找到正确的调用函数，只有这样我们才可以调用这个函数。使用虚函数在内存方面也有一定的成本，即每个对象都将增大，增大量为存储地址的空间。
（
调用一个虚函数比调用一个非虚函数的速度要慢一些

更正：不一定的，如果使用静态类型调用虚函数的话，可以避免此类开销。更极端的做法是对虚函数加inline前缀，那么在使用了编译优化选项后展开（针对静态类型）

每个对象都将增大，增大量为存储地址的空间

更正：虚函数表和类存在一一对应的关系，每个对象仅仅多了vptr的内存开销。

）

参考资料：
《C++ Primmer Plus》 第五版
《C++面向对象程序设计》 张德慧

PART2：
1、c++实现多态的方法

其实很多人都知道，虚函数在c++中的实现机制就是用虚表和虚指针，但是具体是怎样的呢？从more effecive c++其中一篇文章里面可以知道：是每个类用了一个虚表，每个类的对象用了一个虚指针。具体的用法如下：

class A{

public:

virtual void f();

virtual void g();

private:

int a

};

class B : public A{

public:

void g();

private:

int b;

};

//A，B的实现省略

因为A有virtual void f（），和g（），所以编译器为A类准备了一个虚表vtableA，内容如下：

A::f 的地址

A::g 的地址

B因为继承了A，所以编译器也为B准备了一个虚表vtableB，内容如下：

A::f 的地址

B::g 的地址

注意：因为B::ｇ是重写了的，所以B的虚表的g放的是B::g的入口地址，但是f是从上面的A继承下来的，所以f的地址是A::f的入口地址。

然后某处有语句 B bB;的时候，编译器分配空间时，除了A的int a，B的成员int b；以外，还分配了一个虚指针vptr，指向B的虚表vtableB，bB的布局如下：

vptr ： 指向B的虚表vtableB

int a： 继承A的成员

int b： B成员

当如下语句的时候：

A *pa = &bB;

pa的结构就是A的布局（就是说用pa只能访问的到bB对象的前两项，访问不到第三项int b）

那么pa->g()中，编译器知道的是，g是一个声明为virtual的成员函数，而且其入口地址放在表格（无论是vtalbeA表还是vtalbeB表）的第2项，那么编译器编译这条语句的时候就如是转换：call *(pa->vptr)[1]（C语言的数组索引从0开始哈~）。

这一项放的是B：：g()的入口地址，则就实现了多态。（注意bB的vptr指向的是B的虚表vtableB）

另外要注意的是，如上的实现并不是唯一的，C++标准只要求用这种机制实现多态，至于虚指针vptr到底放在一个对象布局的哪里，标准没有要求，每个编译器自己决定。我以上的结果是根据g++ 4.3.4经过反汇编分析出来的。

2、两种多态实现机制及其优缺点

除了c++的这种多态的实现机制之外，还有另外一种实现机制，也是查表，不过是按名称查表，是smalltalk等语言的实现机制。这两种方法的优缺点如下：

（1）、按照绝对位置查表，这种方法由于编译阶段已经做好了索引和表项(如上面的call *(pa->vptr[1]） )，所以运行速度比较快;缺点是：当A的virtual成员比较多（比如1000个），而B重写的成员比较少（比如2个），这种时候，B的vtableＢ的剩下的998个表项都是放Ａ中的ｖｉｒｔｕａｌ成员函数的指针，如果这个派生体系比较大的时候，就浪费了很多的空间。

比如：ＧＵＩ库，以ＭＦＣ库为例，ＭＦＣ有很多类，都是一个继承体系；而且很多时候每个类只是１，２个成员函数需要在派生类重写，如果用Ｃ＋＋的虚函数机制，每个类有一个虚表，每个表里面有大量的重复，就会造成空间利用率不高。于是ＭＦＣ的消息映射机制不用虚函数，而用第二种方法来实现多态，那就是：

（２）、按照函数名称查表，这种方案可以避免如上的问题；但是由于要比较名称，有时候要遍历所有的继承结构，时间效率性能不是很高。（关于ＭＦＣ的消息映射的实现，看下一篇文章）

３、总结：

如果继承体系的基类的virtual成员不多，而且在派生类要重写的部分占了其中的大多数时候，用Ｃ＋＋的虚函数机制是比较好的；

但是如果继承体系的基类的virtual成员很多，或者是继承体系比较庞大的时候，而且派生类中需要重写的部分比较少，那就用名称查找表，这样效率会高一些，很多的ＧＵＩ库都是这样的，比如ＭＦＣ，ＱＴ

PART3：
我的笔记
虚函数类似JAVA里面的抽象类，如果子类继承的基类，而基类里面有一些抽象方法，那么在子类里面可以重写这些方法。
在C++里面，基类里面的虚函数也可以有自己的实现，子类继承可以重写覆盖。这里就涉及2个问题。
第一：编译的问题，就如上面说到的静态联编和动态联编。通过例子可以清晰的看到创建对象后对应的函数到底是怎么实现的，一般通过引用或者指针的话可以实现子类的方法，而如果是直接将子类对象赋给基类对象，这样做不能实现动态联编，虚函数特性失效。
第二：虚函数的实现，主要就是虚函数表（虚表）和虚指针的作用和实现原理。其实就是对应的函数入口地址的对应问题。
通过虚函数可以实现面向对象的三大特性之一——多态性。（封装性、多态性（2种方式：覆盖和重载）、继承性）

覆盖，是指子类重新定义父类的虚函数的做法。

重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce
Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”

那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

PS:还记得那个很厉害的父类引用指向子类对象吗？

/*
* 容器：可以往里面添加对象，没有长度限制，有就可以加进去。数组也是一种容器(集合)
* Collection(分成3种)----Set(HashSet...) List(LinkedList、ArrayList...)      Map(HashMap...)  下面有许多具体容器类
*                      【                                           一个一个数据                                                                                】【     两个两个存   键（key）和值（value） 】
* ArrayList  顺序存储            读取快 修改慢——O(N)
* LinkedList 链表存储            读取慢 修改快   双链表实现——O(N^2)
* HashSet            两者之间
*/

/*Collection接口中定义的方法
* int size()
* boolean isEmpty()
* void clear()
* boolean contains(Object element)
* boolean add(Object element)
* boolean remove(Object element):比较两个对象是否相等，使用equals或hashCode方法（对象为 键值（索引）即一对一对存储时使用hashCode）
* 重写equals方法必须重写hashCode方法 （同一索引必须指向同一个对象）
* Iterator iterator()
* ...
*/

import java.util.*;
class Name{
private String firstName,lastName;
public Name(String firstName,String lastName)
{
this.firstName=firstName;
this.lastName=lastName;
}
public String getFirstName(){return firstName;}
public String getLastName(){return lastName;}
public String toString(){return firstName+" "+lastName;}
}

public class App {
public static void main(String[] args)
{
Collection c=new ArrayList();//这句话大有学问呢！this is 面向对象!
//解析：父类引用指向子类对象，当然可以写成ArrayList c=new ArrayList();
//为什么这样写呢？如果写成ArrayList c=new ArrayList();
//if将来对象c更换成new LinkedList()（LinkedList类的对象）
//则下面的ArrayList特定的东西就不能用了
//while写成Collection c=new ArrayList();通过父类引用访问子类对象
//对象c不能访问子类ArrayList特有的东西
//So将来改变的话 可以放心大胆的改成Collection c=new LinkedList();其他地方一概不用变，增加了灵活性

//可以放入不同类型的对象
c.add("hello");
c.add(new Name("LI","LEI"));//添加了一个新的类
c.add(new Integer(100));//添加了一个Integer对象 不能直接100 因为只能添加对象，不能基础的数据类型
System.out.println(c.size());//装了几个对象
System.out.println(c);//实际调用了toString方法 输出[   ]
}

}