Preprocessing of C ++ specifications

Document directory

• Macro definitions (# define, # UNDEF)
• Conditional comprehensions (# ifdef, # ifndef, # If, # endif, # else and # Elif)
• Line Control (# Line)
• Error Directive (# error)
• Source File lifecycle Sion (# include)
• Pragma Directive (# pragma)
• Predefined macro names

Preprocessor directives

Preprocessor directives are lines encoded in the code of our programs that are not program statements but directives for the Preprocessor. These lines are always preceded by a hash sign (#). The Preprocessor is executed before the actual compilation
Of code begins, therefore the Preprocessor digests all these directives before any code is generated by the statements.

These Preprocessor directives extend only contains ss a single line of code. as soon as a newline character is found, the Preprocessor directive is considered to end. no semicolon (;) is expected at the end of a Preprocessor directive. the
Only way a Preprocessor directive can extend through more than one line is by preceding the newline character at the end of the line by a backslash (\).

Macro definitions (# define, # UNDEF)

To define Preprocessor macros we can use# Define. Its format is:

# Define identifier replacement

When the Preprocessor encounters this directive, it replaces any occurrence
IdentifierIn the rest of the codeReplacement. ThisReplacementCan be an expression, a statement, a block or simply anything. The Preprocessor does not understand C ++, it simply replaces any occurrenceIdentifierBy
Replacement.

1 2 3

#define TABLE_SIZE 100int table1[TABLE_SIZE];int table2[TABLE_SIZE];

After the Preprocessor has replacedTable_size, The Code becomes equivalent:

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

This use of # define as constant definer is already known by us from previous tutorials,# DefineCan work also with parameters to define function macros:

#define getmax(a,b) a>b?a:b

This wocould replace any occurrenceGetmaxFollowed by two arguments by the replacement expression, but also replacing each argument by its identifier, exactly as you wowould have CT if it was a function:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

// function macro#include <iostream>using namespace std;#define getmax(a,b) ((a)>(b)?(a):(b))int main(){ int x=5, y; y= getmax(x,2); cout << y << endl; cout << getmax(7,x) << endl; return 0;}

57

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

1 2 3 4 5

#define TABLE_SIZE 100int table1[TABLE_SIZE];#undef TABLE_SIZE#define TABLE_SIZE 200int table2[TABLE_SIZE];

This woshould generate the same code:

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

FUNCTION macro definitions accept two Special operators (#And##) In the replacement sequence:
If the operator#Is used before a parameter is used in the replacement sequence, that parameter is replaced by a string literal (as if it were enclosed between double quotes)

1 2	#define str(x) #xcout << str(test);

This wocould be translated:

cout << "test";

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

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

This woshould also be translated:

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 may seem obscure to other programmers, since the syntax they Except CT is on your occasions
Different from the regular expressions programmers expect CT in C ++.

Conditional comprehensions (# 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.

# IfdefAllows 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 2 3

#ifdef TABLE_SIZEint table[TABLE_SIZE];#endif

In this case, the line of codeInt table [table_size];Is only compiled ifTable_sizeWas previusly defined
# Define, Independently of its value. If it was not defined, that line will not be encoded in the program compilation.

# IfndefServes for the exact opposite: the code# IfndefAnd
# EndifDirectives is only compiled if the specified identifier has not been previusly defined. For example:

1 2 3 4

#ifndef TABLE_SIZE#define TABLE_SIZE 100#endifint table[TABLE_SIZE];

In this case, if when arriving at this piece of code,Table_sizeMacro has not been defined yet, it wocould be defined to a value of 100. If it already existed it wocould keep its previous value since# DefineDirective wocould not be executed.

The# If,# ElseAnd# 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
# IfOr# ElifCan only evaluate constant expressions, including macro expressions. For example:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#if TABLE_SIZE>200#undef TABLE_SIZE#define TABLE_SIZE 200 #elif TABLE_SIZE<50#undef TABLE_SIZE#define TABLE_SIZE 50 #else#undef TABLE_SIZE#define TABLE_SIZE 100#endif int table[TABLE_SIZE];

Notice how the whole structure# If,# ElifAnd# ElseChained directives ends# Endif.

The behavior# IfdefAnd# IfndefCan also be achieved by using the special OperatorsDefinedAnd
! DefinedRespectively in any# IfOr# ElifDirective:

1 2 3 4 5 6

#if !defined TABLE_SIZE#define TABLE_SIZE 100#elif defined ARRAY_SIZE#define TABLE_SIZE ARRAY_SIZEint table[TABLE_SIZE];#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# LineDirective 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"

WhereNumberIs 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 2	#line 20 "assigning variable"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 the error that can be specified as its parameter:

1 2 3

#ifndef __cplusplus#error A C++ compiler is required!#endif

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

Source File lifecycle Sion (# include)

This directive has also been used assiduously in other sections of this tutorial. When the Preprocessor finds# IncludeDirective it replaces it by the entire content of the specified file. There are two ways to specify a file to be encoded ded:

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

The only difference between both expressions is the places (directories) where the compiler is going to look for the file. in the first case where the file name is specified between double-quotes, the file is searched first in
Same directory that includes des the file containing the directive. In case that it is not there, the compiler searches the file in the default directories where it is configured to look for the standard header files.
If the file name is enclosed between angle-brackets<>The file is searched directly where the compiler is configured to look for the standard header files. Therefore, standard header files are usually encoded in angle-brackets, while other specific
Header files are supported ded using quotes.

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# Pragma, It is ignored-no error is generated.

Predefined macro names

The following macro names are defined at any time:

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.
_ Date __	A string literal in the form "Mmm dd YYYY" containing the date in which the compilation process began.
_ Time __	A string literal in the form "HH: mm: SS" containing the time at which the compilation process began.
_ Cplusplus	An integer value. all C ++ compilers have this constant defined to some value. if the compiler is fully compliant with the c ++ standard its value is equal or greater than 199711l depending on the version of the standard they comply.

For example:

1 2 3 4 5 6 7 8 9 10 11 12 13

// standard macro names#include <iostream>using namespace std;int main(){ cout << "This is the line number " << __LINE__; cout << " of file " << __FILE__ << ".\n"; cout << "Its compilation began " << __DATE__; cout << " at " << __TIME__ << ".\n"; cout << "The compiler gives a __cplusplus value of " << __cplusplus; return 0;}