引言

多态是面向对象编程的三大特性之一（封装、继承、多态），也是C++中最强大且最复杂的特性之一。它允许我们以统一的方式处理不同类型的对象，极大地提高了代码的灵活性和可扩展性。

本文将全面探讨C++中多态的概念，定义，实现，包括纯虚函数和抽象类及其实现原理。

1. 多态的概念

多态，在面向对象编程中，是指同一个行为具有多个不同表现形式或形态的能力。简单来说，就是“一个接口，多种实现”。

多态分为两种：

1. 编译时多态（静态多态）：函数重载和函数模版。
2. 运行时多态（动态多态）：虚函数和继承。

本文重点讨论运行时多态。

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

2. 多态的定义和实现

2.1 实现多态的条件

1. 多态是一个继承关系下的类对象，去调用同一函数产生了不同效果的行为。所以必须有继承的基类和派生类。
2. 必须是基类的指针或者引用调用虚函数。因为只有基类的指针或引用才能既指向基类对象又指向派生类对象。
3. 被调用的函数必须是虚函数，并且完成了虚函数重写或覆盖。只有完成了重写或者覆盖，基类和派生类之间才能有不同的函数，多态的不同形态效果才能达到。

2.2 虚函数

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

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

2.3 虚函数的重写/覆盖

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

注意：在重写基类虚函数时，派生类的虚函数也可以不加 virtual 关键字。

// 基类
class Person
{
public:
	// 基类成员函数必须使用 virtual 修饰
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
	// 不使用 virtual 修饰
	// void BuyTicket() { cout << "买票-全价" << endl; }
};

// 派生类
class Student : public Person {
public:
	// 可以加 virtual 修饰
	virtual void BuyTicket() { cout << "买票-打折" << endl; }
	// 也可以不加
	// void BuyTicket() { cout << "买票-打折" << endl; }
};

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

class Animal
{
public:
	// 基类的必须加virtual
	virtual void talk() const
	{}
};

class Dog : public Animal
{
public:
	// 派生类的成员函数可以不加virtual
	void talk() const
	{
		std::cout << "汪汪" << std::endl;
	}
};

class Cat : public Animal
{
public:
	// 也可以加virtual
	virtual void talk() const
	{
		std::cout << "(>^ω^<)喵" << std::endl;
	}
};

//virtual void func()
//{}

void letsHear(const Animal& animal)
{
	animal.talk();
}

int main()
{
	// 多态的实现
	Cat cat;
	Dog dog;
	letsHear(cat);
	letsHear(dog);

	/*Person ps;
	Student st;

	Func(ps);
	Func(st);*/

	return 0;
}

2.4 虚函数重写的一些其他问题

• 协变：派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或引用，派生类虚函数返回派生类对象的指针或引用。
• 析构函数的重写：基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加 virtual 关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成 destructor ，所以基类的析构函数加了 virtual 修饰，派生类的析构函数就构成重写。
• 下面的代码我们可以看到，如果 ~C() ，不加 virtual ，那么 delete p2 时只调用的 C 的析构函数，没有调用 D 的析构函数，就会导致内存泄漏问题，因为 ~D() 中在释放资源。

// 协变
class A {};

class B : public A {};

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

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

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

// 析构函数的重写
class C
{
public:
	virtual ~C()
	{
		cout << "~C()" << endl;
	}
};

class D : public C {
public:
	// 析构函数会自动改名为destructor
	~D()
	{
		cout << "~D()->delete:" << _p << endl;
		delete _p;
	}

protected:
	int* _p = new int[10];
};

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

int main()
{
	// 基类指针
	Person ps;
	// 派生类指针
	Student st;
	// 类外的函数。基类的指针返回基类的数据，派生类返回派生类的数据
	Func(&ps);
	Func(&st);

	// 基类指针创建了C类和D类的空间
	C* p1 = new C;
	C* p2 = new D;

	// 由于析构函数的重写，所以这里能分别调用各自的析构函数
	delete p1;
	delete p2;

	return 0;
}

2.5 override 和 final 关键字

• 从上面可以看出，C++ 对虚函数重写的要求比较严格，但是有些情况下由于疏忽，比如函数名写错、参数写错等导致无法构成重写，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来 debug 会得不偿失，因此 C++11 提供了 override，可以帮助用户检测是否重写。
• 如果我们不想让派生类重写这个虚函数，那么可以用 final 去修饰。

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

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

int main()
{
	return 0;
}

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

int main()
{
	return 0;
}

2.6 重载/重写/隐藏的对比

3. 纯虚函数和抽象类

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

// 抽象类
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;
}

书接下回：C++ 多态：面向对象编程的核心概念（二）