sizeof的用法

PART 1： 几个例子

第一个例子：

char* ss = "0123456789"; 
sizeof(ss) 结果 4 ＝＝＝》ss是指向字符串常量的字符指针 
sizeof(*ss) 结果 1 ＝＝＝》*ss是第一个字符 
 
char ss[] = "0123456789"; 
sizeof(ss) 结果 11 ＝＝＝》ss是数组，计算到\0位置，因此是10＋1 
sizeof(*ss) 结果 1 ＝＝＝》*ss是第一个字符  

char ss[100] = "0123456789"; 
sizeof(ss) 结果是100 ＝＝＝》ss表示在内存中的大小 100×1 
strlen(ss) 结果是10 ＝＝＝》strlen是个函数内部实现是用一个循环计算到\0为止之前
 
int ss[100] = "0123456789";
sizeof(ss) 结果 400 ＝＝＝》ss表示再内存中的大小 100×4 
strlen(ss) 错误 ＝＝＝》strlen的参数只能是char* 且必须是以''\0''结尾的  

char q[]="abc";
char p[]="a\n"; 
sizeof(q),sizeof(p),strlen(q),strlen(p); 结果是 4 3 3 2 

第二个例子：

class X 
{ 
  inti; 
  int j; 
  char k; 
}; 
X x; cout<<sizeof(X)<<endl; 结果 12 ＝＝＝》内存补齐 
cout<<sizeof(x)<<endl; 结果 12 同上 

sizeof(char *)=4； 
sizeof(int *)=4 
sizeof(double *)=4;  在32位机上，所有的指针都是4字节的   (指针保存地址，为int型）

memcpy(&a[4*sizeof(char)], &usLen, sizeof(char));是什么意思？
将从&usLen 开始 sizeof(char) 大小的内存数据,复制到&a[4*sizeof(char)]  
memcpy (void * ,const void * ,size_t)   
(&a[4*sizeof(char)]表示复制到的地址  &usLen表示从这个地址开始复制  sizeof(char)表示数据长度  
L.elem=(char *)malloc(50*sizeof(char)); 这条语句是什么意思？
elem是类L中的一个成员变量:  char *elem;  给 elem 动态分配50个字符单元，返回char型指针，指向字符单元的首地址。 
 

PART 2： sizeof 计算struct 的大小

字节对齐的细节和编译器实现相关，但一般而言，满足三个准则：
1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）；
3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）

类型
对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量）
Char   偏移量必须为sizeof(char)即1的倍数
int  偏移量必须为sizeof(int)即4的倍数
float  偏移量必须为sizeof(float)即4的倍数
double 偏移量必须为sizeof(double)即8的倍数
Short  偏移量必须为sizeof(short)即2的倍数

简单说明：

struct MyStruct
{
  char dda;     //偏移量为0，满足对齐方式，dda占用1个字节；
  double dda1;  //下一个可用的地址的偏移量为1，不是sizeof(double)=8的倍数，需要补足7个字节才能使偏移量变为8（满足对齐方式）
                //因此VC自动填充7个字节，dda1存放在偏移量为8的地址上，它占用8个节。
  int type;     //下一个可用的地址的偏移量为16，是sizeof(int)=4的倍数，满足int的对齐方式，所以不需要VC自动填充，
                //type存/放在偏移量为16的地址上，它占用4个字节。

}；         
所有成员变量都分配了空间，空间总的大小为1 7 8 4=20，不是结构的节边界数(即结构中占用最大空间的类型所占用的字节数sizeof 字串2(double)=8）的倍数，
所以需要填充4个字节，以满足结构的大小为sizeof(double)=8的倍数。
sizeof(MyStruc)为1 7 8 4 4=24。其中有7 4=11个字节是VC自动填充的，没有放任何有意义的东西。

VC 中提供了 #pragma pack(n)来设定变量以n字节对齐方式。
1) n字节对齐就是说变量存放的起始地址的偏移量有两种情况：
第一、如果n大于等于该变量所占用的字节数，那么偏 移量必须满足默认的对齐方式;
第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足默认的对齐方式。
2) 结构的总大小也有个约束条 件，分下面两种情况：
如果n大于所有成员变量类型所占用的字节数，那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数；否则必须为n的倍数。

下面举例说明其用法。

#pragma pack(push) //保存对齐状态
#pragma pack(4)//设定为4字节对齐
struct test
{
  char m1;
  double m4;
  int m3;
};
#pragma pack(pop)//恢复对齐状态
以上结构的大小为16，
1. 为m1分配空间，其偏移量为0，满足我们自己设定的对齐方式（4字节对齐），m1占用1个字节。
2. 为 m4分配空间，这时其偏移量为1，需要补足3个字节，这样使偏移量满足为n=4的倍数（因为sizeof(double)大于n）,m4占用8个字节。
3. 为m3分配空间，这时其偏移量为12，满足为4的倍数，m3占用4个字节。
这时已经为所有成员变量分配了空间，共分配了16个字节，满足为n的倍数。
如果把上面的#pragma pack(4)改为#pragma pack(16)，那么我们可以得到结构的大小为24。

PART 3： sizeof 计算union的大小

//Union的大小为其内部所有变量的最大值，并且按照类型最大值的整数倍进行内存对齐。
typedef Union
{
  char c[10];
  char cc1;
}u11;//首先按照char c[10]分配10个字节，然后按照char的1个字节对齐，最终sizeof(u11)=10;

typedef union
{
  char c[10];
  int i;
}u22;//首先按照char c[10]分配10个字节，然后按照int的4个字节对齐，最终sizeof(u22)=12;

typedef union
{
  char c[10];
  double d;
}u33;//首先按照char c[10]分配10个字节，然后按照double的4个自己对齐，最终sizeof=16；

union U1 {
  char  c;
  int  i;
  double  d;
} ;按照double的8个字节分配，最终为8；
 
union U3 {
  char  c;
  int  i;
} ;按照int的4个字节分配，最终sizeof为4；

PART 4: 几个练习

struct a
{
    char no[10];
    int p;
    long int pp;
    unsigned int ppp;
    char x;
    float y;
    double h;
}xy;
struct BF1
{
char f1 : 3;
char f2 : 4;
char f3 : 5;
};
struct BF2
{
char f1 : 3;
short f2 : 4;
char f3 : 5;
};
struct b
{
    char i;
    short j:2;
    long k:1;
};
struct B{
    int a;
    double b;
    char c[100];
    long d;
};
typedef struct Test
{
    short  a;
    char   b;
    double c;
    char   d;
    char   e;
    char   f;
    char   g;
}sTest;
void main()
{
    printf("char no:     %d \n",sizeof(xy.no)); //10
    printf("int p:       %d \n",sizeof(xy.p));  //4
    printf("long int pp: %d \n",sizeof(xy.pp)); //8
    printf("unsigned ppp:%d \n",sizeof(xy.ppp));//4
    printf("char x:      %d \n",sizeof(xy.x));  //1
    printf("float y:     %d \n",sizeof(xy.y));  //4
    printf("double h:    %d \n",sizeof(xy.h));  //8
    printf("struct a:    %d \n",sizeof(struct a));
    printf("size of bf1 %d\n",sizeof(struct BF1));
    printf("size of bf2 %d\n",sizeof(struct BF2));
    printf("sizeof b is %d\n",sizeof(struct b));
    printf("sizeof B is %d\n",sizeof(struct B));
    printf("sizeof stest is %d\n",sizeof(sTest));//24
}
注意sizeof(long)的值，我的机子是8，所以所有的值都是以8来算的,如果你的机子值为4，那么下面的有关long的答案都需要作相应的修改。

struct a
{
    char no[10];
    int p;
    long int pp;
    unsigned int ppp;
    char x;
    float y;
    double h;
}xy;
它的值＝10＋2（对齐)+4+8+4+1+3(对齐）+4+8＋4（对齐）＝48
解释：
1，因为int p占用四个字节，而no变量占用10个字节，10并不是4的倍数，所以要加2才能除以4；
2，float x占用4个字节，而float x之前占用了29个字节，29加3才可以除以4，所以要加3；
3，如果不加最后的4，那么一共是44个字节，44必须等被这个结构体里面的最大的数据类型的空间对齐，
最大是long int和double都等于8，所以44＋4才可以除以8，于是最后的值就是48了。

struct B{
    int a;
    double b;
    char c[100];
    long d;
};
sizeof(struct B)=4+4(对齐)+8+100+4(对齐)+8=128;

下面看看有关位域的:
struct BF1
{
char f1 : 3;
char f2 : 4;
char f3 : 5;
};
sizeof(struct BF1)=3+4+5=12bits
大于1个字节小于2个字节，所以只能是分配2个字节了；

struct BF2
{
char f1 : 3;
short f2 : 4;
char f3 : 5;
};
sizeof(struct BF2)=3+4+5=12bits
最后还是2个字节，注意这个值在不同的平台不一样，在VC上等于4个字节；

struct b
{
    char i;
    short j:2;
    long k:1;
};
这个呢？
sizeof(struct b)=8+2+1=11bits
也就是2个字节，但是需要和long对齐，所以结果就是8了；

最后来看看有关几个字符串的:
char *str="0123456";
sizeof(str)=? sizeof(*str)=?  strlen(str)=?   //8，1，7

char str1[]="0123456";
sizeof(str1)=? sizeof(*str1)=? strlen(str1)=? //8，1，7

char str2[10]="0123456";
sizeof(str2)=? sizeof(*str2)=? strlen(str2)=? //10，1，7

参考： 关于#pragma pack ,     关于大端小端