目录

1. 多态的概念

2. 多态的定义及实现

2.1多态的构成条件

2.2 虚函数

2.3 虚函数的重写

2.3.1 虚函数重写的两个例外

2.4 C++11 override 和 fifinal

2.5 重载、覆盖(重写)、隐藏(重定义)的对比

2.6 多态示例

3. 抽象类

3.1 概念

3.2 接口继承和实现继承

4. 多态的原理

4.1 虚函数表

4.2 多态原理总结

4.3 动态绑定与静态绑定

5. 单继承和多继承关系中的虚函数表

5.1 单继承中的虚函数表

5.2 多继承中的虚函数表

1. 多态的概念 多态的概念： 通俗来说，就是多种形态， 具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态 。

2. 多态的定义及实现

2.1多态的构成条件

（1）多态是不同继承关系的类对象，去调用同一函数，产生了不同的行为。

（2）必须通过基类的指针或者引用调用虚函数。

（3）被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写（覆盖）。

2.2 虚函数 （1） 虚函数：即 被virtual修饰 的 类成员函数 称为虚函数。

class Person {
public:
 virtual void BuyTicket() { cout << "全票" << endl;}
};

2.3 虚函数的重写 虚函数的重写 ( 覆盖 ) ： 派生类中有一个跟基类完全相同的虚函数 ( 即 派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同 ) ，称子类的虚函数重写了基类的虚函数。

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

class A{};
class B : public A {};
class Person {
public:
 virtual A* f() {return new A;}
};
class Student : public Person {
public:
 virtual B* f() {return new B;}
};

（2）析构函数的重写(基类与派生类析构函数的名字不同)

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

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能
// 构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;
	return 0;
}

2.4 C++11 override 和 fifinal （1）fifinal：修饰虚函数，表示该虚函数不能再被继承

class Car
{
public:
 virtual void Drive() final {}
};
class Benz :public Car
{
public:
 virtual void Drive() {cout << "Benz-舒适" << endl;}
};

（2） override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

class Car{
public:
 virtual void Drive(){}
};
class Benz :public Car {
public:
 virtual void Drive() override {cout << "Benz-舒适" << endl;}
};

2.5 重载、覆盖(重写)、隐藏(重定义)的对比

（1）重载：在同一作用域中，函数名相同，参数不同。

（2）重写（覆盖）：①两个函数分别在基类和派生类的作用域，返回值、参数、函数名都相同（协变、析构函数的重写例外）。②两个函数必须是虚函数。③重写是语法的叫法，覆盖是原理层的叫法。

（3）重定义（隐藏）：①两个函数或者成员变量分别在基类和派生类的作用域。②函数名或者成员变量名相同。③两个基类和派生类的函数，不构成重写就是重定义。

2.6 多态示例

class Person
{
public:
	virtual void BuyTicket(void)
	{
		cout << "全票" << endl;
	}
};
class Student : public Person
{
public:
    //不带virtual也构成重写，在父类那里继承了虚属性
    //构成重写（覆盖）
	virtual void BuyTicket(void) 
	{
		cout << "半票" << endl;
	}
};
void fun(Person& people)
{
	people.BuyTicket();
}
int main()
{
	Person A;
	Student B;
	fun(A);//多态
    fun(B);//多态
	return 0;
}

3. 抽象类

3.1 概念 在虚函数的后面写上 =0 ，则这个函数为纯虚函数。 包含纯虚函数的类叫做抽象类（也叫接口类），抽象类 不能实例化出对象 。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

 

3.2 接口继承和实现继承 普通函数的继承是一种实现继承 ，派生类继承了基类函数，可以使用函数，继承的是函数的实现。 虚函数的继承是一种接口继承 ，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以 如果不实现多态，不要把函数定义成虚函数。  

4. 多态的原理

4.1 虚函数表 含有虚函数的类实现出来的对象中，都有一个 __vfptr 放在对象的前面 ( 注意有些平台可能会 放到对象的最后面，这个跟平台有关 ) ，对象中的这个指针我们叫做虚函数表指针 (v 代表 virtual ， f 代表 function) 。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

4.2 多态原理总结 （1） 派生类对象 d 中也有一个虚表指针， d 对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的，另一部分是自己的成员。 （2） 基类 b 对象和派生类 d 对象虚表是不一样的，这里我们发现 Func1 完成了重写，所以 d 的虚表中存的是重 写的 Derive::Func1 ，所以虚函数的重写也叫作覆盖 ，覆盖就是指虚表中虚函数的覆盖。 重写是语法的叫法，覆盖是原理层的叫法。 （3） 另外 Func2 继承下来后是虚函数，所以放进了虚表， Func3 也继承下来了，但是不是虚函数，所以不会放进虚表。 （4） 虚函数表本质是一个存虚函数指针的指针数组 ，这个数组最后面放了一个 nullptr 。 （5） 总结一下派生类的虚表生成： a. 先将基类中的虚表内容拷贝一份到派生类虚表中 b. 如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c. 派生类自己新增加的虚函数按其在派生类中的 声明次序增加到派生类虚表的最后。 （6） 虚表存的是虚函数指 针，不是虚函数 ，虚函数和普通函数一样，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。虚表存在 代码段（VS下）。 （7） 满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到 对象的中取找的。不满足多态的函数调用时编译时确认好的。

4.3 动态绑定与静态绑定 1. 静态绑定又称为前期绑定 ( 早绑定 ) ， 在程序编译期间确定了程序的行为，也称为静态多态 ，比如： 函数重载 2. 动态绑定又称后期绑定 ( 晚绑定 ) ， 是在程序运行期间 ，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为 动态多态（父类指针或引用调用重写虚函数：①父类指针或者引用指向父类，调用的就是父类的虚函数。②子类指针或者引用指向子类，调用的就是子类的虚函数。） 。

5. 单继承和多继承关系中的虚函数表

5.1 单继承中的虚函数表

//单继承中的虚函数表
class Base {
public:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int a;
};
class Derive :public Base {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
	virtual void func4() { cout << "Derive::func4" << endl; }
private:
	int b;
};

typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}
int main()
{
	Base b;
	Derive d;
	// 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数指
	//针的指针数组，这个数组最后面放了一个nullptr
		// 1.先取b的地址，强转成一个int*的指针
		// 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
		// 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
		// 4.虚表指针传递给PrintVTable进行打印虚表
		// 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面
		//没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的 - 生成 - 清理解决方 
        //案，再编译就好了。
	VFPTR * vTableb = (VFPTR*)(*(int*)&b);
	PrintVTable(vTableb);
	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
	PrintVTable(vTabled);
	return 0;
}

5.2 多继承中的虚函数表

//多继承中的虚函数表
class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1;
};
class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2;
};
class Derive : public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1;
};
typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}
//多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中
int main()
{
	Derive d;
	VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
	PrintVTable(vTableb1);
	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	PrintVTable(vTableb2);
	return 0;
}