Lesson 4: Loops
Now that you should have learned
about variables, loops, and if statements it is time to learn about functions. You should
have an idea of their uses. Cout is an example of a function. In general, functions
perform a number of pre-defined commands to accomplish something productive.
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
Do not think that a will change at random, 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.
Lets look at an example program:
#include <iostream.h>
int mult(int x, int y);
int main()
{
int x, y;
cout<<"Please input two numbers to be multiplied: ";
cin>>x>>y;
cout<<"The product of your two numbers is "<<mult(x, y);
return 0;
}
int mult(int x, int y)
{
return x*y;
}
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.