VC中预处理指令与宏定义的妙用
刚接触到MFC编程的人往往会被MFC 向导生成的各种宏定义和预处理指令所吓倒，但是预处理和宏定义又是C语言的一个强大工具。使用它们可以进行简单的源代码控制，版本控制，预警或者完成一些特殊的功能。
一个经典的例子
使用预处理与宏定义最经典的例子莫过于加在一个头文件中以避免头文件被两次编译。试想这种的情况，有一个文件headerfile.h 它被包含在headerfile1.h中，同时在headerfile2.h 中也被包含了，现在有一个CPP文件，implement.cpp 包含了headerfile1.h 和headerfile2.h：
| #include “headerfile1.h” #include “headerfile2.h” |
假设headerfile.h 中定义了一个全局变量 iglobal 。
| int iglobal; |
在编译的时候编译器两次编译headerfile，也就会发现iglobal被定义了两次，这时就会发生变量重定义的编译错误。
传统的解决办法是使用#ifdef 以及#endif 来避免头文件的重复编译，在上面的例子中，只需要加上这么几行：
| #ifndef smartnose_2002_6_21_headerfile_h #define smartnose_2002_6_21_headerfile_h int iglobal; #endif |
仔细的考虑上面的宏定义，会发现当编译器编译过一次headerfile.h以后，smartnose_2002_6_21_headerfile_h 这个宏就被定义了，以后对headerfile.h的编译都会跳过int iglobal 这一行。当然smartnose_2002_6_21_headerfile_h 这个宏是可以任意定义的，但是这个宏本身不能和其它文件中定义的宏重复，所以MFC在自动生成的文件中总是使用一个随机产生的长度非常长的宏，但我觉得这没有必要，我建议在这个宏中加入一些有意义的信息，比方作者，文件名，文件创建时间等等，因为我们有时候会忘记在注释中加入这些信息。
在VC.Net 中我们不会再看见这些宏定义了，因为在这里会普遍使用一个预处理指令：
| #pragma once |
只要在头文件的最开始加入这条指令就能够保证头文件被编译一次，这条指令实际上在VC6中就已经有了，但是考虑到兼容性并没有太多的使用它。
源代码版本控制
当我们为许多平台开发多个版本的时候预编译指令和宏定义也能够帮我们的忙。假设我们现在为WINDOWS 和LINUX开发了一套软件，由于这两种系统的不同，我们不得不在程序控制源代码的版本。比方内存的分配，我们可以在LINUX上使用标准C的malloc 函数，但是我们希望在 WINDOWS上使用HeapAlloc API。下面的代码演示了这种情况：
| main() { ……………….. #ifdef _WINDOWS_PLATFORM HeapAlloc(5); #else malloc(5); #endif ……………….. } |
当我们在WINDOWS 平台上编译此程序的时候，只需要定义_WINDOWS_PLATFORM这个宏，那么HeapAlloc这条语句就能够起作用了。这样就能够让我们在同一个文件中为不同的平台实现不同版本的代码，同时保持程序的良好结构。在许多情况下，我们还可以为一个方法使用不同的算法，然后用宏定义来针对不同的情况选择其中的一个进行编译。这在MFC应用程序中是使用得最多的。最明显的就是文件中经常存在的
| #ifdef _DEBUG
…………………….some code……….. #endif |
这样的代码，这些代码在应用程序的调试版（DEBUG）中会发挥其作用。
#Pragma 指令
在所有的预处理指令中，#Pragma 指令可能是最复杂的了，它的作用是设定编译器的状态或者是指示编译器完成一些特定的动作。其格式一般为
#Pragma Para
其中Para 为参数，下面来看一些常用的参数。
message 参数。 Message 参数是我最喜欢的一个参数，它能够在编译信息输出窗口中输出相应的信息，这对于源代码信息的控制是非常重要的。其使用方法为：
#Pragma message(“消息文本”)
当编译器遇到这条指令时就在编译输出窗口中将消息文本打印出来。
当我们在程序中定义了许多宏来控制源代码版本的时候，我们自己有可能都会忘记有没有正确的设置这些宏，此时我们可以用这条指令在编译的时候就进行检查。假设我们希望判断自己有没有在源代码的什么地方定义了_X86这个宏可以用下面的方法
| #ifdef _X86
#Pragma message(“_X86 macro activated!”) #endif |
当我们定义了_X86这个宏以后，应用程序在编译时就会在编译输出窗口里显示“_X86 macro activated!”。我们就不会因为不记得自己定义的一些特定的宏而抓耳挠腮了。
另一个使用得比较多的pragma参数是code_seg。格式如：
| #pragma code_seg( ["section-name"[,"section-class"] ] ) |
它能够设置程序中函数代码存放的代码段，当我们开发驱动程序的时候就会使用到它。
最后一个比较常用的就是上面所说的#pragma once 指令了。
VC预定义的宏
在VC中有一类宏并不是由用户用#define语句定义的，而是编译器本身就能够识别它们。这些宏的作用也是相当大的。让我们来看第一个，也是MFC中使用得最频繁的一个:__FILE__ 。
当编译器遇到这个宏时就把它展开成当前被编译文件的文件名。好了，我们马上就可以想到可以用它来做什么，当应用程序发生错误时，我们可以报告这个错误发生的程序代码在哪个文件里，比方在文件test.cpp中有这样的代码：
| try { char * p=new(char[10]); } catch(CException *e ) { TRACE(“ there is an error in file: %s\n”,__FILE__); } |
在程序运行的时候，如果内存分配出现了错误，那么在调试窗口中会出现there is an error in file: test.cpp 这句话，当然，我们还可以把这个错误信息显示在别的地方。
如果我们还能够记录错误发生在哪一行就好了，幸运的是，与__FILE__宏定义一样，还有一个宏记录了当前代码所在的行数，这个宏是__LINE__。使用上面的两个宏，我们可以写出一个类似于VC提供的ASSERT语句。下面是方法
| #define MyAssert(x) \ if(!(x)) \ MessageBox(__FILE__,__LINE__,NULL,MB_OK); |
我们在应用程序中可以象使用ASSERT语句一样使用它，在错误发生时，它会弹出一个对话框，其标题和内容告诉了我们错误发生的文件和代码行号，方便我们的调试，这对于不能使用ASSERT语句的项目来说是非常有用的。
除了这两个宏以外，还有记录编译时间的__TIME__，记录日期的__DATE__，以及记录文件修改时间的__TIMESTAMP__宏。
使用这些预定义的宏，我们几乎可以生成和VC能够生成的一样完整的源代码信息报表。
结论
翻开MFC和Linux的源代码，宏定义几乎占据了半边天，消息映射，队列操作，平台移植，版本管理，甚至内核模块的拆卸安装都用宏定义完成。毫不夸张的说，有些文件甚至就只能看见宏定义。所以学习宏定义，熟练的使用宏定义对于学习C语言乃至VC都是非常关键的。
一、标准预定义宏
The standard predefined macros are specified by the relevant language standards, so they are available with all compilers that implement those standards. Older compilers may not provide all of them. Their names all start with double underscores.
__FILE__
This macro expands to the name of the current input file, in the form of a C string constant. This is the path by which the preprocessor opened the file, not the short name specified in #include or as the input file name argument. For example, "/usr/local/include/myheader.h"
is a possible expansion of this macro.
__LINE__
This macro expands to the current input line number, in the form of a decimal integer constant. While we call it a predefined macro, it's a pretty strange macro, since its "definition" changes with each new line of source code.
__FILE__ and __LINE__ are useful in generating an error message to report an inconsistency detected by the program; the message can state the source line at which the inconsistency was detected. For example,
fprintf (stderr, "Internal error: "
"negative string length "
"%d at %s, line %d.",
length, __FILE__, __LINE__);
An #include directive changes the expansions of __FILE__ and __LINE__ to correspond to the included file. At the end of that file, when processing resumes on the input file that contained the #include directive, the expansions of __FILE__ and __LINE__ revert
to the values they had before the #include (but __LINE__ is then incremented by one as processing moves to the line after the #include).
A #line directive changes __LINE__, and may change __FILE__ as well. See Line Control.
C99 introduces __func__, and GCC has provided __FUNCTION__ for a long time. Both of these are strings containing the name of the current function (there are slight semantic differences; see the GCC manual). Neither of them is a macro;
the preprocessor does not know the name of the current function. They tend to be useful in conjunction with __FILE__ and __LINE__, though.
__DATE__
This macro expands to a string constant that describes the date on which the preprocessor is being run. The string constant contains eleven characters and looks like "Feb 12 1996". If the day of the month is less than 10, it is padded with a space on the left.
If GCC cannot determine the current date, it will emit a warning message (once per compilation) and __DATE__ will expand to "??? ?? ????".
__TIME__
This macro expands to a string constant that describes the time at which the preprocessor is being run. The string constant contains eight characters and looks like "23:59:01".
If GCC cannot determine the current time, it will emit a warning message (once per compilation) and __TIME__ will expand to "??:??:??".
__STDC__
In normal operation, this macro expands to the constant 1, to signify that this compiler conforms to ISO Standard C. If GNU CPP is used with a compiler other than GCC, this is not necessarily true; however, the preprocessor always conforms to the standard unless
the -traditional-cpp option is used.
This macro is not defined if the -traditional-cpp option is used.
On some hosts, the system compiler uses a different convention, where __STDC__ is normally 0, but is 1 if the user specifies strict conformance to the C Standard. CPP follows the host convention when processing system header files, but
when processing user files __STDC__ is always 1. This has been reported to cause problems; for instance, some versions of Solaris provide X Windows headers that expect __STDC__ to be either undefined or 1. See Invocation.
__STDC_VERSION__
This macro expands to the C Standard's version number, a long integer constant of the form yyyymmL where yyyy and mm are the year and month of the Standard version. This signifies which version of the C Standard the compiler conforms to. Like __STDC__, this
is not necessarily accurate for the entire implementation, unless GNU CPP is being used with GCC.
The value 199409L signifies the 1989 C standard as amended in 1994, which is the current default; the value 199901L signifies the 1999 revision of the C standard. Support for the 1999 revision is not yet complete.
This macro is not defined if the -traditional-cpp option is used, nor when compiling C++ or Objective-C.
__STDC_HOSTED__
This macro is defined, with value 1, if the compiler's target is a hosted environment. A hosted environment has the complete facilities of the standard C library available.
__cplusplus
This macro is defined when the C++ compiler is in use. You can use __cplusplus to test whether a header is compiled by a C compiler or a C++ compiler. This macro is similar to __STDC_VERSION__, in that it expands to a version number. A fully conforming implementation
of the 1998 C++ standard will define this macro to 199711L. The GNU C++ compiler is not yet fully conforming, so it uses 1 instead. We hope to complete our implementation in the near future.
__OBJC__
This macro is defined, with value 1, when the Objective-C compiler is in use. You can use __OBJC__ to test whether a header is compiled by a C compiler or a Objective-C compiler.
__ASSEMBLER__
This macro is defined with value 1 when preprocessing assembly language.
昨天写代码时需要在代码获取当前编译时间，从而可动态地作为版本信息，因此用到了C标准中的一些预定义的宏。在此将C标准中定义的几个宏一并总结一下：
__DATE__ 进行预处理的日期（“Mmm dd yyyy”形式的字符串文字，如May 27 2006）
__FILE__ 代表当前源代码文件名的字符串文字 ，包含了详细路径，如G:/program/study/c+/test1.c
__LINE__ 代表当前源代码中的行号的整数常量
__TIME__ 源文件编译时间，格式微“hh：mm：ss”，如：09:11:10；
__func__ 当前所在函数名，在编译器的较高版本中支持
__FUNCTION__ 当前所在函数名
对于__FILE__，__LINE__，__func__，__FUNCTION__ 这样的宏，在调试程序时是很有用的，因为你可以很容易的知道程序运行到了哪个文件的那一行，是哪个函数。
而对于__DATE__，__TIME__则可以获取编译时间，如如下代码通过宏获取编译时间，并通过sscanf（）从中获取具体的年月日时分秒数据，可在代码中做相应使用。我的代码中是根据此数据作为版本标识，并依此判断哪个版本新些及是否需要升级。
char * creationDate = __DATE__ ", " __TIME__;
sscanf(creationDate, "%s %d %d, %d:%d:%d", month, &day, &year, &hour, &min, &sec);
预处理命令#pragma和预定义宏--转载
一、C预定义宏
C标准指定了一些预定义宏,编程中常常用到。
__DATE__ 进行预处理的日期
__FILE__ 代表当前源代码文件名的字符串
__LINE__ 代表当前源代码文件中行号的整数常量
__STDC__ 设置为1时,表示该实现遵循C标准
__STDC_HOSTED__ 为本机环境设置为,否则设为0
__STDC_VERSION__ 为C99时设置为199901L
__TIME__ 源文件的编译时间
__func__ C99提供的，为所在函数名的字符串
对于__FILE__，__LINE__，__func__这样的宏，在调试程序时是很有用的，因为你可以很容易的知道程序运行到了哪个文件的那一行，是哪个函数.
例如:
#include
#include
void why_me();
int main()
{
printf( "The file is %s\n", __FILE__ );
printf( "The date is %s\n", __DATE__ );
printf( "The time is %s\n", __TIME__ );
printf("The version is %s\n",__STDC__VERSION__);
printf( "This is line %d\n", __LINE__ );
printf( "This function is %s\n ", __func__ );
why_me();
return 0;
}
void why_me()
{
printf( "This function is %s\n", __func__ );
printf( "This is line %d\n", __LINE__ );
}
二、#line和#error
#line用于重置由__LINE__和__FILE__宏指定的行号和文件名。
用法如下：#line number filename
例如：#line 1000 //将当前行号设置为1000
#line 1000 "lukas.c" //行号设置为1000,文件名设置为lukas.c
#error指令使预处理器发出一条错误消息，该消息包含指令中的文本.这条指令的目的就是在程序崩溃之前能够给出一定的信息。
三、#pragma
在所有的预处理指令中，#Pragma 指令可能是最复杂的了。#pragma的作用是设定编译器的状态或者是指示编译器完成一些特定的动作。#pragma指令对每个编译器给出了一个方法,在保持与C和C++语言完全兼容的情况下,给出主机或操作系统专有的特征。依据定义,编译指示是机器或操作系统专有的,且对于每个编译器都是不同的。
其格式一般为: #Pragma Para
其中Para 为参数，下面来看一些常用的参数。
(1)message 参数。 Message 参数是我最喜欢的一个参数，它能够在编译信息输出窗口中输出相应的信息，这对于源代码信息的控制是非常重要的。其使用方法为：
#Pragma message(“消息文本”)
当编译器遇到这条指令时就在编译输出窗口中将消息文本打印出来。
当我们在程序中定义了许多宏来控制源代码版本的时候，我们自己有可能都会忘记有没有正确的设置这些宏，此时我们可以用这条指令在编译的时候就进行检查。假设我们希望判断自己有没有在源代码的什么地方定义了_X86这个宏可以用下面的方法
#ifdef _X86
#Pragma message(“_X86 macro activated!”)
#endif
当我们定义了_X86这个宏以后，应用程序在编译时就会在编译输出窗口里显示“_
X86 macro activated!”。我们就不会因为不记得自己定义的一些特定的宏而抓耳挠腮了。
(2)另一个使用得比较多的pragma参数是code_seg。格式如：
#pragma code_seg( ["section-name"[,"section-class"] ] )
它能够设置程序中函数代码存放的代码段，当我们开发驱动程序的时候就会使用到它。
(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号警告信息。如果编译时总是出现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关键字，可以帮我们连入一个库文件。
（8）progma pack（n）
指定结构体对齐方式！#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)//恢复对齐状态
为测试该功能，可以使用sizeof（）测试结构体的长度！
在你写dll的时候,因为对于C和C++,编译器会有不同的名字解析规则,所以可以这样用
#ifndef __STDC__
extern "C " void function();
#else
void function();
#endif
__LINE__ 在源代码中插入当前源代码行号
__FILE__ 在源代码中插入当前源代码文件名
__DATE__ 在源代码中插入当前编译日期〔注意和当前系统日期区别开来〕
__TIME__ 在源代码中插入当前编译时间〔注意和当前系统时间区别开来〕
__STDC__ 当要求程序严格遵循ANSIC标准时该标识符被赋值为1。
----------------------------------------------------------------------------
标识符__LINE__和__FILE__通常用来调试程序；标识符__DATE__和__TIME__通常用来在编译后的程序中加入一个时间标志，以区分程序的不同版本；当要求程序严格遵循ANSIC标准时，标识符__STDC__就会被赋值为1；当用C++编译程序编译时，标识符__cplusplus就会被定义。
#include
int main ()
{
printf("该输出行在源程序中的位置：%d\n", __LINE__ );
printf("该程序的文件名为：%s\n", __FILE__ );
printf("当前日期为：%s\n", __DATE__ );
printf("当前时间为：%s\n", __TIME__ );
return 0;
}
#include
void main(void)
{
printf("%d",__LINE__); // Line 5
}
结果为:5
// 标准预定义宏宏.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include
void main(void)
{
printf("%d",__LINE__); // Line 5
}
| 编译器宏使用总结 | |||
|