深入理解计算机各种类型大小（sizeof）深入理解计算机各种类型大小（sizeof）

// Example of the sizeof keyword   

size_t  i = sizeof( int );    

struct align_depends {   

    char c;   

    int i;   

};   

size_t size = sizeof(align_depends);  // The value of size depends on    

                                   //  the value set with /Zp or    

                                   //  #pragma pack   

int  array[] = { 1, 2, 3, 4, 5 };     // sizeof( array ) is 20    

                                      // sizeof( array[0] ) is 4    

size_t  sizearr =                        // Count of items in array   

   sizeof( array ) / sizeof( array[0] );  

  <!----> <script src="ms-its:dsmsdn.chm::/html/msdn_footer.js"></script> <!---->

int a;   

sizeof(a); // = 4   

sizeof(int); // = 4   

sizeof(1); // = 4  

void fn() { }   

sizeof(fn); // error：函数   

sizeof(fn()); // error：不能确定类型   

struct S   

{   

    int a : 3;   

};    

S sa;     

sizeof( sa.a ); // error：位域成员  

int a = -1;   

sizeof(a=3); // = sizeof(a) = sizeof(int) = 4   

cout<<a<<endl; // 输出-1。由于“=”操作符返回左操作数的类型，赋值操作没有执行。  

sizeof(int);        // = 4   

sizeof(double);     // = 8   

sizeof(char);       // = 1   

sizeof(bool);       // = 1   

sizeof(short);      // = 2   

sizeof(float);      // = 4   

sizeof(long);       // = 4  

sizeof(int *);         // = 4   

sizeof(double *);      // = 4   

sizeof(char *);        // = 4  

int ai[] = {1, 2};   

sizeof(ai);          // = 2*4 = 8  

char ac[] = "abcd";  //注意数组末尾的字符串终结符'\0'   

sizeof(ac);          // = 5*1 = 5   

sizeof("abcd");      // = 5*1 = 5  

int *pi = new int[10]; //这是指针   

sizeof(pi);            // = 4   

int ai[10];   

int *p = ai;           //这还是指针   

sizeof(p);             // = 4   

double* (*a)[3][6];    //看成(double *) (*a)[3][6]，即一个3×6的二维数组，数组元素为指针，指向double类型。   

sizeof(a);             // = 4，a为指向上述二维数组的指针   

sizeof(*a);            // = sizeof(double *)*3*6 = 72，*a表示上述二维数组       

sizeof(**a);           // = sizeof(double *)*6 = 24，**a即*(*a)，表示double*[6]，是元素为double指针的一维数组。   

sizeof(***a);          // = sizeof(double *) = 4，表示上述一维数组中的第一个元素，元素类型为double指针。   

sizeof(****a);         // = sizeof(double) = 8，表示上述数组首元素指向的double类型。  

void acf(char p[3])     //参数类型是int[]，表示指向int的指针   

    sizeof( p );        // = 4   

}   

void aif(int p[])       //参数类型是int[]，表示指向int的指针   

void pif(int (*p)[6])   //参数类型是int (*)[6]，表示指向int数组的指针   

    sizeof( p);         // = 4   

    sizeof( *p );       // = sizeof(int)*6 = 24   

void ppf(int *p[6])     //参数类型是int *[]，表示指向int指针的指针   

    sizeof( *p );       // = 4   

}  

class CEmpty { };   

sizeof(CEmpty); // = 1   

struct SEmpty { };   

sizeof(SEmpty); // = 1  

class CInt : public CEmpty {   

sizeof(CInt); // = 4;   

class CFunc {   

    void f() {}   

sizeof(CFunc); // = 1;   

struct SInt : SEmpty {   

    static int i;   

sizeof(SInt); // = 1;  

1）结构体变量的首地址能够被其最宽基本类型成员的大小所整除；

2）结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）；

3）结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）。

struct SByte1   

    double d;    // 偏移量0~7   

    char j;      // 偏移量8   

    int a;       // 偏移量12~15，由于9不能整除4，故先填充9~11   

sizeof(SByte1);  // = 16   

struct SByte2   

{         

    char j;      // 偏移量0   

    double d;    // 偏移量8~15，由于1不能整除8，故先填充1~7   

    int a;       // 偏移量16~19   

sizeof(SByte2);  // = 24，为了凑成8的倍数，填充20~23  

#pragma pack(push) //保存对齐状态   

#pragma pack(4)    //设定为4字节对齐   

class CByte   

    char c;        //偏移量0   

    double d;      //偏移量4~11，由于1不能整除4，故先填充1~3   

    int i;         //偏移量12~15   

#pragma pack(pop)  //恢复对齐状态   

sizeof(CByte); // = 16  

struct SBit1   

    char a : 3;   

    char b : 4;   

    char c : 5;   

sizeof(SBit1); // = (3+4+1+5+3) bits = 2 bytes  

SBit1：| a × 3+ b × 4 + # × 1 | c × 5 + # × 3 |

struct SBit2   

    char   : 0;   // 空域   

sizeof(SBit2); // = (3+4+1+5+3) bits = 3 bytes  

SBit2：| a ×3 + # × 5 | b × 4 + # × 4 | c × 5 + # × 3 |

struct SBit3   

    char  a : 3;   

    short b : 4;   

    char  c : 5;   

sizeof(SBit3); // = 6 bytes，由于相邻位域类型不同，在VC6中其sizeof为6，在Dev-C++中为2。  

SBit3（不压缩）：| a ×3 | # ×8 |b × 4 + # ×4 | # ×8 | c ×5 + # ×3 | # ×8 | 

SBit3（压缩）：| a×3 + b ×4 + # ×1 |   c ×5 + # ×3 |

struct SBit4   

    int b : 4;   

    int c;   

sizeof(SBit4); // = 8 bytes  

SBit4：| a×3 + b ×4 + # ×1 | # ×8 | # ×8 | # ×8 | c ×8 | c ×8 | c ×8 | c ×8 |

struct SBit5   

    int b;   

    int c : 5;   

sizeof(SBit5); // = 12 bytes  

SBit5：| a×3 + # ×5 | # ×8 | # ×8 | # ×8 | b ×8 | b ×8 | b ×8 | b ×8 | c ×5 + # ×3 | # ×8 | # ×8 | #×8 |

union U   

    double d;   

sizeof(U); // = Max(sizeof(i), sizeof(c), sizeof(d)) = sizeof(d) = 8