C++ Functions
Think of functions as agents: they sense, think and act.

By convention, any functions that you declare and define should be named with a lower-case initial letter.

Functions are the jobs you need to coordinate in order to get a larger project done. As a programmer, think of yourself as the manager of an enterprise, the general of an army or the director of a movie. We'll pursue the cinematic metaphor. Imagine yourself as the director of a movie. You are in charge of everyone. You coordinate the work of the actors, cameramen, focus pullers, extras, carpenters, electricians, set decorators, prop handlers and sound recorders. Each has a job to do, and each may delegate smaller jobs to those beneath them. But you are in command of the big picture. It is your job to decide what is to be done, how to do it and who to assign to each task.

When you write an application, you are the director of a complex set of functions, your agents to whom you have assigned these specific tasks. Think of C++ functions as your agents. It is up to you to specify what each wil do and how. As as the creator and programmer of an artificial world, it is your responsibility to identify the jobs that need to be done, to describe each job or process as a C++ function, and to organize these functions and their relationships to one another in order to accomplish the task at hand. Think of your application as an organized group of functions; think of it as the social organization of your crew of employees:

• Each one has a name (functionName).
• Each one has one or more jobs to do (the body of the function).
• Each one may, or may not, when it is called, receive further data to help it do its job (its parameters).
• Each may, or may not, reply directly to whoever called it (its returnValue).

For further flexibility, any function, may call any other function, just as any crew member may call upon another for assistance. You must organize all of this. You must describe the "chain of command:"

The Director calls, "Lights 3." (A function call with one parameter and one return value.)

• The lighting person throws the switch on one flood and two spots, and reports back when this is done.

The Director calls, "Camera 2, 5." (A function call with two parameters and one return value.)

• Cameraman 2 starts his camera rolling...
• Cameraman 5 starts his camer rolling...
• They respond that they have done so...

The Director calls, "Action." (A function call with no parameters and no return value.)

• The actors begin to follow their scripts, the key grip pushes the camerman in his dolly along the track, the sound person moves her microphones overhead...
• And each person cues others to begin their jobs: extras swarm around the lead actors, assistants keep the cables from tangling, the continuity person takes notes...
• No one responds directly to the Director...
  

These calls to action are called function calls in programming.

A function may accept parameters, do something in its body, and directly return only one value.
However, it may also change the values of any number of global variables and the properties of any number of components.

// An abstract description of a function:
returnType functionName (parameters) {
   // do this (the function body)
   return returnValue;
}

It might be helpful to think of a function as an agent with a name, who can sense, think, and act:

// Thinking of a function as an agent:
reply functionName (instructions) {
   // do something (thought and action)
   return reply;
}

// Thinking of a function as a black box:
(output) functionName (inputs) {
   // do something (action and output)
   return returnValue;
}

In summary:

• Each function has a name you call it by (i.e. its functionName).
• You can give it additional data when you call if you wish to do so (i.e. its parameters).
• It will do its job.
• You can wait for it to report on what it's done (i.e. its returnValue) or simply assume that it has done its job.

To indicate that the function expects no parameters and returns no returnValue, we insert the word void where the parameters would otherwise be.

// Ready to shoot!

void shooTheScene (void) {
   quietOnTheSet();
   lights();
   camera();
   action();
}

To call it we simply yell:

shootTheScene();

To indicate that the function returns a returnValue but expects no parameters, we insert the data type
of the returnValue before the function name and the word void where the parameters would otherwise be.

// Is there enough film in the camera?
int howMuchFilmIsLeft (void) {
   int feetLeft = 1000 - feetUsed;
   return feetLeft;
}

Since the function has an integer return value, we can use the function call itself as a variable in another statement:
The function call will be replaced by its return value, the number of feet that are left.

if(howMuchFilmIsLeft() < 50) reloadTheCamera();

In other words, if there are less than 50 feet of film left, tell the cameraman to reload.

To indicate that the function expects no returnValue but does take parameters, we insert the word void
where the returnValue would otherwise be and data types and variable names of the parameters .

// On to the next scene!
void prepareForNextScene (int act, int scene) {
   intScriptPage = act * 10 + scene;
   placesEveryone();
}

To call it we may simply say:

prepareForNextScene(3, 4);

To indicate that the function expects one boolian (true or false) returnValue and two parameters, we insert the data type
of the returnValue bool and data types and variables int of the two parameters .

// Get the actors on stage!
bool actorsToYourMarks (int femaleLead, int maleLead) {
   while (femaleLead == notReady) {rehearse()};
   while (maleLead == notReady) {rehearse()};
   bool allReady = true;
   return allReady;
}

Since the function has a boolean returnValue, we can use the function call itself as a variable in a larger statement:
The function call will be replaced by its return value, and we can call action().

if(actorsToYourMarks(11, 27)) action();

In other words, as long as the male and female leads are not ready, they should rehearse.
When they are ready, we will call for action.