🎩 The Preprocessor

Conditional compilation: code that decides to exist

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

An if statement chooses at runtime. The preprocessor's #if chooses at build time — while your program is being compiled — and the losing side isn't skipped, it's deleted before the compiler ever sees it. That deleted code can call functions that only exist on another operating system, sit half-written, or make no sense at all: deleted text can't cause errors.

The directive family

The expression after #if is an integer constant expression evaluated by the preprocessor: arithmetic, comparisons, &&/||, and the special operator defined(NAME), which is 1 if the macro exists (regardless of its value). No sizeof, no casts, no floats, no enum constants — the preprocessor knows only macros and integers.

Platform detection

Compilers predefine macros that identify the target OS — the standard way to write portable code with unportable pieces:

#include <stdio.h>

#if defined(_WIN32)
    #define PLATFORM "Windows"
#elif defined(__APPLE__)
    #define PLATFORM "macOS"
#elif defined(__linux__)
    #define PLATFORM "Linux"
#else
    #define PLATFORM "something exotic"
#endif

int main(void) {
    printf("compiled for: %s\n", PLATFORM);
    return 0;
}

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

Only ONE of those branches survives preprocessing — on Linux, the compiler literally never sees the string "Windows". That's why the Windows branch could call <windows.h> functions that don't exist on Linux, and still build fine there.

Debug builds: -D defines macros from the command line

The most-used pattern in all of C: log verbosely in development, compile the logging away entirely in release. The switch is gcc -DDEBUG, which acts exactly like a #define DEBUG 1 at the top of every file:

#include <stdio.h>

#ifdef DEBUG
    #define DBG(...) fprintf(stderr, "[debug] " __VA_ARGS__)
#else
    #define DBG(...) ((void)0)   /* expands to nothing useful */
#endif

int main(void) {
    int items = 3;
    DBG("starting up, items=%d\n", items);
    printf("processed %d items\n", items);
    DBG("done\n");
    return 0;
}

$ gcc app.c -o app && ./app
processed 3 items
# release build: DBG lines cost literally zero instructions
$ gcc -DDEBUG app.c -o app && ./app
[debug] starting up, items=3
processed 3 items
[debug] done

In the release build the DBG calls expand to ((void)0) — a statement that does nothing and costs nothing. Zero runtime overhead, not even a branch. You can also pass values (-DLEVEL=3) and un-define with -U.

#if 0: the nuclear comment

#if 0
    /* old algorithm — kept for reference */
    total = slow_sum(data, n);   /* O(n^2), ouch */
#endif
    total = fast_sum(data, n);

/* trying the same with a comment would die here ^ at
   the FIRST */ ... because block comments do not nest */

C's /* */ comments don't nest — commenting out code that contains comments breaks at the first */. #if 0 ... #endif blocks nest with other conditionals and swallow (almost) anything, making them the standard way to disable a chunk of code temporarily. Just don't ship code full of them.

Feature-test macros: the reverse direction

Conditionals also flow the other way: you define macros to ask system headers for more. POSIX functions like getline or clock_gettime are hidden behind guards inside glibc's headers; defining _POSIX_C_SOURCE 200809L (or _GNU_SOURCE for everything) before any #include unlocks them. If a man page mentions a feature-test macro requirement, this is what it means.

Try it

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

Conditionals decide what compiles — the next lesson covers the directives that talk back: errors, warnings, and pragmas.