1.#define

1.2#define定义标识符

语法： #define name stuff
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__)
1
2
3
4
5
6
7
8
9
10
11

提问：在#define定义标识符的时候，最后要不要加上；

//比如：
#define MAX 1000;
#define MAX 1000
1
2
3

建议不要加上；，这样容易导致问题
比如以下场景：

#define MAX 100;
if（MAX）
{}
1
2
3

替换后会出现语法问题。

1.2#define 定义宏

#define机制包括了一个规定，允许把参数替换到文本中，这样的实现称为宏或定义宏。
下面是宏的申明方式：
#define name(name-list) stuff
其中parament-list是一个由逗号隔开的符号表，它们可能出现在stuff中。
注意：
参数列表的左括号必须与name紧邻。
如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。

如：

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

提升：
所以用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中
的操作符或邻近操作符之间不可预料的相互作用。

1.3#define定义替换规则

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

1.在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。
2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替代。
3. 最后，再次对结果文本进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述过程。

注意：
1.宏参数和#define定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。
2.当预处理器搜索#define定义的符号的时候，字符串常量的内容并不会被搜索。

1.4#和##

如何把参数插入到字符串中？
首先我们看看这样的代码：

char* p = "hello ""world\n";
printf("hello ""world\n");
printf("%s",p);
1
2
3

这里输出的是不是 hello world？ 答案：是
我们发现字符串是有总的链接的特定的。

那我们是不是可以这样写代码？

##的作用
##可以把位于它两边的符号合成一个一个符号。
它允许宏定义从分离的文本片段创建标识符。

注：这样的连接必须产生一个合法的标识符。否则其结果就是为定义的。

1.5带副作用的宏参数

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

MAX宏可以证明具有副作用的参数所引起的问题。
下面程序结果是多少？

#define MAX(x,y) ((x)>(y)?(x):(y))

int main()
{
	int a = 5;
	int b = 8;
	int c = MAX(a++, b++);
	printf("%d %d %d\n", a, b, c);
	return 0;
}
1
2
3
4
5
6
7
8
9
10

1.6宏和函数对比

宏通常被应用于执行简单的运算
比如在两个数中找较大的一个。

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

那这里为什么不使用函数来完成这个任务？
原因有二：
1.用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。
所以宏比函数在程序的规模和速度方面更胜一筹
2.更为重要的是函数的参数必须声明特定的类型。
所以函数只能在类型合适的表达式上使用。反之，这个宏可以适用于整型、长整型、浮点型等可以用于>来比较的类型。
宏是类型无关的

宏的缺点：当然和函数相比宏也有劣势的地方。
1.每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。
2.宏是没法调试的。
3.宏由于类型无关，也就不够严谨。
4.宏可能会带来运算符优先级的问题，导致程序容易出错。

宏有时候可以做到函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到

宏和函数的一个对比

属性 #define定义宏 函数
代码长度
每次使用时，宏代码都会被插入到程序中。除了非常小的宏之外，程序的长度会大幅度增长
函数代码只出现于一个地方；每次使用这个函数时，都调用那个地方的同一份代码
执行速度
更快
存在函数的调用和返回的额外开销，所以相对慢一些
操作符优先级
宏参数的求值是在所有周围表达式的上下文环境里，除非加上括号，否则邻近操作符的优先级可能会产生不可预料的后果，所以建议宏在书写的时候多些括号。
函数参数只在函数调用的时候求值一次，它的结果值传递给函数。表达式的求值结果更容易预测。
带有副作用的参数
参数可能被替换到宏体中的多个位置，所以带有副作用的参数求值可能会产生不可预料的结果。
函数参数只在传参的时候求值一次，结果更容易控制。
参数类型
宏的参数与类型无关，只要对参数的操作是合法的，它就可以使用于任何参数类型。
函数的参数是与类型有关的，如果参数的类型不同，就需要不同的函数，即使他们执行的任务是不同的。
调试
宏是不方便调试
函数是可以逐语句调试的
递归
宏是不能递归的
函数是可以递归的

1.7命名约定

一般来讲函数和宏的使用语法很相似。所以语言本身没法帮我们区别二者。
那我们平时的一个习惯是：习惯而已

把宏名全部都大写
函数名不要全部大写

2.#undef

这条指令用于移除一个宏定义。
#undef NAME
//如果我们现存的名字需要被重新定义，那么它的旧名字首先要被移除。

3.命令行定义

许多C 的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。
例如：当我们根据同一个源文件要编译出不同的一个程序的不同版本的时候，这个特性有点用处。（假
定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一
个机器内存大些，我们需要一个数组能够大些。）
编译指令：

//linux 环境演示
gcc -D ARRAY_SIZE = 10 programe.c
1
2

#include 
int main()
{
    int array [ARRAY_SIZE];
    int i = 0;
    for(i = 0; i< ARRAY_SIZE; i ++)
   {
        array[i] = i;
   }
    for(i = 0; i< ARRAY_SIZE; i ++)
   {
        printf("%d " ,array[i]);
   }
    printf("\n" );
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4.条件编译

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

比如说：
调试性的代码，删除可惜，保留又碍事，所以我们选择性的编译。
不满足条件，预处理阶段就干掉了。

#include 
#define __DEBUG__
int main()
{
	int i = 0;
	int arr[10] = { 0 };
	for (i = 0; i<10; i++)
	{
		arr[i] = i;
	#ifdef __DEBUG__
		printf("%d\n", arr[i]);//为了观察数组是否赋值成功。 
	#endif //__DEBUG__
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

常见的条件编译指令

1.
#if 常量表达式
 //...
#endif
//常量表达式由预处理器求值。
如：
#define __DEBUG__ 1
#if __DEBUG__
 //..
#endif
2.多个分支的条件编译
#if 常量表达式
 //...
#elif 常量表达式
 //...
#else
 //...
#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//3.判断是否被定义
#define MAX 10
int main()
{
#if defined(MAX)
	printf("hehe\n");
#endif

#if !defined(MAX)
	printf("hehe\n");
#endif

#ifdef MAX
	printf("haha\n");
#endif

#ifndef MAX
	printf("haha\n");
#endif
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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
1
2
3
4
5
6
7
8
9
10
11
12
13

5.文件包含

我们已经知道，#include指令可以使另一个文件被编译。就像它实际出现于#include指令的地方一样。
这种替换的方式很简单：
预处理器先删除这条指令，并用包含文件的内容替换。
这样一个源文件被包含10次，那就实际编译10次。

5.1头文件被包含的方式

本地文件包含

#include "filename"
1

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

Linux环境的标准头文件的路径：/usr/include
VS环境的标准头文件的路径：C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
注意按照自己的安装路径去找。
库文件包含

#include 
1

查找头文件直接去标准路径下去查找，如果找不到就提示编译错误。
这样是不是可以说，对于库文件也可以使用 “” 的形式包含？
答案是肯定的，可以。
但是这样做查找的效率就低些，当然这样也不容易区分是库文件还是本地文件了。

5.2嵌套文件包含

如果出现这样的场景：

comm.h和comm.c是公共模块。
test1.h和test1.c使用了公共模块。
test2.h和test2.c使用了公共模块。
test.h和test.c使用了test1模块和test2模块。
这样最终程序中就会出现两份comm.h的内容。这样就造成了文件内容的重复。

如何解决这个问题？
答案：条件编译。防止头文件被重复包含。

每个头文件开头写：

#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
#endif  //__TEST_H__
1
2
3
4

或者：

#pragma once
1

注：
推荐《高质量C/C++编程指南》中附录的考试试卷（很重要）。
笔试题：

1. 头文件中的 ifndef/define/endif是干什么用的?
2. #include 和 #include "filename.h"有什么区别?

6.其他预处理指令

#error
#pragma
#line
...
不做介绍，自己去了解。
#pragma pack()在结构体部分介绍。
#pragma comment()
1
2
3
4
5
6
7

参考《C语言深度解剖》学习。