🎩 The Preprocessor

#define: object-like macros & text substitution

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

#define teaches the preprocessor a new word. From that line on, every time the word appears on its own as a name in your code, it's replaced by the text you gave — before compilation, with zero understanding of C. That last clause is where all the power and all the danger live.

#include <stdio.h>

#define MAX_USERS 64
#define GREETING  "hello, "
#define PI        3.14159265358979

int main(void) {
    int slots[MAX_USERS];              /* becomes: int slots[64];  */
    printf(GREETING "world\n");        /* string literals concat!  */
    printf("circumference: %f\n", 2 * PI * 10);
    printf("slots: %zu\n", sizeof slots / sizeof slots[0]);
    return 0;
}

$ gcc defines.c -o defines && ./defines
hello, world
circumference: 62.831853
slots: 64

A macro like this — just a name and its replacement text, no parentheses after the name — is called an object-like macro, and it's the classic way to name a constant. Convention: macro names are SCREAMING_SNAKE_CASE — the all-caps shout warns readers "this is not a variable, it's a substitution."

It really is just text

The preprocessor doesn't compute 10+10 into 20. It stores the five characters 1 0 + 1 0 and pastes them wherever SIZE appears. Predict this one before peeking:

#include <stdio.h>

#define SIZE 10+10        /* looks like 20... */

int main(void) {
    printf("%d\n", SIZE);       /* line A */
    printf("%d\n", SIZE * 2);   /* line B */
    return 0;
}

Fine print on substitution

• Macros are not replaced inside string literals: printf("SIZE") prints the word SIZE.
• Nor inside other identifiers: SIZES or my_SIZE are untouched — replacement works on whole tokens, not substrings.
• Macro definitions last until the end of the file — scope means nothing to the preprocessor. A #define inside a function still applies to every later function.
• To retire a macro early, use #undef SIZE. It's rare, but handy when a library macro shadows something you need (e.g. the standard library is allowed to define function-like macros for its functions — #undef getc gets you the real function).

Macros the compiler defines for you

The implementation predefines a set of magic macros, refreshed at each use site:

Pedantic gem: __func__ is technically not a macro but a predefined identifier — it behaves like a local static const char[], because the preprocessor has no idea what function it's in. Everyone lumps it in with these anyway.

__STDC_VERSION__ is how code detects the standard version:

#include <stdio.h>

int main(void) {
    printf("file: %s, line: %d\n", __FILE__, __LINE__);
    printf("func: %s\n", __func__);
    printf("built: %s %s\n", __DATE__, __TIME__);
    printf("standard: %ld\n", __STDC_VERSION__);
    return 0;
}

$ gcc whoami.c -o whoami && ./whoami
file: whoami.c, line: 4
func: main
built: Aug  1 2026 14:03:22
standard: 201710
# gcc's current default is C17 (201710L); try -std=c23

#define vs const vs enum

C gives you three ways to name a constant, and they are genuinely different:

That third row surprises people coming from C++: in C, a const int is merely a read-only variable, so int arr[max]; is a VLA and case max: is an error. For integer constants, enum gives you type + scope + constant-expression status — often the best of all worlds. (C23 finally adds a true constexpr; that story continues in Part 5.)

Try it

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

Object-like macros substitute text; give them parameters and they substitute parameterized text — welcome to function-like macros, where the real footguns are stored.