【深入理解C++】虚函数、override、final、多态_final和virtual、override

1.父类指针可以指向子类对象

父类指针可以指向子类对象，是安全的，开发中经常用到（继承方式必须是public）。

#include <iostream>
using namespace std;

class Person
{
public:
	int m_age;
};

class Student : public Person
{
public:
	int m_score;
};

int main()
{
	Person* p = new Student(); // 父类指针可以指向子类对象，只看左边定义的指针类型
	p->m_age = 10;
	//p->m_score = 100; // 报错，Person类中没有m_score这个成员变量

	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

2.子类指针不可以指向父类对象

子类指针不可以指向父类对象，是不安全的。

#include <iostream>
using namespace std;

class Person
{
public:
	int m_age;
};

class Student : public Person
{
public:
	int m_score;
};

int main()
{
	//Student* p = new Person(); // 报错，子类指针不可以指向父类对象

	Student* p = (Student*) new Person(); // 强制类型转换
	p->m_age = 10;
	p->m_score = 100; // 不报错，但不安全

	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

3.虚函数

默认情况下，编译器只会根据指针类型调用对应的函数。

#include <iostream>
using namespace std;

class Animal
{
public:
	void run()
	{
		cout << "Animal::run()" << endl;
	}
};

class Dog : public Animal
{
public:
	void run()
	{
		cout << "Dog::run()" << endl;
	}
};

class Cat : public Animal
{
public:
	void run()
	{
		cout << "Cat::run()" << endl;
	}
};

int main()
{
	Animal* p1 = new Animal(); // 只看左边定义的指针类型
	p1->run();
	delete p1;

	Animal* p2 = new Dog();  // 只看左边定义的指针类型
	p2->run();
	delete p2;

	Animal* p3 = new Cat(); // 只看左边定义的指针类型
	p3->run();
	delete p3;

	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
36
37
38
39
40
41
42
43
44
45
46

输出结果如下：

汇编代码如下：

可以通过一个父类指针调用父类和子类中的同名同参的函数，只需要在父类中该函数声明之前加上 virtual 关键字使其成为虚函数即可。

只要在父类中声明为虚函数，那么在所有子类中重写的函数也自动变成虚函数，也就是说子类中可以省略 virtual 关键字（为了阅读代码方便，建议加上）。

子类继承父类时，子类可以不重写父类的虚函数，则相当于原样继承了父类的虚函数；也可以重写，则相当于覆盖了父类的虚函数实现。不论是否重写虚函数都不影响子类的实例化。

调用虚函数执行的是“动态绑定”，如下代码所示，在程序运行的时候才能知道调用了哪个子类的 run() 函数。

#include <iostream>
using namespace std;

class Animal
{
public:
	virtual void run()
	{
		cout << "Animal::run()" << endl;
	}
};

class Dog : public Animal
{
public:
	virtual void run()
	{
		cout << "Dog::run()" << endl;
	}
};

class Cat : public Animal
{
public:
	virtual void run()
	{
		cout << "Cat::run()" << endl;
	}
};

int main()
{
	Animal* p1 = new Animal();
	p1->run();
	delete p1;

	Animal* p2 = new Dog();
	p2->run();
	delete p2;

	Animal* p3 = new Cat();
	p3->run();
	delete p3;

	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
36
37
38
39
40
41
42
43
44
45
46

输出结果如下：

汇编代码如下：

4.override

函数的签名包括：函数名、参数列表、const属性。

C++11 增加了 override 关键字，保证子类重写的虚函数与父类的虚函数有相同的签名。也就是说，加了 override，明确表示子类的这个虚函数是重写父类的，如果子类与父类虚函数的签名不一致，编译器就会报错。

因此，为了减少程序运行时的错误，重写的虚函数都建议加上 override。

class Animal
{
public:
	virtual void run()
	{
		cout << "Animal::run()" << endl;
	}
};

class Dog : public Animal
{
public:
	virtual void run() override // 正确，若与父类虚函数的签名不一致，编译器就会报错
	{
		cout << "Dog::run()" << endl;
	}
};

class Cat : public Animal
{
public:
	virtual void run() override // 正确，若与父类虚函数的签名不一致，编译器就会报错
	{
		cout << "Cat::run()" << endl;
	}
};
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

5.final

C++11 增加了 final 关键字，阻止类的进一步派生和虚函数的进一步重写。

如果不希望某个类被继承或者不希望某个虚函数被重写，则可以在类名和虚函数后加上 final 关键字，加上 final 关键字后，若再被继承或重写，编译器就会报错。

class Animal
{
public:
	virtual void run() final
	{
		cout << "Animal::run()" << endl;
	}
};

class Dog : public Animal
{
public:
	virtual void run() override // 报错，一旦父类的虚函数被声明为final，则子类不能再重写它
	{
		cout << "Dog::run()" << endl;
	}
};

class Cat : public Animal
{
public:
	virtual void run() override // 报错，一旦父类的虚函数被声明为final，则子类不能再重写它
	{
		cout << "Cat::run()" << endl;
	}
};
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

6.多态

多态是面向对象非常重要的一个特性：

• 同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
• 在运行时，可以识别出真正的对象类型，调用对应子类中的函数。

默认情况下，编译器只会根据指针类型调用对应的函数，不存在多态。

随着虚函数的提出，面向对象编程中的“多态性”就浮出了水面。多态性体现在具有继承关系的父类和子类之间，父类把成员函数声明为虚函数，子类重写父类的成员函数，在程序运行时期，找到动态绑定到父类指针上的对象（可能是某个子类对象，也可能是父类对象），然后系统内部查一个虚函数表，找到函数的入口地址，从而通过父类指针调用父类或者子类的成员函数，这就是运行时期的多态性。

#include <iostream>
using namespace std;

class Animal
{
public:
	virtual void speak() { cout << "Animal::speak()" << endl; }
	virtual void run() { cout << "Animal::run()" << endl; }
};

class Dog : public Animal
{
public:
	void speak() { cout << "Dog::speak()" << endl; }
	void run() { cout << "Dog::run()" << endl; }
};

class Cat : public Animal
{
public:
	void speak() { cout << "Cat::speak()" << endl; }
	void run() { cout << "Cat::run()" << endl; }
};

class Pig : public Animal
{
public:
	void speak() { cout << "Pig::speak()" << endl; }
	void run() { cout << "Pig::run()" << endl; }
};

void fun(Animal* p)
{
	p->speak();
	p->run();
}

int main()
{
	fun(new Dog());
	fun(new Cat());
	fun(new Pig());

	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
36
37
38
39
40
41
42
43
44
45

输出结果如下：