Preprocessor directives — #define, #ifdef, #ifndef, #include guards

WHY does the preprocessor exist?

WHY we need it:

Reuse code/text without re-typing → #include.
Name magic constants so changes happen in one place → #define.
Compile different code for different situations (debug vs release, Windows vs Linux) → #ifdef / #ifndef.
Stop a header from being pasted twice → include guards.

The build pipeline: $\text{source.c} \xrightarrow{\text{preprocessor}} \text{translation unit} \xrightarrow{\text{compiler}} \text{.o} \xrightarrow{\text{linker}} \text{executable}$

`#define` — naming things by text substitution

HOW it works (object-like macro):

#define PI 3.14159
double area = PI * r * r;   // becomes: 3.14159 * r * r

Why this step? The preprocessor literally swaps the text PI for 3.14159 before the compiler runs. By the time the compiler sees it, PI no longer exists.

Function-like macro (takes "arguments"):

#define SQUARE(x) ((x) * (x))
int y = SQUARE(3 + 1);   // becomes: ((3 + 1) * (3 + 1)) = 16

`#ifdef`, `#ifndef`, `#endif` — conditional compilation

WHY: sometimes you want code that exists only during debugging, or only on one OS. The preprocessor can delete entire chunks of code as text before the compiler sees them.

#define DEBUG
 
#ifdef DEBUG
    printf("x = %d\n", x);   // kept, because DEBUG is defined
#endif
 
#ifndef MAX
    #define MAX 100          // define MAX only if nobody defined it yet
#endif

Why this step? #ifndef MAX guards against double-definition — only set MAX if it isn't already.

Include Guards — the killer use of `#ifndef`

/* file: types.h */
#ifndef TYPES_H      /* if the unique tag is NOT defined... */
#define TYPES_H      /* ...define it now (so next time we skip) */
 
struct Point { int x, y; };   /* the real header body */
 
#endif /* TYPES_H */

HOW it works, step by step:

First time the header is pasted: TYPES_H is undefined → #ifndef is true → preprocessor defines TYPES_H and keeps the struct.
Second time it's pasted: TYPES_H is now defined → #ifndef is false → preprocessor deletes everything up to #endif. The struct appears only once. ✅

Worked examples

Worked example 1. Macro precedence trap

#define HALF(x) x / 2
int z = HALF(6 + 4);

Substitution → 6 + 4 / 2 = 6 + 2 = 8. Not 5! Why this step? / binds tighter than +, so 4/2 happens first. Fix: #define HALF(x) ((x) / 2) → ((6+4)/2) = 5.

Worked example 2. Debug toggling

#define VERBOSE
#ifdef VERBOSE
    printf("loaded %d items\n", n);
#endif

Comment out the #define VERBOSE line → the printf text is deleted by the preprocessor, producing a smaller, silent build. Why this step? No runtime if cost — the line literally isn't compiled.

Worked example 3. Default value pattern

#ifndef BUFFER_SIZE
#define BUFFER_SIZE 256
#endif
char buf[BUFFER_SIZE];

If a build script passes -DBUFFER_SIZE=1024, that wins; otherwise it defaults to 256. Why this step? #ifndef lets external configuration override without editing the file.

Common mistakes (steel-manned)

Flashcards

What stage runs before the C compiler and processes # lines?

The preprocessor (textual substitution + conditional inclusion).

Is a #define macro a typed variable?

No — it's pure text substitution with no type, no memory, no scope.

Why wrap macro arguments in parentheses, e.g. ((x)*(x))?

Because blind text pasting ignores precedence; parens force correct grouping for expressions.

What does #ifdef NAME do?

Keeps the enclosed code only if NAME is currently defined; deletes it otherwise.

Difference between #ifdef and #ifndef?

#ifdef = compile if defined; #ifndef = compile if NOT defined.

Write the include-guard pattern.

#ifndef TAG then #define TAG then body then #endif.

What problem do include guards solve?

Prevent a header's contents being pasted (and re-defined) multiple times in one translation unit.

What's the non-standard one-line alternative to include guards?

#pragma once.

Why is #define MAX 100; dangerous?

The ; is substituted too, breaking usages like arr[MAX] → arr[100;].

What does #ifndef BUFFER_SIZE / #define BUFFER_SIZE 256 / #endif allow?

An external -DBUFFER_SIZE to override; otherwise a safe default of 256.

Recall Feynman: explain it to a 12-year-old

Imagine you write an essay but leave little stickers like "PI" and "BIG_NUMBER". Before the teacher reads it, a helper goes through and replaces every sticker with the real words you told it to use. The helper can also follow notes like "only keep this paragraph if we're in test mode" and "if you already glued this page in once, don't glue it again." That helper is the preprocessor. It just copies, replaces, and removes text — it doesn't actually understand the essay. After the helper finishes, the real teacher (the compiler) reads the cleaned-up version.

Connections

Header files and translation units
const vs #define vs enum
Compilation pipeline — preprocess, compile, assemble, link
Macros vs inline functions
Conditional compilation for cross-platform code
Build flags -D and the command line

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, C me jab tum code likhte ho, to compiler usse seedha nahi padhta. Pehle ek aur banda chalta hai jise preprocessor kehte hain. Ye banda bas text ka kaam karta hai — find-and-replace aur cut-paste. Wo C ko samajhta nahi, bas # se shuru hone wali lines ko follow karta hai. Isliye #define PI 3.14159 likhne ka matlab hai: "jahan jahan PI dikhe, wahan 3.14159 paste kar do" — compiler ke aane se pehle hi.

#define ka function-wala version, jaise #define SQUARE(x) ((x)*(x)), bahut kaam ka hai, par parentheses zaroori hain. Kyunki substitution blind hota hai, agar tum x*x likhoge to SQUARE(3+1) ban jaayega 3+1*3+1 = 7, jo galat hai. Har argument ko aur poore body ko () me lapeto, tabhi grouping sahi rahegi.

#ifdef aur #ifndef se tum conditional compilation kar sakte ho — yaani kuch code ko compile karna hai ya nahi, ye decide karna. #ifdef DEBUG ka matlab: agar DEBUG defined hai tabhi ye lines rakho, warna delete kar do. Iska sabse important use hai include guard: #ifndef TYPES_H → #define TYPES_H → ...body... → #endif. Isse ek header file agar do baar paste ho bhi jaaye, to body sirf ek baar aayegi, aur "redefinition" wala error nahi aayega. Modern shortcut hai #pragma once.

Yaad rakhna do cheezein: directive ke baad semicolon mat lagao (#define MAX 100; galat hai, kyunki ; bhi paste ho jaata hai), aur macro typed variable nahi hai — agar typed constant chahiye to const ya enum use karo. Bas itna samajh lo to preprocessor tumhara dost ban jaayega.

Preprocessor directives — #define, #ifdef, #ifndef, #include guards

WHY does the preprocessor exist?

`#define` — naming things by text substitution

`#ifdef`, `#ifndef`, `#endif` — conditional compilation

Include Guards — the killer use of `#ifndef`

Worked examples

Common mistakes (steel-manned)

Flashcards

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — C Programming

Connections