结构体的sizeof
这是初学者问得最多的一个问题,所以这里有必要多费点笔墨。让我们先看一个
结构体:
1
|
structS1{charc;inti;};
|
问sizeof(s1)等于多少聪明的你开始思考了,char占1个字节,int占4个字节,那么加起来就应该是5。是这样吗?你在你机器上试过了吗?也许你是对的,但很可能你是错的!VC6中按默认设置得到的结果为8。
1
|
S1s1={
'a'
,0xFFFFFFFF};
|
定义上面的变量后,加上
断点,运行程序,观察s1所在的内存,你发现了什么
以我的VC6.0为例,s1的地址为0x0012FF78,其数据内容如下:
0012FF78: 61 CC CC CC FF FF FF FF
发现了什么怎么中间夹杂了3个字节的CC看看MSDN上的说明:
When applied to a structure type or variable, sizeof returns the actual size, which may include padding bytes inserted for alignment.
原来如此,这就是传说中的
字节对齐啊!一个重要的话题出现了。
为什么需要字节对齐
计算机组成原理教导我们这样有助于加快计算机的取数速度,否则就得多花
指令周期了。为此,
编译器默认会对
结构体进行处理(实际上其它地方的数据变量也是如此),让宽度为2的基本数据类型(short等)都位于能被2整除的地址上,让宽度为4的基本数据类型(int等)都位于能被4整除的地址上,以此类推。这样,两个数中间就可能需要加入填充字节,所以整个结构体的sizeof值就增长了。
让我们交换一下S1中char与int的位置:
1
|
structS2{inti;charc;};
|
看看sizeof(S2)的结果为多少,怎么还是8再看看内存,原来成员c后面仍然有3个填充字节,这又是为什么啊别着急,下面总结规律。
1)
结构体变量的首地址能够被其最宽基本类型成员的大小所整除;
2)结构体每个成员相对于结构体首地址的
偏移量(offset)都是成员大小的整数倍,如有需要编译器会在成员之间加上填充字节(internal padding);
3)结构体的总大小为结构体最宽基本类型成员大小的整数倍,如有需要编译器会在最末一个成员之后加上填充字节(trailing padding)。
对于上面的准则,有几点需要说明:
1) 前面不是说结构体成员的地址是其大小的整数倍,怎么又说到
偏移量了呢因为有了第1点存在,所以我们就可以只考虑成员的偏移量,这样思考起来简单。想想为什么。
1
|
#defineoffsetof(s,m)(size_t)&(((s*)0)->m)
|
例如,想要获得S2中c的偏移量,方法为
1
|
size_tpos=offsetof(S2,c);
//pos等于4
|
2) 基本类型是指前面提到的像char、short、int、float、double这样的内置数据类型,这里所说的“数据宽度”就是指其sizeof的大小。由于
结构体的成员可以是复合类型,比如另外一个结构体,所以在寻找最宽基本类型成员时,应当包括复合类型成员的子成员,而不是把复合成员看成是一个整体。但在确定复合类型成员的偏移位置时则是将复合类型作为整体看待。
这里叙述起来有点拗口,思考起来也有点挠头,还是让我们看看例子吧(具体数值仍以VC6为例,以后不再说明):
1
|
structS3{charc1;S1s;charc2;};
|
S1的最宽简单成员的类型为int,S3在考虑最宽简单类型成员时是将S1“打散”看的,所以S3的最宽简单类型为int,这样,通过S3定义的变量,其存储空间首地址需要被4整除,整个sizeof(S3)的值也应该被4整除。
c1的
偏移量为0,s的偏移量呢这时s是一个整体,它作为结构体变量也满足前面三个准则,所以其大小为8,偏移量为4,c1与s之间便需要3个填充字节,而c2与s之间就不需要了,所以c2的偏移量为12,算上c2的大小为13,13是不能被4整除的,这样末尾还得补上3个填充字节。最后得到sizeof(S3)的值为16。
通过上面的叙述,我们可以得到一个公式:
1
|
sizeof
(
struct
)=offsetof(lastitem)+
sizeof
(lastitem)+
sizeof
(trailingpadding)
|
到这里,朋友们应该对结构体的sizeof有了一个全新的认识,但不要高兴得太早,有一个影响sizeof的重要参量还未被提及,那便是
编译器的pack指令。它是用来调整结构体对齐方式的,不同编译器名称和用法略有不同,VC6中通过
#pragmapack实现,也可以直接修改/Zp编译开关。#pragmapack的基本用法为:
1
|
#pragmapack(n)
|
该成员的
偏移量应该以此值为准,即是说,结构体成员的偏移量应该取二者的最小值,
公式如下:
1
|
offsetof(item)=min(n,
sizeof
(item))
|
再看示例:
1
2
3
4
5
|
#pragmapack(push)//将当前pack设置压栈保存
#pragmapack(2)//必须在结构体定义之前使用
structS1{charc;inti;};
structS3{charc1;S1s;charc2;};
#pragmapack(pop)//恢复先前的pack设置
|
计算sizeof(S1)时,min(2, sizeof(i))的值为2,所以i的
偏移量为2,加上sizeof(i)等于6,能够被2整除,所以整个S1的大小为6。
同样,对于sizeof(S3),s的偏移量为2,c2的偏移量为8,加上sizeof(c2)等于9,不能被2整除,添加一个填充字节,所以sizeof(S3)等于10。
如今,朋友们可以轻松的出一口气了,:)
还有一点要注意,“空
结构体”(不含
数据成员)的大小不为0,而是1。试想一个“不占空间”的变量如何被取地址、两个不同的“空结构体”变量又如何得以区分呢于是,“空结构体”变量也得被存储,这样
编译器也就只能为其分配一个字节的空间用于占位了。如下:
struct S5 { }; sizeof( S5 ); // 结果为1含位域结构体的sizeof
C99规定int、unsigned int和bool可以作为位域类型,但编译器几乎都对此作了扩展,允许其它类型类型的存在。使用位域的主要目的是压缩存储,其大致规则为:
1) 如果相邻位域字段的类型相同,且其位宽之和小于类型的sizeof大小,则后面的字段将紧邻前一个字段存储,直到不能容纳为止;
4) 如果位域字段之间穿插着非位域字段,则不进行压缩;
5) 整个
结构体的总大小为最宽基本类型成员大小的整数倍。
还是让我们来看看例子。
示例1:
1
|
structBF1{charf1:3;charf2:4;charf3:5;};
|
其内存布局为:
1
2
|
|_f1__|__f2__|_|____f3___|____|
|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
|
0 3 7 8 1316
位域类型为char,第1个字节仅能容纳下f1和f2,所以f2被压缩到第1个字节中,而f3只
能从下一个字节开始。因此sizeof(BF1)的结果为2。
示例2:
1
|
structBF2{charf1:3;shortf2:4;charf3:5;};
|
由于相邻位域类型不同,在VC6中其sizeof为3,在Dev-C++中为2。
示例3:
1
|
structBF3{charf1:3;charf2;charf3:5;};
|
非
位域字段穿插在其中,不会产生压缩,在VC6和Dev-C++中得到的大小均为3。
9.
联合体的sizeof
结构体在内存组织上是顺序式的,联合体则是重叠式,各成员共享一段内存,所以整个联合体的sizeof也就是每个成员sizeof的最大值。结构体的成员也可以是复合类型,这里,复合类型成员是被作为整体考虑的。
所以,下面例子中,U的sizeof值等于sizeof(s)。
1
2
3
4
5
6
|
unionU
{
inti;
charc;
S1s;
};
|
1)在类中,如果什么都没有,则类占用1个字节,一旦类中有其他的占用空间成员,则这1个字节就不在计算之内,如一个类只有一个int则占用4字节而不是5字节。
2)如果只有成员函数,则还是只占用1个字节,因为类函数不占用空间
3)虚函数因为存在一个虚函数表,需要4个字节,数据成员对象如果为指针则为4字节,注意有字节对齐,如果为13字节,则进位到16字节空间。
4)sizeof的本质是得到某个类型的大小,确切的来说就是当创建这个类型的一个对象(或变量)的时候,需要为它分配的空间的大小。而类也可以理解为类似于int、float这样的一种类型,当类中出现static成员变量的时候,static成员变量是存储在静态区当中的,它是一个共享的量,因此,在为这个类创建一个实例对象的时候,是无需再为static成员变量分配空间的,所以,这个类的实例对象所需要分配的空间是要排除static成员变量的,于是,当sizeof计算类的大小的时候会忽略static成员变量的大小.
与strlen区别
strlen(char*)函数求的是字符串的实际长度,直到遇到第一个'\0',然后就返回计数值,且不包括'\0'。
char aa[10];cout<<strlen(aa)<<endl; //结果是不定的,因为未初始化,'\0'在内存中的位置不确定
char aa[10]={'\0'}; cout<<strlen(aa)<<endl; //结果为0
char aa[10]="jun"; cout<<strlen(aa)<<endl; //结果为3
而sizeof()函数返回的是变量声明后所占的内存数,不是实际长度。
sizeof(aa) 返回10 int a[10]; sizeof(a) 返回40
1.sizeof操作符的结果类型是size_t,它在头文件中typedef为unsigned int类型。
该类型保证能容纳实现所建立的最大对象的字节大小。
2.sizeof是算符,strlen是函数。
3.sizeof可以用类型做参数,strlen只能用char*做参数,且必须是以''\0''结尾的。
sizeof还可以用函数做参数,比如:
1
2
|
shortf();
printf
(
"%d\n"
,
sizeof
(f()));
|
输出的结果是sizeof(short),即2。
5.大部分
编译程序在编译的时候就把sizeof计算过了是类型或是变量的长度这就是sizeof(x)可以用来定义数组维数的原因
1
2
3
|
charstr[20]=
"0123456789"
;
inta=
strlen
(str);
//a=10;
intb=
sizeof
(str);
//而b=20;
|
6.strlen的结果要在运行的时候才能计算出来,是用来计算字符串的长度,不是类型占内存的大小。
7.sizeof后如果是类型必须加括弧,如果是变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。
8.当适用于一个结构类型时或变量, sizeof 返回实际的大小,当适用于静态的空间
数组, sizeof 归还全部数组的尺寸。
sizeof 操作符不能返回被动态分派的数组或外部数组的尺寸
9.数组作为参数传给函数时传的是
指针而不是数组,传递的是数组的首地址,
如:
1
|
fun(
char
[8])fun(
char
[])
|
都等价于 fun(char *)
特别注意:
1.sizeof是运算符,strlen是函数,具体如下:
sizeof
strlen
头文件:stddef.h格式:1) sizeof( object ); // sizeof( 对象 );
2) sizeof( type_name ); // sizeof( 类型 );
3) sizeof object; // sizeof 对象
功能:一个对象或者类型所占的内存字节数;
说明:sizeof操作符的结果类型是size_t,typedef unsigned int size_t;
原型:extern unsigned int strlen(char *s);头文件:string.h
格式:strlen (字符数组名)
功能:计算字符串s的(unsigned int型)长度,不包括'\0'在内
说明:返回s的长度,不包括结束符NULL。
2.strlen只能用char*做参数,且必须是以''\0''结尾的,而sizeof可用类型做参数,还可用函数做参数,如:
1
2
|
intsum();
printf
(
"%d\n"
,
sizeof
(sum()));
//输出的结果是sizeof(int),即4。
|
3.数组做sizeof的参数不退化,传递给strlen就退化为指针了。
4.大部分编译程序,sizeof在编译时确定,因此sizeof(x)可以用来定义数组维数;而strlen要在运行时才能计算出来,用来计算字符串的长度,而不是类型占内存的大小;
1
2
3
|
charstr[20]=
"0123456789"
;
intlen1=
strlen
(str);
//len1=10;
intlen2=
sizeof
(str);
//len2=20;
|
5.sizeof后,若为类型必须加括弧,若为变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。
6.当适用于一个结构类型时或变量, sizeof 返回实际的大小;当适用一静态地空间数组,sizeof 归还全部数组的尺寸。
sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸;
7.数组作为参数传给函数时传的是指针而不是数组,传递的是数组的首地址,
如:
6.当适用于一个结构类型时或变量, sizeof 返回实际的大小;当适用一静态地空间数组,sizeof 归还全部数组的尺寸。
sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸;
7.数组作为参数传给函数时传的是指针而不是数组,传递的是数组的首地址,
如:
1
2
|
fun(
char
[8])
fun(
char
[])
|
都等价于 fun( char * )
在C++里参数传递数组永远都是传递指向数组首元素的指针,编译器不知道数组的大小,如果想在函数内知道数组的大小, 需要这样做:
进入函数后用memcpy拷贝出来,长度由另一个形参传进去
在C++里参数传递数组永远都是传递指向数组首元素的指针,编译器不知道数组的大小,如果想在函数内知道数组的大小, 需要这样做:
进入函数后用memcpy拷贝出来,长度由另一个形参传进去
1
2
3
4
5
|
fun(unsigedchar*p1,intlen)
{
unsignedchar*buf=newunsignedchar[len+1];
memcpy
(buf,p1,len);
}
|
常在用到 sizeof 和 strlen 的时候,通常是计算字符串数组的长度,如果是对指针,结果则会不一样的:
char* str = "abacd";
sizeof(str) //结果 4 --->str是指向字符串常量的字符指针,sizeof 获得的是一个指针所占的空间,应该是长整型的,所以是4;
sizeof(*str) //结果 1 --->*str是第一个字符,其实就是字符串的第一位'a' 所占的内存空间,是char类型的,占了 1 位;
strlen(str)= 5 //--->若要获得这个字符串的长度,则一定要使用 strlen
char* str = "abacd";
sizeof(str) //结果 4 --->str是指向字符串常量的字符指针,sizeof 获得的是一个指针所占的空间,应该是长整型的,所以是4;
sizeof(*str) //结果 1 --->*str是第一个字符,其实就是字符串的第一位'a' 所占的内存空间,是char类型的,占了 1 位;
strlen(str)= 5 //--->若要获得这个字符串的长度,则一定要使用 strlen
看了上面的详细解释,发现两者的使用还是有区别的,从这个例子可以看得很清楚:
1
|
charstr[20]=
"0123456789"
;
|
int a=strlen(str); //a=10; >>>> strlen 计算字符串的长度,以结束符 0x00 为字符串结束。
int b=sizeof(str); //而b=20; >>>> sizeof 计算的则是分配的
数组str[20] 所占的内存空间的大小,不受里面存储的内容改变。
char* ss = "0123456789";
sizeof(ss) 结果 4 ===》ss是指向
字符串常量的字符指针,sizeof 获得的是一个指针的之所占的空间,应该是
长整型的,所以是4
sizeof(*ss) 结果 1 ===》*ss是第一个
字符其实就是获得了字符串的第一位'0' 所占的内存空间,是char类
型的,占了 1 个字节
strlen(ss)= 10 >>>> 如果要获得这个字符串的长度,则一定要使用 strlen