Functions that a
programmer writes will generally require a prototype. Just like an blueprint, the prototype tells the compiler what the function will return, what the function will be called, as well as what
arguments the function can be passed. When I say that the function returns a value, I mean that the function can be used in the same manner as a variable would be. For example, a variable can be set equal to a function that returns a value between zero and four.
For example:
int a;
a=random(5); //random is sometimes defined by the compiler
//Yes, it returns between 0 and the argument minus 1
The value of will be changed as follows: , it will be set to the value returned when the function
is called, but it
will not change again.
The general format
for a prototype is simple:
return-type function_name(arg_type arg);
There can be more than one argument
passed to a function, and it does not have to return a value. Lets
look at a function prototype:
int mult(int x, int y);
This prototype specifies that the function mult will accept two arguments, both integers, and that it will return an integer. Do not forget the trailing semi-colon. Without it, the compiler will probably think that you are trying to write the actual definition of the
function.
When the
programmer actually defines the function, it will begin with the prototype, minus the semi-colon. Then there should always be a bracket (remember, functions require brackets around them) followed by code, just as you would write it for the main function. Finally, end it all with a cherry and a bracket. Okay, maybe not a cherry.
COMMENT TO EXAMPLE.
This program begins
with the only necessary include file. It is followed by the prototye of the function. Notice that it has the final semi-colon! The main function is an integer, which you should always have, to conform to the standard. You should not have trouble understanding the input and output functions. It is fine to use cin to input to variables as the program does.
Notice how cout actually outputs what
appears to be the mult function. What is really happening is
that mult acts as a variable. Because it returns
a value it is possible for the cout function to output the
return value.
The mult
function is actually defined below main. Due to its prototype being above main, the compiler still recognizes it as being defined, and so the compiler will not give an error about mult being undefined, although the definition is below where it is used.
Return is the keyword used to force the
function to return a value. Note that it is possible to have a
function that returns no value. In that case, the
prototype would have a return type of void.
The most important functional (Pun
semi-intended) question is why. Functions have many
uses. For example, a programmer may have a block of code
that he has repeated forty times throughout the program. A
function to execute that code would save a great deal of space, and it would also make the program more readable.
Another reason for functions is to break
down a complex program into something manageable. For example,
take a menu program that runs complex code when a menu choice
is selected. The program would probably best be served by
making functions for each of the actual menu choices, and then
breaking down the complex tasks into smaller, more
manageable takes, which could be in their own
functions. In this way, a program can be designed that makes sense when read.