15 - 多态

面向对象新需求

根据实际的对象类型来判断重写函数的调用，如果父类指针指向的是父类对象则调用父类中定义的函数，如果父类指针指向的是子类对象则调用子类中定义的重写函数。

C++中通过virtual关键字对多态进行支持，使用virtual声明的函数被重写后即可展现多态的特性。

多态是设计模式的基础，多态是框架的基础。

#include <iostream>

using namespace std;

class HeroFighter
{
public:
	virtual int ackPower()
	{
		return 10;
	}
};

class AdvHeroFighter : public HeroFighter
{
public:
	virtual int ackPower()
	{
		return HeroFighter::ackPower() * 2;
	}
};

class enemyFighter
{
public:
	int destoryPower()
	{
		return 15;
	}
};

//如果把这个结构放在动态库里面
//写了一个框架，可以调用
//我的第3代战机代码出现的时间晚于框架出现的时间。。。。
//框架 有使用后来人 写的代码的能力。。。
//面向对象3大概念
/*
封装
	突破了C语言函数的概念。。

继承
	代码复用 。。。。复用原来写好的代码。。。

多态
	多态可以使用未来。。。。。80年代写了一个框架。。。。。。90人写的代码
	多态是我们软件行业追寻的一个目标。。。

*/
//
void objPK(HeroFighter* hf, enemyFighter* enemyF)
{
	if (hf->ackPower() > enemyF->destoryPower())
	{
		printf("英雄打败敌人。。。胜利\n");
	}
	else
	{
		printf("英雄。。。牺牲\n");
	}
}

int main()
{
	HeroFighter hf;
	enemyFighter ef;

	objPK(&hf, &ef);

	AdvHeroFighter advhf;

	objPK(&advhf, &ef);
	system("pause");
}

 

多态的理论基础

静态联编和动态联编

联编是指一个程序模块、代码之间互相关联的过程。

静态联编（static binding），是程序的匹配、连接在编译阶段实现，也成为早期匹配。重载函数使用的就是静态联编。

动态联编，是指程序联编推迟到运行时进行，所以又称为晚期联编（迟绑定）。switch和if就是动态联编。

C++与C相同，是静态编译型的语言，在编译时，编译器自动根据指针的类型判断指向的是一个什么样的对象，所以编译器认为父类指针指向的是父类对象。

由于程序没有运行，所以父类指针指向的具体是父类对象还是子类对象，从程序的安全角度，编译器假设父类指针只会指向父类对象，因此编译的结果为调用父类的成员函数。这种特性就是静态联编。

多态的理解

如果想要实现多态需要在有继承、有virtual重写、有父类指针（引用）指向子类对象的基础上。virtual关键字，告诉编译器这个函数要支持多态，不是根据指针类型判断如何调用，而是要根据指针所指向的实际对象类型来判断如何调用。

多态的表现形式为同样的调用语句有不同的表现形态，通过动态联编和静态联编，根据实际的对象类型来判断重写函数的调用。

多态的原理

当类中声明虚函数时，编译器会在类中生成一个虚函数表，虚函数表是一个存储类成员函数指针的数据结构，虚函数表是由编译器自动生成与维护的，virtual成员函数会被编译器放入虚函数表中，存在虚函数时，每个对象中都有一个指向虚函数表的指针(vptr指针)

编译器为每个类的对象提供一个虚表指针vptr，这个指针指向对象所属类的虚函数表。在程序运行时，根据对象的类型去初始化vptr，从而让vptr正确的指向所属类的虚表，从而在调用虚函数时，就能够找到正确的函数。

父类的指针实际指向的对象类型是子类的对象，因此vptr指向的子类的方法，当调用时，根据虚表中的函数地址找到的就是子类的对应函数。正是由于每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了虚表指针的正确初始化是非常重要的。换句话说，在虚表指针没有正确初始化之前，我们不能够去调用虚函数。

通过虚函数表指针vptr调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上，虚函数的效率要低很多。出于效率考虑，没有必要将所有成员函数都声明为虚函数

对象在创建的时,由编译器对vptr指针进行初始化，只有当对象的构造完全结束后vptr的指向才最终确定，到底是父类对象的vptr指向父类虚函数表还是子类对象的vptr指向子类虚函数表。

虚函数和纯虚函数

虚函数是为了方便使用多态特性，我们常常需要在基类中定义虚函数。

纯虚函数是为了实现多态性，自己不去实现过程，让继承他的子类去实现。在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。 这时我们就将动物类定义成抽象类，也就是包含纯虚函数的类，纯虚函数就是基类只定义了函数体，没有实现过程：

虚函数中的函数是实现的哪怕是空实现，它的作用是这个函数在子类里面可以被重载，运行时动态绑定实现动态，而纯虚函数是个接口，是个函数声明，在基类中不实现，要等到子类中去实现。

虚函数在子类里可以不重载，但是虚函数必须在子类里去实现。

重写、重载、重定义

函数重载：必须在同一类进行，子类无法重载父类的函数，父类同名函数将被名称覆盖。重载是编译期间根据参数类型和个数决定函数的调用。

函数重写：必须发生于父类与子类之间，并且父类与子类中的函数必须有完全相同的原型。使用virtual声明之后能够产生多态（如果不使用virtual，那就叫做重定义了。）

 

构造函数中能调用虚函数，实现多态吗？

对象在创建的时,由编译器对VPTR指针进行初始化 ，只有当对象的构造完全结束后vptr的指向才最终确定。

父类对象的VPTR指向父类虚函数表。

子类对象的VPTR指向子类虚函数表。

因此，构造函数时不能调用虚函数的。

 

纯虚函数和抽象类

 

有关多继承的说明

在工程上，多继承是被实际开发经验所抛弃的，在开发过程中，真正意义上的多继承几乎是不被使用的。多继承带来的代码复杂性远多于其带来的便利。

多重继承对代码维护性上的影响是灾难性的，在设计方法上，任何多继承都可以用单继承代替。

 

多继承的应用场景

绝大多数面向对象语言都不支持多继承，绝大多数面向对象语言都支持接口的概念。C++中没有接口的概念，但是可以使用纯虚函数来实现接口。

接口类当中只有函数原型定义，没有任何数据的定义。

class Interface
{
public:
    virtual void func1() = 0;
    virtual void func2(int i) = 0;
    virtual void func3(int i) = 0; 
};

多重继承接口不会带来二义性和复杂性等问题，多重继承可以通过精心设计用单继承和接口来代替。接口只是一个功能说明，而不是功能的实现。子类需要根据功能说明定义功能实现。

#include "iostream"
using namespace std;

/*
C++中没有接口的概念
C++中可以使用纯虚函数实现接口
接口类中只有函数原型定义，没有任何数据的定义。
*/

class Interface1
{
public:
	virtual void print() = 0;
	virtual int add(int a, int b) = 0;
};

class Interface2
{
public:
    virtual void print() = 0;
	virtual int add(int a, int b) = 0;
	virtual int minus(int a, int b) = 0;
};

class parent
{
public:
	int a;
};
class Child : public parent, public Interface1, public Interface2
{
public:  
	void print()
	{
		cout<<"Child::print"<<endl;
	}

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

	int minus(int a, int b)
	{
		return a - b;
	}
};

int main()
{
	Child c;

	c.print();

	cout<<c.add(3, 5)<<endl;
	cout<<c.minus(4, 6)<<endl;

	Interface1* i1 = &c;  
	Interface2* i2 = &c;

	cout<<i1->add(7, 8)<<endl;
	cout<<i2->add(7, 8)<<endl;
	system("pause");
}