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

C++多态（下）

news 来源：原创 2025/5/5 7:03:25

一、单继承、多继承及菱形虚拟继承中的虚函数表解析

1. 虚函数表基础认知

2. 单继承中的虚函数表

3. 多继承中的虚函数表

4. 菱形虚拟继承中的虚函数表

二、继承与多态常见面试题

1. 选择题

2. 问答题

一、单继承、多继承及菱形虚拟继承中的虚函数表解析

1. 虚函数表基础认知

虚函数表（vtable）是C++实现运行时多态的核心机制，每个包含虚函数的类都会生成一个虚函数指针数组。对象内存布局的第一个位置存储指向这个数组的指针（vptr），通过这个指针可以找到所有虚函数的实际地址。

2. 单继承中的虚函数表

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() override { cout << "Derive::func1" << endl; }// 新增虚函数virtual void func3() { cout << "Derive::func3" << endl; }virtual void func4() { cout << "Derive::func4" << endl; }
private:int b;  // 占位成员变量
};

派生类对象的虚表结构是在基类虚表基础上进行扩展的。基类 Base 的虚表包含 func1 和 func2 两个虚函数的地址。当派生类 Derive 覆盖了 func1 并新增 func3 和 func4 时，派生类对象的虚表在基类虚表的基础上，替换了 func1 的地址为派生类自己的实现，并添加了 func3 和 func4 的地址。

观察上图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。那么我们如何查看d的虚表呢？有以下两种方法：

1、使用内存监视窗口

使用内存监视窗口能够直接观察到派生类对象的虚表内容，这是一种非常直观且真实的方式。通过在内存监视窗口中输入派生类对象的虚表指针地址，我们可以清晰地看到虚表中存储的各个虚函数的地址。

2、内存探查法

虚函数表本质上是一个存储虚函数指针的指针数组。每个包含虚函数的类对象都有一个指向虚函数表的指针（虚表指针），位于对象内存布局的最前面。通过取对象头 4 字节（对于 32 位系统而言）的值，可以获取虚表指针的值，从而访问虚函数表。

void PrintVTable(VFPTR vTable[]) 
{cout << "虚表地址: " << vTable << endl;for (int i = 0; vTable[i] != nullptr; ++i) {printf("索引%d → 地址:0X%p → 执行结果:", i, vTable[i]);vTable[i]();  // 通过函数指针调用虚函数}
}int main() 
{Base b;VFPTR* vTable = (VFPTR*)(*(int*)&b);PrintVTable(vTable);Derive d;// 关键内存操作步骤：// 1. 取对象地址 → 2. 强转为int* → 3. 解引用得vptr → 4. 转为虚表指针vTable = (VFPTR*)(*(int*)&d);PrintVTable(vTable);return 0;
}

3. 多继承中的虚函数表

在多继承中，派生类对象会包含多个基类子对象。每个基类子对象都有自己独立的虚函数表。对于未被派生类重写的虚函数，它们会被放在第一个继承基类部分的虚函数表中。

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:// 重写两个基类的func1virtual void func1() override { cout << "Derive::func1" << endl; }// 新增虚函数virtual void func3() { cout << "Derive::func3" << endl; }
private:int d1;
};

例如，在上述代码中，派生类 Derive 有两个基类 Base1 和 Base2。Derive 自己重写了 func1，并新增了 func3。对于 Base1 的 func2 和 Base2 的 func1、func2 这些未被重写的虚函数，它们会分别放置在对应的基类子对象的虚函数表中。其中，Base1 的 func2 位于 Base1 子对象的虚函数表中，而 Base2 的 func1、func2 位于 Base2 子对象的虚函数表中。

观察上图中的监视窗口中我们发现还是看不见func3，和上面的单继承一样，也有2种解决方法。

1、使用内存监视窗口

2、内存探查法

typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{std::cout << " 虚表地址>" << vTable << std::endl;for (int i = 0; vTable[i] != nullptr; ++i){printf(" 第%d个虚函数地址 :0X%x,->", i+1, vTable[i]);VFPTR f = vTable[i];f(); // 调用虚函数，可看出具体是哪个函数}std::cout << std::endl;
}int main()
{Derive d;// 第一个基类虚表VFPTR* vTableb1 = (VFPTR*)(*(int*)&d); // Base1 子对象的虚表指针在派生类对象最前面PrintVTable(vTableb1); // 第二个基类虚表访问方式：// 1. 将对象地址转为char*进行字节级运算// 2. 偏移Base1的大小得到Base2子对象起始位置VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1))); // Base2 子对象的虚表指针在 Base1 子对象之后PrintVTable(vTableb2); 
}

4. 菱形虚拟继承中的虚函数表

class A {
public:virtual void funcA() { cout << "A::funcA" << endl; }
private:int _a;
};class B : virtual public A {  // 虚拟继承
public:virtual void funcA() override { cout << "B::funcA" << endl; }virtual void funcB() { cout << "B::funcB" << endl; }
private:int _b;
};class C : virtual public A {
public:virtual void funcA() override { cout << "C::funcA" << endl; }virtual void funcC() { cout << "C::funcC" << endl; }
private:int _c;
};class D : public B, public C {
public:virtual void funcA() override { cout << "D::funcA" << endl; }virtual void funcD() { cout << "D::funcD" << endl; }
private:int _d;
};

各类型内存布局对比：

类类型	典型内存组成
A	vptr → A虚表 + _a
B	vptr → B虚表 + vbptr + _b + (A成员)
C	vptr → C虚表 + vbptr + _c + (A成员)
D	B部分 + C部分 + _d + A部分

A 类对象 ：包含一个虚表指针（指向存储 A 类虚函数 funcA 地址的虚表）和成员变量 _a。

B 类对象 ：由于是虚拟继承 A 类，A 类继承下来的成员被放到最后。B 类对象有虚表指针（指向存储 B 类虚函数 funcB 地址的虚表）、虚基表指针（虚基表中存储两个偏移量，第一个是虚基表指针距离 B 虚表指针的偏移量，第二个是虚基表指针距离虚基类 A 的偏移量）和成员变量 _b。

C 类对象 ：与 B 类对象类似，也是虚拟继承 A 类，最后放置 A 类继承下来的成员。C 类对象包含虚表指针（指向存储 C 类虚函数 funcC 地址的虚表）、虚基表指针（虚基表中存储两个偏移量，第一个是虚基表指针距离 C 虚表指针的偏移量，第二个是虚基表指针距离虚基类 A 的偏移量）和成员变量 _c。

D 类对象 ：D 类对象较为复杂。A 类继承下来的成员被放到最后。D 类对象包含从 B 类继承的成员、从 C 类继承的成员和成员变量 _d。D 类对象中虚函数 funcD 的地址存储到了 B 类的虚表当中。

虚拟继承主要是为了解决多继承中的重复继承问题，确保所有继承自同一基类的派生类共享该基类的一个实例。在虚拟继承中，虚基类相关内容在派生类对象中的位置比较特殊，通常被放置在最后，同时会引入虚基表来记录相关偏移量信息，以便正确访问虚基类的成员。

菱形虚拟继承结构下，各个类的虚函数表相互关联又各自独立。B 类和 C 类分别有自己的虚函数表，存储各自新增的虚函数（funcB 和 funcC）。而 D 类在继承 B 和 C 的基础上，覆盖了 funcA 并新增了 funcD。D 类对象的结构使得访问各个虚函数时，需要根据不同的路径找到对应的虚表，进而调用正确的虚函数。

实际开发中不建议设计菱形继承及菱形虚拟继承。一方面，其结构复杂，容易导致代码难以理解和维护，开发人员稍有不慎就可能引发各种继承冲突和访问错误等问题。另一方面，这种模型在访问基类成员时有一定的性能损耗，因为需要通过虚基表等额外的信息来确定正确的访问路径，增加了程序的运行开销。

二、继承与多态常见面试题

1. 选择题

1. 下面哪种面向对象的方法可以让你变得富有( )

A: 继承 B: 封装 C: 多态 D: 抽象

答案：A

解析：继承允许子类复用父类的代码，提高开发效率，题目中的“变得富有”是一个隐喻，强调代码复用带来的效率提升。

2. ( )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，而对方法的调用则可以关联于具体的对象。

A: 继承 B: 模板 C: 对象的自身引用 D: 动态绑定

答案：D

解析：动态绑定（多态）在运行时根据对象类型确定调用的方法，方法定义与对象解耦。

3. 面向对象设计中的继承和组合，下面说法错误的是？（）

A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复用，也称为白盒复用
B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动态复用，也称为黑盒复用
C：优先使用继承，而不是组合，是面向对象设计的第二原则
D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封装性的表现

答案：C

解析：面向对象设计原则提倡“组合优于继承”，继承会破坏封装性，组合更灵活。

4. 以下关于纯虚函数的说法,正确的是( )

A：声明纯虚函数的类不能实例化对象 B：声明纯虚函数的类是虚基类
C：子类必须实现基类的纯虚函数 D：纯虚函数必须是空函数

答案：A

解析：
A 选项：正确，含有纯虚函数的类是抽象类，不能实例化对象。
B 选项：错误，声明纯虚函数的类不一定是虚基类，虚基类是为解决多继承中重复继承问题而引入的概念，与纯虚函数无必然关联。
C 选项：错误，子类不一定必须实现基类的纯虚函数，若子类未实现该纯虚函数，则子类也是抽象类，不能实例化对象。
D 选项：错误，纯虚函数可以不是空函数，可有函数体，只是需在派生类中重写实现。

5. 关于虚函数的描述正确的是( )

A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型 B：内联函数不能是虚函数
C：派生类必须重新定义基类的虚函数 D：虚函数可以是一个static型的函数

答案：B

解析：
A 选项：错误，派生类的虚函数与基类虚函数参数个数和类型应一致，否则不是覆盖重写，而是隐藏基类函数。
B 选项：正确，内联函数在编译时展开，而虚函数需动态绑定，调用时查虚表，编译无法确定具体调用哪个函数实现，所以内联函数不能是虚函数。
C 选项：错误，派生类不是必须重新定义基类虚函数，若不重写，则调用基类虚函数实现。
D 选项：错误，虚函数不能是 static 型函数，static 成员函数属类而非对象，无 this 指针，无法通过对象调用，而虚函数需依托对象动态绑定调用。

6. 关于虚表说法正确的是（）

A：一个类只能有一张虚表
B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表
C：虚表是在运行期间动态生成的
D：一个类的不同对象共享该类的虚表

答案：D

解析：
A 选项：错误，一个类可有多个虚表，若类中存在多个继承关系中的虚函数，每个基类的虚函数可能对应不同虚表。
B 选项：错误，基类虚函数被子类重写时，子类会有自己的虚表，不会与基类共用同一张虚表。
C 选项：错误，虚表在编译期间就生成，非运行时动态生成。
D 选项：正确，一个类的不同对象共享该类的虚表，因为虚表是类的特性，而非单个对象所独有。

7. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（）

A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址
B：A类对象和B类对象前4个字节存储的都是虚基表的地址
C：A类对象和B类对象前4个字节存储的虚表地址相同
D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表

答案：D

解析：A 类和 B 类虚表中虚函数个数相同（都包含被重写的那个虚函数），但由于 B 类重写了 A 类的虚函数，所以 A 类和 B 类使用不同虚表，B 类虚表中的对应虚函数指向自身重写后的实现，故不是同一张虚表。

8. 下面程序输出结果是什么? （）

#include<iostream>
using namespace std;class A
{
public:A(char *s) { cout<<s<<endl; }~A(){}
};class B:virtual public A 
{
public:B(char *s1,char*s2):A(s1) { cout<<s2<<endl; }
};class C:virtual public A 
{
public:C(char *s1,char*s2):A(s1) { cout<<s2<<endl; }
};class D:public B,public C {
public:D(char *s1,char *s2,char *s3,char *s4):B(s1,s2),C(s1,s3),A(s1) { cout<<s4<<endl;}
};int main() 
{D *p=new D("class A","class B","class C","class D");delete p;return 0;
}

A：class A class B class C class D
B：class D class B class C class A
C：class D class C class B class A
D：class A class C class B class D

答案：A

解析：

程序执行过程如下：

创建 D 类对象，执行构造函数时，因 D 继承自 B 和 C，而 B、C 又虚继承自 A，所以首先初始化虚基类 A，输出 "class A"；
接着按照继承顺序，先构造 B 部分，输出 "class B"；
再构造 C 部分，输出 "class C"；
最后执行 D 自身构造函数，输出 "class D"。

所以输出顺序是 "class A class B class C class D"，对应选项 A。

9. 多继承中指针偏移问题？下面说法正确的是( )

class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };int main()
{Derive d;Base1* p1 = &d;Base2* p2 = &d;Derive* p3 = &d;return 0;
}

A：p1 == p2 == p3
B：p1 < p2 < p3
C：p1 == p3 != p2
D：p1 != p2 != p3

答案：C

解析：

在多继承中，对象的内存布局通常是按继承顺序排列基类部分，再是派生类自身成员。对于 Derive 类对象 d：

p1 指向 Base1 部分，即对象起始地址。

p2 指向 Base2 部分，位于 Base1 部分之后，所以 p2 的地址大于 p1。

p3 是 Derive 类型指针，指向整个对象，其值与 p1 相同（因 Base1 在对象最前面），所以 p1 == p3 != p2。

10. 以下程序输出结果是什么（）

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;
}

A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

答案：B

解析：

A 类中的 func() 函数是虚函数，且在 B 类中重写了 func() 函数，但 B 类中 func() 函数的参数默认值被改为 0。
当通过 B 类对象的指针调用 test() 函数时，test() 是 A 类中的函数，在 test() 函数体内调用 func()，此时会发生动态绑定，调用 B 类中重写后的 func() 函数。
但由于在 B 类中 func() 函数的参数默认值是 0，而调用时未给参数，所以输出 "B->0"。但仔细看题目代码：当在 B 类中重写 func() 函数时，参数列表中的默认参数值会覆盖基类中的默认值。所以在 test() 函数中调用 func()，即无参数调用，此时会使用 B 类中 func() 函数的默认参数值 0，所以输出 "B->0"，对应选项 B。

2. 问答题

1. 什么是多态？

同一操作作用于不同对象时，表现出不同的行为。C++ 中通过虚函数实现运行时多态。

2. 什么是重载、重写(覆盖)、重定义(隐藏)？

重载：同一作用域，同名函数参数不同。

重写（覆盖）：派生类重写基类虚函数，函数签名（函数名、参数列表、返回值类型（除 const 修饰外））相同。

重定义（隐藏）：派生类定义与基类同名函数（参数可不同），隐藏基类函数。

3. 多态的实现原理？

多态的实现原理主要依托虚函数表（vtable）和虚表指针（vptr）。当类中声明虚函数时，编译器为该类生成一个虚函数表，表中存放虚函数的地址。每个类对象包含一个指向虚函数表的指针（vptr）。当通过基类指针或引用来调用虚函数时，运行时会根据对象的实际类型，通过 vptr 找到对应的虚函数表，进而调用正确的函数实现，实现动态绑定。

4. inline函数可以是虚函数吗？