121 CptS Fall 09 Lecture 7-2
HK Chapter 6: Modular Programming Lecture Outline I. II. Functions with Output Parameters Scope
CptS 121 L7-2 10/7/09
1
Prof. Chris Hundhausen
Functions with Output Parameters
In many situations, we would like to define functions that compute more than one value
Example: Previously, we "sold out" when we defined function get_width, which prompts the user for the width of a room, and returns that width. The function had to make the unrealistic assumption that rooms are always square, because we had no way to return multiple parameters! Wouldn't it be nice if we could define a function get_room_dims that prompts the user for the width and length of a room (both doubles), and returns those dimensions? Ideally, function get_room_dims would be able to return two values: length and width
2 Prof. Chris Hundhausen
Is that possible?
CptS 121 L7-2 10/7/09
Functions with Output Params (cont.)
Yes, it is! Function parameters would appear a promising place to start. But we first need to understand precisely what happens when we call a function with parameters, e.g.,
void foo (int a, char b, double c); int main (void) { int myint; char mychar; double mydouble; myint = 12; mychar = 'a'; mydouble = 23.45; foo (myint, mychar, mydouble); } void foo (int a, char b, double c) { /* This does random, meaningless stuff */ ++a; b = 'd'; c *= 2; }
CptS 121 L7-2 10/7/09
3
Prof. Chris Hundhausen
Functions with Output Params (cont.)
Remember that each function has a separate area of memory for storing its local variables and parameters. Each data area exists only when the function is active. Before the call to foo, memory might look something like this:
Function main data area myint 12 mychar 'a' mydouble 23.45
CptS 121 L7-2 10/7/09 4 Prof. Chris Hundhausen
Functions with Output Params (cont.)
Then, when function foo is called from main, the foo function's data area becomes active, and the actual parameter values passed to foo are copied to spaces in its memory area:
Function main data area myint 12 mychar 'a' mydouble 23.45 Function foo data area a 12 b 'a' c 23.45
copied
copied
copied
CptS 121 L7-2 10/7/09
5
Prof. Chris Hundhausen
Functions with Output Params (cont.)
Finally, when function foo finishes executing, its memory area disappears, and control returns to the main function. The state of memory is thus as it was prior to the call to foo:
Function main data area myint 12 mychar 'a' mydouble 23.45
CptS 121 L7-2 10/7/09 6 Prof. Chris Hundhausen
Functions with Output Params (cont.)
Since foo's data area goes away after execution, there's no way for foo to communicate with main through its parameter list. What we'd like is a two-way flow, something like this:
Function main data area myint 12 mychar 'a' mydouble 23.45 copied copied copied copied copied copied
7
Function foo data area a 12 b 'a' c 23.45
CptS 121 L7-2 10/7/09
Prof. Chris Hundhausen
Functions with Output Params (cont.)
In C, we can achieve the effect of output parameters by passing memory addresses (pointers) instead of values. Here's how we could modify the previous code to accomplish this:
void foo(int* a, char* b, double* c); int main(void) { int myint; char mychar; double mydoubl; myint = 12; mychar = 'a'; mydouble = 23.45; /* pass memory locations of variables, not vars themselves */ foo(&myint, &mychar, &mydouble); } void foo(int *a, char *b, double *c) { ++(*a); /* autoincrement the value at memory pointed to by a */ *b = 'd'; /* assign to memory pointed to by b */ *c *= 2; /* assign to memory pointed to by b */ }
CptS 121 L7-2 10/7/09 8 Prof. Chris Hundhausen
Functions with Output Params (cont.)
In order to visualize what the previous code is doing, we'll need to number (arbitrarily) the memory locations at which the variable values are stored:
Function main data area &myint myint 100 12 mychar 200 'a' mydouble 300 23.45 &mychar Function foo data area a 100 b 200 c 300
&mydouble
Since foo's parameters contain memory locations and not values, foo can use those memory locations to access, and ultimately to change, the original values the in main function. Such changes are called "side effects".
CptS 121 L7-2 10/7/09 9 Prof. Chris Hundhausen
Functions with Output Params (cont.)
Now let's revisit the get_room_dims example we started with:
void get_room_dims(double *length, double *width) { double local_len, local_width; printf("Please enter the length of the room: "); scanf("%lf",&local_length); printf("Please enter the width of the room: "); scanf("%lf",&local_width); *length = local_length; /* assign to output parameter */ *width = local_width; /* assign to output parameter */ }
CptS 121 L7-2 10/7/09
10
Prof. Chris Hundhausen
Functions with Output Params (cont.)
Here's a main function that calls upon get_room_dims
void get_room_dims(double*,double*); /* prototype */ int main(void) { double len, wid; /* allocate memory to receive output params */ get_room_dims(&len, &wid); /* len and wid now contain data, assuming everything went smoothly with scanf. We could now use those values. */ }
CptS 121 L7-2 10/7/09 11 Prof. Chris Hundhausen
Aside: The Many Faces of *
By now, you might find the multiple meanings of the '*' operator confusing. Let's review them.
Meaning one: "multiplication" Meaning two: "pointer to" Meaning three: "follow the pointer" (unary
indirection)
- e.g., 5
*3
- e.g., char - e.g., *i
*c;
Each of these meanings is markedly
different!
CptS 121 L7-2 10/7/09 12 Prof. Chris Hundhausen
= 4;
You Try It
With a partner, design a function divide that accepts four arguments:
number: an integer input parameter divisor: an integer input parameter result: an integer output parameter remainder: an integer output parameter
The function divides number by divisor. The result is placed into the output parameter result, and the remainder is placed into the output parameter remainder. Also show how a main function would call divide.
CptS 121 L7-2 10/7/09 13 Prof. Chris Hundhausen
Functions with Output Params (cont.)
Recall the get_room_dims example:
void get_room_dims(double *length, double *width) { double local_len, local_width; printf("Please enter the length of the room: "); scanf("%lf",&local_length); printf("Please enter the width of the room: "); scanf("%lf",&local_width); *length = local_length; /* assign to output param */ *width = local_width; /* assign to output param */ }
It turns out we can simplify this even further by substituting the output parameters directly into the calls to scanf (see next slide)
CptS 121 L7-2 10/7/09 14 Prof. Chris Hundhausen
Functions with Output Params (cont.)
Revised version of get_room_dims:
void get_room_dims(double *length, double *width) { printf("Please enter the length of the room: "); scanf("%lf",length); /* Why does this work? */ printf("Please enter the width of the room: "); scanf("%lf",width); /* Why does this work? */ }
Explanation: scanf needs the address of the variable into which to place the value it scans. Since length and width are declared as pointers to (addresss of) doubles, they meet that definition, and therefore can be substituted directly into scanf.
CptS 121 L7-2 10/7/09 15 Prof. Chris Hundhausen
Scope
As has been discussed in previous lectures, the scope of an identifier is the region of a program within which the identifier is defined. In general:
#define macro definitions have global
scope, meaning that they are defined within the entire source file A function is visible to all functions defined below it. However, its local variables are visible only to itself.
CptS 121 L7-2 10/7/09
16
Prof. Chris Hundhausen
Scope (cont.)
Identify the scope of the identifiers in the following example:
CptS 121 L7-2 10/7/09
17
Prof. Chris Hundhausen
Next Lecture
An extended example that includes several functions with input and output parameters
Prepare yourself by studying the extended
example in Section 6.5 (pp. 303-312)
Debugging techniques Common programming errors
CptS 121 L7-2 10/7/09
18
Prof. Chris Hundhausen