Macros & Preprocessor

What is a macro? (quick recap)

A macro is a rule you create with #define that the C preprocessor uses to replace text in your code before the compiler runs. If preprocessor basics like #include and include guards are new to you, read preprocessor directives first. This lesson focuses specifically on macros — the most powerful and most dangerous part of the preprocessor.

Object-like macros (constants)

The simplest macros just give a name to a fixed value. These are called object-like macros.

#include <stdio.h>
#define PI 3.14159
#define GREETING "Hello!"

int main() {
    printf("PI = %f\n", PI);
    printf("%s\n", GREETING);
    return 0;
}

Before compiling, the preprocessor literally replaces every PI with 3.14159 and every GREETING with "Hello!".

Function-like macros

Macros can also take arguments, looking a lot like functions — but they are still just text replacement.

#include <stdio.h>
#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))

int main() {
    printf("Square = %d\n", SQUARE(5));
    printf("Max = %d\n", MAX(10, 20));
    return 0;
}

Why parentheses are critical

This is the number-one macro trap. Because macros are blind text substitution, missing parentheses can silently give wrong answers.

#include <stdio.h>
#define BAD(x)  x * x        // no parentheses
#define GOOD(x) ((x) * (x))  // safe

int main() {
    printf("BAD(2+3)  = %d\n", BAD(2+3));   // 2+3*2+3 = 11
    printf("GOOD(2+3) = %d\n", GOOD(2+3));  // (2+3)*(2+3) = 25
    return 0;
}

The # and ## operators

Two special operators exist only inside macros. # turns an argument into a string; ## pastes two tokens together.

#include <stdio.h>
#define SHOW(x)   printf(#x " = %d\n", x)   // stringize
#define JOIN(a,b) a ## b                    // token paste

int main() {
    int value = 42;
    SHOW(value);            // prints: value = 42

    int JOIN(my, Num) = 7;  // becomes: int myNum = 7;
    printf("myNum = %d\n", myNum);
    return 0;
}

Notice how #x printed the text "value", and JOIN(my, Num) built the identifier myNum.

Macros vs functions

Dangerous pitfalls

Beyond missing parentheses, macros have another classic trap: arguments used more than once can be evaluated more than once.

#include <stdio.h>
#define SQUARE(x) ((x) * (x))

int main() {
    int n = 4;
    printf("%d\n", SQUARE(n++));  // becomes ((n++) * (n++)) -- unsafe!
    return 0;
}

Summary

• A macro is a #define text-replacement rule handled before compilation.
• Object-like macros name constants; function-like macros take arguments.
• Always parenthesise every argument and the whole macro body.
• # stringizes an argument; ## pastes tokens together.
• Macros have no type checking and can double-evaluate arguments — prefer functions when in doubt.