C++：多态

---

一、多态的概念

  多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。
  比方说，我们现在邀请一个朋友Pony玩《金铲铲之战》，登陆游戏后，由于Pony是新用户，而我是老用户，游戏会根据用户的类型来显示不同的页面。

二、多态的定义及实现

2.1 多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。
比如Student继承了Person。
Person对象买票全价，Student对象买票半价。
那么在继承中要构成多态还有两个条件：

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

2.2 虚函数

  虚函数：即被virtual修饰的类成员函数称为虚函数。

2.3 虚函数的重写(覆盖)

  派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的
返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。
  如上图中Person的BuyTicket和Student的BuyTicket函数。

2.4 override 和 final

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

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

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

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

三、抽象类

  在虚函数的后面写上 =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();
}
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

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

感觉能力不够，不能讲的很细致，我们来看几个题目吧。

1.

下面 C++ 程序的运行结果是（）

#include 
using namespace std;
class parent {
	int i;
protected:
	int x;
public:
	parent() { x = 0; i = 0; }
void change() { x++; i++; }
void display();
};
class son :public parent {
public:
void modify();
};
void parent::display() {
	cout << "x=" << x << endl;
}
void son::modify() {
	x++;
}
int main() {
	son A;
	parent B;

	A.display();			
	A.change();
	A.modify();
	A.display();
	B.change();
	B.display();
	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

A x=1      B x=2
 x=0       x=0
 x=2       x=1

C x=0       D x=0
 x=2       x=1
 x=1       x=2

题解：注意看，首先实例化两个对象A，B.
调用了display函数，由于子类中没有这个函数，
我们前往父类执行，打印x= ，由于构造子类，首先要构造父类，父类中初始化x为0，因此打印x=0.
接着调用change函数，同样的，子类中没有这个函数，
继续前往父类执行，x++，i++，x的值变为1，i的值变为1
然后是modify函数，x变为2,
再次调用display，打印x=2.
注意看下一行，由于我们上面已经修改的x是A空间的x，与B空间无关，
因此B空间的x还是要从0开始，
执行change函数，x变为1，最后打印x=1，也就是选择C

2.

分析一下这段程序的输出

#include
using namespace std;
class B
{
public:
	B()
{
	cout << "default constructor" << " ";
}
~B()
{
	cout << "destructed" << " ";
}
B(int i): data(i)
{
	cout << "constructed by parameter" << data << " ";
}
private: 
	int data;
};
B Play( B b)
{
	return b;
}
int main(int argc, char *argv[])
{
	B temp = Play(5);
	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

A constructed by parameter5 destructed destructed
B constructed by parameter5 destructed
C default constructor" constructed by parameter5 destructed
D default constructor" constructed by parameter5 destructed destructed

---

题解：我们首先有一个拷贝构造的临时对象，又有一个temp对象，因此需要两次析构函数。选择A

总结

被多态题爆杀了一阵子，也稍微参悟了一些内容，分享给大家。