Macros vs Functions - GeeksforGeeks

19 Oct, 2021
A macro is a name given to a block of C statements as a pre-processor directive. Being a pre-processor, the block of code is communicated to the compiler before entering into the actual coding (main () function). A macro is defined with the pre-processor directive. Macros are pre-processed which means that all the macros would be processed before your program compiles. However, functions are not preprocessed but compiled.
See the following example of Macro:
C
C++
#include<stdio.h>#define NUMBER 10int main(){     printf("%d", NUMBER);     return 0;}
#include<iostream>#define NUMBER 10using namespace std;int main(){     cout<<NUMBER;     return 0;}//This code is contributed by Mayank Tyagi
Output: 
10
See the following example of Function:
C
C++
#include<stdio.h>int number(){    return 10;}int main(){    printf("%d", number());    return 0;}
#include<iostream>using namespace std;int number(){    return 10;}int main(){    cout<<number();    return 0;}//This code is contributed by Mayank Tyagi
Output: 
10
Now compile them using the command: 
gcc –E file_name.c
This will give you the executable code as shown in the figure: 
This shows that the macros are preprocessed while functions are not.In macros, no type checking(incompatible operand, etc.) is done and thus use of macros can lead to errors/side-effects in some cases. However, this is not the case with functions. Also, macros do not check for compilation error (if any). Consider the following two codes:
Macros:  
C
#include<stdio.h>#define CUBE(b) b*b*bint main(){     printf("%d", CUBE(1+2));     return 0;}
Output: Unexpected output 
7
Note: This macro is expanded as below
CUBE(1+2)  === 1+2*1+2*1+2 which is equal to 7 [correct but unexpected result depending upon the execution of the mathematical operators]
To fix this we need to replace #define CUBE(b) b*b*b as #define CUBE(b) (b)*(b)*(b). With updated macro, CUBE(1+2) will be expanded as 
CUBE(1+2)  === (1+2)*(1+2)*(1+2) which is equal to 27 [correct and expected result]
Functions:
C
#include<stdio.h>int cube(int a){     return a*a*a;}int main(){    printf("%d", cube(1+2));    return 0;}
Output: As expected 
27
Macros are usually one liner. However, they can consist of more than one line, Click here to see the usage. There are no such constraints in functions.
The speed at which macros and functions differs. Macros are typically faster than functions as they don’t involve actual function call overhead.
Conclusion: Macros are no longer recommended as they cause following issues. There is a better way in modern compilers that is inline functions and const variable. Below are disadvantages of macros:a) There is no type checkingb) Difficult to debug as they cause simple replacement.c) Macro don’t have namespace, so a macro in one section of code can affect other section.d) Macros can cause side effects as shown in above CUBE() example.
See following for more details on macros: Interesting facts about Macros and Preprocessors  This article is contributed by Pranjal Mathur. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
RishabhPrabhu
iamsamyak
mayanktyagi1709
klynsaha
shubhamsoni191
rvnay4phri4nwp6gvt8c3lz6yl3gaonp6z7f0tdp
CPP-Functions
cpp-macros
C Language
C++
CPP
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
rand() and srand() in C/C++
fork() in C
Command line arguments in C/C++
Substring in C++
Function Pointer in C
Vector in C++ STL
Initialize a vector in C++ (6 different ways)
Map in C++ Standard Template Library (STL)
Inheritance in C++
Constructors in C++