C++类对象的内存结构

最新推荐文章于 2024-04-17 21:44:35 发布
最新推荐文章于 2024-04-17 21:44:35 发布
阅读量4.7k 收藏 39
点赞数 6
分类专栏： C/C++

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

（1） 无虚函数继承

（2）有一个虚函数继承 

（3）全部虚函数都继承 

（4）多重继承 

（6）菱形继承

（7）单一虚继承

（8）菱形虚继承 （最重要）

 结论： 

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

/d1 reportSingleClassLayoutXXX（其中XXX为类名）

1、C++类的存储 

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

（1）数据成员 

    1）内置类型对齐原则，内置类型就是常用的：char,short,long,int,float,double. 这些内置类型在类的对象中对齐方式，字节为单位（在c 中结构体也是一样的） ：char 1 、short 2 、long 4 、int 4 、float 4 、double 8 。
    2）类类型对齐原则（c 中就是结构体对齐原则） 取类中最长的数据成员作为对齐原则。例如，类中最长为 double,那么就是8 个字节。 

（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/51995911 

蓬莱道人
关注
  • 6
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++对象内存模型.pdf
04-18
本文将通过实验和分析来探索 C++ 对象内存模型，并讨论对象内存结构、简单类型相关数据、包含虚函数类的对象内存结构、继承下的多态性等问题。 1. 实验基础 在 C++ 中，我们可以使用 sizeof 运算符来获取对象的...
浅谈C++中派生类对象的内存布局
08-31
在C++中，派生类对象的内存布局是编程中非常关键的概念，它涉及到对象的存储方式、继承关系以及访问效率。派生类是基于一个或多个基类创建的，继承了基类的属性和方法。本文将从单一继承、多重继承和虚拟继承三个...
c++ 内存结构
AlbertHMY的博客
12-16 946
c++ STL笔记C/C++ 内存结构C++内存结构分类全局变量，全局函数普通类的内存模型类成员非静态成员内存对齐的原则：确定对齐单位：填充内存：静态成员成员函数非静态成员函数静态成员函数补充&总结 C/C++ 内存结构 C++内存结构分类 全局变量，全局函数 static字符不影响全局变量和函数在内存中的表现形式，唯一区别是加了static修饰的值外部不可见。 全局函数都位于代码段，全局变量根据其是否赋有初值，是否被const修饰区分： 未被const修饰，赋初值：位于读写数据段； 未被con
C++对象内存分配总结
沉迷单车的追风少年
10-16 1006
目录 六条基本规则 C++程序占用内存分类 实例代码： 参考： 六条基本规则 空类的大小为1。这个容易理解，任何东西都不可能凭空出现。 静态成员函数不占对象空间。这个很容易理解，因为类中的static是存储在数据区中的，不会占用对象的空间。 析构函数和构造函数不占用对象空间(构造和析构函数除外)。这个容易理解，因为当我们定义了空类的时候，就已经默认包含析构函数和构造函数。在下面的例子当中，我们自己定义了显示的析构函数和构造函数，观察输出。 成员函数不占对象空间。存放在代码区。 虚函数占用
C++类与对象(全）
最新发布
2301_79108642的博客
04-17 1453
类与对象
c/c++程序的内存结构（一）
weixin_42579072的博客
06-19 1674
一、动态分配内存和静态分配内存 一块程序被加载到内存中，首先，这块内存就存在两种属性：动态分配内存和静态分配内存。 静态分配内存：程序编译和链接时就确定好的内存。 动态分配内存：程序加载、调入、执行时分配和回收的内存。 二、堆栈 堆与栈的区别： （1）*管理方式：*堆中资源由程序员控制（通过malloc/free、new/delete，容易产生memory leak），栈资源由编译器自动管理。 ...
C++对象在内存中的存放方式
越明年zZ的博客
03-10 2758
对象占有一定的内存，该内存上存放的是该对象的相关数据，按先后顺序如下： 1、虚表指针：如果该类有虚函数的话，将存放虚表指针，该指针指向该类的虚函数表，即指向表中的第一个元素。续表中存放的是该类虚函数的地址； 2、基类数据成员（如果有基类）； 3、自己的数据成员； 对象在调用成员函数时的方式： 1、调用非虚成员函数：其实相当于是非成员函数调用，实现根据对象类型找到该对象所属类，并在
内存（三）--类的实例化占用
suiyueranxin的专栏
04-06 433
转）提示2：下文提到的“类大小”严格上来说是该类经过实例化的对象的大小。当然了，光研究长度的话，两者差别不大，因为:CClassA objA，sizeof(CClassA)和sizeof(objA)得到的结果都是一样的。 一、真空类class CNull{}; 长度：1内存结构：?? 评注：长度其实为0，这个字节作为内容没有意义，可能每次都不一样。 
C++对象内存分布详解(包括字节对齐和虚函数表)
08-31
C++是一种静态类型的面向对象编程语言，其对象...总之，理解C++对象内存分布，包括字节对齐和虚函数表，对于优化代码性能、编写安全的多态代码至关重要。了解这些概念有助于我们更好地设计和实现复杂的面向对象程序。
C++中的内存分区介绍
09-03
值得注意的是，`new`与`malloc`的区别：`new`不仅分配内存，还会调用对象的构造函数，而`malloc`仅分配内存，不涉及对象的构造。此外，`new`返回的指针具有类型信息，而`malloc`返回的`void*`指针需要显式转换。 ...
C++类对象关于虚函数表详解
03-14
它是一个类的虚函数地址列表，存储在每个具有虚函数的对象实例内存中。当使用基类指针操作派生类对象时，虚函数表起到了关键作用，它指示调用哪个实际的函数，确保正确执行子类的重定义版本。 例如，考虑以下类结构...
c++类的内存结构
09-13
用图片和代码形象的解释c++类的内存结构
C++内部存储结构
tyq20010606的博客
03-04 369
c++内部存储结构
C++ 对象的内存布局
wh128341的博客
07-10 585
07年12月，我写了一篇《C++虚函数表解析》的文章，引起了大家的兴趣。有很多朋友对我的文章留了言，有鼓励我的，有批评我的，还有很多问问题的。我在这里一并对大家的留言表示感谢。这也是我为什么再写一篇续言的原因。因为，在上一篇文章中，我用了的示例都是非常简单的，主要是为了说明一些机理上的问题，也是为了图一些表达上方便和简单。不想，这篇文章成为了打开C++对象模型内存布局的一个引子，引发了大家对C++对象的更深层次的讨论。当然，我之前的文章还有很多方面没有涉及，从我个人感觉下来，在谈论虚函数表里，至少有以下这些
C++：对象及成员变量在内存中的存储分析
Magnum的博客
05-19 3174
类的成员变量并不能决定自身的存储空间位置。决定存储位置的是对象的创建方式。 即： 如果对象是函数内的非静态局部变量，则对象，对象的成员变量保存在栈区。 如果对象是全局变量，则对象，对象的成员变量保存在静态区。 如果对象是函数内的静态局部变量，则对象，对象的成员变量保存在静态区。 如果对象是new出来的，则对象，对象的成员变量保存在堆区。 下面是一个示例：当对象是new出来的时，其对象地址和成员变量、成员变量的成员变量、成员变量存储的数据都在堆区存储。 struct SQL{ SQL()
[C++] 类对象所占内存空间分析和总结
LEOX
08-23 8370
类所占内存的大小主要是由成员变量（静态变量除外）决定的，成员函数（虚函数除外）是不计算在内的。 成员函数的存储还是以一般函数的模式进行存储。a.fun()是通过fun(a.this)来调用的。所谓成员函数只是在名义上是类里的。其实成员函数的大小不在类的对象里面，同一个类的多个对象共享函数代码。 类中的成员函数相当于C语言中一个普通函数,按照一个普通函数的方式存储在内存中，做到使得两者相联系...
C++对象的各方法存储空间占用计算
实践求真知
05-01 2246
一类中只有1个成员函数的存储空间计算 1代码 #include<iostream> using namespace std; class CBox{ int foo(); }; int main(){ CBox boxobj; cout<<sizeof(boxobj)<<endl; return 0; } 2运行 ...
C++对象存储空间探讨
Stay Hungry, Stay Foolish.
10-01 543
对象的存储空间 一个对象要占用多大的内存空间，权威结论是：非静态成员变量总和加上编译器为CPU数据对齐和支持虚函数所产生的负担的总和。 #include <iostream> using namespace std; class Box { }; int main() { Box boxobj; cout << sizeof(boxobj) << endl; return 0; } 程序执行结果为 1 空类型对象中不包含任何信息，但是创建对象时必须在内存中占用
【C++】C++的类|C++类的内存结构
bandaoyu的note
06-06 269
C++类内存结构 占内存的： 1、虚拟函数表指针 2、成员变量 不占内存的： 成员函数
c++ 创建对象内存不足错误解决
10-07
创建对象内存不足错误可以通过以下几种方式解决： 1. 增加可用内存空间：可以通过增加系统内存或者使用更大的内存分配池来解决内存不足的问题。 2. 优化内存使用：可以通过优化代码，减少不必要的内存分配和释放操作...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值