Interesting Facts about Macros and Preprocessors in C
Last Updated :
10 Jan, 2025
In a C program, all lines that start with # are processed by preprocessor which is a special program invoked by the compiler. by this we mean to say that the ‘#’ symbol is used to process the functionality prior than other statements in the program, that is, which means it processes some code before run-time or say during the compile-time. In a very basic term, preprocessor takes a C program and produces another C program without any #.
The following are some interesting facts about preprocessors in C.
1) When we use includedirective, the contents of included header file (after preprocessing) are copied to the current file.
Angular brackets < and > instruct the preprocessor to look in the standard folder where all header files are held. Double quotes " and " instruct the preprocessor to look into the current folder (current directory).
2) When we use define for a constant, the preprocessor produces a C program where the defined constant is searched and matching tokens are replaced with the given expression. For example in the following program max is defined as 100.
C
#include <stdio.h>
#define max 100
int main()
{
printf("max is %d", max);
return 0;
}
3) The macros can take function like arguments, the arguments are not checked for data type. For example, the following macro INCREMENT(x) can be used for x of any data type.
C
#include <stdio.h>
#define INCREMENT(x) ++x
int main()
{
char* ptr = "GeeksQuiz";
int x = 10;
printf("%s ", INCREMENT(ptr));
printf("%d", INCREMENT(x));
return 0;
}
4) The macro arguments are not evaluated before macro expansion. For example, consider the following program
C
#include <stdio.h>
#define MULTIPLY(a, b) a* b
int main()
{
// The macro is expanded as 2 + 3 * 3 + 5, not as 5*8
printf("%d", MULTIPLY(2 + 3, 3 + 5));
return 0;
}
// Output: 16
The previous problem can be solved using following program
C
#include <stdio.h>
// here, instead of writing a*a we write (a)*(b)
#define MULTIPLY(a, b) (a) * (b)
int main()
{
// The macro is expanded as (2 + 3) * (3 + 5), as 5*8
printf("%d", MULTIPLY(2 + 3, 3 + 5));
return 0;
}
// This code is contributed by Santanu
5) The tokens passed to macros can be concatenated using operator ## called Token-Pasting operator.
C
#include <stdio.h>
#define merge(a, b) a##b
int main() { printf("%d ", merge(12, 34)); }
6) A token passed to macro can be converted to a string literal by using # before it.
C
#include <stdio.h>
#define get(a) #a
int main()
{
// GeeksQuiz is changed to "GeeksQuiz"
printf("%s", get(GeeksQuiz));
}
7) The macros can be written in multiple lines using '\'. The last line doesn't need to have '\'.
C
#include <stdio.h>
#define PRINT(i, limit) \
while (i < limit) { \
printf("GeeksQuiz "); \
i++; \
}
int main()
{
int i = 0;
PRINT(i, 3);
return 0;
}
OutputGeeksQuiz GeeksQuiz GeeksQuiz
8) The macros with arguments should be avoided as they cause problems sometimes. And Inline functions should be preferred as there is type checking parameter evaluation in inline functions. From C99 onward, inline functions are supported by C language also.
For example consider the following program. From first look the output seems to be 1, but it produces 36 as output.
C
#include <stdio.h>
#define square(x) x* x
int main()
{
// Expanded as 36/6*6
int x = 36 / square(6);
printf("%d", x);
return 0;
}
But we can write this code as follows to get the expected result i.e. 1:
C
#include <stdio.h>
#define square(x) (x * x)
int main()
{
// Expanded as 36/(6*6)
int x = 36 / square(6);
printf("%d", x);
return 0;
}
Output
1
If we use inline functions, we get the expected output. Also, the program given in point 4 above can be corrected using inline functions.
C
#include <stdio.h>
static inline int square(int x) { return x * x; }
int main()
{
int x = 36 / square(6);
printf("%d", x);
return 0;
}
9) Preprocessors also support if-else directives which are typically used for conditional compilation.
C
int main()
{
#if VERBOSE >= 2
printf("Trace Message");
#endif
}
10) A header file may be included more than one time directly or indirectly, this leads to problems of redeclaration of same variables/functions. To avoid this problem, directives like defined, ifdef and ifndef are used.
11) There are some standard macros which can be used to print program file (__FILE__), Date of compilation (__DATE__), Time of compilation (__TIME__) and Line Number in C code (__LINE__)
C
#include <stdio.h>
int main()
{
printf("Current File :%s\n", __FILE__);
printf("Current Date :%s\n", __DATE__);
printf("Current Time :%s\n", __TIME__);
printf("Line Number :%d\n", __LINE__);
return 0;
}
OutputCurrent File :/usr/share/IDE_PROGRAMS/C/other/081c548d50135ed88cfa0296159b05ca/081c548d50135ed88cfa0296159b05ca.c
Current Date :Sep 4 2019
Current Time :10:17:43
Line Number :8
12) We can remove already defined macros using :
#undef MACRO_NAME
C
#include <stdio.h>
#define LIMIT 100
int main()
{
printf("%d", LIMIT);
// removing defined macro LIMIT
#undef LIMIT
// Next line causes error as LIMIT is not defined
printf("%d", LIMIT);
return 0;
}
// This code is contributed by Santanu
Following program is executed correctly as we have declared LIMIT as an integer variable after removing previously defined macro LIMIT
C
#include <stdio.h>
#define LIMIT 1000
int main()
{
printf("%d", LIMIT);
// removing defined macro LIMIT
#undef LIMIT
// Declare LIMIT as integer again
int LIMIT = 1001;
printf("\n%d", LIMIT);
return 0;
}
Another interesting fact about macro using (#undef)
C
#include <stdio.h>
// div function prototype
float div(float, float);
#define div(x, y) x / y
int main()
{
// use of macro div
// Note: %0.2f for taking two decimal value after point
printf("%0.2f", div(10.0, 5.0));
// removing defined macro div
#undef div
// function div is called as macro definition is removed
printf("\n%0.2f", div(10.0, 5.0));
return 0;
}
// div function definition
float div(float x, float y) { return y / x; }
// This code is contributed by Santanu
You may like to take a Quiz on Macros and Preprocessors in C
Similar Reads
C Preprocessors
Preprocessors are programs that process the source code before the actual compilation begins. They are not part of the compilation process but operate separately, allowing programmers to modify the code before compilation. It is the first step that the C source code goes through when being converted
8 min read
C Preprocessor Directives
In C programming, the preprocessor is a program that process the source code before the actual compilation begins. It uses preprocessor directives are commands that instruct the preprocessor to perform specific actions. These directives start with the # symbol.List of Preprocessor DirectivesThe foll
6 min read
How a Preprocessor works in C?
Compiling a C program - Behind the Scene A Preprocessor is a system software (a computer program that is designed to run on computer's hardware and application programs). It performs preprocessing of the High Level Language(HLL). Preprocessing is the first step of the language processing system. Lan
3 min read
Header Files in C
In C programming, a header file is a file that ends with the .h extension and contains features like functions, data types, macros, etc that can be used by any other C program by including that particular header file using "#include" preprocessor.C language uses header files to provide the standard
5 min read
What’s difference between header files "stdio.h" and "stdlib.h" ?
In C programming, standard header files provide various inbuilt functionalities and two of the most commonly used standard header files are stdio.h and stdlib.h. The <stdio.h> provides Standard Input Output tools such as printf(), scanf(), etc while <stdlib.h> provides some commonly used
4 min read
How to write your own header file in C?
As we all know that files with .h extension are called header files in C. These header files generally contain function declarations which we can be used in our main C program, like for e.g. there is need to include stdio.h in our C program to use function printf() in the program. So the question ar
4 min read
Macros and its types in C
In C programming, a macro is a symbolic name or constant that represents a value, expression, or code snippet. They are defined using the #define directive, and when encountered, the preprocessor substitutes it with its defined content.ExampleC#include <stdio.h> // Macro definition #define LIM
4 min read
Interesting Facts about Macros and Preprocessors in C
In a C program, all lines that start with # are processed by preprocessor which is a special program invoked by the compiler. by this we mean to say that the ‘#’ symbol is used to process the functionality prior than other statements in the program, that is, which means it processes some code before
5 min read
# and ## Operators in C
In C, # and ## operators are preprocessor operators using in macros for token manipulation. They are known as stringizing and token pasting operators and are used in macro definition with #define preprocessor. In this article, we will learn about these operators and how to use them in C programs.Str
3 min read
How to print a variable name in C?
Printing a variable name means printing the identifier that is assigned to the variable. To print it, it should be in the form of string. This can be done by using stringification.Stringification in C is the method to convert the argument of a function like macro to a string. This can be done with t
1 min read