c语言预处理的详细介绍

目录

预处理详解

预定义符号

#define定义的标识符

#define 定义宏

#define 替换规则

#和##

带副作用的宏参数

宏与函数的对比

#undef

 条件编译

文件的包含

嵌套文件包含

---

程序实现要经历的过程

在ANSI C的任何一种实现中，都经历两种不同的环境。

一是翻译环境，在这个环境中源代码被转换为可执行的机器指令；二是执行环境，它用于实际执行代码。

翻译环境又可以细分为编译（预编译+编译+汇编）+链接。

 那上面的每一步都做了些什么呢? 下面给出包含但不完全的要点（仅供参考）：

预处理：

1. 头文件的包含，就是#include后面的文件。

2. 删除注释。

3. #define符号的替换

编译：

把c语言代码转换成了汇编代码。进行了：

1. 语法分析

2. 语义分析

3. 词法分析

4. 符号汇总

汇编：

1. 把汇编代码转换成二进制代码

2. 形成符号表

链接：

1. 合并段表

2. 符号表的合并与重新定位

运行环境：

1. 程序必须载入内存中。在有操作系统的环境中：一般这个由操作系统完成。在独立的环境中，程序的载入必须由手工安排，也可能是通过可执行代码置入只读内存来完成。

2. 程序的执行便开始。接着便调用main函数。

3. 开始执行程序代码。这个时候程序将使用一个运行时堆栈（stack），存储函数的局部变量和返回地址。程序同时也可以使用静态（static）内存，存储于静态内存中的变量在程序的整个执行过程 一直保留他们的值。

4. 终止程序。正常终止main函数；也有可能是意外终止。

  

我使用的VS2022，其实是个集成开发环境（IDE，Integrated Development Environment ），包含编辑器（就是我们写代码的地方），编译器，链接器和调试器。

在对上面程序实现有一个宏观认识之后，文章接下来的内容，便聚焦于预处理了。

预处理详解

预定义符号

__FILE__      //进行编译的源文件

__LINE__     //文件当前的行号

__DATE__    //文件被编译的日期

__TIME__    //文件被编译的时间

__STDC__    //如果编译器遵循ANSI C，其值为1，否则未定义

#include
#include
int main() {
	printf("file:%s ,line:%d ,date:%s ,time:%s \n", __FILE__, __LINE__, __DATE__, __TIME__);
	return 0;
}

 #define

#define定义的标识符

 语法：

#define name stuff

 stuff可以有很多不同的类型。

#define MAX 100 
#define LINE "You jump,I jump!" //内容为字符串
#define REG register //register为关键字，用更简短的单词来进行替换
#define do_foever for(;;) //用更形象的方式替换死循环
// 如果定义的 stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜

//杠(续行符)。
#define PRINT printf("file:%s ,line:%d ,\
date:%s ,time:%s \n", __FILE__,\
__LINE__, __DATE__, __TIME__)

在define定义标识符的时候，最好不要加上；

因为stuff的内容会做一个替换，如果加上；，那么替换的内容就是 stuff；

#define 定义宏

#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称为宏（macro）或定义 宏（define macro）。

// 宏的声明方式：

#define name( parament-list ) stuff

其中，parament-list是一个由逗号隔开的符号表，会出现在后面的stuff中

需要注意的是：参数列表的左括号必须与name紧邻。 如果两者之间有任何空白存在，参数列表就会被解释为stuff的一部分。

#include
#define SQUARE(X) X*X
int main() {
	printf("%d\n", SQUARE(5));
    //相当于printf("%d\n", 5*5);
	return 0;
}

输出 25

那下面这条代码输出的会是什么呢？

printf("%d\n", SQUARE(5+1));

输出 11 。怎么不是36呢？让我们来替换一下，上述代码相当于：

printf("%d\n", 5+1*5+1);

所以在写宏的时候，最好该有的括号给齐。

#include
#define SQUARE(X) (X)*(X)
int main() {
	printf("%d\n", SQUARE(5+1));
	return 0;
}

这才会输出 36。

但宏这样子写，就一定能保证每次使用，算的都是X的平方数吗？再看一看下面的代码。

printf("%lf\n", 1.0/SQUARE(5+1));

输出 1.000000

肯定不对吧。所以定义宏，最好按照下面的方式写：

#include
#define SQUARE(X) ((X)*(X))
int main() {
	printf("%lf\n", 1.0/SQUARE(5+1));
	return 0;
}

再看一个加法的例子：

#include
#define DOUBLE(X) ((X)+(X))
int main() {
	printf("%d\n", 2 * DOUBLE(7));
	return 0;
}

结论：用于对数值表达式进行求值的宏定义都应该用这种方式加上括号，避免在使用宏时由于参数中 的操作符或邻近操作符之间不可预料的相互作用。

#define 替换规则

1. 在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换。

2. 替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被他们的值所替换。

3. 最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理过程。

#define M 10
#define MAX(x,y) ((x)>(y)?(x):(y))

int main()
{
	int m = MAX(2 + 3, M);
    //int m = MAX(2+3, 10);
    //替换成 ： int m = ((2+3)>(10)?(2+3):(10))
	printf("%d\n", m);
	printf("hello M");//#define 定义的标识符M，在字符串里面的是识别不了的
	return 0;
}

需要注意的是：

1. 宏参数和#define 定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归。

2. 当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被搜索。

#和##

我们发现字符串是有自动连接的特点的：

printf("hello " "world!");

输出 hello world!

那么是不是可以考虑把参数插入到字符串中？

我们可以这样操作：

#define PRINT(FORMAT,VALUE) printf("the value is "FORMAT"\n",VALUE)

......

PRINT("%lf",10.2);

 这里只有当字符串作为宏参数的时候才可以把字符串放在字符串中。

也可以利用#，把对应的宏参数转变成字符串

int i = 10;

#define PRINT(FORMAT, VALUE)\

printf("the value of " #VALUE "is "FORMAT "\n", VALUE);

......

PRINT("%d", i+3); // 产生了什么效果？

输出 the value of i+3 is 13

##的作用

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

#define CAT(A,B)  A##B

int main()
{
	int Class107 = 100;

	printf("%d\n", CAT(Class, 107));
    //等价于printf("%d\n", Class107);

	return 0;
}

带副作用的宏参数

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

具有副作用的运算符：赋值运算符、递增运算符以及递减运算符。

下面代码输出的结果是什么？

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )

...

x = 5;

y = 8;

z = MAX(x++, y++);

printf("x=%d y=%d z=%d\n", x, y, z);

 经过替换，我们有：

 z = ((x++) > (y++) ? (x++) : (y++)) ;

 输出 x=6 y=10 z=9

所以我们最好不要写带有副作用的宏参数。

宏与函数的对比

宏通常被应用于执行简单的运算。可这样一来，功能岂不是跟函数一样了？？请继续看接下来的文章，可能会让你对宏与函数的区别有了更清晰的认知。

对于那些简单的运算而言，虽然函数也能实现，但用宏更加优越。原因如下：

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

2. 更为重要的是函数的参数必须声明为特定的类型。 所以函数只能在类型合适的表达式上使用。反之这个宏适用于整形、长整型、浮点型等类型。 宏是类型无关的。

但与函数相比，宏也有缺陷：

1. 每次使用宏的时候，一份宏定义的代码将插入到程序中。除非宏比较短，否则可能大幅度增加程序的长度。比如一段宏50行，然后多次使用。

2. 宏是没法调试的。

3. 宏由于类型无关，也就不够严谨。

4. 宏可能会带来运算符优先级的问题，导致程容易出现错。（如前文所提及的括号问题）。

但宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。

#include
#include
#define MALLOC(num,type) (type*)malloc(num*sizeof(type))
int main() {
	//int* p1 = (int*)malloc(10 * sizeof(int));
	int* p2 = MALLOC(10, int);
    //预处理替换之后：int* p2 = (int*)malloc(10 * sizeof(int));
	return 0;
}

宏的命名规则

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

1. 把宏名全部大写

2. 函数名不要全部大写

但有例外，例如offsetof，它其实是个宏。

#undef

如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除。#undef这条指令用于移除一个宏定义。

#undef MALLOC

 条件编译

对于有些代码，需要根据某些条件，来决定用或不用。这时，就需要条件编译指令。使用逻辑与之前介绍过的分支语句一样，但不一样的是，选择不用的代码，预处理过后就直接被删除掉了，只有选择使用的那部分，会留下来。

条件编译指令：

1.

#if 常量表达式

//...

#endif

//常量表达式由预处理器求值。

如：

#define __DEBUG__ 1

#if __DEBUG__

//..

#endif

2.多个分支的条件编译

#if 常量表达式

//...

#elif 常量表达式

//...

#else

//...

#endif

3.判断是否被定义

#if defined(symbol)   //一个有括号

#ifdef symbol             //一个没括号，但结果是等价的

#if !defined(symbol)

#ifndef symbol

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

 单分支情况：

#include
int main() {
#if 1 //为真值
//#if 2>3 恒为假
	printf("呵呵\n");
#endif
	return 0;
}

多分支情况：

#include
int main() {
    #if 1>2
	printf("呵呵\n");
    #elif 2>4
	printf("嘿嘿\n");
    #else
	printf("哟~\n");
    #endif
	return 0;
}

 判断是否被定义：

#include
#define MAX 0
int main() {
    #if defined(MAX)
	printf("Yes\n");
    #endif
    #if !defined(MAX)
	printf("NO\n");
    #endif
	return 0;
}

 输出 Yes

另一种写法：

#include 
#define __DEBUG__

int main()
{
	int i = 0;
	int arr[10] = { 0 };
	for (i = 0; i < 10; i++)
	{
		arr[i] = i;
    #ifdef __DEBUG__
		printf("%d\n", arr[i]);//为了观察数组是否赋值成功。
    #endif //__DEBUG__
	}
	return 0;
}

这里的__DEBUG__并不需要是真值，只要定义了就可以。

文件的包含

我们已经知道， #include 指令可以使另外一个文件被编译。就像它实际出现于 #include 指令的地方 一样。

这种替换的方式很简单：

预处理器先删除这条指令，并用包含文件的内容替换。 这样一个源文件被包含10次，那就实际被编译10次。

头文件被包含的方式

1. 本地文件包含

#include "filename"

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

2. 库文件包含

#include

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

这样是不是可以说，对于库文件也可以使用" "的形式包含？

答案是肯定的，可以。 但是这样做查找的效率就低些，因为编译器会在源文件所在目录下查找。当然这样也不容易区分是库文件还是本地文件了。

嵌套文件包含

​

comm.h和comm.c是公共模块，test1.h和test1.c使用了公共模块， test2.h和test2.c使用了公共模块，test.h和test.c使用了test1模块和test2模块。

这样最终程序中就会出现两份comm.h的内容。这样就造成了文件内容的重复。 

那我们有什么办法来避免文件内容重复呢？

答案就是条件编译。

每个头文件开头这样子写：

#ifndef __TEST_H__

#define __TEST_H__

//头文件的内容

#endif   //__TEST_H__

 如果一个文件被调用了好多遍。在第一遍的时候，因为之前都是没有定义__TEST_H__，所以会走后面的内容，而当后来再一次被调用时，因为已经定义了__TEST_H__，所以后面的内容就不再执行。不管这个文件后面多少次被调用，都是如此。

或者：

#pragma once

 如此一来，就可以避免头文件的重复引入。