C++ -- 多态与虚函数

多态

概念

多态（polymorphishm）：通常来说，就是指事物的多种形态。在C++中，多态可分为编译时多态（静态多态）和运行时多态（动态多态），这里我们重点讲的是运行时多态。

编译时多态主要就是我们之前讲过的函数重载和函数模板，他们传不同类型的参数就可以调用不同的函数，通过参数不同达到多种形态，并且他们将实参传给形参的参数匹配实在编译时完成的，因此称为编译时多态。我们把编译时一般归为静态，所以又叫静态多态。

运行时多态，就是去完成某个行为（函数）时，传不同的对象就会完成不同的行为，就达到了多种形态。比如买火车票这一行为，当买票的是普通人时为全价，是学生时为折扣价，是军人时可优先买票。

多态的定义与实现

多态的构成条件

多态是一个继承关系下的类对象，去调用同一函数时产生了不同的行为。比如Student继承了Person。Person对象买票为全家，而Student对象买票则会有折扣。

虚函数

在类的成员函数前面加virtual修饰，那么称这个成员函数为虚函数。这里注意：虚函数必须是成员函数。例如Person类中的ButTicket成员函数：

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

虚函数的重写/覆盖

虚函数的重写/覆盖：派生类中有一个跟基类完全相同的虚函数（要求两个虚函数的返回值类型、函数名称、参数列表类型与个数要完全相同），那么称派生类的虚函数重写/覆盖了基类的虚函数。重写只是实现了新的函数体，不会影响函数体之外的任何参数。

注意：在重写基类虚函数时，派生类的虚函数在不加 virtual 关键字时，也可以构成重写，因为继承后的基类虚函数被继承下来了，在派生类中依旧保持虚函数属性，但是这种写法并不规范，所以博主不建议这样使用，为了防止面试题目中出现，这里提一下，可以判断是否构成重写即可。

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

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

void Func(Person& p)
{
	// 这⾥可以看到虽然都是Person指针p在调⽤BuyTicket
	// 但是跟p没关系，⽽是由ptr指向的对象决定的。
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	Func(ps);
	Func(st);
	return 0;
}

实现多态的两个必须条件

必须通过基类的指针或引用调用虚函数。
被调用的函数必须是虚函数。

说明：要实现多态，第一必须是基类的指针或引用，因为只有基类的指针或引用才既能指向基类对象，又能指向派生类对象。第二派生类必须对基类的虚函数进行重写/覆盖，只有重写后派生类的虚函数才能有不同的行为，多态的不同形态效果才能得以体现。

多态场景下的一道面试题：

下面程序输出结果是什么()?

A: A->0 B:B->1 C:A->1 D:B->0 E:编译出错 F:以上都不正确

class A
{
public :
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
	virtual void test() { func(); }
};
class B : public A
{
public :
	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};
int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();
	return 0;
}

解析：

这道题较难理解，首先我们可以看到 p 是 B* 的指针，存储的是 B 类 new 出来的对象的地址，B 类继承了 A 类，A和B 类中的 func 成员函数加了 virtual 关键字，函数名、返回值类型和参数列表类型一致，所以构成重写。p->test() 是通过 B* 来调用的，test函数在A类中，作为基类也继承到了B类中，test函数中调用了func函数，test函数中的this指针指向的是A类，所以调用的是A类中的func函数，到这里之后就是本道题的难点了。因为A类和B类中func虚函数构成了重写，同时p指向的是子类对象的地址，所以调用的是子类对象的B中重写之后的函数体，而重写不会影响函数体外的参数，所以传的val缺省值依旧是A中的1，因此结果为B->1。

虚函数重写的一些问题

协变（了解）

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或引用时，称为协变。协变的意义不大，所以了解即可。

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

class Student : public Person {
public:
	virtual Student* BuyTicket()
	{
		cout << "买票-打折" << endl;
		return nullptr;
	}
};

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

int main()
{
	Person ps;
	Student st;

	Func(&ps);
	Func(&st);
	return 0;
}

析构函数的重写

基类的析构函数为虚函数时，派生类的析构函数只要定义，无论是否加virtual关键字，都会与基类的析构函数构成重写，听起来虽然与之前基类和派生类重写规则不符，但实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor，所以基类的析构函数加上 virtual 修饰后，派生类的析构函数就构成了重写。

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

在上述代码中，我们可以看到使用 A* 的指针分别存放了A类和B类创建的对象的地址，根据继承的切片知识，我们可以得知p2指向的是B类对象继承A类的那一部分成员，在调用delete销毁对象时，如果A类与B类的析构函数没有构成重写，那么就会造成B类对象内存泄漏，导致程序崩溃。只有构成重写之后，当p2在delete释放资源时，才会调用B类重写的析构函数，然后会接着自动调用A的析构函数，因此将析构函数重写为虚函数时必要的。

注意：这个问题在面试中经常考察，各位一定要结合类似例子讲清楚，为什么建议要将基类的析构函数设计为虚函数？

override 和 final 关键字

从上面的定义与各种条件可以看出，C++对于虚函数重写的要求相当严格，但是百密疏于一漏，程序员在使用时还是会经常出错，比如函数名写错、参数写错等导致无法构成重写，而这种错误在编译期间时不会报错的，只有在程序运行时没有得到预期的结果才能发现bug，这样得不偿失。因此在C++11中提供了override关键字，可以帮助用户检测是否构成了重写。

// error C3668: “Benz::Drive”: 包含重写说明符“override”的⽅法没有重写任何基类⽅法
class Car {
public:
	virtual void Dirve()
	{}
};
class Benz :public Car {
public:
	virtual void Drive() override { cout << "Benz-舒适" << endl; }
};

如果我们并不想构成重写，可以主动在虚函数后面使用final去修饰，这样就不会构成重写了。

// error C3248: “Car::Drive”: 声明为“final”的函数⽆法被“Benz::Drive”重写
class Car
{
public :
	virtual void Drive() final 
    {}
};
class Benz :public Car
{
public :
	virtual void Drive() { cout << "Benz-舒适" << endl; }
};

重载/重写/隐藏的对比

纯虚函数和抽象类

在虚函数的后面写上 =0，则这个函数被称为纯虚函数，纯虚函数不需要定义实现，只要声明即可（在语法上是可以实现的，只是实现了没有任何意义，因此不必实现）。包含纯虚函数的类叫做抽象类（abstract），抽象类不能实例化出对象，如果派生类继承了抽象基类后不重写纯虚函数，那么这个派生类也是抽象类，不可实例化对象。纯虚函数某种程度上强制了派生类重写虚函数，因为不重写虚函数无法实例化对象。

class Car
{
public :
	virtual void Drive() = 0;
};
class Benz :public Car
{
public :
	virtual void Drive()
	{
		cout << "Benz-舒适" << endl;
	}
};
class BMW : public Car
{
public :
	virtual void Drive()
	{
		cout << "BMW-操控" << endl;
	}
};
int main()
{
	// 编译报错：error C2259: “Car”: ⽆法实例化抽象类
	Car car;
	Car* pBenz = new Benz;
	pBenz->Drive();
	Car* pBMW = new BMW;
	pBMW->Drive();
	return 0;
}

多态的原理

虚函数表指针

下面编译在32位平台上的程序的运行结果是什么()？

A: 编译报错 B: 运行报错 C: 8 D: 12

class Base
{
public :
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
protected:
	int _b = 1;
	char _ch = 'x';
};
int main()
{
	Base b;
	cout << sizeof(b) << endl;
	return 0;
}

上面的题目中的运行结果为12字节，除了_b 和 _ch 成员之外，还多了一个 _vfptr 放在对象的前面(注意有些平台可能会放到对象的后面，这个跟平台有关)，对象中的这个指针我们称为虚函数表指针(V代表virtual，f代表function)。一个含有虚函数的类中至少都有一个虚函数表指针，因为一个类所有虚函数的地址要被放到这个类对象的虚函数表中，虚函数表也简称虚表。

多态的原理

以前面讲过的买票代码为例：

class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-打折" << endl; }
};
class Soldier : public Person {
public:
	virtual void BuyTicket() { cout << "买票-优先" << endl; }
};
void Func(Person* ptr)
{
	// 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket
	// 但是跟ptr没关系，⽽是由ptr指向的对象决定的。
	ptr->BuyTicket();
} 
int main()
{
	// 其次多态不仅仅发⽣在派⽣类对象之间，多个派⽣类继承基类，重写虚函数后
	// 多态也会发⽣在多个派⽣类之间。
	Person ps;
	Student st;
	Soldier sr;

	Func(&ps);
	Func(&st);
	Func(&sr);
	return 0;
}

从底层的角度来看，Func函数中 ptr->BuyTicket() 是如何作为 ptr 指向 Person 对象调用 Person::BuyTicket()。ptr 指向 Student 对象调用 Student::BuyTicket() 的呢？通过下图我们可以看到，满足多态条件后，底层不再是编译时通过调用对象确定函数的地址，而是运行时到其指针所指向的对象的虚表中确定对应的虚函数的地址，这样就实现了指针或引用指向基类就调用基类的虚函数，指向派生类就调用派生类队形的虚函数。

第一张图中，ptr 指向的是 Person 对象，调用的是 Person 的虚函数；第二张图中，ptr 指向的是 Student 对象，调用的是 Student 的虚函数。

动态绑定与静态绑定

对不满足多态条件的（指针或引用+调用虚函数）函数调用是在编译时绑定，也就是编译时确定调用函数的地址，叫做静态绑定。
满足多态条件的函数调用是在运行时绑定，也就是在运行时到指向对象的虚函数表中找到调用函数的地址，也叫做动态绑定。

// ptr是指针+BuyTicket是虚函数满⾜多态条件。
// 这⾥就是动态绑定，编译在运⾏时到ptr指向对象的虚函数表中确定调⽤函数地址
ptr->BuyTicket();
00EF2001 mov eax,dword ptr [ptr]
00EF2004 mov edx,dword ptr [eax]
00EF2006 mov esi,esp
00EF2008 mov ecx,dword ptr [ptr]
00EF200B mov eax,dword ptr [edx]
00EF200D call eax
// BuyTicket不是虚函数，不满⾜多态条件。
// 这⾥就是静态绑定，编译器直接确定调⽤函数地址
ptr->BuyTicket();
00EA2C91 mov ecx,dword ptr [ptr]
00EA2C94 call Student::Student (0EA153Ch)

虚函数表的相关内容

基类对象的虚函数表中存放基类所有虚函数的地址，同一个类的对象使用一个虚函数表，不同类的对象之间使用的虚函数表相互独立。
派生类由两部分构成，继承下来的基类和自己的成员，一般情况下，继承下来的基类中有虚函数表指针，自己就不会再生成虚函数表指针。但是要注意的是这里继承下来的基类部分虚函数表指针和基类对象的虚函数表指针是相互独立的，就像基类对象的成语和派生类对象中的基类对象成员也相互独立一样。
派生类中重写的基类的虚函数，派生类的虚函数表中对应的虚函数就会被覆盖成派生类重写的虚函数地址。
派生类的虚函数表中包含：基类的虚函数地址、派生类重写的虚函数地址、派生类自己的虚函数地址。需要注意，无论它继承了几个基类，派生类自己的虚函数会放到该派生类第一个继承的基类的虚函数表的末尾，不会生成一个独立的新虚表。
虚函数表本质是一个存虚函数指针的指针数组，一般情况下这个数组最后面会放一个0x00000000标记。（这个C++并没有严格规定，而是各个编译器自行定义的，vs系列编译器会放，g++不会。）
虚函数存在哪？虚函数和普通函数一样，编译好后就是一段指令，都是存在代码段中，只是虚函数的地址会额外存放在虚表中。
虚函数表存在哪？这个问题C++没有严格规定，在vs中是存放在代码段（常量区）。我们在下面演示一下：

这⾥Derive中没有看到func3函数，这个vs监视窗口看不到，可以通过内存窗口查看

class Base {
public:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
	void func5() { cout << "Base::func5" << endl; }
protected:
	int a = 1;
};
class Derive : public Base
{
public :
	// 重写基类的func1
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func1" << endl; }
	void func4() { cout << "Derive::func4" << endl; }
protected:
	int b = 2;
};
int main()
{
	int i = 0;
	static int j = 1;
	int* p1 = new int;
	const char* p2 = "xxxxxxxx";
	printf("栈:%p\n", &i);
	printf("静态区:%p\n", &j);
	printf("堆:%p\n", p1);
	printf("常量区:%p\n", p2);
	Base b;
	Derive d;
	Base* p3 = &b;
	Derive* p4 = &d;
	printf("Person虚表地址:%p\n", *(int*)p3);
	printf("Student虚表地址:%p\n", *(int*)p4);
	printf("虚函数地址:%p\n", &Base::func1);
	printf("普通函数地址:%p\n", &Base::func5);
	return 0;
}

运行结果：
栈:010FF954
静态区:0071D000
堆:0126D740
常量区:0071ABA4
Person虚表地址:0071AB44
Student虚表地址:0071AB84
虚函数地址:00711488
普通函数地址:007114BF