1.
先看下面的例子:
struct A{
char c1;
int i;
short s;
int j;
}a;
struct B{
int i;
int j;
short s;
char c1;
}b;
结构A没有遵守字节对齐原则(为了区分,我将它叫做对齐声明原则),结构B遵守了。我们来看看在x86上会出现什么结果。先打印出a和b的各个成员的地址。会看到a中,各个成员间的间距是4个字节。b中,i和j,j和s都间距4个字节,但是s和c1间距2个字节。所以:
sizeof(a) = 16
sizeof(b) = 12
为什么会有这样的结果呢?这就是x86上字节对齐的作用。为了加快程序执行的速度,一些体系结构以对齐的方式设计,通常以字长作为对齐边界。对于一些结构体变量,整个结构要对齐在内部成员变量最大的对齐边界,如B,整个结构以4为对齐边界,所以sizeof(b)为12,而不是11。
对于A来讲,虽然声明的时候没有对齐,但是根据打印出的地址来看,编译器已经自动为其对齐了,所以每个成员的间距是4。在x86下,声明A与B唯一的差别,仅在于A多浪费了4个字节内存。
(是不是某些特定情况下,B比A执行更快,这个还需要讨论。比如紧挨的两条分别取s和c1的指令)
如果体系结构是不对齐的,A中的成员将会一个挨一个存储,从而sizeof(a)为11。显然对齐更浪费了空间。那么为什么要使用对齐呢?
体系结构的对齐和不对齐,是在时间和空间上的一个权衡。对齐节省了时间。假设一个体系结构的字长为w,那么它同时就假设了在这种体系结构上对宽度为w的数据的处理最频繁也是最重要的。它的设计也是从优先提高对w位数据操作的效率来考虑的。比如说读写时,大多数情况下需要读写w位数据,那么数据通道就会是w位。如果所有的数据访问都以w位对齐,那么访问还可以进一步加快,因为需要传输的地址位减少,寻址可以加快。大多数体系结构都是按照字长来对齐访问数据的。不对齐的时候,有的会出错,比如MIPS上会产生bus error,而x86则会进行多次访问来拼接得到的结果,从而降低执行效率。
有些体系结构是必须要求对齐的,如sparc,MIPS。它们在硬件的设计上就强制性的要求对齐。不是因为它们作不到对齐的访问,而是它们认为这样没有意义。它们追求的是速度。
上面讲了体系结构的对齐。在IA-32上面,sizeof(a)为16,就是对齐的结果。下面我们来看,为什么变量声明的时候也要尽量对齐。
我们看到,结构A的声明并不对齐,但是它的成员地址仍是以4为边界对齐的(成员间距为4)。这是编译器的功劳。因为我所用的编译器gcc,默认是对齐的。而x86可以处理不对齐的数据访问,所以这样声明程序并不会出错。但是对于其他结构,只能访问对齐的数据,而编译器又不小心设置了不对齐的选项,则代码就不能执行了。如果按照B的方式声明,则不管编译器是否设置了对齐选项,都能够正确的访问数据。
目前的开发普遍比较重视性能,所以对齐的问题,有三种不同的处理方法:
1)采用B的方式声明
2)对于逻辑上相关的成员变量希望放在靠近的位置,就写成A的方式。有一种做法是显式的插入reserved成员:
struct A{
char c1;
char reserved1[3];
int i;
short s;
char reserved2[2];
int j;
}a;
3)随便怎么写,一切交给编译器自动对齐。
代码中关于对齐的隐患,很多是隐式的。比如在强制类型转换的时候。下面举个例子:
unsigned int ui_1=0x12345678;
unsigned char *p=NULL;
unsigned short *us_1=NULL;
p=&ui_1;
*p=0x00;
us_1=(unsigned short *)(p+1);
*us_1=0x0000;
最后两句代码,从奇数边界去访问unsigned short型变量,显然不符合对齐的规定。在x86上,类似的操作只会影响效率,但是在MIPS或者sparc上,可能就是一个bus error(我没有试)。
有些人喜欢通过移动指针来操作结构中的成员(比如在linux操作struct sk_buff的成员),但是我们看到,A中(&c1+1) 决不等于&i。不过B中(&s+2)就是 &c1了。所以,我们清楚了结构中成员的存放位置,才能编写无错的代码。同时切记,不管对于结构,数组,或者普通的变量,在作强制类型转换时一定要多看看:)不过为了不那么累,还是遵守声明对齐原则吧!(这个原则是说变量尽量声明在它的对齐边界上,而且在节省空间的基础上)
2.C/C++函数调用方式
我们当然早就知道,C/C++中的函数调用,都是以值传递的方式,而不是参数传递。那么,值传递是如何实现的呢?
函数调用前的典型汇编码如下:
push %eax
call 0x401394 <test__Fc>
add $0x10,%esp
首先,入栈的是实参的地址。由于被调函数都是对地址进行操作,所以就能够理解值传递的原理和参数是引用时的情况了。
Call ***, 是要调用函数了,后面的地址,就是函数的入口地址。Call指令等价于:
PUSH IP
JMP ***
首先把当前的执行地址IP压栈,然后跳转到函数执行。
执行完后,被调函数要返回,就要执行RET指令。RET等价于POP IP,恢复CALL之前的执行地址。所以一旦使用CALL指令,堆栈指针SP就会自动减2,因为IP的值进栈了。
函数的参数进栈的顺序是从右到左,这是C与其它语言如pascal的不同之处。函数调用都以以下语句开始:
push %ebp
mov %esp,%ebp
首先保存BP的值,然后将当前的堆栈指针传递给BP。那么现在BP+2就是IP的值(16位register的情况),BP+4放第一个参数的值,BP+6放第二个参数……。函数在结束前,要执行POP BP。
C/C++语言默认的函数调用方式,都是由主调用函数进行参数压栈并且恢复堆栈,实参的压栈顺序是从右到左,最后由主调函数进行堆栈恢复。由于主调用函数管理堆栈,所以可以实现变参函数。
对于WINAPI和CALLBACK函数,在主调用函数中负责压栈,在被调用函数中负责弹出堆栈中的参数,并且负责恢复堆栈。因此不能实现变参函数。
--------------------------------------------------------------------
<span style="font-family:SimSun;font-size:18px;">enum DataType{IntData,CharData,VcharData};
struct Item
{
char ItemNAme[30];
DataType ItemType;
char ItemDecr[50];
int ItemLength;
};</span>
<span style="font-family:SimSun;font-size:18px;">struct s1
{
char a;
long int d;
double c;
};</span>
<span style="font-family:SimSun;font-size:18px;">struct s2
{
char a;
long int d;
double c;
char e;
};</span>
<span style="font-family:SimSun;font-size:18px;">#pragma pack(4) // 这里也可以是#pragma pack(push,4)
struct s1
{
char a;
long int d;
double c;
};
struct s2
{
char a;
long int d;
double c;
char e;
};</span>
<span style="font-family:SimSun;font-size:18px;">#pragma pack(4)
struct TestStruct2
{
char m1[11];
short m2;
};</span>
<span style="font-family:SimSun;font-size:18px;">enum DataType{IntData,CharData,VcharData};
#pragma pack(2)
struct Item
{
char ItemNAme[30];
DataType ItemType;
char ItemDecr[50];
int ItemLength;
};</span>
struct vector{int x,y,z;} s;
int *p,*q,*r;
struct vector *ps;
p = &s.x;
q = &s.y;
r = &s.z;
ps = &s;
assert(p < q);
assert(p < r);
assert(q < r);
assert((int*)ps == p);
// 上述断言一定不会失败
这时,有朋友可能会问:"标准是否规定相邻字段在内存中也相邻?"。 唔,对不起,ANSI C没有做出保证,你的程序在任何时候都不应该依赖这个假设。那这是否意味着我们永远无法勾勒出一幅更清晰更精确的结构体内存布局图?哦,当然不是。不过先让我们从这个问题中暂时抽身,关注一下另一个重要问题————内存对齐。
typedef struct ms1
{
char a;
int b;
}MS1;
+---------------------------+
| | |
| a | b |
| | |
+---------------------------+
1 Byte 4 byte
因为MS1中有最强对齐要求的是b字段(int),所以根据编译器的对齐规则以及ANSI C标准,MS1对象的首地址一定是4(int类型的对齐模数)的倍数。那么上述内存布局中的b字段能满足int类型的对齐要求吗?嗯,当然不能。如果你是编译器,你会如何巧妙安排来满足CPU的癖好呢?呵呵,经过1毫秒的艰苦思考,你一定得出了如下的方案:
_______________________________________
| |\\\\\\\\\\\| |
| a |\\padding\\| b |
| |\\\\\\\\\\\| |
+-------------------------------------+
Bytes: 1 3 4
typedef struct ms2
{
int a;
char b;
}MS2;
或许你认为MS2比MS1的情况要简单,它的布局应该就是
_______________________
| | |
| a | b |
| | |
+---------------------+
Bytes: 4 1
|<- array[1] ->|<- array[2] ->|<- array[3] .....
__________________________________________________________
| | | | |
| a | b | a | b |.............
| | | | |
+----------------------------------------------------------
Bytes: 4 1 4 1
___________________________________
| | |\\\\\\\\\\\|
| a | b |\\padding\\|
| | |\\\\\\\\\\\|
+---------------------------------+
Bytes: 4 1 3
typedef struct ms3
{
char a;
short b;
double c;
}MS3;
|
_____v_________________________________
| |\| |\\\\\\\\\| |
| a |\| b |\padding\| c |
| |\| |\\\\\\\\\| |
+-------------------------------------+
Bytes: 1 1 2 4 8
sizeof(short)等于2,b字段应从偶数地址开始,所以a的后面填充一个字节,而sizeof(double)等于8,c字段要从8倍数地址开始,前面的a、b字段加上填充字节已经有4 bytes,所以b后面再填充4个字节就可以保证c字段的对齐要求了。sizeof(MS3)等于16,b的偏移是2,c的偏移是8。接着看看结构体中字段还是结构类型的情况:
typedef struct ms4
{
char a;
MS3 b;
}MS4;
_______________________________________
| |\\\\\\\\\\\| |
| a |\\padding\\| b |
| |\\\\\\\\\\\| |
+-------------------------------------+
Bytes: 1 7 16
到了这里,我们可以回答本文提出的最后一个问题了。结构体的内存布局依赖于CPU、操作系统、编译器及编译时的对齐选项,而你的程序可能需要运行在多种平台上,你的源代码可能要被不同的人用不同的编译器编译(试想你为别人提供一个开放源码的库),那么除非绝对必需,否则你的程序永远也不要依赖这些诡异的内存布局。顺便说一下,如果一个程序中的两个模块是用不同的对齐选项分别编译的,那么它很可能会产生一些非常微妙的错误。如果你的程序确实有很难理解的行为,不防仔细检查一下各个模块的编译选项。
思考题:请分析下面几种结构体在你的平台上的内存布局,并试着寻找一种合理安排字段声明顺序的方法以尽量节省内存空间。
A. struct P1 { int a; char b; int c; char d; };
B. struct P2 { int a; char b; char c; int d; };
C. struct P3 { short a[3]; char b[3]; };
D. struct P4 { short a[3]; char *b[3]; };
E. struct P5 { struct P2 *a; char b; struct P1 a[2]; };
【1】《深入理解计算机系统(修订版)》,(著)Randal E.Bryant; David O'Hallaron,(译)龚奕利 雷迎春,
中国电力出版社,2004。
【2】《C: A Reference Manual》(影印版),(著)Samuel P.Harbison; Guy L.Steele,人民邮电出版社,2003
-----------------------------------------------------
<span style="font-family:SimSun;font-size:18px;">struct name1
{
char str; // 占用空间:2个字节
short x; // 占用空间:2个字节
int num; // 占用空间:4个字节
double xx; // 占用空间:8个字节
};
struct name2
{
char str; // 占用空间:4个字节
int num; // 占用空间:4个字节
short x; // 占用空间:8个字节
double xx; // 占用空间:8个字节
};</span>
struct name1=16个字节 struct name2=24个字节
大家帮帮忙,解释一下!!!谢谢大家了!
这个很容易得到,他们分别是 1, 2,4,8
通过下面的语句可以确定在你的系统下是多少,一般 intel 32 位是上面提到的结果
printf("sizeof(char)=%d\n",sizeof(char));
32位机器就是按照每32位来对齐,即4字节。
对于结构体中的某一成员item,它相对于结构首地址的实际字节对齐数目X应该满足
以下规则:
X = min(n, sizeof(item)); // n 是编译器设定的最大对齐边界数。
如果n = 8 .
<span style="font-family:SimSun;font-size:18px;">struct name1
{
char str; // 偏移为0 ,从第一个字节位置存储,占1个字节
short x; // 偏移为2 , 从第三个字节位置开始存储,占2个字节
int num; // 偏移为4, 由于前两个占了4个字节,所以从第五个字节开始存储。占4个字节
double xx; // 偏移为8,由于前两个占了8个字节,所以从第9个字节开始存储。占8个字节
};</span>
struct name2
{
char str; // 偏移为0 ,从第一个字节位置存储,占1个字节
int num; // 偏移为4, 由于前两个占了1个字节,所以从第五个字节开始存储。占4个字
short x; // 偏移为2 ,由于前两个占了8个字节 从第九个字节位置开始存储,占2个字节
double xx; // 偏移为8,由于前两个占了10个字节,所以从第17个字节开始存储。占8个字节
};
struct name2
{
char str; // 占用空间:4个字节
int num; // 占用空间:4个字节
short x; // 占用空间:8个字节//楼主这里错了,应该是2个字节
double xx; // 占用空间:8个字节
};
struct name2=24个字节 //加起来是18个字节,但是要是sizeof(double)的倍数,所以为24。
<span style="font-family:SimSun;font-size:18px;">struct name1
{
char str; // 占用空间:2个字节
short x; // 占用空间:2个字节
int num; // 占用空间:4个字节
double xx; // 占用空间:8个字节
};</span>