• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Inline function

Inline function






Total Views
Views on SlideShare
Embed Views



0 Embeds 0

No embeds


Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.


11 of 1 previous next

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
Post Comment
Edit your comment

    Inline function Inline function Presentation Transcript

    •  Inline function. Workings of Inline Why need of Inline. Implementation in C++ with code example. Advantage against Macros. Where can be implemented.
    •  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.
    •  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.
    •  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.
    •  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.
    • Inline function-header{ function body}
    •  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.
    •  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 functions arguments, and then inserts the body of the function at the call site.
    •  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.
    • 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;}
    •  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
    •  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++.
    • #include<iostream.h> int main()#include<conio.h> {class samp samp k;{ clrscr(); int h; k.display(); public: cout<<"hi friends...n"; samp(){h=0;}; k.display(); void display(); getch();}; return 0;inline void samp::display(){ } cout<<h<<endl;}
    • #include<iostream.h> return 0;#include<conio.h> }void display(){ output : cout<<"nnin Inline in Inline function functionn";}int main(){ clrscr();display(); getch();
    •  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.
    •  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.
    • Some constructs may be difficult through macro, but can be done using inline function.inline double cube(double a){ return(a*a*a);}The above function invoked by statements like OUTPUT:1.cube(3.0); 272.cube(2.5+1.5); 64
    • d = cube(2.5+1.5);{ return(d*d*d);}Output: 64This result will differ in macro definitions.So, by this way also inline function is useful.
    •  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.
    •  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.
    •  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.
    •  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
    • The inline function is a special concept., which isnormally implemented in all C++ compilers and versions. Butbased on the compiler version and vendor the inlineconsideration and conformation differs. Some compilers mayaccept the function declared as inline to do inline expansion.Some compiler won’t.