伪指令(或预处理指令)定义:

预处理指令是以#号开头的代码行。#号必须是该行除了任何空白字符外的第一个字符。#后是指令关键字,在关键字和#号之间允许存在任意个数的空白字符。整行语句构成了一条预处理指令,该指令将在编译器进行编译之前对源代码做某些转换。下面是部分预处理指令:

1
2
3
4
5
6
7
8
9
10
11
指令          用途
# 空指令,无任何效果
#include 包含一个源代码文件
#define 定义宏
#undef 取消已定义的宏
#if 如果给定条件为真,则编译下面代码
#ifdef 如果宏已经定义,则编译下面代码
#ifndef 如果宏没有定义,则编译下面代码
#elif 如果前#if条件不为真,当前条件为真,则编译下面代码,其实就是else if的简写
#endif 结束一个#if……#else条件编译块
#error 停止编译并显示错误信息

特殊符号

预编译程序可以识别一些特殊的符号。预编译程序对于在源程序中出现的这些串将用合适的值进行替换。

_FILE_ 包含当前程序文件名的字符串
_LINE_ 表示当前行号的整数
_DATE_ 包含当前日期的字符串
_STDC_ 如果编译器遵循ANSI C标准,它就是个非零值
_TIME_ 包含当前时间的字符串

例子

1
2
3
4
5
6
7
#include<stdio.h>
int main() {
printf("%s\n",__FILE__);
printf("%d\n",__LINE__);
printf("%s\n",__DATE__);
return 0;
}

1. 宏定义

1.1 不带参数

宏定义又称为宏代换、宏替换,简称“宏”。预处理(预编译)工作也叫做宏展开:将宏名替换为字符串, 即在对相关命令或语句的含义和功能作具体分析之前就要换。

格式:

1
\#define 标识符 字符串

其中标识符就是所谓的符号常量,也称为“宏名”。
例:

1
\#define Pi 3.1415926//把程序中出现的Pi全部换成3.1415926

说明:

(1)宏名一般用大写;
(2)使用宏可提高程序的通用性和易读性,减少不一致性,减少输入错误和便于修改。例如:数组大小常用宏定义;
(3)预处理是在编译之前的处理,而编译工作的任务之一就是语法检查,预处理不做语法检查;
(4)宏定义末尾不加分号;
(5)宏定义写在函数的花括号外边,作用域为其后的程序,通常在文件的最开头;
(6)可以用#undef命令终止宏定义的作用域;
(7)宏定义允许嵌套;
(8)字符串( " " )中永远不包含宏;
(9)宏定义不分配内存,变量定义分配内存;
(10)宏定义不存在类型问题,它的参数也是无类型的。

1.2 带参数

除了一般的字符串替换,还要做参数代换,格式:

1
#define 宏名(参数表) 字符串

例如:

1
2
#define S(a,b) (a)*(b)
area=S(3,2);//第一步被换为area=a*b; ,第二步被换为area=3*2;

(1)实参如果是表达式容易出问题

1
2
3
4
5
#define S(r) r*r
area=S(a+b);
//第一步换为area=r*r;,第二步被换为area=a+b*a+b;
正确的宏定义是:
#define S(r) ((r)*(r))

(2)宏名和参数的括号间不能有空格;
(3)宏替换只作替换,不做计算,不做表达式求解;
(4)函数调用在编译后程序运行时进行,并且分配内存。宏替换在编译前进行,不分配内存
(5)宏的哑实结合不存在类型,也没有类型转换。
(6)宏展开使源程序变长,函数调用不会
(7)宏展开不占运行时间,只占编译时间,函数调用占运行时间(分配内存、保留现场、值传递、返回值)。

1.3 冷门重点编辑

1.3.1 #define用法

1、用无参宏定义一个简单的常量
#define LEN 12
这个是最常见的用法,但也会出错。比如下面几个知识点你会吗?可以看下:

(1)#define NAME “zhangyuncong” 程序中有"NAME"则,它会不会被替换呢?
(2)#define 0x abcd 可以吗?也就是说,可不可以用不是标识符的字母替换成别的东西?
(3)#define NAME "zhang 这个可以吗?
(4)#define NAME “zhangyuncong”

程序中有上面的宏定义,并且,程序里有句:NAMELIST,会不会被替换成:
"zhangyuncong"LIST

四个题答案都是十分明确的。

第一个,"“内的东西不会被宏替换。这一点应该大家都知道;
第二个,宏定义前面的那个必须是合法的用户标识符;
第三个,宏定义也不是说后面东西随便写,不能把字符串的两个”"拆开;
第四个:只替换标识符,不替换别的东西。NAMELIST整体是个标识符,而没有NAME标识符,所以不替换。

也就是说,这种情况下记住:#define第一位置第二位置

(1) 不替换程序中字符串里的东西;
(2) 第一位置只能是合法的标识符(可以是关键字);
(3) 第二位置如果有字符串,必须把""配对;
(4) 只替换与第一位置完全相同的标识符。
还有就是老生常谈的话:记住这是简单的替换而已,不要在中间计算结果,一定要替换出表达式之后再算。

1.3.2 带参宏一般用法

比如

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

则遇到 MAX(1+2,value) 则会把它替换成:
((1+2)>(value)?(1+2):(value))

注意事项和无参宏差不多。 但还是应注意

1
2
3
#define FUN(a) "a"
int a = 345;
char x = FUN(a); // x = 'a'

则,输入FUN(345)会被替换成什么?
其实,如果这么写,无论宏的实参是什么,都不会影响其被替换成"a"的命运。也就是说,""内的字符不被当成形参,即使它和一模一样。那么,你会问了,我要是想让这里输入FUN(345)它就替换成"345"该怎么实现呢?请看下面关于#的用法

1.3.3 有参宏定义中#的用法

1
#define STR(str) #str  //#用于把宏定义中的参数两端加上字符串的""

比如,这里STR(my#name)会被替换成"my#name"
一般由任意字符都可以做形参,但以下情况会出错:

STR())这样,编译器不会把“)”当成STR()的参数。
STR(,)同上,编译器不会把“,”当成STR的参数。

STR(A,B)如果实参过多,则编译器会把多余的参数舍去。(VC++2008为例)
STR((A,B))会被解读为实参为:(A,B),而不是被解读为两个实参,第一个是(A第二个是B)。

1.3.4 有参宏定义中##的用法

#define WIDE(str) L##str
则会将形参str的前面加上L 比如:WIDE(“abc”)就会被替换成L"abc"
如果有#define FUN(a,b) vo##a##b()
那么FUN(id ma,in)会被替换成void main()

1.3.5 多行宏定义:

1
2
3
4
#define doit(m,n) for(int i=0;i<(n);++i)\
{\
m+=i;\
}

1.3.6 #undef

#undef 作用:在后面取消以前定义的宏定义。一旦标识符被定义成一个宏名称,它将保持已定义状态且在作用域内,直到程序结束或者使用#undef 指令取消定义。

1
2
3
4
5
#define TEST_A 1
#define TEST_CLASS_A clase T1
#include "TEST.h"
#undef TEST_A
#undef TEST_CLASS_A

说明:在文件#include “TEST.h” 中宏定义#define TESTA 1、#define TESTCLASS_A clase T1 起作用,过了这一语句宏定义就释放掉了,在test.h里,这个宏是有效的,然后出了这个头文件,又无效了。

2. 文件包含

由来:文件包含处理在程序开发中会给我们的模块化程序设计带来很大的好处,通过文件包含的方法把程序中的各个功能模块联系起来是模块化程序设计中的一种非常有利的手段。

定义:文件包含处理是指在一个源文件中,通过文件包含命令将另一个源文件的内容全部包含在此文件中。在源文件编译时,连同被包含进来的文件一同编译,生成目标目标文件。

文件包含的处理方法:

(1) 处理时间:文件包含也是以"#"开头来写的(#include ), 那么它就是写给预处理器来看了, 也就是说文件包含是会在编译预处理阶段进行处理的。

(2) 处理方法:在预处理阶段,系统自动对#include命令进行处理,具体做法是:将包含文件的内容复制到包含语句(#include )处,得到新的文件,然后再对这个新的文件进行编译。

其一般形式为:

1
2
\#include " 文件名"  
\#include <文件名>

但是这两种形式是有区别的: 使用双撇号 (即〝stdio.h〞形式)时,系统首先在用户当前目录中寻找要包含的文件,若未找到才到包含目录中去查找; 使用尖括号(即<math.h>形式)时,表示在包含文件目录中去查找(包含目录是由用户在设置环境时设置的),而不在源文件目录去查找。若文件不在当前目录中,双撇号内可给出文件路径。

关于头文件的写法个人总结以下几点:

(1) 对应的.c文件中写变量、函数的定义;
(2) 对应的.h文件中写变量、函数的声明;
(3) 如果有数据类型的定义和宏定义,请写在头文件(.h)中;
(4) 头文件中一定加上#ifndef…#define…#endif 之类的防止头文件被重包含的语句;
(5) 模块的.c文件中别忘包含自己的.h文件。

3.条件编译 conditional compilation

程序员可以通过定义不同的宏来决定编译程序对哪些代码进行处理。条件编译指令将决定哪些代码被编译,而哪些不被编译的。可以根据表达式的值或者某个特定的宏是否被定义来确定编译条件。

#if/#endif/#else/#elif指令

一般形式

(1)
#if表达式
//语句段1
#else
//语句段2
#endif
如果表达式为真,就编译语句段1,否则编译语句段2


(2)
\ #if 表达式1
//语句段1
#elif 表达式2
//语句段2
#else
//语句段3
#endif
如果表达式1真,则编译语句段1,否则判断表达式2;如果表达式2为真,则编译语句段2,否则编译语句段3


(3)
#ifdef 宏名
//语句段
#endif
作用:如果在此之前已定义了这样的宏名,则编译语句段。


(4)
#ifndef宏名
//语句段
#endif
作用:如果在此之前没有定义这样的宏名,则编译语句段。#else可以用于#ifdef和#ifndef中,但#elif不可以。

//例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define DEBUG   //此时#ifdef DEBUG为真
//#define DEBUG //此时为假
int main() {
#ifdef DEBUG
printf("Debugging\n");
#else
printf("Not debugging\n");
#endif
printf("Running\n");
return 0;
}
//输出结果是:
Debugging
Running

//例

1
2
3
4
5
6
7
8
9
10
11
#define TWO
int main() {
#ifdef ONE
printf("1\n");
#elif defined TWO
printf("2\n");
#else
printf("3\n");
#endif
}
//输出结果是:2

#ifdef和#ifndef

这二者主要用于防止头文件重复包含。我们一般在.h头文件前面加上这么一段:

1
2
3
4
5
//防止头文件重复包含funcA.h
#ifndef FUNCA_H
#define FUNCA_H
//头文件内容
#endif

这样,如果a.h包含了funcA.h,b.h包含了a.h、funcA.h,重复包含,会出现一些type redefination之类的错误。

#if defined name 等价于#ifdef name
#if !defined name 等价于#ifndef name

#error

#error命令是C/C++语言的预处理命令之一,当预处理器预处理到#error命令时将停止编译并输出用户自定义的错误消息。 语法:

#error [用户自定义的错误消息]
注:上述语法成份中的方括号“[]”代表用户自定义的错误消息可以省略不写。

//例

用法示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/*
*检查编译此源文件的编译器是不是C++编译器
*如果使用的是C语言编译器则执行#error命令
*如果使用的是 C++ 编译器则跳过#error命令
*/
#ifndef __cplusplus
#error 亲,您当前使用的不是C++编译器噢!
#endif
#include <stdio.h>
int main() {
printf("Hello,World!");
return 0;
}
```

####\#line

\#line指令改变LINE与FILE的内容,它们是在编译程序中预先定义的标识符。

#### \#pragma

\#pragma指令没有正式的定义。编译器可以自定义其用途。典型的用法是禁止或允许某些烦人的警告信息。

//例

```c
#line 100 //初始化行计数器
#include<stdio.h>//行号100
int main() {
printf("Hello World!\n");
printf("%d",__LINE__);
return 0;
}
//输出104