#define宏&#和##的对比&条件编译&头文件

#define定义常量

语法：

#define name stuff  

例子：

#define MAX 1000
#define reg register //为 register这个关键字，创建⼀个简短的名字 
#define do_forever for(;;) //⽤更形象的符号来替换⼀种实现 
#define CASE break;case //在写case语句的时候自动把 break写上。 
// 如果定义的 stuff过长，可以分成几行写，除了最后⼀行外，每⾏的后⾯都加⼀个反斜杠(续行符)。
// 如：
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
 date:%s\ttime:%s\n" ,\
 __FILE__,__LINE__ , \
 __DATE__,__TIME__ ) 

思考：在define定义标识符的时候，要不要在最后加上 ; ?

比如：

#define MAX 1000;
#define MAX 1000

建议不要加上“ ;” ，这样容易导致问题。比如下面的场景：

 if(condition) 
    max = MAX; // 这里替换成为两行，if语句没有大括号只能包含一条语句
else 
    max = 0;

#define定义宏

 #define 机制包括了⼀个规定，允许把参数替换到⽂本中，这种实现通常称为宏（macro）或定义宏 （definemacro）。

下面是宏的申明方式：

 #define name( parament-list ) stuff

其中的 parament-list 是⼀个由逗号隔开的符号表，它们可能出现在stuff中。

注意： 参数列表的左括号必须与name紧邻，如果两者之间有任何空白存在，参数列表就会被解释为stuff的⼀部分。

下面我们定义一个宏实现求一个数的平方

#define SQUARE( x ) x * x

int main()
{
	int a = 5;
	// 1
	printf("%d\n", SQUARE(a));
	// 2
	printf("%d\n", SQUARE(a + 1));


	return 0;
}

// 1输出的是25，正确的值；// 2输出的是11，不正确的值，预期是36。为什么会这样呢？

答案：宏实际上就是文本的直接替换，替换文本时，参数x被替换成a+1,所以这条语句实际上变成了：

printf ("%d\n",a + 1 * a + 1 );

这样就比较清晰了，由替换产生的表达式并没有按照预想的次序进行求值。在宏定义上加上两个括号，这个问题便轻松的解决了：

#define SQUARE(x) (x) * (x)

这样预处理之后就产生了预期的效果：

printf ("%d\n",(a + 1) * (a + 1) );

下面再看一个例子：

#define DOUBLE(x) (x) + (x)

定义中我们使用了括号，想避免之前的问题，但是这个宏可能会出现新的错误。

#define SQUARE( x ) x * x
#define DOUBLE(x) (x)+(x)

int main()
{
	int a = 5;
	// 1
	printf("%d\n", SQUARE(a));
	// 2
	printf("%d\n", SQUARE(a + 1));
	// 3
	printf("%d\n", DOUBLE(a));
	// 4
    printf("%d\n", 10 * DOUBLE(a));


	return 0;
}

4这里将打印什么值呢？看上去，好像打印100，但事实上打印的是55.

 我们发现替换之后：

printf ("%d\n",10 * (5) + (5)); 

乘法运算先于宏定义的加法，所以出现了 55 .这个问题，的解决办法是在宏定义表达式两边加上⼀对括号就可以了。

#define DOUBLE(x) ( ( x ) + ( x ) )

所以：不要吝啬使用括号，避免在使用宏时由于参数中的 操作符和邻近操作符之间不可预料的相互作用。

带有副作用的宏参数

当宏参数在宏的定义中出现超过⼀次的时候，如果参数带有副作用，那么你在使用这个宏的时候就可能出现危险，导致不可预测的后果。副作用就是表达式求值的时候出现的永久性效果。

例如：

 x+1;//不带副作⽤ 
 x++;//带有副作⽤

带副作用的宏举例子：

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )

int main()
{	int x = 5;
	int y = 8;
	int z = MAX(x++, y++);

	printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么？
	return 0;
}

这里我们得知道预处理器处理之后的结果是什么：

z = ( (x++) > (y++) ? (x++) : (y++));
//      5       8   ？  
// 比较后x,y都++
//      6       9     没使用     9
   
//                    没使用     10   

宏替换的规则

在程序中扩展#define定义符号和宏时，需要涉及几个步骤。

 1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。

2. 替换文本随后被插⼊到程序中原来文本的位置。对于宏，参数名被他们的值所替换。

3. 最后，再次对结果文件进⾏扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上 述处理过程。

注意：

1. 宏参数和#define定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。

 2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

#运算符

#运算符将宏的⼀个参数转换为字符串字面量。它仅允许出现在带参数的宏的替换列表中。

#运算符所执行的操作可以理解为”字符串化“。当我们有⼀个变量 int a = 10; 的时候，我们想打印出： the value of a is 10 . 就可以写：

// #的使用
#define PRINT(n) printf("the value of "#n " is %d\n", n);

int main()
{
	int a = 10;
	int b = 20;
	int c = 30;

	PRINT(a);
	PRINT(b);
	PRINT(c);

	return 0;
}

当我们调用PRINT的时候： PRINT(a);//当我们把a替换到宏的体内时，就出现了#a，而#a就是转换为 "a"，时⼀个字符串代码就会被预处理为：

printf("the value of ""a" " is %d", a);

在 C 语言中，相邻的字符串字面量会被自动连接成一个单一的字符串。这一特性被称为字符串字面量拼接。代码中：

printf("the value of ""a" " is %d\n", a);

编译器会将这三个相邻的字符串字面量合并为一个：

"the value of a is %d\n"

##运算符

 ## 可以把位于它两边的符号合成⼀个符号，它允许宏定义从分离的文本片段创建标识符。 ## 被称记号粘合这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。比如，写⼀个函数求2个数的较大值的时候，不同的数据类型就得写不同的函数。比如：

int int_max(int x, int y)
{
 return x > y ? x : y;
}
float float_max(float x, float y)
{
 return x > y ? x : y;
}

但是写成宏的形式就好办多了，只需要定义宏和声明函数类型即可：

// ##的使用
//宏定义 
#define GENERIC_MAX(type) \
type type##_max(type x, type y)\
{ \
 return (x>y?x:y); \
}

GENERIC_MAX(int) //替换到宏体内后int##_max 生成了新的符号 int_max做函数名 
GENERIC_MAX(float) //替换到宏体内后float##_max 生成了新的符号 float_max做函数名 


int main()
{
	//调用函数 
	int m = int_max(2, 3);
	printf("m = %d\n", m);

	float fm = float_max(3.5f, 4.5f);
	printf("fm = %.2f\n", fm);

	return 0;
}

#undef

这条指令用于移除⼀个宏定义。

#undef NAME //如果现存的⼀个名字需要被重新定义，那么它的旧名字⾸先要被移除。

例如：

// #undef的使用
#define MAX 100

int main()
{
	// 1
	printf("%d\n", MAX);
#undef MAX
	// 2
	printf("%d\n", MAX);

	return 0;
}

1是可以正常打印100；2不能导致编译报错，因为MAX已经取消定义。

条件编译

在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃是很方便的。 因为我们有条件编译指令。

比如说： 调试性的代码，删除可惜，保留又碍事，所以我们可以选择性的编译。

代码1：

// 1
#include <stdio.h>
int main()
{
	int i = 0;
	int arr[10] = { 0 };
	for (i = 0; i < 10; i++)
	{
		arr[i] = i;
		printf("%d\n", arr[i]);//为了观察数组是否赋值成功。 
	}
	return 0;
}

代码1会将数组内容打印出来。

代码2：

// 条件编译语句
// 2
#include <stdio.h>
//#define __DEBUG__ 
int main()
{
	int i = 0;
	int arr[10] = { 0 };
	for (i = 0; i < 10; i++)
	{
		arr[i] = i;
#ifdef __DEBUG__                 // 如果定义了__DEBUG__则运行下面语句，否则不运行
		printf("%d\n", arr[i]);  //为了观察数组是否赋值成功。  
#endif //__DEBUG__
	}
	return 0;
}

还有其他条件编译语句：

1.
#if 常量表达式
 //...
#endif
//常量表达式由预处理器求值。 
如：
#define __DEBUG__ 1
#if __DEBUG__
 //..
#endif
2.多个分⽀的条件编译
#if 常量表达式
 //...
#elif 常量表达式
 //...
#else
 //...
#endif
3.判断是否被定义
#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol
4.嵌套指令
#if defined(OS_UNIX)
 #ifdef OPTION1
unix_version_option1();
 #endif
 #ifdef OPTION2
 unix_version_option2();
 #endif
#elif defined(OS_MSDOS)
 #ifdef OPTION2
 msdos_version_option2();
 #endif
#endif

如：（对比这两个代码，if 条件为真则打印，否则不打印）

#include <stdio.h> 
int main()
{
	int i = 0;
	int arr[10] = { 0 };
	for (i = 0; i < 10; i++)
	{
		arr[i] = i;
#if 0
		printf("%d\n", arr[i]);//为了观察数组是否赋值成功。 
#endif
	}
	return 0;
}

#include <stdio.h> 
int main()
{
	int i = 0;
	int arr[10] = { 0 };
	for (i = 0; i < 10; i++)
	{
		arr[i] = i;
#if 1
		printf("%d\n", arr[i]);//为了观察数组是否赋值成功。 
#endif
	}
	return 0;
}

其他语句自己去尝试。

头文件的包含

头文件被包含的方式：（本地文件包）

#include "filename"

查找策略： 先在源文件所在目录下查找，如果该头文件未找到，编译器就像查找库函数头文件⼀样在标准位置查找头文件。 如果找不到就提示编译错误。

库文件包含

#include <filename.h>

查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。

这样是不是可以说，对于库文件也可以使用 “ ” 的形式包含？

答案是肯定的，可以，但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件。