C++多态

正文开始前给大家推荐个网站，前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。 点击跳转到网站。

多态的概念

通俗来说，多态就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
比如：买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。他们做的都是一种行为，都是买票，但是得到的结果却是不同的。这就是多态！

多态的定义及实现

多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。所以多态一定是要有继承，然后不同的对象去干某件事产生不同的行为。

除了继承以外，多态还有两个重要的条件：

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

虚函数和虚函数的重写

什么是虚函数呢？

被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
10
11
12
13
14
15
16
17

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

我们说虚函数重写要有三同，返回值类型、函数名字、参数列表完全相同，但是有两个例外，协变和析构函数的重写。

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

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

class A{};

class B : public A {};

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

class Student : public Person
{
public:
	virtual B* BuyTicket()
	{
		cout << "买票-半价" << endl;
		return new B;
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

此时也构成虚函数重写。

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

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

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};
1
2
3
4
5
6
7
8

构成重写以后，只有通过父类的指针或者引用调用，才构成多态。

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

void func(Person* p)
{
	p->BuyTicket();
}
int main()
{
	Person* p = new Person;
	Student* s = new Student;

	func(p);
	func(s);

	delete p;

	p = s;
	delete p;
	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
27
28
29
30
31
32
33
34
35

如果这个代码稍微破坏一下构成多态的条件，就会和这个结果不一样！

override 和 final

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

1. final ：修饰虚函数，表示该虚函数不能再被重写
2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错。

重载、覆盖(重写)、隐藏(重定义)的对比

我们可以认为重写包含在重定义里面，它的条件更为苛刻。

抽象类

在虚函数的后面写上 =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;
	}
};
void Test()
{
	Car* pBenz = new Benz;
	pBenz->Drive();
	Car* pBMW = new BMW;
	pBMW->Drive();
}

int main()
{
	Test();
	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
27
28
29
30
31
32
33
34

这里的Car是实例不出对象的，它的子类也只有重写了纯虚函数才能实例出对象，但是可以定义Car的指针，这也体现了多态的另一种用法。

接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

多态的原理

我们先来做一个小实验。

我们运行一下这个代码，以我们目前的知识储备，这个结果一定是4，但是会发现结果是8，为什么呢？

这是因为在我们age的前面还有一个虚函数表指针。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

父类存在虚表的话，派生类中也会有一个虚表，一部分是继承下来的父类的虚表，还有一部分是自己的独有的虚函数，虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。所以当我们对父类的虚函数进行重写，修改的是续表中对应的虚函数的指针，所以重写也称为覆盖。虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。

为什么只有父类的指针或引用调用才能触发多态呢？

我们会发现不管是指针还是引用，都是找到原来的对象，从它的虚表中找到需要调用的函数的对应的地址进行调用，如果不用指针，用对象的话一定会存在赋值，赋值是不会拷贝虚表指针的，因为如果拷贝续表指针，就不能保证父类指向子类调用子类的函数，指向父类调用父类的函数，所以如果是赋值的话，不会拷贝虚表函数，就根本不可能通过虚表找到对应函数的地址进行调用，就根本也触发不了多态。

多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。

动态绑定与静态绑定

1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

继承和多态常见的面试问题

1. inline函数可以是虚函数吗？

可以，不过编译器就忽略inline属性，这个函数就不再是inline，因为虚函数要放到虚表中去。

2. 静态成员可以是虚函数吗？

不能，因为静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

3. 构造函数可以是虚函数吗？

不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。

4. 对象访问普通函数快还是虚函数更快？

首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。

5. 虚函数表是在什么阶段生成的，存在哪的？

虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。

6. 抽象类的作用？

抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。

那么今天的分享就到这里了，有什么不懂得可以私信博主，或者添加博主的微信，欢迎交流。