sizeof大全

1，本文详细的对各种可能出现的sizeof进行了测试，基本上以我的经验来说， 好像就覆盖全了。

2，各个sizeof的结果肯定都是正确的，因为我是一个一个经过分析+调试得出来的结果；但是分析过程和分析结果可能会有理解不全面的地方，请达人指出来。

 

3，测试环境：VC6

4，更多的理论知识，请参考<深度探索c++对象模型>。

 

5，代码，很长，也有些乱。基本上是以一个一个的namespace做的分割，每个namespace里面的内容是考察的同一个技术点。

 

#include "stdio.h" #include <string.h> #pragma warning (disable: 4101) namespace normal{ class cls{ public: cls(): abc(8), abc1(abc){;}; int abc; //****虽然引用只是个alias（别名），但是类的成员int&，还是会在求sizeof() int& abc1; //****的时候有所体现。所以：sizeof(cls)=8, 一个int，一个int& }; void test() { char str1[] = "Hello"; char str2[5] = {'H','e','l','l','o'}; char str3[6] = {'H','e','l','l','o','/0'}; char *p1 = "Hello"; char *p2[]={"hello","world"}; int x = 10; int *q = &x; int abc = 8; int& abc1 = abc; cls cls1; cls* cls2 = new cls(); cls& cls3 = cls1; int n = 0; n = sizeof (str1[0] );// 1 n = sizeof (str1 );// 6 (自动加了'/0') n = strlen (str1 );// 5 (字符串的长度) n = sizeof (str2 );// 5 (字符数组的大小) n = strlen (str2) ;// 未知 (该字符串缺少结束符'/0') n = sizeof (str3) ;// 6 (字符数组的大小) n = strlen (str3) ;// 5 (该字符串的长度为5) n = sizeof ( p1 );// 4 (p1是一个指针，大小为4) n = sizeof ( p2 );// 8 (p2是长度为2的字符串数组) n = sizeof ( n );// 4 (整型大小为4) n = sizeof ( q );// 4 (q是一个指针，大小为4) n = sizeof(abc); //4 int n = sizeof(abc1); //4 int 引用 n = sizeof(cls1); //8 int + int& n = sizeof(cls2); //4 指针 n = sizeof(cls3); //8 和cls一样 } } // [] into function namespace funct{ void Function1( char p[],int num ){ int n = 0; n = sizeof(p); //4,数组在做为函数参数时，均退化为指针 }; void test() { char p[] = "abcde"; int n = sizeof(p); //6 Function1(p, 10); } } // 基本的对齐 namespace align{ class A{ public: int a;}; class B{ public: int a ; char b; }; class C{ public: int a ; char b; char c;}; class D{ public: int a ; char b; int d ; char c;}; class E{ public: char b; char c; }; void test() { int n = 0; n = sizeof(A); //4 （内含一个int ，所以大小为4） n = sizeof(B); //8 (int为4，char为1，和为5，考虑到对齐，总大小为int的整数倍即8) n = sizeof(C); //8 (同上) n = sizeof(D); //16 (同上) n = sizeof(E); //2 (同上) } } // 位bit变量的对齐 namespace bitwiseAlignment{ struct stru{ int a:3; short b:3; int c:20; int d; }; // sizeof(stru)=16; struct stru2{ int a:3; int b:3; int c:20; int d; }; // sizeof(stru)=8; void test() { int n = sizeof(stru); //16 n = sizeof(stru2); //8 /******************** 分析： int a:3// 3bit short b:3//因类型不同, 从下一个4字节处开始, 3bit int c:20//因与上面类型不同, 从下一个4字节处开始, 20bit int d;//类型相同, 但是不是位域, 也从下一个4字节开始 所以是16. 相当于: int a:3; int :29; // padding short b:3; short :29; // padding int c:20; int :12; // padding int d; 共16字节. 第二个分析同样. */ } } //除了常用的int要求char对齐之外，double还要去int、指针等向它对齐 namespace doubleFloatAlignment{ // 终于看到对齐的最终结果了，下面的结论适用于一个类中的对齐规则，不涉及派生。 // ******************** // 所谓 边界对齐, 是操作系统为了提高系统总线的效率, // 他会按类中最大的的数据类型所占的大小来补齐其他变量, // ******************** // 在一个结构体（类有同样的结果）里面，以最长的基本类型长度作为对齐的标准。 // 最大“基本类型”，包括long，double，float，int，char，___指针___等。 // 所谓的___指针___，包括各种指针：virtual base class的指针，vptr，一般指针都算 // ******************** // 但是如果成员里面只有一个数据，int,char,double等都无所谓，这时候， // 就没有所谓的和其他对象对齐的问题，sizeof(class) == sizeof(成员) // ******************** // 比如下面的既有double, int也有char，那么就以double来对齐； // 如果只有int和char，那么就以int来对齐； // ******************** // 因此你最好把大的数据类型在前前面定义,这样可以节省空间, // temp1以double为单位划分,能看出要了24个字节的内存. struct temp1{double a; double b; int c; int d; }; //大小为24 // temp2里面，最大的是double型,占8字节,因此系统会在int c后面补四个字节 struct temp2{ double a; int c; double b; int d; };//大小为32; struct WORK1{ char a; char b; int c; double d; double e; }; // 该结构体占16个字节，在本例中是最大的变量是4， // 所以是4个4个的对齐，超过4个的就再分配4个字节来存。 struct s{short s1;char c1; short s2; int i1; char c2; }; struct DATA{ int d1; double d2; }; // 这个非常奇怪，但是也正常，就像派生一样的原因：基类有了长数据，子类都需要跟着对齐 // 如果结构里有结构的话, 就按照所有结构中最大的基本数据类型(int,double,char)尺寸进行分配, // 而不是按照本类中的最大类型来对齐（比如int），也不会按照一个结构大小的 // 尺寸进行分配如(DATA:16)。本例按照double进行分配。 struct WORK2{ struct DATA w3; int w0;int w1; char w2; //w1会被按照w3::d2来对齐 }; struct STUDENT{struct STUDENT* pNext; int num; char name[17]; // 这个17，会被allign到4的倍数：20 }; void test() { printf("sizeof(temp1) = %d/n",sizeof(temp1)); //24 printf("sizeof(temp2) = %d/n",sizeof(temp2)); //32 printf("sizeof(WORK1) = %d/n",sizeof(WORK1)); //24 printf("sizeof(WORK2) = %d/n",sizeof(WORK2)); //32 printf("sizeof(s) = %d/n",sizeof(s)); //16 printf("sizeof(DATA) = %d/n",sizeof(DATA)); //16 printf("sizeof(STUDENT) = %d/n",sizeof(STUDENT)); //28 } ; } // 基本派生导致的allignment问题 namespace deriveAlignment{ // 对于allignment，如果没有派生，相对还是比较简单。 // 但是，加上派生；加上virtual 函数，有了vptr；加上virtual 派生， // 基类对象的位置放前面还是放后面的变化 // 等等，情况就非常复杂。 // 但是，总的结论和规律是： // 1）需要保持一个“完整的基类子对象”；换句话说，一直要记住“基类子对象”的概念 // 2）从最高基类一直往下派生，直到某个基类有了padding的需求，之后的子类都应该要padding， // 如果基类在物理上排列到子类后面（比如由于virtual基类），则基类不向子类的padding看齐 // 所以，要时刻关注“基类子对象”的概念。其对齐（allignment）是以“基类子对象” // 中的最大“基本类型”为基准进行对齐 class A{char x; char y;}; class B{char z;}; class C: public A, public B{ int n;}; // B2的z和C2的n结合在一起，然后有2byte的padding // 但是C3却不是这样，原因如上所述 // 所以，A2需要padding，B2不需要（没有从A2派生），而B2紧邻C2，所以B2+C2=2， // 然后加上由于A2而出现的padding。 // 而B3从A3派生，所以也需要padding，C3同样 class A2{int x; char y;}; class B2{char z;}; class C2: public A2, public B2{ char n;}; // C3的整个对象中char n是最后面的一个字节，没有什么需要对齐的要求， // 为什么sizeof(c3)还是12，而不是9？ // 而virtual 继承的时候，就可以出现这样的奇数 // 这是因为：带virtual继承的最高基类不需要padding（肯定），而且它的分布是在最后面， // 所以，如果当最后的一个类（最高基类）只有一个char的时候，sizeof +=1； // 而这里的普通继承，最高基类放到前面，而后面的都是子类，在其中的某个子类中，已经 // 要求后续子类要进行padding了，也就是说即使这里的最后一个是char，但是也要先padding再说， // 所以，即使最后的一个类（最低子类）只有一个char的时候，sizeof +=4（与int对齐）； class A3{int x; char y;}; class B3: public A3{char z;}; class C3: public B3{ char n;}; void test() { int n = sizeof(A); //2 n = sizeof(B); //1 n = sizeof(C); //8 n = sizeof(A2); //8 n = sizeof(B2); //1 n = sizeof(C2); //12 A2 a2; B2 b2; C2 c2; n = sizeof(A3); //8 n = sizeof(B3); //12 n = sizeof(C3); //16 A3 a3; B3 b3; C3 c3; } } // 带有virtual 派生相关的allignment namespace moreAlignment{ // 布局顺序是：vptr+dd; // double为8,vptr是4,加上4个allignment，所以==16 class X1{ public: double dd; virtual void Function(){}; }; // 下面的例子中：56byte=24+24+8 // 在C041、C98、C982中：char --> 8byte, d1: 8byte; vptr -> 8byte struct C041 {char c1;}; struct C98 : public C041 {double d1; virtual f(){};}; //3*8=24 struct C982 : public C041 {double d1; virtual f(){};}; //3*8=24 struct C99 : public virtual C98, public virtual C982{char n1;}; //vptr(4)+char(4)=8 /* 对于这种情况：24byte */ // c1 --> 8byte, d1: 8byte, n1: 8byte（上面已经解释过为什么c1不可以和n1合并） struct C011 {char c1; }; struct C021 {double d1;}; struct C031 : public C011, public C021 {char n1;}; /* 对于这种情况：16byte */ // c1 + n1--> 8byte（上面已经解释过为什么c1可以和n1合并）, d1: 8byte struct C012 {char c1; }; struct C022 {double d1;}; struct C032 : public C022, public C012 {char n1;}; // 对于这种情况，C033实际上是有几个subobject（子类中的bass class subobject）组成的， // 所以，在各个subobject里面进行对齐，而不跨越subobject边界 // 很奇怪，按照分析，C033应该是： // virtual pointer(4) + C033::n1以及padding(4) + C013::c1以及padding(4) // + C023::d1(8) = 20, d1是double类型 // 但是实际看起来，在d1之前有4字节的空闲，不知道是什么东西。根据把C023的double改为int，发现： // d1前面的4个字节不见了，所以这几个字节应该是由于向double对齐而导致的； // 但是，为什么要向double对齐，不可理解：因为C033::n1也没有向double对齐 // 若为int则C033size=16；改为double，则24 struct C013 {char c1; }; struct C023 {int d1;}; struct C033 : public virtual C013, public virtual C023 {char n1;}; // 这里，把所有的成员变量都去掉之后，按照分析，C034应该是4，但是实际是8： // virtual pointer + 空的4byte // 我推想，是compiler做了一些手脚，强制做了一个4byte的空对齐。不管它 class C014{}; class C024{}; class C034:virtual public C014,virtual public C024{}; void test() { X1 x1; printf("sizeof(X1) = %d/n",sizeof(X1)); //16 C033 c; printf("sizeof(C033) = %d/n",sizeof(C033)); //16 C034 d; printf("sizeof(C034) = %d/n",sizeof(C034)); //8 }; } // 带有虚函数产生的size namespace virtualFunc{ // 单继承派生类对象只有一个虚函数指针，该指针位于该派生类实例的父类子对象中， // 虚函数表在对象生成时进行重新填写； // 对单继承来说: // 1）虚函数按照其声明顺序放于虚函数表中。 // 2）父类的虚函数在子类的虚函数前面。 // 3）重写的函数被放到了虚表中原来父类虚函数的位置。 // 4）未重写函数依旧。 // 5）添加新增加的虚函数。 // 所以在vc中看到的是正常的。切割过程生成了一个父类实例 //但是如果有了多个基类，都有virtual function，那么第二个以及后面的基类的vptr // 都会被带下来，而不是和子类共享 class A{ public: int a; virtual void Function(){}; }; class B{ public: int a; virtual void Function1(){}; }; class C:public B{ public: char b; }; class D:public B, public A{ public: virtual void Function2(){}; }; class E{ public: static void Function(){}; static int n; }; void test() { int n = 0; n = sizeof (A);// 8 (内含一个int,普通函数不占大小(虚函数增加函数指针）) n = sizeof (B);// 8 (一个int ,一个虚函数表指针) n = sizeof (C);//12 (一个int ,一个虚函数表指针，一个char ,再加上数据对齐) n = sizeof (D);// 16 (A大小 + B大小。Function2和基类的虚函数是放在一个表里的， //所以D的虚函数表个数不增加，虚函数指针不增加) D d; n = sizeof (E);// 1 (****static变量，static 函数and 普通函数 不占大小,空类大小为1****) } } // 多重继承 + 虚拟继承导致的额外size namespace multiDeriv{ // 一个类如果从N个类中派生，而且都是virtual派生，那么只会增加一个virtual pointer， // 而不会像vptr一样，增加多个!!!! // 另外，这个pointer像vptr一样，放到对象的低地址端 class A{}; class B{}; class C:public A,public B{}; class D:virtual public A{}; class E:virtual public A,virtual public B{}; class F:public A,virtual public B{}; void test1(){ /* 编译器为每个有虚函数的类都建立一个虚函数表（其大小不计算在类中）,并为这个类安插一个 指向虚函数表的指针，即每个有虚函数的类其大小至少为一个指针的大小4 sizeof ( A ) = 1 (空类大小为1,编译器安插一个char给空类，用来标记它的每一个对象) sizeof ( B ) = 1 (空类大小为1,编译器安插一个char给空类，用来标记它的每一个对象) sizeof ( C ) = 1 (继承或多重继承后空类大小还是1) sizeof ( D ) = 4 (****虚继承时编译器为该类安插一个指向父类的指针，指针大小为4****） sizeof ( E ) = 8 (virtual pointer指针与4个空的byte，加起来大小为8。如果这些类有 成员变量的话就没有这样奇怪的问题了） */ int n = 0; n = sizeof(A); //1 n = sizeof(B); //1 n = sizeof(C); //1 n = sizeof(D); //4 n = sizeof(E); //8 n = sizeof(F); //4 } class X1{}; class X21:public virtual X1{}; class X22:public virtual X1{}; class X31:public virtual X21,public virtual X22{}; void test2(){ int n = 0; n = sizeof(X1); //1 n = sizeof(X21); //4 n = sizeof(X22); //4 n = sizeof(X31); //12，X21、X22、X31各带了一个virtual pointer X31 x; } class C041 {char c_;}; class C100 : public virtual C041 {char c_;}; class C101 : public virtual C041 {char c_;}; class C110 : public C100, public C101 {char c_;}; class C111 : public C100, public C101 {char c_;int n;}; class C112 : public C100, public C101 {int n;char c_;}; void test3(){ int n = 0; // 这里面都有一个多余的1（比如，9-8，25-24），这个1的来源是： // 1）因为virtual base subobject在整个对象的最后面， // 所以C041::c_是整个对象最后面的一个字节。 // 2）C041对象中没有其他的元素，所以c_不需要对齐，也就是 // 说sizeof(C041) == 1，因此有了这个多余的1 // 主要的原因是virtual 继承 n = sizeof(C041); //1 n = sizeof(C100); //9 n = sizeof(C101); //9 n = sizeof(C110); //21 n = sizeof(C111); //25 n = sizeof(C112); //25 C111 c1; C112 c2; } void test() { test1(); test2(); test3(); } } // <inside the C++ object model>中的实例 namespace point2d3d{ // 结论： // 详情参阅http://blog.csdn.net/fisker0303/category/186172.aspx?PageNumber=1 // virtual pointer总是在一个对象的最前面； // vptr最是在一个子对象、基类子对象的最前面，virtual pointer之后 // 1）对于普通继承，子类会和基类共享同一个vptr，换句话说，不会由于virtual func而增加size； // 2）对于virtual继承，有两种情况： // a) 如果基类有虚函数，那么子类不会和基类共享同一个vptr，换句话说， // 子类会自己增加一个vptr，而不和基类共享同一个vptr，这样就增加了size； // b) 如果基类没有虚函数，那么在对象最前头会出现一个偏移指针（即我 // 所谓的virtual pointer指针），指向虚拟基类（所以理解成偏移量也可以），其他正常 // 对于2）的理解，以及下面的关于布局的解释，当然也可以理解成： // 基类和子类共享vptr，然后多了一个virtual pointer。 // sizeof的结果一样；而且，根据VC的memory看不出来virtual pointer和vptr的区别?? // 内存布局： // vptr(4),x(4),y(4) class p2d{ public: int x; int y; virtual void f(){}; }; // 内存布局： // vptr(4), next(4), p2d[vptr(4),x(4),y(4)] class vertex:public virtual p2d{ public: vertex* next; }; // 内存布局，同vertex： // vptr(4), z(4), p2d[vptr(4),x(4),y(4)] class p3d:public virtual p2d{ private: int z; }; // 内存布局，因为不是virtual派生，所以它自己没有vptr或者virtual pointer出现： // vertex[vptr(4), next(4)], p3d[vptr(4), z(4)], dummy(4), p2d[vptr(4),x(4),y(4)] class pointvertex3d:public vertex, public p3d { public: int dummy; }; void test() { int n = sizeof(p2d); // 12 n = sizeof(vertex); // 20 n = sizeof(p3d); // 20 n = sizeof(pointvertex3d); // 32 p2d p2; p3d p3; vertex v; pointvertex3d pv3; } } // 普通继承和虚拟继承的时候，基类子对象与子类对象的布局 namespace virtualDeriveLayout{ // private的成员，虽然在子类中不可用，但是是可见的，因此私有的数据还是要占子类的大小 class A{ private: int a; char x; }; class B:public A{}; // c和d的内存结构不同： // c是virtual继承，先是一个virtual pointer和一个vptr，然后是自己的数据，然后是父类数据； // d是一般继承，先是一个vptr，然后是父类数据，然后是自己的数据； // 因为： 使用了虚继承，父类的成员变量被放到了最后面。 // 这个布局和point2d3d的对象布局不完全一样，但是计算sizeof可以按照这里的分析 class C:public virtual A{ private: char c; char d; virtual void f(){}; }; class D:public A{ private: char c; char d; virtual void f(){}; }; void test() { int n = sizeof(B); // = 8; (内含一个不可用的父类的数据） n = sizeof(C); // 20 = A(8) + 4(virtual 继承） + 4(2个char) + 4(virtual f) n = sizeof(D); // 16 = A(8) + + 4(2个char) + 4(virtual f) } } // 菱形继承 namespace diamond{ struct C041 { public: C041() : c_(0x01) {} virtual void foo() { c_ = 0x02; } char c_; }; // C140和C1402只差了一个构造函数，但是sizeof多了4，不知道?? //C140在[[virtual pointer(4), C140::c]]_之后，[[C041::vptr(4), C041::c_]] // 之前，有一个4byte的空间，被初始化为0，不知道是什么东西 struct C140 : public virtual C041 { public: C140() : c_(0x02) {} virtual void foo() { c_ = 0x11; } char c_; }; struct C0412 { public: virtual void foo() { c_ = 0x02; } char c_; }; struct C1402 : public virtual C0412 { public: virtual void foo() { c_ = 0x11; } char c_; }; void test() { int n = 0; C140 c001; C1402 c002; // ******** n = sizeof (C041);// 8 (内含一个char,普通函数不占大小(虚函数增加函数指针）) n = sizeof (C140);// 20 **** 比C1402大4，区别：没有默认构造函数，为什么就大了4 **** n = sizeof (C0412);// 8 (内含一个char,普通函数不占大小(虚函数增加函数指针）) n = sizeof (C1402);// 16 C1402 c2; c2.c_ = 0x03; //不知道这种初始化与构造函数的初始化有啥区别，但是两个对象的sizeof确实不一样 C140 c1; } } // 基类数组，子类对象 namespace array{ class complex{ public: complex(int x=0, int y=0){}; int n; ~complex(){}; }; class derived: public complex{ public: int m; ~derived(){}; }; void test(){ // 定义一个数组，10个对象。 // 每个对象都是一个complex类型的对象，而不是derived类型的 complex* p = new derived[10]; int n = sizeof(p[0]); // 40=4*10 n = sizeof(complex); // 4 n = sizeof(derived); // 8 // 所以这里析构的时候，释放的都是基类的数据(complex)， // 而不是子类的部分：这部分都没有被释放，成了垃圾 // 根据汇编代码就会发现：确实是 // 0040DA9B call @ILT+195(array::complex::`vector deleting destructor') (004010c8) // 但是~derived没有被调用 delete []p; } } // 这个菱形继承是比较变态的 namespace btDiamond{ /* D的size=36，布局： Offset ** c1 Offset ** c2 d a // 注意：a是没有被共享的 b1 a // 注意 b2 */ class A{int a;}; class B1: A{int b1;}; class B2: A{int b2;}; class C1: virtual B1{int c1;}; class C2: virtual B2{int c2;}; class D: C1, C2{int d;}; /*W的size=32，布局 Offset ** y1 z1 Offset ** y2 z2 w x // 注意：x被共享了 */ class X{int x;}; class Y1: virtual X{int y1;}; class Y2: virtual X{int y2;}; class Z1: Y1{int z1;}; class Z2: Y2{int z2;}; class W: Z1, Z2{int w;}; void test(){ D d; int n = sizeof(D); W w; n = sizeof(W); } } int main(int argc, char* argv[]) { // normal test normal::test(); // function test funct::test(); // align test align::test(); bitwiseAlignment::test(); doubleFloatAlignment::test(); deriveAlignment::test(); moreAlignment::test(); // virtual function, derive and virtual derive ... virtualFunc::test(); multiDeriv::test(); point2d3d::test(); diamond::test(); btDiamond::test(); // private Data and data layout virtualDeriveLayout::test(); // 基类数组，子类对象 array::test(); return 0; }