Amiga Computing - Commodore Is Awesome

Of you use a photocopier to make a
copy you go to the machine, place
the document to be copied inside,
press a button and wait for the
device to do its job. It's likely you do all this
without really knowing what goes on inside -
you just know what input is required (the doc
ument to be copied) and what must be done to
start the copying process. You also know that
some results will come back i.e. a copy of the
input document.
This information hiding 'black box' concept is
an effective way of protecting a user from
unnecessary complexity. For the C programmer,
there is an equally effective facility - the C func
tion. This provides similar capabilities and
because of this, functions are the essential
building blocks of all C programs.
Many functions, like printfO we used last
month, have been found to be so useful they
are provided with all C compilers. The Amiga
also has its own function libraries and we'll see
later how these are used for handling Intuition,
graphics and so on. Often however, you'll need
to create your own functions.
Function Definitions
Listing 1 provides a general description of a C
function whilst listing 2 shows a simple exam
ple which calculates the area of a rectangle by
multiplying its width and length values togeth
er. This latter definition uses C's * operator to
indicate multiplication and give us our first
encounter with some variables.
Variables represent areas of memory that
you can use for storing information and, just as
with languages like Basic, it helps to use names
that mean something. Needless to say 1 have
defined a variable called result - because in this
instance that's exactly what it is being used to
store.
The expression 'int', incidentally, is just C's
way of describing a variable that can store an
integer (a whole number) value. The width and
length parameters used in the function defini
tion are also variables (again defined as inte
gers) but, because they represent the function
arguments, take on whatever values are sup
plied when the function is used. Inside the func
tion however, these items are used just like any
other variables.
The return() statement indicates the value to
be returned to the caller and any valid C expres
sion may be used inside the parenthesis.
Functions do not have to provide a return value
and a returnO statement without an expres
sion, or in fact no returnf) statement at all, both
result in no actual value being returned. It's also
perfectly legal to ignore a return value, although
narch^t est^l
iarch_t est . c
rtarchtest.o
More help for
aspiring C coders
as Paul Overaa
puts function use
under the spotlight
un ctj on
return-type funttion-nase ( parameter list )
variable declarations
appropriate C statements
Listing 1: In general C functions
have this sort of layout
in the case of our example function, it would
make little sense to carry out the calculation if
you weren't going to use the results!
So, the listing 2 function definition tells us
Area() is a function that expects two integers
representing the width and length of a rectangle
- and returns an integer representing the area of
that rectangle. Using the function is easy - if, for
example we have a variable called
rectangie_area that we want to set to the area
of a 6 unit by 8 unit rectangle we just write:
rectangle_area = Area(6,8);
C evaluates the right hand side of the expres
sion by making a call to the AreaO function
(using the parameters supplied). Then it assigns
the function's return value to the variable on the
left hand side of the expression. The result - rec-
tangle_area gets set to 48!
To be honest, the operation of multiplying
two numbers together, which is all Area{) does,
would not normally be written as a function -
you'd just work out the result using the state
ment widthiength. It must be said however,
that if you were going to define a function for
pj Output Hindoo : .;_""'.
le^area of a rectaiig I e 5 inches liv 8 inches TIT
48 square inches!
This month's example can be compiled in
exactly the same way as last month's code
Amiga Computing
MARCH 1997
int Areafint width, int length)
I
int result;
result=tndth'length;
returnf result);
Listing 2: An example function definition
doing this you could do it more concisely by
using the function's arguments directly:
int Area(in: iiidth, int length)
{
retsjrnlwidth'Length);
int Areafint vidtii, int
tength)treturnfnidth*length);}
Notice that C, unlike other languages, isn't par
ticularly fussy about the physical layout of the
source code.
Some Example Code
On the coverdisk you will find a short program
that makes use of this AreaO function along
with a few extra notes about the variable and
function naming conventions I use. One thing
you will notice in this month's source is an ANSI
C function declaration statement called a proto
type
int Areafint width, int length);
This looks pretty much like the first line of the
function description itself, with a semicolon
tagged on the end. It's job is to provide an ini
tial definition of the variable types being used
which then allows the compiler to check all
subsequent function use is correct (pre-ANSI
compilers were not able to do this).
Needless to say there is plenty more to be
said about functions but it's best to deal with
individual issues as they crop up within exam
ple code. So, although next month it's C vari
able types and operators that come under the
limelight, you will in fact be also be learning a
little more about function use as well. /^*f