The document discusses inline functions in C++. Inline functions allow code from a function to be pasted directly into the call site rather than executing a function call. This avoids overhead from calling and returning from functions. Good candidates for inline are small, simple functions called frequently. The document provides an example of a function defined with the inline keyword and the optimizations a compiler may perform after inlining. It also compares inline functions to macros and discusses where inline functions are best used.

2.  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
It is used to reduce the save the memory space when a
function is likely to be called many times.

4.  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.  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. Inline function-header

{
function body
}

8.  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.  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.  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. #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;
}

15. #include<iostream.h> return 0;
#include<conio.h> }
void display()
{ output :
cout<<"nnin Inline in Inline function
functionn";
}
int main()
{
clrscr();
display();
getch();

16.  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.
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. 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.  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.  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.  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.  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. 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.