【预处理详解】

本文介绍: c语言设置了一些预定义符号，可以直接使用，预定义符号也是在预处理期间处理的FILE//进行编译的源文件LINE//文件当前的行号DATE//文件被编译的日期TIME//文件被编译的时间STDC//如果编译器遵循ANSI C,其值为1,否则未定义举个例子:FILELINE基本语法:举个例子#define reg register //为了register这个关键字,创建一个简短的名字😉 //用更形象的符号来替换一种实现。

1. 预定义符号

c语言设置了一些预定义符号，可以直接使用，预定义符号也是在预处理期间处理的

FILE //进行编译的源文件
LINE //文件当前的行号
DATE //文件被编译的日期
TIME //文件被编译的时间
STDC //如果编译器遵循ANSI C,其值为1,否则未定义

举个例子:

printf (“file:%s line:%dn”, FILE, LINE );

2. #define定义常量

基本语法:

#define name stuff

举个例子

#define MAX 1000
#define reg register //为了register这个关键字,创建一个简短的名字
#define do_forever for (;😉 //用更形象的符号来替换一种实现
#define CASE break ; case //在写case语句的时候自动把break写上
//如果定义的 stuff过长，可以分成几行写，除了最后一行外，每行后面加一个反斜杠（续行符），转义回车
#define DEBUG_PRINT printf (“file:%st line:%dt
date:%st time:%sn ,
FILE,LINE,
DATE,TIME”)

思考：在define定义标识符的时候，要不要在最后加上；
比如：

#define MAX 1000;
#define MAX 1000

建议不要加上 ;，这样容易导致问题
比如下面的场景：

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

如果是加了分号的情况，等替换后，if和else之间就是2条语句，而没有大括号的时候，if后边只能有一条语句，这里会出现语法错误

3. #define定义宏

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

下面是宏的申明方式:
#define name(parament-list) stuff

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

注意：

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

举例：

#define SQUARE( x ) x * x

这个宏接收一个参数x,如果在上述声明之后，你把SQUARE(5)；置于程序中，预处理就会用下面这个表达式替换上面的表达式：5 * 5

警告：
这个宏存在一个问题：
观察下面的代码段：

int a = 5 ;
printf(“%dn”, SQUARE( a + 1 )) ;

乍一看，你可能觉得这段代码将打印36，事实上它将打印11，为什么呢？
替换文本时，参数x被替换成a + 1,所以这条语句实际上变成了:

printf ( “%dn”,a + 1 * a +1 ) ;

这样就比较清晰了，由替换产生的表达式并没有按照预想的次序进行求值

在宏定义加两个括号，这个问题便轻松的解决了

#define SQUARE(x) (x) * (x)

这也预处理之后就产生了预期的效果:

printf (“%dn”, (a + 1) * (a + 1) ) ;

这里还有一个宏定义

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

定义中我们使用了括号，想避免之前的问题，但是这个宏可能会出现新的错误

int a =5 ;
printf (“%dn”, 10 * DOUBLE(a)) ;

这将打印什么值呢?看上去，好像打印100，但事实上打印的是55
我们发现替换后：

printf (“%dn”,10 * (5) + (5)) ;

乘法运算先于宏定义的加法，所以出现了55
这个问题的解决办法就是在宏定义表达式两边加上一对括号就可以了

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

提示:

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

4. 带有副作用的宏参数

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

x + 1 ; //不带副作用
x ++ ; //带有副作用

MAX宏可以证明具有副作用的参数引起的问题

#define MAX(a, b) ( (a) > (b) ? (a) : (b) )
…
x = 5 ;
y = 8 ;
z = MAX( x++, y++ ) ;
printf(“x=%d y=%d z=%dn”, x, y, z) ; //输出的结果是什么

这里我们得知道预处理处理之后的结果是什么:

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

所以输出的结果是: x = 6 y = 10 z = 9

5. 宏替换的规则

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

在调用宏时，首先对参数进行检查，看看是否包含任何由#define定义的符号。如果是，它们首先被替换
替换文本随后被插入到程序原本的位置。对于宏，参数名被他们的值所替换
最后，再次对结果文件进行扫描，看看它是否包含任何由#define定义的符号。如果是，就重复上述处理的过程

注意：

宏参数和#define定义中可以出现其他#define定义的符号。但是对于宏，不能出现递归
当预处理器搜索#define定义的符号的时候，字符串常量的内容并不被探索

6. 宏函数的对比

宏通常被应用于执行简单的运算

比如在两个数中较大的一个时，写成下面的宏，更有优势一些
#define MAX(a, b) ((a) > (b) ? (a) : (b))

那为什么不用函数来完成这个任务
原因有二:

用于调用函数和从函数返回代码可能比实际执行这个小型计算工作所需要的时间更多。所以宏比函数在程序的规模和速度方面更胜一筹
更为重要的是函数的参数必须声明为特点的类型。所以函数只能在类型合适的表达式上使用。反之，这个宏适用于整形、长整型、浮点型等可以用>来比较的类型。宏和类型是无关的

和函数相比宏的优势：

每次使用宏的时候，一份宏定义的代码插入到程序中，除非宏比较短，否则可能大幅度增加程序的长度
宏是没法调试的
宏由于类型无关，也不够严谨
宏可能会带来运算符优先级的问题，导致容易出错

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

#define MALLOC(num, type)
(type)malloc( num sizeof(type) )
…
//使用
MALLOC(10, int) ; //类型作为参数

//预处理器替换之后
(int)malloc(10 sizeof(int) ) ;

宏和函数的对比:
在这里插入图片描述

7. #和##

7.1 #运算符

#运算符将宏的一个参数转换为字符串面量。它仅允许出现在带参数的宏的替换列表中
#运算符所执行的操作可以理解为“字符串化”
当有一个变量 int a = 10 ;想打印出: the value of a is 10,可以写:

#define PRINT(n) printf (“the value of “#n” is %d”, n) ;

当我们按照下面的方式调用时:
PRINT(a) ;//当我们把a替换到宏的体内时，就出现了#a，而#a就是转换为“a”，字符串代码就会被预处理为：

printf (“the value of “a” is %d”, a) ;

运行代码就能在屏幕上打印:

the value of a is 10

7.2 ##运算符

##可以把位于它两边的符号合成一个符号，它允许宏定义从分离的文本片段创建标识符。##被称为记号粘合

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

这里我们想想，写一个函数求2个数的较大值的时候，不同的数据类型就得写不同的函数

int int_max ( int x, int y )
{
return x > y ? x : y ;
}

float float_max ( float x, float y )
{
return x > y ? x: y ;
}

这样写起来太繁琐了，现在我们这样写代码试试：

//宏定义
#define GENERIC_MAX(type)
type type##_max (type x, type y)
{
return (x > y ? x : y)
}

使用宏，定义不同函数

GENERIC_MAX(int) //替换到宏体内后int##max 生成了新的符号 int_max做函数名
GENERIC_MAX(float) //替换到宏体内后int##max 生成了新的符号 int_max做函数名

int main()
{
//调用函数
int m = int_max(2, 3) ;
printf(“%dn”, m) ;
float fm = float_max(3.5f, 4.5f) ;
printf(“%fn”, fm) ;
}

输出:

3
4.500000

8. 命名约定

一般来讲函数的宏使用语法很相似。所以语法本身没法帮我们区分二者

把宏名全部大写
函数名不要全部大写

offsetof并不是函数,本质是宏

9. undef

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

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

10. 命令行定义

许多c的编译器提供了一种能力，允许在命令行中定义符号。用于启动编译过程

例如：当我们根据同一个源文件要编译出一个程序的不同版本时，这个特性有用处。（假定某个程序中声明了一个某个长度的数组，如果机器内存有限，我们需要一个很小的数组，但是另外一个机器内存大些，需要的数组就大些）

int array[ARRAY_SIZE];
int i = 0;
for (i = 0; i < ARRAY_SIZE; i++)
{
	array[i] = i;
}
for (i = 0; i < ARRAY_SIZE; i++)
{
	printf("%d ",array[i]);
}
printf("n");

linux 环境演示
gcc -D ARRAY_SIZE = 10 programe.c

11. 条件编译

在编译个程序的时候我们如果要将一条语句(一组语句)编译或者放弃是很方便的。因为我们有条件编译指令

比如说：

调试性的代码，删除可惜，保留又碍事，所以我们可以选择性编译

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

常见的条件编译指令：

#if  常量表达式
//...
#endif
	//常量表达式由预处理器求值
//如:
#define __DEBUG__ 1
#if __DEBUG__
//...
#endif

//2.多个分支的条件编译
#if 常量表达式
//...
#elif 常量表达式
//...
#else
//...
#endif

//3.判断是否被定义
#if defined(symbol)
#endif
#ifdef symbol
#endif

#if !defined(symbol)
#endif
#ifndef symbol
#endif
//4.嵌套指令
#if defined(OS_UNIX)
	#ifdef OPTION1
		unix_version_option1();
	#endif

	#ifdef OPTION2
		unix_version_option2();
	#endif
#elif defined(OS_MSDOS)
	#ifdef OPTION2
		unix_version_option2();
	#endif
#endif

12. 头文件的包含

12.1 头文件被包含的方式:

12.1.1 本地文件包含

include “filename”

查找策略: 先在原文件所在目录查找，如果找不到，像查找库函数一样在环境变量标准位置查找，找不到就错误

linux环境的标准头文件路径:

/usr/include

vs环境的标准头文件路径:

C:Program Files (x86)Microsoft Visual Studio 12.0VCinclude
//默认位置

12.1.2 库文件包含

#include <filename.h>

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

这样是不是可以说，对于库文件也可以用“”的形式包含。这个是可以的，不过这样效率就会变低，不容易区分是什么文件

12.2 嵌套文件包含

我们知道，include指令可以使另一个文件被编译，这种替换方式很简单：预处理器先删除这条指令，并用包含文件的内容替换，一个头文件被包含十次，就实际被编译10次，对编译的压力比较大

#include “test.h”
#include “test.h”
#include “test.h”
#include “test.h”
#include “test.h”
#include “test.h”

这样写，就会拷贝6份该头文件

如果这个头文件比较大，处理后的代码量和工程就比较大。如何解决这种问题呢，就是用条件编译

每个头文件开头这样写：

#ifndef TEST_H
#define TEST_H
//头文件内容
#endif //TEST_H

或者

#pragma once

就可以避免头文件重复引入

注:
推荐《高质量C/C++编程指南》中附录的考试试卷
题目:

1.头文件中的ifndef/define/endif是干什么用的?
2.#include <filename.h>和#include “filename,h”有什么区别

13. 其他预处理指令

#error
#pragma
#Line
…
以上不多做介绍
#pragma pack() //结构体部分

参考《C语言深度解剖》学习

原文地址:https://blog.csdn.net/qq_43422358/article/details/135490649

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。

如若转载，请注明出处：http://www.7code.cn/show_54669.html

如若内容造成侵权/违法违规/事实不符，请联系代码007邮箱：suwngjj01@126.com进行投诉反馈，一经查实，立即删除！

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。

符号编译预定

目录