Codecademy Logo

C++ Preprocessor

Related learning

  • Course

    Learn Advanced C++

    Learn advanced C++ programming with preprocessor directives, operator overloading, streams, and lambda expressions.
    • With Certificate
    • Advanced.
      9 hours

#pragma and #error

In C++, the #pragma directive communicates specific instructions to the compiler, often used for optimizations or system-specific features. The #error directive halts compilation, displaying a custom error message for debugging purposes.

// Example Usage of #pragma
defined(__APPLE__)
  #pragma message("Compiling on an Apple system.")
#endif


// Example Usage of #error
#ifndef MY_MACRO
  #error "MY_MACRO is not defined. Define MY_MACRO before using this library."
#endif

C++ Preprocessor Essentials

The C++ preprocessor is a crucial tool that prepares code before it’s compiled by the compiler. It handles directives like #include and #define, which insert other files or define constants, respectively. Understanding how the preprocessor works can help optimize your C++ programs.

#include <iostream>
#define PI 3.14159


int main() {
  std::cout << "Value of PI: " << PI << std::endl;
  return 0;
}

C++ Preprocessor Directives

In C++, preprocessor directives are special commands that start with a # symbol. They’re handled by the preprocessor, and they don’t end with semicolons. Preprocessor directives include commands like #include for including libraries or #define for defining macros.

#define PI 3.14159
#define e 2.71


#include <iostream>
#include "someHeader.hpp"


int main() {
  double radius = 5.0;
  double area = PI * radius * radius;
  std::cout << "Area of the circle: " << area << std::endl;
  return 0;
}

#Define Macros

In C++, #define is employed to establish macros. These macros act as placeholders that the preprocessor replaces with specified values or code snippets before compilation. This mechanism facilitates code consistency and reuse without additional runtime overhead.

#include <iostream>


#define PI 3.14159


int main() {
  float radius = 2.0;
  float area = 0.5 * PI * radius * radius;
  std::cout << "Area of circle: " << area << std::endl;
  return 0;
}

C++ Function-Like Macros

Function-like macros in C++ provide a powerful way to perform parameterized text substitution. Unlike functions, these macros operate during the pre-processing phase, allowing for inline expansion which can optimize performance. Use these macros judiciously, as they don’t provide type safety or scope restrictions like functions do.

#define MULTIPLY(a, b) ((a) * (b))


int main() {
  int x = 5;
  int y = 10;
  int result = MULTIPLY(x, y);  // result will be 50
  return 0;
}

C++ Stringification & Pasting

In C++, the # operator lets you turn a macro parameter into a string literal, while ## combines two tokens in a macro definition. These operators offer powerful preprocessing capabilities, enhancing code efficiency. See the example with macros EXAMPLE and CONCAT to understand how they work.

#include <iostream>
#define STRINGIFY(x) #x
#define CONCAT(a, b) a ## b


int main() {
  std::cout << STRINGIFY(Hello, World!) << std::endl;   // Outputs: "Hello, World!"
  int myVariable42 = 42;
  std::cout << CONCAT(myVariable, 42) << std::endl;    // Outputs: 42
  return 0;
}

C++ Conditional Compilation

Conditional compilation in C++ allows you to include or exclude parts of code during the compilation process. This is achieved using directives like #if, #ifdef, #ifndef, #else, #elif, and #endif. They are particularly useful for defining platform-specific code or enabling/disabling features without altering the codebase. Here’s a snippet demonstrating basic usage.

#ifndef SOME_HEADER
#define SOME_HEADER


  // file code here
  
#endif

C++ Include Guards

In C++, include guards are essential when you want to ensure a header file is included only once, preventing redefinitions. They use preprocessor directives to conditionally compile code.

// example of an include guard
#ifndef MY_HEADER_H
#define MY_HEADER_H


// contents of the header file


#endif // MY_HEADER_H

C++ Predefined Macros

In C++, predefined macros like __LINE__, __FILE__, and __DATE__ help you access the compilation environment data. They are useful for debugging or logging as they provide context such as the current line number and filename.

#include <iostream>


int main() {
  std::cout << "This code is in file: " << __FILE__ << ", on line: " << __LINE__ << std::endl;
  return 0;
}

Predefined Macros in C++

C++ offers predefined macros like __DATE__ and __TIME__, which give details about the compilation date and time. These macros are helpful for debugging to log when and where code was compiled, offering a timestamp for context. 

#include <iostream>


int main() {
  std::cout << "Compiled on: " << __DATE__ << " at " << __TIME__ << std::endl;
  return 0;
}

In the example, __DATE__ and __TIME__ display the compile date and time, respectively.

C++ Predefined Macros

In C++, you can use predefined macros to identify the system your code is compiled on and the type of compiler being used. These macros help in writing portable code that adapts to different environments.

#include <iostream>


int main() {
    #ifdef _WIN32
        std::cout << "Compiled on Windows" << std::endl;
    #elif __linux__
        std::cout << "Compiled on Linux" << std::endl;
    #elif __APPLE__
        std::cout << "Compiled on macOS" << std::endl;
    #endif


    #ifdef __GNUC__
        std::cout << "Using GCC Compiler" << std::endl;
    #elif _MSC_VER
        std::cout << "Using Microsoft Compiler" << std::endl;
    #endif
    return 0;
}

Learn more on Codecademy

  • Course

    Learn Advanced C++

    Learn advanced C++ programming with preprocessor directives, operator overloading, streams, and lambda expressions.
    • With Certificate
    • Advanced.
      9 hours
Previous
Next