http://blog.csdn.net/hgl868/article/details/7058906
替代字符串：
#define DOWNLOAD_IMAGE_LOG /var/log/png.log
#define WGET_IMAGE_(x) "wget -b -c -P ./media/video -a " x " -i mp4url.txt"
WGET_IMAGE_(DOWNLOAD_IMAGE_LOG)就是 wget -b -c -P ./media/video -a /var/log/png.log -i mp4url.txt
C、C++宏体中出现的#，#@，##，
1， #表字符串化（stringfication)，如
#define C(x) #x
C(I am a string) ---> "I am a string"
2, ##表字符串连接（concatenation）
左边的代码可以通过宏字符串连接来简化：
如#define cmd(x) x ## _command
cmd(quit) 就是 quit_command
实用的例子如下：
struct command
{
char *name;
void (*function) (void);
}; struct command commands[] =
{
{ "quit", quit_command },
{ "help", help_command },
...
};
改成如下：
#define COMMAND(NAME) { #NAME, NAME ## _command }
struct command commands[] =
{
COMMAND (quit),
COMMAND (help),
};
下面的代码利用宏字符串化来输出信息：
#define WARN_IF(expr) do{ if(expr) {fprintf(stderr, "warning" #expr "\n");}}while(0)
使用do while的原因是为了让WARN_IF(expr)后面加分号使之看起来更像函数。
- 宏扩展
#include <stdio.h>
#define str(s) #s
#define xstr(s) str(s)
#define foo 4
int main(int argc, char *argv[])
{
printf ("%s\n",str(foo));
printf ("%s\n",xstr(foo));
return 0;
}
# 结果为foo 4
宏展开时先展开里层的宏，但包含#和##的宏不展开，由于str(foo)宏str包含#故foo不展开，而xstr宏中不包含#故foo展开为4，即str(4)再开展str得4
同理可知下面结果为: _G(A,B) AB
#define G(a,b) a##b
#define _G(a,b) G(a,b)
#define S(X) #X
#define _S(X) S(X)
#define A 1
#define B 2
#include<stdio.h>
int main()
{
printf("%s\n",S(_G(A,B)));
printf("%s\n",_S(G(A,B)));
return 0;
}
解释成分段标志，对于每一段和前面比较，相同的就被替换。但是这样做的结果是，
被替换段之间存在一些空格。如果我们不希望出现这些空格，就可以通过添加一些
##来替代空格。
宏定义没有空格，但是依然表达有意义的定义： define add(a, b) a+b
#define A2(name, type) type name##_##type##_type
A2(a1, int); /* 等价于: int a1_int_type; */
1) 在第一个宏定义中，”name”和第一个”_”之间，以及第2个”_”和第二个
”type”之间没有被分隔，所以预处理器会把name_##type##_type解释成3段：
“name_”、“type”、以及“_type”，这中间只有“type”是在宏前面出现过
的，所以它可以被宏替换。
预处理器会把name##_##type##_type解释成4段：“name”、“_”、“type”
以及“_type”，这其间，就有两个可以被宏替换了。
#define A1(name, type) type name_ ##type ##_type
<##前面随意加上一些空格>
#define A2(name, type) type name ##_ ##type ##_type
那么
__stringify_1(linux) <==> ”linux”
2) #define MODULE_GENERIC_TABLE(gtype,name) extern const struct gtype##_id __mod_##gtype##_table
__attribute__ ((unused, alias(__stringify(name))))
MODULE_DEVICE_TABLE(usb, products)
/*notes: struct usb_device_id products; */
<==> MODULE_GENERIC_TABLE(usb_device,products)
<==> extern const struct usb_device_id __mod_usb_device_table
__attribute__ ((unused, alias(”products”)))
给name加上双引号。另外，还注意到一个外部变量”__mod_usb_device_table”被alias
到了本驱动专用的由用户自定义的变量products<usb_device_id类型>。这个外部变量
是如何使用的，更多的信息请参看《probe()过程分析》。
在标准C以及各中编译器中定义了一些对象宏, 这些宏的名称以"__"开头和结尾, 并且都是大写字符. 这些预定义宏可以被#undef, 也可以被重定义。
在ANSI C标准中定义了__FILE__，__LINE__，__DATA__,__TIME__,__STDC__等标准的预定义宏。GCC对其进行扩展，也定义了多个预定义宏。
概括起来GCC中可使用的预定义宏涵盖了如下几方面的信息：
1、宿主的信息：GNU的版本，编译器的版本，类型的相关信息，字节序信息等。
2、编译动作的信息：编译的日期、时间；编译时是否进行了时间或空间上的优化；定义的inline是否被编译器执行等。
3、文件的信息：文件名称、函数名称、行数信息、文件最后修改时间等等。
4、计数信息：__COUNTER__,__INCLUDE_LEVEL__等。
下面是一些常见的预定义宏的使用方法。
1、__FILE__，__LINE__,FUNCTION__
这是最常用到的预定义宏的组合，表示文件名、行数和函数名，用于程序运行期异常的跟踪。如：
//-------file main.c----------
#include <stdio.h>
#include "myassert.h"
int func(const char *filename);
int main(int argc,char **argv)
{
MyAssert("two args are needed",argc==2);
func(argv[1]);
return 0;
}
//-------file func.c----------
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "myassert.h"
int func(const char *filename)
{
int fd;
MyAssert("filename can not be null",filename);
MyAssert("file not exist",0==access(filename,F_OK));
fd = open(filename,O_RDONLY);
close(fd);
return 0;
}
//-------file myassert.h----------
#ifndef __MY_ASSERT_H__
#define __MY_ASSERT_H__
#include <stdio.h>
#include <stdlib.h>
#define MyAssert(message,assertion) do{/
if(!(assertion)){/
printf("line %d in %s(%s)", __LINE__, __FILE__,__FUNCTION__);/
if(message){/
printf(" : %s",message);/
}/
printf("/n");/
abort();/
}/
}while(0);
#endif
#Makefile
TARGET = test
CC = gcc
CCFLAGS = -Wall
OBJS = main.o func.o
$(TARGET) : $(OBJS)
$(CC) -o $@ $(OBJS) $(CCFLAGS)
%.o : %.c
$(CC) -o $@ -c $< $(CCFLAGS)
clean:
rm -rf *.o
rm -rf $(TARGET)
可见通过使用__FILE__，__LINE__,FUNCTION__宏，可以帮助我们精确的定位出现异常的文件、函数和行数。
2、__BASE_FILE__
这个宏是和__FILE__相对应的，表示主输入文件的名字，对于源文件而言__FILE__和__BASE_FILE__是一样的；对于头文件二者才可能不同。比如在上个例子中，__LINE__这个宏是在myassert.h文件中定义的，被main.c和func.c包含之后__FILE__的值
分别变成了main.c和func.c。但是当我们希望知道MyAssert这个宏具体实在哪个文件（实际上是myassert.h）中定义的话，就需要用到__BASE_FILE__。
下面的例子可以帮助加深理解：
//-------file main.c----------
#include <stdio.h>
#include "basefile.h"
int main(int argc, char *argv[])
{
printf("%s/n",sfile);
printf("%s/n",hfile);
return 0;
}
//-------file basefile.h----------
const char sfile[]= __FILE__;
const char hfile[]= __BASE_FILE__;
gcc main.c &&./a.out 得到：
basefile.h
main.c
3、__DATE__,__TIME__
用于得到最后一次编译的日期和时间（字符串形式）：
#include <stdio.h>
//-------file main.c----------
int main()
{
printf("DATE : %s/n",__DATE__);
printf("TIME : %s/n",__TIME__);
}
gcc main.c &&./a.out 得到:
DATE : Jan 27 2011
TIME : 17:12:55
4、__TIMESTAMP__
和__TIME__的格式相同。同于得到本文件最后一次被修改的时间。
5、__GNUC__、__GNUC_MINOR__、__GNUC_MINOR__、__GNUC_PATCHLEVEL__
用于得到GNU版本：
#include <stdio.h>
int main()
{
if( __GNUC__ > 4 ||
(__GNUC__ == 4 && (__GNUC_MINOR__ > 2 ||
(__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ > 0)))){
printf("GNUC version is later than 3.3.2/n");
}else{
printf("GNUC version is older than 3.3.2/n");
}
}
6、__VERSION__
用于得到编译器的版本
//-------file main.c----------
#include <stdio.h>
int main()
{
printf("Version : %s/n",__VERSION__);
return 0;
}
gcc main.c && ./a.out得到：
Version : 4.1.2 (Gentoo 4.1.2 p1.0.2)
可以和gcc -v相互验证
7、__COUNTER__
自身计数器，用于记录以前编译过程中出现的__COUNTER__的次数，从0开始计数。常用于构造一系列的变量名称，函数名称等。如：
//-------file main.c----------
#include <stdio.h>
#define FUNC2(x,y) x##y
#define FUNC1(x,y) FUNC2(x,y)
#define FUNC(x) FUNC1(x,__COUNTER__)
int FUNC(var);
int FUNC(var);
int main() {
var0 = 0;
var1 = 1;
printf("%d/n",var0);
printf("%d/n",var1);
return 0;
}
gcc main.c &&a.out得到结果：
0
1
这里使用__COUNTER__构造了两个变量：var0，var1。
8、__INCLUDE_LEVEL__
用于表示文件被包含的计数，从0开始递增，常作为递归包含的限制条件。如：
//-------file main.c----------
#include <stdio.h>
int main()
{
#define REP_LIMIT 10
#define REP(BLAH) printf("%d ", BLAH);
#include "rep.h"
printf("/n");
return 0;
}
//--------file rep.h----------
#if __INCLUDE_LEVEL__ < REP_LIMIT
REP(__INCLUDE_LEVEL__)
#include "rep.h"
#endif
gcc main.c && ./a.out,得到结果：
1 2 3 4 5 6 7 8 9
在这个例子中文件rep.h自包含了9次，执行了9次REP(BLAH)。
实际上，__INCLUDE_LEVEL__最多的是和#include __FILE__组合使用，用于表示一个递归。如：
//-------file main.c----------
#ifndef AUTOINC
#define AUTOINC
#include <stdio.h>
#define MAX_LEVEL 10
int main()
{
int i = 0;
#include __FILE__
printf("/n");
return 0;
}
#undef AUTOINC
#endif
#ifdef AUTOINC
#if __INCLUDE_LEVEL__ <= MAX_LEVEL
printf("%d ",__INCLUDE_LEVEL__);
#include __FILE__
#if __INCLUDE_LEVEL__ != MAX_LEVEL
printf("%d ",__INCLUDE_LEVEL__);
#endif
#endif
#endif
gcc main.c && ./a.out得到结果：
1 2 3 4 5 6 7 8 9 10 9 8 7 6 5 4 3 2 1
ANSI C标准中有几个标准预定义宏：
__FILE__ __DATE__ __TIME___ __LINE__ 等
__LINE__：在源代码中插入当前源代码行号；
__FILE__：在源文件中插入当前源文件名；
__DATE__：在源文件中插入当前的编译日期
__TIME__：在源文件中插入当前编译时间；
__STDC__：当要求程序严格遵循ANSI C标准时该标识被赋值为1；
__cplusplus：当编写C++程序时该标识符被定义。
一、标准预定义宏
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.
__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
}
|
编译器宏使用总结 |
|
|