学步园

sizeof（）功能：计算数据空间的字节数

    1.与strlen（）比较

    strlen（）计算字符数组的字符数，以"/0"为结束判断，不计算为'/0'的数组元素。

    而sizeof计算数据（包括数组、变量、类型、结构体等）所占内存空间，用字节数表示。

    2.指针与静态数组(代表数组的变量)的sizeof操作

    指针均可看为变量类型的一种。所有指针变量的sizeof 操作结果均为4.

    注意：int *p； sizeof（p）=4；

    但sizeof（*p）相当于sizeof（int）；

    对于静态数组，sizeof可直接计算数组大小；

    例：int a[10]；char b[]="hello"；

    sizeof（a）等于4*10=40；

    sizeof（b）等于6；

    注意：数组名做型参时，数组名称只能当作指针使用！！

    void  fun（char p[]）

    {sizeof（p）等于4}

    经典问题：

    double* （*a）[3][6]；

    cout<<sizeof（a）<<endl； // 4 a为指针

    cout<<sizeof（*a）<<endl； // 72 *a为一个有3*6个指针元素的数组

    cout<<sizeof（**a）<<endl； // 24 **a为数组一维的6个指针

    cout<<sizeof（***a）<<endl； // 4 ***a为一维的第一个指针

    cout<<sizeof（****a）<<endl； // 8 ****a为一个double变量

    问题解析：a是一个很奇怪的定义，他表示一个指向维度为[3][6]元素为double * 数组的指针。既然是指针，所以sizeof（a）就是4.

         既然a是执行double*[3][6]类型的指针，*a就表示一个double*[3][6]的多维数组类型，因此sizeof（*a）=3*6*sizeof(double*)=72.同样的，double*[3][6]实际上可以看成一个指针,指向所代表数组的起始元素,由前可知,*a指向一个类型为double* [6]的数据,那么**a就表示一个double*[6]类型的数组，所以sizeof（**a）=6*sizeof  （double*）=24.***a就表示其中的一个元素，也就是double*了，所以sizeof（***a）=4.至于****a，就是一个double了，所以sizeof（****a）=sizeof（double）=8.

    3.格式的写法

    sizeof操作符，对变量或对象可以不加括号，但若是类型，须加括号。

    4.使用sizeof时string的注意事项

    string s="hello"；

    sizeof（s）等于string类的大小，sizeof（s.c_str（））得到的是与字符串长度。

    5.union 与struct的空间计算

    总体上遵循两个原则：

    （1）整体空间是 占用空间最大的成员（的类型）所占字节数的整倍数

    （2）数据对齐原则——内存按结构成员的先后顺序排列，当排到该成员变量时，其距离结构体起始的偏移量必须是该成员类型大小的整倍数，如果不够则补齐，以此向后类推……
             也就是说各成员变量存放的起始地址相对于结构体的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。
      (3)构成的新类型的对齐方式是空间最大的成员的对齐方式

      (4)注意：因为数组按照单个变量一个一个的摆放，所以就不是看成整体。他的对齐方式是她的元素对齐方式
      (5)如果成员中有自定义的类、结构体，也要注意数组问题。

    类型对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量） 
    Char 
    偏移量必须为sizeof(char)即1的倍数 
    int 
    偏移量必须为sizeof(int)即4的倍数 
    float 
    偏移量必须为sizeof(float)即4的倍数 
    double 
    偏移量必须为sizeof(double)即8的倍数 
    Short 
    偏移量必须为sizeof(short)即2的倍数 
    各成员变量在存放的时候根据在结构中出现的顺序依次申请空间，同时按照上面的对齐方式调整位置，空缺的字节会自动填充。同时为了确保结构的大小为结构的字节边界基数（即该结构中占用最大空间的类型所占用的字节数）的倍数，所以在为最后一个成员变量申请空间后，还会根据需要自动填充空缺的字节。 

    因为对齐问题使结构体的sizeof变得比较复杂，看下面的例子：（默认对齐方式下）

struct s1<br /> {<br /> char a;<br /> double b;<br /> int c;<br /> char d;<br /> };<br /> struct s2<br /> {<br /> char a;<br /> char b;<br /> int c;<br /> double d;<br /> };<br /> cout<<sizeof(s1)<<endl; // 24<br /> cout<<sizeof(s2)<<endl; // 16 

同样是两个char类型，一个int类型，一个double类型，但是因为对齐问题，导致他们的大小不同。计算结构体大小可以采用元素摆放法，我举例子说明一下：首先，CPU判断结构体的边界基数，根据上一节的结论，s1和s2的边界基数都取最大的元素类型，也就是double类型的sizeof(double)=8.然后开始摆放每个元素。

    对于s1，因为0是任何类型大小的倍数，所以都从0开始,先放一个sizeof(char)=1的a变量,此时下一个空闲的地址是1，但是下一个元素d是double类型，sizeof(double)=8 ，需要补足7个字节才能使距离结构开始偏移量变为8(满足对齐方式），因此自动填充7个字节，d存放在偏移量为8 的地址上，它占用8个字节。 此时下一个空闲地址变成了16，下一个元素c的大小是4，16可以满足，所以c放在了16，此时下一个空闲地址变成了20，下一个元素d大小是1，所以距离结构任何偏移量都满足，结构体在地址21处结束。由于s1的大小需要是边界基数8的倍数，所以21-23的空间被空白填上，s1的大小变成了24.

    对于s2，首先把a放到0处，此时下一个空闲地址是1，下一个元素的大小也是1，所以b摆放在1，下一个空闲地址变成了2；下一个元素c的大小是4，要取离最近的大于2并且是4倍数的位置来摆放c，就是4了,放下c后下一个空闲地址变成了8，下一个元素d的大小是8，所以d摆放在偏移量为8的地方，所有元素摆放完毕，结构体在16处结束，占用总空间为16，正好是8的倍数。

    这里有个陷阱，对于结构体中的结构体成员，不要认为它的对齐方式就是他的大小，看下面的例子：

struct s1<br /> {<br /> char a[8];<br /> };<br /> struct s2<br /> {<br /> double d;<br /> };<br /> struct s3<br /> {<br /> s1 s;<br /> char a;<br /> };<br /> struct s4<br /> {<br /> s2 s;<br /> char a;<br /> };<br /> cout<<sizeof(s1)<<endl; // 8<br /> cout<<sizeof(s2)<<endl; // 8<br /> cout<<sizeof(s3)<<endl; // 9<br /> cout<<sizeof(s4)<<endl; // 16; 

s1和s2大小虽然都是8，但最终导致了在s3和s4中才有占用空间大小的差异。这是因为他们的边界基数不一样所致.
        s3中占用空间最大的成员是s1,虽然他的大小为1,但他的对齐方式是1的倍数,这是因为s1是由一个数组构成,数组是他唯一在自然也是他最大的成员,所以数组的对齐方式就是s1的对齐方式,如前所述,数组的对齐方式是元素的对齐方式,所以综上所述,s1的对齐方式居然是数组元素的对齐方式.
        s4的边界基数由其占用最大的s2来决定的,s2的对齐方式自然是他唯一成员double所决定.所以s4的边界基数为8,大小就该是16.
       所以，在自己定义结构体的时候，如果空间紧张的话，最好考虑对齐因素来排列结构体里的元素,最好不要让double干扰你的位域.
       总结下,计算结构的大小,要考虑到这几个指标:一个结构的边界基数,二是成员的对齐方式,以及成员的大小:
占用空间最大的成员的对齐方式自然是结构的边界基数;
如果成员也是结构的话,那么对齐方式不是其大小,而是他的最大的成员的对齐方式,
如果成员是数组的话,那么对齐方式是元素的对齐方式.

    在结构体和类中，可以使用位域来规定某个成员所能占用的空间，所以使用位域能在一定程度上节省结构体占用的空间。不过考虑下面的代码：

struct s1<br /> {<br /> 　int i: 8;<br /> 　int j: 4;<br /> 　double b;<br /> 　int a:3;<br /> };<br /> struct s2<br /> {<br /> 　int i;<br /> 　int j;<br /> 　double b;<br /> 　int a;<br /> };<br /> struct s3<br /> {<br /> 　int i;<br /> 　int j;<br /> 　int a;<br /> 　double b;<br /> };<br /> struct s4<br /> {<br /> 　int i: 8;<br /> 　int j: 4;<br /> 　int a:3;<br /> 　double b;<br /> };<br /> cout<<sizeof(s1)<<endl; // 24<br /> cout<<sizeof(s2)<<endl; // 24<br /> cout<<sizeof(s3)<<endl; // 24<br /> cout<<sizeof(s4)<<endl; // 16 

可以看到，有double存在会干涉到位域（sizeof的算法参考上一节），所以使用位域的的时候，最好把float类型和double类型放在程序的开始或者最后。

    相关常数：

    sizeof int：4

    sizeof short：2

    sizeof long：4

    sizeof float：4

    sizeof double：8

    sizeof char：1

    sizeof p：4

    sizeof WORD：2

    sizeof DWORD：4