Macro in C

What is a Macro in C:

In C programming, a macro is a predefined code construct created using the #define preprocessor directive. Macros are not functions but rather text substitutions that occur during the preprocessor phase of compilation. They are used to define reusable code snippets or constants.

Why are Macros Used:

Macros serve several purposes in C:

  1. Code Reusability: Macros allow developers to define code fragments once and reuse them throughout the program, reducing redundancy and promoting efficient code maintenance.
  2. Code Clarity: They enhance code readability by assigning meaningful names to constants or frequently used code segments, making it easier for programmers to understand the code.

Syntax of Macros in C:

The basic syntax for defining a macro in C is:

#define MACRO_NAME replacement_text
  • MACRO_NAME is the identifier for the macro.
  • replacement_text is the code or value that will replace the macro when it is used.

Examples of Macro in C

Example 1: Creating a constant macro for PI value.

#define PI 3.14159265359

int main() {
    double radius = 5.0;
    double area = PI * radius * radius;
    return 0;

Output: In this code, the macro PI is defined to represent the value of π. It is then used to calculate the area of a circle with a radius of 5.0.

Example 2: Creating a macro for swapping two values.

#define SWAP(a, b) { int temp = a; a = b; b = temp; }

int main() {
    int x = 5, y = 10;
    SWAP(x, y);
    // Now, x is 10 and y is 5
    return 0;

Output: This example defines a SWAP macro to swap two integer values, x and y. When used in the main function, it correctly swaps the values.

Mistakes to Avoid When Using Macros:

  1. Missing Parentheses: Always use parentheses around macro parameters to prevent unexpected behavior, especially within expressions.
  2. Semicolon Problems: Be cautious when macros expand to multiple statements; consider enclosing them in a do { ... } while (0) construct for correct usage.
  3. Excessive Use: Avoid excessive use of macros, as it can hinder code debugging and maintenance.
  4. Naming Conflicts: Be mindful not to use macro names that conflict with standard library functions or variables.
  5. Complex Macros: Avoid creating overly complex macros, as they can reduce code readability.