Preprocessor

From cppreference.com

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros(C++20)
Language support library
Concepts library(C++20)
Diagnostics library
Memory management library
Metaprogramming library(C++11)
General utilities library
Containers library
Iterators library
Ranges library(C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library(C++17)
Concurrency support library(C++11)
Execution control library(C++26)
Technical specifications
Symbols index
External libraries

[edit]

C++ language

General topics

Preprocessor
Comments

Keywords
Escape sequences

Flow control

Conditional execution statements

if

switch

Iteration statements (loops)

`for`
range-`for`(C++11)

`while`
`do-while`

Jump statements

continue -break

goto -return

Functions

Function declaration

Lambda function expression

inline specifier

Dynamic exception specifications(until C++17*)

noexcept specifier(C++11)

Exceptions

`throw`-expression
`try` block


`catch` handler

Namespaces

Namespace declaration

Namespace aliases

Types

Fundamental types
Enumeration types
Function types

Class/struct types
Union types

Specifiers

`const`/`volatile`
`decltype`(C++11)
`auto`(C++11)

`constexpr`(C++11)
`consteval`(C++20)
`constinit`(C++20)

Storage duration specifiers

Initialization

Default-initialization
Value-initialization
Zero-initialization
Copy-initialization
Direct-initialization

Aggregate initialization
List-initialization(C++11)
Constant initialization
Reference initialization

Expressions

Value categories
Order of evaluation

Operators
Operator precedence

Alternative representations

Literals

Boolean -Integer -Floating-point

Character -String -nullptr(C++11)

User-defined(C++11)

Utilities

Attributes(C++11)

Types

typedef declaration

Type alias declaration(C++11)

Casts

Implicit conversions
`static_cast`
`const_cast`

Explicit conversions
`dynamic_cast`
`reinterpret_cast`

Memory allocation

new expression

delete expression

Classes

Class declaration
Constructors
`this` pointer

Access specifiers
`friend` specifier

Class-specific function properties

Virtual function
`override` specifier(C++11)
`final` specifier(C++11)

`explicit`(C++11)
`static`

Special member functions

Default constructor
Copy constructor
Move constructor(C++11)

Copy assignment
Move assignment(C++11)
Destructor

Templates

Class template
Function template

Template specialization
Parameter packs(C++11)

Miscellaneous

Inline assembly

History of C++

[edit]

Preprocessor

#if#ifdef#ifndef#else#elif#elifdef#elifndef#endif (C++23)(C++23)
#define#undef#,## operators
#include__has_include (C++17)
#error#warning (C++23)
#pragma_Pragma (C++11)
#line
#embed (C++26)

[edit]

The preprocessor is executed attranslation phase 4, before the compilation. The result of preprocessing is a single file which is then passed to the actual compiler.

[edit]Directives

The preprocessing directives control the behavior of the preprocessor. Each directive occupies one line and has the following format:

the# character.
a sequence of:

a standard-defined directive name (listedbelow) followed by the corresponding arguments, or
one or morepreprocessing tokens where the beginning token is not a standard-defined directive name, in this case the directive is conditionally-supported with implementation-defined semantics (e.g. a common non-standard extension is the directive#warning which emits a user-defined message during compilation)(until C++23), or
nothing, in this case the directive has no effect.

a line break.

Themodule and import directives are also preprocessing directives.

(since C++20)

Preprocessing directives must not come from macro expansion.

#define EMPTYEMPTY#   include <file.h> // not a preprocessing directive

[edit]Capabilities

The preprocessor has the source file translation capabilities:

conditionally compile parts of source file (controlled by directive#if,#ifdef,#ifndef,#else,#elif,#elifdef,#elifndef(since C++23), and#endif).
replace text macros while possibly concatenating or quoting identifiers (controlled by directives#define and#undef, and operators# and##).
include other files (controlled by directive#includeand checked with__has_include(since C++17)).
cause anerrororwarning(since C++23) (controlled by directive#error or#warning respectively(since C++23)).

The following aspects of the preprocessor can be controlled:

implementation-defined behavior (controlled by directive#pragmaand operator_Pragma(since C++11)). In addition, some compilers support (to varying degrees) the operator__pragma as anon-standard extension.
file name and line information available to the preprocessor (controlled by directive#line).