Teacher: Dr. Shrestha
Fall Semester, 2000
Class hour: 5:00 - 10:00 Friday
Materials for November 10, 2000
Chapter (2) (Contd.)
*****************************
********************
Control Structures
Save days' work in your diskette !
SENTINEL-CONTROLLED REPETITION
- Sentinel-controlled repetition is often called indefinite repetition
because the number of repetitions is not known before the loop begins
executing. EXAMPLE IDEA PSEUDOCODE
Initialize total to zero
Input the first grade (possibly the sentinel)
If the counter is not equal to zero (to avoid division by zero) C++ PROGRAM
int main()
// initialization phase
// processing phase
while ( grade != -1) { // loop until -1 is entered
// termination phase
}
return 0; //indicate program ended successfully The option "ios::fixed" causes a floating point value to be output in
FIXED POINT FORMAT. The "ios::showpoint" option forces the decimal point
and trailing zeros to print even if the value is a whole number amount
such as 85.00. NESTED CONTROL STRUCTURE You have been given a list of 10 students. Next to each name is written
a 1 if the student passed the exam and a 2 if the student failed. Write
the program such that it analyzes the results of the exam as follows:
(1) Input each test result (i.e. a 1 or a 2). Display the message
"Enter result" on the screen each time the program requests another test
result. Observations
(1) The program must process 10 test results. A counter-controlled
loop is to be used. PSEUDOCODE
Initialize passes to zero
While student counter is less than or equal to ten
If the student passed
Add one to student counter
Print the number of passes
If more than eight students passed C++ PROGRAM
- A repetition procedure for solving a problem by using a sentinel
value also called a signal value, a dummy value, or a flag value to indicate
"end of data entry".
- Develop a class averaging program that will process an
arbitrary number of grades each time the program is run.
- The sentinel value must be chosen so that it cannot be confused
with an acceptable input value, As grades on a quiz are normally nonnegative
integers, -1 is an acceptable value for this problem. Thus, a run of the
class average program might process a stream of inputs such as 90, 85, 95,
70, and -1. The program would then compute and print the class average for
the grades 90, 85, 95, and 70. The program will see the flag -1 not as a
grade input but as a signal to indicate end of the grade data.
- Development of well-structured programs is usually done using a
method called top-down, stepwise refinement as is done
in the pseudocode below.
Initialize counter to zero
While the user has not as yet entered the sentinel
Add this grade into the running total
Add one to the grade counter
Input the next grade (possibly the sentinel)
Set the avergae to the total divided by the counter
Print the average
else
Print "No grades were entered"
// Class average program with sentinel controlled repetition.
# include <iostream.h>
# include <iomanip.h>
// This preprocessor directive is needed to produce parametrized stream
// manipulator i.e. print results to a desired number of precision, The
// default is 6 digits.
{
int total, // sum of grades
gradeCounter, // number of grades entered
grade; // one grade
float average; // average of grades
total = 0; // Clear total
gradeCounter = 1; // prepare to loop
cout << "Enter grade, type -1 to indicate the end: ";
cin >> grade; // input grade
total = total + grade; // add grade to total
gradeCounter = gradeCounter + 1; // increment counter
cout << "Enter grade, type -1 to indicate the end: ";
// In a sentinel controlled loop, the prompts requesting data
// entry should explicitly remind the user what the sentinel
// value is.
cin >> grade;
}
if ( gradeCounter != 0 ) {
// A special operator called a cast operator will be used to handle
// the average calculation. This results in a floating point value
// for the average as desired.
average = static_cast< float >( total ) / gradeCounter;
cout << "Class average is " << setprecision( 2 )
// Two digits of precision
<< setiosflags( ios::fixed | ios::showpoint )
// This is a stream manipulator. This sets two output
// formatting options because of | symbol.
<< average << endl;
else
cout << "No grades were entered" endl;
}
Examination Result Problem
(2) Count the number of test results of each type.
(3) Display a summary of the test results indicating the number of
students who passed and the number of students who failed.
(4) If more than 8 students passed the exam, print the message "Raise
tuition."
(2) Each test result is a number - either a 1 or a 2. Each time the
program reads a test result, the program must determine if the number is
a 1 or a 2. We test for a 1 in our algorithm. if the number is not a 1,
we assume that it is a 2.
(3) Two counters are used - one to count the number of students who
passed the exam and one to count the number of students who failed the
exam.
(4) After the program has processed all the results, it must decide
if more than 8 students passed the exam.
Initialize failures to zero
Initialize student counter to one
Input the next exam result
Add one to passes
else
Add one to failures
Print the number of failures
Print "Raise tuition"
//Analysis of examination results
#include <iostream.h>int main()
{
// initialize variables in declarations
int passes = 0, // number of passes
failures = 0, // number of failures
studentCounter = 1, // student counter
result; // one exam result
// process 10 students; counter-controlled loop
while ( studentCounter <=10 ) {
cout << "Enter result (1=pass, 2=fail): ";
cin >> result;
if ( result == 1) // if/else nested in while
passes = passes + 1;
else
failures = failures + 1;
studentCounter = studentCounter + 1;
}
// termination phase
cout << "Passed " << passes << endl;
cout << "Failed " << failures << endl;
if ( passes > 8 )
cout ,, "Raise tuition " << endl;
return 0;
// successful termination
}
ASSIGNMENT OPERATORS
The statement
c = c + 3;
can be abbreviated with the addition assignment operator += as
c += 3;
Any statement of the form
variable = variable operator expression;
where operator is one of the binary operators +, -, *, /, or %, can be
written in the form
variable operator= expression;
INCREMENT AND DECREMENT OPERATORS
If a varaible a is incremented by 1, the increment operator ++
can be used rather than the expressions c = c + 1 or c += 1.
operator placed before the variable - preincrement or predecrement
operator placed afte the variable - postincrement or post decrement
++a -> increment a by 1, then use the new variable of a in
the expression in which a resides.
a++ -> use the current value of a in the expression in which a
resides, then increment a by 1.
ESSENTIALS OF COUNTER-CONTROLLED REPETITION
Counter-controlled repetition requires:
1. The name of a control variable.
2. The initial value of the control variable.
3. The condition that tests for the final value of the control variable.
4. The increment or decrement by which the control varaible is modified
each time through the loop.
Example
int main()
{
int counter = 1; //initialization
while ( counter <= 10 ) { // repetition condition
cout << counter << endl;
++counter; // increment
}
return 0;
}
THE for REPETITION STRUCTURE Example
int main()
{
// Initialization, rewpetition condition, and incrementing
// are all included in the for structure header.
for ( int counter = 1; counter <=10; counter++ )
cout << counter << endl;
return 0;
}
The general format for the for structure is THE switch MULTIPLE-SELECTION STRUCTURE Occasionally, an algorithm will contain a series of decisions in which
a variable or expression is tested separately for each of the
constant integral values it may assume, and different actions are
taken. C++ provides the switch multiple selection structure to
handle such decision making. The switch structure consists of case labels, and an optional default
case.
//counter-controlled repetition
# include <iostream.h>
The for repetition structure handles all the details of
counter-controlled repetition.
// Counter-controlled repetition with the for structure
3include <iostream.h>
for ( expression1; expression2; expression3)
statement
THANKS FOR STOPPING BY !
TAKE CARE !
AFTER TODAY'S CLASS IS OVER, LOOK AT THE ASSIGNMENT.