Preprocessor directives in C++ | C++ Tutorial with Codes With Abhi | C++ Programming Language | Codes WIth Abhi

                     The preprocessor directives in C++

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.

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.

In this tutorial, we will explore the various preprocessor directives supported by C++.

File Inclusion Directives

#include

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.

#include <filename> 

Example:#include <iostream>

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.

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

include “filename” 

Example: #include “vector_int.h”

This is a user-defined header file that we intend to include in our program in order to use its functionality.

The below code Example shows the usage of the #include directive.

#include <iostream>

using namespace std;

int main()

{

  cout<<"This is an example demonstrating inclusion directive #include";

}

Output:

This is an example demonstrating the inclusion directive #include.

As shown, we have used the #include directive to include the functionality of the <iostream> header in our program.

Macro Definition Directives

#define

The #define directive is used to define the symbolic constants or macros in C++ program.

The general form of a #define directive is:

#define macro_name replacement code

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.

The below code Example shows a symbolic constant RADIUS that is defined using #define directive and its usage in the program.

#include <iostream>

#define RADIUS 5

using namespace std;

int main()

{

  

cout<<"Area of a circle : "<<3.142 * RADIUS * RADIUS;

}

Output:

Area of a circle : 78.55

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.

We can use the #define directive to define a proper function code. These functions are usually small functions.

An example is shown below.

#include <iostream>

#define REC_AREA(length, breadth) (length * breadth)

using namespace std;

int main()

{

  int length = 20, breadth = 5, area;

 

  area = REC_AREA(length, breadth);

 

  cout << "Area of a rectangle is: " << area;

 

  return 0;

}

Output:

Area of a rectangle is: 100

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.

#undef

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.

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.

Conditional Compilation Directives

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++.

For Example, we can set DEBUG for a program ON or OFF using these conditional directives.

Some of the conditional compilation directives provided in C++ include:

#if

#elif

#endif

#ifdef

#ifndef

#else

The below program demonstrates the usage of conditional compilation directives in a C++ program.

#include <iostream>

using namespace std;

#define DEBUG

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

int main () {

  int i, j;

 

  i = 100;

  j = 50;

  

#ifdef DEBUG

  cout <<"Trace: Start of main function" << endl;

  #endif

  

cout <<"The maximum is " << MAX(i, j) << endl;

  

#undef MAX

  //cout <<"The maximum is " << MAX(10,20) << endl;

 

  #ifdef DEBUG

  cout <<"Trace: End of main function" << endl;

  #endif

  return 0;

}

Output:

Trace: Start of main function

The maximum is 100

Trace: End of main function

In the above program, we use #ifdef – #endif directive to define a DEBUG for the program. Then we undefined the macro function MAX using the #undef directive. The conditional compilation directive constructs #ifdef – #endif checks if DEBUG is set and if it’s set, it prints few messages in the program.

The # & ## Operators

The # and ## operators are two special operators that are respectively used to convert a text token into a string to be displayed and concatenate two tokens.

Below given is an Example demonstrating both these operators.

#include <iostream>

using namespace std;

#define MKSTR( x ) #x

#define concat(a, b) a ## b

int main () {

  

  cout <<"MKSTR(Hello World) = "<< MKSTR(Hello World) << endl;

  int xy = 100;

 

  cout <<"concat(x,y) = "<<concat(x,y);

  return 0;

}

Output:

MKSTR(Hello World) = Hello World

concat(x,y) = 100

In the above program, we define MKSTR with an argument x. It has body #x. When we print this MKSTR using the argument “Hello World”, we see that because of #x, the argument is converted to a string and is displayed to the output.

Learn Python Programming Language