2025年C++类对象的内存结构

C++类对象的内存结构本文全文转载于 https blog csdn net fenxinzi557 article details 1 无虚函数继承 2 有一个虚函数继承 3 全部虚函数都继承 4 多重继承

大家好,我是讯享网,很高兴认识大家。

    本文全文转载于:https://blog.csdn.net/fenxinzi557/article/details/

(1) 无虚函数继承

(2)有一个虚函数继承 

(3)全部虚函数都继承 

(4)多重继承 

(6)菱形继承

(7)单一虚继承

(8)菱形虚继承 (最重要)

 结论: 


    在VS中查看类对象的内存布局的方法:右击源文件——>属性——>C/C++——>命令行——>输入:

/d1 reportSingleClassLayoutXXX(其中XXX为类名)

讯享网

1、C++类的存储 

    C++中最重要的就是类,那么一个类的对象,它在内存中如何存储的?它占内存中多少个字节? 首先确定类的构成。数据成员:可以是内置类型,类类型。 函数成员:虚函数,非虚函数 。

(1)数据成员 

(2)函数成员 

    函数成员是不占用内存中类的对象的字节。为什么呢,你可以这样理解,c++中为了兼容c也允许struct 作为类的声明。在c 中struct 是用来声明结构体类型的,只不过c 中的结构体没有函数成员。 同样 c++中允许的函数成员,只不过是类给函数提供了一个作用域。 一个对象调用函数的时候,可以等价为普通函数的调用 。例如:

讯享网class A {     cout<<"Hello"; }; A a; a.f();

    a.f()等价于调用f(&a);类中的成员函数(static 成员函数除外)形参中都有个隐含的this指针,它指向类对象本身。当对象 a 调用f()的时候,它会把a 的地址传给this 指针,所以f()就等价执行:

f(const A* this){     cout<<"Hello"; }

    所以对象中并不需要保存函数成员。 

(3)类对象的字节数 

讯享网class A {     char c;     int i; }; A a;

    这对象a 的内存大小sizeof(a)=8(字节为单位) 。c 放在起始位置0,占1 个字节。 i 是int 要4 字节对齐,所以前面要空3 字节。它要从位置4 开始存储,占4,5,6,7 四 个位置。 最后类要按照他最长的数据成员对齐,就是i也就是4 字节对齐.因为已经占用了8 个字节, 8 是对齐4 的,所以不用额外增加字节数了。最后sizeof(a)=8。 

class B { doube d; char c; A a; //1 中的类类型A }; B b;

    这对象b的内存大小sizeof(b)=24(字节为单位) 。d 放在起始位置0到7,占8个字节。 c 是char要1字节对齐,所以放在位置8,占1 个字节。 a是类类型,在1 中可以知道它是8字节对齐的,所以前面要空7 个字节,它从位置16 开始存储,一直到23,占8个字节。 最后类要按照他最长的数据成员对齐,就是d也就是8字节对齐,因为已经占用了24 个字节,24是对齐8 的,所以不用额外增加字节数了。最后sizeof(b)=24。 

讯享网class c { char c; int i1; double d; int i2; }; C c;

    你知道sizeof(c)=多少吗? 答案:首先存储字符变量c,0位置存储,占1个字节;然后存储整型变量i1,4个字节对齐,因此从4~7位置存储,占4个字节;然后存储双精度变量d,从8~15位置存储,占8个字节;最后存储整型变量i2,从位置16~19存储占4个字节;最后对齐到最长的(8个字节),及补全20~23位置,整个占24个字节。 

(4)含有虚函数的类对象字节数

    我们在一开始的时候,就说了成员函数中有虚函数。c++为了处理多态,所以引入虚函数, 在一个类对象存储空间中,第一个位置需要4 个字节来存储一个指针。这个指针是指向该类的虚函数表的。也就是这个指针的值就是改类的虚函数表的地址。所以就比上面说的多了 4 个字节。 例如: 

class D  {  public:  virtual void f(){};  double d;  }  D d; 

    sizeof(d)=16,接下来看派生类对象的内存大小:

讯享网class E:D  { public: virtual void f(){};  private:  int d0;  char c;  int d1;  };  E e; 

    sizeof(e)=32; 基类中有虚函数,所以派生类对象一开始要 4 个字节存储指向虚函数表的指针。 然后继承 D 中的数据成员double d; 它要8 字节对齐,所以前面空4 个字节。 下面就开始存储 d0,c,d1.最后类对齐可计算得到32.

2、类对象内存结构 

    在C++中,如果类中有虚函数,那么它就会有一个虚函数表的指针__vfptr,在类对象最开始的内存数据中。之后是类中的成员变量的内存数据。 对于子类,最开始的内存数据记录着父类对象的拷贝(包括父类虚函数表指针和成员变量)。 之后是子类自己的成员变量数据。 对于子类的子类,也是同样的原理。但是无论继承了多少个子类,对象中始终只有一个虚函数表指针。 

                                         
讯享网

    为了探讨C++类对象的内存布局,先来写几个类和函数 。首先写一个基类: 

class Base  {  public:  virtual void f() { cout << “Base::f” << endl; }  virtual void g() { cout << “Base::g” << endl; }  virtual void h() { cout << “Base::h” << endl; }  int base;  protected:  private:  }; 

   这个基类的内存布局为:

讯享网1> class Base size(8): 1> +--- 1> 0 | {vfptr} 1> 4 | base 1> +--- 1> 1> Base::$vftable@: 1> | &Base_meta 1> | 0 1> 0 | &Base::f 1> 1 | &Base::g 1> 2 | &Base::h

 然后,我们多种不同的继承情况来研究子类的内存对象结构。 

(1) 无虚函数继承

//子类1,无虚函数重载  class Child1 : public Base  {  public:  virtual void f1() { cout << “Child1::f1” << endl; }  virtual void g1() { cout << “Child1::g1” << endl; }  virtual void h1() { cout << “Child1::h1” << endl; }  int child1;  protected:  private:  }; 

    Child1的内存布局为:

讯享网1> class Child1 size(12): 1> +--- 1> | +--- (base class Base) 1> 0 | | {vfptr} 1> 4 | | base 1> | +--- 1> 8 | child1 1> +--- 1> 1> Child1::$vftable@: 1> | &Child1_meta 1> | 0 1> 0 | &Base::f 1> 1 | &Base::g 1> 2 | &Base::h 1> 3 | &Child1::f1 1> 4 | &Child1::g1 1> 5 | &Child1::h1

 这个子类Child1没有继承任何一个基类的虚函数,因此它的虚函数表如下图: 
                                      
    我们可以看出,子类的虚函数表中,先存放基类的虚函数,在存放子类自己的虚函数。 

(2)有一个虚函数继承 

class Child2 : public Base  {  public:  virtual void f() { cout << “Child2::f” << endl; }  virtual void g1() { cout << “Child2::g1” << endl; }  virtual void h1() { cout << “Child2::h1” << endl; }  int child2;  protected:  private:  };   

    Child2的内存布局为:

讯享网1> class Child2 size(12): 1> +--- 1> | +--- (base class Base) 1> 0 | | {vfptr} 1> 4 | | base 1> | +--- 1> 8 | child2 1> +--- 1> 1> Child2::$vftable@: 1> | &Child2_meta 1> | 0 1> 0 | &Child2::f 1> 1 | &Base::g 1> 2 | &Base::h 1> 3 | &Child2::g1 1> 4 | &Child2::h1

 

                                           

    当子类重写了父类的虚函数,则编译器会将子类虚函数表中对应的父类的虚函数替换成子类的函数。 

(3)全部虚函数都继承 

//子类3,全部虚函数重载  class Child3 : public Base  {  public:  virtual void f() { cout << “Child3::f” << endl; }  virtual void g() { cout << “Child3::g” << endl; }  virtual void h() { cout << “Child3::h” << endl; }  protected:  int x;  private:  }; 

    Child3的内存布局为:

讯享网1> class Child3 size(12): 1> +--- 1> | +--- (base class Base) 1> 0 | | {vfptr} 1> 4 | | base 1> | +--- 1> 8 | child2 1> +--- 1> 1> Child3::$vftable@: 1> | &Child3_meta 1> | 0 1> 0 | &Child3::f 1> 1 | &Child3::g 1> 2 | &Child3::h

                                                 

(4)多重继承 

class Base3 { public: virtual void f3() { cout << "Base3::f3" << endl; } virtual void g3() { cout << "Base3::g3" << endl; } virtual void h3() { cout << "Base3::h3" << endl; } int base3; protected: private: }; class Base4 { public: virtual void f4() { cout << "Base4::f4" << endl; } virtual void g4() { cout << "Base4::g4" << endl; } virtual void h4() { cout << "Base4::h4" << endl; } int base4; protected: private: }; class Child5 : public Base3,public Base4 { public: virtual void f3() { cout << "child5::f3" << endl; } virtual void f4() { cout << "Child5::f4" << endl; } virtual void f5() { cout << "Child5::f5" << endl; } virtual void g5() { cout << "Child5::g5" << endl; } virtual void h5() { cout << "Child5::h5" << endl; } int child5; protected: private: };

Child5的内存布局为:

讯享网1> class Child5 size(20): 1> +--- 1> | +--- (base class Base3) 1> 0 | | {vfptr} 1> 4 | | base3 1> | +--- 1> | +--- (base class Base4) 1> 8 | | {vfptr} 1> 12 | | base4 1> | +--- 1> 16 | child5 1> +--- 1> 1> Child5::$vftable@Base3@: 1> | &Child5_meta 1> | 0 1> 0 | &Child5::f3 1> 1 | &Base3::g3 1> 2 | &Base3::h3 1> 3 | &Child5::f5 1> 4 | &Child5::g5 1> 5 | &Child5::h5 1> 1> Child5::$vftable@Base4@: 1> | -8 1> 0 | &Child5::f4 1> 1 | &Base4::g4 1> 2 | &Base4::h4

    我们可以看到,当子类继承了多个父类,Child5将Base3作为主基类,也就是将它虚函数“并入"Base3的虚函数表之中,并将Base3的虚指针作为Child5的内存起始地址。那么子类的内存结构是这样的:

                                  

(6)菱形继承

class Base { public: virtual void f() { cout << "Base::f" << endl; } virtual void g() { cout << "Base::g" << endl; } virtual void h() { cout << "Base::h" << endl; } int base; protected: private: }; class Base3:public Base { public: virtual void f3() { cout << "Base3::f3" << endl; } virtual void g3() { cout << "Base3::g3" << endl; } virtual void h3() { cout << "Base3::h3" << endl; } int base3; protected: private: }; class Base4:public Base { public: virtual void f4() { cout << "Base4::f4" << endl; } virtual void g4() { cout << "Base4::g4" << endl; } virtual void h4() { cout << "Base4::h4" << endl; } int base4; protected: private: }; class Child6 : public Base3,public Base4 { public: virtual void f() { cout << "child6::f" << endl; } virtual void f3() { cout << "child6::f3" << endl; } virtual void f4() { cout << "Child6::f4" << endl; } virtual void f6() { cout << "Child6::f6" << endl; } virtual void g6() { cout << "Child6::g6" << endl; } virtual void h6() { cout << "Child6::h6" << endl; } int child6; protected: private: };

Child6的内存布局为:

讯享网1> class Child6 size(28): 1> +--- 1> | +--- (base class Base3) 1> | | +--- (base class Base) 1> 0 | | | {vfptr} 1> 4 | | | base 1> | | +--- 1> 8 | | base3 1> | +--- 1> | +--- (base class Base4) 1> | | +--- (base class Base) 1> 12 | | | {vfptr} 1> 16 | | | base 1> | | +--- 1> 20 | | base4 1> | +--- 1> 24 | child6 1> +--- 1> 1> Child6::$vftable@Base3@: 1> | &Child6_meta 1> | 0 1> 0 | &Child6::f 1> 1 | &Base::g 1> 2 | &Base::h 1> 3 | &Child6::f3 1> 4 | &Base3::g3 1> 5 | &Base3::h3 1> 6 | &Child6::f6 1> 7 | &Child6::g6 1> 8 | &Child6::h6 1> 1> Child6::$vftable@Base4@: 1> | -12 1> 0 | &thunk: this-=12; goto Child6::f 1> 1 | &Base::g 1> 2 | &Base::h 1> 3 | &Child6::f4 1> 4 | &Base4::g4 1> 5 | &Base4::h4

    在菱形继承中,如果没有加上virtual关键字,那么子类会保存间接基类成员的两个备份。 此外,如果子类重写了间接基类的成员函数,那么将会重写第一个父类虚函数表中所继承的间接基类的虚函数,而第二个父类的虚函数表中所继承的间接基类的虚函数将会变成一个指针,指向第一个父类虚函数表中所继承的间接基类的虚函数。

                       

(7)单一虚继承

class Base { public: virtual void f() { cout << "Base::f" << endl; } virtual void g() { cout << "Base::g" << endl; } virtual void h() { cout << "Base::h" << endl; } int base; protected: private: }; class Child : virtual public Base { public: virtual void f() { cout << "Base::f" << endl; } virtual void f1() { cout << "Child::f1" << endl; } virtual void g1() { cout << "Child::g1" << endl; } virtual void h1() { cout << "Child::h1" << endl; } int child; protected: private: }; 

Child的内存布局为:

讯享网1> class Child size(20): 1> +--- 1> 0 | {vfptr} 1> 4 | {vbptr} 1> 8 | child 1> +--- 1> +--- (virtual base Base) 1> 12 | {vfptr} 1> 16 | base 1> +--- 1> 1> Child::$vftable@Child@: 1> | &Child_meta 1> | 0 1> 0 | &Child::f1 1> 1 | &Child::g1 1> 2 | &Child::h1 1> 1> Child::$vbtable@: 1> 0 | -4 1> 1 | 8 (Childd(Child+4)Base) 1> 1> Child::$vftable@Base@: 1> | -12 1> 0 | &Child::f 1> 1 | &Base::g 1> 2 | &Base::h

    虚拟继承的子类的内存结构,和普通继承完全不同。虚拟继承的子类,有单独的虚函数表, 另外也单独保存一份父类的虚函数表,两部分之间用一个四个字节的0x00000000来作为分界。子类的内存中,首先是自己的虚函数表,然后是子类的数据成员,然后是0x0,之后就是父类的虚函数表,之后是父类的数据成员。 
    如果子类没有自己的虚函数,那么子类就不会有虚函数表,但是子类数据和父类数据之间,还是需要0x0来间隔。因此,在虚拟继承中,子类和父类的数据,是完全间隔的,先存放子类自己的虚函数表和数据,中间以0x分界,最后保存父类的虚函数和数据。如果子类重载了父类的虚函数,那么则将子类内存中父类虚函数表的相应函数替换。 

                                            

(8)菱形虚继承(最重要) 

class Base { public: virtual void f() { cout << "Base::f" << endl; } virtual void g() { cout << "Base::g" << endl; } virtual void h() { cout << "Base::h" << endl; } int base; protected: private: }; class Base3 :virtual public Base { public: virtual void f3() { cout << "Base3::f3" << endl; } virtual void g3() { cout << "Base3::g3" << endl; } virtual void h3() { cout << "Base3::h3" << endl; } int base3; protected: private: }; class Base4 :virtual public Base { public: virtual void f4() { cout << "Base4::f4" << endl; } virtual void g4() { cout << "Base4::g4" << endl; } virtual void h4() { cout << "Base4::h4" << endl; } int base4; protected: private: }; class Child7 : public Base3, public Base4 { public: virtual void f() { cout << "child7::f" << endl; } virtual void f3() { cout << "child7::f3" << endl; } virtual void f4() { cout << "Child7::f4" << endl; } virtual void f7() { cout << "Child7::f7" << endl; } virtual void g7() { cout << "Child7::g7" << endl; } virtual void h7() { cout << "Child7::h7" << endl; } int child7; protected: private: };

Child7的内存布局为:

讯享网1> class Child7 size(36): 1> +--- 1> | +--- (base class Base3) 1> 0 | | {vfptr} 1> 4 | | {vbptr} 1> 8 | | base3 1> | +--- 1> | +--- (base class Base4) 1> 12 | | {vfptr} 1> 16 | | {vbptr} 1> 20 | | base4 1> | +--- 1> 24 | child7 1> +--- 1> +--- (virtual base Base) 1> 28 | {vfptr} 1> 32 | base 1> +--- 1> 1> Child7::$vftable@Base3@: 1> | &Child7_meta 1> | 0 1> 0 | &Child7::f3 1> 1 | &Base3::g3 1> 2 | &Base3::h3 1> 3 | &Child7::f7 1> 4 | &Child7::g7 1> 5 | &Child7::h7 1> 1> Child7::$vftable@Base4@: 1> | -12 1> 0 | &Child7::f4 1> 1 | &Base4::g4 1> 2 | &Base4::h4 1> 1> Child7::$vbtable@Base3@: 1> 0 | -4 1> 1 | 24 (Child7d(Base3+4)Base) 1> 1> Child7::$vbtable@Base4@: 1> 0 | -4 1> 1 | 12 (Child7d(Base4+4)Base) 1> 1> Child7::$vftable@Base@: 1> | -28 1> 0 | &Child7::f 1> 1 | &Base::g 1> 2 | &Base::h

    在Child7的内存布局中,先保存直接基类Base3的拷贝,由于Base3单一虚继承了Base,因此Base3中先存放自己的虚表指针和数据成员,中间有一个四字节分界,因此Base3的拷贝总共为12B。接着保存Base4的拷贝,Base4和Base3类似,也为12B。紧接着保存的是Child7的数据成员4B,然后保存简介基类Base的虚表指针和数据成员(8B)。总共加起来一共36B。Child7的虚函数放在多继承的第一个父类Base3的虚表中。可见,在菱形虚继承中,子类只保存间接基类的一个拷贝,就不存在重复保存间接基类多个拷贝的问题。 

               

   结论: 

(1)对于基类,如果有虚函数,那么先存放虚函数表指针,然后存放自己的数据成员;如果没有虚函数,那么直接存放数据成员。 

(2)对于单一继承的类对象,先存放父类的数据拷贝(包括虚函数表指针),然后是本类的数据。 

(3)虚函数表中,先存放父类的虚函数,再存放子类的虚函数 。

(4)如果重载了父类的某些虚函数,那么新的虚函数将虚函数表中父类的这些虚函数覆盖。 

(5)对于多重继承,先存放第一个父类的数据拷贝,在存放第二个父类的数据拷贝,一次类推,最后存放自己的数据成员。其中每一个父类拷贝都包含一个虚函数表指针。如果子类重载了某个父类的某个虚函数,那么该将该父类虚函数表的函数覆盖。另外,子类自己的虚函数,存储于第一个父类的虚函数表后边部分。 

(6)对于单一虚继承,会保存两个虚表指针。子类的内存中,首先是自己的虚函数表,然后是子类的数据成员,然后是0x0,之后就是父类的虚函数表,之后是父类的数据成员。如果子类重载了父类的虚函数,那么则将子类内存中父类虚函数表的相应函数替换。

(7) 对于菱形虚继承,会先保存第一个直接基类的拷贝,然后保存第二个直接基类的拷贝,然后保存子类的数据成员,最后才保存间接基类的虚表指针和数据成员。子类的虚函数保存在第一个直接基类的虚表中。

参考:https://blog.csdn.net/fenxinzi557/article/details/ 

小讯
上一篇 2025-04-07 19:32
下一篇 2025-04-10 22:09

相关推荐

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容,请联系我们,一经查实,本站将立刻删除。
如需转载请保留出处:https://51itzy.com/kjqy/78178.html