【C++高阶】掌握C++多态：探索代码的动态之美

Eternity._

发布于 2024-06-18 09:15:55

2010

发布于 2024-06-18 09:15:55

前言： 在编程的广阔领域中，多态（Polymorphism） 无疑是一个令人着迷且至关重要的概念。它不仅是面向对象编程（OOP）的三大特性之一（与封装和继承并列），也是实现代码复用、提高软件灵活性和可扩展性的关键所在。当我们谈论C++这门强大的编程语言时，多态更是一个不可或缺的话题

C++作为一种支持多种编程范式的语言，不仅拥有过程式编程的严谨与高效，也具备面向对象编程的丰富与灵活。多态正是这种灵活性的集中体现。它允许我们以统一的方式处理不同类型的对象，无需关心其具体类型，只需知道它们都属于某个共同的基类或接口。这种“以不变应万变”的能力，使得C++程序员在面对复杂多变的业务需求时，能够保持代码的清晰、简洁和可维护性

本文将带领读者一起探索C++多态的奥秘。我们将从多态性的基本概念入手，逐步深入其实现原理，我们将通过丰富的示例代码和详细的解释说明，让我们一起踏上这段探索多态性的旅程吧！

📒1. 多态的定义及实现

🍁多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为

构成多态的两个条件：

必须通过基类的指针或者引用调用虚函数
被调用的虚函数必须构成派生类对基类的重写（覆盖）

多态代码示例

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 p;
	Student s;
	p.BuyTicket();
	s.BuyTicket();
	return 0;
}

🍂虚函数的重写

虚函数

概念：被virtual修饰的类成员函数称为虚函数

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

虚函数的重写(覆盖)

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

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

class Student : public Person 
{
public:
	// 返回值类型、函数名字、参数列表完全相同，构成虚函数的重写
	virtual void BuyTicket() 
	{ 
		cout << "买票-半价" << endl; 
	}
};

注意：

在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写,但是该种写法不是很规范，不建议使用

class Person 
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person 
{
public:
	// 基类不加virtual也构成虚函数重写，但是不规范
	void BuyTicket() { cout << "买票-半价" << endl; }
};

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

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

class Person {
public:
	// 析构函数的名称统一处理成destructor
	virtual ~Person() {cout << "~Person()" << endl;}
};
class Student : public Person {
public:
	// 无论是否加virtual关键字，都与基类的析构函数构成重写
	virtual ~Student() { cout << "~Student()" << endl; }
};

⛰️override 和 final

C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失

因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写

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

override：判断一个虚函数是否重写了基类虚函数，如果没有则报错

🌄重载、覆盖、隐藏

📕2. 抽象类

🎩抽象类概念

概念： 在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象

🎈接口继承和实现继承

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

📜3. 多态的原理

🌈虚函数表

在开始前先问大家一个简单的问题，下面这个类的大小是多少？在类和对象时，我们讲过类的大小判定和结构体差不多，那么在x86中，它的大小到底是不是4bytes?

// 这里常考一道笔试题：sizeof(Pxt)是多少？
class Pxt
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _p = 1;
};

是不是很奇怪为什么它的大小会是8bytes，那么让我们来一探究竟！

通过观察测试我们发现b对象是8bytes，除了_p成员，还多一个_vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)

一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表

🌞虚函数表的特征

基类和派生类不会共用一张虚函数表

同一个自定义类型的对象将会共用一张虚函数表

通过以上测试，我们发现含有虚函数的类中都至少都有一个虚函数表，虚函数的地址要被放到虚函数表中，那么是所有的虚函数的地址都要放进去嘛？我们再来测试以下

虚函数是否都放入虚函数表代码测试

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;
	}
	virtual void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _d = 2;
};
int main()
{
	Base b;
	Derive d;
	return 0;
}

结论：

派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员
基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表 中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法
另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函 数，所以不会放进虚表
虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr
总结一下派生类的虚表生成： 1. 先将基类中的虚表内容拷贝一份到派生类虚表中 2. 然后如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 3. 最后派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后
注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是 他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？实际我们去验证一下会发现vs下是存在代码段的

🌙验证虚函数表的存放位置

我们用代码来验证一下vs下虚函数表的存放位置

代码示例（验证时使用上面的类(Base)进行验证）

int main()
{
	Base b1;
	Derive d1;
	int a = 99;
	Base* b = new Base;
	static int c = 99;
	const char* p = "const char";
	printf("栈区地址：%p\n", &a);
	printf("堆区地址：%p\n", b);
	printf("静态区地址：%p\n", &c);
	printf("代码段地址：%p\n", p);
	printf("虚函数表地址：%p\n", *((int*)(&b1))); // 虚表地址比较接近代码段
	printf("虚函数地址：%p\n", &Base::Func1);
	return 0;
}

⭐多态的原理

多态实则是通过不同的虚表，找到不同的虚函数来调用，这样就实现出了不同对象去完成同一行为时，展现出不同的形态

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

📚4. 虚函数表

🧩单继承中的虚函数表

单继承中的虚函数表

class Base {
public :
	virtual void func1() { cout<<"Base::func1" <<endl;}
	virtual void func2() {cout<<"Base::func2" <<endl;}
private :
	int _a;
};
class Derive :public Base {
public :
	virtual void func1() {cout<<"Derive::func1" <<endl;}
	virtual void func3() {cout<<"Derive::func3" <<endl;}
	virtual void func4() {cout<<"Derive::func4" <<endl;}
private :
	int _b;
};

按照上面讲的，我们在d中的虚函数表应该有func3和func4，但是通过监视窗口并没有发现这两个函数，其实编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug，那么我们自己将虚表打印出来

💧打印虚函数表

打印虚函数表代码示例

// 打印虚表
typedef void (*VFUNC)();

void PrintVFT(VFUNC* a)
{
	// 因为虚函数表在vs下最后一个元素是 0，
	for (size_t i = 0; a[i] != 0; i++)
	{
		// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
		printf("[%d]: %p -> ", i, a[i]);
		VFUNC f = a[i];
		f();
	}
	printf("\n");
}

int main()
{
	Base b;
	Derive d;
	// 类似于打印虚表指针，只不过最后要强制转换成 VFUNC*
	PrintVFT((VFUNC*)(*((int*)&b)));
	PrintVFT((VFUNC*)(*((int*)&d)));

	return 0;
}

注意：有的时候可能会莫名其妙多出很多函数指针，这时我们只需要清理以下解决方案即可

🧩多继承中的虚函数表

多继承中的虚函数表

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 (*VFUNC)();
void PrintVFT(VFUNC* a)
{
	for (size_t i = 0; a[i] != 0; i++)
	{
		printf("[%d]: %p -> ", i, a[i]);
		VFUNC f = a[i];
		f();
	}
	printf("\n");
}
int main()
{
	Derive d;
	PrintVFT((VFUNC*)(*((int*)&d))); // 打印第一张虚函数表
	PrintVFT((VFUNC*)(*((int*)((char*)&d+sizeof(Base1))))); // 打印第二张虚函数表
	return 0;
}

我们要想打印第二张虚表就必须跳过第一张，我们来分析一下 ((char*)&d+sizeof(Base1))

🔥虚函数的调用

我们通过汇编来观察一下虚函数的调用

int main()
{
	Derive d;
	Base1* p1 = &d;
	p1->func1();
	Base2* p1 = &d;
	p2->func2();
	return 0;
}

p1->func1()

p2->func1()

我们发现p2相较于p1调用func1函数进行的步骤多了许多，但是最后发现它们所调用的函数地址相同，所以他们调用的是同一个函数！而进行这么多步骤是为了修正this指针

注意：

inline函数可以是虚函数，如果是普通调用，则inline起作用，如果是多态调用，inline不起作用
静态成员不可以是虚函数，因为静态成员函数没有this指针，无法访问虚函数表
构造函数不可以是虚函数，对象中的虚函数表指针是在构造函数阶段才初始化的，虚函数的多态调用要去虚函数表中找，但虚函数表指针还没初始化

📖5. 总结

经过对C++多态的深入学习，我们不难发现，多态性是面向对象编程中一个不可或缺的概念，它赋予了代码更高的灵活性和可扩展性。通过虚函数和继承机制，C++实现了运行时多态，让我们能够以统一的方式处理不同类型的对象，这无疑极大地提高了软件开发的效率和质量

在学习的过程中，我们或许会遇到一些挑战和疑惑，但正是这些挑战促使我们不断思考、不断探索。多态性的理解和运用需要我们对C++的类继承、虚函数等核心概念有深入的理解，同时也需要我们在实践中不断积累经验

然而，学习多态性并不仅仅是为了掌握一个编程技巧，更重要的是它培养了我们的编程思维和解决问题的能力。通过多态，我们可以更加灵活地设计软件架构，实现代码复用，提高软件的可维护性和可扩展性。而我们不要满足于对多态性的初步了解，而是要继续深入探索，不断实践。只有在实践中，我们才能真正理解和掌握多态性的精髓，才能将其运用到实际项目中，发挥出其最大的价值

让我们一起在学习的道路上不断前行，探索C++多态的无限可能