#Pragma Pack与内存分配

博客转载自：https://blog.csdn.net/mylinx/article/details/7007309

#pragma pack(n)

解释一：

每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。

规则：

1. 数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。

2. 结构(或联合)的整体对齐规则：在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐，对齐将按照#pragma pack指定的数值和结构(或联合)最大数据成员长度中，比较小的那个进行。

解释二：

n 字节的对齐方式 VC 对结构的存储的特殊处理确实提高 CPU 存储变量的速度，但是有时候也带来了一些麻烦，我们也屏蔽掉变量默认的对齐方式，自己可以设定变量的对齐方式。 VC 中提供了#pragma pack(n)来设定变量以 n 字节对齐方式。n 字节对齐就是说变量存放的起始地址的偏移量有两种情况：

第一、如果 n 大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式。

第二、如果 n 小于该变量的类型所占用的字节数，那么偏移量为 n 的倍数，不用满足默认的对齐方式。结构的总大小也有个约束条件，分下面两种情况：如果 n 大于所有成员变量类型所占用的字节数，那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数；否则必须为 n 的倍数。

举例说明#pragma pack(push)

#pragma pack(4)//设定为 4 字节对齐
struct test { char m1; double m4; int m3; }; 
#pragma pack(pop)//恢复对齐状态 以上结构体的大小为 16：

下面分析其存储情况，首先为 m1 分配空间，其偏移量为 0，满足我们自己设定的对齐方式（4 字节对齐），m1 大小为 1 个字节。接着开始为 m4 分配空间，这时其偏移量为 1，需要补足 3 个字节，这样使偏移量满足为 n=4 的倍数（因为 sizeof(double)大于 4）,m4 占用 8 个字节。接着为 m3 分配空间，这时其偏移量为 12，满足为 4 的倍数，m3 占用 4 个字节。这时已经为所有成员变量分配了空间，共分配了 16 个字节，满足为 n 的倍数。如果把上面的#pragma pack(4)改为 #pragma pack(8)，那么我们可以得到结构的大小为 24。

查看下列更多例子

#pragma pack(4)

struct node{

  int e;
  char f;
  short int a;
  char b;

};
struct node n;
printf("%d
",sizeof(n));

自己计算结果是16，但是结果是12

然后结构体内部数据成员变动一下位置：

#pragma pack(4)
struct node{

  char f;
  int e;
  short int a;
  char b;};

struct node n;
printf("%d
",sizeof(n));

计算结果依然是12

将对齐位数强制定位2

#pragma pack(2)
struct node{

  char f;
  int e;
  short int a;
  char b;};

struct node n;
printf("%d
",sizeof(n));

计算结果依然是10

将对齐位数强制定位1

#pragma pack(1)
struct node{

  char f;
  int e;
  short int a;
  char b;};

struct node n;
printf("%d
",sizeof(n));

计算结果是8

其实之所以有内存字节对齐机制，就是为了最大限度的减少内存读取次数。我们知道CPU读取速度比内存读取速度快至少一个数量级，所以为了节省运算花费时间，只能以牺牲空间来换取时间了。

下面举例说明如何最大限度的减少读取次数

#pragma pack(1)
struct node{

  char f;
  int e;
  short int a;
  char b;};

struct node n;
printf("%d
",sizeof(n));

这里强制按照1字节进行对齐，可以理解成所有的内容都是按照1字节进行读取（暂且这样理解，因为这样可以很好的理解内存对其机制），其他所有的数据成员都是1字节的整数倍，所以也就不用进行内存对其，各个成员在内存中就按照实际顺序进行排列，结构体实际长度为8.

#pragma pack(2)
struct node{

  char f;
  int e;
  short int a;
  char b;};

struct node n;
printf("%d
",sizeof(n));

这里强制按照2字节进行对齐。如果内存分布仍然是连续的话，那么int e就得三次才能读到CPU中，所以为了“讲究”int e的读取，所以在char f之后预留1BYTE，最后的char b也是如此，所以长度为10。

#pragma pack(4)
struct node{

  char f;
  int e;
  short int a;
  char b;};
struct node n;
printf("%d
",sizeof(n));

这里强制按照4字节进行对齐。所以char f后要预留3BYTE，而short int a 和 char b可以一次读取到CPU(按照4字节读取)，所以长度为12。

如果#pramga pack(n)中的n大于结构体成员中任何一个成员所占用的字节数，则该n值无效。编译器会选取结构体中最大数据成员的字节数为基准进行对其分配内存数量

#pragma pack (n)             作用：C编译器将按照n个字节对齐。
#pragma pack ()              作用：取消自定义字节对齐方式。

#pragma  pack (push,1)       作用：是指把原来对齐方式设置压栈，并设新的对齐方式设置为1个字节对齐
#pragma pack(pop)            作用：恢复对齐状态

因此可见，加入push和pop可以使对齐恢复到原来状态，而不是编译器默认，可以说后者更优，但是很多时候两者差别不大

#pragma pack(push) //保存当前对齐状态
#pragma pack(4)//设定为4字节对齐
相当于 #pragma  pack (push,4)

举例子

#pragma pack(1)
struct sample
{
char a;
double b;
};
#pragma pack()

注：若不用#pragma pack(1)和#pragma pack()括起来，则sample按编译器默认方式对齐（成员中size最大的那个）。即按8字节（double）对齐，则sizeof(sample)==16.成员char a占了8个字节（其中7个是空字节）；若用#pragma pack(1)，则sample按1字节方式对齐sizeof(sample)＝＝9.（无空字节），比较节省空间啦，有些场和还可使结构体更易于控制。

应用实例

在网络协议编程中，经常会处理不同协议的数据报文。一种方法是通过指针偏移的方法来得到各种信息，但这样做不仅编程复杂，而且一旦协议有变化，程序修改起来也比较麻烦。在了解了编译器对结构空间的分配原则之后，我们完全可以利用这一特性定义自己的协议结构，通过访问结构的成员来获取各种信息。这样做，不仅简化了编程，而且即使协议发生变化，我们也只需修改协议结构的定义即可，其它程序无需修改，省时省力。下面以TCP协议首部为例，说明如何定义协议结构。其协议结构定义如下：

#pragma pack(1) // 按照1字节方式进行对齐
struct TCPHEADER 
{
     short SrcPort; // 16位源端口号
     short DstPort; // 16位目的端口号
     int SerialNo; // 32位序列号
     int AckNo; // 32位确认号
     unsigned char HaderLen : 4; // 4位首部长度
     unsigned char Reserved1 : 4; // 保留6位中的4位
     unsigned char Reserved2 : 2; // 保留6位中的2位
     unsigned char URG : 1;
     unsigned char ACK : 1;
     unsigned char PSH : 1;
     unsigned char RST : 1;
     unsigned char SYN : 1;
     unsigned char FIN : 1;
     short WindowSize; // 16位窗口大小
     short TcpChkSum; // 16位TCP检验和
     short UrgentPointer; // 16位紧急指针
}; 
#pragma pack()