6/3/2021 Preprocessor directives - C++ Tutorials

Search: Go
Not logged in

Tutorials C++ Language Preprocessor directives register log in

C++
Information
Tutorials
Reference
Articles
Forum

Tutorials Preprocessor directives

C++ Language Preprocessor directives are lines included in the code of programs preceded by a hash sign (#). These lines are not
Ascii Codes program statements but directives for the preprocessor. The preprocessor examines the code before actual compilation
Boolean Operations of code begins and resolves all these directives before any code is actually generated by regular statements.
Numerical Bases
These preprocessor directives extend only across a single line of code. As soon as a newline character is found, the
C++ Language preprocessor directive is ends. No semicolon (;) is expected at the end of a preprocessor directive. The only way a
Introduction: preprocessor directive can extend through more than one line is by preceding the newline character at the end of the
Compilers line by a backslash (\).
Basics of C++:
Structure of a program
Variables and types macro definitions (#define, #undef)
Constants To define preprocessor macros we can use #define. Its syntax is:
Operators
Basic Input/Output #define identifier replacement
Program structure:
Statements and flow control When the preprocessor encounters this directive, it replaces any occurrence of identifier in the rest of the code by
Functions replacement. This replacement can be an expression, a statement, a block or simply anything. The preprocessor does
Overloads and templates not understand C++ proper, it simply replaces any occurrence of identifier by replacement.
Name visibility
Compound data types: 1 #define TABLE_SIZE 100
Arrays 2 int table1[TABLE_SIZE];
3 int table2[TABLE_SIZE];
Character sequences
Pointers
Dynamic memory
Data structures After the preprocessor has replaced TABLE_SIZE, the code becomes equivalent to:
Other data types
Classes: 1 int table1[100];
2 int table2[100];
Classes (I)
Classes (II)
Special members
Friendship and inheritance #define can work also with parameters to define function macros:
Polymorphism
Other language features: #define getmax(a,b) a>b?a:b
Type conversions
Exceptions
Preprocessor directives This would replace any occurrence of getmax followed by two arguments by the replacement expression, but also
Standard library: replacing each argument by its identifier, exactly as you would expect if it was a function:
Input/output with files
1 // function macro 5
2 #include <iostream> 7
e radio frequency yonlit.cn 3 using namespace std;
RF Power Amplifie
ranging from VHF UHF 4
CS 3G LTE and 5.8GHz
Manufactuer 5 #define getmax(a,b) ((a)>(b)?(a):(b))
6
7 int main() Edit
8 { &
9 int x=5, y; Run
10 y= getmax(x,2);
11 cout << y << endl;
12 cout << getmax(7,x) << endl;
13 return 0;
14 }

Defined macros are not affected by block structure. A macro lasts until it is undefined with the #undef preprocessor
directive:

1 #define TABLE_SIZE 100

2 int table1[TABLE_SIZE];
3 #undef TABLE_SIZE
4 #define TABLE_SIZE 200
5 int table2[TABLE_SIZE];

This would generate the same code as:

1 int table1[100];
2 int table2[200];

Function macro definitions accept two special operators (# and ##) in the replacement sequence:
The operator #, followed by a parameter name, is replaced by a string literal that contains the argument passed (as if
enclosed between double quotes):
1 #define str(x) #x
2 cout << str(test);

This would be translated into:

cout << "test";

The operator ## concatenates two arguments leaving no blank spaces between them:

1 #define glue(a,b) a ## b
2 glue(c,out) << "test";

https://www.cplusplus.com/doc/tutorial/preprocessor/ 1/4
6/3/2021 Preprocessor directives - C++ Tutorials

This would also be translated into:

cout << "test";

Because preprocessor replacements happen before any C++ syntax check, macro definitions can be a tricky feature.
But, be careful: code that relies heavily on complicated macros become less readable, since the syntax expected is on
many occasions different from the normal expressions programmers expect in C++.

Conditional inclusions (#ifdef, #ifndef, #if, #endif, #else and #elif)

These directives allow to include or discard part of the code of a program if a certain condition is met.

#ifdef allows a section of a program to be compiled only if the macro that is specified as the parameter has been
defined, no matter which its value is. For example:

1 #ifdef TABLE_SIZE
2 int table[TABLE_SIZE];
3 #endif

In this case, the line of code int table[TABLE_SIZE]; is only compiled if TABLE_SIZE was previously defined with
#define, independently of its value. If it was not defined, that line will not be included in the program compilation.

#ifndef serves for the exact opposite: the code between #ifndef and #endif directives is only compiled if the specified
identifier has not been previously defined. For example:

1 #ifndef TABLE_SIZE
2 #define TABLE_SIZE 100
3 #endif
4 int table[TABLE_SIZE];

In this case, if when arriving at this piece of code, the TABLE_SIZE macro has not been defined yet, it would be defined
to a value of 100. If it already existed it would keep its previous value since the #define directive would not be
executed.

The #if, #else and #elif (i.e., "else if") directives serve to specify some condition to be met in order for the portion of
code they surround to be compiled. The condition that follows #if or #elif can only evaluate constant expressions,
including macro expressions. For example:

1 #if TABLE_SIZE>200
2 #undef TABLE_SIZE
3 #define TABLE_SIZE 200
4
5 #elif TABLE_SIZE<50
6 #undef TABLE_SIZE
7 #define TABLE_SIZE 50
8
9 #else
10 #undef TABLE_SIZE
11 #define TABLE_SIZE 100
12 #endif
13
14 int table[TABLE_SIZE];

Notice how the entire structure of #if, #elif and #else chained directives ends with #endif.

The behavior of #ifdef and #ifndef can also be achieved by using the special operators defined and !defined
respectively in any #if or #elif directive:

1 #if defined ARRAY_SIZE

2 #define TABLE_SIZE ARRAY_SIZE
3 #elif !defined BUFFER_SIZE
4 #define TABLE_SIZE 128
5 #else
6 #define TABLE_SIZE BUFFER_SIZE
7 #endif

Line control (#line)

When we compile a program and some error happens during the compiling process, the compiler shows an error
message with references to the name of the file where the error happened and a line number, so it is easier to find the
code generating the error.

The #line directive allows us to control both things, the line numbers within the code files as well as the file name that
we want that appears when an error takes place. Its format is:

#line number "filename"

Where number is the new line number that will be assigned to the next code line. The line numbers of successive lines
will be increased one by one from this point on.

"filename" is an optional parameter that allows to redefine the file name that will be shown. For example:

1 #line 20 "assigning variable"

2 int a?;

This code will generate an error that will be shown as error in file "assigning variable", line 20.

Error directive (#error)

This directive aborts the compilation process when it is found, generating a compilation error that can be specified as
its parameter:

https://www.cplusplus.com/doc/tutorial/preprocessor/ 2/4
6/3/2021 Preprocessor directives - C++ Tutorials
1 #ifndef __cplusplus
2 #error A C++ compiler is required!
3 #endif

This example aborts the compilation process if the macro name __cplusplus is not defined (this macro name is defined
by default in all C++ compilers).

Source file inclusion (#include)

This directive has been used assiduously in other sections of this tutorial. When the preprocessor finds an #include
directive it replaces it by the entire content of the specified header or file. There are two ways to use #include:

1 #include <header>
2 #include "file"

In the first case, a header is specified between angle-brackets <>. This is used to include headers provided by the
implementation, such as the headers that compose the standard library (iostream, string,...). Whether the headers are
actually files or exist in some other form is implementation-defined, but in any case they shall be properly included with
this directive.

The syntax used in the second #include uses quotes, and includes a file. The file is searched for in an implementation-
defined manner, which generally includes the current path. In the case that the file is not found, the compiler interprets
the directive as a header inclusion, just as if the quotes ("") were replaced by angle-brackets (<>).

Pragma directive (#pragma)

This directive is used to specify diverse options to the compiler. These options are specific for the platform and the
compiler you use. Consult the manual or the reference of your compiler for more information on the possible
parameters that you can define with #pragma.

If the compiler does not support a specific argument for #pragma, it is ignored - no syntax error is generated.

Predefined macro names

The following macro names are always defined (they all begin and end with two underscore characters, _):

macro value
__LINE__ Integer value representing the current line in the source code file being compiled.
__FILE__ A string literal containing the presumed name of the source file being compiled.
A string literal in the form "Mmm dd yyyy" containing the date in which the compilation process
__DATE__
began.
__TIME__ A string literal in the form "hh:mm:ss" containing the time at which the compilation process began.
An integer value. All C++ compilers have this constant defined to some value. Its value depends on
the version of the standard supported by the compiler:

199711L: ISO C++ 1998/2003

__cplusplus 201103L: ISO C++ 2011

Non conforming compilers define this constant as some value at most five digits long. Note that many
compilers are not fully conforming and thus will have this constant defined as neither of the values
above.
1 if the implementation is a hosted implementation (with all standard headers available)
__STDC_HOSTED__
0 otherwise.

The following macros are optionally defined, generally depending on whether a feature is available:

macro value
In C: if defined to 1, the implementation conforms to the C standard.
__STDC__
In C++: Implementation defined.
In C:

199401L: ISO C 1990, Ammendment 1

__STDC_VERSION__ 199901L: ISO C 1999
201112L: ISO C 2011

In C++: Implementation defined.

__STDC_MB_MIGHT_NEQ_WC__ 1 if multibyte encoding might give a character a different value in character literals
A value in the form yyyymmL, specifying the date of the Unicode standard followed
__STDC_ISO_10646__
by the encoding of wchar_t characters
__STDCPP_STRICT_POINTER_SAFETY__ 1 if the implementation has strict pointer safety (see get_pointer_safety)
__STDCPP_THREADS__ 1 if the program can have more than one thread

Particular implementations may define additional constants.

For example:

1 // standard macro names This is the line number 7 of file /home/jay/stdmac

2 #include <iostream> Its compilation began Nov 1 2005 at 10:12:29.
3 using namespace std; The compiler gives a __cplusplus value of 1
4
5 int main()
6 {
7 cout << "This is the line number " << __LINE__;
8 cout << " of file " << __FILE__ << ".\n";
9 cout << "Its compilation began " << __DATE__;
10 cout << " at " << __TIME__ << ".\n";
11 cout << "The compiler gives a __cplusplus value of " << __cplusplus;
12 return 0;
13 }

Previous: Next:
Exceptions Input/output with files
Index

https://www.cplusplus.com/doc/tutorial/preprocessor/ 3/4
6/3/2021 Preprocessor directives - C++ Tutorials

Home page | Privacy policy

© cplusplus.com, 2000-2021 - All rights reserved - v3.2
Spotted an error? contact us

https://www.cplusplus.com/doc/tutorial/preprocessor/ 4/4