C++多态(1)

1. 多态的概念

通俗来说，就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

举个例子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person；Person对象买票全价，Student对象买票半价。

多态分为静态的多态和动态的多态。首先来看静态的多态：

再举个例子：

int i = 1;
double d = 1.0; 
cout<<i;//	cout.operator<<(int)
cout<<d;//	cout.operator<<(double)
1
2
3
4

流输出能自动识别类型其实就是这个原理，不同类型的对象调用同一函数但是产生了不同的结果。而以上行为都是在编译的时候实现的，比如cout调用。

而动态的多态：一个父类的引用或指针去调用同一函数，传递不同对象，会调用不同的函数。 这个行为是运行时实现的。

2. 多态的定义和实现

2.1 多态的构成条件

先总结其构成条件（后续再解答）：

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

2.1.1 重写

被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

通俗点：子类必须完成对父类的虚函数的重写。

• 什么是重写？

重写的定义是：子类中满足三同（函数名、参数、返回值）的虚函数，叫做重写（覆盖）。

• 什么是虚函数？

虚函数的定义是：被virtual修饰的类成员函数称为虚函数。

初步了解了这些概念以后，观察下列代码：

class Person 
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
1
2
3
4
5
6
7
8
9

有两个问题需要说明：

1. 这两个函数并不构成隐藏，即使它们是继承关系并且函数名相同

在这里它们构成重写。

也就是说，但凡它们不满足这里面要求的任何一个，它们就构成隐藏（函数名相同即可）。

2. 这里的virtual和继承里的virtual虚继承没有联系

这里表示的是虚函数。

虚函数有一个要求：必须是类的非静态函数；关键点：类的、非静态。也就是说普通函数和静态函数都无法称为虚函数。

• 理解

那么通过这些理解，可以知道：

构成多态的条件之一就是重写，而重写又需要满足四个条件：

1. 子类函数与基类函数都是虚函数
2. 它们的返回值类型相同
3. 它们的函数名字相同
4. 它们的参数列表相同

2.2.2 指针或者引用

必须通过基类的指针或者引用调用虚函数

这里为什么一定要是基类？为什么一定要是指针或者引用？

后面的章节会解释，是切片的原理：第二章节博客

先看构成多态的情况：

```c
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

这时候的结果是一个全价票，一个半价票。

p实现的是Person类，为什么也可以出现半价票的情况？

这说明这里构成了多态。

如果不用引用调用呢？

void Func(Person p)//传对象接收
{ 
	p.BuyTicket(); 
}
1
2
3
4

这时候无论是Student还是People来调用都是全价票，也就是说不构成多态了。

而上述代码换成指针调用也是构成多态的。

构成多态：传的哪个类型的对象，调用的就是这个类型的虚函数，也就是说结果如何和对象有关。可以看到即使p实现的是Person类，也可以出现半价票的情况。

不构成多态：调用的就是p类型的虚函数，跟类型有关。这时候p的类型实现为Person，那么无论怎么调用，它输出的都是全价票。具体的原因涉及虚表，在下一章节解释。

2.2 虚函数重写的两个例外

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

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

class Person {
public:
	virtual A* f() {return new A;}
};
class Student : public Person {
public:
	virtual B* f() {return new B;}
};
1
2
3
4
5
6
7
8

2. 析构函数的重写(基类与派生类析构函数的名字不同)

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

看一段正确实现多态调用析构函数的代码：

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;//切片
	//析构函数+operator delete
	delete p1;//p1->destructor()
	delete p2;//p2->destructor()
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

上述代码中，p1是父类对象，里面包含了父类的所有成员；而p2是被切片后的子类对象，里面包含了父类继承下来的成员还有子类自己的成员。

那么在析构的时候，我们的期望是p1调用父类析构，p2不仅能调用父类析构，还要能调用子类析构。

要实现这个行为，如果不形成多态，是无法实现的。因为p1p2都是父类类型，在不构成多态的情况下都会只调用父类的析构函数，那么p2中子类部分就有可能造成内存泄露。（当前这种情况肯定会，因为申请了子类对象的空间）

在形成多态以后，这种情况也可以

Person* p1 = new Person;
Student* p2 = new Student;
delete p1;//p1->destructor()
delete p2;//p2->destructor()
1
2
3
4

此时把p2定义成Student类的对象，析构的时候自然就会按照继承类的析构方法处理，无论你是否构成多态，都是一样的结果。

析构函数是比较特殊的，它的函数名、返回值、参数都满足重写的条件，刚才阐述了重写有四个条件，已经默认符合了三个，并且也符合指针调用；那么现在它是否形成多态，就决定于父类与子类的析构函数是否都是虚函数。

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

• 上述总结

对于需要析构函数需要实现多态的场景只有一个：

只有当动态申请的父子对象，给了父类指针管理，那么就需要析构函数是虚函数。 因为此时不用多态的原理去让编译器正确调用析构函数的话，p1和p2默认调用的都是父类的析构函数，p2中的子类对象未释放，导致内存泄漏。

Person* p1 = new Person;
Person* p2 = new Student;
1
2

那么上述还有一种情况不会造成内存泄露：就是说如果下面的是普通对象，并不是指针或者引用，就不会构成多态，那么无论析构函数是否是虚函数，是否完成重写，都会正确调用。

//不构成多态，但是依旧能正确调用
int mian()
{
	Person p;
	Student s;
	return 0;
}
1
2
3
4
5
6
7

2.3 多态里的一个不规范的地方

在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后父类的虚函数被继承下来了在子类依旧保持虚函数属性),但是该种写法不是很规范，不建议这样使用。

//虽然子类没写virtual,但是由于它是先继承了父类虚函数的特性
//构成多态
class Person 
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
	void BuyTicket() { cout << "买票-半价" << endl; }
};
1
2
3
4
5
6
7
8
9
10
11

这里更有一个坑：

//Student类里的函数定义为私有
//还是可以形成多态
class Person 
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
	void BuyTicket() { cout << "买票-半价" << endl; }
};
//下列指针或引用调用省略
1
2
3
4
5
6
7
8
9
10
11

子类中的函数定义为了私有，居然还是可以形成多态？！

这也是和上面一个道理，先继承了父类公有的特性，然后完成了重写，形成多态。

其实C++设计者对于为什么子类可以不实现虚函数也可以形成多态这个问题，考虑的更多的是：防止子类析构函数因为没有实现为虚函数而造成内存泄漏。

因为很多项目的父类和子类不是同一个人实现的，那么子类的实现者可能会忘记实现成虚函数而造成内存泄漏，这其实就是为了填这个坑设计出来的；但是没有考虑到会影响到其他函数的歧义。

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

重载重要的特征就是两函数在同一作用域，对返回值没有要求；
重写和隐藏要求的是分别在子类和父类的作用域。

所以说如果作用域满足父子类且函数名相同的情况下，而不构成重写的话，那就是构成隐藏。

3. C++11 override 和 final

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。

1. final：修饰虚函数，表示该虚函数不能再被重写，也表示该类是最终类

class Car
{
public:
	virtual void Drive() final//无法重写 
	{}
};
class Benz :public Car
{
public:
	virtual void Drive() {cout << "Benz-舒适" << endl;}
};
1
2
3
4
5
6
7
8
9
10
11

2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错（放在子类重写的虚函数后面）。

class Car{
public:
	virtual void Drive()
	{}
};
class Benz :public Car {
public:
	virtual void Drive() override //检查是否完成重写
	{cout << "Benz-舒适" << endl;}
};
1
2
3
4
5
6
7
8
9
10