Macros & Conditional Compilation (How the Preprocessor Really Works)

In the previous lesson, you learned:

• What the preprocessor is

• How #include works

• How #define replaces text

Now we go deeper.

This lesson is where things become powerful (and a bit tricky):

Macros and conditional compilation

1. What is a Macro?

A macro is created using:

#define

It tells the preprocessor:

“Replace this name with something else before compilation”

🔹 Example (Object-like Macro)

#define PI 3.14

Usage:

float area = PI * r * r;

Before compilation:

float area = 3.14 * r * r;

2. Macro Expansion (Key Idea)

Macro expansion is just text substitution

The preprocessor does NOT evaluate logic.

It simply replaces text.

Example

#define X 5

int a = X + 2;

Becomes:

int a = 5 + 2;

3. Function-Like Macros

Macros can also look like functions.

🔹 Example

#define SQUARE(x) ((x) * (x))

Usage:

int result = SQUARE(3);

Becomes:

int result = ((3) * (3));

4. Why Parentheses Matter ⚠️

Without parentheses:

#define SQUARE(x) x * x

Then:

int result = SQUARE(1 + 2);

Becomes:

int result = 1 + 2 * 1 + 2;

👉 Wrong result!

Correct Version

#define SQUARE(x) ((x) * (x))

👉 Always use parentheses in macros

5. Macro Pitfalls (Very Important)

Macros are powerful but risky:

• ❌ No type checking

• ❌ Can behave unexpectedly

• ❌ Harder to debug

Example Problem

#define DOUBLE(x) (x + x)

int result = DOUBLE(2 * 3);

Becomes:

(2 * 3 + 2 * 3)  // works, but can be confusing

6. Conditional Compilation

The preprocessor can decide:

Which parts of your code should be compiled

🔹 Basic Example

#ifdef DEBUG
printf("Debug mode\n");
#endif

👉 This code runs only if DEBUG is defined.

7. Common Conditional Directives

---

#ifdef

#ifdef FLAG

Checks if a macro is defined.

#ifndef

#ifndef FLAG

Checks if a macro is NOT defined.

#if, #else, #endif

#if VERSION > 1
    // new version
#else
    // old version
#endif

8. Include Guards (Very Important)

When you include a header file multiple times, errors can occur.

🔹 Solution: Include Guards

#ifndef MAIN_H
#define MAIN_H

// code here

#endif

Why this works:

• First time → included

• Second time → skipped

👉 Prevents duplicate definitions

9. Putting It Together

Example combining everything:

#include <stdio.h>

#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define DEBUG

int main(void)
{
    int x = 10;
    int y = 20;

    int result = MAX(x, y);

#ifdef DEBUG
    printf("Debug: x=%d, y=%d\n", x, y);
#endif

    return 0;
}

10. Key Insight

The preprocessor controls what code the compiler sees

It can:

• include code

• remove code

• replace code

Before compilation even starts.

11. Macros vs Functions

Macros	Functions
Faster (no call overhead)	Safer
No type checking	Type checking
Harder to debug	Easier to debug

---

When to use macros:

• constants

• simple expressions

---

When to use functions:

• complex logic

• safer operations

12. Practice Thinking

Try to reason through these:

1. What happens if you define:

   #define A 10
   int x = A * 2;
   

2. Why do we use parentheses in macros?

3. What happens if DEBUG is not defined in:

#ifdef DEBUG
printf("Hello");
#endif

---

Key Ideas to Remember

• Macros are text replacements

• Function-like macros must use parentheses

• Conditional compilation controls what code runs

• Include guards prevent duplicate inclusion

• Macros are powerful but must be used carefully

What’s Next

Now that you understand macros and conditional compilation, the final step is:

How the preprocessor is used in real programs

In the next lesson, you’ll learn:

• predefined macros (__FILE__, __LINE__)

• real-world use cases

• how this connects to your project

That’s where everything becomes practical.