C Preprocessor and Macros

40 min

The C preprocessor is a powerful tool that processes source code before compilation, performing text manipulation, file inclusion, and conditional compilation. Preprocessor directives (lines starting with #) enable code organization, constants, macros, and platform-specific code. Understanding the preprocessor is essential for writing maintainable, portable C programs. The preprocessor operates on text, not C syntax, so it can generate code programmatically.

Macros defined with #define perform text substitution. Simple macros replace identifiers with values (e.g., #define MAX_SIZE 100). Function-like macros accept arguments and expand to code (e.g., #define MAX(a, b) ((a) > (b) ? (a) : (b))). Macros are expanded before compilation, so they don't have type checking. Understanding macros enables code generation and constants.

Macro pitfalls include operator precedence issues (solved with parentheses), multiple evaluation of arguments (arguments may be evaluated multiple times), and lack of type safety. Best practices include using parentheses around macro arguments and results, using do-while(0) for multi-statement macros, and preferring inline functions for complex operations. Understanding macro pitfalls prevents common errors.

Conditional compilation directives (#ifdef, #ifndef, #if, #else, #elif, #endif) enable including or excluding code based on conditions. This enables platform-specific code, debug code, and feature flags. Conditional compilation is essential for writing portable code that works on different platforms. Understanding conditional compilation enables flexible code organization.

Header guards prevent multiple inclusion of header files. The pattern #ifndef HEADER_H #define HEADER_H ... #endif ensures header contents are included only once, preventing redefinition errors. Header guards are essential for header file organization. Understanding header guards prevents compilation errors.

Advanced preprocessor features include stringification (# operator converts to string), token pasting (## operator concatenates tokens), variadic macros (accepting variable arguments), and predefined macros (__LINE__, __FILE__, etc.). These features enable sophisticated code generation. Understanding advanced features enables powerful preprocessor usage.

Key Concepts

Preprocessor processes code before compilation.
Macros perform text substitution.
Conditional compilation enables platform-specific code.
Header guards prevent multiple inclusion.
Preprocessor operates on text, not C syntax.

Learning Objectives

Master

Creating and using macros
Implementing conditional compilation
Using header guards
Understanding preprocessor pitfalls

Develop

Understanding compilation process
Writing portable, maintainable code
Using preprocessor for code generation

Tips

Use header guards: #ifndef HEADER_H #define HEADER_H ... #endif.
Parenthesize macros: #define MACRO(x) ((x) * 2) to prevent precedence issues.
Use do-while(0): for multi-statement macros to ensure proper behavior.
Check predefined macros: __LINE__, __FILE__, __DATE__, __TIME__ for debugging.

Common Pitfalls

Not using parentheses in macros, causing operator precedence errors.
Creating complex macros, better as functions or inline functions.
Not using header guards, causing redefinition errors.
Multiple evaluation of macro arguments, causing side effects.

Summary

Preprocessor enables code organization and generation.
Macros provide text substitution before compilation.
Conditional compilation enables portable code.
Understanding preprocessor enables advanced C programming.

Exercise

Create a program demonstrating various preprocessor directives and macros.

#include <stdio.h>
#include <stdlib.h>

// Define constants
#define PI 3.14159
#define MAX_SIZE 100
#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))

// Conditional compilation
#ifdef DEBUG
    #define DEBUG_PRINT(x) printf("DEBUG: %s
", x)
#else
    #define DEBUG_PRINT(x)
#endif

// Platform-specific code
#ifdef _WIN32
    #define CLEAR_SCREEN "cls"
#else
    #define CLEAR_SCREEN "clear"
#endif

// Macro with multiple lines
#define PRINT_INFO(name, age, city) do {     printf("Name: %s
", name);     printf("Age: %d
", age);     printf("City: %s
", city); } while(0)

// Stringification macro
#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)

// Token concatenation
#define CONCAT(a, b) a##b

// Variadic macro (C99)
#define DEBUG_LOG(fmt, ...)     printf("[DEBUG] " fmt "
", ##__VA_ARGS__)

int main() {
    // Using defined constants
    printf("PI: %.5f
", PI);
    printf("MAX_SIZE: %d
", MAX_SIZE);
    
    // Using function-like macros
    int num = 5;
    printf("Square of %d: %d
", num, SQUARE(num));
    printf("Max of 10 and 20: %d
", MAX(10, 20));
    printf("Min of 10 and 20: %d
", MIN(10, 20));
    
    // Using conditional compilation
    DEBUG_PRINT("This is a debug message");
    
    // Platform-specific code
    printf("Clear screen command: %s
", CLEAR_SCREEN);
    
    // Multi-line macro
    PRINT_INFO("John Doe", 30, "New York");
    
    // Stringification
    printf("Stringified: %s
", STRINGIFY(Hello World));
    printf("Version: %s
", TOSTRING(1.0));
    
    // Token concatenation
    int var12 = 42;
    printf("Concatenated variable: %d
", CONCAT(var, 12));
    
    // Variadic macro
    DEBUG_LOG("User %s logged in from %s", "john", "192.168.1.1");
    DEBUG_LOG("Processing %d items", 100);
    
    // Predefined macros
    printf("File: %s
", __FILE__);
    printf("Line: %d
", __LINE__);
    printf("Function: %s
", __func__);
    printf("Date: %s
", __DATE__);
    printf("Time: %s
", __TIME__);
    
    // Conditional compilation based on compiler
    #ifdef __GNUC__
        printf("Compiled with GCC version %d.%d.%d
", 
               __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
    #endif
    
    #ifdef _MSC_VER
        printf("Compiled with MSVC version %d
", _MSC_VER);
    #endif
    
    return 0;
}

Exercise Tips

Use header guards in all header files: #ifndef HEADER_H #define HEADER_H ... #endif.
Use parentheses in macros: #define MACRO(x) ((x) * 2) prevents precedence issues.
Use do-while(0) for multi-statement macros: ensures proper statement behavior.
Use variadic macros: #define LOG(fmt, ...) printf(fmt, ##__VA_ARGS__) for flexible logging.

C Preprocessor and Macros