C语言进阶-程序环境和预处理（2）

3.2.4 #和##

这是两个特殊的符号，在介绍它们之前，我们先来了解一个知识点。

在C语言中，把两个字符串放在一起打印，它们会自动合为一个字符串：

下面我们来看一段代码：

可以看到，上述代码中printf函数相似，那我们可不可以将其用#define定义，然后再调用呢？

试一下：

显然不行，因为字符串常量中的n不会被替换。

这时可以试试#符了，#a相当于"a"，#b相当于"b"：

#n相当于字符串"n"，和它前后的两个字符串"the value of"和"= %d\n" 合为一个字符串，并且a,b可以传给n，所以实现了以上功能。

由此可见，#的作用是：把一个宏参数变为字符串。

如果我们要打印浮点数，可以用下面的方式：

下面我们来看看##的作用：

##可以把位于他两边的符号合成一个符号

它允许宏定义从分离的文本片段创建标识符

示例：

可以看到，x##y将class和008合为一个符号class008，然后打印出class008的值。

3.2.5 带副作用的宏参数

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

例如：

int a = 10;
int b = a + 1;//b=11,a=10
int c = ++a;//c=11,a=11

++a在使用时改变了a的值，这就是副作用。

下面来看使用带有副作用的宏参数会有什么后果：

#include<stdio.h>
#define MAX(x,y) ((x)>(y)?(x):(y))
int main()
{
  int a = 5;
  int b = 6;
  int c = MAX(a++, b++);
  printf("a = %d\n", a);
  printf("b = %d\n", b);
  printf("c = %d\n", c);
  return 0;
}

打印出来的结果是什么呢？

因为预处理后的结果是：

int c = ((a++) > (b++) ? (a++) : (b++));

所以结果是，6 8 7。

3.2.6 宏和函数的对比

上文中求两个数的最大值，用宏和函数都能实现：

//宏
#define MAX(x,y) ((x)>(y)?(x):(y))
//函数
int Max(int x, int y)
{
  return (x > y ? x : y);
}

那如果要我们来选一种方式，选哪种方式更好呢？

我们打开反汇编窗口就可以明显对比出来：

明显，使用函数的汇编代码量远远超过调用宏的代码量。

所以选择宏更好。

其实选择宏的原因有二：

1. 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多。
   所以宏比函数在程序的规模和速度方面更胜一筹。
2. 更为重要的是函数的参数必须声明为特定的类型。

   函数只能在类型合适的表达式上使用。反之这个宏可以适用于整形、长整型、浮点                型等可以用>来比较的类型。

   宏是类型无关的。

但是宏也是有缺点的：

1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度      增加程序的长度。
2. 宏是没法调试的。

3. 宏由于类型无关，也就不够严谨。
4. 宏可能会带来运算符优先级的问题，导致程容易出现错。

可以看到，宏和函数各有各的优缺点，函数可以实现和宏相同的功能，但是宏的有些能力是函数绝对没有的。

例如我们要开辟126个大小为int型的空间：

#include<stdio.h>
#define MALLOC(num,type) (type*)malloc(num*sizeof(type))
int main()
{
  int* p = MALLOC(126, int);
  //int* p = (int*)malloc(126*sizeof(int));
  return 0;
}

这个可以用宏实现，但是不能封装成函数实现，因为函数传参不能传类型（int）。

宏和函数的对比：

3.2.7 命名约定

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

把宏名全部大写

函数名不要全部大写

例如：

//宏
#define MAX(x,y) ((x)>(y)?(x):(y))
//函数
int Max(int x, int y)
{
  return (x > y ? x : y);
}

3.3 #undef

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

例如：

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

我们在调用宏MAX之前就移除了它的定义，那再使用就会报错：

3.4 命令行定义

许多C 的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程。

例如：当我们根据同一个源文件要编译出一个程序的不同版本的时候，这个特性有点用处。（假定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一个机器内存大些，我们需要一个数组能够大些。）

命令行定义在VS中不能演示，只能在Linux中演示。

看下面一段代码：

#include<stdio.h>
int main()
{
  int arr[sz];
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    arr[i] = i + 1;
  }
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}

可见我们定义了一个变长数组arr[sz]，但是sz未定义，在编译时会出错，此时在Linux环境下，可以在命令行中定义变量sz：

gcc test.c -D sz=10 -o test

这样就能打印出来变长数组的值。

3.5 条件编译

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

条件编译就是条件满足就编译，条件不满足就不编译。

常见的条件编译指令：

1.
#if常量表达式
//...
#endif
//常量表达式由预处理器求值。

例如：

#if后面为真就编译，#if后面为假就不编译，为假时，在预处理阶段就直接将#if和#endif之间的代码删了。

2.多个分支的条件编译

#if 常量表达式

//...

#elif 常量表达式

//...

#else

//...

#endif

例如：

上述代码在预处理阶段如下：

3.判断是否被定义

//如果被定义过

#if defined(symbol)
#ifdef symbol

//如果没有被定义过

#if !defined(symbol)
#ifndef symbol

例如：

如果被定义过，就打印haha：

如果没被定义过，就打印undefined:

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 else语句的嵌套使用，这里不再细讲。

3.6 头文件包含

我们之前讲过头文件有两种包含方式，一种是用< >包含，一种是用" "包含，用< >包含的是库文件，用" "包含的是自定义的文件。

3.6.1 头文件被包含的方式：

本地文件包含：

#include "filename"

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

库文件包含：

#include <filename>

查找策略： 直接去标准路径下去查找，如果找不到就提示编译错误。

这里思考一个问题，是不是对于库文件也可以使用" "的形式包含？

答案是肯定的。

只不过这样查找的效率就低一些，也不容易区分是库文件还是本地文件了。

3.6.2 嵌套文件包含

来看一张图：

可以看到，上图中，comm.h被test.c重复包含了两次，最终程序中就会出现两份comm.h的内容，这样就造成了文件内容的重复。

那要如何解决这个问题呢？

使用条件编译就行。

我们先来看一下，重复包含的后果：

这个得在Linux环境下看：

可以看到，int Add(int x,int y)多次重复。

如果要解决这个问题，我们可以用以下代码：

#ifndef __TEST_H__
#define __TEST_H__
int Add(int x, int y);
#endif;

这段代码判断是否定义了__TEST_H__，如果没定义说明此时还没包含头文件"test.h"，如果定义了说明包含了头文件"test.h"，以后再包含，#ifndef和#endif之间的内容会被删除，这样就实现了只能对头文件"test.h"一次包含。

虽然此时我们在代码中依然包含了4次头文件"test.h"，但实际上只包含了一次：

当然我们也可以用下面方式解决这个问题：

#pragma once
int Add(int x, int y);

4. 其他预处理指令

以上就是我们今天介绍的预处理指令了，当然还有很多其他的，这里不再细讲。

#error
#pragma
#line

...

不做介绍，自己去了解。

那么到今天为止，C语言部分的学习就结束了，接下来就要开始学习数据结构了。