🎩 The Preprocessor

Function-like macros: power tools with no guard

⏱ 14 min · free interactive lesson · quizzes, visualizations & a real compiler

Add parentheses right after the macro name — no space! — and #define takes arguments, making a function-like macro: #define SQUARE(x) x * x. Now SQUARE(7) becomes 7 * 7. It looks like a function, but remember the mantra: it's still just text. Arguments aren't worked out to a value and handed over the way a function's are — they're pasted, character for character.

The classic disaster, in three acts

#include <stdio.h>

#define SQUARE(x) x * x

int main(void) {
    int a = 4;
    printf("%d\n", SQUARE(3));      /* fine: 3 * 3 = 9   */
    printf("%d\n", SQUARE(a + 1));  /* ...uh oh          */
    return 0;
}

The repaired version parenthesizes each parameter: #define SQUARE(x) (x) * (x). But that's still only half the armor:

Hence the full parenthesization rule: parentheses around every parameter use AND around the whole replacement:

/* every parameter use wrapped + the whole body wrapped */
#define SQUARE(x) ((x) * (x))

/* the same discipline, always: */
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define ABS(x)    ((x) < 0 ? -(x) : (x))

And even the perfect version has one unfixable flaw — arguments that get pasted twice are evaluated twice:

Multi-statement macros: the do { } while (0) idiom

Suppose a macro needs two statements. Wrapping them in bare braces seems reasonable — until the macro meets an if:

#define SWAP(a, b) { int t = (a); (a) = (b); (b) = t; }

void order(int x, int y) {
    if (x > y)
        SWAP(x, y);      /* expands to { ... } ;   */
    else                 /* error: 'else' without a previous 'if' */
        x = y;
}

Expansion of the bad version: the if owns the { ... } block, then the user's semicolon becomes an empty statement, and the else is left dangling with nothing to attach to — a syntax error (or worse, silently wrong pairing in nested ifs). The cure is a loop that runs exactly once:

#define SWAP(a, b) do { int t = (a); (a) = (b); (b) = t; } while (0)

void order(int x, int y) {
    if (x > y)
        SWAP(x, y);      /* one statement + required ';' — perfect */
    else
        x = y;           /* compiles, and pairs correctly */
}

Why it works: do { ... } while (0) is a single statement that demands a semicolon — so SWAP(a, b); behaves exactly like a function call in every grammatical position, including between if and else. Every serious C codebase (Linux kernel included) uses this idiom.

The # and ## operators

Two operators exist only inside macro replacement text:

• #param — stringify: turns the argument's text into a string literal. #x with x = score+1 gives "score+1".
• a ## b — token pasting: glues two tokens into one new token. val ## 2 makes the identifier val2.

Stringify powers every debugging macro ever written — print the expression and its value without typing it twice:

#include <stdio.h>

#define DUMP(expr) printf(#expr " = %d\n", (expr))

int main(void) {
    int score = 40, bonus = 2;
    DUMP(score);
    DUMP(score + bonus);
    DUMP(score * bonus + 1);
    return 0;
}

$ gcc dump.c -o dump && ./dump
score = 40
score + bonus = 42
score * bonus + 1 = 81
# the expression text AND its value — typed only once

Note the trick: #expr " = %d\n" works because adjacent string literals are concatenated. Token pasting shines in code generators — one macro stamping out families of declarations: DECLARE_LIST(int) can mint list_int_push, list_int_pop, and friends via list_ ## T ## _push.

Variadic macros: __VA_ARGS__

Since C99, a macro's parameter list may end in ..., and __VA_ARGS__ expands to whatever extra arguments were passed — tailor-made for wrapping printf-style functions:

#include <stdio.h>

#define LOG(fmt, ...) \
    fprintf(stderr, "[%s:%d] " fmt "\n", \
            __FILE__, __LINE__, __VA_ARGS__)

int main(void) {
    int users = 3;
    LOG("startup ok, %d users", users);
    LOG("temp=%d limit=%d", 71, 80);
    return 0;
}

$ gcc log.c -o log && ./log
[log.c:9] startup ok, 3 users
[log.c:10] temp=71 limit=80

One wrinkle: with the C99 rules, LOG("boot") — no extra args — leaves a dangling comma after __LINE__,. C23 fixes this cleanly with __VA_OPT__(x), which expands to x only if variadic arguments are present: __LINE__ __VA_OPT__(,) __VA_ARGS__. (Before C23, GCC and Clang offered , ## __VA_ARGS__ as an extension that swallows the comma.)

Macro or function? A field guide

Modern advice: prefer real functions (the compiler inlines them beautifully — see the inline lesson), and reserve macros for what functions cannot do: stringifying, token pasting, using __FILE__/__LINE__ at the call site, and type-generic tricks.

Try it

▶ This spot has an interactive editor widget — open the interactive lesson to play with it.

You now command substitution; next comes the preprocessor's other superpower — making whole regions of code appear or vanish with #if.