---

一、多态的概念

1、概念：
多态就是具有多种形态，可以理解为同一个行为不同对象去完成表现出不同的状态，如：

二、多态使用

1、构成多态的条件
（1）派生类要对基类虚函数进行重写。
（2）通过基类指针或引用调用虚函数。

2、虚函数
关键字：virtual，加在函数声明前面，并且该函数是非静态成员函数。
如：

3、函数重写
（1）条件：
派生类重写的函数返回值、函数名称、函数参数与基类相同。

（2）使用

class Person {
public:
//虚函数
	virtual void test01()
	{
		//...
	}
};
class Student : public Person {
public:
	//重写 virtual关键字在派生类中写不写都可
	virtual void test01()
	{
		//...
	}
};

（3）例外
协变：
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指
针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

class Person {
public:
	virtual  Person& test01()
	{
		//...
	}
};
class Student : public Person {
public:
	//重写 返回值是继承关系
	virtual  Student& test01()
	{
		//...
	}
};

析构函数：
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，
都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，
看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处
理，编译后析构函数的名称统一处理成destructor。

如果出现以下情况就会出现子类没有析构

class Person {
public:
	 ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	~Student() { cout << "~Student()" << endl; }
};

void test()
{
	//情况
	//不重写析构函数时
	Person* p = new Student;
	delete p;
}

如果重写之后调用调用子类的析构，子类的析构再去调用父类析构就不会出现以上情况了。

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

void test()
{
	Person* p = new Student;
	delete p;
}

（3）重载、重定义（隐藏）、重写的区别
重载：同一作用域下，函数名相同，参数（类型、个数、顺序）不同。
重定义：作用域不同（派生类域、基类域），函数名相同。
重写：作用域不同（派生类域、基类域），必需是虚函数，函数名相同、返回类型相同、参数相同。
（4）使用多态

class Person {
public:
	//虚函数
	virtual void test01() {
		cout << "Person" << endl;
	}
protected:
	int _a;
};

class Student : public Person {
public:
	virtual void test01() {
		cout << "Student" << endl;
	}
protected:
	int _b;
};

void Print(Person* pp)
{
	pp->test01();
}

void test()
{
	Person p;
	Student s;
	//基类对象，传给基类指针pp，pp还是基类 ->不构成多态，依然使用基类的函数
	Print(&p);

	//派生类对象，传给基类指针pp，pp指向的是派生类-> 构成多态，使用的是派生类重写的函数
	Print(&s);
}

4、抽象类
（1）纯虚函数
在虚函数声明后面加上 =0 就是纯虚函数了。

virtual void test01() = 0;

（2）
拥有纯虚函数的类叫做抽象类，抽象类不能被实例化，当派生类继承抽象类后，必须重写抽象类中的纯虚函数，不然该派生类依旧还是抽象类，不能被实例化。

//抽像类
class Person {
public:
	//纯虚函数
	virtual void test01() = 0;
};
class Student : public Person {
public:
	//重写纯虚函数
	virtual void test01()
	{
		cout << "virtual void test01()" << endl;
	}
};

三、多态的原理

1、虚函数表
一个类中存在虚函数是会生成一个指针，该指针指向的内容就是虚函数表。
在x86环境下：

//抽像类
class Person {
public:
	//虚函数
	virtual void test01() {};
protected:
	int _a;
};

void test()
{
	Person p;
	cout << sizeof(Person) << endl;
}

当派生类继承基类时也会产生一个虚函数指针，该指针指向的内容一部分是从父类继承下来的，一部分是重写的。

test01()使用了派生类的，test02()没有重写，还是使用基类的。

2、多态原理

满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的（运行时确定）。

3、动态绑定和静态绑定

1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，
   比如：函数重载
2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体
   行为，调用具体的函数，也称为动态多态。

4、多继承与多态

class Person1{
public:
	//虚函数
	virtual void test01() {};

protected:
	int _a;
};

class Person2 {
public:
	//虚函数
	virtual void test02() {};

protected:
	int _b;
};

class Student : public Person1, public Person2 {
public:
	//重写Person1
	void test01()
	{}
	//重写Person2
	void test02() 
	{}
	void test03()
	{}
protected:
	int _b;
};

void test()
{
	Student s;
}

多继承时每个基类会生成相应的虚函数指针。