C++ 多态以及多态的原理

多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会 产生出不同的状态
比如，买票时都是同一个景点有学生票半价和成人票全价等等

多态的构成条件

多态的构成条件主要涉及两个概念：虚函数和继承。
虚函数

• 虚函数是C++中用于实现运行时多态性的关键概念。
• 被virtual修饰的类成员函数称为虚函数

class Person {
public:
	//虚函数
	virtual void BuyTicket() 
	{
		//....
	}
};

在继承中构成多态还需要满足两个条件

• 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
• 父类的指针或者引用进行调用

举个栗子

class Person {
public:
	//虚函数
	virtual void BuyTicket() 
	{
		cout << "买票-全价" << endl;
	}
};
class Student : public Person
{
  //重写基类函数
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
};
//必须是基类对象指针或引用调用
void Func(Person& people)
{
	people.BuyTicket();
}
void Test()
{
	Person Mike;
	Func(Mike);
	Student Johnson;
	Func(Johnson);
}
int main()
{
	Test();
	return 0;
}

父类对象和子类对象调用同一个函数，得到的结果不一样

运行结果：

解释：

虚函数的重写

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

在上面的例子中 派生类Student中的BuyTicket函数就重写了基类Person的虚函数

虚函数重写的两个例外

1. 协变
   派生类重写基类虚函数时，与基类虚函数返回值类型不同，且返回值必须是父子关系的指针或者引用。即基类虚函数返回基类对象的指 针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。
   比如

class Person
{
public:
	// 基类虚函数返回基类指针
	virtual Person* BuyTicket() 
	{
		return new Person();
	}
};
class Student : public Person
{
	// 派生类协变，返回更具体的类型 Student*
	virtual Student* BuyTicket()
	{
		return new Student();
	}
};

上面例子中也构成虚函数的重写，派生类和基类的返回值不同,称为协变

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

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

运行结果：

12行加不加virtual关键字 都构成重写

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

C++11 final 和 override关键字

C++对函数重写的要求比较严格，有些情况可能由于疏忽，导致无法构成重写，这种情况编译器不会报错，程序会正常运行，但是得到的结果不是正确的，所以C++11引入了final和override关键字

• final 修饰虚函数，表示该虚函数不能再被重写

class Person
{
	virtual void Func() final
	{
		cout << "virtual void Func() final" << endl;
	}
};

class Student : public Person
{
	virtual void Func()//error
	{
		cout << "virtual void Func()" << endl;
	}
};

编译时报错：

• override 检查派生类是否重写了基类虚函数。如果没重写，编译器会报错。

class Person
{
public:
	virtual void Func() const 
	{
		cout << "virtual void Func() " << endl;
	}
};

class Student : public Person
{
public:
	virtual void Func() override//error 派生类没有正确重写基类Func函数  编译器会报错，少了const修饰
	{
		cout << "virtual void Func()" << endl;
	}
};

抽象类

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

class Person
{
public:
	virtual void Abstract() = 0;//纯虚函数  Person类为抽象类  Person类不能实例化出对象
};

//派生类
class Student : public Person
{
public:
	virtual void Abstract() override//派生类必须重写纯虚函数，派生类才可以实例化出对象，否则不行
	{
		cout << "Hello World\n";
	}

};
int main()
{
	//Person p1; //error 抽象类无法实例化对象
	Student s1;
	Person* s1prt = &s1;
	//使用基类指针访问
	s1prt->Abstract();
	return 0;
}

接口继承和普通继承

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

多态的原理

虚函数表

#include <iostream>
using namespace std;
class Person
{
public:
	virtual void Func();
private:
	int _a;
	char _b;
};
int main()
{
	cout << sizeof(Person) << endl;
	return 0;
}

上面代码求Person所占字节数大小
按照内存对齐的规则，Person类的大小应该是8(32位下）。
但实际结果是12

这里不仅要内存对齐，当实例化一个对象后发现，成员变量不仅仅只有_a,和_b 。还有一个指针_vfptr(虚函数表指针)

• 一个含有虚函数的类都会有至少一个虚函数表指针，虚函数表指针存放在对象的前4个字节或者前8个字节(32位下4个字节，64位下8个字节)。
• 而虚函数的地址会被存放到虚函数表中。虚函数表也简称为虚表
• 虚函数表指针指向虚表。
• 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr(VS编译器下做了处理，g++没有处理)

一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。
通过下面的代码进行分析派生类中的虚表。

class Person
{
public:
  virtual void Func()
  {
  	cout << "virtual void Func()" << endl;
  }
  virtual void Func2()
  {
  	cout << "virtual void Func()" << endl;
  }
  void Func3()//普通函数
  {
  	cout << "void Func3()" << endl;
  }
private:
  int _a = 0;
  char _b = 0;
};
class Student : public Person
{
  virtual void Func() override//重写基类函数
  {
  	cout << "virtual void Func()" << endl;
  }
};
int main()
{	
  Person p1;//基类对象
  Student s1;//派生类对象
  return 0;
}

• Person类中有两个虚函数，一个非虚函数。
• Student继承了Person类，并且重写了Func函数。
• 实例化出基类和派生类对象 监视窗口如下
  
  可以发现：
• 派生类对象也有一个虚表指针，虚表由两部分组成，一部分是继承基类的成员，另一部分是自己的成员。
• 基类对象和派生类对象的虚表是不一样的，派生类重写了基类的Func虚函数，所以派生类对象虚表中存的是派生类重写后的函数地址。所以虚函数的重写也覆盖，覆盖值得是虚表中虚函数的覆盖，重写是语法的叫法，覆盖是底层的原理。
• Func2虚函数被继承下来后也会被放到虚表中，Func3也会被继承下来，但是Func3不是虚函数，所以不会放到虚表中

多态的原理

class Person {
public:
	//虚函数
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
};
class Student : public Person
{
	//重写基类函数
	virtual void BuyTicket()
	{
		cout << "买票-半价" << endl;
	}
};
//必须是基类对象指针或引用调用
void Func(Person& people)
{
	people.BuyTicket();
}
void Test()
{
	Person p1;
	Func(p1);
	Student s1;
	Func(s1);
}

对于上面的例子

• 当people指向的是基类对象时，people.BuyTicket();就会在基类对象p1中的虚表中找到对应虚函数
• 当people指向的是派生类对象时，，people.BuyTicket();就会在派生类对象s1中的虚表中找到对应的虚函数
• 通过虚表，实现了了不同对象去完成同一行为时，展现出不同的形态。

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

单继承中的虚函数表

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;
};
int main()
{
	Base b1;
	Derive d1;
	return 0;
}

• 上面代码中基类Base有两个虚函数
• 派生类Derive继承了Base类，并且重写了func1函数，且新增了两个虚函数func3 和func4

单继承对象模型：

通过监视窗口发现：派生类中新增的虚函数func3 和func4 没有进虚函数表。(不知道是编译器故意的 还是编译器的
bug)

我们可以利用程序自己打印虚表来观察，参考代码如下。

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 (*VF_Ptr)();//函数指针
//VF_Prt table[];//函数指针数组

//打印虚函数表
void PrintVFTable(VF_Ptr table[])
{
	for (int i = 0; table[i] != nullptr; ++i)
	{
		printf("table[%d] = %p\n", i, table[i]);
                
		VF_Ptr Fun = table[i];//取出函数地址对其进行访问
		Fun();
	}
	cout << endl;
}
int main()
{
	Base b1;
	Derive d1;
	//虚函数表指针在对象的头四个字节(32位下), 拿到对象的地址对其强制类型转换:(int*)&p1
	//在解引用就能拿到对象前四个字节地址:*((int*)&p1)，在将其强制类型转换位函数指针：(VF_Ptr*)(*(int*)&p1)
	PrintVFTable((VF_Ptr*)(*(int*)&b1));
	PrintVFTable((VF_Ptr*)(*(int*)&d1));
	return 0;
}

运行结果:

可以看出，不论是派生类还是基类，只要是虚函数都会存到虚表中

多继承中的虚函数表

class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int _a;
};
class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
    int _b;
};
class Derive : public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int _d;
};

多继承对象模型：
多继承对象模型对比单继承模型就复杂很多

派生类会有两个虚表，监视窗口仍然无法观察， 通过程序打印查看

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);
        //派生类第二个虚表指针需要加行Base对象大小的偏移量才能获得
	VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
	PrintVTable(vTableb2);
	return 0;
}

结果如下

和上面的对象模型一样。
可以发现：
多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中