程序员进阶之路：程序环境和预处理（二）

预处理（预编译）

预定义符号

__FILE__    //进行编译的源文件

__LINE__   //文件当前的行号

__DATE__   //文件被编译的日期

__TIME__   //文件被编译的时间

__STDC__   //如果编译器遵循ANSI C，其值为1，否则未定义

这些预定义符号都是语言内置的。 举个栗子：

1. int main()
2. {
3.  printf("%s\n", __FILE__);
4.  printf("%d\n", __LINE__);
5. 
6. 
7.  return 0;
8. }

这些符号都是在预处理阶段处理的。

我们把代码拿到Linux系统下，进行预处理：

我们发现预处理之后，预处理指令直接就被替换了。

#define

#define 定义标识符

举个例子：

#define N 100
#define STR "abcdef"
#define FOR for(;;)
#define reg register
#define CASE break;case
int main()
{
  int input = 0;
  printf("%d\n", N);
  printf("%s", STR);
  switch (input)
  {
  case 1:
  CASE 2:
  CASE 3:
      ;
  }
  FOR;
}

在程序运行时，N就会被替换成100，STR被替换成abcdef，FOR被替换成for（；；）也就是死循环，reg被替换成register(变量类型，寄存器变量），CASE 2：被替换成break；case 2：。

这样的方法是可行的，缺点就是当标识符部分有错误时，程序出现报错，无法具体到位置。

提问：

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

答案是最好别加。

为什么呢？我们举个例子来看：

这样的逻辑表面上 没有什么问题，但是编译器已经向我们报错了

当程序进行预处理时，将N替换成100；，b=N；就会变成b=100；；，这样if后边就变成了两个语句，if在没有{}括住的情况下，后边最多只能有一条语句，所以运行时程序就会报错。

尽量定义标识符时不要加；

#define 定义宏

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

宏的申明方式：

#define name( parament-list ) stuff

name是宏的名字，parament-list是参数列表，parament-list它们可能替换到stuff内容里边。

我们直接上代码：

#define MAX(x,y) ((x)>(y)?(x):(y))
int main()
{
  int a = 0;
  int b = 1;
  int c = MAX(a, b);
  printf("%d", c);
  return 0;
}

MAX就是定义的宏，在程序预处理后就会被替换，如下图：

很类似于函数，但又与函数不同。

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

此外我们还要注意定义宏时常见的错误：

例如我们定义一个宏求一个数的平方：

#define SQUARE( x ) x * x

上述声明之后，我们传进去一个5：

SQUARE( 5 );

在程序运行后就会被替换成5*5.

但是如果这样写呢？

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

乍一看，你可能觉得这段代码将打印36这个值。 事实上，它将打印11. 为什么？

替换文本时，参数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)

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

int a = 5;
printf("%d\n" ,10 * DOUBLE(a));

看上去，好像打印100，但事实上打印的是55. 替换之后：

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

乘法优先级高于加法，所以结果就成了55.

这个问题，的解决办法是在宏定义表达式两边加上一对括号就可以了：

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

总结：

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

#define 替换规则

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

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

注意：

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

#和##

那么如何把参数插入到字符串中？

#的作用

int main()
{
  int a = 10;
  printf("the value of a is %d", a);
  int b = 20;
  printf("the value of b is %d", b);
  return 0;
}

例如这样，我们理想输出是the value of a is 10，the value of b is 20；

但是这样写多个的话又很麻烦，能不能封装成一个函数呢？

当去实现的时候我们会发现，实现不了，因为打印的时候只可以把数值修改了，前边的变量名并不能随意变换。

显然函数是无法做到的，但是宏却可以做到

怎么写呢？

#define PRINT(n) printf("the value of "#n" is %d\n",n)
int main()
{
  int a = 10;
  PRINT(a);
  int b = 20;
  PRINT(b);
  return 0;
}

我们可以使用 # ，把一个宏参数转化成对应的字符串。

但是这样仍然有局限性，它只能打印整形，不能打印浮点型数据啊。

于是我们可以这样修改：

#define PRINT(n,format) printf("the value of "#n" is"format"\n",n)
int main()
{
  int a = 10;
  PRINT(a, "% d" );
  int b = 20;
  PRINT(b," % d");
  float c = 3.14f;
  PRINT(c, " % f");
  return 0;
}

##的作用

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

举个例子：

#define CAT(x,y) x##y
int main()
{
  int cc = 10;
  printf("%d", CAT(c, c));
  return 0;
}

输出结果是10，它可以把位于它两边的符号合成一个符号。在预处理时，就会将从c，c合成一个片段替换为cc。

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

#和##只可以在宏里边用。

带副作用的宏参数

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

y=x+1;//不带副作用
y=x++;//带有副作用

虽然两种方法赋值给y的结果相同，但是第二种方法在赋值的同时，自身的大小也发生了变化。

MAX宏可以证明具有副作用的参数所引起的问题。

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
int main()
{
  int x = 5;
  int y = 6;
  int z = MAX(x++, y++);
  printf("x=%d y=%d z=%d\n", x, y, z);//输出的结果是什么？
  return 0;
}

程序运行，MAX会被替换成（（x++）>（y++）？（x++）：（y++））；在判断a和b大小之前，x是5，y是6.条件为假，就不执行（x++），执行（y++），判断后x是6，y是7，此时赋给z的值就变成了7，再次执行y++后y就变成了8。所以最终输出为6，8，7

从这里我们可以知道如果传给宏的参数带有副作用，那副作用就会在宏中延续，这也间接的表明宏的传参和函数传参的不同。

宏和函数对比

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

那为什么不用函数来完成这个任务？ 原因有二：

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

当然和宏相比函数也有劣势的地方：

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

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

宏和函数的一个对比：

命名约定

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

把宏名全部大写

函数名不要全部大写

#undef

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

如何使用呢？

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

实例：

#define MAX(x,y) ((x)>(y)?(x):(y))
int main()
{
  int a = 0;
  int b = 1;
#undef MAX
  int c = MAX(a, b);
  printf("%d", c);
  return 0;
}

这样代码再次运行时，就会报错，MAX未定义（要在MAX使用前）。

命令行定义

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

#include <stdio.h>
int main()
{
int array [SIZE];
int i = 0;
for(i = 0; i< SIZE; i ++)
{
array[i] = i;
}
for(i = 0; i< SIZE; i ++)
{
printf("%d " ,array[i]);
}
printf("\n" );
return 0;
}

编译指令：

gcc -D SIZE=10 programe.c

在输入编译指令时赋值也是可以的。

条件编译

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

比如说：

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

常见的条件编译指令：

#if 常量表达式
//……
#endif

怎么使用呢？

举个例子：

int main()
{
#if 1
  printf("Hello world!\n");
#endif
  return 0;
}

当我们想控制某个语句执行时，#if后边为真则执行，如果为假则不执行。感觉是不是很像if语句。

但与if语句不同的是，在预处理阶段，如果#if为假，那该语句在程序运行时就会被剔除。

当然它也是可以进行嵌套使用的：

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

不运行的代码，在预处理阶段就会被剔除，如下图：

除此之外，它还能判断是否被定义

#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol

#ifdef是判断某个标识符是否已经被定义，而#ifndef是判断某个标识符是否未被定义。

这样预处理指令是支持嵌套指令的例如：

#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

最后一个#endif用于结束#elif defined(OS_MSDOS)和#elif defined(OS_MSDOS)

文件包含

我们已经知道， #include 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方一样。

这种替换的方式很简单： 预处理器先删除这条指令，并用包含文件的内容替换。 这样一个源文件被包含10次，那就实际被编译10次。

头文件被包含的方式有两种：

• 本地文件包含
• 库文件包含

本地文件包含，我们用的都是双引号，例如：

#include "filename"

库文件包含：

#include <filename.h>

这两种引用方式有什么不同呢？

两种方式确实有所不同，它们查找策略不同。

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

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

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

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

嵌套文件包含

这些文件的包含其实还可以进行嵌套，在实际场景中经常遇到，例如我们在写一个扫雷小游戏时：

我们分了3个文件去写，一个.h文件用于声明，包含所有需要使用的头文件，而其他两个.c文件就可以直接包含我们自己创建的.h文件,如下图：

当然这样嵌套的包含也存在弊端：

文件多次被包含，这样会有什么影响呢？

我们知道在预处理阶段，计算机就会将头文件中的所有内容写到代码中，如果头文件的内容很多，那么重复的包含就会导致预处理时多次将头文件内容加入到代码中，导致代码量加大。效率就会降低。

如何解决这个问题？ 答案：条件编译。

每个头文件的开头这样写：

#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
#endif //__TEST_H__

如果没有定义过test.h这个文件，就执行下边代码，如果定义过就不会再执行，重复包含。

或者：

#pragma once

在头文件的开头这样写，也是可以让头文件仅包含一次。

这两种方式都可以避免头文件的重复引入。

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

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

除此之外还有很多的预处理指令，这里就不再向大家一一介绍。

总结

希望本文能够为您提供有价值的学习资源，并帮助您更好地理解程序环境和预处理的重要性和作用。最后，感谢您的阅读！