1057-ch06

8/10/2019 1057-CH06

1/5

5/6/13 1057-CH06

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

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 addressof 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 accessfiles. See the program in FIGURE 6.2as 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 referenceof 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:
http://www.cis.temple.edu/~pwang/1057-PC/SourceCode/Chapter%206/06.03.chttp://www.cis.temple.edu/~pwang/1057-PC/1057-index.htmhttp://www.cis.temple.edu/~pwang/1057-PC/SourceCode/Chapter%206/06.03.chttp://www.cis.temple.edu/~pwang/1057-PC/SourceCode/Chapter%206/06.02.chttp://www.cis.temple.edu/~pwang/1057-PC/Lecture/Ch06.htm#http://www.cis.temple.edu/~pwang/1057-PC/1057-index.htm

8/10/2019 1057-CH06

2/5

5/6/13 1057-CH06


The completeprogram 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.7orders 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 tokeep 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.
http://www.cis.temple.edu/~pwang/1057-PC/SourceCode/Chapter%206/06.07.chttp://www.cis.temple.edu/~pwang/1057-PC/SourceCode/Chapter%206/06.05.chttp://www.cis.temple.edu/~pwang/1057-PC/Lecture/Ch06.htm#

8/10/2019 1057-CH06

3/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 thetask. 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
http://www.cis.temple.edu/~pwang/1057-PC/SourceCode/Chapter%206/06.10.chttp://www.cis.temple.edu/~pwang/1057-PC/SourceCode/Chapter%206/06.09.c

8/10/2019 1057-CH06

4/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 manageablesize 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
http://www.cis.temple.edu/~pwang/1057-PC/Lecture/Ch06.htm#http://www.cis.temple.edu/~pwang/1057-PC/SourceCode/Chapter%206/06.15.c

8/10/2019 1057-CH06

5/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.

1057-ch06

Documents