【C++】多态

        简单来说，多态就是多种形态，指不同的对象去完成某个行为会产生不同的结果。

        例如，逢年过节车站在买车票，普通人买票时，是全价票；学生买票时，是特价票；军人买票时是优先票。又例如，由动物类继承出鸡类和狗类，动物类有“叫()”的动作，而鸡类会“啼叫()”，狗类则会“吠叫()”。

        本篇博客总结了多态的相关用法，旨在解读多态的常见疑问和背后的思想。

目录

一、多态的定义

1、构成多态的条件

2、虚函数与虚函数的重写

3、关键字 override 和 final（C++11）

4、函数的重载重写（覆盖）、重定义（隐藏）的对比

二、多态的原理

1、虚函数表

2、多态的底层

3、静态绑定与动态绑定

三、继承关系中的虚函数表

1、单继承中的虚函数表

2、多继承中的虚函数表

3*、菱形继承和菱形虚拟继承

四、抽象类

补、相关面试题

---

一、多态的定义

1、构成多态的条件

        具体来说，多态是指，在一个继承体系中的不同类对象，去调用同一函数，产生了不同的行为。例如，Student类继承了Person类，Person对象买票全价，Student对象买票半价。

        此外，在继承中要构成多态还有两个条件：

1. 必须通过基类的指针或者引用调用虚函数；
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。

class Person
{
public: 
	virtual void BuyTicket()const
	{
		cout << "买票-全价" << endl;
	}
};
class Student :public Person
{
public:
	virtual void BuyTicket()const
	{
		cout << "买票-半价" << endl;
	}
};

void func(const Person& p)
{
	p.BuyTicket();
}

int main()
{
	//不同的对象传递后，会调用不同的函数
	func(Person());
	func(Student());
	//多态调用取决于指向的对象
	//普通对象取决于当前的对象类型
	//构成多态的条件：
	//1.调用的函数必须是重写的虚函数
	//2.函数的参数必须是基类（父类）的指针或引用
}

2、虚函数与虚函数的重写

        被关键字 virtual 修饰的类成员函数称为虚函数。例如：

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

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

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

class Student : public Person {
public:
     virtual void BuyTicket() { cout << "买票-半价" << endl; }
 
     /*void BuyTicket() { cout << "买票-半价" << endl; }*/
     /*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因
     为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议
     这样使用*/
};

void Func(Person& p) { p.BuyTicket(); }

int main()
{
     Person ps;
     Student st;
 
     Func(ps);
     Func(st);

     ps = st;
     Person* ptr = &st;
     Person& ref = st;
     return 0;
}

        虚函数重写存在两个例外，一个是协变，一个是析构函数的重写。

        协变是指，基类与派生类虚函数返回值类型不同，此情景下，基类虚函数返回的是基类对象的指针或者引用，派生类虚函数返回的是派生类对象的指针或者引用。

（这一点了解即可）

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;}
};

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

// 析构函数加virtual，是虚函数重写
// 类析构函数都被处理成destructor这个统一的名字
// 之所以要让他们构成重写，是因为下面的场景：（笔试常考）

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

class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }

	~Student() {
		cout << "~Student()" << endl;
		delete[] ptr;
	}
protected:
	int* ptr = new int[10];
};

int main()
{
	Person* p = new Person;
	p->BuyTicket(); 
	delete p;

	p = new Student;
	p->BuyTicket();
	delete p; // p->destructor() + operator delete(p)

	// 这里我们期望p->destructor()是一个多态调用，而不是普通调用

	return 0;
}

【ps】

1. 派生类的重写虚函数可以不加virtual，但建议都加上以便区分；
2. 协变，返回值可以不同，但必须是父子关系的指针和引用（不常用）。

3、关键字 override 和 final（C++11）

        C++对函数重写的要求比较严格，但是有些情况下由于疏忽，如函数名字母次序写反，可能会导致而无法构成重写。而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果再进行debug，但这样会得不偿失。因此，C++11提供了 override 和 final 两个关键字，可以帮助用户检测是否重写。

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

class Car
{
public:
	virtual void Drive() final {} // final修饰的虚函数不能再被重写
};

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

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

class Car {
public:
	 virtual void Drive() {}
};

class Benz :public Car {
public:
	virtual void Drive() override { cout << "Benz-舒适" << endl; }
    // override 帮助派生检查是否完成重写，如果没有会报错
};

// 设计不想被继承类，如何设计？

// 方法1：基类构造函数私有   (C++98)
class A
{
public:
	static A CreateObj()
	{
		return A();
	}
private:
	A()
	{}
};

class B : public A
{};

int main()
{
	// B bb;
	A::CreateObj();

	return 0;
}

class A
{
public:
private:
	~A()
	{}
};
class B : public A
{};

int main()
{
	A* p = new A;

	//B bb;

	return 0;
}


// 方法2：基类加一个final  （C++11）

class A final
{
public:
private:
};

class B : public A
{};

int main()
{
	return 0;
}

4、函数的重载重写（覆盖）、重定义（隐藏）的对比

二、多态的原理

1、虚函数表

// 引例：sizeof(Base)是多少？

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	char _b = 1;
};

int main()
{
	Base b;
	return 0;
}

        由VS2019调试的监视窗口，b对象是8bytes。除了_b成员，还多一个__vfptr放在对象的前面(有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数 的地址要被放到虚函数表中，虚函数表也简称虚表。 

        而派生类中的虚函数表又放了些什么呢？

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}

	virtual void Func2()
	{
		cout << "Func1()" << endl;
	}

	void Func3()
	{
		cout << "Func1()" << endl;
	}
private:
	char _b = 1;
};

class Derive : public Base
{
public:
     virtual void Func1()
     {
         cout << "Derive::Func1()" << endl;
     }
private:
     int _d = 2;
};

int main()
{
     Base b;
     Derive d;
     return 0;
}

        由VS2019调试的监视窗口： 

1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是派生类中另一部分的自己的成员；
2. 基类b对象和派生类d对象虚表是不一样的。这里Func1完成了重写，d的虚表中存的是重写的Derive::Func1，所以，虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖（重写是语法的叫法，覆盖是原理层的叫法）；
3. Func2继承之后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。

【Tips】派生类的虚表生成：

1. 先将基类中的虚表内容拷贝一份到派生类虚表中；
2. 如果派生类重写了基类中某个虚函数，则用派生类自己的虚函数覆盖虚表中基类的虚函数；
3. 派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

        由此可见，虚函数表本质是一个存虚函数指针的指针数组。一般情况，这个数组的尾部放了一个nullptr。 

        虚函数存在哪的？虚表存在哪的？ 这是一些很容易混淆的问题，一般会误以为，虚函数存在于虚表，虚表存在于对象中，但这些回答都是错的。实际上，虚表存的是虚函数指针，不是虚函数。虚函数和普通函数一样的，都是存在代码段（常量区）的，只是它的指针又存到了虚表中。对象中存的不是虚表，存的是虚表指针。虚表实际是存在代码段的（vs2019下）。

class Person {
	public:
		virtual void BuyTicket() { cout << "买票-全价" << endl; }
	
		virtual void Func1() 
		{
			cout << "Person::Func1()" << endl;
		}
	
		virtual void Func2() 
		{
			cout << "Person::Func2()" << endl;
		}
	
	//protected:
		int _a = 0;
	};
	
	class Student : public Person {
	public:
		virtual void BuyTicket() { cout << "买票-半价" << endl; }
	
	private:
		virtual void Func3()
		{
			//_b++;
			cout << "Student::Func3()" << endl;
		}
	protected:
		int _b = 1;
	};
int main()
{
	Person ps;
	Student st;

	int a = 0;
	printf("栈：%p\n", &a);

	static int b = 0;
	printf("静态区：%p\n", &b);

	int* p = new int;
	printf("堆：%p\n", p);

	const char* str = "hello world";
	printf("常量区：%p\n", str);

	printf("虚表1：%p\n", *((int*)&ps));
	printf("虚表2：%p\n", *((int*)&st));


	return 0;
}

         虚表1和虚表2的地址与静态区等的地址相差较大，而与常量区的地址相差不远。由此可见，虚表是存在常量区的，也进一步验证了，其本质是一个函数指针数组。

2、多态的底层

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

	int _a = 1;
};

class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
	int _b = 1;
};

void Func(Person& p)
{
	// 符合多态，运行时到指向对象的虚函数表中找调用函数的地址
	p.BuyTicket();
}

int main()
{
	Person Mike;
	Func(Mike);

	Student Johnson;
	Func(Johnson);

	return 0;
}

        在上面这段代码中，Func函数传Person调用的是Person::BuyTicket，传Student调用的是Student::BuyTicket。 

        通过调试监视窗口可以看到，当p指向mike对象时，p->BuyTicket在mike的虚表中找到的虚函数是Person::BuyTicket；当p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。

        多态的底层原理是，代码运行时，对象的指针或引用在虚表中找到要调用的虚函数的地址，然后调用相应的虚函数。这样就实现出了不同对象去完成同一行为时，展现出不同的形态，也侧面力证了构成多态的两个条件——一个是虚函数覆盖，另一个是对象的指针或引用调用虚函数。

        并且，从下面的汇编代码可以看出，满足多态的函数调用不是在编译时确定的，是运行起来以后到对象的中取找的，而不满足多态的函数调用在编译时就已经确认了。

void Func(Person* p)
{
 p->BuyTicket();
}

int main()
{
 Person mike;
 Func(&mike);
 mike.BuyTicket();    
 return 0;
}

/

// 汇编代码（精简后）

void Func(Person* p)
{
...
 p->BuyTicket(); // p中存的是mike对象的指针，将p移动到eax中

001940DE  mov         eax,dword ptr [p]
// [eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx

001940E1  mov         edx,dword ptr [eax]
// [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax

00B823EE  mov         eax,dword ptr [edx]
// call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，
//而是在运行起来以后到对象的中取找的。

001940EA  call        eax  

001940EC  cmp         esi,esp  
}

int main()
{
... 

// 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是普通函数的调
// 用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call 地址

 mike.BuyTicket();

00195182  lea         ecx,[mike]

00195185  call        Person::BuyTicket (01914F6h) 
 
... 

}

3、静态绑定与动态绑定

        这一小点算是一个小补充。

        静态绑定又称前期绑定或早绑定，也称静态多态，指在程序编译期间就确定了程序的行为， 例如，函数重载

        动态绑定又称后期绑定或晚绑定，也称为动态多态，指在程序运行期间，根据具体获得的类型来确定程序的行为。在面向对象程序设计中，这被直接称为多态。

三、继承关系中的虚函数表

        在单继承和多继承关系中，派生类对象的虚表还有其他特点。

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;
};

（调试的监视窗口看不见func3和func4，是因为编译器的监视窗口将其隐藏了，这算是VS2019的一个小bug。可以通过下面的代码来查看d的虚表找到func3和func4）

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;

     VFPTR* vTableb = (VFPTR*)(*(int*)&b);
     PrintVTable(vTableb);
     VFPTR* vTabled = (VFPTR*)(*(int*)&d);
     PrintVTable(vTabled);

 // 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数
 // 指针的指针数组，这个数组最后面放了一个nullptr

 // 1.先取b的地址，强转成一个int*的指针

 // 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针

 // 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。

 // 4.虚表指针传递给PrintVTable进行打印虚表

 // 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最
 // 后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再
 // 编译就好了。

     return 0;
}

        由此可见，单继承的派生类对象只有一张虚表。 

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;
}

        由此可见，多继承的派生类对象有多张虚表。

3*、菱形继承和菱形虚拟继承

class A
{
public:
	virtual void func1()
	{
		cout << "A::func1" << endl;
	}
public:
	int _a;
};

//class B : public A
class B : virtual public A
{
public:
	virtual void func1()
	{
		cout << "B::func1" << endl;
	}

	virtual void func2()
	{
		cout << "B::func2" << endl;
	}
public:
	int _b;
};

//class C : public A
class C : virtual public A
{
public:
	virtual void func1()
	{
		cout << "C::func1" << endl;
	}

	virtual void func2()
	{
		cout << "C::func2" << endl;
	}
public:
	int _c;
};

class D : public B, public C
{
public:
	virtual void func1()
	{
		cout << "D::func1" << endl;
	}

	virtual void func3()
	{
		cout << "D::func3" << endl;
	}
public:
	int _d;
};
int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;

	return 0;
}

四、抽象类

        在虚函数后加赋值0（=0） ，则称这个虚函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），即这个类在现实世界没有对应实体。抽象类不能实例化出对象，派生类继承后也不能实例化出对象，只有重写纯虚函数，才能使派生类实例化出对象。相当于，纯虚函数间接强制派生类重写虚函数。

class Car
{
public:
	virtual void Drive() = 0; // 在虚函数后加赋值0，则为纯虚函数
};
class Benz :public Car
{
public:
};
int main()
{
	Benz b;    //编译报错，不允许使用抽象类型的对象
}

//要实例化出对象，重写虚函数即可

class Car
{
public:
	virtual void Drive() = 0;
};
class Benz :public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz-comfortable" << endl;
	}
};
int main()
{
	Benz b;
}

//纯虚函数间接强制派生类重写虚函数

class Car
{
public:
	inline virtual void Drive() = 0;

	int Func();

	// virtual static  void Func1()
	// {}
};

int Car::Func()
{
	int a = 0;
	int b = 2;
	return a + b;
}
class Benz :public Car
{
public:
	inline virtual void Drive()
	{
		cout << "Benz-舒适" << endl;
	}
};

class BMW :public Car
{
public:
	inline virtual void Drive()
	{
		cout << "BMW-操控" << endl;
	}
};

class BYD :public Car
{
public:
	inline virtual void Drive()
	{
		cout << "BYD-build year dream" << endl;
	}
};
void Func(Car* p)
{
	p->Drive();
	p->Func();
}

int main()
{
	Func(new Benz);
	Func(new BMW);
	Func(new BYD);

	return 0;
}

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

补、相关面试题