Last Updated on June 19, 2023 by Mayank Dham

In this blog post, we will delve into the topic of macros in the C programming language, specifically focusing on the concept of C defined macros. We will explore what macros are, their purpose in the C language, the syntax used to define and use them, as well as their compilation process. Additionally, we will discuss various types of macros, accompanied by detailed explanations, code examples, and corresponding output. Furthermore, we will highlight the advantages offered by macros or C defined macros.

What are Macros in C Language?

Consider a scenario where we are working on a program and come across a situation where a particular value, code segment, or object repeats multiple times. To save time, reduce code duplication, and enhance code readability, we can define it once and utilize that definition throughout the code. This can be achieved by employing macros in the C programming language.

In C, a macro is a piece of code that can be replaced with a macro value. Macros are defined using the #define preprocessor directive and do not require a semicolon at the end. It’s important to note that "macro" is simply a label assigned to specific values or phrases and does not represent a memory location. Additionally, macro definitions in C are substituted with their respective macro values whenever encountered by the compiler. It is essential to ensure that the names of different macros do not overlap in the C language.

Syntax of Macros in C Language

In the general syntax for c macro function or macros in c language, we have three main parts that we have to keep in our mind. This will be the general syntax while writing any macro program.
The syntax includes “#define” followed by “macro name” and at last “ the value of macro”.

• define: it is a preprocessor directive.

• Macro name: This will be the name of the macro that you will use in the code which will use to search for the maco outside the call.
• Macro value: As the name suggests this is the value assigned with a macro which will be used in the code whenever a macro in c language name is mentioned.

Example of Macro in C Language
In this section of the blog, we will discuss the example of macro in c language

Code Implementation:

#include<stdio.h>

// This is macro definition
#define PI 3.14

void main()
{
    // declaration and initialization of radius
    int radius = 22;
// decalarion and calculating the circumference 
float area = 2 * PI * radius; 
    
//printing the circumference of the circle
printf("Circumference of circle is %f", area);
}

Circumference of circle is 138.160004

Explanation of the above example
In the above example, we have used a macro in c language named PI and assigned it the value 3.14, and in the code, we are finding the circumference of the circle and we need to use the value of pie in the code we have just named the macro in c that we have mentioned above and in the formulae, we have used the macro name and we are guessing the required answer.

Types of Macro in C Language

There are mainly four types of macros in c language, we will discuss all of them with a proper explanation of their code and output.

1. Object Like Macro in C Language
   An object-like macro is a straightforward identifier that gets replaced by a section of code. It is referred to as "object-like" because it behaves like an object within the code where it is used. It is a common practice to substitute a constant number or variable in place of a symbolic name. In simple terms, the identifier will be substituted with a code fragment or segment.

   Example

   • C

   #include <stdio.h>
   
   // Macro definition
   #define DATE 19
   
   int main()
   {
       // Print the message
       printf("Prepbytes was founded on"
           "  %d-FEB-2019",
           DATE);
   
       return 0;
   }
   

   
   Output

   Prepbytes was founded on  19-FEB-2019

   Explanation of the above example
   In the above example, we have used a macro in c language with the name date and simply used it to print the message involving that date. Like we have used the date to print the message with the required date.

2. Chain-Like Macros
   These are the certain type of c define macro or macros that are considered to be macros as they are macros inside the c define macro or macros in simple words when a macro is defined inside a macro it is known as a chain-like macro. The flow of accessing the c define macros is first the parent macro will be expanded by the compiler after that the child macros which are defined inside the parent macro are accessed or expanded by the compiler.

   Example
   In this example, we will study the example of a chain like macros in c language.

   Code Implementation:

   • C

   #include <stdio.h>
   
   #define INSTAGRAM FOLLOWERS
   #define FOLLOWERS 113
   
   // Driver Code
   int main()
   {
       // Print the message
       printf("Prepbytes have %dK"
           " followers on Instagram",
           INSTAGRAM);
   
       return 0;
   }
   

   
   Output

   Prepbytes have 113K followers on Instagram

   Explanation of the above example
   In the above example, we have studied the chain-like macros in c language. Here we have used two macros one with the name “INSTAGRAM FOLLOWERS” and the other with the name “ FOLLOWERS”. First, INSTAGRAM is developed to generate FOLLOWERS. The extended macro is then expanded to provide the result as 138K. This is referred to as macro chaining.

3. Multi-Line Macro
   We can define a macro in c language in multiple lines as some c define macro names need to be present in multiple lines so in those cases the multi-line macros are very important
   We can just change the line by using a backsplash – newline

   Code Implementation:

   • C

   // C program to illustrate macros
   #include <stdio.h>
   
   // Multi-line Macro definition
   #define ELEM 21, \
               22, \
               23, \
               24
   
   // Driver Code
   int main()
   {
   
   
       int arr[] = { ELEM };
   
       printf("Elements of Array are:\n");
   
       for (int i = 0; i < 4; i++) {
           printf("%d ", arr[i]);
       }
       return 0;
   }
   

   
   Output

   Elements of Array are:
   21 22 23 24

   Explanation of the above code
   In the above code, we have used multi-line macros and in that multi-line macros, we have declared elements of the array each element is declared in the new line and the name of the macro is elem.

4. Function Like Macro
   In C programming, function-like macros are remarkably similar to actual functions.
   The macro name can be used to supply parameters and carry out operations in a code segment.
   Since there is no type checking for arguments in c define macros, it is advantageous to send several datatypes through the same macro in the C programming language.

   Example
   In this example, we will understand the function like a macro with proper code and output and will have the proper explanation of the same.

   Code Implementation:

   • C

   // C program to illustrate macros
   #include <stdio.h>
   
   // Function-like Macro definition
   #define max(a, b) (((a) < (b)) ? (b) : (a))
   
   // Driver Code
   int main()
   {
   
       // Given two number a and b
       int a = 35;
       int b = 22;
   
       printf("Maximum value between"
           " %d and %d is %d\n",
           a, b, max(a, b));
   
       return 0;
   }
   

   
   Output

   Maximum value between 35 and 22 is 35

   Explanation of the above code
   In the above code we have used a function like a macro in c language here we have tried to find the maximum of two numbers by using ternary operators and we have found out the max of two numbers using that macro in c language.

Predefined Macros in C language

While Writing any macro program you can use these predefined macros in c language.

Advantages of Macros in C

• Code Reusability: Macros allow us to define reusable code snippets that can be used multiple times throughout the program. By defining a macro once, we can easily incorporate its functionality wherever needed, reducing code duplication and promoting modular programming.
• Readability and Maintainability: Macros can enhance code readability by providing meaningful names to frequently used code segments or values. This makes the code easier to understand and maintain, as the purpose and functionality of the macro are explicitly stated.
• Compile-Time Efficiency: Macros are processed during the compilation phase. The code substitution performed by macros is done at compile-time, resulting in efficient code execution without any runtime overhead. This can lead to improved performance in certain scenarios.
• Conditional Compilation: Macros enable conditional compilation, allowing specific sections of code to be included or excluded based on certain conditions. This is often used for handling platform-specific code, debugging statements, or feature toggles, providing flexibility in code compilation.
• Flexibility and Customization: Macros offer flexibility in defining custom functionalities tailored to specific requirements. They allow developers to create specialized code snippets that suit their needs. This level of customization can be highly beneficial in solving unique programming challenges.
• Performance Optimization: Macros can be utilized to optimize code performance by replacing function calls with inline code. This eliminates the overhead associated with function calls, resulting in faster execution and reduced runtime stack usage.
• Language Extensions: Macros provide a way to extend the C language by introducing new constructs and language-specific features. They allow programmers to add domain-specific functionality or implement advanced programming techniques not directly supported by the core language.

Disadvantages of Macros in C

• Lack of Type Checking: Macros do not undergo type-checking during compilation. This can lead to errors and unexpected behavior if the macro is used with incompatible types or expressions. Debugging such issues can be challenging as the errors may only surface at runtime.
• Difficulty in Debugging: Macros can make code harder to debug due to their inline nature. Errors or issues within macro definitions can be difficult to trace and diagnose, as the code executed may not directly correspond to the original macro invocation.
• Potential for Code Bloat: Macros can result in code duplication when used extensively throughout the program. Each macro invocation expands to the full macro definition, leading to increased code size. This can impact the overall program size and potentially reduce code maintainability.
• Limited Readability: Complex macro definitions or nested macros can make the code more cryptic and difficult to understand. Macros may introduce non-intuitive behavior and obscure the original intent of the code, making it harder for other developers to comprehend and modify.
• Scope Issues: Macros lack coping mechanisms. They operate globally, which means that their definitions can inadvertently affect other parts of the codebase. This can lead to unintended side effects and conflicts if macro names clash with other identifiers.
• Preprocessor Dependency: Macros rely on the C preprocessor, which introduces an extra step in the compilation process. This can result in longer compilation times, especially if the program extensively uses macros or includes numerous header files with complex macro definitions.
• Limited Functionality: Macros have certain limitations compared to regular functions. They cannot accept arguments by reference, have local variables, or perform complex control flow. This can restrict their usefulness in certain scenarios requiring more advanced functionality.

Conclusion
Macros in the C language offers several advantages, including code reusability, improved readability, compile-time efficiency, conditional compilation, flexibility, performance optimization, and language extension. They enable developers to create reusable code snippets and customize functionalities according to specific needs. However, macros also come with certain drawbacks, such as potential type errors, debugging difficulties, code bloat, limited readability, scope issues, preprocessor dependency, and limited functionality. It is important to use macros judiciously, considering the trade-offs and potential pitfalls associated with their usage.

FAQs related to Macros in C Language:

Q1. Can macros be used to define complex logic or perform calculations?
Macros in C is primarily used for code substitution and textual replacement. While they can handle simple calculations, they are not suitable for complex logic or extensive computations. Functions or inline functions are more appropriate for such scenarios.

Q2. Are macros specific to the C language only?
Macros are commonly associated with the C programming language due to the extensive use of the C preprocessor. However, similar mechanisms for code substitution exist in other programming languages as well, although they may have different syntax and implementation details.

Q3. Can macros be used to define recursive functions or loops?
Macros are not suitable for defining recursive functions or loops. Macros are expanded during compilation, and recursive definitions or loops can lead to infinite expansion, resulting in compilation errors or unexpected behavior.

Q4. How do macros differ from inline functions?
Macros and inline functions both aim to reduce function call overhead. However, macros operate at the textual level, performing direct code substitution, while inline functions are actual functions that can undergo type-checking and provide better encapsulation and scoping.

Q5. What are some best practices for using macros in C?
It is recommended to define macros with uppercase names to differentiate them from regular variables or functions. Additionally, macros should be self-contained and not rely on external variables. Proper documentation and comments are crucial to explain the purpose, usage, and potential caveats of macros.

Q6. Can macros be redefined or undefined within a program?
Macros can be redefined or undefined using the #define and #undef directives. However, redefining or undefining macros within the same translation unit can lead to confusion and potential errors. It is generally advisable to define macros consistently throughout the program.

Q7. Are there any tools available to analyze or debug macros in C?
There are various tools and debuggers available that can assist in the macro analysis, such as preprocessors that show the expanded form of macros, code linters that provide warnings or suggestions related to macro usage, and integrated development environments (IDEs) with built-in macro debugging capabilities.