当前位置：首页 > news >正文

C++进阶-多态2

news 2025/7/14 8:41:31

1.预备知识

2.纯虚函数和抽象类

3.多态的原理

3.1虚函数表指针

3.2多态的原理

3.2.1多态是如何实现的

3.2.2动态绑定与静态绑定

3.2.3虚函数表

4.重载/重写/隐藏的对比

5.总结

1.预备知识

该讲的多态内容需要以下知识的铺垫，见我写的博客：

C++进阶-多态1-CSDN博客文章浏览阅读638次，点赞16次，收藏10次。多态是⼀个继承关系的下的类对象，去调⽤同⼀函数，产⽣了不同的⾏为。//运行时多态public:virtual void BuyTicket() { cout << "买票-全价" << endl;public:// 重写virtual void BuyTicket() { cout << "买票-打折" << endl;Student st;Func(ps);Func(st);return 0;https://blog.csdn.net/2401_86446710/article/details/149276311?spm=1011.2415.3001.10575&sharefrom=mp_manage_link

2.纯虚函数和抽象类

在虚函数的后⾯写上 =0 ，则这个函数为纯虚函数，包含纯虚函数的类叫做抽象类，比如：

#include<iostream>
using namespace std;
class Car
{virtual void Drive() = 0;
};

其中的Car就是抽象类，Drive就是纯虚函数。

可能有些人有点疑惑，为什么这个纯虚函数没有{}即没有定义？

因为纯虚函数不需要定义实现，主要是实现没啥意义因为要被派⽣类重写。当然你可以实现一下，比如：

//纯虚函数
class Car
{
public:virtual void Drive() = 0{ _a = 0;}
private:int _a;
};

一般情况下，这个纯虚函数直接写成第一种形式就可以，那种形式称为纯虚函数的声明，建议在日常的情况下就只要写声明即可。

抽象类无法实例化出对象，比如这样是有问题的：

Car c;

那么在编译器上会报错：

如果派生类继承后不重写纯虚函数，那么派生类也是抽象类，比如：

//纯虚函数
class Car
{virtual void Drive() = 0;
};
class Subway :public Car
{
private:int _a = 0;
};
int main()
{Subway s;return 0;
}

那么这样仍然会有问题：

如果我们把代码改成这样：

class Car
{virtual void Drive() = 0;
};
class Subway :public Car
{
public:virtual void Drive() { }
private:int _a = 0;
};
int main()
{Subway s;return 0;
}

那么最后是不会有问题的。

纯虚函数某种程度上强制了派⽣类重写虚函数，因为不重写实例化不出对象。

那这个纯虚函数有什么用处呢？

除了上面这个强制派生类重写虚函数外，我们如果在实现各种职业的类的时候，如果直接写的话，必须用到继承才行，因为各种职业都具有人的特征，所以我们可以把人这个类置为抽象类，如：

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:virtual void work() = 0;
protected:string _name;int _age;string telephone;
};
class Doctor :public Person
{
public:virtual void work(){cout << "Doctor" << " :" << "医生" << endl;}
private:string place;
};
class Teacher :public Person
{
public:virtual void work(){cout << "Teacher" << " :" << "老师" << endl;}
private:string study;
};

这样我们之后可以用来实现多态就简单很多了，所以我们可以用纯虚函数来满足我们日常的需求。

3.多态的原理

3.1虚函数表指针

下⾯编译为32位程序的运⾏结果是什么（）
A. 编译报错 B. 运⾏报错 C. 8 D. 12

class Base
{
public:virtual void Func1(){cout << "Func1()" << endl;}
protected:int _b = 1;char _ch = 'x';
};
int main()
{Base b;cout << sizeof(b) << endl;return 0;
}

一个类的大小如果在开始学习C++的情况下就是成员变量的大小，但是计算类的大小的时候需要考虑内存对齐，具体内容可能需要自己去搜索资料了解一下内存对齐规则，这里我简单讲解一下：对齐数是默认对齐数与该成员变量所占的内存大小取小值，_b的对齐数就是4，_ch的对齐数就是1，但是总共是5是不够的（要是最大对齐数的整数倍），所以要补三个字节，最终该类的大小为8。

但我们运行该代码的结果为：

注：在VS下x86就是32位。

这里涉及到多态的规则：一个类里面如果有一个虚函数，就要多存储一个类的指针，在32位系统下指针的大小是4个字节，所以最终还是要加4的。这个指针叫虚表指针，全称：虚函数表指针。

故这个是4（指针）+4（int）+1（char）+3（补全）。

如果是64位系统下就是16了，因为指针是占了8个字节的，我们验证一下：

我们可以通过调试发现：

这个_vfptr就是虚函数表指针，这个其实本质上就是vft，v表示virtual，f表示function即函数，t表示table即表，这个_vfptr指向一张表即虚函数表，_vfptr实际上就是存储虚函数指针的数组，我们把代码改成这样：

class Base
{
public:virtual void Func1(){cout << "Func1()" << endl;}virtual void Func2(){cout << "Func1()" << endl;}virtual void Func3(){cout << "Func1()" << endl;}
protected:int _b = 1;char _ch = 'x';
};
int main()
{Base b;cout << sizeof(b) << endl;return 0;
}

那么调试就有：

存储多个虚函数，但是这个_vfptr的大小是不会变化的，如果我们在32位系统下运行这个代码会有：

为什么呢？

因为_vfptr本质上就是一个指针，这个指针指向虚函数表，而这个虚函数表本质是虚函数指针数组。只有虚函数才会被放进去，这个需要自己去验证，这里就不做过多讲解了。

相当于这样的存储结构：

3.2多态的原理

3.2.1多态是如何实现的

首先看一下以下代码：

//多态的原理
class Person 
{
public:virtual void BuyTicket() { cout << "买票-全价" << endl; }
private:string _name;
};class Student : public Person 
{
public:virtual void BuyTicket() { cout << "买票-打折" << endl; }
private:string _id;
};class Soldier : public Person 
{
public:virtual void BuyTicket() { cout << "买票-优先" << endl; }
private:string _codename;
};void Func(Person& ptr)
{ptr.BuyTicket();
}int main()
{Person ps;Student st;Soldier sr;Func(ps);Func(st);Func(sr);return 0;
}

这个Func满足多态，所以运行结果为：

我们调试发现：

我们观察发现，这三个虚表实际上是不同的，实际上如果没完成重写：

class Person 
{
public:virtual void BuyTicket() { cout << "买票-全价" << endl; }
private:string _name;
};class Student : public Person 
{
public://virtual void BuyTicket() { cout << "买票-打折" << endl; }
private:string _id;
};class Soldier : public Person 
{
public://virtual void BuyTicket() { cout << "买票-优先" << endl; }
private:string _codename;
};void Func(Person& ptr)
{ptr.BuyTicket();
}int main()
{Person ps;Student st;Soldier sr;Func(ps);Func(st);Func(sr);return 0;
}

那么我们经过调试有：

我们发现每个子类的虚表的_vfptr都是存放的和父类一样的虚表指针。

这里我们可以得出一个结论：若子类完成重写，则子类的_vfptr会被覆盖成子类自己的虚函数指针，这个时候虚表的虚函数则会被覆盖成重写的虚函数。

实际上，编译器在编译的时候检查是否满足多态，如果不满足多态，那么直接调用（父类）对应的函数；如果满足多态，则调用该函数的时候是只看到父类对象的，我们之前在继承里面讲过：子类是由父类的成员和子类独有的成员构成的，所以这个时候如果构成多态，那么由于函数参数是父类的指针或引用，看到的是父类的对象，不知道是父类还是哪个子类。当我们运行时，这个就确定了，编译器会根据传递来的对象找到对应的虚函数的地址，传递给这个函数（以上的代码这个函数指的是：Func函数），然后再根据函数的地址进行调用对应的虚函数。

我们写多态的时候，那个满足多态的函数要用父类的指针或引用就是因为我们不知道以后传递的参数到底是父类对象还是子类对象，因为传递过来的父类对象可能是子类切割或切片而来的，所以要等到运行时才能确定传递的到底是哪个类的对象，才能正确的进行调用。这就是所谓的运行时多态。

以上内容不需要完全看懂，但是要大概了解这个过程，理解为什么实现多态的函数要用基类的指针或引用来作为参数以及调用该函数时的行为是什么就可以了！

3.2.2动态绑定与静态绑定

对不满⾜多态条件(指针或者引⽤+调⽤虚函数)的函数调⽤是在编译时绑定，也就是编译时确定调⽤函数的地址，叫做静态绑定。这个情况适用于普通的（成员）函数。

满⾜多态条件的函数调⽤是在运⾏时绑定，也就是在运⾏时到指向对象的虚函数表中找到调⽤函数
的地址，也就做动态绑定。我们主要理解这个函数调用时传递的参数是可以为基类也可以为派生类的对象即可，理解起来不是很麻烦。

这两个概念只要了解一下即可。

3.2.3虚函数表

这些概念看一下就基本上知道了，以下概念只要看会就没问题了，我也不做过多讲解了：

（1）基类对象的虚函数表中存放基类所有虚函数的地址。同类型的对象共⽤同⼀张虚表，不同类型的对象各⾃有独⽴的虚表，所以基类和派⽣类有各⾃独⽴的虚表。

（2）派⽣类由两部分构成，继承下来的基类和⾃⼰的成员，⼀般情况下，继承下来的基类中有虚函数表指针，⾃⼰就不会再⽣成虚函数表指针。但是要注意的这⾥继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同⼀个，就像基类对象的成员和派⽣类对象中的基类对象成员也独⽴的。

（3）派⽣类中重写的基类的虚函数，派⽣类的虚函数表中对应的虚函数就会被覆盖成派⽣类重写的虚函数地址。

（4）派⽣类的虚函数表中包含，一、基类的虚函数地址，二、派⽣类重写的虚函数地址完成覆盖，派⽣类⾃⼰的虚函数地址三个部分。

（5）虚函数表本质是⼀个存虚函数指针的指针数组，⼀般情况这个数组最后⾯放了⼀个0x00000000标记。(这个C++并没有进⾏规定，各个编译器⾃⾏定义的，vs系列编译器会再后⾯放个0x00000000标记，g++系列编译不会放)

（6）虚函数存在哪的？虚函数和普通函数⼀样的，编译好后是⼀段指令，都是存在代码段的，只是虚函数的地址⼜存到了虚表中。

（7）虚函数表存在哪的？这个问题严格说并没有标准答案C++标准并没有规定，我们写下⾯的代码可以对⽐验证⼀下。vs下是存在代码段(常量区)

#include<iostream>
using namespace std;
//虚函数表
class Base 
{
public:virtual void func1() { cout << "Base::func1" << endl; }virtual void func2() { cout << "Base::func2" << endl; }void func5() { cout << "Base::func5" << endl; }
protected:int a = 1;
};
class Derive : public Base
{
public:// 重写基类的func1virtual void func1() { cout << "Derive::func1" << endl; }virtual void func3() { cout << "Derive::func1" << endl; }void func4() { cout << "Derive::func4" << endl; }
protected:int b = 2;
};
int main()
{int i = 0;static int j = 1;int* p1 = new int;const char* p2 = "xxxxxxxx";printf("栈:%p\n", &i);printf("静态区:%p\n", &j);printf("堆:%p\n", p1);printf("常量区:%p\n", p2);Base b;Derive d;Base* p3 = &b;Derive* p4 = &d;printf("Person虚表地址:%p\n", *(int*)p3);printf("Student虚表地址:%p\n", *(int*)p4);printf("虚函数地址:%p\n", &Base::func1);printf("普通函数地址:%p\n", &Base::func5);return 0;
}

则运行结果为：