I left out one item of interest. That thing is the inline function. Inline functions are not extremely significant, but it is excellent to know them. The crucial idea is to save time at a cost in space. Inline functions are a lot like a placeholder. One time you classify an inline function, by means of the 'inline' keyword, when you call that function the compiler will restore the function call with the definite code from the function.

How does this build the program go quicker? Simple, function calls are basically more time overwhelming than writing all of the code with no functions. To go throughout your program as well as restore a function you have used 100 times with the code from the function would be time consuming not too brilliant. Obviously, by means of the inline function to restore the function calls with code you will also significantly augment the size of your program.

With the help of inline keyword is easy, presently set it before the given name of a function. And after that, when you make use of that function, act as if it is a non-inline function.

For example:

Code:
#include <iostream>

using namespace std;

inline void hello()
{ 
  cout<<"hello";
}
int main()
{
  hello(); //Call it like a normal function...
  cin.get();
}
But, once the program is compiled, the call to hello(); will be replaced by the code building up the function.

A WORD OF WARNING: Inline functions are extremely excellent for saving time, but if you make use of them too regularly or else with huge functions you will have an extremely large program. Sometimes huge programs are in fact less well-organized, plus as a result they will run more gradually than before. Inline functions are best for small functions that are called often.

At last, note down that the compiler might select, in its infinite wisdom, to overlook your effort to inline a function. So if you do make a mistake and inline a moster fifty-line function that gets called thousands of times, the compiler might take no notice of you.