The Formality of Functions
Formals and Actuals
Notice that even when an argument expression is just a single variable,
it need not be named the same thing as it is named in the function being
called.
The name given in the callee is called the
formal parameter
(or sometimes just
parameter
) where the argument expression
is known as the
actual parameter
or
argument
.
For example, we called one of the variables
adjacent
in the
main()
function and used that name passing it as the
first argument when we called
pythag()
.
However, in
pythag()
itself, the first parameter is
called
side_a
.
side_a
is the
formal parameter
and for this call,
adjacent
is the
actual parameter
.
It couldn't be any other way; we don't know what the formal for
sqrt()
is!
Positional Parameters
So the question arises, how does C know which actual goes with which
formal?
If we run the program:
#include <stdio.h>
void foo(int a, int b);
main()
{
int a, b;
a = 3;
b = 9;
foo(a, b);
foo(b, a);
}
void foo(int a, int b)
{
printf("%d %d\n", a, b);
}
we see that the output looks like:
3 9
9 3
illustrating that parameters are passed by
position
.
Namely, the first actual always corresponds to the first formal and so
on.
This is true whether or not the names of the actuals and formals are
the same.
(See
Part 2-5
for an explanation of
the return type
void
.)
Passing by Value
Another important fact about parameter passing is shown in this next
example.
#include <stdio.h>
void foo(int a);
main()
{
int x;
x = 42;
foo(x);
printf("After calling foo: x = %d\n", x);
}
void foo(int a)
{
a = 101;
printf("Inside foo: a = %d\n", a);
}
When we run this program which number (42 or 101) will be
printed for
x
after the call to
foo()
?
The answer depend on what kind of parameter passing C uses.
All parameter passing in C is of the type known as
pass
by value
.
(There are others, but we are not concerned with them here.)
What this means is that when something is to be passed, the expression
is first evaluated.
If the expression is just a variable, then the value of the expression
is just what's stored in the variable.
Then a copy of the expression's value is placed into a new "variable"
which has the name of the formal parameter.
In a case like this where the argument is a single variable, we now
have two copies of that number (as opposed to having both names as
aliases for the same memory location).
That means that any changes to a parameter made inside a function get
made to it's local copy of the data, not to the actual parameter.
In the program:
#include <stdio.h>
int foo(int x);
main()
{
int i, j;
i = foo(3);
j = foo(i);
printf("%d %d\n", i, j);
}
int foo(int x)
{
x = x * 2;
printf("%d ", x);
return x + 3;
}