Macro Expansion in C
Macro Expansion
Macro expansion in C is the process of replacing a macro with its corresponding value or code snippet in the source code during the preprocessing phase.
Macros are defined using the
#define
directive, which allows a programmer to define a sequence of code or a value as a macro name.During macro expansion, the preprocessor reads the source code and looks for instances of the macro name.
When a macro name is found, the preprocessor replaces it with the corresponding value or code snippet defined in the macro definition.
The result is a modified source code that can be compiled or interpreted by the computer.
Syntax of Macro Expansion
The syntax of macro expansion in C programming language is as follows:
#define macro_name value
Explanation:
In this syntax,
macro_name
is the name of the macro being defined, andvalue
is the value or code snippet associated with the macro.The
#define
directive is used to define the macro, which is then expanded during the preprocessing phase of the compilation process.
Types of Macros
In C, there are two main types of macros:
- object-like macros
- function-like macros.
Object-like Macros
Object-like macros are simple text substitutions that replace an identifier with a specified value.
The syntax for defining an object-like macro is as follows:
#define macro_name value
- Following macro definition creates an object-like macro called
MAX
that represents the maximum value of two numbers:
#define MAX(a, b) ((a) > (b) ? (a) : (b))
- When used in code, this macro expands to the maximum value of two numbers:
int x = 5;
int y = 7;
int max_value = MAX(x, y); // max_value will be 7
Function-like Macros
- Function-like macros are more complex than object-like macros and can take arguments.
The syntax for defining a function-like macro is as follows:
#define macro_name(argument_list) replacement_text
- Following macro definition creates a function-like macro called
SQUARE
that calculates the square of a number:
#define SQUARE(x) ((x)*(x))
- When used in code, this macro expands to the square of a number:
int x = 5;
int square_value = SQUARE(x); // square_value will be 25
Example of Macro Expansion
#include <stdio.h>
#define PI 3.14159
#define SQUARE(x) ((x)*(x))
int main() {
double radius = 5.0;
double area = PI * SQUARE(radius);
printf("The area of the circle is %f\n", area);
return 0;
}
Explanation:
The
#define
directive is used to define two macros:PI
andSQUARE
. ThePI
macro is defined as the value of pi, and theSQUARE
macro is defined as a code snippet that squares its argument.During macro expansion, the preprocessor replaces
PI
with the value3.14159
andSQUARE(radius)
with((radius)*(radius))
.The resulting code will look as below:
#include <stdio.h>
int main() {
double radius = 5.0;
double area = 3.14159 * ((radius)*(radius));
printf("The area of the circle is %f\n", area);
return 0;
}
As you can see, the
PI
macro has been replaced with its corresponding value of3.14159
, and theSQUARE
macro has been replaced with its corresponding code snippet((radius)*(radius))
.This results in a modified source code that can be compiled and executed by the computer.