Macro Substitution Directives in C

Macro Substitution Directives in C Language with Examples

In this article, I will discuss the Macro Substitution Directives in C Language with Examples. Please read our previous article, where we discussed Pre-Processing in C. At the end of this article, you will understand the following pointers:

  1. Macro Substitution (#define) Directives in C
  2. What is Macro in C?
  3. Types of Macros in C
  4. Object-Like Macros Example In C
  5. Function-Like Macros Example in C
  6. Token Pasting (##) Example using Macros
  7. Stringizing (#) Example using Macros
  8. Macro with Arguments Example in C
  9. Macro for Code Block Example in C
  10. Undefining Macro Example in C
  11. Use Cases of Macros in C
  12. Advantages and Disadvantages of Macro
Macro Substitution (#define) Directives in C:

Macro substitution directives in C are a powerful feature of the C preprocessor, a tool that processes your source code before it is compiled. These directives allow you to define macros, essentially shortcuts or replacements for code snippets. When the program is compiled, all instances of the macro are replaced by its defined contents.

What is Macro in C?

A macro in C programming is a fragment of code that has been given a name. Whenever the name is used, it is replaced by the contents of the macro. Macros are processed by the preprocessor, a step that takes place before the actual compilation of code.

  • Defined using #define Directive: Macros are defined using the #define directive. For example, #define PI 3.14159 defines a macro named PI.
    No Storage Allocation: Unlike variables, macros don’t allocate storage space. They are merely replacements done by the preprocessor.
Types of Macros in C:
  • Object-Like Macros: These are simple replacements. For example, #define MAX_SIZE 100 defines a macro MAX_SIZE that is replaced by 100 wherever it appears in the code.
  • Function-Like Macros: These macros can take arguments but differ from functions. The arguments are replaced textually. For example, #define SQUARE(x) (x*x) defines a macro that calculates the square of its argument.
Object-Like Macros Example In C

Object-like Macros in C are a form of macro that resemble data objects when used. They don’t take arguments like function-like macros. Here’s an overview to illustrate how object-like macros are defined and used in C:

Defining Object-like Macros: You define object-like macros using the #define directive. For instance:
#define MAX_SIZE 100
#define PI 3.14159

In this example, MAX_SIZE and PI are macros. Whenever these names appear in the code, the preprocessor replaces them with 100 and 3.14159, respectively.

Example Usage Object-Like Macros In a C Program

Here’s a simple C program demonstrating the use of these macros:

#include <stdio.h>

#define MAX_SIZE 100
#define PI 3.14159

int main() {
    int array[MAX_SIZE]; // Array of size 100
    double circumference = 2 * PI * 10; // Circumference of a circle with radius 10

    printf("Array size: %d\n", MAX_SIZE);
    printf("Circumference of the circle: %f\n", circumference);

    return 0;
How Does It Work?
  • The preprocessor scans the source code before compilation.
  • When it encounters MAX_SIZE, it replaces it with 100.
  • Similarly, PI is replaced with 3.14159.
  • The compiler then compiles the code as if you had written 100 and 3.14159 directly in those places.
Benefits of Object-Like Macros in C
  • Readability: Using macros like MAX_SIZE and PI makes the code more readable and understandable.
  • Maintainability: If you need to change the value, you only need to change the macro definition, and all usages will automatically update.
  • Consistency: It ensures that the same value or concept is used consistently across the program.
Function-Like Macros Example in C

Function-like macros in C are macros that resemble function calls. They take arguments and are useful for creating inline code that doesn’t incur the overhead of a function call. Here’s an example to illustrate how function-like macros work in C:

#include <stdio.h>

// Define a macro that calculates the square of a number
#define SQUARE(x) ((x) * (x))

int main() {
    int value = 5;
    int result = SQUARE(value);

    printf("The square of %d is %d\n", value, result);

    // Using the macro with an expression
    printf("The square of %d is %d\n", value+1, SQUARE(value+1));

    return 0;

In this example:

Macro Definition: #define SQUARE(x) ((x) * (x))

  • SQUARE is a macro that takes one argument x.
  • It computes the square of x by multiplying x by itself.
  • The parentheses around x and the entire expression ensure correct evaluation order.

Using the Macro:

  • SQUARE(value) in the main function will be replaced by (value * value) during preprocessing.
  • When the main function is executed, the result will hold 25, as the value is 5.
  • Similarly, SQUARE(value+1) is replaced by ((value+1) * (value+1)), correctly computing the square of value+1.

Function-like macros are handy in C, but they should be used carefully. Since the preprocessor replaces them, they don’t have the same type-checking or scope rules as regular functions. Additionally, using complex expressions as macro arguments can lead to unexpected behaviors due to how macros are expanded.

Token Pasting (##) Example using Macros in C

Token pasting in C is achieved using the ## operator within a macro definition. This operator allows you to concatenate two tokens into a single token. It’s particularly useful for creating compound names or identifiers dynamically. Here’s an example to illustrate how token pasting works using macros in C:

#include <stdio.h>

// Define a macro to concatenate two tokens
#define CONCAT_TOKENS(a, b) a ## b

int main() {
    // Declare two variables
    int xy = 10;
    int yz = 20;

    // Use the macro to create concatenated names
    printf("Value of xy: %d\n", CONCAT_TOKENS(x, y)); // This will be replaced with xy
    printf("Value of yz: %d\n", CONCAT_TOKENS(y, z)); // This will be replaced with yz

    return 0;
In this example:

Macro Definition: #define CONCAT_TOKENS(a, b) a ## b

  • The CONCAT_TOKENS macro takes two arguments, a and b.
  • The ## operator concatenates a and b into a single token.

Using the Macro:

  • CONCAT_TOKENS(x, y) in the main function is replaced by xy during preprocessing, thus referring to the variable xy declared earlier.
  • Similarly, CONCAT_TOKENS(y, z) is replaced by yz, referring to the variable yz.

The token-pasting operator (##) provides a way to dynamically build complex expressions and names, which can be very powerful in certain programming scenarios, especially in meta-programming and code generation tasks. However, it should be used cautiously, as it can make code harder to read and debug.

Stringizing (#) Example using Macros in C

The stringizing operator (#) in C macros converts macro arguments into string literals. When you place a # before a parameter in a macro definition, the preprocessor converts the actual argument passed to the macro into a quoted string.

Macro Definition with Stringizing: #define STRINGIZE(x) #x
In this macro, STRINGIZE, the # before the parameter x converts x into a string.

Here’s an example to illustrate the use of the stringizing operator in C macros:

#include <stdio.h>

#define STRINGIZE(x) #x

int main() {
    // Using the macro to convert symbols to strings
    printf("%s\n", STRINGIZE(Hello, world!));  // Output: "Hello, world!"
    printf("%s\n", STRINGIZE(1234));           // Output: "1234"
    printf("%s\n", STRINGIZE(3.14));           // Output: "3.14"

    // Example with expressions
    int a = 5, b = 10;
    printf("%s\n", STRINGIZE(a + b));          // Output: "a + b"

    return 0;

How Does It Work?

  • When STRINGIZE(Hello, world!) is encountered, the preprocessor replaces it with “Hello, world!”, turning the argument into a literal string.
  • Likewise, STRINGIZE(1234) becomes “1234”, and so on.
  • Note that STRINGIZE(a + b) converts the literal text a + b into the string “a + b,” not the result of the expression.
Points to Remember:
  • The stringizing operator works only within macros. It converts the macro argument into a string, not the result of an expression involving the argument.
  • This feature is particularly useful for debugging purposes, where you might want to print variable names and their values or create strings based on macro parameters.
  • It’s important to understand that the preprocessor does the conversion before compilation. Hence, any changes to variables at runtime won’t be reflected in strings created by stringizing.
Macro with Arguments Example in C

A macro with arguments in C is a function-like macro, which allows you to define macros that can take input parameters (or arguments) and perform operations similar to a function. Here’s an example to illustrate this:

#include <stdio.h>

// Defining a macro with arguments
#define MAX(a, b) ((a) > (b) ? (a) : (b))

int main() {
    int num1 = 10, num2 = 20;

    // Using the macro
    int maximum = MAX(num1, num2);

    printf("The maximum of %d and %d is %d\n", num1, num2, maximum);

    return 0;
In this example:
  • A macro named MAX is defined, which takes two arguments, a and b.
  • The macro body is ((a) > (b) ? (a) : (b)), which is a ternary operation returning the greater of a and b.
  • In the main() function, MAX(num1, num2) is used. Here, num1 and num2 are passed as arguments to the MAX macro.
  • The preprocessor replaces MAX(num1, num2) with ((num1) > (num2) ? (num1) : (num2)) before the code is compiled. So, effectively, it evaluates to the maximum of num1 and num2.
Macro for Code Block Example in C

Creating a macro for a code block in C can be quite useful, especially for debugging, logging, or executing repetitive instructions. However, using such macros carefully is important to avoid issues with scope, unexpected behavior, or readability problems.

Macro Definition:
#define DEBUG_BLOCK(code) \
    do { \
        printf("Debug Start\n"); \
        code \
        printf("Debug End\n"); \
    } while(0)

In this macro DEBUG_BLOCK, code represents the block of code that will be executed within the macro. The do { … } while(0) construct is used to ensure that the macro behaves like a single statement, which is particularly important for control flow constructs (like if statements). Here’s an example of how you might define and use a macro for a code block:

#include <stdio.h>

#define DEBUG_BLOCK(code) \
    do { \
        printf("Debug Start\n"); \
        code \
        printf("Debug End\n"); \
    } while(0)

int main() {
    int x = 5, y = 10;

        printf("x = %d, y = %d\n", x, y);
        x = x + y;
        printf("Sum = %d\n", x);

    return 0;

Output: This would output something like:
Debug Start
x = 5, y = 10
Sum = 15
Debug End

How Does It Work?
  • The DEBUG_BLOCK macro encapsulates a code block with debug start and end messages.
  • The code within DEBUG_BLOCK is replaced by whatever block of code is passed to it when the macro is used.
  • The do { … } while(0) construct ensures that the macro can be safely used within if-else statements or other places where a single statement is expected.
Important Considerations
  • Scope: Variables defined within the macro are scoped to the macro and inaccessible outside it.
  • Braces Requirement: Braces {} are required to enclose multiple statements when using the macro.
  • Debugging: Debugging can be more challenging with macros, as the debugger operates on the expanded code, not the macro definition.
Undefining a Macro Example in C

In C, you can use the #undef directive to “undefine” a macro, effectively removing its definition from that point onwards in your code. This can be useful when you want to ensure that a macro does not interfere with later parts of your code or when you want to redefine it with a different value or behavior. Here’s an example to illustrate how to use #undef:

#include <stdio.h>

// Define a macro
#define PI 3.14159

int main() {
    printf("The value of PI is: %f\n", PI);

    // Undefine the macro
    #undef PI

    // Attempt to use the undefined macro (this will cause a compilation error)
    // printf("The value of PI is: %f\n", PI);

    // Redefine the macro with a different value
    #define PI 3.14
    printf("The new value of PI is: %f\n", PI);

    return 0;

In this code:

  • Initially, the macro PI is defined with the value 3.14159.
  • PI is used in a printf statement.
  • The #undef PI directive is used to remove the definition of PI.
  • After #undef, attempting to use PI would result in a compilation error because PI is no longer defined. This line is commented out in the example to avoid a compilation error.
  • PI is then redefined with a new value, 3.14, which is used again in another printf statement.

This example demonstrates how #undef can be used to control the scope and behavior of macros in a C program.

Use Cases of Macros in C:
  • Constant Definition: Defining constants throughout the code, like #define PI 3.14159.
  • Code Efficiency: They can make certain tasks more efficient by eliminating function call overhead, although this comes with its own trade-offs.
  • Conditional Compilation: Macros can be used for conditional compilation, which allows for compiling different code sections depending on certain conditions (e.g., #ifdef DEBUG).
Features of Macros:
  • Textual Replacement: Macros are replaced textually by the preprocessor. They are not checked for data types.
  • No Type Safety: Since macros are replaced before compilation, there’s no type checking as with functions.
  • Macro Expansion: Macros can be expanded recursively, leading to complex expressions.
Advantages of Macro:
  • Speed: No function call overhead when using macros.
  • Flexibility: Can be used for conditional compilation, enabling, or disabling code sections.
Disadvantages of Macro:
  • Debugging Difficulty: Since macros are expanded before the compilation, debugging can be challenging.
  • Complexity: Overusing or misusing macros can make code hard to read and maintain.
  • Potential for Errors: Macros don’t do type checking, and improper use can lead to errors that are hard to trace.

In the next article, I will discuss File Inclusion Directives in C Language with Examples. In this article, I try to explain Macro Substitution Directives in C Language with Examples. I hope you enjoy this Macro Substitution Directive in C Language with Examples article. I would like to have your feedback. Please post your feedback, questions, or comments about this article.

Leave a Reply

Your email address will not be published. Required fields are marked *