Top-Down Design with Functions What do programmer’s (not programs!) use as input to the design of a program? – Documentation • Problem definition • Requirements analysis • Design document (algorithm) – Previously written code • Library functions
Jan 07, 2016
Top-Down Design with Functions What do programmer’s (not programs!) use
as input to the design of a program?– Documentation
• Problem definition
• Requirements analysis
• Design document (algorithm)
– Previously written code• Library functions
Building Programs from Existing Information Problem analysis precedes requirements
analysis Requirements analysis precedes solution
design Solution design precedes programming This sequence of steps (and successive steps)
or phases is known as the software lifecycle
Building Programs from Existing Information An algorithm can be developed following a
methodology called stepwise refinement In this methodology, an initial high-level
solution is sketched, and each step in the algorithm is refined in a series of steps
We go from the human-oriented initial solution to the machine-oriented final program
Program Design Steps
Problem Statement Problem Analysis Data Requirements
– Inputs– Outputs– Constants
Program Design– Initial Design
• Pseudocode
Program Design Steps
– Algorithm refinement
Implementation Testing
– Test cases
Self-Check 3.1, 3.3
Library Functions
There are two major reasons to use functions– Code reuse– Divide and conquer approach to program
design
C provides numerous functions to provide useful tasks– Similar functions are grouped into a library
Library Functions
We have already seen the standard i/o library– We can use the functions in this library by
including the line “#include <stdio.h>” at the beginning of our program
– The file <stdio.h> is an example of a header file• It gives the definitions of all of the functions and
constants in the library so that they can be used by the compiler to check the program
Library Functions
Another important standard library (what is a standard library and how does it differ from a non-standard library?) is the standard math library - #include <math.h>
Among the functions in this library are• ceil(x) and floor(x)
• cos(x), sin(x) and tan(x) (all inputs given in radians)
• sqrt(x) and pow(x, y)
• exp(x), log(x) and log10(x)
• All have input, output of type double
Mathematical Functions
Consider the following use of the math functions– Given two sides (b and c) of a triangle and the
angle between them (the length of the third side can be computed using the following formula: a2 = b2 + c2 -2bc cos
– In C, we compute a as follows:– a = sqrt(pow(b,2) + pow(c,2) -2 * b * c *
cos(alpha * PI / 180.0));
User-Defined Functions
Besides the standard library functions (and main) C allows the programmer to define his own functions
The essential parts of the declaration of a function are:– Function name– Number of arguments and argument types – Return type
Top-Down Design and Structure Charts As we said previously, top-down design is a
methodology for program design– We apply the divide and conquer philosophy of a
dividing a problem into subproblems– Concentrate on the subproblems one at a time– In the implementation, each subproblem may be
implemented as a function– We may document a top-down design using a
diagramming technique known as structure charts
Functions Without Arguments
The simplest functions are those which have no arguments and which return no value
These are also the most limited type of function since they always have the same outcome
An example of a function call for such a function is: do_input();
Functions Without Arguments
Just as we needed to declare variables prior to using them, we must also declare functions prior to use
The function is declared in a function prototype– The prototype gives the function’s name, argument
types, and return types– If there is no value returned we use the reserved word
void in place of the data value– If there are no arguments, use void
Functions Without Arguments
Example function prototype for a simple function: void do_input(void);
Function prototypes are placed after the includes and defines and before the main function of the program
Note that the header files for the standard libraries contain function prototypes for, e.g., scanf
Functions Without Arguments
After giving the function prototype, we must also have the function itself (function header and function body)
The function is placed after the function prototypes and before or after the main function (but not inside the main function!)
The function prototypes and preprocessor directives may also be place in a header file (when would you do this?)
Functions Without Arguments
If a function gets too big (say, > 200 lines of code) it should be split into multiple functions to make it easier to read
If a file gets too (say, > 1000 lines of code) it should be split into multiple files to make it easier to read
Functions should be commented to give their intended use
Flow of Control
A function call causes program execution to be transferred from the calling function to the called function
The return statement causes program execution to return to the calling function (or to the operating system in the case of the main function)
Functions with Arguments
Arguments carry information from the calling function (or operating system in the case of the main function) into the called function
Called functions can also return values to the calling function (or operating system in the case of the main function)
Functions with Arguments
Functions with arguments are much more powerful than those without since they can calculate a different value for each different argument
Arguments carry information into the function or allow multiple results to be returned by the function
Parameters can be classified as input or output arguments
Functions with Arguments
We can also have functions which have input parameters but a void return type– For example: print_sum(x,y);
Another possibility is to have a function with input arguments and a single result– In this case, the function call most often
appears as part of an assignment statement– result = compute_sum(x,y);
Functions which return a value
These functions pass the value they compute back to the calling program using the return statement
A function to find the circumference of a circle might have a single statement - return: return(2.0*PI*r); /* r - argument */
The arguments of a function are given names in the implementation of the function
Functions which return a value
double compute_sum(int first, int second)
We may then use the arguments of the function just as we would variables of the same types (only within the function though)
The values of the arguments are lost when we leave the function
Functions which return a value
Imagine we have a function called zero_out with an argument z: – int zero_out(int z);
Now in our main function we have an int variable x which we set to 3:– X = 3;
Call the function zero_out as follows:– y = zero_out(x);
Functions which return a value
In the body of zero_out we do the following:– z = 0; return(z);
What are the values of x and y? If we have multiple arguments in the function,
we must have a corresponding number of arguments in the function call and the must be of the same types as in the function prototype
Functions
If there are some variables that we need to perform the task of the function, we may declare these local variables at the start of the function body
Each time the function is called, the computer reserves space for the functions local variables and arguments (on the stack)
This space is freed when the function terminates
Testing Functions using Drivers
In top-down design, a programs functions may be tested separately from the programs which use them
In order to do this, write a short function which calls the function you want to test with some input and then displays the result
This calling function is called the driver function