C程序存储空间布局（二）—— 内存对齐（字节序对齐）

By zieckey (http://blog.chinaunix.net/u/16292/)

本文测试环境是Linux系统，FC7，gcc 版本 4.1.2 20070502

表示方式：
    内存地址                (H)字节内容(L)        
0x0000 0000            B3B2 B1B0
0x0000 0004            B3B2 B1B0
0x0000 0008            B3B2 B1B0
...
...
...

首先看下面的程序：
#include

char g_c1;
short g_s;
char g_c2;
int g_i;

int main(void)
{
    char c1;
    short s;
    char c2;
    int i;
    
    printf("sizeof: char=%d,short=%d,int=%d\n", sizeof(char), sizeof(short), sizeof(int));
    printf(    "Global variable init value is 0: g_c1=%d, g_s=%d, g_c2=%d, g_i=%d\n",     g_c1, g_s, g_c2, g_i);
    printf("Local variable init value is random: c1=%d, s=%d, c2=%d, g_i=%d\n", c1, s, c2, i);
    printf("Global variable： g_c1=%p, g_s=%p, g_c2=%p, g_i=%p\n", &g_c1, &g_s,    &g_c2, &g_i);
    printf("Local variable： c1=%p, s=%p, c2=%p, i=%p\n", &c1, &s, &c2, &i);
    return 0;
}
运行输出：
sizeof: char=1,short=2,int=4
Global variable init value is 0: g_c1=0, g_s=0, g_c2=0, g_i=0
Local variable init value is random: c1=80, s=12276, c2=79, g_i=1096046812
Global variable： g_c1=0x8049944, g_s=0x8049946, g_c2=0x8049948, g_i=0x804994c
Local variable： c1=0xbfe9562f, s=0xbfe9562c, c2=0xbfe9562b, i=0xbfe95624
全局变量由编译器自动初始化为0，局部变量初始化的值是随机的。

下面看变量的内存分配：

全局变量（放在静态数据存储区，全局可见）：

    内存地址                (H)字节内容(L)       
 
g_s 和  g_c1            BBxB 由低位字节开始    ,  g_c1 放置在B0字节， g_s 放置在B3B2两个字节处（g_c1=0x8049944）
0x0804 9944            B3B2 B1B0

g_c2                    xxxB 由低位字节开始    ,  g_c2 放置在B0字节（g_c2=0x8049948）
0x0804 9948            B3B2 B1B0

i                        BBBB    g_i 放置在 B3B2B1B0 四个字节，一个机器字长
0x0804 994c            B3B2 B1B0

内存存放时候有字节序对齐，以32位为准，且在内存中存放的顺序与定义时的顺序一致，即先定义的变量在内存中的低地址，后定义的变量在高地址。
同时，不足四字节的变量，优先放在一个机器字长（4字节）低位。


局部变量（放在栈空间，局部可见）：
    内存地址                (H)字节内容(L)       
 
i                     BBBB    i 放置在 B3B2B1B0 四个字节，一个机器字长
0xbfe9 5624            B3B2 B1B0

c2                       Bxxx 由高位字节开始    ,   c2 放置在B3字节（c2=0xbfe9562b）
0xbfe9 5628            B3B2 B1B0

c1 和  s                BxBB 由高位字节开始    ,  c1 放置在 B3 高位字节，s放在 B1B0 低位字节
0xbfe9 562C            B3B2 B1B0
内存存放时候有字节序对齐（内存对齐），以32位为准，在内存中存放的顺序与定义时的顺序正好相反，即先定义的变量在内存中的高地址，后定义的变量在低地址。
同时，不足四字节的变量，优先放在一个机器字长（4字节）高位。

为什么会有内存对齐

   以下内容节选自《Intel Architecture 32 Manual》。
   字，双字，和四字在自然边界上不需要在内存中对齐。（对字，双字，和四字来说，自然边界分别是偶数地址，可以被4整除的地址，和可以被8整除的地址。）
   无论如何，为了提高程序的性能，数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；然而，对齐的内存访问仅需要一次访问。
   一个字或双字操作数跨越了4字节边界，或者一个四字操作数跨越了8字节边界，被认为是未对齐的，从而需要两次总线周期来访问内存。一个字起始地址是奇数但却没有跨越字边界被认为是对齐的，能够在一个总线周期中被访问。
   某些操作双四字的指令需要内存操作数在自然边界上对齐。如果操作数没有对齐，这些指令将会产生一个通用保护异常（#GP）。双四字的自然边界是能够被 16整除的地址。其他的操作双四字的指令允许未对齐的访问（不会产生通用保护异常），然而，需要额外的内存总线周期来访问内存中未对齐的数据。


下面再看看结构体的内存空间：
#include

struct foo
{
   char c1;
   short s;
   char c2;
   int i;
};

struct bar
{
   char c1;
   char c2;
   short s;
   int i;
};

#pragma pack(1)
struct foo_pack
{
   char c1;
   short s;
   char c2;
   int i;
};
#pragma pack()

int main(void)
{
   struct foo a;
   struct bar b;
   struct foo_pack p;


   printf("struct foo c1=%p, s=%p, c2=%p, i=%p\n", &a.c1,&a.s,&a.c2,&a.i);
   printf("struct bar c1=%p, s=%p, c2=%p, i=%p\n", &b.c1,&b.s,&b.c2,&b.i);
   printf("struct foo_pack c1=%p, s=%p, c2=%p, i=%p\n", &p.c1,&p.s,&p.c2,&p.i);
  
   printf("sizeof foo is %d\n", sizeof(struct foo));
   printf("sizeof bar is %d\n", sizeof(struct bar));
   printf("sizeof foo_pack is %d\n", sizeof(struct foo_pack));
  
   return 0;
}
程序输出：
struct foo c1=0xbfe40dd8, s=0xbfe40dda, c2=0xbfe40ddc, i=0xbfe40de0
struct bar c1=0xbfe40dd0, s=0xbfe40dd2, c2=0xbfe40dd1, i=0xbfe40dd4
struct foo_pack c1=0xbfe40dc8, s=0xbfe40dc9, c2=0xbfe40dcb, i=0xbfe40dcc
sizeof foo is 12
sizeof bar is 8
sizeof foo_pack is 8


   缺省情况下，c/c++编译器默认将结构、栈中的成员数据进行内存对齐。因此，
struct foo
{
    char c1;
    short s;
    char c2;
    int i;
};
printf("struct foo c1=%p, s=%p, c2=%p, i=%p\n", &a.c1,&a.s,&a.c2,&a.i);
的输出为：
struct foo c1=0xbfe675f8, s=0xbfe675fa, c2=0xbfe675fc, i=0xbfe67600
c1、s各占两字节，c2和i各占4字节

编译器将未对齐的成员向后移，将每一个都成员对齐到自然边界上，从而也导致了整个结构的尺寸变大。尽管会牺牲一点空间（成员之间有空洞），但提高了性能。
也正是这个原因，我们不可以断言sizeof(foo) == 8。在这个例子中，sizeof(foo) == 12。

如何避免内存对齐的影响

   那么，能不能既达到提高性能的目的，又能节约一点空间呢？有一点小技巧可以使用。比如我们可以将上面的结构改成：

struct bar
{
   char c1;
   char c2;
   short s;
   int i;
};
   这样一来，每个成员都对齐在其自然边界上，从而避免了编译器自动对齐。在这个例子中，sizeof(bar) == 8。
  
如何使用c/c++中的对齐选项
有3种办法：

1. gcc的编译选项“-fpack-struct”

可以去除struct结构中额外的hole，缺点是，影响应用中所有的struct，包括从其它库中引入的struct结构

2. __attribute__ ((packed)) 声明

struct {char a; double b;} xyz __attribute__ ((packed));

不过这种简单格式的声明只对C有效，在C++中，你必须对struct中的每个成员（size>1）进行这样的声明：

struct {

char a;

double b __attribute__ ((packed));

int c __attribute__ ((packed));

} xyz;

3. 预编译选项 #pragma pack(n)

这里的n是通知编译器对此“pragma”行后出现的所有数据结构（包括stuct/union）采用n字节方式对齐(align)。如果n=1，那么表示全紧凑，struct中不会出现任何占位的hole。如果n是空，表示回复到编译器缺省的设置（一般＝8）

#pragma pack(1)

//此段内所有数据结构全紧凑

#pragma pack()

  比如：

#pragma pack(1)
struct foo_pack
{
   char c1;
   short s;
   char c2;
   int i;
};
#pragma pack()  
这样sizeof(struct foo_pack)=8

参考：

unix环境高级编程第二版p152