This is our first lesson on functions, functions are 
extremely important in programming in C++
This is not a topic that you can get away from.
You will always be writing functions  or this class, 
in any case, from here on out
So I want to begin by giving you motivation for
why we have functions, So take a look at this 
example here.
Look at this main program the lines of code are 
function calls. See how the is reads, it reads very 
easily
                         display_greetings(),                          
gather_data().
calculate(); output(); sign_off();
return 0;
What we're doing in each one of these 
statements is redirecting the execution to other 
blocks of code that reside someplace else 
We've created an outline for our program.
Ok, so the motivations (To learn functions): 
Functions help you to organize your code; break 
larger project down into smaller pieces.
It allows groups of coders to work on one
large program.
Also, It allows you to reuse code, for instance you 
are a block of code to calculate square root,
and you need to calculate the square root in 
many different places. So, you write the code 
once and then, 
redirect the execution of the program to that block 
of code, numerous times, with a function call.
Lastly, it allows you to carry code of from one 
project another very easily. So let's start by 
looking at the format of a function. 
This first line here is what we call the function 
header. I always think of a function header as 
having three things as it does.
A return type, A function name. And then a formal 
parameter list.
The formal parameter list can be empty.
That means that you send nothing to the function, 
it expects nothing to be sent to it. The parameters 
are variables that are declared local,
to the function and they're going to be (filled) with 
values that you passed to the function. 
The return type is the type of value that is 
returned or sent back to the calling function.
Which for now we will just think of as being Main. 
In the function body you have: local variable 
declarations,
you have statements, and then you have a return 
statement that returns the value of the return 
type. Whatever this return type is,
you will send back a valued that will fill it.
Ok, does this look familiar? Well it should. 
This is exactly what you do when your write a 
"Main" program.
We have actually written functions already. The 
return type "int" the name "main"
The formal parameter list in this case is empty. 
local variables, here we have our character, our 
statements, a "do while" loop
"return 0", Zero is the
value of the return type in this case an "int".
'Main' is just another function.
Main is the one function every program must 
have
Ok, I am going to go through several examples 
here and I am going to start with very simple one.
I am going to look at three aspects of functions. 
They include: The declaration of a function, right 
here. 
This is the prototype I am declaring the function. 
The call of the function, the invocation function,
and Lastly the definition. 
Prototypes go before main, definitions after "Main" 
and of course the call or the invocation the 
function would happen in "Main"
and can be done in other functions.
Ok, this is a very simple function returns nothing
you send it nothing. You send no information to 
the function, it returns nothing back and you might 
be thinking "What in the world does it do?" 
In this case all is does is it outputs something to 
the screen so again the prototype,
the definition, and the call.
 when the compiler comes through it will compile 
this line, it'll put that function on the function table. 
we can to think perhaps it's easier to think it.
as a list of declarations of functions the compiler 
will refer back to it.
So, it gets to "Main" and here is a function call. 
How does it know that it is a function call? It reads 
"greeting();" thinking possibly that is a  variable 
but when it hits this "()" it knows it has a function 
call. It looks to see that there's nothing being 
passed it so it looks its function table,
 for a function called greetings, that has nothing 
pasted to or has no parmeters.
