C++多态性及虚函数

多态性

多态性是面向对象程序设计的重要特性

一种接口，多种方法

在C++程序设计中，多态性是指具有不同功能的函数可以使用同一个函数名。

在面向对象方法中多态性一般表述为：向不同的对象发送同一个消息，不同的对象在接收时会产生不同行为。

多态性可分为：静态多态性和动态多态性

静态多态性（编译多态性）：在程序编译时系统就能决定调用哪个函数，通过重载实现（包括函数的重载、运算符的重载）。

动态多态性（运行多态性）：在程序运行的时候才动态的确定操作所针对的对象，通过虚函数实现。

虚函数

在同一个类中不能定义两个名字相同、参数类型及个数都相同的函数，否则就是“重复定义”（多重继承下来两个完全相同的不算重复定义）。而在继承层次结构中，不同层次中可以出现名字、参数类型、参数个数都相同的函数，因为在不同层次中编译系统会按照同名屏蔽的原则调用派生类的函数。

特别说明：析构函数也可以为虚，实现原理相同（虚函数表实现），但构造函数不能为虚，因为指向vtable的指针其实是存储在对象的内存空间的。问题出来了，如果构造函数是虚的，就需要通过 vtable来调用，可是对象还没有实例化，也就是内存空间还没有，怎么找vtable呢。

谭浩强版本中：虚函数的作用是允许在派生类中重新定义与基类同名的函数，并通过基类指针或引用来访问基类和派生类中的同名函数。

个人觉得前半句不妥，即无虚函数仍可以在派生类中重新定义与基类同名的函数，举例说明：

class A
{
	public:
	void ss()
	{cout<<"hello"<<endl;}
};
class B:public A
{
	public:
	void ss()
	{cout<<"world"<<endl;}	
};
int main()
{
	B b1;
	b1.ss();	//调用的是类B中新增的ss()函数 
	b1.A::ss(); //调用的是类A中的ss()函数
}

虚函数真正作用：突破了无法通过基类指针或引用去调用派生类对象中的成员函数的限制，从而实现了动态多态性。

举例分析：

class A
{
	public:
	virtual void ss()
	{cout<<"hello"<<endl;}
};
class B:public A
{
	public:
	void ss()
	{cout<<"world"<<endl;}	
};
class C:public B
{
	public:
	void ss()
	{cout<<"！！"<<endl;}	
};
void show(A *p)
{
	p->ss();
}
int main()
{
	A a1;
	B b1;
	C c1; 
	show(&a1);
	show(&b1);	
	show(&c1);
}

代码中将类A中的ss()函数定义成虚函数，通过采用虚函数的方式，你不用管传入show函数的实参哪个派生类的指针，都可以通过基类形参指针，调用对应派生类的ss()函数从而产生不同的效果，即为多态的体现。如果不采用虚函数的方式的话，你得给各个派生类分别写一个函数，这大大增加了代码的复杂度。

通过基类引用的方法实现，只需稍作修改：

void show(A &p)
{
	p.ss();
}
int main()
{
	A a1;
	B b1;
	C c1; 
	show(a1);
	show(b1);	
	show(c1);
}

对于引用的方法适用于作为形参，若作为实参将不能使用引用的方法

class A
{
	public:
	virtual void pp()
	{
		cout<<"hello"<<endl;
	}
};
class B:public A
{
	public:
	void pp()
	{
		cout<<"world"<<endl;
	}	
};
int main()
{
	A a1;
	B b1;
	A &p=a1;
	p.pp();
	p=b1;	//引用变量是无法重新绑定，这里只是b1赋值给a1 
	p.pp();
}

引用变量是无法重新绑定，所以p=b1只是b1赋值给a1，而赋值只是数据成员的传递，成员函数无法传递，于是只是执行了b1中对应基类A的数据成员传递给了基类A的对象a1， 因为b1继承a1所以b1中对应基类A的数据成员即为a1中的数据成员。

虚函数的使用方式：

(1)在基类用关键字virtual声明成员函数为虚函数，若在类外定义虚函数则，可不用加virtual。（这里说的基类并非一定要最原始的类，而是任何一个类都可作为基类，继承它的类自然成了派生类）

(2)在派生类中重新定义此函数，要求函数名、函数类型、函数参数个数及类型全部与基类虚函数相同。

特别注意：当一个成员函数被声明为虚函数后，其派生类中的同名函数自动成为虚函数，可以不加virtual，但为了代码更清晰，一般都会加上virtual。

(3)定义一个指向基类对象的指针或引用变量，利用指针或引用调用同一类族中某一对象的虚函数。

注意：不能定义了派生类对象指针或引用，然后想指向或引用基类对象。

虚函数的实现原理：

<参考>http://blog.youkuaiyun.com/haoel/article/details/1948051

采用了虚函数表实现虚函数

虚函数表：它是一个指针数组，存放每个虚函数的入口地址，虚函数的实现即通过了虚函数表（Virtual Table）。

注意的是，编译器会为每个有虚函数的类创建一个虚函数表，该虚函数表将被该类的所有对象共享，这个指针数组并非存于某个对象中而是进行单独存储，但各个对象实例都有指向虚函数表的指针，并存于对象中。

这张表解决了继承、覆盖的问题，保证其真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个派生类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

C++的编译器应该是保证指向虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承的情况下）。 这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

假设我们有这样的一个类：

class Base 
{ 
public:
	virtual void f() { cout << "Base::f" << endl; }
	virtual void g() { cout << "Base::g" << endl; }
	virtual void h() { cout << "Base::h" << endl; }
};

按照上面的说法，我们可以通过Base的实例来得到虚函数表。 下面是实际例程：

typedef void(*Fun)(void);
 
	Base b;
 
	Fun pFun = NULL;
	
	cout << "虚函数表地址：" << (int*)(&b) << endl;
	cout << "虚函数表 - 第一个函数地址：" << (int*)*(int*)(&b) << endl;
 
	// Invoke the first virtual function 
	pFun = (Fun)*((int*)*(int*)(&b));
	pFun();

实际运行结果如下：

虚函数表地址：0012FED4

虚函数表 — 第一个函数地址：0044F148

Base::f

通过这个示例，我们可以看到，我们可以通过强行把&b转成int *，取得虚函数表的地址，然后，再次取址就可以得到第一个虚函数的地址了，也就是Base::f()，这在上面的程序中得到了验证（把int*强制转成了函数指针）。通过这个示例，我们就可以知道如果要调用Base::g()和Base::h()，其代码如下：

(Fun)*((int*)*(int*)(&b)+0);  // Base::f()
(Fun)*((int*)*(int*)(&b)+1);  // Base::g()
(Fun)*((int*)*(int*)(&b)+2);  // Base::h()

画个图解释一下。如下所示：

注意：在上面这个图中，我在虚函数表的最后多加了一个结点，表示虚函数表的结束结点。

下面，我将分别说明“无覆盖”和“有覆盖”时的虚函数表的样子。没有覆盖父类的虚函数是毫无意义的。我之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。

一般继承（无虚函数覆盖）
下面，再让我们来看看继承时的虚函数表是什么样的。假设有如下所示的一个继承关系：

请注意，在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：
 
对于实例：Derive d; 的虚函数表如下：

我们可以看到下面几点：
1）虚函数按照其声明顺序放于表中。
2）父类的虚函数在子类的虚函数前面。

一般继承（有虚函数覆盖）
 覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。下面，我们来看一下，如果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，我们有下面这样的一个继承关系。

为了让大家看到被继承过后的效果，在这个类的设计中，我只覆盖了父类的一个函数：f()。那么，对于派生类的实例，其虚函数表会是下面的一个样子：

我们从表中可以看到下面几点，
1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置，派生类处就不会再有。
2）没有被覆盖的函数依旧。
 
这样，我们就可以看到对于下面这样的程序，

Base *b = new Derive();

b->f();

由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。

多重继承（无虚函数覆盖）
 下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有覆盖父类的函数。

对于子类实例中的虚函数表，是下面这个样子：

我们可以看到：
1）  每个父类都有自己的虚表。
2）  子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）
 这样做就是为了解决不同的父类类型的指针指向同一个派生类实例，而能够调用到实际的函数。
 
 
多重继承（有虚函数覆盖）
下面我们再来看看，如果发生虚函数覆盖的情况。
下图中，我们在子类中覆盖了父类的f()函数。

下面是对于子类实例中的虚函数表的图：

我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如：

Derive d;
Base1 *b1 = &d;
Base2 *b2 = &d;
Base3 *b3 = &d;
b1->f(); //Derive::f()
b2->f(); //Derive::f()
b3->f(); //Derive::f()
 
b1->g(); //Base1::g()
b2->g(); //Base2::g()
b3->g(); //Base3::g()