C - Macros and Parameterized Macros in C

Macros are one of the important features of the C preprocessor. A macro allows you to define a name that the preprocessor replaces with a specified value or piece of code before the actual compilation of the program begins.

Macros are created using the #define preprocessor directive. Unlike functions, macros do not execute at runtime. They are expanded by the preprocessor during the preprocessing stage.

1. What is a Macro?

A simple macro associates a name with a constant value or expression.

#include <stdio.h>

#define PI 3.14159

int main()
{
    printf("Value of PI = %f", PI);
    return 0;
}

Before compilation, the preprocessor replaces PI with 3.14159. Conceptually, the compiler receives something similar to:

printf("Value of PI = %f", 3.14159);

Therefore, a macro does not create a variable and does not require memory allocation like a normal variable.

2. Syntax of a Macro

The general syntax is:

#define MACRO_NAME replacement_text

For example:

#define MAX_SIZE 100
#define COMPANY "ABC Technologies"
#define RATE 10

The preprocessor replaces every occurrence of the macro name with its replacement text, subject to the normal rules for preprocessing.

3. Object-Like Macros

A macro without parameters is called an object-like macro.

#define MAX 100
#define MIN 0
#define MESSAGE "Welcome to C programming"

Example:

#include <stdio.h>

#define MAX 100

int main()
{
    int number = 75;

    if (number < MAX)
        printf("Number is within the limit");

    return 0;
}

Here, MAX represents the value 100.

Object-like macros are commonly used for constants, configuration values, and conditional compilation settings.

4. Parameterized Macros

A parameterized macro accepts one or more arguments. It looks similar to a function, but it is handled completely differently.

Syntax:

#define MACRO_NAME(parameter1, parameter2) replacement_text

For example:

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

The macro can then be used as:

int result = SQUARE(5);

The preprocessor expands it approximately as:

int result = ((5) * (5));

The result is 25.

5. Macro with Multiple Parameters

A macro can accept multiple parameters.

#define ADD(a, b) ((a) + (b))

Example:

#include <stdio.h>

#define ADD(a, b) ((a) + (b))

int main()
{
    int result;

    result = ADD(10, 20);

    printf("Result = %d", result);

    return 0;
}

The preprocessor expands:

ADD(10, 20)

into:

((10) + (20))

The output is:

Result = 30

6. Why Parentheses Are Important

Parentheses are extremely important when defining parameterized macros.

Consider this macro:

#define SQUARE(x) x * x

Now suppose we write:

int result = SQUARE(2 + 3);

The expansion becomes:

int result = 2 + 3 * 2 + 3;

Because multiplication has higher precedence than addition, the result is not 25. It becomes 11.

A safer definition is:

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

Now:

SQUARE(2 + 3)

becomes:

((2 + 3) * (2 + 3))

and produces:

25

As a general rule, parameters and the complete macro expression should usually be protected with parentheses when the macro represents an expression.

7. Macro Arguments Are Textually Substituted

A macro does not behave exactly like a function. Its arguments are substituted into the replacement text.

For example:

#define MULTIPLY(a, b) ((a) * (b))

When we write:

MULTIPLY(4, 5)

the preprocessor produces:

((4) * (5))

This is textual preprocessing rather than a normal function call.

This distinction becomes particularly important when macro arguments contain expressions or operations with side effects.

8. Macro Versus Function

Consider:

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

and:

int square(int x)
{
    return x * x;
}

Both can calculate the square of a number, but they work differently.

A function receives an argument and executes when the program runs. A macro is expanded before compilation.

For example:

square(5);

is a function call.

Whereas:

SQUARE(5);

is replaced by the preprocessor with:

((5) * (5))

Functions generally provide better type checking and predictable evaluation. Macros can be useful for simple compile-time substitutions but require careful design.

9. A Major Problem: Multiple Evaluation

Parameterized macros can evaluate an argument more than once.

Consider:

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

Now:

int i = 5;
int result = SQUARE(i++);

The expansion becomes:

int result = ((i++) * (i++));

The argument i++ occurs twice. This can lead to problematic behavior and should be avoided.

A normal function would receive the value of the argument once:

int square(int x)
{
    return x * x;
}

Then:

square(i++);

passes the value of i once to the function.

This is one of the most important differences between macros and functions.

10. Macros for Finding Maximum and Minimum

Parameterized macros can be used to define simple operations.

#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))

Example:

#include <stdio.h>

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

int main()
{
    int x = 15;
    int y = 25;

    printf("Maximum = %d", MAX(x, y));

    return 0;
}

Output:

Maximum = 25

Again, arguments with side effects should not be passed to such macros.

11. Multi-Line Macros

A macro can contain multiple statements. The backslash \ is used to continue the macro onto the next line.

Example:

#define DISPLAY() \
    printf("Hello\n"); \
    printf("Welcome to C\n");

It can be used as:

DISPLAY();

However, multi-statement macros require careful construction because they can interact unexpectedly with if, else, and other control structures. The common do { ... } while (0) technique can make statement-like macros safer:

#define DISPLAY() do { \
    printf("Hello\n"); \
    printf("Welcome to C\n"); \
} while (0)

This makes the macro behave more like a single statement.

12. Variadic Macros

C also supports macros that accept a variable number of arguments.

A commonly used form is:

#define LOG(...) printf(__VA_ARGS__)

Example:

LOG("Hello %s\n", "John");

The ... represents additional arguments, while __VA_ARGS__ is replaced with those arguments.

Variadic macros are particularly useful for logging, debugging, and wrapper macros around functions such as printf.

13. Stringizing Operator

The preprocessor provides the # operator for converting a macro argument into a string.

Example:

#define STRINGIFY(x) #x

Now:

printf("%s", STRINGIFY(Hello));

produces:

Hello

The argument Hello is converted into the string literal "Hello" during preprocessing.

Another example:

#define SHOW(x) printf(#x " = %d\n", x)

Using:

int age = 25;
SHOW(age);

can produce output such as:

age = 25

This feature is useful in debugging and diagnostic macros.

14. Token-Pasting Operator

The ## operator joins two tokens together.

Example:

#define JOIN(a, b) a##b

If we write:

int JOIN(number, 1) = 100;

the preprocessor combines number and 1 to create:

int number1 = 100;

Token pasting is useful when generating identifiers programmatically through macros.

15. Undefining a Macro

A macro can be removed using #undef.

#define VALUE 100

#undef VALUE

After #undef VALUE, the macro VALUE is no longer defined.

This can be useful when controlling definitions in different parts of a program.

16. Advantages of Macros

Macros provide several advantages:

1. They can make frequently used constants easier to manage.

2. They can avoid the overhead of a function call in situations where macro expansion is appropriate.

3. They can be used for conditional compilation and configuration.

4. Parameterized macros can provide generic operations that are not tied to a particular data type.

5. They are useful for debugging, logging, and platform-specific code.

6. They are extensively used in system programming and library development.

17. Disadvantages of Macros

Macros also have important limitations:

1. They do not provide normal function-like type checking.

2. Arguments can be evaluated multiple times.

3. Operator precedence can cause unexpected results if parentheses are omitted.

4. Debugging macro-expanded code can be more difficult.

5. Large macros can make source code difficult to understand.

6. Macros can introduce unexpected naming conflicts.

7. Excessive use of macros can make programs harder to maintain.

18. Macro and Function: Key Difference

Feature	Macro	Function
Processing	Preprocessor stage	Compilation/runtime
Type checking	No normal function-style checking	Yes
Argument evaluation	Textual substitution	Arguments evaluated when called
Return type	No	Has a return type if applicable
Debugging	Can be more difficult	Generally easier
Code expansion	Can increase generated code	Function body normally exists separately
Genericity	Can work across types through substitution	Usually requires compatible types or other mechanisms
Side effects	Can be problematic	Generally more predictable

19. Complete Example

#include <stdio.h>

#define PI 3.14159
#define SQUARE(x) ((x) * (x))
#define ADD(a, b) ((a) + (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))

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

    printf("PI = %.5f\n", PI);
    printf("Square of x = %d\n", SQUARE(x));
    printf("Sum = %d\n", ADD(x, y));
    printf("Maximum = %d\n", MAX(x, y));

    return 0;
}

Output:

PI = 3.14159
Square of x = 100
Sum = 30
Maximum = 20

In this program, PI is an object-like macro, while SQUARE, ADD, and MAX are parameterized macros.

Conclusion

Macros are preprocessor definitions that allow programmers to substitute constants, expressions, or blocks of code before compilation. Parameterized macros extend this concept by accepting arguments, making them useful for reusable operations such as calculating squares, finding maximum values, and performing generic substitutions.

However, macros should be designed carefully. Proper use of parentheses, awareness of multiple evaluation, and understanding the difference between textual substitution and function execution are essential. For many ordinary calculations, functions are safer and easier to maintain, while macros remain particularly valuable for compile-time configuration, conditional compilation, debugging, and low-level C programming.