多态原理、虚表指针与虚基表的内存布局。

于 2022-11-28 14:43:48 发布
阅读量1k 收藏 7
点赞数 6
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45029051/article/details/128058916
版权

文章目录

前言

继承和多态是OOP三大特性其中两个重要特性，多态又是在继承的基础上实现的，二者糅合在一起使用语法比较复杂，本文将讲述一些基本使用语法，多态的原理、虚函数表的内存布局和菱形虚继承等。

多态

多态是指 调用一个函数，根据不同的类型展现出不同的形态称为多态。多态又分为静态的多态和动态的多态： 1、静态多态：重载、模板，在编译时确定调用哪个； 2、动态多态：用基类的引用或者指针调用虚函数，在运行时确定调用哪个。

虚函数

        如果一个类的非静态成员函数用virtual修饰，则该函数为虚函数，其子类如果有一个返回值、参数列表相同的同名函数即使不用virtual修饰也是是虚函数。

class B{
public:
	virtual void fun(){...};
}
class D:public B{
public:
	void fun(){...}; //也是虚函数
}

静态类型与动态类型

        静态类型是指成员在编译时就已经确定要调用的代码了，动态类型要在运行时根据调用类型才能知道。
        只有通过基类的指针或者引用调用虚函数才能调用动态类型，其他情况调用的都是静态类型。
        如下列代码，基类指针p指向子类，并且调用的是虚函数，切子类对虚函数进行了覆盖，所以调用的是子类覆盖后的虚函数B::func()，因此输出B::func:。


class A
{
public:
    virtual void func() { std::cout <<"A::func : "<< endl; }
};
class B : public A
{
public:
    virtual void func()  { std::cout << "B::func: " << endl; }
};
int main(int argc, char* argv[])
{
    A* p = new B;
    p->func();
    return 0;
}

重载、覆盖和隐藏的区别

①重载：在同一作用域内相同函数名的函数根据参数个数、类型的不同形成重载；
②覆盖：在父类和子类作用域中，如果子类的一个虚函数的函数名、参数类型、返回值与父类的虚函数一模一样则构成覆盖；
        注意有以下两个例外也构成覆盖：

  1. 如果基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用；
  2. 如果基类的析构函数为虚函数，子类的虚函数无论是否加virtual关键字，都与基类的析构函数构成重写 。 这是因为析构函数在编译时被编译器同一处理最后都被命名为destructor();

③隐藏：在父类和子类之间两个同名函数如果不构成覆盖，就是隐藏。

final和override

final：如果一个类不希望被继承可以在定义后面；如果一个虚函数不想再被覆盖可以在声明后面加final。
在这里插入图片描述

override：父类和子类之间两个同名函数如果不构成覆盖，就是构成隐藏。如果我们想在子类中覆盖父类的虚函数，但是不小心搞成隐藏了，那么在程序运行过程中很可能会造成实际与预期不符，但是很难通过调试发现这个bug。于是可以用override来检查子类中的函数是否与父类的函数构成覆盖，如果不构成则编译报错。

虚函数的默认实参

        如果某次函数调用使用了默认参数，则默认参数的值由该次调用的静态类型决定。
        例如：通过基类指针调用函数，则使用基类中定义的默认参数，即使该基类指针指向的是子类对象。

        如下列代码：基类A的指针p指向子类，调用func时调用的是子类B重写的func，但是根据上面的原则使用的是基类默认参数的实参，因此输出B::func： 1

class A
{
public:
    virtual void func(int c=1) { std::cout <<"A::func : " << c << endl; }
};
class B : public A
{
public:
    virtual void func(int c = 20)  { std::cout << "B::func: "  << c << endl;  }
};
int main(int argc, char* argv[])
{
    A* p = new B;
    p->func();
    return 0;
}

虚析构函数

建议把基类的析构函数都定义为虚函数。
考虑下面代码中的情况：基类指针p指向子类，进行delete时只运行了基类A的析构；如果子类B中有资源需要释放那么这种情况会造成资源泄漏。而如果把基类的析构函数定义为虚函数就能正确释放子类中的资源。

class A 
{
public:
    virtual void func(int c=1) final{ std::cout <<"A::func : " << c << endl; }
    ~A()
    {
        cout << "~A()" << endl;
    }
    /*virtual ~A()  如果定义为虚析构函数那么main函数中的代码先执行子类的析构、再执行父类的析构。
    {
        cout << "~A()" << endl;
    }*/
};
class B : public A
{
public:
    ~B()
    {
        cout << "~B()" << endl;
    }
};
int main(int argc, char* argv[])
{
    A* p = new B;
    delete p;
    return 0;
}

在构造函数和析构函数中调用虚函数

        子类对象在构造时先构造基类部分，再构造子类部分；在析构时先析构子类部分再析构基类部分。子类对象在构造基类部分时，此时子类对象部分处于未被初始化的状态。当子类对象析构基类部分时，此时子类对象部分处于已析构状态。
        如果在基类部分进行构造或者析构时调用子类的成员很可能会造成程序崩溃。
        所以在构造函数和析构函数中调用的虚函数时，需要把该调用看成是该构造函数或者析构函数类型的对象调在调用虚函数。

多态原理

一个类中声明虚函数之后，每个实例化的对象的首个成员是一个指针（称为虚表指针），这个指针指向虚函数表。子类覆盖了父类的虚函数后，虚函数表中对应的地址也会被更改。因此当用父类的指针或者引用调用虚函数时，根据虚表指针找到对应的虚函数地址，再进行调用，因此实现了多态。

各种形式继承的虚函数内存布局

各种情况我都用VS2022的内存布局来看的。要注意不同的编译器可能略有差异，但是大体布局应该是一致的。我会以一段代码，一张基类、子类对象内存布局、一段说明的方式来解析内存布局。

单一继承无覆盖
class Base {
public:
    int ib=0;
    int cb=1;
    virtual void f() { cout << "Base::f" << endl; }
    virtual void B() { cout << "Base::f" << endl; }
};

class B1:public  Base{
public:
    int ib2 = 2;
    int cb2 = 3;
    virtual void f1() { cout << "B1::f" << endl; }
    virtual void Bf1() { cout << "Base::f" << endl; }
};

在这里插入图片描述
可以看到基类和子类的虚函数地址都放在同一张表中，并且在没有覆盖的情况下，基类的虚函数地址在前，子类的在后，类内的虚函数地址按照声明顺序排列。

单一继承有覆盖
class Base {
public:
    int ib=0;
    int cb=1;
    virtual void f() { cout << "Base::f" << endl; }
    virtual void Bf() { cout << "Base::Bf" << endl; }
};

class B1:public  Base{
public:
    int ib2 = 2;
    int cb2 = 3;
    virtual void f() { cout << "B1::f" << endl; }
    virtual void f1() { cout << "B1::f1" << endl; }
    virtual void Bf1() { cout << "B1::Bf1" << endl; }
};

在这里插入图片描述
可以看到子类覆盖的虚函数f的地址替换了基类虚函数f的地址，并且之后f的地址不再重复出现，其他的布局没有改变。

单一虚拟继承有覆盖
class Base {
public:
    int ib=0;
    int cb=1;

    virtual void f() { cout << "Base::f" << endl; }
    virtual void Bf() { cout << "Base::Bf" << endl; }
};
class B1:public virtual Base{
public:
    int ib2 = 2;
    int cb2 = 3;
    virtual void f() { cout << "B1::f" << endl; }
    virtual void f1() { cout << "B1::f1" << endl; }
    virtual void Bf1() { cout << "B1::Bf1" << endl; }
};

在这里插入图片描述

继承后有两张虚函数表：一个是子类的虚函数表、一个是虚基类的虚函数表。子类如果覆盖了父类的虚函数则在父类的虚表中修改对应的地址，并且不再出现在子类的虚表中。
对象的首个成员是子类的虚函数指针，然后是虚基表指针。
虚基表指针中存放：1、虚基表指针与子类对象首地址的偏移量；2、虚基表指针到虚基类部分的偏移量。

多继承无覆盖
class Base1 {
public:
    int ib=0;
    int cb=1;
    virtual void f() { cout << "Base::f" << endl; }
    virtual void Bf() { cout << "Base::Bf" << endl; }
};
class Base2{
public:
    int ib2 = 2;
    int cb2 = 3;
    virtual void f() { cout << "B1::f" << endl; }
    virtual void Bf() { cout << "B1::Bf1" << endl; }
};
class Derive :public  Base1 ,public Base2 {
public:
    int ib2 = 10;
    int cb2 = 11;
    virtual void f2() { cout << "Base::f" << endl; }
    virtual void Bf2() { cout << "Base::f" << endl; }
};

在这里插入图片描述
继承下来的基类如果都有虚函数，那么子类对象对应的基类部分都有一张虚函数表。如果子类自己定义了新的虚函数那么这些虚函数总是放在第一张虚表中。

多继承有覆盖
class Base1 {
public:
    int ib=0;
    int cb=1;
    virtual void f() { cout << "Base1::f" << endl; }
    virtual void Bf1() { cout << "Base1::Bf1" << endl; }
    virtual void B1() { cout << "Base1::B1" << endl; }
};

class Base2{
public:
    int ib2 = 2;
    int cb2 = 3;
    virtual void f() { cout << "Base2::f" << endl; }
    virtual void Bf2() { cout << "Base2::Bf2" << endl; }
    virtual void B2() { cout << "Base2::B2" << endl; }
};

class Derive :public  Base1 ,public Base2 {
public:
    int ib2 = 10;
    int cb2 = 11;
    virtual void f() { cout << "Derive::f" << endl; }
    virtual void Bf1() { cout << "Derive::Bf1" << endl; }
    virtual void Bf2() { cout << "Derive::Bf2" << endl; }
    virtual void Df() { cout << "Derive::Df" << endl; }
};

在这里插入图片描述
虚表的存放方式还是符合上述原则。至于为何子类对象的基类Base1和Base2虚函数表f的地址不同我也不是很清楚，无论是用Base1还是Base2的指针绑定到子类对象上调用f都是一样的，输出Derive::f，所以它们应该填一样的值。

菱形继承有覆盖
class Base {
public:
    int ib=0;
    int cb=1;
    virtual void f() { cout << "Base::f" << endl; }
    virtual void B() { cout << "Base::Bf" << endl; }
};
class B1: public Base{
public:
    int ib2 = 10;
    int cb2 = 11;
    virtual void f() { cout << "B1::f" << endl; }
    virtual void f1() { cout << "B1::Bf1" << endl; }
    virtual void Bf1() { cout << "Base::Bf" << endl; }
};

class B2 : public Base {
public:
    int ib2 = 16;
    int cb2 = 17;
    virtual void f() { cout << "B1::f" << endl; }
    virtual void f2() { cout << "B1::Bf1" << endl; }
    virtual void Bf2() { cout << "Base::Bf" << endl; }
};

class Derive :public  B1 ,public B2 {
public:
    int ib2 = 10;
    int cb2 = 11;
    virtual void f() { cout << "Base::f" << endl; }
    virtual void f1() { cout << "Base::f" << endl; }
    virtual void f2() { cout << "Base::f" << endl; }
    virtual void Df() { cout << "Base::f" << endl; }
};

在这里插入图片描述

菱形虚继承有覆盖
class Base {
public:
    int ib=0;
    int cb=1;
    virtual void f() { cout << "Base::f" << endl; }
    virtual void B() { cout << "Base::Bf" << endl; }
};
class B1:virtual public Base{
public:
    int ib2 = 10;
    int cb2 = 11;
    virtual void f() { cout << "B1::f" << endl; }
    virtual void f1() { cout << "B1::Bf1" << endl; }
    virtual void Bf1() { cout << "Base::Bf" << endl; }
};

class B2:virtual public Base {
public:
    int ib2 = 16;
    int cb2 = 17;
    virtual void f() { cout << "B1::f" << endl; }
    virtual void f2() { cout << "B1::Bf1" << endl; }
    virtual void Bf2() { cout << "Base::Bf" << endl; }
};

class Derive :public  B1 ,public B2 {
public:
    int ib2 = 10;
    int cb2 = 11;
    virtual void f() { cout << "Base::f" << endl; }
    virtual void f1() { cout << "Base::f" << endl; }
    virtual void f2() { cout << "Base::f" << endl; }
    virtual void Df() { cout << "Base::f" << endl; }
};

在这里插入图片描述
最后总结一下：

  1. 如果有虚继承那么虚基类的虚函数总是单独放在后面。
  2. 如果一个类声明了virtual继承，那么该类对象的第一个成员是虚表指针，第二个成员是虚基表指针。
  3. 子类自己定义的虚函数总是放在第一张虚表中。
  4. 子类如果覆盖了父类的虚函数，那么子类对象的基类部分对应的虚表中的地址会被修改。

END

justdoitzws
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
多态中的指针
小时候挺菜的博客
11-20 1373
一、父类指针指向子类对象 首先，来看一段代码： //用父类指针指向子类对象 class A { public: A() { printf("A \n"); } ~A() { printf(" ~A \n"); } // 这里不管写不写virtual，删除B对象的时候，都会被执行。因为这个例子是B*指针指向B对象，不是A*指针指向B对象。 }; class B : public A { pu...
虚继承与虚基类的内存布局
shixiazuike的专栏
07-02 300
1. 多重继承的内存布局 struct A { int a; }; struct B:public A { int b; }; struct C:public A { int c; } struct D { int d; }多重继承的情况， 如果父类有共同的祖父类，则祖父类对象被拷贝了多次。在该例中，B的内存布局为（假设从上往下为地址增加方向） int A::a int
含有虚基类的类的内存布局.vsdx
11-04
博客《Cpp 对象模型探索 —— 含有虚基类的类的内存布局》的图片原文档，网址：https://blog.csdn.net/itworld123/article/details/102890062。
C++ 虚基类表指针字节对齐模型
chengonghao的博客
06-15 3317
关于虚基类表指针/虚函数表指针这些类里面的“隐藏成员”在结构里面是如何进行字节对齐的这个问题困惑了我48个小时。虽然网上也有很多关于虚继承、虚函数表、虚基类等内存布局的一些文章，但是基本上谈的都是大致的布局，什么地方有什么，按照什么顺序来排放等这些泛泛而谈的东西，好像都没有把字节对齐方面考虑进去的文章，或许他们都没有考虑到一些复杂层次的类继承关系，从而字节对齐的问题也没有成为问题，也自然而然地会被
C++ 多继承和虚继承的内存布局
weixin_34344403的博客
03-03 358
来源：http://www.oschina.net/translate/cpp-virtual-inheritance 来源：http://www.cnblogs.com/BeyondAnyTime/archive/2012/06/05/2537451.html C++中的虚拟继承的一些总结 1.为什么要引入虚拟继承 虚拟继承是多重继承中特有的...
c++ 虚函数多态、纯虚函数、虚函数表指针、虚基类表指针详解
暖心~的博客
05-24 3879
静态多态和动态多态–虚函数、纯虚函数 静态多态：程序在编译阶段就可以确定调用哪个函数。这种情况叫做静态多态。比如重载 动态多态：在运行期间才可以确定最终调用的函数。需要通过虚函数+封装+继承实现。 虚函数 1、虚函数都必须有定义 2、虚函数一般用在继承中。多个子类继承同一基类，若在某种行为上不同的派生类有着自己的实现方式。这种情况我们就会用到多态。采用在基类中将此函数定义成虚函数，派生类...
【C++】虚函数与虚拟继承的内存布局规则
bale的博客
08-03 1090
在很多面试或口试题中经常涉及到类，而这其中又不得不说类的继承，虚继承，虚函数等问题，所以涉及到了类的内存布局，其中关于虚拟继承（virtual public）这个话题比较难以懂得，而且不同的编译器环境可能实现的类的内存布局不同，所以本文仅在vs2013编译环境下调试，如果你在像gcc这样的编译器中调试结果会不同(gcc中会把虚基指针和虚函数指针合并)。 首先我们要区分虚函数和虚拟继承： 虚拟继承和...
图解剖析C++多态与内存模型
Xiaoqing的博客
03-30 839
导引 看完了Lippman《深度探索C++对象模型》这本书以后，对于多态和虚函数的理解还是比较模糊，直到查阅了不少资料与博文以后，才有恍然大悟的感觉。 在对C++多态进行总结之前，推荐几篇优秀的经典博文： 陈皓的 C++ 对象的内存布局 这篇虽然代码有些小瑕疵，但是瑕不掩瑜 C++ 之 多态 这篇博文代码对理解虚函数表很有帮助。可以拿来自己测试。 C++对象的内存布局以及虚函数表和虚基表 这篇总...
C++多态（上）——虚函数、虚表
丁香枝上，豆蔻梢头
04-18 1223
OOP的核心思想是多态性（polymorphism）。其含义是“多种形态”。我们把具有继承关系的多个类型称为多态类型。引用或指针的静态类型和动态类型不同这一事实正是C++语言支持多态性的根本所在。 多态性：当用于面向对象编程的范畴时，多态性的含义是指程序能通过引用或指针的动态类型来获取类型特定行为的能力。 多态性在C++中是通过虚函数来实现的。首先我们先来强调几组概念： 静态多态和动态多态、静
C++多态（五）---菱形继承中的虚函数表详解
董皓宇
12-28 3216
C++多态 菱形继承 虚基表指针与虚基表 我们知道，在虚继承（菱形继承）中，对于类D创建的对象d，为了避免A类中的变量重复，所以，将A类中成员变量放在d对象模型的最下面，由B类与C类各自虚基表指针访问虚基表中偏移量的方式进行访问A类成员变量。 虚函数表指针与虚函数表（虚表） 在类中成员函数实现多态时，需要将成员函数定义为虚函数，所以，在多态的情景下，单继承下会存在一个虚函数表指针，指向成员函数...
C++ 内存布局虚继承 ---Empty virtual base classs (空虚基类)
12-16
C++ 内存布局虚继承 ---Empty virtual base classs (空虚基类).doc
虚继承 虚基类的子类内存布局
Y~哈哈哈的博客
03-30 516
1、普通多继承的内存布局 class A { public: int dataA; }; class B : public A { public: int dataB; }; class C : public A { public: int dataC; }; class D : public B, public C { public: int dataD; }; B类的内存...
虚表的内存布局（c++）
陈嘉怡的专栏
04-13 2760
点击这里查看下篇＞＞＞ 前言  转自：http://blog.csdn.net/haoel/article/details/3081328 07年12月，我写了一篇《C++虚函数表解析》的文章，引起了大家的兴趣。有很多朋友对我的文章留了言，有鼓励我的，有批评我的，还有很多问问题的。我在这里一并对大家的留言表示感谢。这也是我为什么再写一篇续言的原因。因为，在上一篇文章中，我用了的示例都是非
Cpp 对象模型探索 / 含有虚基类的类的内存布局
布袋和尚
11-04 211
一、栗子 class Grand { public: int i_grand_ = 8; }; class Parent1 : public virtual Grand { public: int i_parent1_ = 9; }; class Parent2 : public virtual Grand { public: int i_parent2_ = 10; }; cla...
浅谈C++中虚基类的内存布局
skiing_886的专栏
09-26 1667
今天重温C++的知识，当看到虚基类这点的时候，那时候也没有太过追究，就是知道虚基类是消除了类继承之间的二义性问题而已，可是很是好奇，它是怎么消除的，内存布局是怎么分配的呢？于是就深入研究了一下，具体的原理如下所示：来至于网络：http://www.cdtarena.com       在C++中，obj是一个类的对象，p是指向obj的指针，该类里面有个数据成员mem，请问obj.mem和p->
深入多态—虚表指针
dove1202ly的博客
10-17 325
上一篇就多态做了简单的介绍，但还是对多态的运行很迷，那我们就来虚函数内部是怎么操作的？（一）单继承中的虚函数（无虚拟继承）#include<iostream> using namespace std; class A { public: virtual void Funtest1() { cout<<"A::Funtest1()"<<endl; } v
C++基础——虚指针（vptr）与虚基表（vtable）
qq_25065595的博客
07-16 3939
vptr与vtable 手动操作vptr 来访问vtable中的虚函数，如以下测试程序： #include <iostream> #include <memory> using namespace std; typedef void (*func)(void); class Base { public: virtual void f() { cout << "Base::f" << endl; } virtual void g() { cout
虚函数、虚表、多态
sony303的专栏
05-31 695
1. 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。2. 存在虚函数的类都有一个一维的虚函数表叫做虚表。类的对象有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。3. 多态性是一个接口多种实现，是面向对象的核心。分为类的多态性和函数的多态性。4. 多态用虚函数来实现，结合动态绑定。5. 纯虚函数是虚函数再加上= 0。6. 抽象类是指包括至少一个纯虚函数的
C++虚基类，在（钻石）继承下的派生类对象的内存布局
iMatt的专栏
11-03 340
C++语言标准，对于虚继承的实现并未做出要求，这依赖于具体编译器的实现。大部分编译器的实现如下： class A{}; class B : virtual public A{}; class C: virtual public A{}; class D: public classB,public classC{}; class E: public class D{}; int main() { E object; return 0; } 这段代码中E对象object的内存布局如下：
深入理解C++多态与虚函数表
"C++ 多态 虚表 分析 图解 .doc" 在C++编程语言中，多态性是面向对象编程的核心概念之一，它允许程序员使用一个父类类型的指针或引用来调用实际是子类对象的成员函数。这使得代码更加灵活，能够处理多种类型的对象...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值