【C++】深究C++三大特性之多态

1. 多态的概念

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

例如：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时时是优先买票。

2. 多态的定义及实现

2.1 多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买全价票，Student对象买半价票。

代码示例：

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "购买全价票" << endl;
	}
};
class Student:public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "购买半价票" << endl;
	}
};
void Func(Person& people)
{
	people.BuyTicket();
}
int main()
{
	Person p;
	Func(p);
	Student s;
	Func(s);
	return 0;
}

继承中构成多态的两个条件：

1.必须通过基类的指针或者引用调用虚函数。

2.被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。

2.2 虚函数

被virtual修饰的类成员函数称为虚函数。

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

virtual关键字：

1.可以修饰成员函数，为了完成虚函数的重写，满足多态的条件之一。

2.也可以在菱形继承中，去完成虚继承，解决数据冗余和二义性。

他们都使用了同一个关键字，但是他们互相之间没有关联。

2.3 虚函数的重写

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

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

注意：

在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，也可以构成重写，因为继承后基类的虚函数被继承下来了在派生类中依旧保持虚函数的属性，但是这种写法不规范，不建议这样使用。

那么如何看对象调用的是谁的虚函数呢？

看是否满足多态。

1.满足多态：跟指向的对象有关，指向的对象是谁，就调用谁的虚函数。

2.不满足多态（构成多态的两个条件不满足其中一个）：跟调用对象的类型有关，类型是谁，就调用谁的虚函数。

代码示例1：

代码示例2：

2.3.1 笔试题：

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

程序的运行结果是什么？

A: A->0   B: B->1   C: A->1   D: B->0

答案：B。

思路解析：

1、p调用test()相当于把p传给了test()，而test( A*this)，此时，把p传给了this，相当于父类A的指针指向了子类对象。

2、子类func虚函数完成了重写（隐藏了virtual），test函数调用func虚函数时，指向的对象为B，所以调用B的func虚函数。

3、子类虚函数的重写只是继承了父类虚函数的函数名、参数、返回值，继承的是函数的接口，然后重写函数具体的实现。

4、所以，此时，B的func默认参数不起作用，结果就是"B->1"。

2.3.2 虚函数重写的两个例外

1.协变（基类与派生类虚函数返回值类型不同）

派生类重写虚函数时，基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用。

class A
{};
class B :public A
{};
class Person
{
public:
	virtual A* func()
	{	}
};
class Student : public Person
{
public:
	virtual B* func()
	{	}
};

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

面试题：析构函数是否需要定义为虚函数？

说明：

只有派生类Student的析构函数重写了Person的析构函数，delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。

注意：

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

2.4 C++11 override和final

C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名、字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才debug。

因此，C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

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

final也可以修饰类，表示这个类不能被继承

之前我们说过如何设计一个可以不被继承的类（上一篇博客中写到），可以把父类的构造函数私有化（C++98），这里给出了一个C++11的方式，用final修饰这个类。

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

2.5 重载、覆盖（重写）、隐藏（重定义）的对比

3. 抽象类

3.1 概念

在虚函数的后面写上=0，这个函数为纯虚函数。包含纯虚函数的类叫抽象类（接口类）。

抽象类不能示例化出对象。派生类继承后也不能实例化对象。

说明：

为什么子类Benz也不能实例化出对象呢？

因为Benz继承了父类的纯虚函数，因此，Benz也是一个抽象类。

只有重写纯虚函数，派生类才能实例化出对象。

纯虚函数的作用：

1.强制子类完成重写。

2.表示抽象类。抽象就是现实生活中没有对应的实体。

3.2 接口继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数， 继承的是函数的实现 。

虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态， 继承的是接口 。

所以如果不实现多态，不要把函数定义成虚函数。

4. 多态的原理

4.1 虚函数表

为什么是8个字节呢？

我们知道 成员函数是编译成了指令，放到了代码段 ，不计算，只计算成员变量的大小就可以了。而这里_b是一个int类型，应该是4个字节，为什么是8呢？

通过监视窗口可以看到，这里b对象除了_b成员，还多了一个_vfptr的指针。这里是32位平台指针大小为4，所以b对象大小为8。

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

说明：

监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。那么我们如何查看d的虚表呢？下面我们使用代码打印

出虚表中的函数。

打印虚表：

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)();//typedef函数指针类型
//打印虚表->虚表本质就是一个虚函数指针数组（最后面放了一个nullptr）
void PrintVFTable(VF_PTR* ptable)
{
	for (int i = 0; ptable[i] != 0; i++)
	{
		printf("vftable[%d]:%p->", i, ptable[i]);
		VF_PTR f = ptable[i];
		f();
	}
	cout << endl;
}
int main()
{
	Base b;
	Derive d;
	//取对象中前四个字节就是虚表指针
	PrintVFTable((VF_PTR*)*(int*)&b);
	PrintVFTable((VF_PTR*)*(int*)&d);
	return 0;
}

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

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

计算一下sizeof(d)是多大?

20个字节，Base1的虚表指针和b1，Base2的虚表指针和b2，Derive的d1。总共20字节。

可以看到Base1、Base2分别有一个虚表指针，Derive重写了Base1和Base2的func1（）。

Derive未重写的func3放到了谁的虚表中呢？

我们打印虚表来看一下：

打印虚表：

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(*VF_PTR)();
void PrintVFTable(VF_PTR* ptable)
{
	printf("虚表地址:%p\n", ptable);
	for (int i = 0; ptable[i] != 0; i++)
	{
		printf("vftable[%d]:%p->", i, ptable[i]);
		VF_PTR f = ptable[i];
		f();
	}
	cout << endl;
}
int main()
{
	Derive d;
	PrintVFTable((VF_PTR*)*(int*)&d);
	PrintVFTable((VF_PTR*)*(int*)((char*)&d+sizeof(Base1)));
	return 0;
}

说明：

多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。

6. 面试题

1.inline函数可以是虚函数吗？

可以，不过编译器就忽略inline属性，这个函数就不再是inline，因为inline要放到虚表中。

2.静态成员可以是虚函数吗？

不能，静态成员函数没有this指针，使用类型：：成员函数的方式无法访问虚表。

3.构造函数可以是虚函数吗？

不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。

4.对象访问普通函数快还是虚函数更快？

如果是普通对象是一样快的。如果是指针对象或者引用，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚表中查找。

5.虚函数表是在什么阶段生成的，存在哪？

编译阶段，代码段（常量区）。

6.什么是多态？

xxx

7.多态的实现原理？

xxx

8.什么是重载、重写、重定义？

xxx

9.析构函数可以是虚函数吗？什么场景下是？

xxx

10.什么是抽象类，作用？

xxx