CPP has a number of features which are present mainly for
compatibility with older programs. We discourage their use in new code.
In some cases, we plan to remove the feature in a future version of GCC.
Assertions are a deprecated alternative to macros in writing
conditionals to test what sort of computer or system the compiled
program will run on. Assertions are usually predefined, but you can
define them with preprocessing directives or command-line options.
Assertions were intended to provide a more systematic way to describe
the compiler's target system. However, in practice they are just as
unpredictable as the system-specific predefined macros. In addition, they
are not part of any standard, and only a few compilers support them.
Therefore, the use of assertions is less portable than the use
of system-specific predefined macros. We recommend you do not use them at
An assertion looks like this:
predicate must be a single identifier. answer can be any
sequence of tokens; all characters are significant except for leading
and trailing whitespace, and differences in internal whitespace
sequences are ignored. (This is similar to the rules governing macro
redefinition.) Thus, (x + y) is different from (x+y) but
equivalent to ( x + y ). Parentheses do not nest inside an
To test an assertion, you write it in an #if. For example, this
conditional succeeds if either vax or ns16000 has been
asserted as an answer for machine.
#if #machine (vax) || #machine (ns16000)
You can test whether any answer is asserted for a predicate by
omitting the answer in the conditional:
Assertions are made with the #assert directive. Its sole
argument is the assertion to make, without the leading # that
identifies assertions in conditionals.
#assert predicate (answer)
You may make several assertions with the same predicate and different
answers. Subsequent assertions do not override previous ones for the
same predicate. All the answers for any given predicate are
Assertions can be canceled with the #unassert directive. It
has the same syntax as #assert. In that form it cancels only the
answer which was specified on the #unassert line; other answers
for that predicate remain true. You can cancel an entire predicate by
leaving out the answer:
In either form, if no such assertion has been made, #unassert has
You can also make or cancel assertions using command line options.
Chapter 12 Invocation.
11.3.2. Obsolete once-only headers
CPP supports two more ways of indicating that a header file should be
read only once. Neither one is as portable as a wrapper #ifndef,
and we recommend you do not use them in new programs.
In the Objective-C language, there is a variant of #include
called #import which includes a file, but does so at most once.
If you use #import instead of #include, then you don't
need the conditionals inside the header file to prevent multiple
inclusion of the contents. GCC permits the use of #import in C
and C++ as well as Objective-C. However, it is not in standard C or C++
and should therefore not be used by portable programs.
#import is not a well designed feature. It requires the users of
a header file to know that it should only be included once. It is much
better for the header file's implementor to write the file so that users
don't need to know this. Using a wrapper #ifndef accomplishes
In the present implementation, a single use of #import will
prevent the file from ever being read again, by either #import or
#include. You should not rely on this; do not use both
#import and #include to refer to the same header file.
Another way to prevent a header file from being included more than once
is with the #pragma once directive. If #pragma once is
seen when scanning a header file, that file will never be read again, no
#pragma once does not have the problems that #import does,
but it is not recognized by all preprocessors, so you cannot rely on it
in a portable program.