1. 多态概念

2. 多态的定义及实现

2.1 多态的构成条件

2.2 虚函数重写

2.3 C++11 override和final

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

3. 抽象类

3.1 概念

3.2 接口继承和实现继承

4. 多态的原理

4.1 虚函数表

4.2 多态的原理

4.3 动态绑定与静态绑定

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

5.1 单继承中的虚函数表

5.2 多继承中的虚函数表

6. 常见面试问答题

1. 多态概念

多态：多种形态。具体就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

买票行为。普通人买票是全价；学生买票是半价；军人买票是优先买票。

这里普通人、学生、军人（不同的对象）去完成买票动作有不同的状态。

并夕夕大部分人应该都用过，对于新用户砍一刀时必定可以砍成功0.1元；老用户砍一刀可能失败或者+几个碎片（相当多的碎片再组合成0.1元）。

针对不同程度的用户，砍一刀产生的状态也不同。

支付宝扫码领红包，有的人扫红包可以得到8块、10块......而有的人扫红包却只能得到几毛......。这背后其实也是一个多态行为。（PS：瞎编，仅供娱乐）支付宝首先会分析你的账户数据，比如你是新用户/没有经常支付宝支付等，那么你就需要被鼓励使用支付宝，那么你的扫码金额=random()%99；比如你经常使用支付宝支付/支付宝账户常年没钱，那么你就不需要太被鼓励去使用支付宝，那么你的扫码金额=random()%1；同样是扫码动作，不同的用户扫码得到的不一样的红包，这也是一种多态行为。

2. 多态的定义及实现

2.1 多态的构成条件

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

继承中要构成多态条件：

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

2.2 虚函数重写

虚函数重写/覆盖条件：虚函数(只有成员函数才能加virtual)+三同（函数名、参数、返回值）

不符合重写，就是隐藏关系。

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

虚函数重写的例外（C++挖的坑）：

子类虚函数不加virtual，依旧构成重写。（先继承下虚函数，再重写（实现））

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

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

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

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

2.3 C++11 override和final

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

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

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

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

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

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

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

3. 抽象类

3.1 概念

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

类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生

类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

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

3.2 接口继承和实现继承

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

现。

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

多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

我们来做道面试题看看接口继承：
   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 E: 编译出错 F: 以上都不正确

答案：B

解析：虚函数重写是接口继承，重写实现，继承接口。

上例中，接口继承上面的void func(int val=1)。调用test，B*传递给A*（切片操作）但是this还是指向B对象，this->调用的是指向对象的函数。（多态）

多态指向谁调用谁！

4. 多态的原理

4.1 虚函数表

虚函数表的实质是函数指针数组

// 这里常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
 virtual void Func1()
 {
 cout << "Func1()" << endl;
 }
private:
 int _b = 1;
};

通过观察测试我们发现b对象是8bytes，除了_b成员，还多了一个__vfptr放在对象前面（VS平台），对象中的指针（Vs x86,指针4bytes）我们叫做虚函数表指针。一个含有虚函数表的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也称虚表。

注意： 虚函数存在哪的？虚表存在哪的？

虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。在VS下测验发现虚表存在代码段。

4.2 多态的原理

举个模型来演示下：

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

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


	int _a = 0;
};

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

	int _b = 0;
};

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

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

	Student Johnson;
	Func(Johnson);

	return 0;
}

总结：

多态的本质原理，符合多态的两个条件。那么调用时，会到指向对象的虚表中找到对应的虚函数地址，进行调用。

多态（程序运行时去指向对象的虚表中找到函数地址，进行调用，所以p指向谁调用谁的虚函数）

普通函数调用，编译链接时确定函数的地址,运行时直接调用。类型是谁调用谁的。

4.3 动态绑定与静态绑定

静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

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

5.1 单继承中的虚函数表

结论：

单继承：同一个类的对象共用一个虚表
vs下，不管是否完成重写，子类虚表跟父类虚表都不是同一个（内容改变）
子类虚表里有自己的和父类的虚函数（存的是虚函数指针）

测验下子类自己的虚函数是放在子类的虚表还是父类的虚表：

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都不见了，是真的不见了吗？其实不是！这里是vs编译器的监视窗口故意隐藏了这两个函数，可认为这是一个bug。那么我们如何查看d的虚表呢，我们使用下列代码打印出虚表中的函数。

typedef void(*VFPTR)();
void PrintVFTable(VFPTR* table)
{
	for (size_t i = 0; table[i] != nullptr; ++i)
	{
		printf("vft[%d]:%p->", i, table[i]);
		VFPTR pf = table[i];
		pf();
	}
	cout << endl;
}

结果我们可以看到，子类的虚函数确实放在子类自己的虚表当中。

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

子类自增的虚函数无法在VS监视窗口看到。

通过上面写的函数代码测试出来结果：

菱形继承、菱形虚拟继承贴2篇陈皓大佬的文章：C++ 虚函数表解析 | 酷壳 - CoolShellC++ 对象的内存布局 | 酷壳 - CoolShell

6. 常见面试问答题

inline函数可以是虚函数吗？

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

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

答：不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

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

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

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

答：可以，并且最好把基类的析构函数定义成虚函数。

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

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

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

答：虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。

什么是抽象类？抽象类的作用？

答：作用：抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。

拷贝构造和operator=可以是虚函数吗？

答：拷贝构造不可以，拷贝构造也是构造函数。operator=可以，但是没有什么实际价值。