You are on page 1of 5

C++ Preprocessor

The pre-processor is a utility program, which processes special instructions that can be or are written
in a C/CPP program. These instructions can be include a library or some special instructions to the
compiler about some certain terms used in the program.
Pre-processor directives start with # character.
Different preprocessor directives (commands) perform different tasks. We can categorize the
Preprocessor Directives as follows:
Inclusion Directives
Macro Definition Directives
Conditional Compilation Directives
Other Directives

Inclusion Directive
This category has only one directive, which is called #include. This inclusion directive is used to
include files into the current file. The inclusion directive can be used as follows:
#include <stdio.h>
includes stdio.h from include
#include <iostream>

includes cpp class library header



includes my.cpp file from include


#include my.h

includes my.h file from current working



includes abc.h file from the myfolder which

is available in current working folder

From the above usage-table we can see that #include is used with two options angular brackets
(<>)and inverted commas (). When #include is written with <> it means we are instructing to
include the files from the include path defined in the compiler settings which is generally the include
folder from the compiler. When #include is written with it means we are instructing to include a
file: first the current folder is checked and if it is not found there, then the include folder of the
compiler is checked.
Take a look at a simple example. Save the following code in a file called main.c:
#include "header.h"
int main() {
printf("The variable from the header file: a = %d", a);
return 0;

Then save the code below in a file called header.h and place it in the same directory as main.c:

#ifndef __mynamespace__
int a = 10;
The variable declared in the header.h file will be included in main.c, so we can use the variable in
Macro Definition Directives
These are used to define macros, which are one, or more program statements (like functions) and they
are expanded inline. (Expanded inline means they are substituted at the place of macro call unlike
functions in which the execution pointer moves to the function definition.).
There are two directives for Macro Definition:

#define Used to define a macro

#undef Used to undefine a macro (The macro cannot be used after it is undefined.)
Take a look at the example, which is using include directive and some macro definition directives:
#include <iostream>
using namespace std;
#define PI 3.14
#define SQR(X) ((X)* (X))
#define CUBE(y) SQR(y)* (y)
int main(int argc,char *argv[])
int radius;
cout << endl << "Enter Radius of the Circle:"; cin >> radius;
cout << endl << "Area of the Circle is: " << PI * SQR(radius);
#undef PI
//It is now
invalid to use PI, thus we cannot use the next line.
//cout << endl << "Perimeter of Circle is : " << 2 * PI * radius;
cout << endl << "Area of the Sphere of Radius " << \
radius << " is: " << 4/3.0 * 3.14 * CUBE(radius);
The above example illustrates the following:

We do not terminate the macros using (;)

Macros can be parameterized

Macros can be dependent on other macros (must be defined before they are used.)

Macros are customarily written in capital letters to avoid confusion between macro and
functions. (this is not a rule)

Parameters are enclosed in () to avoid the ambiguity arising due to operator precedence. For
instance in the example above we call SQR(4+3). This statement will be expanded as (4+3) *

Directives are helpful whenever things are prone to changes and are used at many places in
one program. Changing the directive value at the top will cause the corresponding changes at all
the places in the program.
If the directive requires use of more than one line then it can be continued in the next line after
placing \ at the end of the first line.
Take a look at the following example:
#include <iostream>
using namespace std;
#define greater(m,n)(m>n) ? (m)
: (n);

int main(int argc, char *argv[])

int number1, number2;
cout << endl << "Enter two numbers:";
cin >> number1 >> number2;
int g = greater(number1, number2);
cout << endl << "Greater of the two numbers is: " << g;
Conditional Compilation Directives
Conditional Compilation Directives these are used to execute statements conditionally for:

Executing the code on different machine architectures.

Debugging purposes.

Macros can be dependent on other macros (must be defined before they are used.)

Evaluating codes, which are to be executed depending upon the requirements of the
The following directives are included in this category:





Note: These macros are evaluated on compile time. Therefore they can only use the predefined
macros or literals. Most compilers do not support the use of variables with these directives.

#include <iostream>
using namespace std;
#define US 0
#define ENGLAND 1
//We define Netherlands as country, then we get Euro.
//If we define England we get pounds and so on.
int main(int argc, char *argv[])
char acurrency[] = {"Dollar"};
#define CHOSEN US
char acurrency[] = { "Pound" };
char acurrency[] = { "Euro" };
char acurrency[] = {"Euro"};
// If CHOSEN is not defined, then we get default.
#ifndef CHOSEN
cout << endl << "Using Default Currency " << acurrency;
cout << endl << "Chosen Currency " << acurrency;
Other Directives
The following directives are the other directives:



When the #error directive is found the program will be terminated and the message (that is given after
the #error statement) will be used in the compilation error that is given by the compiler.
Take a look at an example:
#ifndef __cplusplus
#error Compilation Error: A C++ compiler is required to compile this program!
The __plusplus macro is by default defined by most C++ compilers. So if this macro is not found,
during compilation, then the compilation is aborted and the message (Compilation Error: A C++
compiler is required to compile this program!) is printed for the user.

The #line directive is used to change the value of the __LINE__ and __FILE__ macros. (Note: the
filename is optional.) The __LINE__ and __FILE__ macros represent the line being read and the file
being read.
#line 50 "myfile.cpp"
This will set the __LINE__ to 50 and __FILE__ to myfile.cpp
The #pragma directive is used to allow suppression of specific error messages, manage heap and
stack debugging, etc. These are compiler specific directives. (Check your compiler documentation for
the #pragma lines you can use.)
For Example #pragma inline statement indicates the assembly code is available in the code.
If the directive is unavailable in an implementation the statement is ignored.
Predefined Macros
An integer that gives the line number of the current source file being compiled.
A string that gives the name of the source file being compiled.
A string that gives the date, in the form Mmm dd yyyy, when the compilation process began.
A string constant that gives the time at which the preprocessor is being run. The string constant looks
like 22:05:02 and contains eight characters. If the compiler cannot determine the current time, it
will give a warning message and __TIME__ will be expanded to ??:??:??. Note: the warning will
only be given once per compilation.
Forces the use of standard C/CPP codes only in the program.
Contains a 6 digit number to indicate that the compiler is based on the standards, otherwise it contains
5 or fewer digits.
This macro is defined with a value of 1 when preprocessing assembly language.
If this macro is defined with a value of 1 then the Objective-C compiler is in use. This macro can be
used to test whether a header file is compiled by a C compiler or an Objective-C compiler.