lesson13.txt

C++ is a programming language. It is a programming language of many different dialects, just like

								Lesson 13: More on Functions
				
	The reason I have placed this tutorial at the end of the list, rather than as an addition to 
my other lesson is simple, I don't want people who already read that tutorial to miss this!

	In lesson 4 you were given the basic information on tutorials.  However, I left out two items
of interest.  First, when you declare a function you don't have to prototype it!  However, you must
give the function definition physically before you call the function.  You simply type in the entire
definition of the function where you would normally put the prototype.  

For example:

#include <iostream.h>

void function(void)  //Normally this would be the prototype.  Don't forget to exclude the semicolon
					//Only prototypes have semicolons
{
  cout<<"HA!  NO PROTOTYPE!";
}

void main()
{
  function(); //It works like a normal function now.
}


The other programming concept is the inline function.  Inline functions are not very important,
but it is good to understand them.  The basic idea is to save time at a cost in space.  
	
	How does an inline function make the program go faster?  How does it make the program larger?
Does this remind you of relativity?  Inline functions are really a lot like a placeholder.  Once
you define an inline function,using the 'inline' keyword, whenever you call that function the 
compiler will replace the function call with the actual code from the function.  How does this 
make the program go faster?  Simple, function calls are simply more time consuming than writing 
all of the code without functions.  However, to go through your program and replace a function
you have used 100 times with the code from the function would be time consuming.  Of course, by
using the inline function to replace the function calls with code you will also greatly increase
the size of your program.  
	
	Using the inline keyword is simple, just put it before the name of a function.  Then, when
you use that function, just pretend it is a non-inline function.  For example:

#include <iostream.h>

inline void hello(void) //Just use the inline keyword before the function 
{					    //Note that this is a non-prototyed function
  cout<<"hello";
}

void main()
{
  hello();   //Call it like a normal function...
}

	However, once the program is compiled, the call to hello(); will be replaced by the code 
making up the function.  

	A WORD OF WARNING: Inline functions are very good for saving time, but if you use them too often
or with large functions  you will have a tremendously large program.  Sometimes large programs are
actually less efficient, and therefore they will run slower than before.  Inline functions are best
for small functions that are called often.  

	In the future we will discuss inline functions in terms of C++ classes.  However, now that 
you understand the concept I will feel comfortable using inline functions in later tutorials.  
At this point I do not wish to add something about classes that individuals could easily miss if
they did not realize that the information was in the tutorial.

Note: My homepage is http://www.cprogramming.com.  My email is [e-mail].  Please
email me with comments and or suggestions.  If you want to use this on your own site please
email me and add a link to http://www.cprogramming.com.  Thanks :)