Red Hat Enterprise Linux 3 的C预处理器cpp详解

需积分: 1 153 浏览量更新于2024-06-26 收藏 443KB PDF 举报

"Red Hat Enterprise Linux 3 使用 cpp，C 预处理器" 本文档详细介绍了在 Red Hat Enterprise Linux 3 操作系统环境下如何使用 `cpp`，即 C 语言预处理器。cpp 是 C 和 C++ 编译过程中的一个重要组成部分，它在编译器实际编译源代码之前对源代码进行处理，执行一系列预定义的任务，如宏展开、条件编译等。预处理器的主要功能包括： 1. **宏替换**：cpp 可以处理源代码中的宏定义，将宏名替换为其定义的值。这允许程序员创建可重用的代码片段，并且在编译时可以动态改变。 2. **条件编译**：cpp 支持 `#if`, `#ifdef`, `#ifndef`, `#else`, `#elif` 和 `#endif` 等指令，使得代码可以根据特定的条件进行编译。这在编写跨平台或有多种配置的代码时非常有用。 3. **包含头文件**：cpp 使用 `#include` 指令将其他源文件或头文件的内容插入到当前文件中，方便共享代码和定义。 4. **行号和文件名注释**：cpp 可以添加行号和文件名信息到输出的预处理代码中，这对于调试非常有帮助。 5. **预定义宏**：cpp 自动定义了一些预定义宏，如 `__DATE__`, `__TIME__`, `__LINE__` 和 `__FILE__`，它们提供了关于编译时间、日期和当前源文件的信息。在 Red Hat Enterprise Linux 3 中，cpp 工具通常作为 gcc 编译器的一部分提供。用户可以通过命令行调用 `gcc -E` 或 `cpp` 来运行预处理器，查看预处理后的代码。使用 `cpp` 的步骤通常包括： 1. 定义宏：在源文件中使用 `#define` 定义宏，例如 `#define PI 3.14159`。 2. 条件编译：根据需要使用条件编译指令控制代码块的编译，例如 `#if defined(_DEBUG)`。 3. 包含头文件：使用 `#include` 指令引入头文件，如 `#include <stdio.h>` 引入标准输入输出库。 4. 运行预处理器：通过 `gcc -E source.c -o preprocessed.c` 命令将源文件 `source.c` 预处理成 `preprocessed.c`。在实际开发中，cpp 能帮助开发者实现代码的灵活性和模块化，提高代码的可维护性和可读性。然而，过度使用宏可能导致代码难以理解和调试，因此应谨慎使用宏，并遵循良好的编程实践。此文档由 Red Hat, Inc. 准备，包含了关于 `cpp` 的详细指南，适用于 Red Hat Enterprise Linux 3 用户。文档还遵循 GNU Free Documentation License，允许复制、分发和修改，但不包含任何不变章节、封面文本和背面文本。同时，文档指出 Red Hat 不授权任何分销商使用 Red Hat 品牌名称，Red Hat、Shadow Man logo、RPM 和 RPM logo 均为 Red Hat, Inc. 的注册商标，而 Linux 是一个注册商标。

10 Chapter 2. Header Files

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.

GNU 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 optimization.

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 different header ﬁles to be included into your pro-

gram. They might specify conﬁguration parameters to be used on different 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

...

#endif

That rapidly becomes tedious. Instead, the preprocessor offers 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, so 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 in-

cluded. 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"

Chapter 2. Header Files 11

#include HEADER

looks for a ﬁle named a\"b. CPP searches for the ﬁle according to the rules for double-quoted in-

cludes.

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 minimize the risk

of different compilers interpreting your computed includes differently, we recommend you use only

a single object-like macro which expands to a string constant. This will 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?

You cannot simply include the old header with #include. That will start from the beginning, and

ﬁnd your new header again. If your header is not protected from multiple inclusion (Refer to Section

2.4 Once-Only Headers), it will recurse inﬁnitely and cause a fatal error.

You could include the old header with an absolute pathname:

#include "/usr/include/old-header.h"

This works, but is not clean; should the system headers ever move, you would have to edit the new

headers to match.

There is no way to solve this problem within the C standard, but you can use the GNU exten-

sion #include_next. It means, "Include the next ﬁle with this name." This directive works like

#include except in searching for the speciﬁed ﬁle: it starts searching the list of header ﬁle directo-

ries after the directory in which the current ﬁle was found.

Suppose you specify -I /usr/local/include, and the list of directories to search also

includes /usr/include; and suppose both directories contain signal.h. Ordinary #include



signal.h



ﬁnds the ﬁle under /usr/local/include. If that ﬁle contains #include_next



signal.h



, it starts searching after that directory, and ﬁnds the ﬁle in /usr/include.

#include_next does not distinguish between



file



and "file" inclusion, nor does it check that

the ﬁle you specify has the same name as the current ﬁle. It simply looks for the ﬁle named, starting

with the directory in the search path after the one where the current ﬁle was found.

The use of #include_next can lead to great confusion. We recommend it be used only when there is

no other alternative. In particular, it should not be used in the headers belonging to a speciﬁc program;

it should be used only to make global corrections along the lines of fixincludes.

Chapter 3.

Macros

A macro is a fragment of code which has been given a name. Whenever the name is used, it is replaced

by the contents of the macro. There are two kinds of macros. They differ mostly in what they look

like when they are used. Object-like macros resemble data objects when used, function-like macros

resemble function calls.

You may deﬁne any valid identiﬁer as a macro, even if it is a C keyword. The preprocessor does not

know anything about keywords. This can be useful if you wish to hide a keyword such as const from

an older compiler that does not understand it. However, the preprocessor operator defined (Refer to

Section 4.2.3 Deﬁned) can never be deﬁned as a macro, and C++’s named operators (Refer to Section

3.7.4 C++ Named Operators) cannot be macros when you are compiling C++.

3.1. Object-like Macros

An object-like macro is a simple identiﬁer which will be replaced by a code fragment. It is called

object-like because it looks like a data object in code that uses it. They are most commonly used to

give symbolic names to numeric constants.

You create macros with the #define directive. #define is followed by the name of the macro and

then the token sequence it should be an abbreviation for, which is variously referred to as the macro’s

body, expansion or replacement list. For example,

#define BUFFER_SIZE 1024

deﬁnes a macro named BUFFER_SIZE as an abbreviation for the token 1024. If somewhere after this

#define directive there comes a C statement of the form

foo = (char *) malloc (BUFFER_SIZE);

then the C preprocessor will recognize and expand the macro BUFFER_SIZE. The C compiler will see

the same tokens as it would if you had written

foo = (char *) malloc (1024);

By convention, macro names are written in upper case. Programs are easier to read when it is possible

to tell at a glance which names are macros.

The macro’s body ends at the end of the #define line. You may continue the deﬁnition onto multiple

lines, if necessary, using backslash-newline. When the macro is expanded, however, it will all come

out on one line. For example,

#define NUMBERS 1, \

2, \

int x[] = { NUMBERS };

==> int x[] = { 1, 2, 3 };

剩余83页未读，继续阅读

rocazj

粉丝: 9
资源: 725

Red Hat Enterprise Linux 3 的C预处理器cpp详解

cpp.exe(c预编译器)

The C Preprocessor

Tips and tricks using the preprocessor 1

Tips and tricks using the preprocessor 2

The C Preprocessor.rar

C, GNUC GCC 预处理《The C Preprocessor》

The Tree Preprocessor

The C++ Preprocessor

The Beanshell Preprocessor-开源

WPP - The Web Preprocessor-开源

最新资源