TECHBAZ.
  • Menu

For profound search results, you can try Google Custom Search.

Preprocessor Directive

Learn preprocessor directive in C++.

C++ Language

  1. Expand Menus ↓

Fundamentals

  1. 1 Introduction
  2. 2 Compiler & Installation
  3. 3 Program Structure
  4. 4 Data Types & Ranges
  5. 5 Reserved Keywords
  6. 6 Operators

Control Statement

  1. 7 Statement/Flow Control
  2. 8 if-else Statement
  3. 9 switch case

Loop Statements

  1. 10 Loops
  2. 11 for Loop
  3. 12 while Loop
  4. 13 do-while Loop
  5. 14 break & continue

Functions

  1. 15 Function Declaration
  2. 16 Function Calling & Arguments
  3. 17 Recursive Function
  4. 18 Scope Rules

Arrays

  1. 19 Array Declaration
  2. 20 Array Dimensions

Structure and Unions

  1. 21 Structure Declaration
  2. 22 Union Declaration
  3. 23 Structure with Functions
  4. 24 Preprocessor Directive

Pointers

  1. 25 Declaration & Arguments
  2. 26 Memory Allocation
  3. 27 new & delete

OOP

  1. 28 OOP Concepts
  2. 29 Class & Objects
  3. 30 Constructors & Destructors

STL

  1. 31 STL Concepts
  2. 32 String Manipulations
  3. 33 Mathematical Calculations

Files

  1. 34 File Processing
  2. 35 Binary File I/O
  3. 36 File Errors Handling

Exception Handling

  1. 37 Handling Exceptions
  2. 38 try-catch Blocks

QnA

  1. 39 Interview QnA

* In C++ programming, preprocessing is an essential step in the compilation process. While preprocessing is not directly related to creating a "struct" (structure) in C++, it is an integral part of the overall compilation process.

Preprocessor Directive

A preprocessor directive is a command that is processed by the preprocessor before the actual compilation of the program begins. These directives provide instructions to the preprocessor to perform various tasks such as file inclusion, conditional compilation, macro definition, and more. Preprocessor directives start with the '#' symbol.

• Some commonly used preprocessor directives in C++:

1. '#include': Used for including the contents of a header file in the source code.

#include ＜iostream＞

2. '#define': Used for defining macros, which are symbolic names representing a sequence of code.

#define PI 3.14159

3. '#ifdef, #ifndef, #else, #endif': Used for conditional compilation based on whether a macro is defined.

#ifdef DEBUG
    // Code for debugging
#else
    // Code for release
#endif

4. '#if, #elif, #else, #endif': Used for conditional compilation based on constant expressions.

#if defined(DEBUG) && (VERSION >= 2)
    // Code for a specific configuration
#else
    // Default code
#endif

5. '#pragma': Used for providing additional information to the compiler.

#pragma once

6. '#error': Used to generate a compiler error with a specified error message.

#ifndef SUPPORTED_PLATFORM
    #error "Unsupported platform"
#endif

7. '#warning': Used to generate a compiler warning with a specified warning message.

#warning "This feature is deprecated, use the new one instead"

8. '#line': Used to change the current line number and filename during compilation.

#line 42 "my_file.cpp"

#pragma

Let's create a small C++ program that uses some common preprocessor directives. In this example, we'll define a simple macro, include a header file conditionally, and use '#pragma' to demonstrate some directives.

cpp Copy Code 
#include＜iostream＞

// Define a macro
#define SQUARE(x) ((x) * (x))

// Conditional compilation based on a macro
#ifdef DEBUG
    #define LOG(message) std::cout << "[DEBUG] " << message << std::endl
#else
    #define LOG(message) // Empty macro for release build
#endif

int main() {
    // Use the macro to calculate the square of a number
    int num = 5;
    std::cout << "Square of " << num << " is: " << SQUARE(num) << std::endl;

    // Use the conditional compilation macro for logging
    LOG("This is a debug message.");

    // Using #pragma to disable a specific compiler warning
    #pragma warning(disable: 4996)
    std::cout << "Deprecated function, but we use it anyway." << std::endl;
    #pragma warning(default: 4996)

    return 0;
}
Output: 
Square of 5 is: 25
Deprecated function, but we use it anyway.

• Lets break down the program:

⤏ The '#include <iostream>' directive includes the iostream header file.

⤏ The 'The #define SQUARE(x) ((x) * (x))' directive defines a macro named 'SQUARE' that calculates the square of a given number.

⤏ The '#ifdef DEBUG' directive checks whether the macro 'DEBUG' is defined. If it is defined, the 'LOG' macro is defined to print debug messages; otherwise, it is defined as an empty macro.

⤏ In the 'main' function, we use the 'SQUARE' macro to calculate the square of a number and the LOG macro to print a debug message based on the 'DEBUG' macro's definition.

⤏ The '#pragma warning(disable: 4996)' directive is used to disable a specific compiler warning related to a deprecated function, and '#pragma warning(default: 4996)' reverts the warning settings back to default.

Note: Please note that the use of '#pragma' directives can be compiler-specific, and the warnings or features they control may vary between compilers. In this example, I used '#pragma warning' assuming a Microsoft Visual C++ compiler.

These directives provide a way to control the behavior of the preprocessor and, consequently, influence the compilation process of your C++ code. Keep in mind that excessive use of preprocessor directives can make code harder to read and maintain, so they should be used judiciously.

← Previous
Next →

What's Next?

We actively create content for our YouTube channel and consistently upload or share knowledge on the web platform.