FUNCTIONS

A function is a section of program code that

performs a particular task. Making functions is
a way of isolating one section of code from
other independent sections. Functions allow a
programmer to separate code by its purpose,
and make a section of code reusable — that is,
make it so the section can be called in many
different contexts.
Functions should be written in the following
form:
type function name (type parameter1 name,
type parameter2 name, ...)
{
variable declarations
statements
A function can have a number of parameters, or
pieces of information from outside, and the
function’s body consists of a number of
declarations and statements,enclosed by curly
brackets: ‘{...}’.
Function names
Every function has a name by which it is known to
the rest of the program. The name of a function in
C can be anything from a single letter to a long
word. A function name must begin with an
alphabetic letter or the underscore ‘_’
character,but the other characters in the name can
be chosen from the following groups:
• Any lower-case letter from ‘a’ to ‘z’
• Any upper-case letter from ‘A’ to ‘Z’
Function examples
Example of a function that adds two integers
and prints the sum
void add_two_numbers (int a, int b)
{
int c;
c = a + b;
printf ("%d\n", c);}
The variables a and b are parameters passed in
from outside the function. The code defines a,
b, and c to be of type int.
The function above is not much use standing
alone. Here is a main function that calls the
int main()
{
int var1, var2;
var1 = 1;
var2 = 53;
add_two_numbers (var1, var2);
add_two_numbers (1, 2);
}
Functions with values
In mathematics, a function takes one or more
values and calculates, or returns, another value.
In C, some functions return values and others do
not; whether a function you write does or does
not will depend on what you want the function
to do. For example, a function that calculates a
value should probably return that value, while a
function that merely prints something out may
not need to.
The add_two_numbers function above did not
return a value. bill = calculate_bill (data1,
data2, data3);
When this statement is executed, control is
passed to the function calculate_bill, that
function executes, and then it returns control
int calculate_bill (int a, int b, int c){
int total;
total = a + b + c;
return total;}
As soon as the return statement is met,
calculate_bill stops executing and returns the
value total.
A function that returns a value must have a
return statement. For instance if calculate_bill
had read as follows, then the variable bill would
have had no meaningful value assigned to it, and
you might have received a warning from the
compiler . (The word void below indicates that
the function does not return a value.
void calculate_bill (int a, int b, int c)
{int total;
total = a + b + c;}
Function prototyping
Functions do not have to return integer values,
as in the above examples, but can return almost
any type of value, including floating point and
character values. (A function must be declared to
return a certain variable type (such as an
integer), just as variables must be.) To write code
in good C style, you should declare what type of
value a function returns (and what type of
parameters it accepts) in two places:
1.   At the beginning of the program, in global
scope.
2.   In the definition of the function itself.
Function declarations at the beginning of a
program are called prototypes.
Example of a program in which prototypes are
used:
#include <stdio.h>
void print_stuff (int foo, int bar);
int calc_value (int bas, int quux);
void print_stuff (int foo, int bar)
{
int var_to_print;
var_to_print = calc_value (foo, bar);
printf ("var_to_print = %d\n", var_to_print);
}
int calc_value (int bas, int quux)
return bas * quux;
}
int main() {
print_stuff (23, 5);
}
Without function prototypes, you usually
cannot write code that calls a function before
the function itself is defined in the program .
If you place prototypes for your functions in a
header file, however, you can call the functions
from any source code file that includes the
header. This is one reason C is considered to be
such a flexible programming language.
Some compilers avoid the use of prototypes by
making a first pass just to see what functions
are there, and a second pass to do the work,
but this takes about twice as long.
Programmers already hate the time compilers
take, and do not want to use compilers that
make unnecessary passes on their source code,
making prototypes a necessity. Also,prototypes
enable the C compiler to do more rigorous error
checking, and that saves an enormous amount
of time .
The exit function
We can use the exit function to terminate a
program at any point, no matter how many
function calls have been made. Before it
terminates the program, it calls a number of
other functions that perform tidy-up duties such
as closing open files.
exit is called with a return code, like this:
exit(0);
In the example above, the return code is 0.
Any program that calls your program can
read the return code from your program.
The return code is like a return value from
another function that is not main; in fact,
most of the time you can use the return
command within your main, instead of exit.
Conventionally, a return code of 0 specifies
that your program has ended normally and
all is well. (You can remember this as “zero
errors”, although for technical reasons, you
cannot use the number of errors your
program found as the return code. A return
code other than 0 indicates that some sort
of error has occurred.
If your code terminates when it encounters