In this lesson, we'll talk about inlining functions. 
So, what is an inline function? Any function can 
be inline.
What it is, is the suggestion to the compiler to 
expand the definition of the function itself where 
the function is called.
And we have three functions here declared, in 
this example.
One of them is an inline function. You can see 
that the key word inline is used,
to tell the compiler, "Hey, consider inlining this 
function."
Not only that, the definition is provided right here,
in the, along with the prototype. This could be in a 
header file,
it could be here above main, but what you're 
suggesting to the compiler, is that, that code 
could be inserted
right there where the function is called. So, what's 
the payoff here? Well, the payoff is that
time is saved in the execution of this function. 
That is,
the referencing of function pointers and the other 
overhead costs of calling a function are,
they are gotten around. So, why would you wanna 
do such a thing?
Well, you only one to do it with a relatively small 
function.
It reduces the overhead of the function call, and 
you should consider that if the function only going 
to be called once or twice or even 1000 times the
savings of speed up is very small and it's 
probably not worth worrying about.
I like to think about inlining a function, only if the 
function
again is small, and it's possibly going to be called 
many many many times.
Millions of times, perhaps.
You should try a little experiment. Write a baby 
program, where you write a very very small
function not inline it and then inline it, and in both 
cases
time the speed of the function execution and see 
what you get. But, you are going to have to run 
that function
many millions of times, but inside a "for" loop,
and see what you come up with. And that's 
inlining a function. We will also put function 
definitions
in the header files or with prototypes when we talk 
about
object oriented programming. I tend to call that 
inlining a function.
So, we'll talk about that later also.
