The simplest sort of conditional is

#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.

Sometimes you wish to use some code if a macro is not defined. You can do this by writing `#ifndef' instead of `#ifdef'. One common use of `#ifndef' is to include code only the first time a header file is included.

#ifndef _TEST_H_
#define _TEST_H_

// #ifdef __cplusplus
// extern "C" {
// #endif


// #ifdef __cplusplus
// }
// #endif

#endif /* _TEST_H_ */

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 `defined' operator, 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 MACRO' instead 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.

  In some contexts this shortcut is undesirable. The `-Wundef' option causes GCC to warn whenever it encounters an identifier which is not a macro in an `#if'.

The preprocessor does not know anything about types in the language. Therefore, `sizeof' operators are not recognized in `#if', and neither are `enum' constants. They will be taken as identifiers which are not macros, and replaced by zero. In the case of `sizeof', this is likely to cause the expression to be invalid.

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 .

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.

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'.