面向对象编程：多态性（C++）

一、简介

1、介绍：同样的消息给各种不同的对象时，会产生多种形式的结果，这就是多态性。

注：
（1）、继承层次中的对象
（2）、消息是重载的函数 （因为重载的函数的签名才会一样，即函数名和类型）

2、多态性能设计和实现更具扩展性的软件系统。
3、多态性的两个底层技术：虚函数和动态绑定

（一）、静态绑定：系统在编译时就确定如何实现某一动作；
（二）、动态绑定：系统在运行时动态实现某一动作（在编译时不确定执行哪段代码）。

4、多态发生的两个要素：
（1）、虚函数的调用；
（2）、指向派生类对象或引用的基类指针（它们不同时刻指向不同派生类的对象）。

二、类继承层次中对象之间的关系

1、派生类对象可以被当做它的基类对象来处理。

不能把基类对象当做任何一个派生类的对象来处理。

GraduateStudent gs;//实例化一个派生类对象gs Student s = gs;//基类对象指向派生类对象 Student &t = gs;//基类的引用可以指向派生类 Student *p = &gs;//基类的指针可以指向派生类对象  gs = s;//错误，不可以派生类对象指向基类对象 GraduateStudent *pGs = &s;//错误，派生类指针不可以指向基类对象 

2、调用的函数功能是由调用函数的句柄（指针或引用）决定的，而不是由句柄所指向的对象类型决定。
例如：

/*一个基类指针指向派生类*/ commissionEmployeePtr = &basePlusCommissionEmployee;//commissionEmployeePtr为基类指针，basePlusCommissionEmployee为派生类对象 commissionEmployeePtr -> print();//print函数功能是由基类决定的，不是派生类。找句柄所属类的对象。 

3、通过基类指针调用派生类的成员函数：

1、基类指针指向派生类对象，并试图访问只在派生类中拥有的成员函数，会产生编译错误（派生类中有的成员函数基类中没有）。
2、显示把基类指针强制转化为派生类指针（向下强制类型转换），可以通过指向派生类对象的基类指针访问只在派生类中拥有的成员。

例如：

/*getBaseSalary(),setBaseSalary()为派生类中的函数；commissionEmployeePtr为基类指针*/ double baseSalary = commissionEmployeePtr ->getBaseSalary(); commissionEmployeePtr -> setBaseSalary(500);//两条语句错误。 

以上情况可以用强制类型转换的方法，把基类指针commissionEmployeePtr转换成派生类指针。

4、虚函数（动态绑定）
利用虚函数，调用哪个版本的虚函数就由句柄所指向的对象类型决定，而非句柄的类型。

虚函数的定义在函数原型前加关键字virtual.函数原型和实现都加关键字。

注意:动态的绑定只发生句柄必须是基类的指针或引用，发送消息的函数是虚函数；如果是一个确定的基类对象和派生类对象，没有动态的性质。

举例：

/*以下print()函数全是virtual函数*/ commissionEmployeePtr = &commissionEmployee;//基类指针指向基类对象 commissionEmployeePtr -> print();//此处的print()自然找基类的print()执行  basePlusCommissionEmployeePtr = &basePlusCommissionEmployee;//派生类指针指向派生类对象 basePlusCommissionEmployeePtr -> print();//print()找派生类中的print()操作  commissionEmployeePtr = &basePlusCommissionEmployee;//基类指针指向派生类对象 commissionEmployeePtr -> print();//此处print()将调用派生类中的print（）函数 

（1）、派生类中重载的函数必须和在基类中的具有相同的原型，如以上的print函数。
（2）、用虚函数进行 动态绑定，只能通过指针或引用句柄来实现。
（3）、一旦一个函数声明为virtual,那么从整个继承层次的那一点向下的所有类中，它将保持virtual的，即使当派生类重写此函数时并没有显示的将它声明为virtual.
（4）、当派生类选择不重写从其基类继承而来的virtual函数时，派生类就会简单地继承它的基类的virtual函数的实现。

三、抽象类和纯virtual函数

1、抽象类：有些类通常在类的继承层次结构中作为基类，从来不实例化任何对象，这种类称为抽象类。

注：
（1）、抽象类是不完整的，派生类必须定义缺少的部分。
（2）、构造一个抽象类的目的就是为其它的类提供合适的基类。
（3）、能实例化对象的类称为具体类，具体类实现了它所定义的每一个成员函数。

2、通过声明类的一个或多个virtual函数为纯虚函数，就能定义其为抽象类。

纯虚函数定义： virtual void draw() = 0; 

3、纯虚函数不提供函数的具体实现，每个派生的具体类必须重写所有类的纯虚函数的定义。
4、抽象类为类层次结构中的各种类定义公共的接口。抽象类包含一个或多个纯虚函数，这些函数必须在派生类中重写。

（1）、试图实例化抽象类的对象将导致编译错误。
（2）、未能在派生类中重写纯virtual函数，然后试图实例化这个派生类对象将产生编译错误。

四、应用向下强制类型转换

1、向下强制类型转换

BasePlusCommissionEmployee *derivedPtr = dydynamic_cast<BasePlusCommissionEmployee *> (employee[i]);  返回值：derivedPtr不为零，说明其指向一个BasePlusCommissionEmployee 对象 否则，它指的不是这种BasePlusCommissionEmployee 的对象。 

返回运算符操作数类型的信息（要写出类型的名字）

cout << typeid(int).name() << endl; 或  int a ; cout << typeid(a).name() << endl; 输出的都是int 

五、virtual析构函数

1、将基类的析构函数声明为虚析构函数，这样就会使所有派生类的析构函数自动成为虚析构函数（即使它们与基类析构函数名不同）。
2、当基类指针指向其派生类对象，用delete删除基类指针时，就会调用其所指对象（即其对应派生类）的析构函数，所有类的析构函数将执行，如果派生类要求执行析构函数，那么基类必须声明为虚析构函数。

class A { public: A() {} virtual ~A(); }; A::~A() {        cout << "~A"<< endl; } 

class B:public A { public: B(int); virtual~B(); private: int *b; };  B::B(int n) {    b = new int(n);//实例化B类对象 }  B::~B() {    cout << "~B" << endl; delete b;//要回收开辟的 } 

在继承层次关系中，在某一层出现开辟空间的操作，则要把析构函数声明为虚析构函数。

3、构造函数不能是virtual函数。

六、（补充）类模板和模板类

1、类模板和模板类
所谓类模板，实际上是建立一个通用类，其数据成员、成员函数的返回类型和形参类型不具体指定，用一个虚拟的类型来代表。
使用类模板定义对象时，系统会根据实参的类型（模板实参）来取代类模板中虚拟类型从而实现了不同类的功能。
2、定义一个类模板，格式如下：

template<typename Type> class 类名 {    类成员函数 } 1、template是一个声明模板的关键字 2、Type是类型参数（自定义）  或 template<class Type> class 类名 {    类成员函数 } 

例如：建立一个用来实现求和的类模板

类模板定义对象时用以下形式

类模板名<实际类型名> 对象名[{实参表列}] int main() {    Three <int> sum3_1(3,5,7);//用类模板定义对象sum3_1,此时T被int取代    Three <double> sum3_2(12.34,34.56,56.78);//用类模板定义对象sum3_2,此时T被double取代    cout << "三个整数之和是" << sum3_1.sum() << endl;    cout << "三个双精度数之和是:" << sum3_2.sum() << endl; return 0; 

3、类模板中的成员函数可以在类模板体外定义。此时，若成员函数中有类型参数存在，则C++有一些特殊的规定：
（1）、需要在成员函数定义之前进行模板声明；
（2）、在成员函数名前缀上“类名<类型参数>::”
在类模板体外定义的成员函数的一般形式如下：

template <typename 类型参数> 函数类型 类名<类型参数>::成员函数（形参表） { ........... } 

例如，上例这种成员函数Three在类模板体外定义时，应该写成：

template<typename T> T Three<T>::sum() { return x + y + z; }