C++中多态的实现

1 C++中多态概述

        面向对象语言的主要特点是：封装性、继承性、多态性。其中，封装性使得代码模块化，继承性完成代码的复用，多态实现接口的重用。

        在C++中，多态性是指具有不同功能的函数用同一个函数名。即用同一个函数名，调用不同内容的函数。下面主要从多态的实现分析C++中的多态。多态的实现有两种方式：静态联编和动态联编。

1.1 静态联编

        系统在编译的时候就知道该调用哪个函数。也叫做编译时的多态性，如函数重载。

函数重载：函数名相同，但是他们的参数个数或顺序、类型不同。但是不能仅靠返回类型来判断。

#include "iostream"
using namespace std;

int add(int a, int b);
double add(double a, double b);

void main(void)
{
    cout<<add(1,2)<<endl;      //add(int,int) 3
    cout<<add(1.0,2.0)<<endl;  //add(double,double) 3
}

int add( int a, int b )
{
    cout<<"add(int,int)"<<" ";
    return a+b;
}

double add( double a, double b )
{
    cout<<"add(double,double)"<<" ";
    return a+b;
}

关于函数重载的几点说明：

        （1）、重载的函数具有相同的作用域。

        （2）、函数名相同。

        （3）、函数的参数不同（参数类型不同或参数个数、顺序不同）。

        （4）、返回值可以不同。

1.2 动态联编

        程序在运行过程中才动态地确定操作所针对的函数，又叫运行时多态性。下面看一个动态联编的实例。考虑有两种交通工具飞机（airplane）和火车（train），它们都公有继承交通工具（traffic），都有属性运输（transport）。

#include "iostream"
using namespace std;

class traffic{
public:
	virtual void transport(void)
	{cout<<"traffic"<<endl;}
};

class airplane:public traffic
{
public:
	void transport(void)
	{cout<<"airplane"<<endl;}
};

class train:public traffic
{
public:
	void transport(void)
	{cout<<"train"<<endl;}
};

void main(void)
{
	train * a = new train;
	airplane b;
	traffic *c = a;
	traffic &d = b;
	traffic e = b;
	c->transport();  //train
	d.transport();   //airplane
	e.transport();   //traffic
}

        我们可以看到，虽然c,d是基类的指针和引用，但是我们可以通过它们访问其子类的相关函数。这就是针对不同的对象用同样的函数实现了不同的操作。

关于动态联编的几点说明。

        （1）、C++规定，动态联编是在虚函数下实现的。

        （2）、动态联编只能通过指针或引用来操作虚函数，如果用一般类实例来操作虚函数，将按照静态联编调用虚函数。

2 多态性实现原理

        这部分从编译层来分析，多态是怎样实现的。

2.1 静态联编

        编译器在处理函数重载时，也同时考虑了函数参数的类型和顺序。如上面函数重载的例子中，编译器编译结果，形如：

add(int a, int b) ------> _ADD_INT_INT

add(double a, double b)-------->_ADD_DOUBLE_DOUBLE

        所以函数调用时，可以根据实参的类型和顺序，唯一调用相对应的函数。

2.2 动态联编

        动态联编的关键在于虚函数。

        关键字virtual告诉编译器不应该完成早绑定，应该自动安装实现绑定所必需的所有机制。

三个步骤实现动态联编：

        （1）、对每个包含虚函数的类，创建一个表（vtable），用于放置特定类的虚函数的位置。

        （2）、在每一个带虚函数的类中，编译器设置指针vpointer（vptr），指向vtable表。

        （3）、通过基类指针做虚函数调用时（也就是多态调用时）编译器静态地插入取得vptr，并在vtable中，查找函数地址代码。

下面再具体看一个实例。

class A{
public:
	virtual void f(void);
	void g(void);
}

class B{
public:
	virtual void f2(void);
	void g(void);
}

class C:public A,public B
{
public:
	void f(void);
	virtual void h(void);
}

        在上面的代码中，基类A、B，派生类C的存储结果为：

              

        派生类C，继承了基类A、B的特性，同样也继承了A、B的vptr和vtable。同时如果在派生类C，如果对函数进行了重写，则将vtable中相应的函数地址改为派生类的重写后的函数地址。如图中红色部分所示。如果派生类还有自己的虚函数，则将派生类虚函数地址放在基类vtable的表末，如果同时继续了多个基类，则放在第一个基类的vtable的表末。如图中的C::h()。所以派生类对象通过基类的指针或引用访问虚函数时，通过地址偏移计算，就可以访问派生类重写的虚函数，实现动态联编。