当前位置：首页 > news >正文

C语言基础20

news 来源：原创 2025/8/25 0:07:12

内容提要

预处理
库文件

预处理

C语言编译步骤

预处理
编译
汇编
链接

什么是预处理

预处理就是在源文件（.c文件）编译之前，所进行的一部分预备操作，这部分操作是由预处理程序自动完成。当源文件在编译时，编译器会自动调用预处理程序来完成预处理执行的操作，预处理执行解析完成才能进入下一步的编译过程

查看预处理结果：

 gcc 源文件 -E -o 程序名[.后缀]

预处理功能

宏定义（可以使用宏定义完成无符号常量的创建）

不带参数的定义
- 语法：
```
 #define 宏名称 常量数据
```
- 预处理机制：此时的预处理只做数据替换，不做类型检查
- 注意：宏定义不会占用内存空间，因为在编译前已经将宏名替换成了常量数据
- 宏展开：在预编译时将宏名替换成字符串的过程称之为“宏展开”（将宏名替换成常量数据的过程）
- 案例：
```
 #define PI 3.1415926int main(){float l,s,r,v;printf("请输入圆的半径：\n");scanf("%f",&r);// 计算周长l = 2.0 * PI * r;// 计算面积s = PI * r * r;printf("l=%10.4f\ns=%10.4f\n",l,s);return 0;}
```

带参数的宏定义

语法：

 #define 宏名(参数列表) 参数表达式

面试题：

 #define multi(a,b) (a) * (b)#define multi(a,b) a * b

实现：

 // 定义一个带参数的宏，带参数的宏名为小写#define multi_1(a,b) (a) * (b)#define multi_2(a,b) a * bint main(){int result1 = multi_1(7+2,3); // (a)*(b) = (7+2)*3 = 27printf("%d\n",result1); // 27int result2 = multi_2(7+2,3); // a * b = 7+2 * 3 = 13printf("%d\n",result2); // 13return 0;}

宏定义的作用域：

#define命令出现在程序中函数的外面，宏名的有效范围为定义命令之后到本源文件结束
可以用#undef命令终止宏定义的作用域

案例：

 #define PI 3.14  // PI的作用域 10行 ~ 18行#define DAY 28   // DAY的作用域 11行 ~ 文件末尾void func1(){float r = 4;float s = PI * r * r;int day = DAY;}#undef PI // 终止了PI的范围#define PI 3.1415926void func2(){float r = 4;float s = PI * r * r;int day = DAY;}int main(int argc, char *argv[]){func1();func2();return 0;}

在宏定义中引用已定义的宏名

案例：

 #define R 3.0       // 半径#define PI 3.14  #define L 2 * PI * R   // 在宏定义中引用已定义的宏名#define S PI * R * R#define P_WIDTH 800#define P_HEIGHT 480#define SIZE P_WIDTH * P_HEIGHTint main(int argc, char *argv[]){printf("L=%f\nS=%f\n",L,S);return 0;}

文件包含

概念

所谓“文件包含”处理是指一个源文件可以将另一个源文件的全部内容包含进来。这适用于多文件开发。通常，一个常规的C语言程序会包含多个源码文件（*.c），当某些公共资源需要在各个源码文件中使用时，为了避免多次编写相同的代码，我们一般会进行代码的抽取（*.h），然后在各个源码文件中直接包含即可

注意：*.h中的函数声明必须要在*.c中有对应的函数定义（函数的实现），否则没有意义。（函数一旦声明，就一定要定义）

头文件（.h）的内容

头文件中所存放的内容，就是各个源码文件的彼此可见的公共资源，包括：

全局变量的声明
普通函数的声明
静态函数的定义
宏定义
结构体、共用体的定义
枚举常量列表的定义
其他头文件包含

示例代码：

 // head.hextern int global;    // 全局变量的声明extern void func1();  // 普通函数的声明static void func2();  // 静态函数的声明，写在.h中，引用此文件的.c文件直接调用；写在.c，只能这个.c文件访问{...}#define max(a,b) ((a)>(b)?(a):(b)) // 宏定义struct node          // 结构体定义{...};union attr           // 共用体定义{...};enum SEX             // 枚举常量列表定义{...};#include <stdio.h>   // 系统头文件#include "myhead.h"  // 自定义头文件

特别说明：

全局变量、普通函数的定义一般出现在某个源文件（*.c,*.cpp）中，其他源文件想要使用都需要进行声明，因此一般放在头文件中更方便
静态函数、宏定义、结构体、联合体的定义都只能在其所在的文件可见，因此如果多个源文件都需要的话，放到头文件中定义是最方便的选择

预处理机制：将文件中的内容替换文件包含指令

包含方式

#include <xxxx.h>：系统会到标准库文件目录（Linux下/usr/include）查找包含的文件，建议对于系统库访问采用这种写法
#include "xxxx.h"：在当前工程路径下（Linux下./）查找包含的文件，如果未找到，就去标准库文件目录下查找。建议对于自定义库采用这种写法

案例

myhead.h

 #ifndef _MYHEAD_H#define _MYHEAD_H/*** 数组的累加和运算* @param int* int数组* @param int 数组大小*/extern int sum(const int*, int)#endif // _MYHEAD_H

myhead.c

 #include <stdio.h>#include "myhead.h"/*** 数组的累加和运算（定义）*/int sum(const int *arr, int len){const int *p = arr;int sum = 0;for(; p < arr + len; p++){sum += *p;}return sum;}

app.c

 #include <stdio.h>#include "myhead.h"int main(int argc, char *argv[]){int arr[] = {11,12,13,14,15};int result = sum(arr,sizeof(arr)/sizeof(arr[0]));printf("数组累加和的结果是：%d\n",result);return 0;}

多文件编译命令：

 gcc app.c myhead.c -o app

条件编译

定义：根据设定的条件选择待编译的语句代码

预处理机制：将满足条件的语句进行保留，将不满足条件的语句进行删除，交给下一步编译

语法：

语法一：

根据是否找到标识，来决定是否参与编译（标识存在为真）

 #ifdef 标识   // 判断标识符定义与否，定义为真，未定义为假（找到标识符为真①，找不到为假②）... ①#else... ②#endif

语法二：

根据是否找到标识，来决定是否参与编译（标识不存在为真）

 #ifndef 标识   // 判断标识符定义与否，未定义为真，定义为假（找不到标识符为真①，找不到为假②）... ①#else... ②#endif

语法三：

根据表达式的结果，来决定是否参与编译（表达式成立为真1，不成立为假0）
```
 #if 表达式   // 判断表达式结果，成立为1，不成立为0... ①#else... ②#endif
```

案例：

 #include <stdio.h>#define LETTER 0 // 默认是大写int main(int argc,char *argv[]){// 测试用的字母字符串char str[20] = "C Language";char c;int i = 0;// 遍历获取每一个字符while((c = str[i])!='\0'){#if LETTERif(c >= 'a' && c <= 'z'){c -= 32;}#elseif(c >= 'A' && c <= 'Z'){c += 32;}#endifprintf("%c",c);i++;}printf("\n");return 0;}

避免头文件重复包含的方法

其实就是头文件去重复

由于头文件包含指令#include的本质是复制粘贴，并且一个头文件中可以嵌套包含其他头文件，因此很容易出现头文件被重复包含的文件。此时就需要我们进行去重，去重需要用到预处理提供的去重相关的指令

语法：

 #ifndef _XXXX_H  // 一般为 下划线+头文件名大写+下划线+H#define _XXXX_H..#endif

案例：

 #ifndef _MYHEAD_H#define _MYHEAD_H/*** 数组的累加和运算* @param int* int数组* @param int 数组大小*/extern int sum(const int*, int);#endif // _MYHEAD_H

库文件

什么是库文件

库文件本质上是经过编译后生成的可被计算机执行的二进制代码，但注意库文件不能独立运行，库文件需要加载到内存中才能执行。库文件大量存在于Windows、Linux、MacOS等软件平台上

库文件的分类

静态库
- Windows：xxx.lib
- Linux：libxxxx.a
动态库（共享库）
- Windows：xxx.dll
- Linux：libxxxx.so.major.minor

注意：不同的软件平台因为编译器、链接器不同，所生成的库文件是不兼容的

静态库与动态库的区别

静态库链接时，将库中所有内容包含到最终的可执行程序中
动态库链接时，将库中的符号信息包含到最终可执行程序中，在程序运行时，才将动态库中符号的具体实现加载到内存中

静态库与动态库的优缺点

静态库
- 优点：生成的可执行程序不再依赖静态库文件
- 缺点：可执行程序体积较大
动态库
- 优点：生成的可执行程序体积小；动态库可被多个语言程序共享
- 缺点：可执行程序运行依赖动态库文件

库文件的创建

Linux系统下库文件命名规范：libxxxx.a（静态库）libxxxx.so（动态库）

静态库文件的生成

将需要生成库文件对应的源文件（*.c）通过编译（不链接）生成（*.o）目标文件
用ar命令将生成的*.o打包生成libxxxx.a

库的生成：

库的使用：

动态库文件的生成

利用源文件（*.c）通过编译（不链接）生成*.o目标文件
将目标文件链接为*.so文件