Inline function

1. Inline Function

2. Discussion about… Inline function. Workings of Inline Why need of Inline. Implementation in C++ with code example. Advantage against Macros. Where can be implemented.

3. What is the use of function What is the use of function It is used to reduce the save the memory space when a function is likely to be called many times.

4. Disadvantages of using function Every time a function is called, it take a lot of extra time in executing a series of instructions. In the following ways of execution it takes more time 1. Jumping to the function 2.Saving in Register. 3.Pushing arguments into the stack. 4.Returning to the calling function.

5. Introduction Inline functions can be implemented using the keyword inline . The inline is a request to the compiler. The function always can not be inline by the compiler The complicated functions will not be inline. Just like a macro, but different from macro.

6. C++ proposes a new feature called inline functions. By using this we can eliminate the cost of calls to small functions. An inline function is a function that in expanded in line when it is invoked. Inline function must be defined before they are called. Inline keyword sends a request, not a command to the compiler.

7. SYNTAX Inline function-header { function body }

8. Workings of Inline The inline function is just a code replacement instead of the function call. There is a need of stack storage and other special mechanism for function call and return. The stack storage is used to store the return value and return address for function call and return process. And while passing the parameter the stack storage needed to store the parameter values, and from the stack area the values moved to data area.

9. While using the inline function, there is no need of these operations, because of code replacement. The compiler can do inline on either a high-level intermediate representation or a low-level intermediate representation. In either case, the compiler simply computes the arguments, stores them in variables corresponding to the function's arguments, and then inserts the body of the function at the call site.

10. Need of Inline F unction In an application, if the time complexity is to be reduced means the inline function can be used. The overhead of calling and returning from the function, parameter manipulation (push/ pop) are reduced. Increases locality of references by utilizing instruction cache. After inline the compiler may perform the optimization of the code by boycott the dead codes. i.e., the unused code lines that will always get true or false or not performing any modification in execution.

11. Example: int pred ( int x) { if (x == 0) return 0; else return x - 1; } Before inline int f( int y) { return pred (y) + pred (0) + pred (y+1); } After inline int f( int y) { int temp = 0; if (y == 0) temp += 0; else temp += y - 1; /*1*/ if (0 == 0) temp += 0; else temp += 0 - 1; /*2*/ if (y+1 == 0) temp += 0; else temp += (y + 1) - 1; /*3*/ return temp; }

12. The temp += 0 statements in the lines marked (1), (2) and (3) do nothing. The compiler can remove them. The condition 0 == 0 is always true, so the compiler can replace the line marked (2) with the consequent, temp += 0 (which does nothing). The compiler can rewrite the condition y+1 == 0 to y == -1. The compiler can reduce the expression (y + 1) - 1 to y (assuming wraparound overflow semantics) The expressions y and y+1 cannot both equal zero. This lets the compiler eliminate one test. These are all the actions the compiler may do for the better resulting of the inline function implementation

13. Implementation in C++ In C++ the function can be inline using the keyword ‘inline’. The member function of a class and the global functions are also possible to declare as inline. The compiler may or may not make the function as an inline we requested. It is up to the compiler. The advanced provisions made in Visual C++ to make a function as inline. The pragmas implemented. The recursive functions also may be implemented as inline in VC++.

14. Code example in c++ #include< iostream.h > #include< conio.h > class samp { int h; public: samp (){h=0;}; void display(); }; inline void samp ::display() { cout <<h<< endl ; } int main() { samp k; clrscr (); k.display (); cout <<"hi friends...\n"; k.display (); getch (); return 0; }

15. The global function as Inline #include< iostream.h > #include< conio.h > void display() { cout <<"\n\ nin Inline function\n"; } int main() { clrscr (); display(); getch (); return 0; } output : in Inline function

16. Advantage against MACRO Macro invocations do not perform type checking, or even check that arguments are well-formed, whereas function calls usually do. Macro can not return any value where the function return. Some constructs may be difficult through macro, but can be done using inline function. Error correction in function is somewhat easier than Macro. Many compilers can also inline expand some recursive functions; recursive macros are typically illegal.

17. Many compilers can also inline expand some recursive functions; recursive macros are typically illegal. Major drawback is macros are not Functions Usual error checking does not occur during compilation .

18. Some constructs may be difficult through macro, but can be done using inline function. EXAMPLE inline double cube(double a) { return(a*a*a); } The above function invoked by statements like OUTPUT: 1.cube(3.0); 27 2.cube(2.5+1.5); 64

19. How inline function differ from macros d = cube(2.5+1.5); { return(d*d*d); } Output: 64 This result will differ in macro definitions. So, by this way also inline function is useful.

20. Restrictions…. The inline function must be simple and small. If the code size is too large, some compiler will not treat that as inline function. The inline expansion can not be recognized by the programmer. If the function is not treated as inline, then it will take care of compiler as normal function .

21. When it not work In the following situation inline expansion may not work: 1.For function returning values, if a loop, a switch or goto exists. 2.For function not returning values, if a return statement exists. 3.If function contains static variables. 4.If inline function are recursive.

22. Implementation Can be ???? Wherever the execution time is need to reduce, there the inline function can be implemented. But the one thing is the memory consumption for storing the file may be increased. For example, assume while writing Operating system the inline function may be used to reduce the execution time. The simple and small code can be inline. And in mobile application , the memory available is more than enough. But application response time is a criteria means we can use inline function.

23. When Inline is need to be avoid.. Whenever the memory consumption is a constraint then inline will not be applied there as a solution., because inline will paste the code then and there, where the function call. For some embedded applications, the execution time can be extended, but memory is restricted . If the function is larger size, the speed benefits of inline function will reduce. Sometimes the overhead of the function call becomes small compared to execution of the function. On that time the benefits of inline function may be lost

24. Conclusion The inline function is a special concept., which is normally implemented in all C++ compilers and versions. But based on the compiler version and vendor the inline consideration and conformation differs. Some compilers may accept the function declared as inline to do inline expansion. Some compiler won’t.

25. Thank you……!!!!!