理解C++多态 - 技术栈

多态概念

多态，简单来讲就是多种形态。可以分为编译时多态（静态多态）和运行时多态（动态多态）
编译时多态主要是函数重载和函数模板，他们传不同的参数可以调用不同的函数，实参传给形参的参数匹配是在编译时完成的。
运行时多态，就是去完成某个行为（函数），不同对象有不同的行为，达成了多种形态。比如普通人买票为全价，学生买票则打折。

实现多态的两个必须条件：

必须是基类的指针或者引用调用虚函数
被调用的函数必须是虚函数，并完成了虚函数重写/覆盖
说明：要实现多态，第一必须是基类的指针或引用，因为只有基类的指针或引用才能既指向基类对象又指向派生类对象 ；第二派生类必须对基类的虚函数完成重写/覆盖，重写或覆盖之后，基类和派生类之间才能有不同的函数，多态的不同形态效果才能实现。

虚函数

类成员函数前面加virtual修饰，那么这个成员函数被称为虚函数。需要注意的是，非成员函数不能加 virtual 修饰。

cpp 复制代码

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

虚函数的重写/覆盖

虚函数的重写/覆盖：如果派生类中有一个跟基类完全相同的虚函数（返回值类型、函数名、参数列表相同），成派生类的虚函数重写/覆盖了基类的虚函数。
再重写基类的虚函数时，派生类的虚函数可以不加 virtual 关键字 ，但是不是很规范，不建议这样用。建议在派生类的虚函数中也加上 virtual关键字
基类的虚函数必须加 virtual 关键字

cpp 复制代码

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

class Student : 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;
	Func(&ps);	//买票全价
	Func(&st);	//买票打折
	return 0;
}

重写/覆盖可以理解为基类的声明+派生类的实现，所以不要再重写的虚函数上加缺省值，加了也没用。

虚函数重写的一些问题

协变

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

析构函数的重写

基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加 virtual 关键字，都与基类的析构函数构成重写。编译后析构函数的名称统一处理成 destructor，所以基类的析构函数加了 virtual 修饰，派生类的析构函数就构成重写。
建议基类析构函数设置为虚函数

cpp 复制代码

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

int main()
{
	A* p1 = new A;
	A* p2 = new B;

	//p1->析构函数+operator delete
	delete p1;
	delete p2;  
}

override 和 final 关键字

C++11 提供了 override 关键字，可以帮助用户检测是否构成重写

如果不想让派生类重写某个虚函数，可以加上 final 修饰

cpp 复制代码

class Car {
public:
	virtual void Dirve() final
	{
	}
};

class Benz :public Car 
{
public:
	// error C3248: "Car::Dirve": 声明为 "final" 的函数不能由 "Benz::Dirve" 重写
	virtual void Dirve() 
	{
		cout << "Benz舒适" << endl; }
	};

重载/重写/隐藏对比

其实就是函数名相同的函数之间的关系对比

纯虚函数和抽象类

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

cpp 复制代码

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

cpp 复制代码

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

应该选D.12
除了 _b 和 _ch 成员，还多一个 _vfptr 放在对象的前面（与平台有关，可能放在后面），对象中的这个指针就是虚函数表指针(v 代表virtual ， f 代表 function)。
一个含有虚函数的类中都至少有一个虚函数表指针，因为一个类所有虚函数的地址要被放到这个类对象的虚函数表中，虚函数表也简称为虚表。

多态是如何实现的

满足多态的条件后，底层不再是编译时通过调用对象确定函数的地址，而是运行时到指向的对象的虚表中确定对应的虚函数的地址，这样就实现了指针或者引用指向基类就调用基类的虚函数，指向派生类就调用派生类对应的虚函数。

cpp 复制代码

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

class Student : public Person {
public:
	virtual void BuyTicket()
	{
		cout << "买票打折" << endl; 
	}
	private:
		string _id;
};

class Soldier : public Person {
public:
	virtual void BuyTicket() {
		cout << "买票优先" << endl; 
	}
private:
	string _codename;
};
			
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;
}

动态绑定与静态绑定

对不满⾜多态条件 (指针或者引⽤+调⽤虚函数)的函数调⽤是在编译时绑定，也就是编译时确定调⽤函数的地址，叫做静态绑定。
满⾜多态条件 的函数调⽤是在运⾏时绑定，也就是在运⾏时到指向对象的虚函数表中找到调⽤函数的地址，也就做动态绑定