Inline Functions

"Much of the relative simplicity of Java is - like for most new languages - partly an illusion and partly a function of its incompleteness." - Bjarne Stroustrup

How Normal Functions Work

Normal function calls involve having a program jump to another address (the function's address) and then jump back when the function terminates.
Jumping back and forth and keep track of where to jump means that there is an overhead in elasped time to using functions.
Quote from the Waite's Group C++ Primer Plus by Stephen Prata:
"It's a bit like having to leave off reading some text to find out what a footnote says and then, upon finishing the footnote, returning to where you were reading in the text."

How Inline Functions Work

A C++ inline function is a function whose compiled code is "in line" with the other code in the program. That is, the compiler replaces the function call with the corresponding function code.
The advantage: with inline code, the program doesn't have to jump to another location to execute the code and then jump back. Inline functions thus run a little faster than regular functions.
The disadvantage: there is a memory penalty. If a program calls an inline function ten times, then the program winds up with ten copies of the function inserted in the code.
Also, the compiler doe snot have to honour your request to make a function inline. It might decide the function is too large or noteice that it calls itself (recursion is not allowed for inline functions), or the feature might not be implemented for your aprticular compiler.

Usage

Preface the function definition with the keyword inline.
Place the function definition above all functions that call it. Note that you have to place the entire definition (meaning the function header and all the function code), not just the prototype, above the other functions.

Inline Versus Macros

The inline facility is a C++ addition. C uses the preprocessor #define statement to prove macros, a crude implementation of inline code. For instance, here's a macro for squaring a number:
```
          #define SQUARE(X) X*X
```
This works not by passing arguments but by text substitution, with the X acting as a symbolic label for the "argument".
```
          a = SQUARE(5.0); is repalced by a = 5.0*5.0;
          b = SQUARE(4.5 + 7.5); is replaced by b = 4.5 + 7.5 * 4.5 + &.5;
          d = SQUARE(C++); is replaced by d = c++ * c++;
```
Only the first example works properly. You can improve matters with a liberal application of parentheses:
```
          #define SQUARE(X) ((X)*(X))
```
Still, the problem remains that macros don't pass by value. Even with this new definition, SQUARE(C++) increments C twice.