C++ 多态

前言

本文将会向你介绍多态的概念，重写，虚表，纯虚函数等知识点

一、多态的概念

多态的概念：同样的一个行为，不同的对象去完成时会产生不同的状态。

例子：多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如买票：军人、学生、普通人（人：父类）去买票，军人买票可以优先选票，学生买票可以折扣，普通人买票就需要全价了。

那么在继承中要构成多态还有两个条件：

1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写（重写的概念会在下文介绍）

二、虚函数

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

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

2.1 虚函数的重写

说起重写，我们不得不再把上一篇文章中的隐藏再来谈谈

隐藏是指在派生类中定义了与基类中同名的成员函数，导致基类中的成员函数被隐藏起来，无法直接访问。这种情况下，通过派生类的对象只能访问到派生类中定义的同名成员函数。隐藏是静态绑定的，即在编译时就确定了调用的是哪个函数。

重写是指派生类中定义了与基类中同名的虚函数，通过基类的指针或引用调用该函数时，会根据指针或引用所指向的对象的实际类型来确定调用的是基类的函数还是派生类的函数。重写是动态绑定的，即在运行时根据对象的实际类型来确定调用的是哪个函数。

总结如下：

重定义（隐藏）： 两个函数分别在基类和派生类的作用域，函数名相同，两个基类和派生类的同名函数不构成重写（覆盖）就是重定义（隐藏）
重写（覆盖）的条件：
（1）派生类中这个虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同（函数体中的内容可以不同），简称三同。
（2）但是即使满足三同的条件还不够，因为虚函数的重写是基于父类的指针或引用的多态性实现的，只有通过父类指针或引用调用虚函数才能触发虚函数重写，如果直接使用子类对象或子类指针或引用调用虚函数，那么只会调用子类的实现，而不会触发虚函数重写

结论：只有构成多态的时候，才会触发虚函数的重写

以下是一个隐藏的例子，如果派生类的函数与基类的函数同名，但是参数不同。此时无论有没有virtual关键字，基类的函数都将被隐藏。

class Car
{
public:
	virtual void Drive(int x) 
	{
		cout << "Car::Drive(int x)" << endl;
	}
};
class Benz : public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz::Drive()" << endl;
	};
};

以下依旧是隐藏，如果派生类的函数与基类的函数同名，而且参数相同，但是基类的函数没有virtual关键字，此时基类的函数将被隐藏

class Car
{
public:
	void Drive() 
	{
		cout << "Car::Drive()" << endl;
	}
};
class Benz : public Car
{
public:
	void Drive()
	{
		cout << "Benz::Drive()" << endl;
	};
};

以下就是重写了，满足1、函数名，返回值，参数都相同。2、两个函数分别在父类和派生类的作用域里面。3、两个函数都是虚函数的条件。但是依旧要有父类的指针或引用调用到虚函数才行

class Car
{
public:
	virtual void Drive() 
	{
		cout << "Car::Drive()" << endl;
	}
};
class Benz : public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz::Drive()" << endl;
	};
};

最后我们可以得到一个小结论：函数名相同，两个基类和派生类的同名函数不构成重写就是重定义
看到这里你应该会有个疑问：什么是静态绑定什么又是动态绑定呢？（在多态的实现原理将会向您介绍）
买票例子：

class Person {
public:
       virtual void BuyTicket()
       {
              cout << "Person::买票-全价" << endl;
       }
       virtual ~Person()
       {
              cout << "~Person()" << endl;
       }
};
class Student : public Person {
public:
       //重写
       void BuyTicket() { cout << "Student::买票-半价" << endl; }
       ~Student()
       {
              cout << "~Student()" << endl;
       }
};
//父类的引用
void Func(Person& p)
{
       p.BuyTicket();
}
int main()
{
       Person ps;
       Student st;
       Func(ps);
       Func(st);
       return 0;
}

结果如下：

我们可以观察到：该多态满足了两个条件

1、通过了父类的引用调用虚函数
2、派生类对父类的虚函数进行了重写

2.2 虚函数重写的三个例外

1、 协变(基类与派生类虚函数返回值类型不同)
重写时基类和派生类函数的返回值类型可以不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。（了解）

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

2、 析构函数的重写(基类与派生类析构函数的名字不同)
当基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写
原因：类的析构函数编译后析构函数的名称统一处理成destructor，所以实际上它们的名字仍是相同的，符合重写的条件。

为了确保在使用基类指针或引用删除派生类对象时能够正确调用派生类的析构函数，通常需要将基类的析构函数声明为虚函数
只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。

class Person {
public:
 	virtual ~Person() {cout << "~Person()" << endl;}
};

class Student : public Person {
public:
 	virtual ~Student() { cout << "~Student()" << endl; }
};

int main()
{
 	Person* p1 = new Person;
 	Person* p2 = new Student;
 	delete p1;
 	delete p2;
 	
 	return 0;
}

3、类的虚函数可以不加virtual
在父类的虚函数加上virtual的情况下，子类的虚函数不加上virtual，并且符合重写的其他条件，照样可以实现重写。

class Car
{
public:
	virtual void Drive() 
	{
		cout << "Car::Drive()" << endl;
	}
};
class Benz : public Car
{
public:
	void Drive()
	{
		cout << "Benz::Drive()" << endl;
	};
};

三、多态的实现原理

多态的实现原理主要涉及两个概念：动态绑定和虚函数

动态绑定：在编译时，编译器并不知道一个对象的具体类型，而是根据引用或指针的类型来访问对象的成员。在运行时，根据引用或指针所指向的实际对象的类型，动态绑定机制会决定调用哪个对象的方法。这样，不同类型的对象可以对同一个消息做出不同的响应。

我们回到开头的买票例子

class Person {
public:
       virtual void BuyTicket()
       {
              cout << "Person::买票-全价" << endl;
       }
       virtual ~Person()
       {
              cout << "~Person()" << endl;
       }
};
class Student : public Person {
public:
       //重写
       void BuyTicket() { cout << "Student::买票-半价" << endl; }
       ~Student()
       {
              cout << "~Student()" << endl;
       }
};
//父类的引用
void Func(Person& p)
{
       p.BuyTicket();
}
int main()
{
       Person ps;
       Func(ps);
       ps.BuyTicket();
       return 0;
}

构成多态时->动态绑定

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

查看汇编代码

（省略了与当前讨论无关的汇编代码）

...（省略了与当前讨论无关的汇编代码）
 p中存的是父类对象的指针，将p移动到eax中
00142831 mov eax,dword ptr [p]

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

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

call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来
以后到对象的中取找的。
0014283D call eax
0014283F cmp esi,esp

当我们通过对象调用的时候，不构成多态->静态绑定

 ps.BuyTicket();

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

四、探索虚表

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

结果为12字节，并不是我们想的（int（4字节）+ char（1字节）+3字节（内存对齐）= 8字节 ）
原因是当存在虚函数的时候，每个对象都会有一个虚函数表指针（vfptr），该指针指向一个虚函数表（vtable）。虚函数表是一个存储了虚函数地址的数组，每个虚函数在表中占据一个位置。通过虚函数表指针，程序可以在运行时动态地确定调用哪个虚函数。

对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表，那么派生类中这个表放了些什么呢？我们接着往下分析

4.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:
       //重写了func1
       virtual void func1() { cout << "Derive::func1" << endl; }
       virtual void func3() { cout << "Derive::func3" << endl; }
       virtual void func4() { cout << "Derive::func4" << endl; }
       void func5() { cout << "Derive::func4" << endl; }
private:
       int b;
};
class X :public Derive {
public:
       //重写了func3
       virtual void func3() { cout << "X::func3" << endl; }
};
int main()
{
       Base b;
       Derive d;
       X x;
  //多态
       Derive* p = &d;
       p->func3();
       p = &x;
       p->func3();
       return 0;
}

这个表称为虚函数表(简称虚表)，表里面存储的是虚函数的地址
观察下图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。那么我们如何查看d的虚表呢?

我们可以通过内存窗口观察虚表中的虚函数指针，（观察箭头指向）可以发现虚函数重写后对应的虚函数指针也发生了改变（重写/覆盖）

4.2 多继承对象模型

示例代码：

//多继承的虚表
class Base1 {
public:
       virtual void func1() { cout << "Base::func1" << endl; }
       virtual void func2() { cout << "Base::func1" << endl; }
private:
       int b1;
};
class Base2 {
public:
       virtual void func1() { cout << "Base::func1" << endl; }
       virtual void func2() { cout << "Base::func1" << endl; }
private:
       int b2;
};
class Derive : public Base1, public Base2 {
public:
       //重写了base1的和base2的func1
       virtual void func1()
       {
              cout << "Derive::func1" << endl;
       }
       //自己的虚函数func3放在第一张虚表中
       virtual void func3() { cout << "Derive::func3" << endl; }
private:
       int d1;
};
int main()
{
       Derive d;
       //打印第一张虚表
       PrintVFT((VFUNC*)(*(int*)&d));
       //打印第二张虚表
       PrintVFT((VFUNC*)(*(int*)((char*)&d+sizeof(Base1))));
       return 0;
}

透过监视一栏我们可以观察到对象d中存了两张虚表，多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中（）

五、纯虚函数

定义：纯虚函数是在基类中声明的没有实际实现的虚函数。它的声明形式为在函数声明的末尾加上 “= 0”。纯虚函数的目的是为了让派生类必须实现该函数，以使派生类能够成为一个完整的类。
特点：
1.间接强制取派生类重写
2.（具有纯虚函数的类叫做抽象类）抽象类-不能实例化出对象
3.派生类若不重写纯虚函数，则无法实例化出对象

class  Car
{
public:
	virtual void Drive() = 0;
	void func()
	{
		cout << "void func()" << endl;
	}
};

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

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

void func(Car* ptr)
{
	ptr->Drive();
}

int main()
{
	//func(new Benz);
	func(new BMW);
	Benz b;
	b.Drive();
	return 0;
}

若是我们屏蔽了派生类对纯虚函数的重写，则无法构建对象

小结

今日的分享就到这里啦，如果本文存在疏漏或错误的地方还请您能够指出！