Inline functions & macros
Download as PPTX, PDF2 likes1,780 views
Inline functions allow function code to be expanded at the point of call at compile time for improved performance. They are declared with the "inline" keyword and behave like regular functions but with type checking and argument evaluation. Macros are preprocessor directives that perform simple textual substitution and lack type checking, so they are more error prone than inline functions. The key differences between inline functions and macros are that inline functions are parsed by the compiler while macros are expanded by the preprocessor, and inline functions support features like debugging that macros do not.
Inline functions & macros
- 1. INLINE FUNCTIONS & MACROS Designed by, Anand K
- 2. InlineFunctions Similar to Macros Function code is expanded at the point of function call at compile time. Parsed by the compiler. Inline functions follow all the protocols of type safety enforced on normal functions. Expressions passed as arguments to inline functions are evaluated once.
- 3. InlineFunctions It is declared by using keyword “inline” before the function prototype. Argument types are checked and necessary conversions are performed correctly. The compiler performs return type checking, function signature before putting inline functions into the symbol table. They can be overloaded to perform the right kind of operation for the right kind of data.
- 4. InlineFunctions Can be used for debugging a program as they are expanded at compile time and a break point can be placed at the inline function definition. We can do step by step debugging. Inline functions can access class’s member data. Inline functions may or may not be expanded by the compiler. It can be defined inside or outside the class. Inline functions pass arguments by value., just like regular functions.
- 5. InlinefunctionsVsRegularfunctions The difference between an inline function and a regular function is that whenever the compiler finds a call to an inline function, it writes a copy of the compiled function definition. With a regular function, a normal function call is generated. Inline functions looks like regular functions.
- 6. Macros Preprocessor directive provided by C. Declared by #define. Macros are expanded by preprocessor at precompile time. Expressions passed are arguments are evaluated more than once. Good for declaring constants. Provide textual substitution. Each time the macro name is encountered with arguments, the arguments used in its definition are replaced by the actual arguments found.
- 7. Macros Macros are more error prone as compared to inline functions. The parameters are not typed. The macro works for any objects of arithmetic type. No error checking is done during compilation. e.g.. You can pass strings to a macro that does some integer arithmetic. Cannot be used for debugging as they are expanded at pre-compile time.
- 8. Macros The preprocessor has no permission to access member data of a class and are thus useless even if used within a class. Thus they cannot even be used as member functions. Macros are always expanded. It cannot be defined inside the class. Macros don’t pass by value. Expressions passed into macros are not always evaluated before entering the macro body.
- 9. Macros Expressions may expand inside the macro so that their evaluation precedence is different from what you expect. C++ preprocessor implements macros by using simple textual replacements.
- 10. DifferencebetweenMacrosandInline functions Inline functions take defined type arguments whereas Macros can take any type as arguments. Macros are expanded by the preprocessor and then compilation takes place. Macros are expanded by C preprocessor. Inline functions are parsed by the compiler. The program size increases with both macros and inline functions.
- 11. Samplecode.Copyandpasteit in any C/C++ Editortoseeresults. #include<stdio.h> #define SUM(x) x*x #define SUM1(x) (x)*(x) #define SUM2(x) x++ * x++ #define SUM3(x) (x++)*(x++) #define toupper(a) ((a) >= 'a' && ((a) <= 'z')?((a)-('a'-'A')):(a)) #define max(c,d) (c>d?c:d) #define max1(a,b) ((a<b)?b:a) int main() { int y=3; int z=10; char ch; int f=1,e=2; printf("rnhello world!"); printf("rn%d",y); int j= SUM(y); printf("rn%d",j); printf("rn");
- 12. printf("rn%d",y); int k= SUM1(y); printf("rn%d",k); printf("rn"); printf("rn%d",y); int i= SUM(++y); printf("rn%d",i); printf("rn"); printf("rn%d",y); int a= SUM(y++); printf("rn%d",a); printf("rn"); printf("rn%d",y); int l= SUM2(y); printf("rn%d",l); printf("rn"); printf("rn%d",y); int m= SUM3(y); printf("rn%d",m); printf("rn");
- 13. int g=max(f++,e++); printf("rn%d,%drn",f,e); printf("rnMax of 10 and 30 isrn"); int h=max1(41,40); printf("rn%drn",h); printf("rnEnter a character:rn"); ch=toupper(getc(stdin)); printf("rn%c",ch); getch(); return 0; }