编译之前，其处理结果将会被作为独立的文件传至真正的编译器。
预处理功能：
有条件地编译文件的若干部分（由指令#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
在所有的预处理指令中，#pragma 指令可能是最复杂的了，它的作用是设定编译器的状态或者是指示编译器完成一些特定的动作。
#pragma 指令对每个编译器给出了一个方法,在保持与 C 和 C++ 语言完全兼容的情况下,给出主机或操作系统专有的特征。
依据定义,编译指示是机器或操作系统专有的,且对于每个编译器都是不同的。
其格式一般为: #pragma para
其中 para 为参数，下面来看一些常用的参数。
message 参数是我最喜欢的一个参数，它能够在编译信息输出窗口中输出相应的信息，
这对于源代码信息的控制是非常重要的。
其使用方法为：
#pragma message （" 消息文本 " ）
当编译器遇到这条指令时就在编译输出窗口中将消息文本打印出来。
当我们在程序中定义了许多宏来控制源代码版本的时候，我们自己有可能都会忘记有没有正确的设置这些宏，
此时我们可以用这条指令在编译的时候就进行检查。假设我们希望判断自己有没有在源代码的什么地方定义了 _X86 这个宏,
可以用下面的方法:
#pragma message("_X86 macro activated!")
#endif
我们定义了 _X86 这个宏以后，应用程序在编译时就会在编译输出窗口里显示 " _86 macro activated! "。
我们就不会因为不记得自己定义的一些特定的宏而抓耳挠腮了。
格式如：
#pragma code_seg( ["section-name" [, "section-class"] ] )
它能够设置程序中函数代码存放的代码段，当我们开发驱动程序的时候就会使用到它。
Example
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 相似。
但是考虑到兼容性并没有太多的使用它。
(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( 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 )。
任何基本数据类型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)
/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 。
紧凑值是一样的。
(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）条件分配空间。各个成员按照它们被声明的顺序在内存中顺序存储，第一个成员的地址和整个结构的地址相同。
- struct{
- char x1;
- short x2;
- doule x3;
- char x4;
- short x5;
- };
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....中的一个.例子：
对齐的原则是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：
例子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：
#re: #pragma 预处理命令详解
#ifdef _X86
#pragma message("_X86 macro activated!")
#endif
和循环优化功能：
#pragma loop_opt(on) // 激活
#pragma loop_opt(off) // 终止
422
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
