C/C++预处理器相关

预处理执行时间：
编译之前，其处理结果将会被作为独立的文件传至真正的编译器。
预处理功能：
有条件地编译文件的若干部分（由指令#ifdef #ifndef #if #else #elif #endif控制）
替换文本宏（由指令#define #undef # ##控制）
包含其他文件（由指令#include控制）
产生一个警告（由指令#warning控制）
产生一个错误（由指令#error控制）
实现定义的行为（有指令#pragma控制）

文件名和行信息提供给预处理期（由指令#line控制）

#运算符 
出现在宏定义中的#运算符把跟在其后的参数转换成一个字符串。有时把这种用法的#称为字符串化运算符。例如：
#definePASTE(n)"adhfkj"#n

main()
{
printf("%s/n",PASTE(15));
}
宏定义中的#运算符告诉预处理程序，把源代码中任何传递给该宏的参数转换成一个字符串。所以输出应该是adhfkj15。

##运算符 

##运算符用于把参数连接到一起。预处理程序把出现在##两侧的参数合并成一个符号。看下面的例子：

#defineNUM(a,b,c)a##b##c
#defineSTR(a,b,c)a##b##c
main()
{
printf("%d/n",NUM(1,2,3));
printf("%s/n",STR("aa","bb","cc"));
}
最后程序的输出为:
123
aabbcc

 

符合ANSI的预定义宏：

 

__DATE__ ：表示当前源文件编译时的日期，格式为：月/天/年（Mmm dd yyyy）。

__FILE__ ：表示当前正在处理的源文件名称。

__LINE__ ：表示当前正在处理的源文件的行，可以用#line指令修改。

__STDC__ ：表示是ANSI C标准。只有在编译器选项指定了/Za，并且不是编译C++程序时，被定义为常整数1；否则未定义。

__TIME__ ：表示当前源文件的最近编译时的时间，格式为：小时/分/秒（hh:mm:ss）。

__TIMESTAMP__ ：表示当前源文件的最近修改日期和时间，格式为：Ddd Mmm dd hh:mm:ss yyyy，其中Ddd是星期的缩写。

 

Microsoft相关的宏 ：

 

_ATL_VER ：定义了ATL的版本。

_CHAR_UNSIGNED ：设置默认的char类型是unsigned的。只有在编译器选项/J指定时才有定义。

__CLR_VER ：指定了应用程序编译时的通用语言运行时（CLR）的版本。格式为：Mmmbbbbb，其中M是CLR的主版本，mm是CLR的次版本，bbbbb是build号。

__cplusplus_cli ：只有在用/clr，/clr:pure或/clr:safe编译时才有定义。__cplusplus_cli的值是200406。

__COUNTER__ ：为一个整数，从0开始，每出现一次，其值增加1。可以使用__COUNTER__作为前缀来产生唯一的名字。

__cplusplus 只有在编译C++程序时才有定义，一般用于区分C程序和C++程序。

_CPPLIB_VER ：在程序中如果包含了任意C++标准库头文件，则_CPPLIB_VER有定义。用于显示正在使用的头文件的版本。

_CPPRTTI ：用于标识编译器是否指定了RTTI。如果编译器选项中设定了/GR（打开运行时类型信息机制-RTTI），则_CPPRTTI有定义。

_CPPUNWIND ：用于标识编译器是否打开异常处理。如果编译器选项中设定了/GX，则_CPPRTTI有定义。

_DEBUG ：用于标识是Debug模式。在编译器指定了/LDd，/MDd或/MTd时才有定义。

_DLL ：当编译器选项指定了/MD或/MDd（Multithread DLL）时才有定义。

__FUNCDNAME__ ：只有在函数内部才有效。返回该函数经编译器修饰后的名字。如果编译器选项中设定了/EP或/P，则__FUNCDNAME__是未定义。

__FUNCSIG__ ：只有在函数内部才有效，并且返回该函数的签名。一个函数的签名由函数名、参数列表、返回类型、内含的命名空间组成。如果它是一个成员函数，它的类名和const/volatile限定符也将是签名的一部分。在64位操作系统中，__cdecl是默认的函数调用方式。如果编译器选项中设定了/EP或/P，则__FUNCSIG__是未定义。

__FUNCTION__ ：只有在函数内部才有效。返回该函数未经修饰的名字。如果编译器选项中设定了/EP或/P，则__FUNCTION__是未定义。

_INTEGRAL_MAX_BITS ：表示整数类型的最大位数（bits）。

_M_ALPHA ：为DEC ALPHA平台定义。（现在已不支持）

_M_CEE ：当使用/clr的任意形式(/clr:oldSyntax, 例如/clr:safe)编译时被定义。

_M_CEE_PURE ：当使用/clr:pure编译时被定义。

_M_CEE_SAFE ：当使用/clr:safe编译时被定义。

_M_IX86 ：为x86处理器架构定义。当值为300时说明是80386，值是400时说明是80486

_M_IA64 ：为Itanium处理器家族的64位处理器（IA64）架构定义。

_M_IX86_FP ：表示编译器选项/arch的值。0：/arch未指定；1：指定/arch:SSE；2：指定/arch:SSE2

_M_MPPC ：为Power Macintosh平台定义。（现在已不支持）

_M_MRX000 ：为MIPS平台定义。（现在已不支持）

_M_PPC ：为PowerPC平台定义。（现在已不支持）

_M_X64 ：为x64处理器架构定义。 

_MANAGED ：当编译器选项指定/clr时定义，其值为1。

_MFC_VER ：指定MFC版本。例如：0x0700表示MFC version 7。

_MSC_BUILD ：表示编译器版本号的修订号部分。修订号是以时期进行分割的版本号的第四部分。例如：如果VC++编译器的版本号是15.00.20706.01，则_MSC_BUILD的值为1。

_MSC_EXTENSIONS ：当指定编译器选项/Ze（默认）时有定义，其值为1。

_MSC_FULL_VER ：表示编译器的主，次版本号及build号。主版本号是整个版本号的第一部分，次版本号是整个版本号的第二部分，build号是整个版本号的第三部分。例如： 如果VC++编译器的版本号是15.00.20706.01，则_MSC_FULL_VER的值为150020706。可以在命令行键入cl /?来查看编译器的版本号。

_MSC_VER ：表示编译器的主，次版本号。例如： 如果VC++编译器的版本号是15.00.20706.01，则_MSC_VER的值为1500。

__MSVC_RUNTIME_CHECKS ：当指定编译器选项/RTC之一（/RTCs或/RTCu或/RTC1）时有定义。

_MT ：当指定编译器选项/MD或/MDd(Multithreaded DLL)或/MT或/MTd(Multithreaded)时有定义。

_NATIVE_WCHAR_T_DEFINED ：当指定编译器选项/Zc:wchar_t（将wchar_t视为内置类型）时有定义。

_OPENMP ：当指定编译器选项/openmp时有定义，返回一个表示Visual C++中的OpenMP的日期的整数。

_VC_NODEFAULTLIB ：当指定编译器选项/Zl（忽略默认库名）时有定义。

_WCHAR_T_DEFINED ：当指定编译器选项/Zc:wchar_t或工程中包含的系统头文件中定义了wchar_t时有定义。

_WIN32 ：为Win32和Win64应用程序定义。总有定义。

_WIN64 ：为Win64应用程序定义。

_Wp64 ：当指定编译器选项/Wp64时有定义。

 

#pragma  预处理指令详解

   详细信息可查看http://msdn.microsoft.com/en-us/library/7f0aews7.aspx
   在所有的预处理指令中，#pragma 指令可能是最复杂的了，它的作用是设定编译器的状态或者是指示编译器完成一些特定的动作。

#pragma 指令对每个编译器给出了一个方法,在保持与 C 和 C++ 语言完全兼容的情况下,给出主机或操作系统专有的特征。
依据定义,编译指示是机器或操作系统专有的,且对于每个编译器都是不同的。  

    其格式一般为: #pragma  para  
    其中 para 为参数，下面来看一些常用的参数。  
 

(1)message 参数

    message 参数是我最喜欢的一个参数，它能够在编译信息输出窗口中输出相应的信息，
这对于源代码信息的控制是非常重要的。

其使用方法为：
  
    #pragma  message （" 消息文本 " ）   

    当编译器遇到这条指令时就在编译输出窗口中将消息文本打印出来。
  
    当我们在程序中定义了许多宏来控制源代码版本的时候，我们自己有可能都会忘记有没有正确的设置这些宏，
此时我们可以用这条指令在编译的时候就进行检查。假设我们希望判断自己有没有在源代码的什么地方定义了 _X86 这个宏,

可以用下面的方法:

    #ifdef  _X86  
    #pragma  message("_X86  macro  activated!")  
    #endif 
 
    我们定义了 _X86 这个宏以后，应用程序在编译时就会在编译输出窗口里显示 " _86  macro  activated! "。

我们就不会因为不记得自己定义的一些特定的宏而抓耳挠腮了。  
      

(2)另一个使用得比较多的 pragma 参数是 code_seg 

    格式如： 
 
    #pragma  code_seg( ["section-name" [, "section-class"] ] )  

    它能够设置程序中函数代码存放的代码段，当我们开发驱动程序的时候就会使用到它。 

    用法：

Example

---

Copy

// pragma_directive_code_seg.cpp
void func1() {                  // stored in .text
}

#pragma code_seg(".my_data1")
void func2() {                  // stored in my_data1
}

#pragma code_seg(push, r1, ".my_data2")
void func3() {                  // stored in my_data2
}

#pragma code_seg(pop, r1)      // stored in my_data1
void func4() {
}

int main() {
}
    

    相类似还有pragma 参数 data_seg

    格式 #pragma data_seg([ {push|pop,}[identifier,]]["section_name"[,"section_class"]])

    #pragma data_seg 用法：

1，#pragma data_seg()一般用于DLL中。也就是说，在DLL中定义一个共享的，有名字的数据段。最关键的是：这个数据段中的全局变量可以被多个进程共享。否则多个进程之间无法共享DLL中的全局变量。

2，共享数据必须初始化，否则微软编译器会把没有初始化的数据放到.BSS段中，从而导致多个进程之间的共享行为失败。

3，你所谓的结果正确是一种错觉。如果你在一个DLL中这么写：

#pragma data_seg("MyData")

int g_Value; // Note that the global is not initialized.

#pragma data_seg()

DLL提供两个接口函数：

int GetValue()
{
     return g_Value;
}

void SetValue(int n)
{
     g_Value = n;
}

然后启动两个进程A和B，A和B都调用了这个DLL，假如A调用了SetValue(5); B接着调用int m = GetValue();那么m的值不一定是5，而是一个未定义的值。因为DLL中的全局数据对于每一个调用它的进程而言，是私有的，不能共享的。假如你对g_Value进行了初始化，那么g_Value就一定会被放进MyData段中。换句话说，如果A调用了SetValue(5); B接着调用int m = GetValue();那么m的值就一定是5！这就实现了跨进程之间的数据通信！

此外还有 #pragma const_seg ,用法与#pragma data_seg 相似。

 

(3)#pragma once  ( 比较常用 )  

    只要在头文件的最开始加入这条指令就能够保证头文件被编译一次，这条指令实际上在 VC6 中就已经有了，
但是考虑到兼容性并没有太多的使用它。 

       
(4)#pragma  hdrstop 

    表示预编译头文件到此为止，后面的头文件不进行预编译。BCB 可以预编译头文件以加快链接的速度，
但如果所有头文件都进行预编译又可能占太多磁盘空间，所以使用这个选项排除一些头文件。 
   
    有时单元之间有依赖关系，比如单元 A 依赖单元 B，所以单元B要先于单元 A 编译。

你可以用 #pragma  startup 指定编译优先级，如果使用了 #pragma  package(smart_init)，
 BCB 就会根据优先级的大小先后编译。   

       
(5)#pragma  resource  "*.dfm" 

    表示把 *.dfm 文件中的资源加入工程。*.dfm 中包括窗体  
外观的定义。   

         
(6)#pragma  warning( disable: 4507 34; once: 4385; error: 164 )
  
    等价于：  
  
    #pragma  warning( disable: 4507 34 )    //  不显示 4507 和 34 号警告信息  
    #pragma  warning( once: 4385 )          //  4385 号警告信息仅报告一次  
    #pragma  warning( error: 164 )          //  把 164 号警告信息作为一个错误。 

    同时这个 pragma  warning  也支持如下格式：  

    #pragma  warning( push [, n ] )  
    #pragma  warning( pop )  

    这里 n 代表一个警告等级 (1---4)。
  
    #pragma  warning( push )保存所有警告信息的现有的警告状态。  
    #pragma  warning( push, n )保存所有警告信息的现有的警告状态，并且把全局警告等级设定为 n。    
    #pragma  warning( pop )向栈中弹出最后一个警告信息，在入栈和出栈之间所作的一切改动取消。

例如：  
    #pragma  warning( push )  
    #pragma  warning( disable: 4705 )  
    #pragma  warning( disable: 4706 )  
    #pragma  warning( disable: 4707 )  
    //.......  
    #pragma  warning(  pop  )   
 
    在这段代码的最后，重新保存所有的警告信息( 包括 4705，4706 和 4707 )。 

(7)#pragma  comment(...)  

    该指令将一个注释记录放入一个对象文件或可执行文件中。  

    常用的 lib 关键字，可以帮我们连入一个库文件。

例如：
    #pragma  comment(lib, "comctl32.lib")
    #pragma  comment(lib, "vfw32.lib")
    #pragma  comment(lib, "wsock32.lib")
 
    #pragma comment：
该指令将一个注释记录放入一个对象文件或可执行文件中。

该指令的格式为：
        #pragma comment( "comment-type" [, commentstring] )

comment-type(注释类型)：可以指定为以下五种预定义的标识符的其中一种。
1、compiler
    将编译器的版本号和名称放入目标文件中,本条注释记录将被编译器忽略。
    如果你为该记录类型提供了commentstring参数,编译器将会产生一个警告。
    例如:#pragma comment( compiler )
2、exestr
   将commentstring参数放入目标文件中,在链接的时候这个字符串将被放入到可执行文件中。
   当操作系统加载可执行文件的时候,该参数字符串不会被加载到内存中.但是,该字符串可以被dumpbin之类的程序查找出并打印出来,你可以用这个标识符将版本号码之类的信息嵌入到可执行文件中!
3、lib
   这是一个非常常用的关键字,用来将一个库文件链接到目标文件中。
   例如: #pragma comment(lib, "user32.lib")
            该指令用来将user32.lib库文件加入到本工程中。
4、linker
   将一个链接选项放入目标文件中,你可以使用这个指令来代替由命令行传入的或者在开发环境中设置的链接选项。
你可以指定/include选项来强制包含某个对象。
   #pragma comment(linker,"/include:__mySymbol")

你可以在程序中设置下列连接选项：
/DEFAULTLIB
/EXPORT
/INCLUDE
/MANIFESTDEPENDENCY
/MERGE
/SECTION
/NODEFAULTLIB
  
又如：
#pragma comment(linker,"/nodefaultlib:LIBC.lib")
该与指令是用来忽略特定库的，解决诸如LINK : fatal error LNK1104: 无法打开文件“LIBC.lib”的编译错误。


   
每个编译程序可以用 #pragma 指令激活或终止该编译程序支持的一些编译功能。 

例如，对循环优化功能： 

#pragma  loop_opt(on)     //  激活  
#pragma  loop_opt(off)    //  终止 

补充 —— #pragma pack 与 内存对齐问题

    许多实际的计算机系统对基本类型数据在内存中存放的位置有限制，它们会要求这些数据的首地址的值是某个数 k
( 通常它为 4 或 8 ) 的倍数，这就是所谓的内存对齐，而这个 k 则被称为该数据类型的对齐模数( alignment modulus )。

    Win32 平台下的微软 C 编译器( cl.exe for 80x86 )在默认情况下采用如下的对齐规则: 
    任何基本数据类型T的对齐模数就是 T 的大小，即 sizeof(T)。比如对于 double 类型( 8 字节 )，
就要求该类型数据的地址总是 8 的倍数，而 char 类型数据( 1 字节 )则可以从任何一个地址开始。 

    Linux 下的 GCC 奉行的是另外一套规则( 在资料中查得，并未验证，如错误请指正 ):

    任何 2 字节大小( 包括单字节吗? )的数据类型(比如 short )的对齐模数是 2，而其它所有超过 2 字节的数据类型
( 比如long,double )都以 4 为对齐模数。 

    ANSI C 规定一种结构类型的大小是它所有字段的大小以及字段之间或字段尾部的填充区大小之和。

填充区就是为了使结构体字段满足内存对齐要求而额外分配给结构体的空间。那么结构体本身有什么对齐要求吗？

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

如何使用 c/c++ 中的对齐选项 

    vc6 中的编译选项有 /Zp[1|2|4|8|16] ，/Zp1 表示以 1 字节边界对齐，相应的，/Zpn 表示以 n 字节边界对齐。
n 字节边界对齐的意思是说，一个成员的地址必须安排在成员的尺寸的整数倍地址上或者是 n 的整数倍地址上，取它们中的最小值。

也就是：

    min ( sizeof ( member ),  n)

    实际上，1 字节边界对齐也就表示了结构成员之间没有空洞。

    /Zpn 选项是应用于整个工程的，影响所有的参与编译的结构。

    要使用这个选项，可以在 vc6 中打开工程属性页，c/c++ 页，选择 Code Generation 分类，在Struct member alignment 可以选择。 

    要专门针对某些结构定义使用对齐选项，可以使用 #pragma pack 编译指令:

(1) #pragma  pack( [ n ] ) 

    该指令指定结构和联合成员的紧凑对齐。而一个完整的转换单元的结构和联合的紧凑对齐由 /Zp 选项设置。

紧凑对齐用 pack 编译指示在数据说明层设置。该编译指示在其出现后的第一个结构或联合说明处生效。

该编译指示对定义无效。

    当你使用 #pragma  pack ( n ) 时, 这里 n 为1、2、4、8 或 16。
    第一个结构成员之后的每个结构成员都被存储在更小的成员类型或 n 字节界限内。

如果你使用无参量的 #pragma  pack, 结构成员被紧凑为以 /Zp 指定的值。该缺省 /Zp 紧凑值为 /Zp8 。

(2) 编译器也支持以下增强型语法:

    #pragma  pack( [ [ { push | pop } , ] [ identifier, ] ] [ n] ) 

    若不同的组件使用 pack 编译指示指定不同的紧凑对齐, 这个语法允许你把程序组件组合为一个单独的转换单元。
带 push 参量的 pack 编译指示的每次出现将当前的紧凑对齐存储到一个内部编译器堆栈中。

    编译指示的参量表从左到右读取。如果你使用 push, 则当前紧凑值被存储起来; 

如果你给出一个n 的值, 该值将成为新的紧凑值。若你指定一个标识符, 即你选定一个名称, 
则该标识符将和这个新的的紧凑值联系起来。 

    带一个 pop 参量的 pack 编译指示的每次出现都会检索内部编译器堆栈顶的值, 并且使该值为新的紧凑对齐值。
如果你使用 pop 参量且内部编译器堆栈是空的,则紧凑值为命令行给定的值, 并且将产生一个警告信息。

若你使用 pop 且指定一个 n 的值, 该值将成为新的紧凑值。若你使用 pop 且指定一个标识符, 

所有存储在堆栈中的值将从栈中删除, 直到找到一个匹配的标识符, 这个与标识符相关的紧凑值也从栈中移出, 

并且这个仅在标识符入栈之前存在的紧凑值成为新的紧凑值。如果未找到匹配的标识符,

将使用命令行设置的紧凑值, 并且将产生一个一级警告。缺省紧凑对齐为 8 。
 

   pack 编译指示的新的增强功能让你编写头文件, 确保在遇到该头文件的前后的
紧凑值是一样的。

(3) 栈内存对齐 

    在 vc6 中栈的对齐方式不受结构成员对齐选项的影响。它总是保持对齐，而且对齐在 4 字节边界上。

 

关于内存对齐问题：

 

lsj注：（1）这里我先说几个关键点：enum都是int类型存储的。enum state{a,b,c,d,e};此时sizeof(state)=4，同时对界也是int类型对界的。

       （2）Union内部需要对界的。

Union u{

char str[13];

        int a;

}

sizefo(u) = 16，说明内部进行了一个对界，并且按照最大的类型int来进行对界。

这里两个注解看不懂，先跳过后再回头看。

1、内存对界原理

         在C语言中，结构是一种复合数据类型，其构成元素既可以是基本数据类型（如int、long、float等）的变量，也可以是一些复合数据类型（如数组、结构、联合等）的数据单元。在结构中，编译器为结构的每个成员按其自然对界（alignment）条件分配空间。各个成员按照它们被声明的顺序在内存中顺序存储，第一个成员的地址和整个结构的地址相同。

[html] view plain copy print ?

1. struct{  
2.          char x1;  
3.          short x2;  
4.          doule x3;  
5.          char x4;  
6.          short x5;  
7. };  

struct{
         char x1;
         short x2;
         doule x3;
         char x4;
         short x5;
};

内存地址分配如下图：

 

 

x1为结构体的第一个成员，其地址和整个结构的地址相同，因而其偏移地址为0。

x2为short类型，其大小为2，因而其自然对界也为2，所以其偏移地址必须为2的整数倍，所以编译器在x2和x1之间添充了1个空字节。这样，x2的偏移地址为2。（注意这里说的是便宜地址）

x3为double类型，其大小为8，因而其自然对界也为8，所以其偏移地址必须是8的整数倍，所以编译器在x3和x2之间添充了4个空字节。这样，x3的偏移地址为8。

同理，可以算出x4的偏移地址为16，紧跟着x3存储。x5的偏移地址为18。

最后，由于结构整体长度的计算必须取所用过的所有对齐参数的整数倍，不够补空字节；也就是取所用过的所有对齐参数中最大的那个值的整数倍，因为对齐参数都是2的n次方；这样在处理数组时可以保证每一项都边界对齐；

由于x3要求8字节对界，是该结构所有成员中要求的最大对界单元，因而整个结构struct1的自然对界条件为8字节（注意不是该结构的总大小），所以该结构的大小必须满足8的整数倍，这就要求在x5之后还要再添充4个字节，使整个结构体的大小为24字节。

 

为什么要对界？

         需要字节对齐的根本原因在于CPU访问数据的效率问题。假设上面整型变量的地址不是自然对齐，比如为0x00000002，则CPU如果取它的值的话需要访问两次内存，第一次取从0x00000002-0x00000003的一个short，第二次取从0x00000004-0x00000005的一个short然后组合得到所要的数据，如果变量在0x00000003地址上的话则要访问三次内存，第一次为char，第二次为short，第三次为char，然后组合得到整型数据。而如果变量在自然对齐位置上，则只要一次就可以取出数据。一些系统对对齐要求非常严格，比如sparc系统，如果取未对齐的数据会发生错误。

2、更改C编译器的缺省字节对齐方式

这里有三点很重要:
        （1）每个成员分别按自己的方式对齐,并能最小化长度
        （2）复杂类型(如结构)的默认对齐方式是它最长的成员的对齐方式,这样在成员是复杂类型时,可以最小化长度
        （3）对齐后的长度必须是成员中最大的对齐参数的整数倍,这样在处理数组时可以保证每一项都边界对齐

        补充一下,对于数组,比如:
             char a[3];这种,它的对齐方式和分别写3个char是一样的.也就是说它还是按1个字节对齐.
             如果写: typedef char Array3[3];
             Array3这种类型的对齐方式还是按1个字节对齐,而不是按它的长度.
            不论类型是什么,对齐的边界一定是1,2,4,8,16,32,64....中的一个.

例子：

#pragma pack(4)

typedef struct

{

    char buf[3];

    word a;

}kk;
//去掉对齐方式声明
#pragma pack() 

对齐的原则是min(sizeof(word ),4)=2,因此是2字节对齐，而不是我们认为的4字节对齐。

 

语法：
#pragma pack( [show] | [push | pop] [, identifier], n )

说明：
       （1）pack提供数据声明级别的控制，对定义不起作用；
       （2）调用pack时不指定参数，n将被设成默认值；
       （3）一旦改变数据类型的alignment，直接效果就是占用memory的减少，但是performance会下降；

 

语法具体分析：
       （1）show：可选参数；显示当前packing aligment的字节数，以warning message的形式被显示；
       （2）push：可选参数；将当前指定的packing alignment数值进行压栈操作，这里的栈是the internal compiler stack，同时设置当前的packing alignment为n；如果n没有指定，则将当前的packing alignment数值压栈；
       （3）pop：可选参数；从internal compiler stack中删除最顶端的record；如果没有指定n，则当前栈顶record即为新的packing alignment数值；如果指定了n，则n将成为新的packing aligment数值；如果指定了identifier，则internal compiler stack中的record都将被pop直到identifier被找到，然后pop出identitier，同时设置packing alignment数值为当前栈顶的record；如果指定的identifier并不存在于internal compiler stack，则pop操作被忽略；
      （4）identifier：可选参数；当同push一起使用时，赋予当前被压入栈中的record一个名称；当同pop一起使用时，从internal compiler stack中pop出所有的record直到identifier被pop出，如果identifier没有被找到，则忽略pop操作；
      （5）n：可选参数；指定packing的数值，以字节为单位；缺省数值是8，合法的数值分别是1、2、4、8、16。

 

注：默认对齐方式为8

 

更改c编译器的缺省字节对齐方式：
在缺省情况下，c编译器为每一个变量或数据单元按其自然对界条件分配空间；一般地可以通过下面的两种方法来改变缺省的对界条件：
方法一：
使用#pragma pack(n)，指定c编译器按照n个字节对齐；
使用#pragma pack()，取消自定义字节对齐方式。

方法二：
__attribute(aligned(n))，让所作用的数据成员对齐在n字节的自然边界上；如果结构中有成员的长度大于n，则按照最大成员的长度来对齐；
__attribute((packed))，取消结构在编译过程中的优化对齐，按照实际占用字节数进行对齐。

重要的规则：

        （1）复杂类型中各个成员按照它们被声明的顺序在内存中顺序存储，第一个成员的地址和整个类型的地址相同；
        （2）每个成员分别对齐，即每个成员按自己的方式对齐，并最小化长度；规则就是每个成员按其类型的对齐参数（通常是这个类型的大小）和指定对齐参数中较小的一个对齐；
        （3）结构、联合或者类的数据成员，第一个放在偏移为0的地方；以后每个数据成员的对齐，按照#pragma pack指定的数值和这个数据成员自身长度两个中比较小的那个进行；也就是说，当#pragma pack指定的值等于或者超过所有数据成员长度的时候，这个指定值的大小将不产生任何效果；
       （4）复杂类型（如结构）整体的对齐是按照结构体中长度最大的数据成员和#pragma pack指定值之间较小的那个值进行；这样在成员是复杂类型时，可以最小化长度；
       （5）结构整体长度的计算必须取所用过的所有对齐参数的整数倍，不够补空字节；也就是取所用过的所有对齐参数中最大的那个值的整数倍，因为对齐参数都是2的n次方；这样在处理数组时可以保证每一项都边界对齐；

 

3、例子说明

例子1：

  

#pragma pack(4)
class TestB
{
public:
int aa; //第一个成员，放在[0,3]偏移的位置，
　　char a; //第二个成员，自身长为1，#pragma pack(4),取小值，也就是1，所以这个成员按一字节对齐，放在偏移[4]的位置。
　　short b; //第三个成员，自身长2，#pragma pack(4)，取2，按2字节对齐，所以放在偏移[6,7]的位置。
　　char c; //第四个，自身长为1，放在[8]的位置。
};
可见，此类实际占用的内存空间是9个字节。根据规则5，结构整体的对齐是min( sizeof( int ), pack_value ) = 4，所以sizeof( TestB ) = 12;

例子2：

#pragma pack(2)
class TestB
{
public:
int aa; //第一个成员，放在[0,3]偏移的位置，
　　char a; //第二个成员，自身长为1，#pragma pack(4),取小值，也就是1，所以这个成员按一字节对齐，放在偏移[4]的位置。
　　short b; //第三个成员，自身长2，#pragma pack(4)，取2，按2字节对齐，所以放在偏移[6,7]的位置。
　　char c; //第四个，自身长为1，放在[8]的位置。
};
可见结果与例子一相同，各个成员的位置没有改变，但是此时结构整体的对齐是min( sizeof( int ), pack_value ) = 2，所以sizeof( TestB ) = 10；

例子3：

  

#pragma pack(4)
class TestC
{
public:
char a; //第一个成员，放在[0]偏移的位置，
　　short b; //第二个成员，自身长2，#pragma pack(4)，取2，按2字节对齐，所以放在偏移[2,3]的位置。
　　char c; //第三个，自身长为1，放在[4]的位置。
};
整个类的实际内存消耗是5个字节，整体按照min( sizeof( short ), 4 ) = 2对齐，所以结果是sizeof( TestC ) = 6；

例子4：

struct Test
{
char x1; //第一个成员，放在[0]位置，
short x2; //第二个成员，自身长度为2，按2字节对齐，所以放在偏移[2,3]的位置，
float x3; //第三个成员，自身长度为4，按4字节对齐，所以放在偏移[4,7]的位置，
char x4; //第四个陈冠，自身长度为1，按1字节对齐，所以放在偏移[8]的位置，
};
所以整个结构体的实际内存消耗是9个字节，但考虑到结构整体的对齐是4个字节，所以整个结构占用的空间是12个字节。

 

#re: #pragma 预处理命令详解 
#ifdef _X86 
#pragma message("_X86 macro activated!") 
#endif 

和循环优化功能： 

#pragma loop_opt(on) // 激活 
#pragma loop_opt(off) // 终止