C语言预处理器详解与实现机制

2星需积分: 9 47 浏览量更新于2024-08-02 收藏 462KB PDF 举报

“C 预处理器介绍以及如何实现的” C 预处理器是 C 编译过程中的一个重要环节，它在程序实际编译之前执行一系列的文本替换和处理任务，提高了代码的可复用性和模块化。预处理器的主要工作包括宏定义、头文件包含、条件编译等。 1. **字符集** (Charactersets) 在 C 语言中，预处理器处理的文本是基于特定的字符集，通常是 ASCII 或 Unicode。预处理器会识别这些字符并进行相应的处理，例如，识别注释、字符串字面量和标识符。 2. **初步处理** (Initialprocessing) 预处理器首先会移除源代码中的注释。C 语言有两种类型的注释：单行注释（始于 `//`）和多行注释（始于 `/*` 和止于 `*/`）。预处理器不会对注释内的内容进行进一步的处理。 3. **分词化** (Tokenization) 分词化是将源代码分解成一个个称为“token”的基本单元。这些 token 包括标识符（如变量名）、关键字（如 `int`、`if`）、运算符（如 `+`、`=`）、常量（如整数、浮点数、字符字面量）和字符串字面量。每个 token 都具有特定的含义，预处理器会根据这些 token 执行后续的操作。 4. **预处理语言** (The preprocessing language) 预处理器有自己的简单语言，主要由宏定义组成。宏定义允许程序员创建可以替代文本的符号，这些符号可以在编译时展开，从而实现代码的动态替换。宏有两种类型：对象-like 宏（无参数的宏，如 `#define PI 3.14`）和函数-like 宏（带有参数的宏，如 `#define SQUARE(x) ((x) * (x))`）。 5. **头文件** (Header Files) - **包含语法** (Include Syntax) 头文件通常包含函数声明、常量定义和其他共享的代码片段。通过 `#include` 指令，可以将头文件的内容插入到源文件中。有两种包含方式：`#include <file>`（用于系统头文件）和 `#include "file"`（用于用户头文件）。 - **包含操作** (Include Operation) 当遇到 `#include` 指令时，预处理器会读取指定的文件内容并将其插入到当前源文件的当前位置。 - **搜索路径** (Search Path) 预处理器会在一系列预先设定的目录（搜索路径）中查找被包含的头文件。系统头文件的路径通常固定，而用户头文件的路径可以是相对或绝对的，并且可以通过 `-I` 编译选项自定义。 - **一次只包含一次** (Once-Only Headers) 为了避免头文件被多次包含导致的问题，C 预处理器提供了 `#ifndef`、`#define`、`#endif` 结构来确保头文件只被包含一次，这被称为“头文件卫士”。 6. **条件编译** (Conditional Compilation) 预处理器支持条件编译指令，如 `#ifdef`, `#ifndef`, `#if`, `#else`, `#elif`, `#endif`，允许程序员根据某些条件选择性地编译部分代码。这在处理平台差异、编译选项或调试时非常有用。 7. **文本替换** (Text Substitution) 除了宏定义外，预处理器还负责其他形式的文本替换，如 `#define` 宏展开、`#undef` 去除宏定义、`#line` 修改源代码行号和文件名信息，以及 `#pragma` 指令用于编译器特定的指令。 8. **字符串化** (Stringification) 通过 `#` 运算符，预处理器可以将非字符串 token 转换为对应的字符串字面量，这对于打印或记录宏参数的值非常有用。 9. **拼接** (Concatenation) 使用 `##` 运算符，预处理器可以连接两个 token 生成一个新的 token，这是创建动态标识符的一种方法。总结来说，C 预处理器是 C 编程中一个不可或缺的部分，它在编译前对源代码进行处理，提高了代码的可维护性和可移植性。理解预处理器的工作原理对于编写高效的 C 代码至关重要。

Chapter 2: Header Files 8

2.1 Include Syntax

Both user and system header ﬁles are included using the preprocessing directive ‘#include’.

It has two variants:

#include <file >

This variant is used for system header ﬁles. It searches for a ﬁle named ﬁle in

a standard list of system directories. You can prepend directories to this list

with the ‘-I’ option (see Chapter 12 [Invocation], page 50).

#include "file "

This variant is used for header ﬁles of your own program. It searches for a ﬁle

named ﬁle ﬁrst in the directory containing the current ﬁle, then in the same

directories used for <file >.

The argument of ‘#include’, whether delimited with quote marks or angle brackets,

behaves like a string constant in that comments are not recognized, and macro names are

not expanded. Thus, #include <x/*y> speciﬁes inclusion of a system header ﬁle named

‘x/*y’.

However, if backslashes occur within ﬁle, they are considered ordinary text characters,

not escape characters. None of the character escape sequences appropriate to string con-

stants in C are processed. Thus, #include "x\n\\y" speciﬁes a ﬁlename containing three

backslashes. (Some systems interpret ‘\’ as a pathname separator. All of these also interpret

‘/’ the same way. It is most portable to use only ‘/’.)

It is an error if there is anything (other than comments) on the line after the ﬁle name.

2.2 Include Operation

The ‘#include’ directive works by directing the C preprocessor to scan the speciﬁed ﬁle as

input before continuing with the rest of the current ﬁle. T he output from the preprocessor

contains the output already generated, followed by the output resulting from the included

ﬁle, followed by the output that comes from the text after the ‘#include’ directive. For

example, if you have a header ﬁle ‘header.h’ as follows,

char *test (void);

and a main program called ‘program.c’ that uses the header ﬁle, like this,

int x;

#include "header.h"

int

main (void)

{

puts (test ());

}

the c ompiler will see the same token stream as it would if ‘program.c’ read

int x;

char *test (void);

int

main (void)

{

puts (test ());

Chapter 2: Header Files 9

}

Included ﬁles are not limited to declarations and macro deﬁnitions; those are merely the

typical uses. Any fragment of a C program can be included from another ﬁle. The include

ﬁle could even contain the beginning of a statement that is concluded in the containing ﬁle,

or the end of a statement that was started in the including ﬁle. However, an included ﬁle

must consist of c omplete tokens. Comments and string literals which have not been closed

by the end of an included ﬁle are invalid. For error recovery, they are considered to end at

the e nd of the ﬁle.

To avoid confusion, it is best if header ﬁles contain only complete syntactic units—

function declarations or deﬁnitions, type declarations, etc.

The line following the ‘#include’ directive is always treated as a separate line by the C

preprocessor, even if the included ﬁle lacks a ﬁnal newline.

2.3 Search Path

GCC looks in s everal diﬀerent places for headers. On a normal Unix system, if you do not

instruct it otherwise, it will look for headers requested with #include <file > in:

/usr/local/include

libdir /gcc/target /version /include

/usr/target /include

/usr/include

For C++ programs, it will also look in ‘/usr/include/g++-v3’, ﬁrst. In the above, target

is the canonical name of the system GCC was conﬁgured to compile code for; often but not

always the same as the canonical name of the system it runs on. version is the version of

GCC in use.

You can add to this list with the ‘-Idir ’ command line option. All the directories named

by ‘-I’ are searched, in left-to-right order, before the default directories. The only exception

is when ‘dir’ is already searched by default. In this case, the option is ignored and the

search order for s ystem directories remains unchanged.

Duplicate directories are removed from the quote and bracket search chains before the

two chains are m erged to make the ﬁnal search chain. Thus, it is possible for a directory to

occur twice in the ﬁnal search chain if it was speciﬁed in b oth the quote and bracket chains.

You can prevent GCC from searching any of the default directories with the ‘-nostdinc’

option. This is useful when you are compiling an operating system kernel or some other

program that does not use the s tandard C library facilities, or the s tandard C library itself.

‘-I’ options are not ignored as described above when ‘-nostdinc’ is in eﬀect.

GCC looks for headers requested with #include "file " ﬁrst in the directory containing

the current ﬁle, then in the same places it would have looked for a header requested with

angle brackets. For example, if ‘/usr/include/sys/stat.h’ contains #include "types.h",

GCC looks for ‘types.h’ ﬁrst in ‘/usr/include/sys’, then in its usual search path.

‘#line’ (see Chapter 6 [Line Control], page 38) does not change GCC’s idea of the

directory containing the current ﬁle.

You may put ‘-I-’ at any point in your list of ‘-I’ options. This has two eﬀects. First,

directories appearing before the ‘-I-’ in the list are searched only for headers requested

with quote marks. Directories after ‘-I-’ are searched for all headers. Second, the directory

Chapter 2: Header Files 10

containing the current ﬁle is not searched for anything, unless it happens to be one of the

directories name d by an ‘-I’ switch.

‘-I. -I-’ is not the same as no ‘-I’ options at all, and does not cause the same behavior

for ‘<>’ includes that ‘""’ includes get with no special options. ‘-I.’ searches the compiler’s

current working directory for header ﬁles. That may or may not be the same as the directory

containing the c urrent ﬁle.

If you need to look for headers in a directory named ‘-’, write ‘-I./-’.

There are several more ways to adjust the header search path. They are generally le ss

useful. See Chapter 12 [Invocation], page 50.

2.4 Once-Only Headers

If a header ﬁle happens to be included twice, the compiler will process its contents twice.

This is very likely to cause an error, e.g. when the compiler sees the same structure deﬁnition

twice. Even if it does not, it will certainly waste time.

The standard way to prevent this is to enclose the entire real contents of the ﬁle in a

conditional, like this:

/* File foo. */

#ifndef FILE_FOO_SEEN

#define FILE_FOO_SEEN

the entire file

#endif /* !FILE_FOO_SEEN */

This construct is commonly known as a wrapper #ifndef. When the header is included

again, the conditional will be false, because FILE_FOO_SEEN is deﬁned. The preprocessor

will skip over the entire contents of the ﬁle, and the compiler will not see it twice.

CPP optimizes even further. It remembers when a header ﬁle has a wrapper ‘#ifndef’.

If a subsequent ‘#include’ speciﬁes that header, and the macro in the ‘#ifndef’ is still

deﬁned, it does not bother to rescan the ﬁle at all.

You can put comments outside the wrapper. They will not interfere with this optimiza-

tion.

The macro FILE_FOO_SEEN is called the controlling macro or guard macro. In a user

header ﬁle, the macro name should not begin with ‘_’. In a system header ﬁle, it should

begin with ‘__’ to avoid conﬂicts with user programs. In any kind of header ﬁle, the macro

name should contain the name of the ﬁle and some additional text, to avoid conﬂicts with

other header ﬁles.

2.5 Computed Includes

Sometimes it is necessary to select one of several diﬀerent header ﬁles to be included into

your program. They might specify conﬁguration parameters to be used on diﬀerent sorts

of operating systems, for instance. You could do this with a series of conditionals,

#if SYSTEM_1

# include "system_1.h"

#elif SYSTEM_2

# include "system_2.h"

#elif SYSTEM_3

Chapter 2: Header Files 11

...

#endif

That rapidly becomes tedious. Instead, the preprocessor oﬀers the ability to use a macro

for the header name. This is called a computed include. Instead of writing a header name

as the direct argument of ‘#include’, you simply put a macro name there instead:

#define SYSTEM_H "system_1.h"

...

#include SYSTEM_H

SYSTEM_H will be expanded, and the preprocessor will look for ‘system_1.h’ as if the

‘#include’ had been written that way originally. SYSTEM_H could be deﬁned by your Make-

ﬁle with a ‘-D’ option.

You must be careful when you deﬁne the macro. ‘#define’ saves tokens, not text.

The preprocessor has no way of knowing that the macro will be used as the argument of

‘#include’, s o it generates ordinary tokens, not a header name. This is unlikely to cause

problems if you use double-quote includes, which are close enough to string constants. If

you use angle brackets, however, you may have trouble.

The syntax of a computed include is actually a bit more general than the above. If

the ﬁrst non-whitespace character after ‘#include’ is not ‘"’ or ‘<’, then the entire line is

macro-expanded like running text would be.

If the line expands to a single string constant, the contents of that string constant are the

ﬁle to be included. CPP does not re-examine the string for embedded quotes, but neither

does it process backslash escapes in the string. Therefore

#define HEADER "a\"b"

#include HEADER

looks for a ﬁle named ‘a\"b’. CPP searches for the ﬁle acc ording to the rules for double-

quoted includes.

If the line expands to a token stream beginning with a ‘<’ token and including a ‘>’

token, then the tokens between the ‘<’ and the ﬁrst ‘>’ are combined to form the ﬁlename

to be included. Any whitespace between tokens is reduced to a single space; then any space

after the initial ‘<’ is retained, but a trailing space before the closing ‘>’ is ignored. CPP

searches for the ﬁle according to the rules for angle-bracket includes.

In either case, if there are any tokens on the line after the ﬁle name, an error occurs and

the directive is not processed. It is also an error if the result of expansion does not match

either of the two expected forms.

These rules are implementation-deﬁned behavior according to the C standard. To min-

imize the risk of diﬀerent compilers interpreting your computed includes diﬀerently, we

recommend you use only a single object-like macro which expands to a string constant.

This w ill also minimize confusion for people reading your program.

2.6 Wrapper Headers

Sometimes it is necessary to adjust the contents of a system-provided header ﬁle without

editing it directly. GCC’s fixincludes operation does this, for example. One way to do

that would be to create a new header ﬁle with the same name and insert it in the search

path before the original header. That works ﬁne as long as you’re willing to replace the old

header entirely. But what if you want to refer to the old header from the new one?

剩余75页未读，继续阅读

jimmyleeee

粉丝: 1w+

C语言预处理器详解与实现机制

安卓界面C语言预处理器设计与实现

C语言预处理器指南

C语言预处理器详解与实战

c语言预处理器.pdf

C语言预处理器深度解析

C语言预处理器深入解析

Java实现C语言预处理器：源码去注释及空白压缩

嵌入式C语言预处理器与宏详解

C语言预处理器指令详解

优化秘籍：C语言预处理器宏的高级应用

最新资源