{"id":83249,"date":"2019-08-08T01:58:54","date_gmt":"2019-08-08T01:58:54","guid":{"rendered":"https:\/\/www.softwaretestinghelp.com\/?page_id=83249"},"modified":"2025-04-01T08:10:31","modified_gmt":"2025-04-01T08:10:31","slug":"preprocessor-directives-in-cpp","status":"publish","type":"page","link":"https:\/\/www.softwaretestinghelp.com\/preprocessor-directives-in-cpp\/","title":{"rendered":"Preprocessor Directives In C++"},"content":{"rendered":"

A Detailed Look At Preprocessor Directives In C++.<\/strong><\/p>\n

The preprocessor is a unique feature of C++. In C++, we have steps like compilation, linking and execution for a typical program. In reality, we have a lot of other features in a C++ program that needs to be processed before passing the program for compilation.<\/p>\n

For this purpose, a special step called preprocessing is carried out. Preprocessing is carried out before the compilation process and the special features are preprocessed. As a result, an expanded C++ program is obtained and then it is passed to the compiler.<\/p>\n

=> Visit Here To Learn C++ From Scratch.<\/a><\/strong><\/p>\n

<\/strong><\/em><\/p>\n

\"Preprocessor<\/a><\/p>\n

Overview<\/h3>\n

The special features for preprocessing are identified using an entity called \u201cPreprocessor directive\u201d. These preprocessor directives tell the compiler that certain information in the C++ program marked with preprocessor directives need to be preprocessed before compilation.<\/p>\n

Note that in C++ all preprocessor directives begin with a \u201c#\u201d symbol. The moment the preprocessor (part of the compiler) encounters the # symbol, the information following the # symbol is preprocessed before passing the program to the compiler.<\/p>\n

Unlike the other C++ statements, preprocessor directives do not end with a semicolon.<\/p>\n

In this tutorial, we will explore the various preprocessor directives supported by C++.<\/strong><\/em><\/p>\n

File Inclusion Directives<\/h3>\n

#include<\/span><\/h4>\n

File inclusion directive #include allows us to include other files in our source program. We can include any header file that contains definitions of various predefined functions in our program using these functions. We can include header files in our program using the following syntax.<\/p>\n

#include <filename> <\/strong><\/pre>\n
Example:<\/strong><\/span>#include <iostream><\/p>\n
We have already seen this in our C++ programs. The header iostream contains the functions required for input\/output data streaming like cout, cin, etc.<\/p>\n
As our programs grow larger or the functionality becomes complex, we might want to divide our program into various files or import functionality from the other files. In this case, we make use of user-defined files. To include user-defined files in our program we can make use of the following syntax of #include directive.<\/p>\n
#include \u201cfilename\u201d <\/strong><\/pre>\n
Example:<\/strong><\/span> #include \u201cvector_int.h\u201d<\/p>\n
This is a user-defined header file that we intend to include in our program in order to use its functionality.<\/p>\n
The below code Example shows the usage of the #include directive.<\/strong><\/span><\/p>\n
#include <iostream>\r\nusing namespace std;\r\nint main()\r\n{\r\n  cout<<"This is an example demonstrating inclusion directive #include";\r\n}<\/pre>\n
 Output:<\/strong><\/p>\n
This is an example demonstrating the inclusion directive #include.<\/p>\n
As shown, we have used the #include directive to include the functionality of the <iostream> header in our program.<\/p>\n
Macro Definition Directives<\/h3>\n
#define<\/span><\/h4>\n
The #define directive is used to define the symbolic constants or macros in C++ program.<\/p>\n
 The general form of a #define directive is:<\/strong><\/p>\n
#define macro_name replacement code<\/strong><\/pre>\n
When a preprocessor encounters the macro in the program, the preprocessor replaces this macro with the code that is defined using the #define directive before the code is passed to the compiler.<\/p>\n
The below code Example shows a symbolic constant RADIUS that is defined using #define directive and its usage in the program.<\/strong><\/span><\/p>\n
#include <iostream>\r\n#define RADIUS 5\r\nusing namespace std;\r\n\r\nint main()\r\n{\r\n  \r\ncout<<"Area of a circle : "<<3.142 * RADIUS * RADIUS;\r\n}<\/pre>\n
Output:<\/strong><\/p>\n
Area of a circle : 78.55<\/p>\n
As shown in the program, we can make use of symbolic constant RADIUS in our code and it will be replaced by the value defined for it using the #define directive.<\/p>\n
We can use the #define directive to define a proper function code. These functions are usually small functions.<\/p>\n
An example is shown below.<\/strong><\/span><\/p>\n
#include <iostream>\r\n#define REC_AREA(length, breadth) (length * breadth)\r\nusing namespace std;\r\n\r\nint main()\r\n{\r\n  int length = 20, breadth = 5, area;\r\n \r\n  area = REC_AREA(length, breadth);\r\n \r\n  cout << "Area of a rectangle is: " << area;\r\n \r\n  return 0;\r\n}<\/pre>\n
Output:<\/strong><\/p>\n
Area of a rectangle is: 100<\/p>\n
Here using the #define directive we have defined a function REC_AREA that takes two arguments i.e. length and breadth and calculates the area of a rectangle. In the main function, we just make use of this macro and supply two arguments to it to obtain the area of a rectangle.<\/p>\n
#undef<\/span><\/h4>\n
Macros in a program defined with the #define directive last until it is undefined using the #undef directive. Once the program encounters #undef, the subsequent use of macro (undefined by #undef) will give a compilation error.<\/p>\n
In the above program, if we just give a statement #undef REC_AREA after the integer declarations, then the program will give a compilation error.<\/p>\n
Conditional Compilation Directives<\/span><\/h3>\n
Apart from the directives explained above, C++ also provides the following directives that can be used for conditional compilation of code. These directives can be used on similar lines of the if-else statement of C++.<\/p>\n
For Example,<\/strong><\/span> we can set DEBUG for a program ON or OFF using these conditional directives.<\/p>\n
Some of the conditional compilation directives provided in C++ include:<\/strong><\/p>\n