INTRODUCTION:
The C preprocessor, often known as cpp, is a macro processor
that is used automatically by the C compiler to transform your program before
compilation. It is called a macro processor because it allows you to define macros,
which are brief abbreviations for longer constructs.
The C preprocessor is intended to be used only with C, C++, and Objective-C
source code. In the past, it has been abused as a general text processor. It
will choke on input which does not obey C's lexical rules. For example,
apostrophes will be interpreted as the beginning of character constants, and
cause errors. Also, you cannot rely on it preserving characteristics of the
input which are not significant to C-family languages. If a Makefile is preprocessed,
all the hard tabs will be removed, and the Makefile will not work.
Include Syntax
Both user and system header files are
included using the preprocessing directive `#include'.
It has two variants:
#include <file> #include "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>
specifies inclusion of a system header file named x/*y.
However, if backslashes occur within file,
they are considered ordinary text characters, not escape characters. None of
the character escape sequences appropriate to string constants in C are
processed. Thus,
#include "x\n\\y"
specifies a filename 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 file name.
Conditional Syntax
A conditional in the C preprocessor begins
with a conditional directive: `#if', `#ifdef' or `#ifndef'.
Ifdef
#ifdef MACRO
controlled text
#endif /* MACRO */
This block
is called a conditional group. controlled text will be
included in the output of the preprocessor if and only if MACRO is
defined. We say that the conditional succeeds if MACRO is
defined, fails if it is not.
If
The `#if' directive allows you to test the value of
an arithmetic expression, rather than the mere existence of one macro. Its
syntax is
#if expression
controlled text
#endif /* expression */
expression is a C expression of integer type, subject to
stringent restrictions. It may contain
- Integer constants.
- Character constants, which are interpreted as they would be in normal code.
- Arithmetic operators for
addition, subtraction, multiplication, division, bitwise operations,
shifts, comparisons, and logical operations (
&&and||). The latter two obey the usual short-circuiting rules of standard C. - Macros. All macros in the expression are expanded before actual computation of the expression's value begins.
- Uses of the
definedoperator, which lets you check whether macros are defined in the middle of an `#if'. - Identifiers that are not
macros, which are all considered to be the number zero. This allows you to
write
#if MACROinstead of#ifdef MACRO, if you know that MACRO, when defined, will always have a nonzero value. Function-like macros used without their function call parentheses are also treated as zero.
Defined
The special operator
defined is used in `#if'
and `#elif' expressions to test whether a certain name
is defined as a macro. defined name
and defined (name) are both expressions whose value is 1
if name is defined as a macro at the current point in the program,
and 0 otherwise. Thus, #if defined MACRO
is precisely equivalent to #ifdef MACRO.
defined is useful when
you wish to test more than one macro for existence at once. For example, #if defined (__vax__) || defined (__ns16000__)
would succeed if either of the names
__vax__ or __ns16000__ is defined as a macro.
Conditionals written like this:
#if defined BUFSIZE && BUFSIZE >= 1024
can generally be simplified to just
#if BUFSIZE >= 1024,
since if BUFSIZE is not
defined, it will be interpreted as having the value zero.
Else
The `#else'
directive can be added to a conditional to provide alternative text to be used
if the condition fails. This is what it looks like:
#if expression
text-if-true
#else /* Not expression */
text-if-false
#endif /* Not expression */
If expression is nonzero, the text-if-true
is included and the text-if-false is skipped. If expression
is zero, the opposite happens.
You can use `#else' with `#ifdef'
and `#ifndef', too.
Elif
One common case of nested conditionals
is used to check for more than two possible alternatives. For example, you
might have
#if X == 1
...
#else /* X != 1 */
#if X == 2
...
#else /* X != 2 */
...
#endif /* X != 2 */
#endif /* X != 1 */
Another conditional directive, `#elif', allows this
to be abbreviated as follows:
#if X == 1
...
#elif X == 2
...
#else /* X != 2 and X != 1*/
...
#endif /* X != 2 and X != 1*/
`#elif' stands for “else
if”. Like `#else', it goes in the middle of a
conditional group and subdivides it; it does not require a matching `#endif' of its own. Like `#if', the `#elif' directive includes an expression to be tested. The
text following the `#elif' is processed only if the
original `#if'-condition failed and the `#elif' condition succeeds.
More than one `#elif' can
go in the same conditional group. Then the text after each `#elif'
is processed only if the `#elif' condition succeeds
after the original `#if' and all previous `#elif' directives within it have failed.
`#else' is allowed after any number
of `#elif' directives, but `#elif'
may not follow `#else'
--------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------
No comments:
Post a Comment