C语言进阶——程序环境和预处理（下）

🪴2.3.4、带有副作用的参数

 宏不仅会因为优先级问题造成影响，还会因为参数传递导致副作用，因为宏参数在传递后，会原封不动的进行替换，某些操作会对参数本身造成影响，而函数就没有这种问题

宏：举一个比较极端的例子，来说明宏传参有副作用这件事

//计算两数+1后的较大值
#define MAX(x, y) ((x) > (y) ? (x) : (y))
int main()
{
  int x = 1;
  int y = 2;
  int z = MAX(++x, ++y);
  printf("x = %d y = %d z = %d\n", x, y, z);
  return 0;
}

结果： x = 2 y = 4 z = 4

这次的宏体没有问题，问题就出在宏参数上，下面是替换后的代码

int z = ((++x) > (++y) ? (++x) : (++y));    //预编译处理后

走读代码：

1.首先明确为前置++，先+1，再使用

2.把 x 和 y 进行比较，因为是前置++，此时 x = 2  y = 3，显然为假，走后面的语句

3.找出较大值后，执行 ++y ，结果为 4，将这个值返回给 z

4.此时 x = 2，y = 4，z = 4

按照预料值，计算结果应该为 x = 2，y = 3，z = 3，因为宏参数计算存在副作用，所以计算结果才会有出入，即使换成后置，也会有问题。较为稳妥的做法，就是先把 x、y 分别+1，再作为宏参数传递使用。

函数：跟上面一样的功能，不过换成了函数形式

int max(int x, int y)
{
  return x > y ? x : y;
}
int main()
{
  int x = 1;
  int y = 2;
  int z = max(++x, ++y);
  printf("x = %d y = %d z = %d\n", x, y, z);
  return 0;
}

结果： x = 2 y = 3 z = 3

可以看到此时的运算结果是正确的，原因很简单，函数在传递参数时，只会进行一次运算，也就是说，实参 ++x、++y 在传递给形参后，已经变成了 2、3，所以运算就没有问题。

当然这里是有意设置的(对参数 x、y造成了影响)，实际使用中，最好不要传递自增和自减，避免出现副作用

🪴2.3.5、参数类型

 宏是没有规定参数类型的，而函数规定了参数类型，这就注定函数只能完成指定类型的操作，而宏可以适用于所有数据类型，这点上宏是比较好的

宏：比如模拟实现一个适用于所有数据类型的加法程序

#define ADD(x, y) ((x) + (y))
int main()
{
  printf("%d\n", ADD(2, 3));
  printf("%f\n", ADD(1.1, 2.2));    //甚至能用于浮点型
  printf("%c\n", ADD('A', 32));
  return 0;
}

结果： 5

          3.30000

          a

函数：一样的操作，不过把宏换成了函数

int add(int x, int y)
{
  return x + y;
}
int main()
{
  printf("%d\n", add(2, 3));
  printf("%f\n", add(1.1, 2.2));    //调用失败，类型不匹配
  printf("%c\n", add('A', 32));
  return 0;
}

结果： 5

          0.000000

          a

浮点型在内存中存储规则不同与整型，强行计算会出问题，因此编译器直接给出了 0.000000 这个结果

🪴2.3.6、能否调试

 宏是直接替换的，代码都在一行中，是调试不了的（当然可以通过汇编指令观察到细节）；而函数相对来说比较独立，能够进入到函数体中，进行逐步调试

宏：直接替换后，无法调试，或者说想调试很困难，只能通过汇编代码逐细节观察

函数：函数具有完整的躯干，可以进入到函数体内，逐语句调试

🪴2.3.7、能否递归

 宏是不能递归的，因为递归需要两个必要条件：限制条件和接近条件，而宏定义是直接替换的，条件是不能设置的；函数能实现递归，递归思想：大事化小，可以通过对同一个函数的不断调用，来完成复杂的任务。

宏：在一个宏体内放入当前宏体名，这是不合理的（参考 2.2.3 宏的替换规则），举个栗子

//递归打印数位，从低位开始
#define TEST(x) (if(x < 10) printf("%d\n",(x));  else { printf("%d ",x % 10) ; TEST(x / 10);})
int main()
{
  TEST(123456);
  return 0;
}

结果： 编译失败，报了很多种错误

函数：一模一样的代码(除了宏名部分)，让函数来完成

void test(int x)
{
  //当然这是不好的代码风格，这里是为了和上面对比
  if (x < 10) printf("%d\n", (x));  else { printf("%d ", x % 10); test(x / 10); }
}
int main()
{
  test(123456);
  return 0;
}

结果： 6 5 4 3 2 1

函数成功完成了任务，这个例子很好的说明了宏是无法使用递归的

🪴2.3.8、结论

 函数和宏各有各的好处，要根据实际需求选择使用，使用时要注意优先级和副作用问题

属性 #define 定义的宏 函数

代码长度 如果多次调用，替换后代码会很长 一份代码，多次调用

运行速度 预处理阶段直接替换，比函数更快 需要进行调用、返回等操作

操作符优先级 可能存在隐藏的优先级问题 相对隔离，不必担心此问题

带有副作用的参数 替换后，可能会进行多次运算 只有在传递时进行运算

参数类型 没有固定类型，合法就行 类型固定，使用时要与之相匹配

能否调试 不方便调试 可以进行逐语句调试

能否递归 不能递归 可以递归

 函数和宏都是很好的工具，关于函数的更多知识可以点击这里，宏的优缺点如下:

优点：

1.宏的运行速度比函数更快

2.宏与类型无关，涉及多类型的简单算法推荐使用宏

缺点：

1.当多次调用宏时，除非宏体很短，否则会大幅度增加程序的长度

2.宏是不方便调试的

3.宏没有类型，不够严谨

4.宏在使用时，可能会出现优先级和副作用问题

  🌱2.4、#undef 移除宏定义

 除了能 #define 定义符号外，还能 #undef 移除宏定义

语法：

#undef name    

//name 是已经定义好的符号名或宏名，必须合法（存在）

#define MAX 100
#define ADD(x,y) (x + y)
int main()
{
#undef MAX  //取消定义的标识符 MAX
  printf("%d\n", MAX);
#undef ADD  //取消定义的宏 ADD
  printf("%d\n", ADD(2, 3));
  return 0;
}

结果： 报错， 显示 MAX ADD未定义

  🌱2.5、命令行定义

 C语言中允许在命令行中定义符号，当然是在编译前定义（得在 Linux 上用 gcc 命令行编译的方式展示）

举个栗子

//命令行定义
int main()
{
  int arr[ARR_SIZE];
  int i = 0;
  for (i = 0; i < ARR_SIZE; i++)
  arr[i] = i;
  for (i = 0; i < ARR_SIZE; i++)
  printf("%d ", arr[i]);
  printf("\n");
  return 0;
}

在 Linux 环境下 gcc 中输入指令： gcc -D ARR_SIZE=10 test.c        //假设文件为 test.c

此时程序中的数组大小就变为了10，显然命令行定义的方式能让程序更加灵活，环境适配性更强

结果： 1 2 3 4 5 6 7 8 9 10

  🌱2.6、条件编译

 之前学过分支与循环，其中的条件满足时才会执行语句。C语言中还提供了一组条件编译函数，这些函数能决定后续语句是否需要编译。

🪴2.6.1、单分支条件编译

语法：

#if   #endif

// #if 后面跟条件表达式，当条件成立，后续代码才会编译

// #endif 条件编译块结束的标志，每个 #if 都必须有一个 #endif 与之匹配

int main()
{
#if 1 > 2
  printf("hello "); //条件不成立，此条语句不参与编译
#endif
  printf("world\n");
  return 0;
}

结果： world

看看预编译产生的 .i 文件

 注意：有 #if 就要有 #endif ，二者互为彼此存在的必要条件

🪴2.6.2、多分支条件编译

 多分支是在单分支基础上增加了两条语句：否则(#else) 与 否则如果(#elif)

语法：

#if   #elif   #else   #endif

//其中，#if   #elif 后面都需要跟条件表达式

//如果前两个都为假，那就编译 #else 后的语句

// #endif 服务于 #if ，不可缺失

//当然多分支可写的更细，这就不就展开叙述

int main()
{
#if 1>2
  printf("1\n");
#elif 4>3
  printf("2\n");    //只有这条语句参与编译
#else
  printf("3\n");
#endif
  return 0;
}

结果： 2

看看预编译产生的 .i 文件

不难看出，多分支条件编译就跟多分语句一样，只会选择一个通道进行编译

 注意：在使用多分支编译语句时，逻辑要严谨，设计要合理

🪴2.6.3、判断是否定义过宏

 我们可以定义宏、取消宏，还可以判断宏是否已定义

语法：

#if defined( )   #endif

//这个是判断宏有没有定义过，如果定义了，就执行后续语句

#if !defined( )   #endif

//这个是上面的反面，逻辑取反嘛，如果没定义，就执行后续语句

下面这俩是上面判断语句的另一种写法(个人比较推荐下面的写法，不需要加 ( ) 号)

#ifdef   #endif

//判断是否定义过，如果定义过，执行后续语句

#ifndef   #endif

//判断是否没有定义过，如果没有定义，执行后续语句

#define ADD(x, y) ((x) + (y))
int main()
{
//判断是否定义过
#if defined(ADD)
  printf("Yes\n");    //这个宏是已经定义了的
#endif
//判断是否没定义
#ifndef SUB
  printf("Yes\n");    //这个宏没定义
#endif
  return 0;
}

结果： Yes

          Yes

两种写法我都展示了，展示的还是不同的逻辑，判断定义就是这么用的

🪴2.6.4、嵌套使用条件编译

 下面演示一段三种条件编译语句混合的代码：

//#define OS_UNIX
#define OS_MSDOS
int main()
{
#if defined(OS_UNIX)
#ifdef UNIX_1
  printf("Welcome to UNIX_1\n");
#endif
#ifndef UNIX_2
#define UNIX_2
  printf("Increase UNIX_2\n");
#endif
#elif defined(OS_MSDOS)
  printf("Welcome to Windows\n");
#else
  printf("The system does not exist");
#endif
  return 0;
}

结果： Welcom to Windows

这段代码中包含了单分支、多分支、判断定义的知识 ，可以嵌套使用，灵活强大

 那么这种条件编译在现实中存在吗？

 答：存在，且使用很频繁，比如下图为VS中某头文件的定义截图

  🌱2.7、文件包含

 最后再来谈谈C语言中头文件的包含方式，分为自定义头文件和库文件的包含

🪴2.7.1、自定义头文件的包含

 自定义头文件在包含时，只能用 " " 引出自定义头文件名，如果像库函数头文件那样包含，是不会成功的，因为< >这种包含方式，是在标准路径下寻找头文件(C语言自带库函数头文件位于此目录下)，显然这个路径中是不会有我们自定义头文件的，因此只能使用 " " 引出自定义头文件。

 " " 包含头文件的查找策略是：先在当前目录下寻找目标头文件，找到了就打开，如果没找到，就会跑到标准路径下寻找，再找不到，就打开失败。显然，如果是头文件不存在的情况下，需要查找两次，效率会比较低。

🪴2.7.2、库函数头文件的包含

 库函数头文件在包含时，一般使用 < > 引出库文件名，被< >引出的头文件，编译器会直接去标准路径下寻找，只要没写错，那一般都能找到。" " 引头文件时，虽然要查找两次，但最终也会找到标准路径下，那么能否使用 " " 引库函数头文件呢？

 答案是不推荐，如果使用 " " 引库函数头文件的话，可以正常打开，但会拖慢运行速度，毕竟要查找两次。同时我们在使用时，就不能一眼辨别出，哪些是自定义头文件，哪些是库函数头文件了。

#include<stdio.h> //库函数头文件的包含风格
#include"Add.h" //自定义头文件的包含风格

🪴2.7.3、避免多次展开同一头文件

 头文件在被成功调用后，在预编译阶段会被展开（详情转至 1.1.1），光是 stdio.h 这个头文件就被展开了一万多行代码，如果不做特殊处理，然后多包含几次头文件，那光是在预编译阶段就会出现很多很多行代码了，并且这些代码还是重复的，为此要对头文件做一些特殊处理，避免其被多次展开

方法1（比较远古的方法）

 通过给头文件打标记，避免多次展开，会用到条件编译

#if !defined __TEST_H__ //打个标记，如果是第一次被引用
#define __TEST_H__  //就会创建一个标识符，然后开始预处理头文件中的内容
//预处理头文件中的内容
#endif

结果： 当第一次展开头文件时，没有识别到标记 __TEST_H__  之后会定义标记，再展开头文件；等后续在次文件中再次展开头文件时，识别到标记，不会继续展开代码，这样在预编译阶段就不会重复展开头文件了（不得不佩服前人的智慧）

方法2（现在比较常用的方法）

 这个就比较简单了，在头文件第一行直接使用提前定义好的工具就行，底层原理还是条件编译

#pragma once  //在头文件首行放置此条语句，可以避免重复展开

实际运用

 比如我们在VS中创建一个头文件，当文件创建完成后，编译器会自动在首行添加方法2中的语句，现在编译器太智能了，再比如下图为 stdio.h 这个头文件的首行

 足以看出这个东西是真实存在的，我们在创建自定义头文件时，可不敢把首行代码删除。

推荐了解其他预处理指令

#error

#pragma

#line

……

🌳总结

 以上就是关于C语言程序环境和预处理的所有内容了，如果你在看完此文后能对C语言代码的运行有一个新的认识，那么本文就值了；如果你对涉及命令行的操作还不太熟悉，没有关系，现在可以先了解，等以后学习了 Linux 的相关知识后，再回来解决就行了。

 如果本文有不足或错误的地方，随时欢迎指出，我会在第一时间改正

 写在最后：本文结束后，我们C语言的学习就可以宣布毕业了！从7月16日发布第一篇文章，到10月16结束最后一篇文章，历时三个月，此专栏的文章数达到了19篇，收获了近一万的文章阅读量和大量的点赞、收藏和评论，在此感谢一直支持我博客创作的朋友们，你们的支持是我坚持创作的最大动力！感谢那个拥有坚定信念的自己，一直坚持学习，砥砺前行。

 当然，只是C语言整体知识系列划上了句号，其他文章还是会继续更新下去的， 比如 数据结构 | C 这个系列，还有高深一些的 C语言高阶——函数栈帧的创建和销毁 ，其他好玩的小程序、有意义的题解等。新的旅途即将开始，就像章北海一样，我们的征途将是更加广袤的大海！