5/6/13

1057-CH06

CIS 1057. Computer Programming in C

Chapter 6. Pointers and Modular Programming

1. Pointers and the indirection operator
An asterisk ('*') before an identifier is called an "indirection operator", which indicates that the variable contains the
address of another variable. Such a variable is called a "pointer" in C. For instance, the declaration double *p
makes pa "pointer variable" of type "pointer to double", and char *signptells the compiler that signpwill
contain the address of a type charvariable.
When putting before a variable name, the "address of operator" '&' (ampersand) gets a pointer to that variable. For
example,
int m = 25;
int itemp = &m;

Then the second variable contains the address of the first variable. After that, *itempcan be used as m. This is
called "indirect reference".
Intuitively, '*' and '&' are inverse operations, and '*&m' is the same as 'm' if 'm' is an ordinary variable, while '&*p'
is the same as 'p' if 'p' is a pointer.
As a special case, pointers can be used to access files. See the program in FIGURE 6.2 as an example.

2. Functions with output parameters

A function passes data from and to the calling function through the argument list and return value. While the latter is
for output only, the former can be both input and output.
When a function call executes, the computer allocates memory space in the function data area for each formal
parameter. The value of each actual parameter is stored in the memory cell allocated to its corresponding formal
parameter. The function body can manipulate this value.
Please note that the changed value is not copied back into the actual arguments. Therefore, in our previous
examples, the argument list of a function is used for input only. To use it as output, the reference of the actual
argument, rather then its value, should be passed between the two functions.
In the calling function, the "address of" ('&', ampersand) operator is used to pass a pointer. For example, see
FIGURE 6.3. The memory content looks like FIGURE 6.4:

www.cis.temple.edu/~pwang/1057-PC/Lecture/Ch06.htm

1/5

5/6/13

1057-CH06

The complete program is in FIGURE 6.5.

The character '*' (asterisk) in C has three different meanings. When used between two numbers, it means
"multiplication"; then used in a declaration like "char *signp", it indicates that signpis a pointer; when used in a
statement like "*signp = '-';", it means "to follow the pointer". Similarly, an ampersand '&' indicates "address
of" when used before a variable, but "and" when used as an operator between two operands '&' is "bitwise
and", and '&&' is the "logical and".

3. Multiple calls to a function with input/output parameters

A single argument can be used both as input and output of a function, by passing a pointer to the function.
The program in FIGURE 6.7 orders three numbers.
If a function only produces a single output value, it is preferred to use it as the return value of the function, and to
keep the argument list as input only, passing by values. In this way, the function will not accidentally produce
changes that are not desired.

4. Scope of names
The scope of a name refers to the region of a program where a particular meaning of a name is visible or can be
referenced.
www.cis.temple.edu/~pwang/1057-PC/Lecture/Ch06.htm

2/5

5/6/13

1057-CH06

For example, in the program of FIGURE 6.9, the constant macros have a scope that begins at their definitions, and
continues to the end of the source file. The scope of a function name start from its prototype (if available) or
header, and continues to the end of the source file. Formal arguments are local to the body of the defining function.
If a "local" variable/function has the same name as a "global" one (such as the name "one" in the previous example),
the former is used whenever the name is used in the local scope. It is invalid for more than one local (or global)
name to be identical within the same scope.

5. Formal output parameters as actual arguments

Sometimes a function needs to pass its own output parameter as an argument when it calls another function.
For example, the incomplete program in FIGURE 6.10, the output parameters of the function scan_fraction
need to be passed to function scanfas the following:
status = scanf("%d %c%d", nump, &slash, denomp);

Please note that scanfexpects addresses of variable to be passed after the format, so the address of (&) symbol
is used. In this example, since the first and the third arguments are pointers (addresses of variable) themselves, they
are directly passed.
Now we can see that since scanfmay get many values (one for each format specifier in the format string), all
arguments passed to it must be pointers. The return value of scanfis the number of items it successfully converts
and stores.
In general, if function f1passes an argument xto another function f2, there are the following situations:
If xis used in both f1and f2as a value, then xis directly passed.
If xis used in both f1and f2as a pointer, then xis directly passed.
If xis used in f1as a value, but in f2as a pointer, then &xis passed.
If xis used in f1as a pointer, but in f2as a value, then *xis passed.

6. A program with multiple functions

The basic idea of modular programming is to develop a program by modules, each of which carries out part of the
task. In this way, the development and maintenance of a program is simplified. In C, each module typically
corresponds to a function.
The next case study shows how to handle a data type not defined in C by providing functions for certain
operations.

CASE STUDY: Arithmetic with common fractions

Problem: To represent and process common fractions as integer ratios. The operations to be implemented include
www.cis.temple.edu/~pwang/1057-PC/Lecture/Ch06.htm

3/5

5/6/13

1057-CH06

addition, subtraction, multiplication, and division.

Analysis: each "number" is represented by a numerator and a denominator, both are integers. Each operation takes
two numbers as input, and produce one number as output. The operations can be repeated.
Design: FIGURE 6.14

Implementation: FIGURE 6.15. Two functions in it are left as exercises. In the program, "stubs" are used as place
holders.

7. Debugging and testing

To keep each function to a manageable size will make debugging and testing easier.
To insert studs into incomplete program makes it possible to test parts of a program before the whole thing is
finished. Each stub displays an identification message and assigns values to its output parameters to prevent
execution errors caused by undefined values.
Especially, studs allow the main function to be debugged and tested before the sub-functions are done this is
www.cis.temple.edu/~pwang/1057-PC/Lecture/Ch06.htm

4/5

5/6/13

1057-CH06

called "top-down testing", which means to get the big picture right before filling in all the details.
To test a sub-function by itself is called "unit testing", which can be performed with a simple "driver function", which
calls the function to be tested with proper actual arguments.
The process of separately testing individual functions before inserting them into the whole program is called
"bottom-up testing". Tests of the entire systems are called "system integration tests".
Debugging tips:
1. Document parameters and variables, as well as functions.
2. Trace executions by displaying functions entered.
3. Trace executions by displaying input/output of each function.

8. Common programming errors

Be careful about parameter lists check number, order, and type.
An output argument in an argument list must be a pointer.
Give identifiers proper ranges, that is, neither too large nor too small.

www.cis.temple.edu/~pwang/1057-PC/Lecture/Ch06.htm

5/5