While main() is a function, it is an unusual one. Typical functions are
called, or invoked, during the course of your program. A program is executed
line by line in the order it appears in your source code, until a function is
reached. Then the program branches off to execute the function. When the
function finishes, it returns control to the line of code immediately following
the call to the function.

A good analogy for this is sharpening your pencil. If you are drawing a
picture, and your pencil breaks, you might stop drawing, go sharpen the pencil,
and then return to what you were doing. When a program needs a service
performed, it can call a function to perform the service and then pick up where
it left off when the function is finished running. Listing below demonstrates
this idea.

The function DemonstrationFunction() is defined on lines 5-7. When it is
called, it prints a message to the screen and then returns.

Line 13 is the beginning of the actual program. On line 15, main() prints out
a message saying it is in main(). After printing the message, line 16 calls
DemonstrationFunction(). This call causes the commands in DemonstrationFunction()
to execute. In this case, the entire function consists of the code on line 7,
which prints another message. When DemonstrationFunction() completes (line 8),
it returns back to where it was called from. In this case the program returns to
line 17, where main() prints its final line.

Using Functions

Functions either return a value or they return void, meaning they return
nothing. A function that adds two integers might return the sum, and thus would
be defined to return an integer value. A function that just prints a message has
nothing to return and would be declared to return void.

Functions consist of a header and a body. The header consists, in turn, of
the return type, the function name, and the parameters to that function. The
parameters to a function allow values to be passed into the function. Thus, if
the function were to add two numbers, the numbers would be the parameters to the
function. Here's a typical function header:

int Sum(int a, int b)

A parameter is a declaration of what type of value will be passed in; the
actual value passed in by the calling function is called the argument. Many
programmers use these two terms, parameters and arguments, as synonyms. Others
are careful about the technical distinction. This book will use the terms
interchangeably.

The body of a function consists of an opening brace, zero or more statements,
and a closing brace. The statements constitute the work of the function. A
function may return a value, using a return statement. This statement will also
cause the function to exit. If you don't put a return statement into your
function, it will automatically return void at the end of the function. The
value returned must be of the type declared in the function header.

Listing below demonstrates a function that takes two integer parameters and
returns an integer value.

The function Add() is defined on line 2. It takes two integer parameters and
returns an integer value. The program itself begins on line 9 and on line 11,
where it prints a message. The program prompts the user for two numbers (lines
13 to 15). The user types each number, separated by a space, and then presses
the Enter key. main() passes the two numbers typed in by the user as arguments
to the Add() function on line 17.

Processing branches to the Add() function, which starts on line 2. The
parameters a and b are printed and then added together. The result is returned
on line 6, and the function returns.

In lines 14 and 15, the cin object is used to obtain a number for the
variables a and b, and cout is used to write the values to the screen. Variables
and other aspects of this program are explored in depth in the next few days.