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 ,
关于大端小端