---

一、多态的概念

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://重写Person1void test01(){}//重写Person2void test02() {}void test03(){}
protected:int _b;
};void test()
{Student s;
}

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