投稿
  1. 首页
  2. 随笔

【C语言】预处理详解

秋月无边 • 2022-12-16 • 随笔 • 阅读 21

【C语言】预处理详解,第1张

【C语言】预处理详解

目录

1.源代码生成可执行程序的过程

2.预定义符号

3.#define

3.1 #define定义标识符

3.2 #define定义宏

         3.3 #define的替换规则

3.4 #和##

3.5 带副作用的宏参数

3.6 宏和函数的对比

4.条件编译

5.文件包含

1.源代码生成可执行程序的过程

在ANSI C的任何一种实现中，存在两个不同的环境。

第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。

第2种是执行环境，它用于实际执行代码。

翻译环境可以大体分为：预编译，编译，汇编，链接。

大体过程如下：

每个阶段也有不同的作用：

想具体观察每一阶段的同学，可以自己去gcc动手实验。

本文主要探讨的就是预编译这个阶段。

2.预定义符号

在C语言中，有些内置定义的符号：

__FILE__      //进行编译的源文件
__LINE__     //文件当前的行号
__DATE__    //文件被编译的日期
__TIME__    //文件被编译的时间
__STDC__    //如果编译器遵循ANSI C，其值为1，否则未定义

eg.

3.#define
3.1 #define定义标识符 
语法：
 #define name stuff

eg.

#define MAX 100
#define reg register
#define STR "baichen"
// 如果定义的 stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜杠(续行符)。
#define DEBUG_PRINT printf("file:%stline:%dt 
                          date:%sttime:%sn" ,
                           __FILE__,__LINE__ ,       
                          __DATE__,__TIME__ )

特别注意：如果不是需要，不要在 #define name stuff后面加 ; ,因为这样就相当于多替换了一个 ; 进去，会导致很多非常隐蔽的bug。

eg.

#define MAX 1000;

if (condition)
max = MAX;
else
max = 0;

由于else必须寻找上一个if，但是MAX相当于多了一条空语句，使else查找失败。

3.2 #define定义宏

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

语法：

#define name( parament-list ) stuff

其中的 parament-list 是一个由逗号隔开的符号表，它们可能出现在stuff中。

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

eg.

#define SQUARE (x) x * x

这就相当于定义了一个SQUARE的标识符，内容是(x) x * x。

我们现在将这个bug修复

#define SQUARE( x ) x * x

int main()
{
	int a = 5;
	int ret = SQUARE(a+5);
	printf("%dn", ret);

	return 0;
}

会输出我们预期中的100吗？

结果好像和我们的预期不一样，这是为什么呢？

宏本质上只是对内容的替换，传递参数时并不会进行运算，只是单纯的替换。

所以上式替换为了 a+5*a+5 ，结果为35。

所以要怎么才能得到预期的答案呢？

#define SQUARE(X) ((X)*(X))

int main()
{
	int a = 5;
	int ret = SQUARE(a+5);
	printf("%dn", ret);

	return 0;
}

将参数用括号括起来，保证运算次序就可以了。

再来看一个例子

#define DOUBLE(x) (x) + (x)
int a = 5;
printf("%dn" ,10 * DOUBLE(a));

看上去，好像打印100，但事实上打印的是55。

大家可以自行替换一下，替换的形式是 10*(5)+(5) ，得到55。

如果想得到正确答案，可以在宏运算结果前加上括号。

#define DOUBLE( x)   ( ( x ) + ( x ) )

提示：

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

#undef 

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

#undef NAME
//如果现存的一个名字需要被重新定义，那么它的旧名字首先要被移除。
3.3 #define的替换规则

在程序中扩展#define定义符号和宏时，需要涉及几个步骤。

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

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

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

注意：

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

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

#define ptr_t int*
typedef int* ptr_t2;


int main()
{
	ptr_t p1, p2;
	//预处理后替换为int *p1, p2;
	//p1是指针，p2是整形的
	ptr_t2 p3, p4;//p3和p4都是指针类型

	return 0;
}

要特别注意#define定义的类型和typedef定义的类型间的区别。

#define只是单纯的替换，后面的变量按照正常语法规则走。

typedef就是相当于重新定义了一个变量类型，后面的变量都是这个类型的变量。

3.4 #和## 

int main()
{
	
	printf("hello"  " worldn");
	printf("hello worldn");
	return 0;

}

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

利用这个特性，我们可以干很多有趣的事情。

我们想用一个宏来实现：

    int a = 10;
	printf("the value of a is %dn", a);

	int b = 20;
	printf("the value of b is %dn", b);

就是要一个变量名打印一个参数。

这个实现用函数显然不太可能，因为函数只能传递值，变量名应该怎么办呢？

这就要用到宏的一个优势了。

使用 # ，把一个宏参数变成对应的字符串。

#define PRINT(n) printf("the value of "#n" is %dn", n)

int main()
{
	int a = 10;
	PRINT(a);
	int b = 20;
	PRINT(b);
	
	return 0;
}

 此时编译器会将 #n 处理为"n"，而不是n的值

同理，我们可以玩的再花一点

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，大家可以自行替换加验证。

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

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

eg.

#define CAT(X,Y) X##Y

int main()
{
	int baichen = 100;
	printf("%dn", CAT(bai, chen));
	printf("%dn", CAT(1, 2));
	return 0;
}

注： 这样的连接必须产生一个合法的标识符。否则其结果就是未定义的。 

3.5 带副作用的宏参数

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

 eg.

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

int main()
{
	int x = 5;
	int y = 8;
	int z = MAX(x++, y++);
	printf("x=%d y=%d z=%dn", x, y, z); 

	return 0;
}

我们可以翻译一下，z = ( (x++) > (y++) ? (x++) : (y++)) 。

3.6 宏和函数的对比

宏的优点：

1.宏比函数在程序的规模和速度方面更胜一筹。

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

当然和宏相比函数也有劣势的地方：

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

2. 宏是没法调试的。

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

4. 宏可能会带来运算符优先级的问题，导致程容易出现错。 宏有时候可以做函数做不到的事情。比如：宏的参数可以出现类型，但是函数做不到。

命名区别：

宏名全部大写

函数名不要全部大写

4.条件编译

 条件编译指的是：满足条件代码就参与编译，不满足条件，代码就不参与编译

#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

eg.

#define M 2

int main()
{
	int a = 2;
#if M==2
	printf("hehen");
#endif
	return 0;
}

当M==2是，#if 和 #endif 中间的语句参与编译。

#define M 500

int main()
{
#if M==100
	printf("hahan");
#elif M==200
	printf("hehen");
#else
	printf("heihein");
#endif


	return 0;
}

类比if，else if，else语法。

int main()
{
    //判断符号是否被定义
#if defined(MAX)
	printf("hehe:MAXn");
#endif
	
	//判断符号是否未被定义
#ifndef MAX
	printf("haha:MAXn");
#endif

	return 0;
}

如果MAX未定义输出haha，定义输出hehe。

5.文件包含

本地文件包含： 

#include "filename"

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

当然，也可以指定路径

#include "C:\Users\baichen\Desktop\add.h"

库函数文件包含：

#include

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

由上面的查找策略，我们可以推断出，库函数也可以用 "" 包含，只不过不好区分而且效率会慢很多。

如何避免文件重复包含呢？

在头文件开头写：

#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
#endif   //__TEST_H__

或者

#pragma once

以上就是本次的分享内容了，喜欢我的分享的话，别忘了点赞加关注哟！

如果你对我的文章有任何看法，欢迎在下方评论留言或者私信我鸭！

我是白晨，我们下次分享见！！

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/5658037.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
秋月无边 秋月无边 一级用户组
0 0
上一篇 2022-12-16
下一篇 2022-12-16

发表评论

登录后才能评论

评论列表（0条）

保存