程序员C语言快速上手——进阶篇（七）

约定不等于承诺〃 2022-01-05 11:25 337阅读 0赞

### 文章目录 ###

*  进阶语法
 *   *  模块化编程
     *   *  多个源文件
         *  使用头文件
         *   *  关于头文件的总结
     *  预处理
     *   *  预处理概述
         *   *  文件包含
             *  宏定义
             *  条件编译
         *  预处理的高级使用
         *   *  普通宏
             *  带参的宏
             *  条件编译
             *  其他预处理指令
 *  欢迎关注我的公众号：编程之路从0到1

# 进阶语法 #

## 模块化编程 ##

所谓模块化开发，是对源文件的一种组织方式。

### 多个源文件 ###

最早的C语言仅仅用来编写小而美的代码，总共不超过100行，随着计算机软件的发展，小程序变成了大型软件工程，整个项目是由多人协同开发完成的，一个人显然已经玩不动了，这时候也就出现了模块化编程的概念。

假设现在有小明、小张和小王三人，这三人决定同时开发一个C程序，由小明负责主函数的编写和调用，小张编写一个加法函数，小王编写一个减法函数。这时候三人显然不能同时编辑同一个源码文件，那么就需要每个人编写一个源码文件。

小明的源码 `main.c`

#include <stdio.h>
    
    //声明但不实现
    int add(int a, int b);
    int sub(int a, int b);
    
    int main(){ 
        printf("1+2=%d",add(1,2));
        printf("18-9=%d",sub(18,9));
        return 0;
    }

小张的加法源码 `t1.c`

int add(int a, int b){ 
        return a+b;
    }

小王的减法源码 `t2.c`

int sub(int a, int b){ 
        return a-b;
    }

小明写完代码时，发现另两位早就完成了，接下来三人将三份源码放到一起执行编译，这里使用`gcc`命令编译

gcc t1.c t2.c main.c -o main

多个源文件之间使用空格分隔，执行命令之后生成`main.exe`可执行程序，运行结果：

1+2=3
    18-9=9

整个过程非常清晰，三人只需提前商议好各自编写的函数名和参数即可开干。

### 使用头文件 ###

上面的例子是比较简单的演示，但当真实项目中，有几十上百的函数要编写时，多人协作就会显得有些混乱，而且声明与实现混合，代码结构也变得冗长。特别是当完成项目之后，我们需要给每个函数编写注释，解释函数的功能和用法时，会变得很麻烦，非常不易于阅读和维护。这时候我们就需要一种被称为头文件的文本文件，来描述函数。

之前我们一直使用别人的头文件，现在自己也来做一份头文件，创建`calculate.h`文件，并将函数声明都挪到头文件中

/* 加法函数 */
    int add(int a, int b);
    
    /* 减法函数 */
    int sub(int a, int b);

这时`main.c`源文件就变得更简单清晰了

#include <stdio.h>
    #include "calculate.h" //包含头文件
    
    int main(){ 
        printf("1+2=%d\n",add(1,2));
        printf("18-9=%d\n",sub(18,9));
        return 0;
    }

再次执行命令编译，成功！

gcc t1.c t2.c main.c -o main

这里有几点需要注意

1.  头文件和`.c`源文件放到一个文件夹下
2.  我们自己本地的头文件，在包含时应当写英文双引号，而不是尖括号

有了头文件以后，我们的声明都可以放到头文件中，然后在源码文件的顶部去包含它。这就是将声明和实现分离，声明单独放一个文件，实现放在源码文件中。这种开发模式，就是模块化开发，也被人称为面向接口的开发。

试想一下，在多人开发之前，大家只要协商好头文件，后面就只需要对照着头文件去写代码，省了很多事。开发完成后，将源代码编译，这时候头文件就相当于一份功能说明书，可以很方便的将二进制和头文件一同发布。

#### 关于头文件的总结 ####

以上例子是演示完了，但细心的朋友会发现，这里还遗留了一些问题。

1.  头文件到底是什么？
2.  头文件一定要和源代码放在一起吗？
3.  在包含头文件时，`<>`和`""`到底有什么区别？

首先回答第一个问题，头文件实际上并不是什么特殊的东西，它仅是一个普通的文本文件，它也可以是任意后缀名的文本文件。例如，我们将`calculate.h`文件改为`calculate.txt`，包含时使用`#include "calculate.txt"`，再次使用`gcc t1.c t2.c main.c -o main`编译，完全没有任何问题。

第二个问题，头文件是可以放置到本机的任意文件夹下的。但一定要学会如何处理头文件路径问题。当我们想将头文件和C语言源文件放在同一根路径下时，为了方便查看，可以单独为头文件再创建一个目录，例如创建一个`head`目录，将头文件移入，则需要使用相对路径包含的写法`#include "head/calculate.h"`。

当头文件和源代码不在同一级目录下时，则可以为其指定绝对路径，这时又有两种方法。首先将头文件移入到其他盘的任意目录

*  `gcc`参数指定头文件目录。这里使用`-I`后面紧跟路径的写法。注意`I`和路径之间没有空格
    
        gcc t1.c t2.c main.c -o main -ID:\workspace\head
 *  配置环境变量`C_INCLUDE_PATH`。这里是设置地临时环境变量
    
        set C_INCLUDE_PATH=D:\workspace\head
        gcc t1.c t2.c main.c -o main

最后说一下包含头文件时`<>`和`""`的区别。关于这个区别，很多资料和教材的说法都是错误的。大多解释为尖括号用来包含标准库的头文件，双引号包含自己写的头文件。这只是很肤浅的表面现象。实际上两者的区别仅仅是参照物的区别，更简单的说就是路径的区别，和是不是标准库头文件或自定义头文件没有关联。这一点很重要，特别是在自己编写或修改开源库构建脚本，编译大型C语言工程时。

当我们的头文件和源文件在同一级目录时，这时候的头文件路径是以源文件（.c文件）路径为参照物的，因此当使用双引号来包含；当我们的头文件和源文件不在同一级目录下时，且使用上述两种方式之一指定了头文件路径，那么使用`<>`或`""`来包含头文件都可以

验证，将`#include "calculate.h"` 改为`#include <calculate.h>`，使用命令编译

gcc t1.c t2.c main.c -ID:\workspace\head -o main

我们指定了头文件路径，编译成功。这里我们的`calculate.h`明显不是所谓的标准库头文件，但是编译运行没问题，说明尖括号包含头文件，只和路径有关，与是不是标准库无关，因此看到尖括号包含的头文件时，不要想当然的认为这个头文件是标准库的，特别是在处理库移植的时候。

## 预处理 ##

所谓预处理，就是在办正事之前做一点准备工作。预处理指令都是以`#`号开头的，这一点很好辨认。

在之前，我们已经了解过了`#include`、`#define`这两个指令，实际上预处理指令并不是C语言词法的一部分，它仅仅是写给编译器看的，让编译器在正式编译之前，先帮我们做点小事情。

学习预处理最好的方法，就是将C语言的`预处理-编译-汇编-链接`四个阶段拆开，分步进行，这时候正好体现出使用`gcc`命令行学习C语言的优势。

首先为了简单，先去除标准库的头文件包含，代码如下

#include "calculate.h" //包含头文件
    
    int main(){ 
        printf("1+2=%d\n",add(1,2));
        printf("18-9=%d\n",sub(18,9));
        return 0;
    }

使用gcc进行预处理，这里加`-E`参数预处理，`-o`指定生成的文件名

gcc -E main.c -o main.i

执行命令后，生成了预处理之后的源文件`main.i`

# 1 "main.c"
    # 1 "<built-in>"
    # 1 "<command-line>"
    # 1 "main.c"
    
    # 1 "D:\\workspace\\head/calculate.h" 1 3
    
    # 3 "D:\\workspace\\head/calculate.h" 3
    int add(int a, int b);
    
    
    int sub(int a, int b);
    # 3 "main.c" 2
    
    # 5 "main.c"
    int main(){ 
        printf("1+2=%d\n",add(1,2));
        printf("18-9=%d\n",sub(18,9));
        return 0;
    }

这个文件很简单，只是将`calculate.h`中的声明都复制到了当前的源文件中来。到现在就很容易理解预处理指令`#include`了吧，就是在正式编译代码之前，帮我们把头文件中的声明拷贝到源文件中，这说明C语言中，那些声明最终还是必须得写到源文件中的。这件事被称为`声明展开`

预编译完成之后，接下来需要汇编了，不过我们得先把`<stdio.h>`头文件加回来，重新预编译一次，加了`<stdio.h>`之后，`main.i`变得很大，这是因为`<stdio.h>`里的声明太多了。

**编译** `-S` 生成汇编代码

gcc -S main.i -o main.s
    gcc -S t1.c -o t1.s
    gcc -S t2.c -o t1.s

**汇编** `-c` 生成机器码，亦称为目标文件。

gcc -c main.s -o main.o
    gcc -c t1.s -o t1.o
    gcc -c t2.s -o t2.o

这一次我们生成的`.o`文件就无法阅读了，已经是二进制文件了，但它还不是可执行文件。

**链接** 生成可执行程序`main.exe`

gcc main.o t1.o t2.o -o main

### 预处理概述 ###

大多数预处理指令可分为三类

#### 文件包含 ####

使用`#include`指令包含一个指定文件

#### 宏定义 ####

使用`#define`指令定义一个宏  
使用`#undef`指令删除一个宏

之前说用`#define`来定义常量，实际上就是利用宏的预处理，进行字符串替换而已。现在我们就使用`gcc`命令要验证

编写以下代码`main.c`

#define PI 3.14
    
    int main(){ 
        int r = PI *10 + PI*PI;
        return 0;
    }

不生成文件了，直接在命令行打印预处理结果

gcc -E main.c

输出：

# 1 "main.c"
    # 1 "<built-in>"
    # 1 "<command-line>"
    # 1 "main.c"
    
    
    int main(){ 
        int r = 3.14 *10 + 3.14*3.14;
    }

可以很清楚的看到，预处理之后，将所有的`PI`进行了文本替换。

#### 条件编译 ####

包含`#if`、`#ifdef`、`ifndef`等，使预处理器可以根据条件确定是否将一段文本包含

条件编译就更简单了，修改`main.c`

#define PI 3.14
    
    int main(){ 
        int a = 0;
    #if 0
        int r = PI *10 + PI*PI;
    #endif
    	return 0;
    }

预编译输出

# 1 "main.c"
    # 1 "<built-in>"
    # 1 "<command-line>"
    # 1 "main.c"
    
    
    int main(){ 
        int a = 0;
    }

可以看到，当使用条件预处理指令`#if`时，判断的条件为0，直接就将包裹的代码删除了，实际上在真正的编译之后的程序中 ，根本就不存在这些内容，等同你从来没写过。

关于预编译指令，需要记住几点

1.  `#`开头的预处理指令必须顶格写，前面不要有空格
2.  记住三大类预处理指令的特点，`#include`指令是声明展开，宏定义是文本替换，条件编译是直接删除代码。

### 预处理的高级使用 ###

在预处理指令中，最复杂的是宏定义。很多人学了C语言，信心满满的要学习一下C语言开源库的代码，结果看过之后如同看天书，瞬间开始怀疑人生，感觉自己学了假的C语言。实际上据我观察，高校教材中的所谓C语言，顶多只能算是C语言的皮毛，连入门都算不上。那么问题到底出在哪呢？

我个人认为，看不懂C语言代码，百分之六十的原因就出在预处理指令的宏上面，可以说，宏是C语言中最灵活，最头疼，最复杂的东西，即使你很熟悉宏，看到宏依然会头大。特别是宏函数，非安全编程范式，代码出了问题也很难查。

说了这么多，在学习宏之前，还是先来看点有意思的东西。

创建头文件`replace.h`

#define zhengshu int
    #define zifuchuan char*
    #define fanhui return
    #define ruguo if
    #define fouze else
    #define $ main

编写`main.c`

#include <stdio.h>
    #include "replace.h"
    
    zhengshu $(){ 
        zifuchuan yijuhua = "this is chinese";
        zhengshu a = 1;
        ruguo (a > 2){ 
            printf("a>2\n");
        }fouze{ 
            printf(yijuhua);
        }
        
        fanhui 0;
    }

打印结果：

this is chinese

上面的代码完全可以正常编译运行，这虽然是个比较极端的例子，但是说明会玩宏的人，能把C语言玩得谁都不认识！

#### 普通宏 ####

#define 标识符 替换列表
    #define PI 3.1514

宏的替换列表可以包括标识符、关键字、数值、字符串常量、操作符等。当预处理器遇到一个宏时，会做一个“标识符”代表“替换列表”的记录，在文件后面，不管标识符在哪出现，都会被替换列表的内容替换。有一点需要注意，定义一个宏时，替换列表允许为空。

#### 带参的宏 ####

也称函数式宏，宏函数。

#define 标识符(a,b,c,...,d) 替换列表
    #define MAX(x,y) ((x)>(y)?(x):(y))

如上，预处理器会在后面将所有的MAX(x,y)替换为后面替换列表的内容，其中x、y分别对应后面替换列表中的x、y

**关于宏函数的注意事项**

max = MAX(i++,j);

如上例，错误的使用宏函数，可能得到预期之外的结果，上例在预处理之后，被替换为如下代码，i会被加两次：

max = ((i++) > (j)?(i++):(j));

**关于小括号的注意事项**  
1、如果宏替换列表中有运算符号，那么必须将整个替换列表放入小括号中  
`#define TOW_PI (2*3.14)`

2、如果宏有参数，那么每个参数在替换列表中出现时，都要放在小括号中  
`#define MAX(x,y) ((x)>(y)?(x):(y))`

**运算符**  
宏定义包含两个专用运算符`#`和`##`

*  `#` 运算符可以用来字符串化宏函数里的参数，它出现在带参数宏的替换列表中。

#define PRINT_INT(n) printf(#n "=%d\n",n)
    
    PRINT_INT(i/j);
    //宏展开为
    printf("i/j""=%d\n",i/j)
    //等价于（C语言相邻字符串字面量会被合并）
    printf("i/j=%d\n",i/j)

*  `##` 运算符可以将两个记号（如标识符）粘合在一起。

#define MK_ID(n) i##n
    
    int MK_ID(1),MK_ID(2);
    //宏展开后
    int i1,i2;

实际代码示例

#define GENERIC_MAX(type) \ type type##_max(type x,type y){ \ return x > y ? x : y;
        }
        
    //需要float类型的求最大值函数，则可以如下定义
    GENERIC_MAX(float)
    //再定义一个int类型的最大值函数，我们可以量产函数了
    GENERIC_MAX(int)
    
    //float的宏函数展开为
    float float_max(float x,float y){ 
        return x > y ？ x ： y；
    }

这样，就可以使用一个宏函数，生成对各种基本类型数据求最大值的max函数了。

**创建包含多条语句的宏**

使用`do-while`编写多条语句宏是一种C语言的技巧。

#define ECHO(s) \ do{ \ gets(s); \ puts(s); \ }while(0) 
        
    ECHO(str);
    //宏展开后
    do{ gets(str);puts(str);}while(0);

**预定义宏**  
这是编译器预先给我们定义好了的宏，可以直接在代码中使用，例如打印日志时，就可以使用`_LINE_`宏，将当前代码的行号也输出

<table> 
 <thead> 
  <tr> 
   <th align="left">宏</th> 
   <th align="left">简述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">_<em>LINE</em>_</td> 
   <td align="left">当前程序行的行号（十进制整型常量）</td> 
  </tr> 
  <tr> 
   <td align="left">_<em>FILE</em>_</td> 
   <td align="left">当前源文件名（字符串型常量 ）</td> 
  </tr> 
  <tr> 
   <td align="left">_<em>DATE</em>_</td> 
   <td align="left">编译的日期（表示为Mmm dd yyyy 形式的字符串常量）</td> 
  </tr> 
  <tr> 
   <td align="left">_<em>TIME</em>_</td> 
   <td align="left">编译的时间（hh:mm :ss形式的字符串型常量）</td> 
  </tr> 
  <tr> 
   <td align="left">_<em>STDC</em>_</td> 
   <td align="left">编译器符合C标准，值为1</td> 
  </tr> 
 </tbody> 
</table>

**关于宏的一些总结**

1.  使用宏函数，可以减少函数栈的调用，稍微提升一点性能，相当于C++中的内联的概念，在C99中也实现了内联函数的新特性。缺点是宏展开后，增加了编译后的体积大小。
2.  宏参数没有类型检查，缺少安全机制。
3.  宏的替换列表可以包含对其他宏的调用
4.  宏定义的作用范围，直到出现这个宏的文件末尾
5.  宏不能被定义两次，除非新定义与旧定义完全一样
6.  可以使用`#undef 标识符`取消宏定义，若宏不存在，则该指令没有作用

#### 条件编译 ####

*  `#if`和`#endif`
    
        #define DEBUG 1
        
        
        /* #if和#endif成对出现，#if后面跟常量表达式，0为false，反之true。当为0时，它们之间的代码在预处理时会被删去 */
        
        #if DEBUG
        printf("this is debug!\n");
        #endif

需要注意，`#if`后面的标识符如未被定义过时，则当作值为0处理，因此默认为0时，可以不用定义该宏。

*  defined运算符
    
        #define DEBUG
        
        #if defined DEBUG
        ...
        #endif

检测其后的标识符是否有定义过，若定义过则返回1，否则返回0

*  `#ifdef`和`#ifndef`  
    `#ifdef`指令用于检测一个标识符是否已经被定义为宏，`#ifndef`则相反，检测一个标识符是否未被定义为宏
    
        #ifdef 标识符
        
        /* 它等价于以下指令 */
        #if defined 标识符
 *  `#elif`和`#else`  
    这两个指令结合`#if`使用，相当于C语言中的if…else if…else的用法。这两个指令还可以与`#ifdef`或`#ifndef`结合使用
    
        #if 表达式1
        ...
        #elif 表达式2
        ...
        #else
        ...
        #endif

条件编译主要可以用于  
1、需要测试调试代码时，打印更多信息，正式发布时则去除这些代码  
2、跨平台，跨编译器。对于不同平台，可以包含不同的代码，使用不同的编译器特性  
3、屏蔽代码。使用注释符号注释代码时，有一个缺点，注释无法嵌套，即不能注释中间包含注释的代码，使用条件编译则很方便

#### 其他预处理指令 ####

*  `#error` 指令  
    可以用于检查某些编译器属性，当不符合时，提示错误，并终止编译。
    
        #error 消息

# 欢迎关注我的公众号：编程之路从0到1 #

![编程之路从0到1][0_1]

[0_1]: /images/20211229/8931acfcb0b24f01aedf465864f5457a.png