inline function

25
Inline Function

Upload: techmx

Post on 28-Oct-2014

217 views

Category:

Documents


6 download

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 function's 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; if (0 == 0) temp += 0; else temp += 0 - 1; if (y+1 == 0) temp += 0; else temp += (y + 1) - 1; return temp; }

/*1*/ /*2*/ /*3*/

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 #include class samp { int h; public: samp(){h=0;}; void display(); }; inline void samp::display() { cout