CS 161 Introduction to Programming and Problem Solving Chapter 24 C Functions Herbert G. Mayer, PSU...
-
Upload
suzanna-cannon -
Category
Documents
-
view
217 -
download
0
Transcript of CS 161 Introduction to Programming and Problem Solving Chapter 24 C Functions Herbert G. Mayer, PSU...
CS 161Introduction to Programming
and Problem Solving
Chapter 24C Functions
Herbert G. Mayer, PSUStatus 9/8/2014
Initial content copied verbatim fromECE 103 material by prof. Phillip Wong @ PSU
Syllabus Introduction Function Definition Parameter List Function Body Function Declaration Examples Recursion
3
Introduction A program can be divided into multiple parts Logical partitions are named: modules Physical partitions are named: C functions Each function has a name; when listed in a C
program, the respective function is “called” or “invoked” to do its logical task at that code location
Why are functions useful? Organization – divides tasks into subtasks Encapsulation – hides design and implementation details
from view of the rest of the program Simplification – reduces unnecessary code repetition Modularity – creates reusable code libraries
4
Arguments, AKA actual parameters, contain data that the caller passes to the function Arguments can be literal constants, variables, data
structures, or expressions Some functions require multiple arguments, while
others may need no arguments at all The Return Value returns data back to the caller
A function can return a single value or no value at all, in which case it is a void function
C FunctionArgumentsReturnValue
5
Example:
Sample function calls:
fun1(); // no input arg, no ret valfun2( n ); // 1 input arg, AKA 1 actualfun3( 1.25, "xm” ); // 2 input args: 2 actuals
R = rand(); /* no arg, 1 return value */y = sin( x ); /* 1 arg, 1 return value */w = pow( 2.5, 3 ); /* 2 args, 1 return value */
/* 5 input args, 1 return value */val = myfun( "PSU", 'x', 3.5, ivar, 2*cos( A ) );
6
Function Definition
return_type function_name ( parameter_list ){ // function_name
local variable declarationscode statements
} //end function_name
Function definition consists of: header – defines required function inputs/outputs body – defines the function code Body includes return operation, even default fall-thru
Function names follow variable naming rules
Function body{between braces}
Header
7
Parameter List:
The formal parameter list defines expected data to be passed to function Formal Parameters are local function variables,
generally initialized at place of call via actuals Names and data types of parameter are declared Multiple parameters are separated by commas During a call, the actual parameters are bound to the
formal parameters If no parameters are needed, the list is declared as
type void
8
Are arguments (actuals) and parameters (formals) the same?
→ No. Arguments are the values passed to the function. Parameters are the function’s internal variables that hold copies of the passed values.
Example:int x = 3, y = 5, k;
char c = '#';
k = fun( x, y, 42, c ); . . .int fun( int x, int y, int z, char c ){ . . . }
The contents of variables x, y, c, along with the constant 42, are passed to the function. These are called arguments.
These variables x, y, z, c receive the values passed to the function. They are called parameters.
9
Must an argument variable have the same name as its corresponding parameter variable?→ No. They independent of one another
Example:int a = 3, b = 5, k;char m = '#';
k = fun( a, b, 42, m );. . .
int fun( int x, int y, int z, char c ){ . . . }
Function call
Function definition
'#'4253
10
Example:/* Function definition */void display( int xval, char ch, double * ptr ){ // display
printf( "%d %c %p\n", xval, ch, ptr );} //end display
int xval = 3, cat = 3;char ch = 'T', z = 'T';double * ptr = & xval, * q = & xval; // careful!!!
// Some function calls:display( 3, 'T', & xval ); // careful!!!display( xval, ch, ptr );display( cat, z, q );/* In each case, the value of the argument * is stored in the corresponding parameter
*/
11
If possible, an argument's type will be promoted or demoted to match its parameter's type
Example:/* Function definition */void fun( int u, double v ){ . . . }
int x = 2;double y = 3.1415;
/* Some function calls */fun( x, y ); /* u contains 2, v contains 3.1415 */fun( y, x ); /* u contains 3, v contains 2.0 */
Incompatible arguments can cause programs to fail at runtime! Be very carful!!
12
Return type:
Return type can be: Variant of char, int, float, double, struct Pointer (i.e., memory address) void (if no value is to be returned)
If the function returns a value, then a return statement is needed in the function body.Example:double Compute_Vx (double V, double angle){
return V * sin( angle );}
13
Function Body Function body contains:
Local variable declarations Local prototype declarations Code that defines what the function does Including code to specify return value
Braces { } mark the beginning and end of the function body
There is no semicolon after the final brace In C, a function definition cannot be nested inside
another function definition! Note: gcc extension!
14
Example:/* Program #1 Compute areas of triangles - without separate function */#include <stdio.h>
int main( void ){ // main
float b, h; /* base and height */float A1, A2; /* area */
A1 = ( 3.0 * 1.5 ) / 2.0;printf( "Area1 = %f\n", A1 );
b = 2.5; h = 15.4; A2 = ( b * h ) / 2.0;printf( "Area2 = %f\n", A2 );
b = 0.33; h = 5.7;printf( "Area3 = %f\n", ( b * h ) / 2.0 );
return 0;} //end main
15
Example:/* Program #2 Compute areas of triangles – with function */
#include <stdio.h>
float triangle_area( float base, float height ){ // triangle_area
return ( base * height ) / 2.0f;} //end triangle_area
int main( void ){ // main
float b, h; /* base and height */float A1, A2; /* area */
A1 = triangle_area( 3.0f, 1.5f );printf( "Area1 = %f\n", A1);
b = 2.5f; h = 15.4f; A2 = triangle_area( b, h );printf( "Area2 = %f\n", A2);
b = 0.33f; h = 5.7f;printf( "Area3 = %f\n", triangle_area( b, h ) );
return 0;} //end main
16
Declaring a Function
Functions must be defined before they are first used
Does this imply that functions must be placed in the source file in a specific order? It depends
For functions, C has two approaches to meet the "define-before-use" rule: Define functions in order within the source file Use function prototypes
17
Approach #1: Ordered Definitions
Within the source file, function definitions that are used first are placed before functions that call them
Example:Suppose A, B, C, D are functions. B calls C,D calls C, and A calls D:
CBDA
Top of source file
18
Example:void fun1( void ){ // fun1
int x;. . .x = 3;
} //end fun1
void fun2( void ){ // fun2
int x;. . .x = 5;fun1();
} //end fun2
int main( void ){ // main
int x;x = 7;fun1();fun2();return 0;
} //end main
fun1 defined 1st since both fun2 and main call it.
fun2 defined 2nd since main calls it (but not fun1).
main defined last
19
Approach #2: Prototypes A function can be declared before being defined A function declaration is just the function header by
itself followed by a semicolon (no body) These declarations are called prototypes Prototypes are usually placed at the top of the
source file before the actual function definitions Prototypes allow the compiler to determine the basic
input/output characteristics of functions without needing to know the internal details
By the end of the compilations, bodies for the prototypes must be available
20
Example 1, with formal parameter names:#include <stdio.h>/* Function prototypes */void display( char ch, int xval );float calculate( int x );
int main( void ){ // main
display( 'G', 8 );return 0;
} //end main
/* Function definitions */void display( char ch, int xval ){ // display
printf( "%c %d %f\n", ch, xval, calculate( xval ) );} //end display
float calculate( int x ){ // calculate
return x*x / 3.0;} //end calculate
Once the prototypes are declared, the order in which the functions are defined does not matter
NOTE:The main() function does not need to be declared.
21
Example 2 without formal parameter names:#include <stdio.h>/* Function prototypes */void display( char, int );float calculate( int );
int main( void ){ // main
display( 'G', 8 );return 0;
} //end main
/* Function definitions */void display( char ch, int xval ){ // display
printf( "%c %d %f\n", ch, xval, calculate( xval ) );} //end display
float calculate( int x ){ // calculate
return x*x / 3.0;} //end calculate
22
Example 3 function min( int, int ) with 3-4 args?#include <stdio.h>
int min( int arg1, int arg2 ){ // min
return arg1 < arg2 ? arg1 : arg2;} //end min
int main( void ){ // main
printf( “min of 2, -3 = %d\n”, min( 2, -3 ) );printf( “min of 2, 12, 3 = %d\n”, min( 2, min( 12, 3 ) ) );printf( “min of -9, 2, 12, 3 = %d\n”, min( min( -9, 2 ), min( 12, 3 ) ) );return 0;
} //end main
23
No parameters Single parameter Multiple parameters (e.g., 2)
No return value
Declarationvoid fun (void);
Declarationvoid fun (dtype a);
Declarationvoid fun (dtype a, dtype b);
Definitionvoid fun (void){ /* return not needed */}
Definitionvoid fun (dtype a){ /* return not needed */}
Definitionvoid fun (dtype a, dtype b){ /* return not needed */}
Callfun();
Callfun(x);
Callfun(x, y);
Single return value
Declarationdtype fun (void);
Declarationdtype fun (dtype a);
Declarationdtype fun (dtype a, dtype b);
Definitiondtype fun (void){ return expr;}
Definitiondtype fun (dtype a){ return expr;}
Definitiondtype fun (dtype a, dtype b){ return expr;}
Callz = fun();
Callz = fun(x);
Callz = fun(x, y);
24
Recursive Functions
A function f() may call itself! Either directly, i.e. from inside its own body of f() Or indirectly, from inside another function g(), which
was in turn called by f() The former is referred to as “directly recursive calls” The latter a “indirect recursive calls” Recursion is a powerful programming tool, so strong,
it can replace almost all other tools; though that is not a recommended approach
25
Recursive Function Definition
A function f() is recursive, if it is partly defined by simpler versions of f() itself
The partly is important, providing for a base case, a case where the result is known and no further calls are made at all
The simpler version is also important, else there would be no recursion at all, but instead infinite regress instead; that is as bad as an infinite loop
Let’s see an example:
26
Simple Recursive Function: fact()#include <stdio.h>
// compute the unsigned factorial of an unsigned argumentunsigned fact( unsigned arg ){ // fact
if ( 0 == arg ) {return 1;
}else{return fact( arg – 1 ) * arg;
} //end if} //end fact
int main( void ){ // main
int i;for ( i = 0; i < 10; i++ ) {
printf( “fact(%d) = %d\n”, i, fact( i ) );} //end for
} //end main