自定义头文件，预处理

分手后的思念是犯贱 2022-11-29 11:23 237阅读 0赞

一、自定义头文件。  
1、自定义头文件一定要写的吗？  
不一定要写的，当声明的语句比较多的时候，就会将这些声明的语句写到头文件中。

2、 可以写到自定义头文件中的内容有哪些？  
1）包含系统的头文件：\#include <stdio.h>  
2）宏定义：\#define OK 0  
3）自定义函数接口声明： int fun(int x,int y);  
4）结构体声明：  
struct data\{  
int a;  
int b;  
\};

3、自定义头文件书写格式。  
1）头文件文件名格式： xxx.h (my\_head.h)  
2）头文件内容开头必须写：  
\#ifndef \_MY\_HEAD\_H\_ -> 如果之前没有定义过\_MY\_HEAD\_H\_  
\#define \_MY\_HEAD\_H\_ -> 那么就定义\_MY\_HEAD\_H\_

3）可以明确列出需要包含的内容。  
//系统头文件  
//函数声明  
//宏定义  
//结构体声明

4）头文件结束后，必须写上这个  
\#endif

5）在.c文件写上  
\#include "my\_head.h" 等价于 \#include "./my\_head.h" 表示在当前的目录下寻找my\_head.h，如果找不到，那么就提示找不到头文件。

4、举例子。  
参考： header\_demo/

5、使用""与<>来包含头文件有什么区别？  
双引号""：先在指定的路径下去寻找头文件，如果找不到，则会去系统中寻找头文件，如果找不到，则报错。  
尖括号<>：直接去系统中寻找头文件，如果找不到，就报错。

1）使用尖括号来包含系统头文件。  
\#include <stdio.h>

int main(int argc,char \*argv\[\])  
\{  
printf("helloworld!\\n");  
return 0;  
\}

结果： 编译通过。 -> 直接去系统中寻找stdio.h,找到了！

2）使用尖括号来包含自定义的头文件。  
假设当前目录下有一个头文件叫my\_head.h，头文件内容：  
\-----------------------------  
\#ifndef \_MY\_HEAD\_H\_  
\#define \_MY\_HEAD\_H\_

\#include <stdio.h>

\#endif  
\------------------------------  
\#include <my\_head.h>

int main(int argc,char \*argv\[\])  
\{  
printf("helloworld!\\n");  
return 0;  
\}  
结果： 编译不通过，提示头文件找不到。 -> 直接去系统中寻找my\_head.h,没找到！

解决方案：在编译时，添加-I来指定头文件的路径。  
gcc xxx.c -o xxx -I . (编译时，先去当前目录寻找，再去系统寻找)

简单来讲,假设当前目录有一个my\_head.h头文件：  
\#include "my\_head.h"  
gcc xxx.c -o xxx

等价于  
\#include <my\_head.h>  
gcc xxx.c -o xxx -I .

3）使用双引号来包含系统头文件。  
\#include "stdio.h"

int main(int argc,char \*argv\[\])  
\{  
printf("helloworld!\\n");  
return 0;  
\}  
结果： 编译通过。 -> 先去当前目录下寻找stdio.h，结果没找到，则去系统中寻找，结果找到了。

4）使用双引号来包含自定义头文件  
假设当前目录下有一个头文件叫my\_head.h，头文件内容：  
\-----------------------------  
\#ifndef \_MY\_HEAD\_H\_  
\#define \_MY\_HEAD\_H\_

\#include <stdio.h>

\#endif  
\------------------------------

\#include "my\_head.h"

int main(int argc,char \*argv\[\])  
\{  
printf("helloworld!\\n");  
return 0;  
\}  
结果：编译通过。 先去当前目录找my\_head.h，结果找到了。

5）使用双引号来包含自定义头文件  
假设上一级目录下有一个头文件叫my\_head.h，头文件内容：  
\-----------------------------  
\#ifndef \_MY\_HEAD\_H\_  
\#define \_MY\_HEAD\_H\_

\#include <stdio.h>

\#endif  
\------------------------------

\#include "my\_head.h"

int main(int argc,char \*argv\[\])  
\{  
printf("helloworld!\\n");  
return 0;  
\}  
结果：编译不通过，提示头文件没有找到。 -> 先去当前目录找my\_head.h，结果找不到，再去系统中，结果还是找不到。

6）使用双引号来包含自定义头文件  
假设上一级目录下有一个头文件叫my\_head.h，头文件内容：  
\-----------------------------  
\#ifndef \_MY\_HEAD\_H\_  
\#define \_MY\_HEAD\_H\_

\#include <stdio.h>

\#endif  
\------------------------------

\#include "../my\_head.h"

int main(int argc,char \*argv\[\])  
\{  
printf("helloworld!\\n");  
return 0;  
\}  
结果：编译通过。 -> 先去上一级目录找，结果找到了。

6）使用双引号来包含自定义头文件  
假设当前目录下有一个头文件叫my\_head.h，头文件内容：  
\-----------------------------  
\#ifndef \_MY\_HEAD\_H\_  
\#define \_MY\_HEAD\_H\_

\#include <stdio.h>

\#endif  
\------------------------------

\#include "../my\_head.h"

int main(int argc,char \*argv\[\])  
\{  
printf("helloworld!\\n");  
return 0;  
\}  
结果：编译不通过，提示头文件没有找到。 -> 先去上一级目录找，结果找不到，再去系统找，还是没找到，所以报错。

二、条件编译。  
1、什么是条件编译？  
根据条件的真假来选择是否编译代码。

\#if 1 (1代表以下的代码是参与编译，0代表以下的代码不参与编译)  
xxxx;  
yyyy;  
\#endif

2、条件编译使用场景。  
在调试代码，某段代码用于输出某些值来观察现象。

\#if 0  
printf("a = %d\\n",a);  
printf("b = %d\\n",b);  
printf("c = %d\\n",c);  
printf("d = %d\\n",d);  
\#endif

三、总结预处理阶段需要注意事项。  
1、头文件展开/宏定义展开/条件编译，占用是预处理时间，而不是运行时间。  
2、宏定义既可以使用大写字母，可以使用小写字母。  
3、由于头文件中有函数的声明，所以头文件必须在函数调用之前就要包含了。  
4、如果在同一行代码中出现了多个预处理的语句，只会执行第一个预处理语句。

四、拆分多个.c文件。  
源文件test.c：  
\#include <stdio.h>  
\#include <stdlib.h>  
\#include <string.h>  
\#include <strings.h> //系统头文件

\#define OK 0 //宏定义

struct data\{ //结构体声明  
int a;  
char b;  
\};

int m = 0; //全局变量

void fun1(int x); //函数声明  
void fun2(int y);

void fun1(int x)  
\{  
printf("m = %d\\n",m);  
printf("x = %d\\n",x);  
return;  
\}

void fun2(int y)  
\{  
printf("y = %d\\n",y);  
return;  
\}

int main(int argc,char \*argv\[\])  
\{  
printf("helloworld");  
strlen("hello");  
char A\[10\];  
bzero(A,sizeof(A));  
malloc(10);  
  
struct data k;  
printf("OK = %d\\n",OK);  
  
fun1(10); //第一个功能  
fun2(20); //第二个功能  
  
return 0;  
\}

第一步： 先写头文件，将系统头文件，宏定义，结构体声明，函数声明全部写入到头文件  
1. 先创建一个my\_head.h  
2. 将系统头文件，宏定义，结构体声明，函数声明全部写到头文件中。  
========================my\_head.h=========================

\#ifndef \_MY\_HEAD\_H\_  
\#define \_MY\_HEAD\_H\_

\#include <stdio.h>  
\#include <stdlib.h>  
\#include <string.h>  
\#include <strings.h>

\#define OK 0

struct data\{  
int a;  
char b;  
\};

void fun1(int x);  
void fun2(int y);

\#endif

第二步： 创建功能函数的.c文件，用于存放功能函数。  
1. 先创建一个fun1.c，用于存放fun1()函数接口。  
2. 将fun1()函数的实现过程，放在fun1.c中。  
==========================fun1.c==============================  
\#include "my\_head.h"

void fun1(int x)  
\{  
printf("m = %d\\n",m);  
printf("x = %d\\n",x);  
return;  
\}

第三步： 创建功能函数的.c文件，用于存放功能函数。

1. 先创建一个fun2.c，用于存放fun2()函数接口。  
2. 将fun2()函数的实现过程，放在fun2.c中。  
==========================fun2.c==============================  
\#include "my\_head.h"

void fun2(int y)  
\{  
printf("y = %d\\n",y);  
return;  
\}

第四步：所有的.c文件，都要包含自定义头文件my\_head.h  
===========================test.c=============================  
\#include "head.h"

int m = 0;

第五步： 怎么处理全局变量？  
1）只需要在头文件中声明该全局变量是外部变量。

extern int m; //声明m是一个外部变量。  
//可以理解为这个m的作用域是全部的.c文件。

2）在某一个.c文件(test.c下/fun1.c下/fun2.c下定义"int m = 0"都可以)中定义以下该全局变量即可。  
例如： 在test.c下定义"int m = 0"  
\#include "head.h"

int m = 0;

第六步： 编译。  
gcc test.c fun1.c fun2.c -o test

练习： 找一份旧的代码，尝试拆分以下。