C Macros (#define) – Powerful Compile-Time Substitution in C

Introduction – What Are Macros in C?

In C programming, a macro is a preprocessor directive that performs compile-time substitution of values or code snippets. Defined using #define, macros improve code readability, reduce repetition, and offer performance benefits since they are expanded before compilation.

There are two types of macros in C:

1. Object-like macros – Represent constants
2. Function-like macros – Act like inline functions

Syntax and Usage of Macros

Object-Like Macro

#define PI 3.14159
#define MAX_COUNT 1000

• Replaces all instances of PI with 3.14159 during preprocessing
• Commonly used to define constants

Function-Like Macro

#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))

• These act like inline functions
• Arguments are substituted as-is—use parentheses to avoid operator precedence bugs

Key Features of Macros

Important Macro Considerations

Operator Precedence Issue

#define BAD_SQUARE(x) x * x
int result = BAD_SQUARE(2 + 3);  // Expands to: 2 + 3 * 2 + 3 = 11 

Correct Way:

#define GOOD_SQUARE(x) ((x) * (x))
int result = GOOD_SQUARE(2 + 3);  // ((2 + 3) * (2 + 3)) = 25 

Undefining a Macro

You can remove or cancel a macro definition using #undef:

#undef PI

Macros vs Constants

Real-World Examples

Toggle Debug Mode

#define DEBUG
...
#ifdef DEBUG
    printf("Debugging enabled\n");
#endif

Platform-Specific Compilation

#define WINDOWS
...
#ifdef WINDOWS
    // Windows-specific code
#else
    // Linux/Other code
#endif

Best Practices & Tips

Best Practice:
Use parentheses around macro parameters and expressions to avoid precedence bugs.

Tip:
Prefer const for typed constants when type safety is required.

Pitfall:
Macros don’t respect scope—avoid naming collisions by using descriptive names.

Summary – Recap & Next Steps

Macros provide powerful tools for code substitution, parameterized expressions, and compile-time customization. When used correctly, they simplify code and enhance configurability.

Key Takeaways:

• Macros are expanded during preprocessing using #define
• Can be constant-like or function-like
• Offer zero runtime cost but require careful usage
• Combine with #ifdef, #undef, and other preprocessor tools for best results

Real-World Relevance:

Used in configuration headers, logging systems, platform abstraction, and high-performance math or embedded programming.

Frequently Asked Questions (FAQ)

What is #define in C?

It defines a macro that replaces a name with code or value before compilation.

Can macros have parameters?

Yes, function-like macros accept arguments for substitution.

Are macros type-safe?

No. Macros are not evaluated with type checking—use const for safety.

Can macros be debugged?

No. Since macros are expanded before compilation, their names don’t appear in the debugger.

When should I use macros over functions?

When you need inline substitution and performance with very small and generic operations.