宏定义命令 #define 用来定义一个标识符和一个字符串，以这个标识符来代表这个字符串，在程序
 
中每次遇到该标识符时就用所定义的字符串替换它，其作用相当于给置顶的字符串起一个别名。
 
  不带参数的宏定义一般格式如下：
 
#define 宏名 字符串
 
1> “#”表示这是一条预处理命令
 
2>“宏名”是一个标识符，必须符合C语言标识符的规定
 
3>“字符串”在此可以是常数、表达式、格式字符串等
 
例如：
 
#define PI 3.14159
 
其作用是在该程序中用PI替代3.14159，在编译预处理时，每当在源程序中遇到PI就自动用3.14159
 
代替。
 
  使用#define进行宏定义的好处是需要改变一个常量的时候只需要改变#define命令行，整个程序的常
 
量都会改变，大大提高了程序的灵活性。
 
  宏名要简单且意义明确，一般习惯用大写字母表示，以便与变量名相区别。
 
  注意：宏定义不是C语句，不需要在行末加分号。
 
  宏名定义后，即可成为其他宏名定义中的一部分。例如，下面代码定义了正方形的边长SIDE、周
 
长PERIMETER及面积AREA的值。
 
#define SIDE 5
#define PERIMETER 4*SIDE
#define AREA SIDE*SIDE
 
  前面强调过宏替换是以串代替标识符，这一点要牢记。因此，如果希望定义一个标准的邀请语，
 
可编写如下代码。
 
 
 
#define STANDARD "You are welcome to join us."
printf(STANDARD);
 
编译程序遇到标识符STANDARD时，就会用"You are welcome to join us."替换。
 
对于编译程序，printf()语句如下形式是等效的。
 
printf("You are welcome to join us.");
 
对于不带参数的宏定义有以下几点要强调一下：
 
1、如果在串中含有宏名，则不进行替换。
 
  例如：
 
#include <stdio.h>

#define TEST "this is an example"

int main(void) { 
      
      char exp[30] = "This TEST is not that TEST";
       
       printf("%s\n", exp);
        
    

	return 0;
}
 
该段代码的输入结果如下：
 
This TEST is not that TEST
 
注意上面程序字符串中的TEST并没有用"this is an example"来替换，所以说如果串中含有宏名，
 
则不进行替换。
 
2、如果串长于一行，可以在该行末尾用一反斜杠“\”续行。
 
3、#define 命令出现在程序中函数的外面，宏名的有效范围为定义命令之后到此源文件结束。
 
注意：在编写程序时通常将所有的#define放到文件的开始处或独立的文件中，而不是将它们分散到
 
整个程序中。
 
4、可以用#undef命令终止宏定义的作用域。
 
例如以下程序
 
#include <stdio.h>

#define TEST "this is an example"

int main(void) { 
      
       
       printf(TEST);
       

	return 0;
}
 
程序输出为：
 
this is an example
 
修改程序为：
 
#include <stdio.h>

#define TEST "this is an example"

int main(void) { 
      
      
       
       printf(TEST);
       #undef TEST
       
       printf(TEST);
        
    

	return 0;
}
 
使用#undef,然后再打印 TEST,会报错
 
Compilation Failed


/usercode/file.cpp: In function ‘int main()’:
/usercode/file.cpp:12:15: error: ‘TEST’ was not declared in this scope
        printf(TEST);
 
显示TEST未定义。

 宏定义有无参数宏定义和带参数宏定义两种。
    无参数的宏定义的一般形式为
             # define 标识符 字符序列
 其中# define之后的标识符称为宏定义名(简称宏名)，要求宏名与字符序列之间用空格符分隔。这种宏定义要求编译预处理程序将源程序中随后所有的定名的出现(注释与字符串常量中的除外)均用字符序列替换之。前面经常使用的定义符号常量是宏定义的最简单应用。如有：
             # define TRUE 1
             # define FALSE 0
 则在定义它们的源程序文件中，凡定义之后出现的单词TRUE将用1替代之；出现单词FALSE将用0替代之。
        在宏定义的＃之前可以有若干个空格、制表符，但不允许有其它字符。宏定义在源程序中单独另起一行，换行符是宏定义的结束标志。如果一个宏定义太长，一行不 够时，可采用续行的方法。续行是在键人回车符之前先键入符号"/"。注意回车要紧接在符号"/"之后，中间不能插入其它符号。
       宏定义的有效范围称为宏定义名的辖域，辖域从宏定义的定义结束处开始到其所在的源程序文件末尾。宏定义名的辖域不受分程序结构的影响。可以用预处理命令#undef终止宏定义名的辖域。
   在新的宏定义中，可以使用前面已定义的宏名。例如，
              # define R 2.5
              # define PI 3.1415926
              # define Circle 2*PI*R
              # define Area PI* R * R
 程序中的Circle被展开为2*3.1415926* 2.5， Area被展开为3.1415926*2.5*2.5。
      如有必要，宏名可被重复定义。被重复定义后，宏名原先的意义被新意义所代替。
 
      通常，无参数的宏定义多用于定义常量。程序中统一用宏名表示常量值，便于程序前后统一，不易出错，也便于修改，能提高程序的可读性和可移植性。特别是给数组元素个数一个宏定义，并用宏名定义数组元素个数能部分弥补数组元素个数固定的不足。
       注意：预处理程序在处理宏定义时，只作字符序列的替换工作，不作任何语法的检查。如果宏定义不当，错误要到预处理之后的编译阶段才能发现。宏定义以换行结束，不需要分号等符号作分隔符。如有以下定定义：
    # define PI 3.1415926；
 原希望用PI求圆的周长的语句
    c＝2*PI*r；
 经宏展开后，变成
    c＝2*3.1415926*r；
 这就不能达到希望的要求。
    带参数宏定义进一步扩充了无参数宏定义的能力，在字符序列替换同时还能进行参数替换。带参数定定义的一般形式为
    # define 标识符(参数表)字符序列
 其中参数表中的参数之间用逗号分隔，字符序列中应包含参数表中的参数。在定义带参数的宏时，宏名标识符与左圆括号之间不允许有空白符，应紧接在一起，否则变成了无参数的宏定义。如有宏定义：
    # define MAX(A，B) ((A) > (B)?(A):(B))
 
 则代码 y＝ MAX( p＋q， u+v)将被替换成 y＝((p＋q) >(u＋v)?(p＋q):(u＋v)。
            程序中的宏调用是这样被替换展开的，分别用宏调用中的实在参数字符序列(如p＋q和u＋V) 替换宏定义字符序列中对应所有出现的形式参数(如用p＋q替代所有形式参数A，用u＋V替代所有形式参数B)，而宏定义字符序列中的不是形式参数的其它字 符则保留。这样形成的字符序列，即为宏调用的展开替换结果。宏调用提供的实在参数个数必须与宏定义中的形式参数个数相同。
        注意：宏调用与函数调用的区别。函数调用在程序运行时实行，而宏展开是在编译的预处理阶段进行；函数调用占用程序运行时间，宏调用只占编译时间；函数调用 对实参有类型要求，而宏调用实在参数与宏定义形式参数之间没有类型的概念，只有字符序列的对应关系。函数调用可返回一个值，宏调用获得希望的C代码。另 外，函数调用时，实参表达式分别独立求值在前，执行函数体在后。宏调用是实在参数字符序列替换形式参数。替换后，实在参数字符序列就与相邻的字符自然连 接，实在参数的独立性就不一定依旧存在。如下面的宏定义：
    # define SQR(x) x*x
 希望实现表达式的平方计算。对于宏调用
    P＝SQR(y)
 能得到希望的宏展开p＝ y*y。但对于宏调用q＝SQR(u＋v)得到的宏展开是q＝u＋V*u＋V。显然，后者的展开结果不是程序设计者所希望的。为能保持实在参数替换后的独立性，应在宏定义中给形式参数加上括号。进一步，为了保证宏调用的独立性，作为算式的宏定义也应加括
 号。如 SQR宏定义改写成：
    # define SQR((x)*(x))
 才是正确的宏定义。
 
       对于简短的表达式计算函数，或为了提高程序的执行效率、避免函数调用时的分配存储单元、保留现场、参数值传递、释放存储单元等工作。可将函数定义改写成宏定义。所以合理使用宏定义，可以使程序更简洁。
 
 
 
 
 使用一些宏跟踪调试
 
 A N S I标准说明了五个预定义的宏名。它们是：
 
 _ L I N E _ (两个下划线)，对应%d
 
 _ F I L E _    对应%s
 
 _ D A T E _   对应%s
 
 _ T I M E _   对应%s
 
 _ S T D C _
 
 如果编译不是标准的,则可能仅支持以上宏名中的几个,或根本不支持。记住编译程序
 
 也许还提供其它预定义的宏名。
 
 _ L I N E _及_ F I L E _宏指令在有关# l i n e的部分中已讨论,这里讨论其余的宏名。
 
 _ D AT E _宏指令含有形式为月/日/年的串,表示源文件被翻译到代码时的日期。
 
 源代码翻译到目标代码的时间作为串包含在_ T I M E _中。串形式为时：分：秒。
 
 如果实现是标准的,则宏_ S T D C _含有十进制常量1。如果它含有任何其它数,则实现是
 
 非标准的。
 
 可以定义宏,例如:
 
 当定义了_DEBUG,输出数据信息和所在文件所在行
 
 #ifdef _DEBUG
 
 #define DEBUGMSG(msg,date) printf(msg);printf(“%d%d%s”,date,_LINE_,_FILE_)
 
 #else
 
       #define DEBUGMSG(msg,date)
 
 #endif
 
 20,宏定义防止使用是错误
 
 用小括号包含。
 
 例如：#define ADD(a,b) （a+b）
 
 用do{}while(0)语句包含多语句防止错误
 
 例如：#difne DO(a,b) a+b;/
 
                    a++;
 
 应用时：if(….)
 
           DO(a,b); //产生错误
 
         else
 
         
 
 解决方法: #difne DO(a,b) do{a+b;/
 
                    a++;}while(0)
 
 
 宏中"#"和"##"的用法 
 一、一般用法 
 我们使用#把宏参数变为一个字符串,用##把两个宏参数贴合在一起（这里说的是在预处理是对源文件的操作）. 
 用法: 
 #include<cstdio> 
 #include<climits> 
 using namespace std;
 
 #define STR(s)     #s 
 #define CONS(a,b) int(a##e##b)
 
 int main() 
 { 
 printf(STR(vck));           // 输出字符串"vck" 
 printf("%d/n", CONS(2,3)); // 2e3 输出:2000 
 return 0; 
 }
 
 二、当宏参数是另一个宏的时候 
 需要注意的是凡宏定义里有用''#''或''##''的地方宏参数是不会再展开.
 
 1, 非''#''和''##''的情况 
 #define TOW      (2) 
 #define MUL(a,b) (a*b)
 
 printf("%d*%d=%d/n", TOW, TOW, MUL(TOW,TOW)); 
 这行的宏会被展开为： 
 printf("%d*%d=%d/n", (2), (2), ((2)*(2))); 
 MUL里的参数TOW会被展开为(2).
 
 2, 当有''#''或''##''的时候 
 #define A          (2) 
 #define STR(s)     #s 
 #define CONS(a,b) int(a##e##b)
 
 printf("int max: %s/n", STR(INT_MAX));    // INT_MAX #include<climits> 
 这行会被展开为： 
 printf("int max: %s/n", "INT_MAX");
 
 printf("%s/n", CONS(A, A));               // compile error 
 这一行则是： 
 printf("%s/n", int(AeA));
 
 INT_MAX和A都不会再被展开, 然而解决这个问题的方法很简单. 加多一层中间转换宏. 
 加这层宏的用意是把所有宏的参数在中间层里全部展开, 那么在转换宏里的那一个宏(_STR)就能得到正确的宏参数.
 
 #define A           (2) 
 #define _STR(s)     #s 
 #define STR(s)      _STR(s)          // 转换宏 
 #define _CONS(a,b) int(a##e##b) 
 #define CONS(a,b)   _CONS(a,b)       // 转换宏
 
 printf("int max: %s/n", STR(INT_MAX));          // INT_MAX,int型的最大值,为一个变量 #include<climits> 
 输出为: int max: 0x7fffffff 
 STR(INT_MAX) --> _STR(0x7fffffff) 然后再转换成字符串;
 
 printf("%d/n", CONS(A, A)); 
 输出为：200 
 CONS(A, A) --> _CONS((2), (2)) --> int((2)e(2))
 
 三、''#''和''##''的一些应用特例 
 1、合并匿名变量名 
 #define ___ANONYMOUS1(type, var, line) type var##line 
 #define __ANONYMOUS0(type, line) ___ANONYMOUS1(type, _anonymous, line) 
 #define ANONYMOUS(type) __ANONYMOUS0(type, __LINE__) 
 例：ANONYMOUS(static int); 即: static int _anonymous70; 70表示该行行号; 
 第一层：ANONYMOUS(static int); --> __ANONYMOUS0(static int, __LINE__); 
 第二层：                        --> ___ANONYMOUS1(static int, _anonymous, 70); 
 第三层：                        --> static int _anonymous70; 
 即每次只能解开当前层的宏,所以__LINE__在第二层才能被解开;
 
 2、填充结构 
 #define FILL(a)   {a, #a}
 
 enum IDD{OPEN, CLOSE}; 
 typedef struct MSG{ 
 IDD id; 
 const char * msg; 
 }MSG;
 
 MSG _msg[] = {FILL(OPEN), FILL(CLOSE)}; 
 相当于： 
 MSG _msg[] = {{OPEN, "OPEN"}, 
 {CLOSE, "CLOSE"}};
 
 3、记录文件名 
 #define _GET_FILE_NAME(f)   #f 
 #define GET_FILE_NAME(f)    _GET_FILE_NAME(f) 
 static char FILE_NAME[] = GET_FILE_NAME(__FILE__);
 
 4、得到一个数值类型所对应的字符串缓冲大小 
 #define _TYPE_BUF_SIZE(type) sizeof #type 
 #define TYPE_BUF_SIZE(type)   _TYPE_BUF_SIZE(type) 
 char buf[TYPE_BUF_SIZE(INT_MAX)]; 
 --> char buf[_TYPE_BUF_SIZE(0x7fffffff)]; 
 --> char buf[sizeof "0x7fffffff"]; 
 这里相当于： 
 
 
char buf[11]
 
本文转载自http://hi.baidu.com/ufo008ahw/blog/item/5e943d4f5f49513caec3abd1.html)

宏函数没有普通函数压栈、跳转、返回等的开销，可以提高程序的效率。
 
宏的名字中不能有空格；用括号括住每一个参数，并括住宏的整体定义；用大写字母表示宏的函数名。
 
#define SUM（a,b） （（x）+(y)）
 
在程序中执行：int ret=SUM(1,2);//则该语句被替换为int ret=((1)+(2)),宏函数不进行计算。
 

 

   
 
目录
 
一、宏定义中 “#”知识点
 
1、直接转换字符串，不展开。
 
2、转换出的结果一定是“字符串”。
 
二、宏定义中 ## 知识点
 
1、应用场景
 
2、“##”的作用是将 左右两边的参数做整体字符串拼接替换
 
3、经过 ## 替换后的内容必须 有一个 同名的 变量与之对应。
 
4、 只拼接，不展开。
 
5、## 操作 动态函数指针 案例代码
 

一、宏定义中 “#”知识点
 
  #的作用是将“#”后面的宏参数进行字符串转换操作，也就是将#后面的参数 两边加上一对双引号，使其成为字符串。
 
这里面有几个知识点：
 
1、直接转换字符串，不展开。
 
    这句话的意思是，带参数宏定义也是宏，而不是普通函数，所以要保留宏的基本特性，也就是全部替换，而不展开。示例代码：
 
#include <stdio.h>
#include <stdlib.h>

#define CONVERT(a) 	#a

int main(int argc, char *argv[]) {
	
	int a = 6;
	
	printf("res:%s\n", CONVERT(a));
	
	return 0;
}
 
 运行结果：
  
 
res:a
 
2、转换出的结果一定是“字符串”。
 
代码如下：
 
#include <stdio.h>
#include <stdlib.h>

#define CONVERT(a) 	#a

int main(int argc, char *argv[]) {
	
	printf("string print:%s\n", CONVERT(6));     // 字符串格式打印
	printf("int print:%d\n", CONVERT(6));     // 整型打印
	
	return 0;
}
 
 运行结果如下：
 
string print:6
int print:4210688
 
二、宏定义中 ## 知识点
 
1、应用场景
 
     ## 的 应用场景主要是 函数指针的动态绑定，使用该宏参数，可以实现 同类型 函数指针 赋值或者引用的 方便操作。这个后面会有代码详细分析。 
 
2、“##”的作用是将 左右两边的参数做整体字符串拼接替换
 
    不管 ## 左右两边是字母还是数字，最终都是作为 一个整体 拼接成一个字符串。代码如下：
 
#include <stdio.h>
#include <stdlib.h>

#define FUNC(a) 	func_##a

void func_1(void)
{
	printf("this is func 1.\n");
}

void func_2(void)
{
	printf("this is func 2.\n");
}

int main(int argc, char *argv[]) {	
	FUNC(1)();
	FUNC(2)();
	return 0;
}
 
3、经过 ## 替换后的内容必须 有一个 同名的 变量与之对应。
 
   比如 运行 FUNC(1)，必须要保证 有一个 func_1 函数， 同样的 FUNC(2) 对应 func_2函数，如果没有，编译会报错，提示对象未 定义。
 
4、 只拼接，不展开。
 
    这个类似于 # ，也是原封不动的转换，并不会进一步展开，比如：
 
int i = 1;
FUNC(i)();
 
 尽管 i = 1，但是 FUNC(i) 的结果是  func_i，而不是 func_1.，所以我们不能够使用 ## 的时候，自作聪明的使用变量。
 
5、## 操作 动态函数指针 案例代码
 
    在 知识点3中，我们提到 不能使用 变量 和 ## 的结合来实现 动态绑定函数指针，那么我们的程序代码就相对不太方便，尤其是我们 想要定义 一系列的 函数，这些函数主题名相同，但是序号不同，那么这个时候，就推荐使用 结构体  数据结构，代码如下所示：
 
#include <stdio.h>
#include <stdlib.h>

#define FUNC(a) 	func_##a

void func_0(void)
{
	printf("this is func 0.\n");
}

void func_1(void)
{
	printf("this is func 1.\n");
}

void func_2(void)
{
	printf("this is func 2.\n");
}


//包含函数 序号、 函数指针的 结构体
typedef struct func_t{
	int id;
	void (*func)(void);
} func_map_t;


// 函数结构体  数组
static func_map_t  g_func_map[3] = {
{0, FUNC(0)},
{1, FUNC(1)},
{2, FUNC(2)},
};

int main(int argc, char *argv[]) {	

	g_func_map[0].func();            //间接调用 序号对应的 函数。
	g_func_map[1].func();
	g_func_map[2].func();
	return 0;
}
 
    这里需要注意的是，我们在定义 上面的 g_func_map 数组 时，需要 在 函数func_0、func_1、func_2之后，这可能是因为编译器先后顺序的原因，如果g_func_map 在这三个函数之前，那么会出现 编译报错信息，显示 这3个函数未定义，可以简单的认为，在定义的时候，数据类型从 前面 查找， 而不是全局查找。
 
运行结果如下：
 
this is func 0.
this is func 1.
this is func 2.