【C++历险记】国庆专辑---探索多态迷宫的代码之旅！

---

🎉博客主页：.小智

🎉欢迎关注：👍点赞🙌收藏✍️留言

🎉系列专栏：C++终极篇

🎉代码仓库：小智的代码仓库

一、什么是多态？

多态多态顾名思义就是多种形态，比如我们要完成某一件事情，不同的对象去完成，我们产生的结果是不一样的。

举个栗子我们平时的买火车票，就有这几种分类：

• 成人票----全价
• 学生票----半价
• 军人----优先

再来举个栗子：支付宝年底经常会做诱人的扫红包-支付-给奖励金的活动。那么大家想想为什么有人扫的红包又大又新鲜8块、10块…，而有人扫的红包都是1毛，5毛…。其实这背后也是一个多态行为。支付宝首先会分析你的账户数据，比如你是新用户、比如你没有经常支付宝支付等等，那么你需要被鼓励使用支付宝，那么就你扫码金额 =random()%99；比如你经常使用支付宝支付或者支付宝账户中常年没钱，那么就不需要太鼓励你去使用支付宝，那么就你扫码金额 = random()%1；总结一下：同样是扫码动作，不同的用户扫得到的不一样的红包，这也是一种多态行为。
ps：支付宝红包问题纯属瞎编，大家仅供娱乐。

二、多态的定义及其实现

2.1多态构成的条件

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

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

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

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

void Func(Person& people)
{
	people.BuyTicket();
}

int main()
{

	Person P;
	Func(P);

	Student S;
	Func(S);

}
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

运行结果>

这里可以看到我们传递了不同的对象过去，就会调用不同的函数，得到不同的结果。
具体实现方法：

这里我们可以小小总结一下：

• 多态调用看的指向的对象
• 普通对象，看当前类型
• 多态不同的对象传递过去，调用不同的函数。

2.2虚函数

虚函数：即被virtual修饰的类成员函数称为虚函数。
【注意】：虚函数只能是成员函数！！！

2.3虚函数的重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的
返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

虚函数重写的一些细节：
重写的本来条件是虚函数+三同，但是有一些例外

1. 派生类的重写虚函数可以不加virtual – (建议大家加上)
2. 协变，返回的值可以不同，但要求返回值必须是父子关系指针和引用（不常用）

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; }//这里返回值类型是派生类指针
};
1
2
3
4
5
6
7
8
9
10
11

注意：返回值类型不能反着来（会报错）必须父是父，子是子！

2.3.1析构函数的重写

析构函数可以是虚函数吗？
答案是可以是虚函数，因为析构函数也是成员函数。

为什么要是虚函数呢？
接下来我们来聊聊为什么要将析构函数搞成虚函数，我们来看下面场景：

class Person {
public:
	~Person() 
	{
		cout << "~Person()" << endl; 
	}
};
class Student : public Person {
public:
	~Student() 
	{
		cout << "~Student()" << endl; 
		delete[] ptr;
	}
private:
	int* ptr = new int[10];
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这里我们不把析构函数写成虚函数，我们来new一个对象来测试一下：

int main()
{
	Person* P = new Person;//new一个person对象
	delete P;

	P = new Student;//delete之后再new一个student对象
	delete P;
}
1
2
3
4
5
6
7
8

但是我们却发现Person的析构被调用了两遍，反而没有去调用子类的析构函数，导致我们申请的是个空间没有被释放，就会造成内存泄漏。那么我们再把析构函数都写成虚函数再来试试：

改写成虚函数之后，就可以完成对申请的空间进行释放。
补充：类析构函数都被处理成destructor这个统一的名字，因为要让他们构成重写。

2.4C++11 override 和 final

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

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

这里就会强制报错：

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

假如我们把函数名写错了就会强制报错：

补充：如何设计一个不能被继承的类？

• 方法一C++98的实现方法
  将该类中的构造函数私有化，但是私有成员在外面是无法被访问的，子类继承之后也无法去调用父类的构造函数，但这也导致了我们定义一个对象，但是那个对象无法去调用他的构造函数，但是私有成员可以在类里面被访问，所以我们可以定义一个静态的成员函数去简洁的调用构造函数。
  
• 方法二C++11实现方法
  在定义类后面直接加上final关键字即表示这个类不能被继承。
  

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

2.6为什么不能是子类的指针或者引用呢？

因为基类中定义了虚函数，子类继承并重写了这些虚函数。如果使用子类的指针或者引用，就无法保证能够调用到基类中定义的虚函数，从而无法实现多态。因此，多态的条件必须是基类的指针或者引用。

2.7为什么不能是父类对象呢？

是因为父类对象无法调用子类中特有的成员函数或属性。多态需要通过基类指针或引用来调用虚函数，而父类对象只能访问父类中定义的成员函数和属性，无法访问子类中新增或重写的成员函数和属性。因此，多态的条件必须是基类的指针或引用，而不能是父类对象。

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(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

这里看到我们如果使用父类对象，调用结果永远都是父类的中的成员函数。


我们对比这两张图，我们可以得出结论：子类赋值给父类对象切片，不会拷贝虚表。
如果拷贝虚表，那么父类中的虚表是子类还是父类的就不确定了，就乱套了。

2.8子类中为什么要对付类的虚函数进行重写？

子类重写基类的虚函数的主要目的是实现特定于子类的行为。通过重写虚函数，子类可以提供自己的实现逻辑，覆盖基类中的默认行为。这样，当我们通过基类指针或引用调用虚函数时，实际执行的是子类的实现。
重写虚函数使得多态成为可能。当我们使用基类指针或引用来操作子类对象时，编译器会根据对象的实际类型来调用正确的虚函数实现。这种动态绑定的机制使得程序更加灵活和可扩展。
因此，子类重写基类的虚函数是为了实现多态性，并允许子类提供自己的行为逻辑。

三、多态的实现原理

3.1虚函数表

// 这里常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};
int main()
{
	Base b;
	cout << sizeof(b) << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

通过观察测试我们发现b对象是8bytes，除了_b成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。 一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

3.2派生类中的虚函数表

// 针对上面的代码我们做出以下改造
// 1.我们增加一个派生类Derive去继承Base
// 2.Derive中重写Func1
// 3.Base再增加一个虚函数Func2和一个普通函数Func3
class Base
{
public:
	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}
	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _b = 1;
};
class Derive : public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 2;
};
int main()
{
	Base b;
	Derive d;
	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

通过监视窗口，我们发现了以下几点问题：

1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。
2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。

总结一下派生类的虚表生成：

• 先将基类中的虚表内容拷贝一份到派生类虚表中
• 如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数
• 派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

同一个程序中，同一类型的对象公用同一个虚函数表。

这里还有一个童鞋们很容易混淆的问题：虚函数存在哪的？虚表存在哪的？
答：虚函数存在虚表，虚表存在对象中。注意上面的回答的错的。但是很多童鞋都是这样深以为然的。注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？实际我们去验证一下会发现vs下是存在代码段的 ，Linux g++下大家自己去验证!
vs2019下验证：

int main()
{
	Base b;
	Derive d;
 
	int a = 0;
	printf("栈：%p\n", &a);

	static int b1 = 0;
	printf("静态区：%p\n", &b1);

	int* p = new int;
	printf("堆：%p\n", p);

	const char* str = "hello world";
	printf("常量区：%p\n", str);

	printf("虚表1：%p\n", *((int*)&b));
	printf("虚表2：%p\n", *((int*)&d));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

这里打印出来的地址可以看到我们对应的两个虚表的地址和常量区相差很小，而和静态区相差很大，这样我们就可以推断出来虚表是存在常量区的，这么解释也是比较合理的，因为虚表也是不能被改变的。

3.3探索内存中的虚函数表

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

	virtual void Func1() 
	{
		cout << "Person::Func1()" << endl;
	}

	virtual void Func2() 
	{
		cout << "Person::Func2()" << endl;
	}

protected:
	int _a = 0;
};

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

	virtual void Func3()
	{
		//_b++;
		cout << "Student::Func3()" << endl;
	}
protected:
	int _b = 1;
};

int main()
{
	Person ps;
	Student 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
27
28
29
30
31
32
33
34
35
36
37

这里我们通过监视窗口发现虚函数表中没有派生类func3函数的地址，但是我们通过内存窗口发现0地址上面有四个地址，前三个都是虚函数表中的地址，那么最后一个地址是什么呢？怀疑是fun3的地址，我们来写程序验证一下：
写程序之前我们要了解虚函数表的本质是函数指针数组，那么我们就要定义一个函数指针数组，通过遍历这个数组来访问和调用虚函数表中的内容。

typedef void(*FUNC_PTR) ();//重定义一个函数指针数组

// 打印函数指针数组
void PrintVFT(FUNC_PTR* table)
{
	for (size_t i = 0; table[i] != nullptr; i++)
	{
		printf("[%d]:%p->", i, table[i]);
		
		FUNC_PTR f = table[i];
		f();//调用函数
	}
	printf("\n");
}

int main()
{
	Person ps;
	Student st;

	int vft1 = *((int*)&ps);
	PrintVFT((FUNC_PTR*)vft1);

	int vft2 = *((int*)&st);
	PrintVFT((FUNC_PTR*)vft2);

	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

可以看到我们虚函数表中最后一个地址确实是func3函数的地址，这样就说明了vs的监视窗口是由Bug的，所以我们平时不能够太依赖于监视窗口，而是要去内存中查找真相。
这里我们发现了一个问题，虚函数表中的函数都是成员函数，我们没有通过成员对象去访问，而是通过函数地址去调用函数，这种调用会有一些问题，函数形参this指针接收不到对象，如果这个函数中存在对成员变量的访问，我们这种通过函数指针去调用函数就会出现问题。

3.4多态实现的原理

上面分析了这个半天了那么多态的原理到底是什么？还记得这里Func函数传Person调用的Person::BuyTicket，传Student调用的是Student::BuyTicket

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 Mike;
 Func(Mike);
Student Johnson;
Func(Johnson);
 return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1. 观察上图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。
2. 观察上图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。
3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。

再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。

反观我们直接用对象去调用成员函数，他的汇编代码是这样的：

他是直接call Person::BuyTicket()完成函数调用。

3.5动态绑定与静态绑定

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

四、单继承和多继承关系的虚函数表

4.1多继承中的虚函数表

因为监视窗口有bug，所以我们通过打印虚函数表的方式来观察：

class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1;
};

class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2;
};

class Derive : public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
private:
	int d1;
};

typedef void(*FUNC_PTR) ();

// 打印函数指针数组
void PrintVFT(FUNC_PTR* table)
{
	for (size_t i = 0; table[i] != nullptr; i++)
	{
		printf("[%d]:%p->", i, table[i]);

		FUNC_PTR f = table[i];
		f();
	}
	printf("\n");
}
int main()
{
	Derive d;

	int vft1 = *((int*)&d);
	Base2* ptr = &d;
	int vft2 = *((int*)ptr);

	PrintVFT((FUNC_PTR*)vft1);
	PrintVFT((FUNC_PTR*)vft2);

	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
47
48
49
50
51

多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。

但是我们发现这两个虚函数地址不一样，但是都能访问到func1()
这里我们通过反汇编来解释这里的原因：

这里ptr1是直接去调用func1()函数的,而ptr2是进行了封装到，执行完jmp的时候对ecx的值进行修正（修正this的位置），因为func1()的函数地址在Base1的虚函数表中，所以当ptr2要去调用的时候就要将this指针修正到d对象的首地址，而ptr1不用修正this指针的原因是因为ptr1本身就在d对象的首地址，所以不用修正。

4.2菱形继承、菱形虚拟继承

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看了，一般我们也不需要研究清楚，因为实际中很少用。如果好奇心比较强的宝宝，可以去看下面的两篇链接文章。

1. C++ 虚函数表解析
2. C++ 对象的内存布局

4.2.1普通菱形继承

class A
{
public:
	virtual void func1()
	{
		cout << "A::func1()" << endl;
	}

	virtual void func2()
	{
		cout << "A::func2()" << endl;
	}

	int _a = 1;
};

class B : public A
{
public:
	virtual void func1()
	{
		cout << "B::func1()" << endl;
	}

	virtual void func3()
	{
		cout << "B::func3()" << endl;
	}

	int _b = 2;
};

class C : public A
{
public:
	virtual void func1()
	{
		cout << "C::func1()" << endl;
	}

	virtual void fun4()
	{
		cout << "C::func4()" << endl;
	}

	int _c = 3;
};

class D : public B, public C
{
public:
	virtual void func1()
	{
		cout << "D::func1()" << endl;
	}

	virtual void func3()
	{
		cout << "D::func3()" << endl;
	}

	virtual void fun5()
	{
		cout << "D::func5()" << endl;
	}

	int _d = 4;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

我们再来分别定义这个几个对象再来打印这几个对象的虚表：


普通菱形继承的虚表和多继承是没有什么区别的。

4.2.2菱型虚拟继承

class A
{
public:
	virtual void func1()
	{
		cout << "A::func1()" << endl;
	}

	virtual void func2()
	{
		cout << "A::func2()" << endl;
	}

	int _a = 1;
};

class B :virtual public A
{
public:
	virtual void func1()
	{
		cout << "B::func1()" << endl;
	}

	virtual void func3()
	{
		cout << "B::func3()" << endl;
	}

	int _b = 2;
};

class C :virtual public A
{
public:
	virtual void func1()
	{
		cout << "C::func1()" << endl;
	}

	virtual void fun4()
	{
		cout << "C::func4()" << endl;
	}

	int _c = 3;
};

class D : public B, public C
{
public:
	virtual void func1()
	{
		cout << "D::func1()" << endl;
	}

	virtual void func3()
	{
		cout << "D::func3()" << endl;
	}

	virtual void fun5()
	{
		cout << "D::func5()" << endl;
	}

	int _d = 4;
};
typedef void(*VFPTR) ();

void PrintVTable(VFPTR vTable[])
{
	cout << "虚表地址:" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf("vTable[%d]:0X%p--------->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}
int main()
{
	A a;
	cout << "A:";
	PrintVTable((VFPTR*)*(int*)&a);
	cout << "B:";

	B b;
	A* p3 = &b;
	PrintVTable((VFPTR*)*(int*)p3);

	PrintVTable((VFPTR*)*(int*)&b);
	cout << "C:";

	C c;
	p3 = &c;
	PrintVTable((VFPTR*)*(int*)p3);
	PrintVTable((VFPTR*)*(int*)&c);
	cout << "D:";

	D d;
	p3 = &d;
	PrintVTable((VFPTR*)*(int*)p3);

	B* p1 = &d;
	PrintVTable((VFPTR*)*(int*)p1);

	C* p2 = &d;
	PrintVTable((VFPTR*)*(int*)p2);

	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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

我们再来分别定义这个几个对象再来打印这几个对象的虚表：

在菱形虚拟继承中，由于派生类继承了两个共享同一公共基类的基类，因此会出现两份相同的虚函数表。为了避免这种情况，C++中使用了虚函数表指针（vptr）和虚基类指针（vbptr）的概念。
虚函数表指针是存储在对象中的一个指针，它指向该对象所属的类的虚函数表。而虚基类指针则是存储在派生类对象中的一个指针，它指向该派生类对象所共享的公共基类的子对象。
通过使用虚函数表指针和虚基类指针，C++可以在派生类对象中只保留一份公共基类的子对象，从而避免了菱形继承中出现多份相同的虚函数表的问题。

五、抽象类

5.1概念

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。**包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。**派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

//抽象类(接口)
class Car
{
public:
	virtual void Drive() const = 0;
};

class Benz : public Car
{
public:
	virtual void Drive() const
	{
		cout << "Benz-舒适" << endl;
	}
};

class Bmw : public Car
{
public:
	virtual void Drive() const
	{
		cout << "Bmw-操控" << endl;
	}
};

void Advantages(const Car& car)
{
	car.Drive();
}

int main()
{
	Benz be;
	Advantages(be);

	Bmw bm;
	Advantages(bm);
}
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

5.2接口继承和实现继承

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

六、问答环节

• inline 函数可以是虚函数嘛？
  答：可以，不过编译器会忽略 inline 属性，这个函数就不再是 inline，因为虚函数要放进虚函数表中。

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

• 构造函数可以是虚函数嘛？
  答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。

• 析构函数可以是虚函数嘛？什么场景下析构函数是虚函数？
  答：可以，并且最好把基类的析构函数定义成虚函数。集体场景参考 2.4.2 小节。

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

• 虚函数表是在什么阶段生成的？存在哪？
  答：虚函数表是在编译阶段就生成的，一般情况下存在代码段（常量区）。

• 什么是抽象类？抽象类的作用？
  答：什么是抽象类请参考 5.1 小节。抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。

七、常见面试题

以下程序输出结果是什么?

//下面这段代码的运行结果是什么？
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()
{
    B* p = new B;
    p->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

这段代码定义了两个类A和B，其中类B继承自类A。类A中定义了一个名为func的虚函数，该函数有一个默认参数val=1，同时类A中还定义了一个名为test的函数，该函数调用了func函数。类B中也定义了一个名为func的函数，该函数重写了类A中的func函数，并且它也有一个默认参数val=0。

在main函数中，我们创建了一个指向类B对象的指针p，然后调用了p的test函数。由于test函数是在类A中定义的，因此在调用test函数时会调用类A中的func函数。但是由于p指向的是类B对象，所以实际上调用的是类B中重写的func函数。此时，由于类B中的func函数有一个默认参数val=0，而test函数并没有传递参数给func函数，因此val参数取默认值1。最终输出的结果为B->1，其中1是val参数的默认值。

总结一句话就是：虚函数的重写本质上是重写了函数的实现。

🍀小结🍀

今天我们学习了"【C++历险记】国庆专辑---探索多态迷宫的代码之旅！"相信大家看完有一定的收获。种一棵树的最好时间是十年前，其次是现在！ 把握好当下，合理利用时间努力奋斗，相信大家一定会实现自己的目标！加油！创作不易，辛苦各位小伙伴们动动小手，三连一波💕💕~~~，本文中也有不足之处，欢迎各位随时私信点评指正！
本节课的代码已上传gitee仓库