60-140 Lecture 3 Dr. Robert D. Kent Program Control - Details.

60-140 Lecture 3

Dr. Robert D. Kent

Program Control - Details

Lecture 3: OutlineProgram control

Generalities versus detailsDecision control

Nested if-else control structuresThe switch control structure

Repetition controlNested while and do-while control structuresThe for control structure

The role of functions in Top-Down design Impact on formulation of well-defined control

structures

3A : Program control

Generalities versus Details

Generalities versus DetailsPreviously, we introduced the basic C control

structuresDecision (Selection)

if if-else switchRepetition

while do-while for

We shall now take another look, in more detailUsage and patternsFlexibility

Generalities versus DetailsUsage and patterns

How are the control structures used in simple, versus complicated, programming circumstances?

What patterns emerge often?These can be re-used

FlexibilityHow flexible is the syntax and grammar of the

control structures?Efficiency versus Clarity

3B. Decision Control

Nested if-else and Switch

3b: OutlineReviewNested if-else control structuresThe switch control structure

ReviewWe have introduced the structured control

mechanisms for decision and selection

Decision:

if ( condition ) Statement ;

Either – perform the Statement (simple or compound) or NOT !Straightforward in most cases

ReviewIf Statement is compound, use braces and

indentation

if ( condition ) { Statement1 ; ...... StatementN ; }

Indentation improves the readability (hence, understanding) of the code for humans.

ReviewSelection:

if ( condition ) T_statement ; /* do when cond is True */ else F_statement ; /* do when cond is False */

Once again, if using compound statements, or if placing a simple statement on a following line, use indentation to improve code readability.This is an either-or situation – perform EITHER the

True clause OR the False clause, but not both!

Many styles exist – use one style consistently in program code.

If ( condition ) { T_stmts ;} else { F_stmts ;}

ReviewSimple Selection:

( condition ) ? T_statement : F_statement

This simple selection structure uses the ternary operator ?: This form may be used as a single control

structure/statementIt is most often incorporated into another statement (eg.

printf) as a component (nested) sub-structure.

If Value is 60, output is: Answer is A

printf( “Answer is %c\n”, (Value > 50) ? ‘A’ : ‘B’ ) ;

Multiple selection – A simple sortProblem:

Enter three integer values and output them in the order from largest to smallestAll values inputted are distinctNote – there are six (6) separate cases to account for

This is called sorting Later we will discuss this for an arbitrary number of

values

Multiple selection – A simple sortSolution:

int A, B, C ;

scanf( “%d%d%d”, &A, &B, &C ) ;

if ( A > B && B > C ) printf( “%d %d %d\n”, A, B, C ) ; if ( A > C && C > B ) printf( “%d %d %d\n”, A, C, B ) ; if ( B > A && A > C ) printf( “%d %d %d\n”, B, A, C ) ; if ( B > C && C > A ) printf( “%d %d %d\n”, B, C, A ) ; if ( C > A && A > B ) printf( “%d %d %d\n”, C, A, B ) ; if ( C > B && B > A ) printf( “%d %d %d\n”, C, B, A ) ;

Note the number of distinct operationsCan this be improved upon (made more efficient)?

CPU instructions are binary for relational comparisons and logic operations. Thus, an expression like:

A > B && B > C

requires three (3) separate operations, namely:

Temp1 = A>BTemp2 = B>CExprvalue = Temp1 && Temp2

3 x 6 = 18

Multiple selection – A simple sortImproved Solution:

if ( A > B ) if ( B > C ) printf( “%d %d %d\n”, A, B, C ) ; else if ( A > C ) printf( “%d %d %d\n”, A, C, B ) ; else printf( “%d %d %d\n”, C, A, B ) ; else if ( A > C ) printf( “%d %d %d\n”, B, A, C ) ; else if ( B > C ) printf( “%d %d %d\n”, B, C, A ) ; else printf( “%d %d %d\n”, C, B, A ) ;

Note the number of distinct operationsCan this be improved upon (made more efficient)? NO !

A minimum of 2 – a maximum of 3!Divide and Conquer (binary subdivision) strategy.

Multiple selectionMultiple selection logic arises when a choice

between more than two possible outcomes may happen

C provides two control structures to deal with these situations if-else (with nesting) switch

Multiple selection Problem:

Part of a calculator program requires the user to input a value from 1 to 4 indicating his/her choice of the operation to perform on two values A and B (assume A, B already entered) RESULT: C = A operation B ;

The interpretation of the inputs is defined as1 - Add2 - Subtract3 - Multiply4 - Divide

Multiple selection : if-elseSolution using if-else :

printf ( “Enter operation code >” ) ; scanf ( “%d”, &Code ) ; if ( Code == 1 ) C = A + B ; else if ( Code == 2 ) C = A – B ; else if ( Code == 3 ) C = A * B ; else C = A / B ;

Multiple selection : switchSolution using switch :

printf ( “Enter operation code >” ) ; scanf ( “%d”, &Code ) ; switch ( Code ) { case 1 : C = A + B ; break ; case 2 : C = A – B ; break ; case 3 : C = A * B ; break ; case 4 : C = A / B ; break ; default : printf ( “Error in input\n” ) ; break ; }

Multiple selection : switchProblem:

Count the number of times that the ‘A’ (or ‘a’) or ‘B’ (or ‘b’) key is pressed, and all remaining alphabetic character keystrokes.

Solution considerations:Need counters for A-keystrokes, B-keystrokes and all

other alphabetic keystrokes.Must ignore non-alphabetic keystrokes such as digits

and punctuation and control signals (eg. ‘\n’) We must differentiate between the alphabetic characters that are

not (‘a’, ‘A’, ‘b’, ‘B’), but which must be counted, and the non-alphabetic keystrokes that are not counted

Recall that the ASCII character code treats the lower case and upper case alphabetic character sequences as ordinal sequences:

‘a’ < ‘b’ < ... < ‘z’ ‘A’ < ‘B’ < ... < ‘Z’

Multiple selection : switch int Acnt = 0, Bcnt = 0, Alphacnt = 0 ;

char Ch ;

switch( Ch = getchar() ) { case ‘a’ : /* lower case */ case ‘A’ : /* upper case */ Acnt++ ; break ; case ‘b’ : /* lower case */ case ‘B’ : /* upper case */ Bcnt++ ; break ; default : if ( (Ch > ‘b’ && Ch <= ‘z’) || (Ch > ‘B’ && Ch <= ‘Z’) ) Alphacnt++ ; break ; }


char Ch ;


getchar() is a function from <stdio.h> that obtains one character from stdin. In this scenario, the character inputted is assigned to Ch variable.

The value of the condition is the same as the value of Ch.


char Ch ;


Use of break implies that the switch must be immediately exited.


char Ch ;


Logic Patterns!- reused


char Ch ;


Note that break is not required for each case clause. Lack of a break implies that the next case must be processed.

In this case, if Ch is assigned ‘a’, the first case ‘a’ is compared and found to match, but since there is no specific statement to execute, the

processing logic advances to the next case clause (‘A’) and performs the statement: Acnt++ ;


char Ch ;


The default clause is used to handle all other cases that are not explicitly coded. It is possible that this clause may involve complicated logic and processing steps.

Recall that the ASCII character code treats the lower case and upper case alphabetic character sequences as ordinal sequences:

‘a’ < ‘b’ < ... < ‘z’ ‘A’ < ‘B’ < ... < ‘Z’

If Ch is alphabetic and not ‘a’, ‘b’, ‘A’ or ‘B’, then it must lie within one OR the other range of characters.

Multiple selection : switchIt is possible to nest multiple statements and control

structures within each case clause of the switch structureUsually this leads to coding that is difficult to understandTypically, it is advised to keep the logic of each case

clause relatively simple and directLater, we will see that complicated logic is best

encapsulated within C functions (library or user-defined) and these functions can be called (referenced/invoked) within the case clauses.

3C. Repetition Control

While, Do-while and For

3c: OutlineReviewNested while and do-while control structuresThe for control structure

3c. RepetitionRepetition logic may be of two forms

Pre-condition testing : enter, or re-enter, the loop body if the condition is true.

Post-condition testing : enter the loop body in all cases (performing the body a minimum of once), then repeat the loop body only if the condition is true.

C supports three forms of repetition control structures whiledo-while for

Repetition : while while ( condition_expression )

statement ;

while ( condition_expression ) { statement1 ; ...... statementN ; }

cond

process

FALSE

TRUE

Repetition : do-while do

statement ; while ( condition_expression ) ;

do { statement1 ; ...... statementN ; } while ( condition_expression ) ;

MUST execute the body (process) at least once!

cond

process

FALSE

TRUE

Repetition : NestingConsider a do-while that contains another do-

while structure:

cond

FALSE

TRUE

cond

process

FALSE

TRUE

Nested do-while loop.

Repetition : NestingNesting of control structures within other control

structures occurs quite often in programmingLoop structures require care in order to ensure that

all control conditions are properly establishedAlways remember to check that any statements that

must be performed outside the formal control structure (eg. initializations) are strongly coupled to the structure.

Inner loop structures may reference variables that are controlled by outer loop structures. In such cases special attention must be paid to the interface between the structures.

Stop

Process_k

Process_k+1

InterfaceLogic_k

Process_1

Start

Repetition : NestingProblem: Find the average of the averages of

lists of non-negative real numbers.

Each sublist will be terminated by a negative value

Each sublist must contain at least one non-negative value, except the last (final) sublistThe last sublist will consist only of the delimiter

sentinel negative number. This allows for the scenario where a user starts the program and then decides not to enter any values – they must enter a negative number, however.

1.04.3-15.637.5326.18.3-3.14159975.64478.524.6789-53.5-1.0

1.04.3-15.637.5326.18.3-3.14159975.64478.524.6789-53.5-1.0

Repetition : Nesting Problem: Find the average of the averages of lists of non-

negative real numbers.

Variables: int NumLists, Num ;

float Value, Ave, Sum, AveSum, AveAve ;

Initializations:Start of Program: Within Program:

NumLists = 0 ; Num = 0 ; AveSum = 0.0 ; Sum = 0.0 ;

1.04.3-15.637.5326.18.3-3.14159975.64478.524.6789-53.5-1.0

Repetition : NestingAverage of a sub-list terminated by negative sentinel:

Num = 0 ; Sum = 0.0 ; do { printf( “Enter a number (<0 to quit) : ” ; scanf( “%f”, &Value ) ; if ( Value >= 0 ) { Sum = Sum + Value ; Num++ ; } } while ( Value >= 0 ) ; if ( Num > 0 ) Ave = Sum / Num ;

1.04.3-15.637.5326.18.3-3.14159975.64478.524.6789-53.5-1.0

Repetition : NestingAverage of a sub-list terminated by negative sentinel:

Num = 0 ; Sum = 0.0 ; do { printf( “Enter a number (<0 to quit) : ” ; scanf( “%f”, &Value ) ; if ( Value >= 0 ) { Sum = Sum + Value ; Num++ ; } } while ( Value >= 0 ) ; if ( Num > 0 ) Ave = Sum / Num ;

Treat this code as a unit (module).

Repetition : NestingAverage of sub-list averages (terminated by negative

sentinel):

NumLists = 0 ; AveSum = 0.0 ; do { /* Input sublist and find its average */ if ( Num > 0 ) { AveSum = AveSum + Ave ; NumLists++ ; } } while ( Num > 0 ) ; if ( NumLists > 0 ) AveAve = AveSum / NumLists ; printf ( “Average of averages = %f\n”, AveAve ) ;

1.04.3-15.637.5326.18.3-3.14159975.64478.524.6789-53.5-1.0

Repetition : NestingMerge codes together:

NumLists = 0 ; AveSum = 0.0 ; do { /* Input sublist and find its average */ Num = 0 ; Sum = 0.0 ; do { printf( “Enter a number (<0 to quit) : ” ; scanf( “%f”, &Value ) ; if ( Value >= 0 ) { Sum = Sum + Value ; Num++ ; } } while ( Value >= 0 ) ; if ( Num > 0 ) Ave = Sum / Num ; if ( Num > 0 ) { AveSum = AveSum + Ave ; NumLists++ ; } } while ( Num > 0 ) ; if ( NumLists > 0 ) AveAve = AveSum / NumLists ; printf ( “Average of averages = %f\n”, AveAve ) ;

NumLists = 0 ; AveSum = 0.0 ; do { /* Input sublist and find its average */ Num = 0 ; Sum = 0.0 ; do { printf( “Enter a number (<0 to quit) : ” ; scanf( “%f”, &Value ) ; if ( Value >= 0 ) { Sum = Sum + Value ; Num++ ; } } while ( Value >= 0 ) ; if ( Num > 0 ) Ave = Sum / Num ; if ( Num > 0 ) { AveSum = AveSum + Ave ; NumLists++ ; } } while ( Num > 0 ) ; if ( NumLists > 0 ) AveAve = AveSum / NumLists ; printf ( “Average of averages = %f\n”, AveAve ) ;

To complete the program, place the code into main and

add necessary #include and

documentation.

Repetition : Nesting NumLists = 0 ; AveSum = 0.0 ; do { /* Input sublist and find its average */ Num = 0 ; Sum = 0.0 ; do { printf( “Enter a number (<0 to quit) : ” ; scanf( “%f”, &Value ) ; if ( Value >= 0 ) { Sum = Sum + Value ; Num++ ; } } while ( Value >= 0 ) ; if ( Num > 0 ) Ave = Sum / Num ; if ( Num > 0 ) { AveSum = AveSum + Ave ; NumLists++ ; } } while ( Num > 0 ) ; if ( NumLists > 0 ) AveAve = AveSum / NumLists ; printf ( “Average of averages = %f\n”, AveAve ) ;

It may be useful to examine the code

to clean up any obvious

inefficiences.

Repetition : Nesting NumLists = 0 ; AveSum = 0.0 ; do { /* Input sublist and find its average */ Num = 0 ; Sum = 0.0 ; do { printf( “Enter a number (<0 to quit) : ” ; scanf( “%f”, &Value ) ; if ( Value >= 0 ) { Sum = Sum + Value ; Num++ ; } } while ( Value >= 0 ) ; if ( Num > 0 ) { Ave = Sum / Num ; AveSum = AveSum + Ave ; NumLists++ ; } } while ( Num > 0 ) ; if ( NumLists > 0 ) AveAve = AveSum / NumLists ; printf ( “Average of averages = %f\n”, AveAve ) ;



inefficiences.

Repetition : Nesting NumLists = 0 ; AveSum = 0.0 ; do { /* Input sublist and find its average */ Num = 0 ; Sum = 0.0 ; do { printf( “Enter a number (<0 to quit) : ” ; scanf( “%f”, &Value ) ; if ( Value >= 0 ) { Sum = Sum + Value ; Num++ ; } } while ( Value >= 0 ) ; if ( Num > 0 ) { AveSum += Sum / Num ; NumLists++ ; } } while ( Num > 0 ) ; if ( NumLists > 0 ) AveAve = AveSum / NumLists ; printf ( “Average of averages = %f\n”, AveAve ) ;



inefficiences.

Repetition : NestingBe systematic

Top-DownBottom-UpStepwise Refinement

Test your algorithms and codingsUse simple tests first, then add complexityMake sure special cases are treated

Clean up code once you have the basic idea working.

Repetition : for for ( init_stmt ; cond_expr ; update_stmt )

statement ;

for ( init_stmt ; cond_expr ; update_stmt ) { statement1 ; ...... statementN ; }

COND

INITIALIZE

PROCESS

UPDATE

T

F

Repetition : forExample: Find the sum of all integers from 1 to 10.

int Sum = 0, k ;

for ( k = 1 ; k <= 10 ; k++ ) Sum = Sum + k ;

Repetition : forExample: Find the sum of all integers from 1 to 10.

int Sum, k ;

for ( k = 1, Sum = 0 ; k <= 10 ; k++ ) Sum = Sum + k ;

This form has the advantage that it localizes the initialization of Sum to the actual location of the for structureOtherwise, the programmer might forget to do this if the

for is repeated within the program

Repetition : forExample: Find the sum of all odd integers from 1 to

10.

int Sum, k ;

for ( k = 1, Sum = 0 ; k <= 10 ; k += 2 ) Sum = Sum + k ;

Repetition : forExample: Find the sum of all odd integers from 1 to

10.

int Sum, k ;

/* OR, recognizing that (2k-1) is always odd */

for ( k = 1, Sum = 0 ; k <= 5 ; k++) Sum = Sum + k + k - 1 ;

Repetition : forSimplified syntax:

for ( Slot1 ; Slot2 ; Slot3 ) Stmt ;

Each Slot may contain an executable expression or assignment expression

Each Slot may be emptyUse with careful planning and make sure you know

what you are doingThe Stmt is optional

There may be no Stmt, but the semi-colon is mandatory!

Repetition : forComplex syntax:

for ( init_list ; cond ; update_list ) .....

for ( init_list ; init_cond ; update_list ) .....

Repetition : for for ( init_list ; cond ; update_list ) .....

In C, a list is a set of elements separated by commas

The first component (slot) of the for structure may be used to initialize several variablesThe elements may be executable expressions and

assignment expressions

for ( k = 1, Sum = 0 ; k <= 10 ; k++ ) Sum = Sum + k ;

Repetition : for for ( init_list ; cond ; update_list ) .....

The last component (slot) of the for structure may be used to update several variablesThe elements may be executable expressions and

assignment expressions

for ( k = 1, Sum = 0 ; k <= 10 ; k++, Sum += k ) ;

Repetition : for for ( init_list ; init_cond ; update_list ) .....

The middle component (slot) of the for structure may be used to initialize (assign) a value to a variable and then test it as a condition

for ( ; (Ch = getchar()) && ((Ch != ‘q’) || (Ch != ‘Q’)) ; ) printf ( “Enter q or Q to quit >” ;

Repetition : forThe for control structure has an interesting

relationship to CPU register hardware and code optimization

Consider: for ( k = 0 ; k < N ; k++ ) Statement ;

If the variable k is modified only by the for structure and if N is left constant (invariant) within the Statement, the CPU performs all updates on k and comparisons (k<N) within the CPU registers. This avoids the need to transfer data back and forth from

RAM to CPU and thereby saves time.

RAM CPUBUS

3D. Break

Break and ContinueC defines two instruction statements that cause

immediate, non-sequential alteration of normal sequential instruction processing

Break LogicExecution of a break ; statement at any location in a loop-structure

causes immediate exit from the loop-structure. Break is also used to exit from a switch structure.

Continue LogicExecution of a continue ; statement at any location in a loop-

structure causes execution to continue at the beginning of the loop structure (at the next loop iteration) while skipping the remaining statements.

Break and ContinueContinue Logic

Execution of a continue ; statement at any location in a loop-structure causes execution to continue at the beginning of the loop structure (at the next loop iteration) while skipping the remaining statements.

for ( k = 0 ; k < 5 ; k++ ) { if ( k == 3 ) continue ; printf ( “%d, ”, k ) ; }

Produces output : 0, 1, 2, 4

BreakBreak Logic

Execution of a break ; statement at any location in a loop-structure causes immediate exit from the loop-structure

for ( k = 0 ; k < 10 ; k++ ) { if ( k == 5 ) break ; printf ( “%d, ”, k ) ; }

Produces output : 0, 1, 2, 3, 4

BreakBreak Logic

Execution of a break ; statement at any location in a switch-structure causes immediate exit from the switch-structure

switch ( cond ) { ...... Case 53 : Stmt ; ..... break ; ...... }

And now for something completely different ...

Enter

3E. Input and Output

Standard I/O and Redirected file I/O, Formatting output

Standard I/OThe C language provides definition of several

functions and pre-defined constants in the <stdio.h> library system

These are used for programming input and output of data through the standard I/O system

printf, putchar (stdout)

scanf, getchar (stdin) EOF (end of file constant)

Ctrl D

(Unix systems)

Standard I/OOutput (stdout) :

Normally (default) the standard output device is the computer’s monitor (VDU: video display unit)More rarely, a printer may be the standard output device

Most monitors use a matrix of picture elements, or pixels. A beam of electrons is swept repeatedly across and down

the screen, interacting with the chemicals at the pixel locations causing them to flouresce for brief moments.

The screen is refreshed many times each second, thereby fooling the brain.

Standard I/OOutput (stdout) :

Groups of pixels (rectangular areas) are used to represent graphical symbols such as printed characters.

The technical aspects of programming the computer have been solved. The appropriate programming functions are provided in the standard input output library

#include <stdio.h>

Standard I/O putchar()The putchar function is useful for outputting single

characters. The need to do this occurs quite often.Text processingSpecial forms of output from programs

char Ch = ‘w’ ;

putchar( Ch ) ;

Outputs a single character: wThe cursor position is immediately after the outputted

character

Standard I/O printf()The printf function is used for outputting text

Characters (strings of characters)Conversion of integer and real valued data from

machine representations to printable formsControl characters

Example:

printf ( “The average of %d and %d is %f\n”, A, B, (A+B)*0.5 ) ;

Standard I/O printf()General Syntax:

printf ( FormatString [, Op1 [ , ... OpN ]] ) ;

FormatString :: a string of characters, including control characters, and data format specifier codes

OpK :: a set of operands (the K’th operand)Operands may be variables, computable expressions or functions

Operands are optional, but the number of operands must match the number of specifier codes.

Standard I/O printf()The printf() function is straightforward to use for simple

applications

Prompts : printf( “Enter a value:” ) ;

Non-formatted output

printf( “Sum of %d and %d is %d\n”, A, B, A+B ) ;

More complicated applications must include formatting of the output to produce better looking reports.

Standard I/OIn contrast to output, input is handled by the

standard input system (stdin).

Input one character to a char variable Ch:

Ch = getchar() ;

Input of numeric data, or more than one character (a character string) is accomplished using

scanf()

Standard I/O scanf()The scanf() function permits input of various kinds

of data

Each data type to be inputted is indicated by a data type specifier code

%d %f %c %lf

Actual input must be provided in character (text) form.

Standard I/O EOF<stdio.h> provides definition of a special

constant, called the end-of-file marker, EOF.

The actual value of EOF may vary on different systems, but is typically the value -1.

The getchar() and scanf() functions return a value which can be assigned to a variable (int or char)This variable can then be compared with EOF to “detect”

the end-of-file condition

while ( ( Ch = getchar() ) != EOF ) { ..... }

Redirected File I/OThe standard I/O system of Unix allows the re-

direction of I/O from typical devices (KBD, VDU) to files.

This is accomplished at the command line when the program is started

%a.out < infile.dat

%a.out > outfile.dat

%a.out < infile.dat > outfile.dat

Redirected File I/ORedirected I/O disconnects the default I/O

Input: cannot use KBDOutput: cannot use VDU

If redirected output is used, the output must be sent to a text file. This file can then be read using an editor.

If redirected input is used, the input text file must be prepared beforehand using an editor.

Formatted OutputFormatting of output is discussed in Chapter 9 of

the required textbook for the course.

Students are assigned this chapter to read and experiment with.Chapter 9.1 – 9.6, 9.8, 9.10If time permits, we will discuss this further in the

lectureLaboratory exercises will provide additional

practice, as will assignments.

3 : Summary

Lecture 3: SummaryAssigned Reading

PREVIOUS: Concepts, data, algorithms, basic C language

Chapters 1-3 (complete)BASICS:

Structured programming Program control

Chapter 4 (complete) Standard I/O and Formatted Output

Chapter 9.1 – 9.6, 9.8, 9.10

NEXT: Functions – Chapter 5

60-140 Lecture 3 Dr. Robert D. Kent Program Control - Details.

Documents

Transcript of 60-140 Lecture 3 Dr. Robert D. Kent Program Control - Details.