为什么sizeof(List)为20,多了两个字节?

[dongyi940333]

下面的这个程序的目的是建立一个单链表.开发环境WINDOWSXP+VC6.0

我的问题是这样的:我在调试的时候获取以下的信息:

sizeof(List) 20

sizeof(Head->Number) 4

sizeof(Head->Name) 10

sizeof(Head->Next) 4

Head 0x004300b0

&Head->Number 0x004300b0

&Head->Name 0x004300b4

&Head->Next 0x004300c0


4 + 4 +10 = 18, 为什么sizeof(List)为20,多了两个字节

0x004300c0 - 0x004300b4 = c,而我只定义了10个字符,这里是不是因为在80x86中

双字的低端字节最好在能够被四整除的地址.所以编译器自动得将Name的长度加2.

如果是的话,那么这两个字节的内容是什么?在VC6.0中可不可以改变这个设置?



#include <stdlib.h>

#include <stdio.h>



#define Max 10



struct List
{

int Number;

char Name[ Max ];

struct List *Next;

};



typedef struct List Node;

typedef Node *Link;



//Function declare

Link Create_List( Link Head );



int main()
{

Link Head = NULL;



Head = Create_List( Head );

return 0;

}




Link Create_List( Link Head )
{

int DataNum = 0;

char DataName[ Max ];

Link New;

Link Pointer;

int i = 0;



Head = ( Link )malloc( sizeof( Node ) );



// allocate memory failure

if( Head == NULL )

{

printf( "Memory allocate Failure!!\n" );

}

else

{

DataNum = 1;

printf( "Please input the data name : " );

scanf( "%s", DataName );

Head->Number = DataNum;



for( i = 0; i <= Max; i++ )

{

Head->Name[ i ] = DataName[ i ];

}


Head->Next = NULL;



Pointer = Head;



while( 1 )

{

DataNum++;

New = ( Link )malloc ( sizeof( Node) );



if( New == NULL )

{

printf( "Memory allocate Failure!!\n" );

break;

}



printf( "Please input the data name : " );

scanf( "%s", DataName );



if( DataName[ 0 ] == '0' ) //input the 0 to end input.

{

break;

}



New->Number = DataNum;



for( i = 0; i <= Max; i++ )

{

New->Name[ i ] = DataName[ i ];

}



New->Next = NULL;

Pointer->Next = New;

Pointer = New;

}
}

return Head;
}

[liuyaoyou]

结构体内存对齐，如果是一个short类型，一个char类型，一个int类型的话，在char类型后面补一个字节。也就是说在不连续的大小为奇数个字节的类型变量后补足字节。

[chenzhiyubuaa]

一般情况下，结构体的大小要是最大基本成员的整数倍
那个结构体的最大基本成员是指针4，
所以结构体的大小为4的整数倍，于是就补了2个字节

[ming4098]

内存对齐问题

[land_rover]

属于字节对齐问题 ，是 因为你的结构体里有 int 所以默认将你的对齐位数设为4位，
如果你包含了double那么你的对齐位数将变为8位，也就是说
如果
struct List
{

double Number;

char Name[ Max ];

struct List *Next;

};则结果应是 8+16+4=28位

其实如果你可以通过 定义，自己手动指定对齐位数，如果你想sizeof(list)为18，那么你可以手动指定对其位数为 1,方法是在结构之前指定 #param pack(1）。
其中#param pack(N) 是用来指定对齐方式的，N代表期望对齐位数！

[land_rover]

更正上面
struct List
{

double Number;

char Name[ Max ];

struct List *Next;

}应为24位
原因是：
1:Number占前8位，在没有手动指定对齐方式的情况下（#param pack(N))则以后的对齐方式都为8位.
2:则 Name 占了接下来的第二个 8位字节，和第三个8位的前两个字节，
3:Next 占据了第三个8位的第3~6个字节,因为对其方式为8位，所以第三个8位的7、8两个字节也算在stuct结构占据的内存之内，没有实际意义

顺便说下你的

struct List
{
int Number;
char Name[ Max ];
struct List *Next;
};
为20位的原因应该是这样的:

1:Number占4个字节，以后对其方式都为4位字节，
2:Name占第二个4位字节，第三个4位字节和第4个4位字节的前两位
3:Next占第4个4位字节的后两位和第5个4位字节的前两位。这样，第5个4位字节便剩下了两个没有意义的字节，因为对齐方式位两位，所以该块内存也算在结构体内
如下内存图：
////////////////////////////////////////////
4-------Number

4-------Name前4

4-------Name5~8

2-------Name9~10
2-------Next前2

2-------Next后2
2-------空闲

[jixingzhong]

【转】

内存对齐与 struct型数据的内存布局

当在C中定义了一个结构类型时，它的大小是否等于各字段(field)大小之和？编译器将如何在内存中放置这些字段？ANSI C对结构体的内存布局有什么要求？而我们的程序又能否依赖这种布局？这些问题或许对不少朋友来说还有点模糊，那么本文就试着探究它们背后的秘密。 首先，至少有一点可以肯定，那就是ANSI C保证结构体中各字段在内存中出现的位置是随它们的声明顺序依次递增的，并且第一个字段的首地址等于整个结构体实例的首地址。比如有这样一个结构体：

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没有做出保证，你的程序在任何时候都不应该依赖这个假设。那这是否意味着我们永远无法勾勒出一幅更清晰更精确的结构体内存布局图？哦，当然不是。不过先让我们从这个问题中暂时抽身，关注一下另一个重要问题————内存对齐。

许多实际的计算机系统对基本类型数据在内存中存放的位置有限制，它们会要求这些数据的首地址的值是某个数k(通常它为4或8)的倍数，这就是所谓的内存对齐，而这个k则被称为该数据类型的对齐模数(alignment modulus)。当一种类型S的对齐模数与另一种类型T的对齐模数的比值是大于1的整数，我们就称类型S的对齐要求比T强(严格)，而称T比S弱(宽松)。这种强制的要求一来简化了处理器与内存之间传输系统的设计，二来可以提升读取数据的速度。比如这么一种处理器，它每次读写内存的时候都从某个8倍数的地址开始，一次读出或写入8个字节的数据，假如软件能保证double类型的数据都从8倍数地址开始，那么读或写一个double类型数据就只需要一次内存操作。否则，我们就可能需要两次内存操作才能完成这个动作，因为数据或许恰好横跨在两个符合对齐要求的8字节内存块上。某些处理器在数据不满足对齐要求的情况下可能会出错，但是Intel的IA32架构的处理器则不管数据是否对齐都能正确工作。不过Intel奉劝大家，如果想提升性能，那么所有的程序数据都应该尽可能地对齐。Win32平台下的微软C编译器(cl.exe for 80x86)在默认情况下采用如下的对齐规则: 任何基本数据类型T的对齐模数就是T的大小，即sizeof(T)。比如对于double类型(8字节)，就要求该类型数据的地址总是8的倍数，而char类型数据(1字节)则可以从任何一个地址开始。Linux下的GCC奉行的是另外一套规则(在资料中查得，并未验证，如错误请指正):任何2字节大小(包括单字节吗?)的数据类型(比如short)的对齐模数是2，而其它所有超过2字节的数据类型(比如long,double)都以4为对齐模数。

现在回到我们关心的struct上来。ANSI C规定一种结构类型的大小是它所有字段的大小以及字段之间或字段尾部的填充区大小之和。嗯？填充区？对，这就是为了使结构体字段满足内存对齐要求而额外分配给结构体的空间。那么结构体本身有什么对齐要求吗？有的，ANSI C标准规定结构体类型的对齐要求不能比它所有字段中要求最严格的那个宽松，可以更严格(但此非强制要求，VC7.1就仅仅是让它们一样严格)。我们来看一个例子(以下所有试验的环境是Intel Celeron 2.4G + WIN2000 PRO + vc7.1，内存对齐编译选项是"默认"，即不指定/Zp与/pack选项):
typedef struct ms1
{
char a;
int b;
} MS1;
假设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
这个方案在a与b之间多分配了3个填充(padding)字节，这样当整个struct对象首地址满足4字节的对齐要求时，b字段也一定能满足int型的4字节对齐规定。那么sizeof(MS1)显然就应该是8，而b字段相对于结构体首地址的偏移就是4。非常好理解，对吗？现在我们把MS1中的字段交换一下顺序:
typedef struct ms2
{
int a;
char b;
} MS2;
或许你认为MS2比MS1的情况要简单，它的布局应该就是
_______________________
| | |
| a | b |
| | |
+---------------------+
Bytes: 4 1
因为MS2对象同样要满足4字节对齐规定，而此时a的地址与结构体的首地址相等，所以它一定也是4字节对齐。嗯，分析得有道理，可是却不全面。让我们来考虑一下定义一个MS2类型的数组会出现什么问题。C标准保证，任何类型(包括自定义结构类型)的数组所占空间的大小一定等于一个单独的该类型数据的大小乘以数组元素的个数。换句话说，数组各元素之间不会有空隙。按照上面的方案，一个MS2数组array的布局就是:
|<- array[1] ->|<- array[2] ->|<- array[3] .....
__________________________________________________________
| | | | |
| a | b | a | b |.............
| | | | |
+----------------------------------------------------------
Bytes: 4 1 4 1
当数组首地址是4字节对齐时，array[1].a也是4字节对齐，可是array[2].a呢？array[3].a ....呢？可见这种方案在定义结构体数组时无法让数组中所有元素的字段都满足对齐规定，必须修改成如下形式:
___________________________________
| | |\\\\\\\\\\\|
| a | b |\\padding\\|
| | |\\\\\\\\\\\|
+---------------------------------+
Bytes: 4 1 3
现在无论是定义一个单独的MS2变量还是MS2数组，均能保证所有元素的所有字段都满足对齐规定。那么sizeof(MS2)仍然是8，而a的偏移为0，b的偏移是4。
好的，现在你已经掌握了结构体内存布局的基本准则，尝试分析一个稍微复杂点的类型吧。
typedef struct ms3
{
char a;
short b;
double c;
} MS3;
我想你一定能得出如下正确的布局图:

padding
|
_____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;
MS3中内存要求最严格的字段是c，那么MS3类型数据的对齐模数就与double的一致(为8)，a字段后面应填充7个字节，因此MS4的布局应该是:
_______________________________________
| |\\\\\\\\\\\| |
| a |\\padding\\| b |
| |\\\\\\\\\\\| |
+-------------------------------------+
Bytes: 1 7 16
显然，sizeof(MS4)等于24，b的偏移等于8。
在实际开发中，我们可以通过指定/Zp编译选项来更改编译器的对齐规则。比如指定/Zpn(VC7.1中n可以是1、2、4、8、16)就是告诉编译器最大对齐模数是n。在这种情况下，所有小于等于n字节的基本数据类型的对齐规则与默认的一样，但是大于n个字节的数据类型的对齐模数被限制为n。事实上，VC7.1的默认对齐选项就相当于/Zp8。仔细看看MSDN对这个选项的描述，会发现它郑重告诫了程序员不要在MIPS和Alpha平台上用/Zp1和/Zp2选项，也不要在16位平台上指定/Zp4和/Zp8(想想为什么？)。改变编译器的对齐选项，对照程序运行结果重新分析上面4种结构体的内存布局将是一个很好的复习。

到了这里，我们可以回答本文提出的最后一个问题了。结构体的内存布局依赖于CPU、操作系统、编译器及编译时的对齐选项，而你的程序可能需要运行在多种平台上，你的源代码可能要被不同的人用不同的编译器编译(试想你为别人提供一个开放源码的库)，那么除非绝对必需，否则你的程序永远也不要依赖这些诡异的内存布局。顺便说一下，如果一个程序中的两个模块是用不同的对齐选项分别编译的，那么它很可能会产生一些非常微妙的错误。如果你的程序确实有很难理解的行为，不防仔细检查一下各个模块的编译选项。

[chenyi3315]

内存对齐啊……

[spofmy]

内存对齐

LS说得很清楚了

[lidongri]

内存对齐
LS的LS说的对

[dongyi940333]

to land_rover() :

更正上面
struct List
{

double Number;

char Name[ Max ];

struct List *Next;

}应为24位
原因是：
1:Number占前8位，在没有手动指定对齐方式的情况下（#param pack(N))则以后的对齐方式都为8位.
2:则 Name 占了接下来的第二个 8位字节，和第三个8位的前两个字节，
3:Next 占据了第三个8位的第3~6个字节,因为对其方式为8位，所以第三个8位的7、8两个字节也算在stuct结构占据的内存之内，没有实际意义

我在VC6.0中得到的结果如下:
&dong.Number 0x0012ff68

&dong.Name 0x0012ff70

&dong.Next 0012ff7c

sizeof(dong) 24


按照jixingzhong(瞌睡虫·星辰)所说
Win32平台下的微软C编译器(cl.exe for 80x86)在默认情况下采用如下的对齐规则: 任何基本数据类型T的对齐模数就是T的大小，即sizeof(T)。

那么结构体本身有什么对齐要求吗？有的，ANSI C标准规定结构体类型的对齐要求不能比它所有字段中要求最严格的那个宽松，可以更严格(但此非强制要求，VC7.1就仅仅是让它们一样严格).

它的结果应该是:8+12+4=24,因为sizeof(Next)的大小为4, 所以它的地址应该是4的倍数,而Name的大小为10,所以加2个字节为12是4的倍数.

[dongyi940333]

按照jixingzhong(瞌睡虫·星辰)所说:

在实际开发中，我们可以通过指定/Zp编译选项来更改编译器的对齐规则。比如指定/Zpn(VC7.1中n可以是1、2、4、8、16)就是告诉编译器最大对齐模数是n。在这种情况下，所有小于等于n字节的基本数据类型的对齐规则与默认的一样，但是大于n个字节的数据类型的对齐模数被限制为n。
我试了一下WINDOWS XP+VC6.0

#pragma pack(8)
struct List
{

int i;

double Number;

struct List *Next;

}dong;
#pragma pack()

在#pragma pack(1), #pragma pack(2), #pragma pack(4),sizeof(dong)都为16,
它的原因应该是:但是大于n个字节的数据类型的对齐模数被限制为n。
在#pragma pack(8)时为24,数据如下:
&dong.i 0x0012ff68

&dong.Number 0x0012ff70( 这里所有小于等于n字节的基本数据类型的对齐规则与默认的一样,所以dong.Number的地址为8的倍数,前面的i为4个字节,所以填充4个字节,对不对??? )

&dong.Next 0x0012ff78
我的问题sizeof(dong.Next)的大小为4,它这里为什么成8了?是不是因为这句话:

ANSI C标准规定结构体类型的对齐要求不能比它所有字段中要求最严格的那个宽松，可以更严格

所以结构的首地址应该是8的倍数,而Next刚好是一个指向结构的指针,所以Next加了4个字节

[xlbdan]

内存对齐，边界调整，按最大的数据占用的内存数来做为倍数

可以看 inside the c++ object modal

[jixingzhong]

这里所有小于等于n字节的基本数据类型的对齐规则与默认的一样,所以dong.Number的地址为8的倍数,前面的i为4个字节,所以填充4个字节,对不对???

是的

[jixingzhong]

sizeof(dong.Next)的大小为4,它这里为什么成8了?

不会吧？
即使 是8字节对齐， Next 后面填充了 4个字节，
也不会导致 sizeof(dong.Next)＝8 的，
填充的字节就是被废弃了而已，
不会计算在 sizeof(dong.Next) 之内的。

[winner8080]

做嵌入式经常被考倒内存对齐和位域

[dongyi940333]

to jixingzhong(瞌睡虫·星辰):]

sizeof(dong.Next)的大小为4,它这里为什么成8了?
不会吧？
即使 是8字节对齐， Next 后面填充了 4个字节，
也不会导致 sizeof(dong.Next)＝8 的，
填充的字节就是被废弃了而已，
不会计算在 sizeof(dong.Next) 之内的。


呵呵!是我没有把意思说清楚:sizeof(dong.Next)是4,不是8.

我说的意思是:

sizeof(dong.Next)的大小为4,在
#pragma pack(8)情况下

按照所有小于等于n字节的基本数据类型的对齐规则与默认的一样
那么Next后面不应该再填充4字节了.sizeof(dong)= 8+8+4= 20呀.

[jixingzhong]

#pragma pack(8)
struct List
{
int i;
double Number;
struct List *Next;
}dong;
#pragma pack()

对齐有两个步骤：

1 结构体（或其他）中的每个成员需要对齐在指定的对齐单位上，这个就是 Number需要对齐到8，导致4字节填充；其他的两个成员都正好在对齐边界上，不需要填充，得到的空间是 4+4+8+4＝20 字节。

2 对整个结构体进行对齐。这里就是需要吧 20 对齐到 8（不小于20的最小的一个能被8整除的数值），结果就是24

[jixingzhong]

20 只是对齐了struct 的各个成员得到的结果，

在这个之后，还需要对整个struct进行8对齐！！

[Solomne]

结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节。应该是对应这条

[dongyi940333]

谢谢各位,祝各位万事如意!!!!