Mastering the C preprocessor is a form of meta-programming. You can write code that writes code, enabling patterns that are impossible with C syntax alone.

1. The Stringification (#) and Token-Pasting (##) Operators

These two operators work only within #define macros and provide powerful text manipulation capabilities.

a) The Stringification Operator (#)

The # operator takes a macro parameter and turns it into a string literal without expanding the parameter's definition.

·         Purpose: Useful for creating debugging macros that can print both a variable's name and its value.

Example:

C

#include <stdio.h>

#define PRINT_VAR(var) printf(#var " = %d\n", var)

int main() {

    int counter = 100;

    // The preprocessor expands this to:

    // printf("counter" " = %d\n", counter);

    // which the compiler treats as: printf("counter = %d\n", counter);

    PRINT_VAR(counter);

    return 0;

}

b) The Token-Pasting Operator (##)

The ## operator concatenates two separate tokens into a single new token.

·         Purpose: Used to create unique variable or function names programmatically within a macro.

Example:

C

#include <stdio.h>

#define DEFINE_HANDLER(name) void handle_##name(void) { \

                                printf("Handling " #name " event.\n"); \

                             }

// This macro call expands to:

// void handle_error(void) { printf("Handling error event.\n"); }

DEFINE_HANDLER(error);

// This macro call expands to:

// void handle_success(void) { printf("Handling success event.\n"); }

DEFINE_HANDLER(success);

int main() {

    handle_error();

    handle_success();

    return 0;

}

2. Variadic Macros (C99 and later)

Variadic macros can accept a variable number of arguments, similar to functions like printf.

·         Syntax: ... is used to represent the variable arguments, and the special identifier __VA_ARGS__ is used to access them in the macro's body.

·         Purpose: Essential for creating generic logging or wrapper functions.

Example: A custom debug logging macro

C

#include <stdio.h>

// __FILE__ and __LINE__ are standard predefined macros

#define DEBUG_LOG(format, ...) fprintf(stderr, "[DEBUG] %s:%d: " format, \

                                     __FILE__, __LINE__, __VA_ARGS__)

int main() {

    int user_id = 123;

    char *status = "success";

    // This expands to a single fprintf call with all the arguments

    DEBUG_LOG("User login status: %s, ID: %d\n", status, user_id);

    return 0;

}

3. The do-while(0) Trick for Safe Macros

When a macro contains multiple statements, it can break the logic of if-else blocks if it's not used with curly braces. The standard professional solution is to wrap the macro's body in a do { ... } while(0) loop.

·         Why it works: This construct ensures the entire macro body is parsed as a single, complete statement that correctly consumes the trailing semicolon.

Example:

C

// UNSAFE MACRO

#define FREE_MEM(p) free(p); p = NULL;

// SAFE MACRO

#define SAFE_FREE(p) do { free(p); p = NULL; } while(0)

int main() {

    int *p1 = malloc(sizeof(int));

    int *p2 = malloc(sizeof(int));

    if (p1 == NULL)

        FREE_MEM(p2); // Problem! Expands to: if (...) free(p2);; p2=NULL;

                      // The p2=NULL is OUTSIDE the if.

    if (p2 == NULL)

        SAFE_FREE(p1); // Correct. Expands to: if (...) do { ... } while(0);

                       // The entire block is a single statement.

    return 0;

}

4. X-Macros for Code Generation

This is an advanced technique for maintaining parallel lists of related items (e.g., enums and their string representations) without redundancy. The list is defined in one place, and a macro is used to "expand" that list for different purposes.

Example: Generating enums and a corresponding string table

C

#include <stdio.h>

// 1. Define the list of items using an X-Macro

#define COLOR_LIST \

    X(RED, "Red") \

    X(GREEN, "Green") \

    X(BLUE, "Blue")

// 2. Expand the list to create an enum

typedef enum {

#define X(name, str) C_##name,

    COLOR_LIST

#undef X

} Color;

// 3. Expand the same list again to create a string table

const char *ColorStrings[] = {

#define X(name, str) str,

    COLOR_LIST

#undef X

};

int main() {

    Color myColor = C_GREEN;

    // The enum and string array are guaranteed to be in sync

    printf("My color is %s\n", ColorStrings[myColor]); // Prints "My color is Green"

    return 0;

}

Conditional statements, also known as branching statements, allow a program to make decisions and execute different blocks of code based on whether a specific condition is true or false.