C++：多态 ( 语法篇)

🍁多态简介

多态是C++面向对象三大特性之一，那么多态二字又该如何去理解呢？

在现实生活中，针对同一行为不同对象所体现的事件的不同形态称为多态。

例如：

1. 不同国家的人吃饭的所用的餐具不一样，在我国吃饭用的是筷子；美国等其他欧洲国家吃饭用餐叉；印度更是直接用手抓。
2. 去公园买票，普通人买票时需要全票价购买；学生买票时可以半票价购买；针对退伍军人可以优先购票等等。
3. 商品售卖，新用户可以享受到九折优惠；老用户可以享受到八折优惠。

🍁构成多态的条件

多态是在继承的基础上实现的，当然C++构成多态还需要满足以下条件：

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

以上提到构成多态的条件缺一不可，否则构不成多态。

🍂虚函数

在类中被virtual关键字修饰的函数称为虚函数

class Person
{
public:	
	virtual void BuyTicket()  //被virtual关键字修饰的函数为虚函数
	{
		cout << "普通人买票->全票价" << endl;
	}
};

🍂虚函数重写

派生继承基类的时候，会将基类的成员和成员函数继承到派生类中，当成派生类中一部分；

在这里先捋清楚两个概念：继承中的重定义 和 多态中虚函数的重写

1. 重定义：承体系中基类和派生类都有独立的作用域。派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏，也叫重定义
2. 虚函数重写：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称派生类的虚函数重写了基类的虚函数

针对继承中的重定义来说，只要基类和派生类的成员名字相同即构成重定义；

虚函数构成重写的条件较为严格，不仅仅只是虚函数的函数名字相同还包括：虚函数返回值、参数列表等等。

在这里切记不要将重定义与虚函数重写两者概念搞混了。

下面举个构成虚函数重写的示例：

class Person
{
public:	
	virtual void BuyTicket()  //基类的虚函数
	{
		cout << "普通人购票->全票价" << endl;
	}
};

class Student : public Person
{
public:	
	virtual void BuyTicket() //子类的虚函数与基类的虚函数：名字、函数返回值、参数相同；构成虚函数重写
	{
		cout << "学生购票->半票价" << endl;
	}
};

重定义和虚函数重写区分开后，回到刚刚提到的构成多态的条件。

在上面示例中只是完成了虚函数的重写，并不能实现多态。

还要需要完成另一个条件：通过基类的指针或是引用去调用虚函数

class Person
{
public:	
	virtual void BuyTicket()  //基类的虚函数
	{
		cout << "普通人购票->全票价" << endl;
	}
};

class Student : public Person
{
public:	
	virtual void BuyTicket() //子类的虚函数与基类的虚函数：名字、函数返回值、参数相同；构成虚函数重写
	{
		cout << "学生购票->半票价" << endl;
	}
};

void func(Person& p) //基类的引用
{
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;
	
	func(ps);
	func(st);

	return 0;
}

创建ps和st两个不同对象，可以看到的是func函数的参数是基类的引用，通过基类的引用去调用虚函数从而构成多态

如果构成多态情况到此为此还好，但是往往都会有特殊情况，好比如下虚函数重写的两个特例，也构成多态：

🍂构成虚函数重写的两个特例

🍃派生类中的虚函数的virtual关键字可以省略

class Person
{
public:	
	virtual void BuyTicket()  //基类的虚函数
	{
		cout << "普通人购票->全票价" << endl;
	}
};

class Student : public Person
{
public:	
	void BuyTicket() //省略BuyTicket虚函数的virtual关键字
	{
		cout << "学生购票->半票价" << endl;
	}
};

void func(Person& p) //基类的引用
{
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;
	
	func(ps);
	func(st);

	return 0;
}

上述提到的派生类中的虚函数的virtual关键字省略后，完成了虚函数重写。

只是为了这样去运用开此特例难免会多此一举，这个特例主要运用于析构函数的重写：

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; //构成多态，delete会调用Student类的析构函数
	
	return 0;
}

基类和派生类的类名字不同，因此析构函数的名字也会不同。如果基类的指针去调用派生类进行切片，待程序结束后，与之对应的析构函数又如何去调用呢？这个就要让编译器去处理了：

派生类继承基类后，编译器会对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

如果实现过程中，基类将析构函数设置为虚函数，那么派生类中的析构函数就必须完成相对应的虚函数重写。但是往往都会出现例外，要是实现者就忘记去加上virtual关键字不就构不成虚函数重写了吗？因此才会开此特例。

上面例子我们也看到了，在这里不单单只适用于析构函数，所有情况都适用这个特例。切记，基类虚函数的关键字不能省略。

🔥多态的一道例题

我们来看看这样的一道例题：

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()
{
	A*p = new B;

	p->test();

	return 0;
}

这道程序构成多态么？答案为？

这道程序很直观的可以看到符合多态的==虚函数重写==这个条件。

B类继承了A类，这道程序中虽然B派生类中的func函数没有被virtual关键字进行修饰，但是也构成虚函数的重写(该函数与基类的func虚函数的返回值相同、函数名相同、函数的参数列表个数和类型都相同)。

再来分析一下该程序是否满足构成多态第二个条件：虚函数通过基类的指针或是引用进行调用

test函数是虚函数，派生类中并没有完成重写，在这里不构成多态。但是test函数内部用this指针去调用func函数的时候构成了多态。

这里解释一下为什么this指针在这里构成了多态：创建的p指针的类型是基类的，在这里存储了派生类B地址；在第调用test函数的时候，p指针传给了this指针，因此this指针就是基类的指针，此时调用虚函数正对应上了构成多态的第二个条件。

看到这里我相信很多人会心里面的答案会是：B->0。但是答案果真如此吗？

这里我们要想到一件事情：为什么要叫虚函数重写，而不是虚函数的替换或者是其他的名字？

在用基类的指针或是引用去调用派生类的虚函数时，只会去调用派生类的虚函数的定义。虚函数参数列表类型的缺省值用的还是基类的。

这也是答案为什么是B->1而不是B->0。

🍃协变（运用场景不多）

• 协变(基类与派生类虚函数返回值类型不同)

派生类重写基类虚函数时，与基类虚函数返回值类型不同。这里提到派生类的虚函数的返回值不同，不是说什么返回值都可以。

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

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

🍂关键字 final 和 override

final 和 override 关键字是C++11提供的，不支持C++11的编译器在使用这两个关键字时会报错。

C++11提供这两个关键字是为了让用户更好的去检测虚函数重写。

🍃final

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

该关键字直接加到函数参数列表的右括号后面即可：

class Car
{
public:
	virtual void Drive() final  // final进行修饰
	{} 
};
class Benz :public Car
{
public:
	virtual void Drive() 
	{
		cout << "Benz-舒适" << endl;
	}
};

🍃override

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

该关键字直接加到函数参数列表的右括号后面即可：

class Car
{
public:
	virtual void Drive()
	{} 
};
class Benz :public Car
{
public:
	virtual void Drive(int x) override //用 override 关键字进行修饰，和基类的虚函数参数列表不同
	{
		cout << "Benz-舒适" << endl;
	}
};

int main()
{
	Benz b;
	Car c;

	return 0;
}

🍂重载、重定义(隐藏) 和 重写(覆盖)

1. 函数重载：限制在同一个作用域内，两个函数的函数名相同；函数的形参列表的 类型、参数个数、参数顺序 不同，构成函数重载。
2. 重定义：承体系中基类和派生类都有独立的作用域。派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。
3. 虚函数重写：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的 返回值类型、函数名字、参数列表 完全相同 )，称 派生类 的虚函数重写了 基类 的虚函数。

🍁抽象类

看抽象类前，先来介绍一下纯虚函数：

🍂纯虚函数

• 直接在虚函数后面写上等于0，该函数称为纯虚函数

virtual void Func() = 0; //Drive为纯虚函数

• 包含纯虚函数的类被称为抽象类(接口类)

class Car
{
public:
	virtual void Drive() = 0; //Car类中的纯虚函数
};

注意：抽象类不能实例化出对象！！！

int main()
{
	Car c; //报错

	return 0;
}

在继承体系中，如果基类为抽象类，派生类没有去重写纯虚函数的话，派生类也不能实例化出对象。

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

class Benz :public Car //继承抽象类Car
{};

int main()
{
	Benz b; //不能实例化出对象，报错

	return 0;
}

• 纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承（基类写了纯虚函数那么派生类就必须完成纯虚函数的重写的工作）

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

class Benz :public Car //继承抽象类Car
{
public:
	virtual void Drive()
	{
		cout << "Drive()" << endl;
	}
};

int main()
{
	Benz b; //派生类重写了虚函数，实例化对象成功

	return 0;
}

🍂接口继承 和 实现继承

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

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

因此在实现过程中，如果不实现多态，不要把函数定义成虚函数