目录
- 前言
- 1.预定义符号
- 2.#define定义常量
- 3.#define定义宏
- 4.带有副作用的宏参数
- 5.宏替换的规则
- 6.宏和函数的对比
- 7.#和##运算符
- 7.1 #运算符
- 7.2 ##运算符
- 8.命名约定
- 9.undef
- 10.命令行指令
- 11.条件编译
- 12.头文件的包含
- 12.1 头文件包含方式
- 12.1.1 本地头文件包含
- 12.1.2 库文件包含
- 12.2 嵌套文件包含
- 13.其他预处理指令
- 总结
前言
我们了解预处理有利于理解程序运行,自行查找问题以及代码修复。
1.预定义符号
C语言设置了一些预定义符号,可以直接使用,会在预处理期间处理。
__FILE__ //进行编译的源文件
__LINE__ //文件当前的行号
__DATE__ //文件被编译的日期
__TIME__ //文件被编译的时间
__STDC__ //如果编译器遵循ANSI C,其值为1,否则未定义
测试代码如下:
#include <stdio.h>
int main()
{
printf(" __FILE__: %s\n", __FILE__);
printf(" __LINE__: %d\n", __LINE__);
printf(" __DATE__: %s\n", __DATE__);
printf(" __TIME__: %s\n", __TIME__);
//printf(" __STDC__: %D\n", __STDC__);
return 0;
}
VS2022 X64输出结果如下
VS未定义__STDC__
.
2.#define定义常量
基本语法:
#define name stuff
测试代码如下
#include <stdio.h>
#define MAX 100//定义常量
#define reg register//为关键字register创建一个简短的名字
#define do_forever for(;;)//死循环,用更形象的符号来替换一种实现
#define CASE break;case//在写case语句的时候自动加上break
//定义的stuff过长,可以分成几行写,除最后一行,每行后面加续行符'\'
#define DEBUG_PRINT printf("file:%s\nline:%d\n\
date:%s\ntime:%s\n",\
__FILE__,__LINE__,\
__DATE__,__TIME__)
int main()
{
//CASE测试
int input = 1;
switch(input)
{
case 0:
//
CASE 1:
//
break;
}
//测试
DEBUG_PRINT;
return 0;
}
VS2022 X64输出结果如下
注:#define定义标识符最好不要在末尾加";
",因为#define name stuff
就是将name
换成stuff
,如果是stuff;
,原本的name
就会被替换成stuff;
举个例子
#include <stdio.h>
#define M 100;
int main()
{
int a = M;
printf("%d\n", M);
return 0;
}
上面的代码等价于下面的代码
#include <stdio.h>
int main()
{
int a = 100;;//这个地方没问题,因为;等价于空语句
printf("%d\n", 100;);//但是这个地方影响打印,会报错
if(1)
a = M;//这个地方也有问题,因为if后没有{},只能跟一条语句,现在是两条语句
else
a = 0;
return 0;
}
VS2022 X64系统如下
3.#define定义宏
#define机制包括了一个规定,允许把参数替换到文本中,这种实现通常称为宏(macro)或定义宏(define macro)。
下面是宏的申明方式:
#define name(parament-list) stuff
其中的parament-list
是一个由逗号隔开的符号表,它们可能出现在stuff中。
注意:
参数列表的左括号必须与name相邻,如果两者之间有任何空白存在,参数列表就会被解释为stuff的一部分。
举个例子:
#define SQUARE(x) x*x
该宏接收参数x,用x*x的值代替SQUARE(x).
测试代码如下:
#include <stdio.h>
#define SQUARE(x) x*x
int main()
{
printf("%d\n", SQUARE(5));
printf("%d\n", SQUARE(5+1));
return 0;
}
VS2022 X64输出结果如下
25
11
其实宏替换的时候是直接替换,不会对传入的表达式进行计算,所以SQUARE(5+1)等价于5+1*5+1
,因此第二行的结果是11.
所以我们要考虑在参数的外面带上括号,防止由于相邻操作符优先级的关系导致结果有误差。
对宏定义修改后,下面代码的输出结果是36.
#include <stdio.h>
#define SQUARE(x) (x)*(x)
int main()
{
printf("%d\n", SQUARE(5+1));
return 0;
}
最安全的方式其实是在最后结果也加上括号,如下代码所示。
#define SQUARE(x) (x)*(x)
比如下面这段代码输出结果是66,是10*(5+1)+(5+1),但我们想要的是10ADD(6),也就是1012=120.
#include <stdio.h>
#define ADD(x) (x)+(x)
int main()
{
printf("%d\n", 10*ADD(5 + 1));
return 0;
}
修改后的代码如下所示,输出结果是120.
#include <stdio.h>
#define ADD(x) ((x)+(x))
int main()
{
printf("%d\n", 10*ADD(5 + 1));
return 0;
}
综上所述,宏定义要注意在各个参数以及最终结果加上括号。
4.带有副作用的宏参数
比如前置、后置++(–)会对参数本身进行修改,所以我们在定义宏的时候,如果传入的参数是a++等内容,特别是多次替换的情况下,由于参数本身被修改,结果将会是不可预测的。
举个例子:
#include <stdio.h>
#define MAX(a,b) ((a)>(b)?(a):(b))
int main()
{
int x = 5;
int y = 8;
int z = MAX(x++, y++);
printf("%d %d %d\n", x, y, z);
return 0;
}
代码int z = MAX(x++, y++);
等价于int z = ((x++)>(y++)?(x++):(y++));
后置++是先使用后++,首先进行x与y的比较,x<y,且此时x变成6,y变成9,执行z = y++
,z变成9,y+1变成10.
VS2022 X64输出结果如下
6 10 9
但是我们想要的是x和y进行比较,将较大的值赋给z.
当然这个例子感觉有些“为赋新词强说愁”的意味,但是有时候确实会存在参数自身发生变化导致宏结果的不确定性。所以在使用宏的时候尽量不要去传带有++、- -这些运算符的参数,很容易出现意想不到的结果。
5.宏替换的规则
在程序中扩展#define定义符号和宏时,需要涉及几个步骤。
- 在调用宏时,首先对参数进行检查,看是否包含任何由#define定义的符号。如果是,首先替换这些符号。
- 替换文本随后被插入到程序中原来文本的位置,对于宏,参数名被其值替换。
- 最后再次对结果文件进行扫描,看看它是否包含任何由#define定义的符号。如果是,重复上述处理过程。
注意:
- 宏参数和#define定义中可以出现其它#define定义的符号。但是宏,不能递归!
- 当预处理器搜索#define定义的符号的时候,字符串常量的内容并不被搜索。
举例说明第二点如下所示:
#include <stdio.h>
#define MAX(a,b) ((a)>(b)?(a):(b))
int main()
{
int a = MAX(3, 4);
printf("MAX(3,4)=%d\n",a);//字符串中的宏不会被替换
return 0;
}
VS2022 X64输出结果如下
MAX(3,4)=4
6.宏和函数的对比
宏通常被应用于执行简单的运算,比如在两个数字=中找出较大的一个时,写成下面的宏,更有优势一些。
#define MAX(a,b) ((a)>(b)?(a):(b))
为什么不用函数来完成这个任务呢?
原因有二:
- 用于调用函数和从函数返回的代码可能比实际执行这个小型计算工作所需要的时间更多,所以宏比函数在程序的规模和速度方面更胜一筹。
- 更为重要的是,函数的参数必须声明为特定的类型,所以函数只能在类型合适的表达式上使用,反之,这个宏可以适用于整型、长整型、浮点型等可以用
>
比较的类型,宏的参数与类型无关。
和函数相比宏的劣势:
- 每次使用宏的时候,一份宏定义的代码将插入到程序中。除非宏比较短,否则可能大幅度增加程序的长度。
- 宏是没法调试的。
- 宏由于类型无关,也就不够严谨。
- 宏可能带来运算符优先级的问题,导致结果可能不确定。
宏有时候可以做函数做不到的事情,比如,宏的参数可以出现类型,但是函数不可以。
举例代码如下:
#include <stdio.h>
#include <stdlib.h>
#define MALLOC(num,type)\
(type*)malloc(num*sizeof(type))
int main()
{
int* p= MALLOC(10, int);
if (p = NULL)
{
perror("MALLOC");
return 1;
}
for (int i = 0; i < 10; i++)
p[i] = i + 1;
for (int i = 0; i < 10; i++)
printf("%d ",p[i]);
return 0;
}
综上,宏和函数的比较如下:
7.#和##运算符
7.1 #运算符
#运算符将宏的一个参数转换为字符串字面量,仅出现在带参数的宏替换列表中。
对于变量a,其值为10,我们想打印:the value of a is 10
.
可以用以下宏定义:
#define PRINT(n) printf("the value of " #n " is %d\n",n)
//同一行多个字符串打印的时候会自动拼接,#n会自动转化为字符串
举例如下:
#include <stdio.h>
#define PRINT(n) printf("the value of " #n " is %d\n",n)
int main()
{
int a=10,b=11,c=12;
PRINT(a);
PRINT(b);
PRINT(c);
return 0;
}
VS2022 X64输出结果如下所示
7.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)
GENERIC_MAX(float)
int main()
{
int a = int_max(2, 3);
printf("%d\n", a);
float b = float_max(2, 3);
printf("%f\n", b);
return 0;
}
VS2022 X64输出结果如下所示
3
3.000000
在实际开发中##使用较少,很难举出非常贴切的例子。
8.命名约定
一般来讲,函数和宏的使用语法很相似,
命名习惯为:宏定义一般都会将name的所有字母设置为大写,函数名一般只有开头字母大写。
9.undef
该指令用于移除一个宏定义。
#define M 10
#undef M//首先移除旧的宏定义名,才能重新定义
#define M 10
10.命令行指令
许多C的编译器提供了一种能力,允许在命令行中定义符号,用于启动编译过程。
例如:可以用于同一个源文件编译一个程序的不同版本(假定某个程序中声明了一个某个长度的数组,如果机器内存有限,我们需要一个很小的数组,但是另外一个机器内存大一些,我们需要一个大一些的数组)。
#include <stdio.h>
int main()
{
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" );
return 0;
}
编译指令:
//linux环境
gcc -D ARRAY_SIZE=10 programe.c
11.条件编译
在编译一个程序的时候,可以使用条件语句选择性编译语句。
比如:调试性的代码。
#include <stdio.h>
#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;
}
常见的条件编译指令:
1.
#if 常量表达式
//...
#endif
//常量表达式由预处理器求值
如:
#define __DEBUG__ 1
#if __DEBUG__
printf("haha\n");
#endif
2.多个分支的条件编译
#if 常量表达式
//...
#elif 常量表达式
//...
#else
//...
#endif
举例代码如下:
#include <stdio.h>
#define __DEBUG__ 2
#if __DEBUG__==0
printf("hehe\n");
#elif __DEBUG__==1
printf("haha\n");
#else
printf("heihei\n");
#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
12.头文件的包含
12.1 头文件包含方式
12.1.1 本地头文件包含
#include "filename"
查找策略:先在源文件所在目录下查找,如果该头文件未找到,编译器就像查找库函数头文件一样在标准位置查找文件。
Linux环境的标准头文件路径:
/usr/include
VS环境的标准头文件路径:
C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include
//这是VS2013的默认路径
根据安装路径去找。
12.1.2 库文件包含
#include <filename.h>
一般标准头文件格式为#include <stdio.h>
,即使用<>
,而不是""
;使用""
的头文件查找策略如上所述,使用<>
的头文件会直接在标准位置查找。所以,如果对库文件使用""
,会先在目录文件下寻找,但这是浪费时间的,效率较低,并且也不容易区分到底是库文件还是本地文件。
12.2 嵌套文件包含
#include指令可以使一个文件被编译,预处理会将这条指令的内容替换为该文件包含的内容。
但是,如果多次引用头文件,头文件内容就会被多次包含,对编译的压力比较大。
test.h
void test();
struct Stu
{
int id;
char name[20];
};
test.c
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
#include "test.h"
int main()
{
return 0;
}
如果是这样的话,test.c文件将5次包含test.h的内容,如果tets.h内容比较多,预处理代码剧增。如果工程较大,公共使用的头文件被多次引用,不做任何处理,导致预处理后的代码冗余。
每个头文件的开头写:
#ifndef __TEST_H__
#define __TEST_H__
//头文件的内容
#endif //__TEST_H__
或者
#pragma once
可以避免头文件的重复引入
注:推荐《⾼质量C/C++编程指南》中附录的考试试卷(很重要)。
笔试题:
- 头⽂件中的 ifndef/define/endif是⼲什么用的?
- #include <filename.h> 和 #include “filename.h” 有什么区别?
13.其他预处理指令
#error
#pragma
#line
...//大家有兴趣自行了解
#pragma pack()//用于改变编译器结构体的默认对齐数
参考《C语言深度解剖》学习。
总结
“路漫漫其修远兮,吾将上下而求索。”是C语言最后一篇啦,下次就是数据结构啦!头文件、宏定义等内容比较多,记得消化哟~