【C++】多态深入分析

青春：一叶知秋

已于 2024-03-02 21:45:57 修改

阅读量1.1k

点赞数 24

文章标签： c++ 开发语言

于 2024-02-27 21:34:39 首次发布

本文链接：https://blog.csdn.net/m0_74246469/article/details/136300539

版权

一，多态的原理

1，虚函数表与虚函数表指针

虚函数表：存放虚函数指针的表，简称虚表。虚函数表指针：指向虚函数表的指针。

一个含有虚函数的类中，至少都有一个虚函数表指针__vfptr，因为虚函数的地址要被放到虚函数表中，而虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。注意：类似于友元函数、静态函数不能为虚函数，因为它们都不属于类，即都不是类的成员函数，无法放到虚函数表中。

派生类的虚表生成一共有以下步骤：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后（注意：在vs监视窗口下可能在虚表中看不到新增的虚函数，但是通过内存窗口下可以观察到）。

#include <iostream>
using namespace std;
class Base
{
public:
   virtual void Fun1() { //虚函数，地址存放到虚表中
       cout << "Base::Fun1()" << endl;
   }
   virtual void Fun2() { //虚函数，地址存放到虚表中
       cout << "Base::Fun2()" << endl;
   }
   void Fun3() { //不是虚函数，地址没有存放到虚表中
       cout << "Base::Fun3()" << endl;
   }
private:
   int _a = 1;
   char _ch = 'a';
};
class Derive : public Base
{
public:
   virtual void Func1() { //虚函数，与子类后成重写，将子类的Func1覆盖
       cout << "Derive::Func1()" << endl;
   }
private:
   int _d = 2;
};
int main()
{
   Base bb;
   Derive dd;
   return 0;
}

原理图如下：

我们通过以上知识来计算下基类与派生类的存储大小。观察以下代码：

#include <iostream>
using namespace std;
class Base
{
public:
   virtual void Fun1() {
       cout << "Base::Fun1()" << endl;
   }
   virtual void Fun2() {
       cout << "Base::Fun2()" << endl;
   }
   void Fun3() {
       cout << "Base::Fun3()" << endl;
   }
private:
   int _a = 1;
   char _ch = 'a';
};
class Derive : public Base
{
public:
   virtual void Func1()
   {
       cout << "Derive::Func1()" << endl;
   }
private:
   int _d = 2;
};
int main()
{
   //因为有了虚函数，所以这里多了虚函数表指针。虚表指针也存储在类中
   cout << sizeof(Base) << endl; //输出12

   cout << sizeof(Derive) << endl; //输出16
   return 0;
}

这里说明一下，虚表指针存放的位置与平台有关，有些平台可能会放到对象的最后面，有些平台可能会放到对象的最前面。这里的测试是放在对象的前面且是32位机器，也就是说虚表指针占用4字节空间，然后这里再根据空间对齐规则，计算出总空间大小。

下面，我们研究下虚表存放的区域（注意：这里研究的不是虚表指针存放的区域，即研究虚表指针指向的地址，不是虚表指针本身的地址，这里不要搞错）。这里可以使用对比法来观察。具体做法是先输出各大区域的代表地址，然后输出虚表地址(即虚表指针)，通过对比观察与哪个区域代表地址相差最小的就是存储在哪块区域，因为各大区域的地址相差非常大。我们先创造以下类

class Base
{
public:
   virtual void Fun1() {
       cout << "Base::Fun1()" << endl;
   }
   virtual void Fun2() {
       cout << "Base::Fun2()" << endl;
   }
   void Fun3() {
       cout << "Base::Fun3()" << endl;
   }
private:
   int _a = 1;
   char _ch = 'a';
};

内部结构图如下：

#include <iostream>
using namespace std;
class Base
{
public:
   virtual void Fun1() {
       cout << "Base::Fun1()" << endl;
   }
   virtual void Fun2() {
       cout << "Base::Fun2()" << endl;
   }
   void Fun3() {
       cout << "Base::Fun3()" << endl;
   }
private:
   int _a = 1;
   char _ch = 'a';
};
int main()
{
   Base bb;
   //创造熟为认知的四大区域的代表
   int a = 0;
   int* b = new int;
   static int c = 1;
   const char* d = "a";
   fprintf(stdout, "栈区: %p\n", &a);
   fprintf(stdout, "堆区: %p\n", b);
   fprintf(stdout, "静态区(数据段): %p\n", &c);
   fprintf(stdout, "常量区(代码段): %p\n", d);
   //因为在32位下，内存中一个地址占用四个字节，所以这里解引用需解出bb对象开头的前四字节内容。这里可转换成int*，一次性可解引用出4个字节
   Base* pb = &bb;
   fprintf(stdout, "虚表存放区域: %p\n", *(int*)pb); //地址与常量区代表地址最相近，即虚表存放在常量区中
   return 0;
}

2，原理调用

虚函数的重写在某种意义上来讲也叫做覆盖。我们通常所说的重写是语法层上的概念，而覆盖是原理层上的概念，这也就是父类虚函数覆盖子类虚函数。

这里要说明一下，虚表是在编译的时候就已经生成，但虚表指针是在构造函数中初始化，通常在初始化列表的最开始阶段。若平台将虚表指针放在最后面也不排除在初始化列表的最后才初始化。但一般情况下平台都将虚表指针放在最前面，这里可通过监视窗口可观察到。

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

多态调用的本质是在运行时去虚函数表中找函数的地址进行调用，因此调用前必须先确定虚表以及虚表指针，虚表指针又是在构造函数阶段才生成，多态调用的机制也是在构造函数之后才生效，也就是说多态的调用是在构造函数之后才调用，所以指向父类调用的是父类的虚函数，指向子类调用的是子类的虚函数。普通调用的本质是系统直接通过调用者类型确定函数地址，也就是在某一具体空间作用域中去查找。对于多态调用而言，即便实例化出多个对象，它们的虚表指针以及存放的虚函数地址都是一样的，如下：

测试一：

#include <iostream>
using namespace std;
class A
{
public:
virtual void func(int val = 1)
{ std::cout << "A->" << val << std::endl; }
virtual void test()
{ func(); }
A()
{
func();
}
};

class B : public A
{
public:
B()
{
func();
}
virtual void func(int val = 0)
{ std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
A* p = new B;
p->test();
//以次输出A->1 B->0 B->1
return 0;
}

首先，当new B时先调用父类A的构造函数执行func时，由于此时还处于对象构造阶段，多态机制还没有生效，所以，此时执行的func函数为父类的func函数，输出A->1。构造完父类后执行子类构造函数，又要调用func，同理执行子类的func，输出B->0。当构造函数结束后再次调用，多态机制生成，后面就正常调用。

测试二：

#include <iostream>
using namespace std;
class A
{
public:
A()
: m_iVal(0) {
test();
}
virtual void func() {
std::cout << m_iVal << " ";
}
void test() {
func();
}
public:
int m_iVal;
};
class B : public A
{
public:
B() {
test();
}
virtual void func()
{
++m_iVal;
std::cout << m_iVal << " ";
}
};
int main()
{
//以下输出0 0 1
A a;
B b; //当调用完A的构造后，A中的基表就确定了。
//子类B的虚表是拷贝父类的虚表内容，也就是说子类调用完构造函数之后多态机制就已经生成
return 0;
}

测试三：

#include <iostream>
using namespace std;
class Base
{
public:
   virtual void Fun1() {
       cout << "Base::Fun1()" << endl;
   }
   virtual void Fun2() {
       cout << "Base::Fun2()" << endl;
   }
   void Fun3() {
       cout << "Base::Fun3()" << endl;
   }
private:
   int _a = 1;
   char _ch = 'a';
};
class Derive : public Base
{
public:
   virtual void Func1()
   {
       cout << "Derive::Func1()" << endl;
   }
private:
   int _d = 2;
};
int main()
{
   Base bb1;
   Base bb2;
   Base bb3;

   Derive dd1;
   Derive dd2;
   Derive dd3;
   return 0;
}

内部结构图：

3，动态绑定与静态绑定

1，静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载

2，动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型并确定程序的具体行为，调用具体的函数，也称为动态多态。

以上两个概念只需了解即可。

二，抽象类

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

#include <iostream>
using namespace std;
class Car //抽象类
{
public:
   virtual void Drive() = 0 { //纯虚函数
       cout << "Car" << endl;
   };
};
class Benz : public Car
{
public:
   virtual void Drive() //重写抽象类的纯虚函数，可以被实例化
   {
       cout << "Benz" << endl;
   }
};
class BMW : public Car
{   };
int main()
{
   //重写纯虚函数，实例化成功
   Benz a;
   a.Drive();
   //没有重写纯虚函数，实例化报错
   BMW b;
   return 0;
}

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

三，单继承和多继承关系的虚函数表

1，单继承中的虚函数表

之前说过，在vs监视窗口下可能在虚表中看不到新增的虚函数，这里我们实践下，如下：

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

观察上图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是它的一个小bug。那么我们如何查看d的虚表呢？下面我们使用代码打印出虚表中的函数。

#include <iostream>
using namespace std;
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;
};
typedef void(*VFPTR) (); //声明函数指针VFPTR
void PrintVTable(VFPTR vTable[]) {
   for (int i = 0; vTable[i] != nullptr; ++i) { //vs下的虚表最后一个存储单元为nullptr
       cout << "vTable[" << i << "]: " << vTable[i] << endl;
   }
   cout << endl;
}
int main()
{
   Base b;
   Derive d;
   VFPTR* vTableb = (VFPTR*)(*(int*)&b); //用函数二级指针来表示函数指针数组
   PrintVTable(vTableb);
   VFPTR* vTabled = (VFPTR*)(*(int*)&d); //与上同理
   PrintVTable(vTabled);
   return 0;
}

这里需说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再编译就好了。

2，多继承中的虚函数表

在多继承中，要谨记派生类的虚表内容是将基类中的虚表内容拷贝一份到派生类虚表中。从这里不难发现，在多继承中，派生类不止有一个虚表，即继承多少个类就有多少个虚表。当派生类的虚函数往虚表中添加地址时，会往第一个继承基类虚表中添加。当派生类对象/指针/引用赋值给基类时，这里会将基类以及包含基类虚表的那一部分一并切割。

#include <iostream>
using namespace std;
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(*VFPTR)();
void PrintVTable(VFPTR vTable[])
{
   cout << " 虚表地址>" << vTable << endl;
   for (int i = 0; vTable[i] != nullptr; ++i) {
       printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
       VFPTR f = vTable[i];
       f(); //函数指针的调用，调用类中的虚函数
   }
   cout << endl;
}
int main()
{
   Derive d;
   cout << sizeof(Derive) << endl; //输出20，因为继承了两个父类，有两个虚表

   //这里的p1和p2的值不一样，因为这里要发生切片，将父类包含特有的子类切出来
   Base1* p1 = &d; //切出Base1
   Base2* p2 = &d; //切出Base2

   VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
   PrintVTable(vTableb1);
   //这里要先跳转到包含Base2的虚表上，然后找到虚表指针
   VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
   PrintVTable(vTableb2);
   return 0;
}

观察下面结构图可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。

3，菱形继承、菱形虚拟继承

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面使用这样的模型访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承的虚表我们可不做研究，一般我们也不需要研究清楚，因为实际中很少用。我们只需知道，菱形继承往多继承方向理解，菱形虚拟继承就很复杂了，这里有很多问题，不必深思。

四，继承和多态常见的经典题型

继承与多态这方面有许多坑，由于内部结构多变，通常可设计出一些逻辑上的运算。这里我们来一一观察这方面的典型问题和经典面试问题。

1，概念逻辑考察

1. 下面哪种面向对象的方法可以让你变得富有( A )
A: 继承 B : 封装 C : 多态 D : 抽象

2. ( D )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，
而对方法的调用则可以关联于具体的对象。
A : 继承 B : 模板 C : 对象的自身引用 D : 动态绑定

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

4. 以下关于纯虚函数的说法, 正确的是( A )
A：声明纯虚函数的类不能实例化对象 B：声明纯虚函数的类是虚基类
C：子类必须实现基类的纯虚函数 D：纯虚函数必须是空函数

5. 关于虚函数的描述正确的是( B )
A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型 B：内联函数不能是虚函数
C：派生类必须重新定义基类的虚函数 D：虚函数可以是一个static型的函数

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

7. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（ D ）
        A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址
        B：A类对象和B类对象前4个字节存储的都是虚基表的地址
        C：A类对象和B类对象前4个字节存储的虚表地址相同
        D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表

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

#include <iostream>
using namespace std;
class A {
public:
   A(const char* s) { cout << s << endl; }
   ~A() {}
};
class B :virtual public A
{
public:
   B(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
};
class C :virtual public A
{
public:
   C(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
};
class D :public B, public C
{
public:
   D(const char* s1, const char* s2, const char* s3, const 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，所以当开始调用D的构造函数时，会首先调用A的析构函数，在B、C中不会调用A的构造函数。

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

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

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

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

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(int argc, char* argv[])
{
   B* p = new B;
   p->test();
   return 0;
}

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

2，问答题

1. 什么是多态？答：多态分为静态多态和动态多态，静态多态是编译器在编译时就能确定函数调用的是哪个实现，如：函数重载，而动态多态则是在运行时才能确定，如：派生类重写虚函数时的调用。

2. 什么是重载、重写(覆盖)、重定义(隐藏)？答：参考以上图片内容

3. 多态的实现原理？答：多态的实现原理主要依赖于虚函数表和虚函数表指针，通过虚函数表指针找到虚函数，在运行时进行动态绑定，以具体确定调用哪个函数。

4. inline函数可以是虚函数吗？答：可以，不过编译器就忽略inline属性，这个函数就不再是
inline，因为inline修饰后，若编译器看成内联函数，那么此函数是没有地址的，无法存入虚表中，而虚函数是要放到虚表中去。

5. 静态成员可以是虚函数吗？答：不能，因为类中存储的数据一切调用都需通过this指针，包括虚函数表。静态成员函数没有this指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。

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

7. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？答：可以，并且最好把基类的析
构函数定义成虚函数。因为这里可能存在内存泄漏问题。当使用基类指针指向派生类地址空间时，由于切割，指针指向的是派生类中基类的地址，所以这里结束时默认调用基类析构函数，不会调用派生类析构函数，这将会导致派生类中部分空间没有释放，导致内存泄漏问题。因此，这里需使用虚函数，使其调用派生类的析构函数。

8. 对象访问普通函数快还是虚函数更快？答：首先如果是普通调用，是一样快的。如果是多态调用，则普通函数快，因为多态调用构成多态，运行时调用虚函数需要到虚函数表中去查找指定地址才能调用，而普通函数直接调用。

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

10. C++菱形继承的问题？虚继承的原理？答：菱形继承有二义性和数据冗余的问题。在继承前加上关键字virtual的继承是虚继承。虚继承是一种解决多重继承中菱形继承问题的方法（注意这里不要把虚函数表和虚基表搞混了。）

11. 什么是抽象类？抽象类的作用？答：包含纯虚函数（即在虚函数的后面写上 =0 ）的类叫做抽象类。作用：抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。