程序环境和预处理（2）

前言：文章承接程序环境和预处理（1）

---

目录：

.宏和函数

.命名和命令行定义

.条件编译

.文件包含

---

1.宏和函数

1.1带副作用的宏参数

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

看代码：

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
...
x = 5;
y = 8;
z = MAX(x++, y++);
printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么？

这里将参数替换入宏就可得：

z = ( (x++) > (y++) ? (x++) : (y++));

所以输出结果为：

x=6，y=10，z=9.

 如此可见，使用带副作用的宏参数时，会改变参数的值，从而影响后续程序的运行，导致不可预测的后果。

1.2宏和参数的对比

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

我们时常用这个宏，来比较两个数的大小，这里不用函数的原因有二：

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

#define MALLOC(num, type)\
(type *)malloc(num * sizeof(type))
...
//使用
MALLOC(10, int);//类型作为参数
//预处理器替换之后：
(int *)malloc(10 * sizeof(int));

当然，相较于函数，宏依然有它的缺点：

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

---

下面是总结表格：

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

2.命名和命令行定义

2.1命名约定

我们在函数和宏的命名是，通常有一个习惯：

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

 2.2#undef

#undef可以用来移除一个宏定义，操作如下：

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

2.3命令行定义

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

例：

#include <stdio.h>
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;
}

编译指令：//linux 环境演示
                   gcc -D ARRAY_SIZE=10 programe.c

3.条件编译

 1.#if    常量表达式

             //……

    #endif（常量表达式由预处理器求值）

例：

#define __DEBUG__ 1
#if __DEBUG__
        //..
#endif

---

2.多个分支的条件编译：

 #if 常量表达式
        //...
#elif 常量表达式
        //...
#else
        //...
#endif

---

3.判断是否被定义：

 #if defined(symbol)
#ifdef symbol        //若symbol在之前被宏定义（define）过，就不再执行后面

#if !defined(symbol)
#ifndef symbol        //若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

4.文件包含

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

4.1头文件被包含方式

.本地文件包含：

#include "filename"

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

 .Linux环境的标准文件的路径：

/usr/include

 .VS环境的标准头文件的路径：

C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
//这是VS2013的默认路径

 这里要注意按照自己的安装路径去找。

.库文件包含:

#include <filename.h>

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

4.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__

或者，我们可能会在一些编译器中，新建头文件的时候发现里面默认编写了一串代码：

 #pragma once

这也可以避免头文件的重复引入。 

结语：

以上便是程序环境和预处理的所有内容，共两部分，可以结合阅读。