C++基础（9）多态

1. 多态

1.1 多态基本概念

多态是面向对象程序设计语言中数据抽象和继承之外的第三个基本特征。
多态性(polymorphism)提供接口与具体实现之间的另一层隔离，从而将”what”和”how”分离开来。多态性改善了代码的可读性和组织性，同时也使创建的程序具有可扩展性，项目不仅在最初创建时期可以扩展，而且当项目在需要有新的功能时也能扩展。
c++支持编译时多态(静态多态)和运行时多态(动态多态)，运算符重载和函数重载就是编译时多态，而派生类和虚函数实现运行时多态。
静态多态和动态多态的区别就是函数地址是早绑定(静态联编)还是晚绑定(动态联编)。如果函数的调用，在编译阶段就可以确定函数的调用地址，并产生代码，就是静态多态(编译时多态)，就是说地址是早绑定的。而如果函数的调用地址不能编译不能在编译期间确定，而需要在运行时才能决定，这这就属于晚绑定(动态多态,运行时多态)。

#include<iostream>
using namespace std;
class annimal
{
public:
	void func()
	{
		cout<<"动物在吃东西"<<endl;
	}
};
class cat:public annimal
{
public:
	 void func(){cout<<"猫吃鱼"<<endl;}
};
void test()
{
	annimal *c = new cat;//如果用annimal类开辟了猫类空间会输出？
	c->func();//输出动物在吃东西

}
void main()
{
	test();
}

如果想输出猫在吃东西：就需要使用虚函数来实现

#include<iostream>
using namespace std;
class annimal
{
public:
	virtual void func()
	{
		cout<<"动物在吃东西"<<endl;
	}
};
class cat:public annimal
{
public:
	 virtual void func(){cout<<"猫吃鱼"<<endl;}
};
void test()
{
	annimal *c = new cat;//如果用annimal类开辟了猫类空间会输出？
	c->func();//输出动物在吃东西，因为这是调用的是annimal类的func
	//因此如果想要调用猫的func这是就要定义虚函数,然后父类的指针就会指向cat类的func

}
void main()
{
	test();
}

这里要先引出绑定的概念即：

把函数体与函数调用相联系称为绑定(捆绑，binding)

当绑定在程序运行之前(由编译器和连接器)完成时，称为早绑定(early binding).C语言中只有一种函数调用方式，就是早绑定。

上面的问题就是由于早绑定引起的，因为编译器在只有Animal地址时并不知道要调用的正确函数。编译是根据指向对象的指针或引用的类型来选择函数调用。这个时候由于DoBussiness的参数类型是Animal&,编译器确定了应该调用的speak是Animal::speak的，而不是真正传入的对象Dog::speak。

解决方法就是迟绑定(迟捆绑,动态绑定,运行时绑定，late binding),意味着绑定要根据对象的实际类型，发生在运行。

1.2 虚函数（virtual）

C++动态多态性是通过虚函数来实现的，虚函数允许子类（派生类）重新定义父类（基类）成员函数，而子类（派生类）重新定义父类（基类）虚函数的做法称为覆盖(override)，或者称为重写。
对于特定的函数进行动态绑定，c++要求在基类中声明这个函数的时候使用virtual关键字,动态绑定也就对virtual函数起作用.

• 为创建一个需要动态绑定的虚成员函数，可以简单在这个函数声明前面加上virtual关键字，定义时候不需要.
• 如果一个函数在基类中被声明为virtual，那么在所有派生类中它都是virtual的.
• 在派生类中virtual函数的重定义称为重写(override).
• Virtual关键字只能修饰成员函数.
• 构造函数不能为虚函数

仅需要在基类中声明一个函数为virtual.调用所有匹配基类声明行为的派生类函数都将使用虚机制。可以在派生类声明前使用关键字virtual(这也是无害的)，虽然会使得程序显得冗余和杂乱。但是建议写上，可以提醒程序员。

1.2动态绑定的实现原理

首先，我们看看编译器如何处理虚函数。当编译器发现我们的类中有虚函数的时候，编译器会创建一张虚函数表，把虚函数的函数入口地址放到虚函数表中，并且在类中秘密增加一个指针，这个指针就是vpointer(缩写vptr)，这个指针是指向对象的虚函数表。在多态调用的时候，根据vptr指针，找到虚函数表来实现动态绑定。

#include<iostream>
#include<string>
using namespace std;
class A{
public:
	virtual void func1(){}
	virtual void func2(){}
};

//B类为空，那么大小应该是1字节，实际情况是这样吗？
class B : public A{};

void test(){
	cout << "A size:" << sizeof(A) << endl;
	cout << "B size:" << sizeof(B) << endl;
}
void main()
{
	test();
}

在编译阶段，编译器秘密增加了一个vptr指针，但是此时vptr指针并没有初始化指向虚函数表(vtable),什么时候vptr才会指向虚函数表？在对象构建的时候，也就是在对象初始化调用构造函数的时候。编译器首先默认会在我们所编写的每一个构造函数中，增加一些vptr指针初始化的代码。如果没有提供构造函数，编译器会提供默认的构造函数，那么就会在默认构造函数里做此项工作，初始化vptr指针，使之指向本对象的虚函数表。

起初，子类继承基类，子类继承了基类的vptr指针，这个vptr指针是指向基类虚函数表，当子类调用构造函数，使得子类的vptr指针指向了子类的虚函数表。
当子类无重写基类虚函数时:

Animal* animal = new Dog;
animal->fun1();
当程序执行到这里，会去animal指向的空间中寻找vptr指针，通过vptr指针找到func1函数，此时由于子类并没有重写也就是覆盖基类的func1函数，所以调用func1时，仍然调用的是基类的func1.
执行结果: 我是基类的func1。
测试结论: 无重写基类的虚函数，无意义

当子类重写基类虚函数时:

过程分析:
Animal* animal = new Dog;
animal->fun1();
当程序执行到这里，会去animal指向的空间中寻找vptr指针，通过vptr指针找到func1函数，由于子类重写基类的func1函数，所以调用func1时，调用的是子类的func1.
执行结果: 我是子类的func1

多态的成立条件：

• 有继承

• 子类重写父类虚函数函数
  a) 返回值，函数名字，函数参数，必须和父类完全一致(析构函数除外)
  b) 子类中virtual关键字可写可不写，建议写

• 类型兼容，父类指针，父类引用 指向 子类对象

2. 抽象基类和纯虚函数(pure virtual function)

在设计时，常常希望基类仅仅作为其派生类的一个接口。这就是说，仅想对基类进行向上类型转换，使用它的接口，而不希望用户实际的创建一个基类的对象。同时创建一个纯虚函数允许接口中放置成员原函数，而不一定要提供一段可能对这个函数毫无意义的代码。

在基类中加入至少一个纯虚函数(pure virtual function),使得基类称为抽象类(abstract class).

抽象类无法实例化对象。

• 纯虚函数使用关键字virtual，并在其后面加上=0。使用带有纯虚函数的类去实例化一个对象，编译器会报错，不允许这样做。
• 当继承一个抽象类的时候，必须实现所有的纯虚函数，否则由抽象类派生的类也是一个抽象类。
• Virtual void fun() = 0;告诉编译器在vtable中为函数保留一个位置，但在这个特定位置不放地址。
• 建立公共接口目的是为了将子类公共的操作抽象出来，可以通过一个公共接口来操纵一组类，且这个公共接口不需要事先(或者不需要完全实现)。可以创建一个公共类.

纯虚函数和多继承

多继承带来了一些争议，但是接口继承可以说一种毫无争议的运用了。

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

接口类中只有函数原型定义，没有任何数据定义。
注意:除了析构函数外，其他声明都是纯虚函数。

2.1 虚析构函数

虚析构函数是为了解决基类的指针指向派生类对象，并用基类的指针删除派生类对象。

#include<iostream>
#include<string>
using namespace std;
class annimal
{
public:
	annimal(){}
	//纯虚函数
	virtual void func() =0;
	
	//虚析构函数
	virtual ~annimal()
	{
		cout<<"annimal 析构调用"<<endl; 
	}

};

class cat:public annimal
{
public:
	cat(char * str)
	{
		name = new char[strlen(str)+1];
		strcpy(name,str);
	}
	void func()
	{
		cout<<name<<"吃鱼"<<endl;
	}
	~cat()
	{
		cout<<"cat 析构调用"<<endl;
		if(name != NULL)
		{
			delete[] name;
			name = NULL;
		}
	}
	char * name;
};
void main()
{
	annimal *d = new cat("tom");
	d->func();
	delete d;
	//虚析构函数是为了解决基类的指针指向派生类对象，并用基类的指针删除派生类对象
	//调用了cat的析构，释放了内存空间
}

2.2 纯虚析构函数

纯虚析构函数在c++中是合法的，但是在使用的时候有一个额外的限制：必须为纯虚析构函数提供一个函数体。

那么问题是：如果给虚析构函数提供函数体了，那怎么还能称作纯虚析构函数呢？

纯虚析构函数和非纯析构函数之间唯一的不同之处在于纯虚析构函数使得基类是抽象类，不能创建基类的对象。

#include<iostream>
#include<string>
using namespace std;



//非纯虚析构函数
class A{
public:
	virtual ~A();
};

A::~A(){}

//纯析构函数
class B{
public:
	virtual ~B() = 0;
};

B::~B(){}

void test(){
	A a; //A类不是抽象类，可以实例化对象
	//B b; //B类是抽象类，不可以实例化对象
}

如果类的目的不是为了实现多态，作为基类来使用，就不要声明虚析构函数，反之，则应该为类声明虚析构函数。

3. 重写 重载 重定义的区别

• 重载，同一作用域的同名函数

1. 同一个作用域
2. 参数个数，参数顺序，参数类型不同
3. 和函数返回值，没有关系
4. const也可以作为重载条件 //do(const Teacher& t){} do(Teacher& t)

• 重定义（隐藏）

1. 有继承
2. 子类（派生类）重新定义父类（基类）的同名成员（非virtual函数）

• 重写（覆盖）

1. 有继承
2. 子类（派生类）重写父类（基类）的virtual函数
3. 函数返回值，函数名字，函数参数，必须和基类中的虚函数一致

代码实现：

class A{
public:
	//同一作用域下，func1函数重载
	void func1(){}
	void func1(int a){}
	void func1(int a,int b){}
	void func2(){}
	virtual void func3(){}
};

class B : public A{
public:
	//重定义基类的func2,隐藏了基类的func2方法
	void func2(){}
	//重写基类的func3函数，也可以覆盖基类func3
	virtual void func3(){}
};