CISC 181 Introduction to Computer Science Dr Mc

CISC 181 Introduction to Computer Science Dr. Mc. Coy Lecture 4 September 10, 2009 1

2 2. 11 Assignment Operators • Assignment expression abbreviations – Addition assignment operator c = c + 3; abbreviated to c += 3; • Statements of the form variable = variable operator expression; can be rewritten as variable operator= expression; • Other assignment operators d e f g -= *= /= %= 4 5 3 9 2003 Prentice Hall, Inc. All rights reserved. (d (e (f (g = = d e f g * / % 4) 5) 3) 9)

3 2. 7 while Repetition Structure • Repetition structure – Action repeated while some condition remains true – Psuedocode while there are more items on my shopping list Purchase next item and cross it off my list – while loop repeated until condition becomes false • Example int product = 2; while ( product <= 1000 ) product = 2 * product; 2003 Prentice Hall, Inc. All rights reserved.

4 2. 7 The while Repetition Structure 2003 Prentice Hall, Inc. All rights reserved.

2. 8 Formulating Algorithms (Counter. Controlled Repetition) • Counter-controlled repetition – Loop repeated until counter reaches certain value • Definite repetition – Number of repetitions known • Example A class of ten students took a quiz. The grades (integers in the range 0 to 100) for this quiz are available to you. Determine the class average on the quiz. 2003 Prentice Hall, Inc. All rights reserved. 5

2. 8 Formulating Algorithms (Counter. Controlled Repetition) • Pseudocode for example: Set total to zero Set grade counter to one While grade counter is less than or equal to ten Input the next grade Add the grade into the total Add one to the grade counter Set the class average to the total divided by ten Print the class average • Next: C++ code for this example 2003 Prentice Hall, Inc. All rights reserved. 6

1 2 3 // Fig. 2. 7: fig 02_07. cpp // Class average program with counter-controlled repetition. #include <iostream> 4 5 6 7 using std: : cout; using std: : cin; using std: : endl; 8 9 10 11 12 13 14 15 // function main begins int main() { int total; // int grade. Counter; // int grade; // int average; // 16 17 18 19 Outline fig 02_07. cpp (1 of 2) program execution sum of grades input by user number of grade to be entered next grade value average of grades // initialization phase total = 0; // initialize total grade. Counter = 1; // initialize loop counter 20 2003 Prentice Hall, Inc. All rights reserved. 7

21 22 23 24 25 26 27 // processing phase while ( grade. Counter <= 10 ) { cout << "Enter grade: "; cin >> grade; total = total + grade; grade. Counter = grade. Counter + 1; } 28 29 30 // termination phase average = total / 10; 31 32 33 // display result cout << "Class average is " << average << endl; 34 35 return 0; 36 37 // indicate } // end function main Enter Enter Enter Class grade: 98 grade: 76 grade: 71 grade: 87 grade: 83 grade: 90 grade: 57 grade: 79 grade: 82 grade: 94 average is 81 // // // loop 10 times prompt for input read grade from user add grade to total increment counter Outline fig 02_07. cpp (2 of 2) fig 02_07. cpp output (1 of 1) // integer division The counter gets incremented each time the loop executes. program ended successfully Eventually, the counter causes the loop to end. 2003 Prentice Hall, Inc. All rights reserved. 8

2. 9 Formulating Algorithms (Sentinel. Controlled Repetition) • Suppose problem becomes: Develop a class-averaging program that will process an arbitrary number of grades each time the program is run – Unknown number of students – How will program know when to end? • Sentinel value – Indicates “end of data entry” – Loop ends when sentinel input – Sentinel chosen so it cannot be confused with regular input • -1 in this case 2003 Prentice Hall, Inc. All rights reserved. 9

2. 9 Formulating Algorithms (Sentinel. Controlled Repetition) • Top-down, stepwise refinement – Begin with pseudocode representation of top Determine the class average for the quiz – Divide top into smaller tasks, list in order Initialize variables Input, sum and count the quiz grades Calculate and print the class average 2003 Prentice Hall, Inc. All rights reserved. 10

2. 9 Formulating Algorithms (Sentinel. Controlled Repetition) • Many programs have three phases – Initialization • Initializes the program variables – Processing • Input data, adjusts program variables – Termination • Calculate and print the final results – Helps break up programs for top-down refinement 2003 Prentice Hall, Inc. All rights reserved. 11

2. 9 Formulating Algorithms (Sentinel. Controlled Repetition) • Refine the initialization phase Initialize variables goes to Initialize total to zero Initialize counter to zero • Processing Input, sum and count the quiz grades goes to Input the first grade (possibly the sentinel) 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) 2003 Prentice Hall, Inc. All rights reserved. 12

2. 9 Formulating Algorithms (Sentinel. Controlled Repetition) • Termination Calculate and print the class average goes to If the counter is not equal to zero Set the average to the total divided by the counter Print the average Else Print “No grades were entered” • Next: C++ program 2003 Prentice Hall, Inc. All rights reserved. 13

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 // Fig. 2. 9: fig 02_09. cpp // Class average program with sentinel-controlled repetition. #include <iostream> using Outline 14 fig 02_09. cpp (1 of 3) std: : cout; std: : cin; std: : endl; std: : fixed; #include <iomanip> // parameterized stream manipulators using std: : setprecision; // sets numeric output precision // function main begins program execution int main() Data type double used to { int total; // sum of grades represent decimal numbers. int grade. Counter; // number of grades entered int grade; // grade value 20 21 double average; 22 23 24 25 // initialization phase total = 0; // initialize total grade. Counter = 0; // initialize loop counter // number with decimal point for average 2003 Prentice Hall, Inc. All rights reserved.

26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 // processing phase // get first grade from user cout << "Enter grade, -1 to end: " ; cin >> grade; Outline // prompt for input // read grade from user 15 fig 02_09. cpp (2 of 3) // loop until sentinel value read from user while ( grade != -1 )static_cast<double>() treats total as a { double temporarily (casting). total = total + grade; // add grade to total grade. Counter = grade. Counter + 1; // increment counter Required because dividing two integers truncates the cout << "Enter grade, -1 to end: " ; remainder. cin >> grade; } // end while // prompt for input // read next grade. Counter is an int, but it gets promoted to double. // termination phase // if user entered at least one grade. . . if ( grade. Counter != 0 ) { // calculate average of all grades entered average = static_cast< double >( total ) / grade. Counter; 2003 Prentice Hall, Inc. All rights reserved.

49 50 51 // display average with two digits of precision cout << "Class average is " << setprecision( 2 ) << fixed << average << endl; 52 53 } // end if part of if/else 54 55 56 else // if no grades were entered, output appropriate message cout << "No grades were entered" << endl; 57 58 return 0; 59 60 Outline 16 fig 02_09. cpp (3 of 3) fig 02_09. cpp output (1 of 1) // indicate program ended successfully } // end function main Enter Enter Enter Class grade, -1 to end: grade, -1 to end: grade, -1 to end: average is 82. 50 75 94 97 88 70 64 83 89 -1 setprecision(2)prints two digits past fixed forces output to decimal point (rounded to fit precision). print in fixed point format (not scientific notation). Programs that use this must include Also, forces trailing zeros <iomanip> and decimal point to print. Include <iostream> 2003 Prentice Hall, Inc. All rights reserved.

Example Program • Write a program that uses a sentinelcontrolled while loop to read in a number of (positive) integers from the terminal and computes (and outputs) both the smallest and largest. • User should type -1 as input to indicate there are no more numbers. 17

Exercise 2. 16 • Drivers are concerned with the mileage obtained by their automobiles. One driver has kept track of several tankfuls of gasoline by recording miles driven and gallons used for each tankful. Develop a C++ program that uses a while structure to input the miles driven and gallons used for each tankful. The program should calculate and display the miles per gallon obtained for each tankful. After processing all input information, the program should 18

Example output Ex. 2. 16 Enter the gallons used (-1 to end): 12. 8 Enter miles driven: 287 The miles / gallon for this tank was 22. 4219 Enter the gallons used (-1 to end): 10. 3 Enter miles driven: 200 The miles / gallon for this tank was 19. 4175 Enter the gallons used (-1 to end): 5 Enter miles driven: 120 The miles / gallon for this tank was 24 Enter the gallons used (-1 to end): -1 The overall average miles/gallon was 21. 6014 19

Exercise 2. 16 • Drivers are concerned with the mileage obtained by their automobiles. One driver has kept track of several tankfuls of gasoline by recording miles driven and gallons used for each tankful. Develop a C++ program that uses a while structure to input the miles driven and gallons used for each tankful. The program should calculate and display the miles per gallon obtained for each tankful. After processing all input information, the program should calculate and print the combined miles 20 per gallon obtained for all tankfuls.

Example output Ex. 2. 16 Enter the gallons used (-1 to end): 12. 8 Enter miles driven: 287 The miles / gallon for this tank was 22. 4219 Enter the gallons used (-1 to end): 10. 3 Enter miles driven: 200 The miles / gallon for this tank was 19. 4175 Enter the gallons used (-1 to end): 5 Enter miles driven: 120 The miles / gallon for this tank was 24 Enter the gallons used (-1 to end): -1 The overall average miles/gallon was 21. 6014 21

2. 13 Essentials of Counter-Controlled Repetition • Counter-controlled repetition requires – – Name of control variable/loop counter Initial value of control variable Condition to test for final value Increment/decrement to modify control variable when looping 2003 Prentice Hall, Inc. All rights reserved. 22

1 2 3 // Fig. 2. 16: fig 02_16. cpp // Counter-controlled repetition. #include <iostream> 4 5 6 using std: : cout; using std: : endl; 7 8 9 10 11 // function main begins program execution int main() { int counter = 1; // initialization 12 13 14 15 while ( counter <= 10 ) { cout << counter << endl; ++counter; 16 17 } // end while 18 19 return 0; 20 21 Outline fig 02_16. cpp (1 of 1) // repetition condition // display counter // increment // indicate successful termination } // end function main 2003 Prentice Hall, Inc. All rights reserved. 23

1 2 3 4 5 6 7 8 9 10 Outline fig 02_16. cpp output (1 of 1) 2003 Prentice Hall, Inc. All rights reserved. 24

25 2. 14 for Repetition Structure • General format when using for loops for ( initialization; Loop. Continuation. Test; increment ) statement • Example for( int counter = 1; counter <= 10; counter++ ) cout << counter << endl; – Prints integers from one to ten No semicolon after last statement 2003 Prentice Hall, Inc. All rights reserved.

1 2 3 // Fig. 2. 17: fig 02_17. cpp // Counter-controlled repetition with the for structure. #include <iostream> 4 5 6 using std: : cout; using std: : endl; 7 8 9 10 11 12 // function main begins program execution int main() { // Initialization, repetition condition and incrementing // are all included in the for structure header. 13 14 15 for ( int counter = 1; counter <= 10; counter++ ) cout << counter << endl; 16 17 return 0; 18 19 Outline fig 02_17. cpp (1 of 1) // indicate successful termination } // end function main 2003 Prentice Hall, Inc. All rights reserved. 26

1 2 3 4 5 6 7 8 9 10 Outline fig 02_17. cpp output (1 of 1) 2003 Prentice Hall, Inc. All rights reserved. 27

28 2. 14 for Repetition Structure • for loops can usually be rewritten as while loops initialization; while ( loop. Continuation. Test){ statement increment; } • Initialization and increment – For multiple variables, use comma-separated lists for (int i = 0, j = 0; j + i <= 10; j++, i++) cout << j + i << endl; 2003 Prentice Hall, Inc. All rights reserved.

29 2. 14 for Repetition Structure 2003 Prentice Hall, Inc. All rights reserved.

1 2 3 // Fig. 2. 20: fig 02_20. cpp // Summation with for. #include <iostream> 4 5 6 using std: : cout; using std: : endl; 7 8 9 10 11 // function main begins program execution int main() { int sum = 0; // initialize sum Outline fig 02_20. cpp (1 of 1) 12 13 14 15 // sum even integers from 2 through 100 for ( int number = 2; number <= 100; number += 2 ) sum += number; // add number to sum 16 17 18 cout << "Sum is " << sum << endl; return 0; 19 20 fig 02_20. cpp output (1 of 1) // output sum // successful termination } // end function main Sum is 2550 2003 Prentice Hall, Inc. All rights reserved. 30

Practice writing for’s • Vary control variable from 1 to 10 by increments of 1 • Vary control variable from 100 to 0 by 5’s • Vary control variable over values: 4, 8, 12, 16, 20, 24, 28, 32 • Vary control variable over values: 70, 60, 50, 40, 30, 20 • Vary control variable from 57 to 43 by 1’s 31

Exercise 2. 28 • Write a program that reads in the size of the side of a square and then prints a hollow square of that size out of asterisks and blanks. Your program should work for squares of all side sizes between 1 and 20. 32

33 2. 16 switch Multiple-Selection Structure • switch – Test variable for multiple values – Series of case labels and optional default case switch ( variable ) { case value 1: statements break; case value 2: case value 3: statements break; default: statements break; // taken if variable == value 1 // necessary to exit switch // taken if variable == value 2 or == value 3 // taken if variable matches no other cases } 2003 Prentice Hall, Inc. All rights reserved.

34 2. 16 switch Multiple-Selection Structure 2003 Prentice Hall, Inc. All rights reserved.

35 2. 16 switch Multiple-Selection Structure • Example upcoming – Program to read grades (A-F) – Display number of each grade entered • Details about characters – Single characters typically stored in a char data type • char a 1 -byte integer, so chars can be stored as ints – Can treat character as int or char • 97 is the numerical representation of lowercase ‘a’ (ASCII) • Use single quotes to get numerical representation of character cout << "The character (" << 'a' << ") has the value " << static_cast< int > ( 'a' ) << endl; Prints The character (a) has the value 97 2003 Prentice Hall, Inc. All rights reserved.

1 2 3 // Fig. 2. 22: fig 02_22. cpp // Counting letter grades. #include <iostream> 4 5 6 7 using std: : cout; using std: : cin; using std: : endl; 8 9 10 11 12 13 14 15 16 17 // function main begins program execution int main() { int grade; // one grade int a. Count = 0; // number of As int b. Count = 0; // number of Bs int c. Count = 0; // number of Cs int d. Count = 0; // number of Ds int f. Count = 0; // number of Fs 18 19 20 Outline fig 02_22. cpp (1 of 4) cout << "Enter the letter grades. " << endl << "Enter the EOF character to end input. " << endl; 21 2003 Prentice Hall, Inc. All rights reserved. 36

22 23 // loop until user types end-of-file key sequence while ( ( grade = cin. get() ) != EOF ) { break causes switch to end and Outline the program continues with the first grade was input statement after the switch structure. fig 02_22. cpp // switch structure nested in while (2 of 4) 24 25 26 // determine which switch ( grade ) { 27 28 29 30 31 case 'A': case 'a': ++a. Count; break; // // 32 33 34 35 36 case 'B': case 'b': ++b. Count; break; // // Assignment statements have a value, which is the same as grade was uppercase B the variable on the left of the or lowercase b =. The value of this statement increment b. Count exit switch is the same as the value returned by cin. get(). // // grade was uppercase C or lowercase c This can also be used to increment c. Count initialize multiple variables: exit switch Compares grade (an int) to 37 38 the numerical representations case 'C': of A and a. 39 case 'c': 40 ++c. Count; 41 break; 42 grade was uppercase A or lowercase a increment a. Count necessary to exit switch cin. get() uses dot notation (explained chapter 6). This function gets 1 character from the keyboard (after Enter pressed), and it is assigned to grade. cin. get() returns EOF (end-offile) after the EOF character is input, to indicate the end of data. EOF may be ctrl-d or ctrl-z, depending on your OS. a = b = c = 0; 2003 Prentice Hall, Inc. All rights reserved. 37

43 44 45 46 case 'D': case 'd': ++d. Count; break; // // grade was uppercase D or lowercase d increment d. Count exit switch This test is necessary because grade was Enter is pressed after each uppercase F or lowercase f letter grade is input. This adds increment f. Count a newline character that must exit switch be removed. Likewise, we want to ignore any whitespace. ignore newlines, 47 48 49 50 51 case 'F': case 'f': ++f. Count; break; // // 52 53 54 55 56 case 'n': case 't': case ' ': break; // // tabs, // and spaces in input Notice the default statement, which // exit switch 57 58 59 60 61 default: // catch all other characters cout << "Incorrect letter grade entered. " << " Enter a new grade. " << endl; break; // optional; will exit switch anyway 62 63 64 65 Outline fig 02_22. cpp (3 of 4) catches all other cases. } // end switch } // end while 66 2003 Prentice Hall, Inc. All rights reserved. 38

67 68 69 70 71 72 73 74 // output summary of results cout << "nn. Totals for each letter grade are: " << "n. A: " << a. Count // display number of << "n. B: " << b. Count // display number of << "n. C: " << c. Count // display number of << "n. D: " << d. Count // display number of << "n. F: " << f. Count // display number of << endl; 75 76 return 0; 77 78 Outline A B C D F grades grades fig 02_22. cpp (4 of 4) // indicate successful termination } // end function main 2003 Prentice Hall, Inc. All rights reserved. 39

Enter the letter grades. Enter the EOF character to end input. a B c C A d f C E Incorrect letter grade entered. Enter a new grade. D A b ^Z Outline fig 02_22. cpp output (1 of 1) Totals for each letter grade are: A: 3 B: 2 C: 3 D: 2 F: 1 2003 Prentice Hall, Inc. All rights reserved. 40

41 2. 17 do/while Repetition Structure • Similar to while structure – Makes loop continuation test at end, not beginning – Loop body executes at least once • Format do { statement } while ( condition ); 2003 Prentice Hall, Inc. All rights reserved.

42 2. 17 do/while Repetition Structure 2003 Prentice Hall, Inc. All rights reserved.

1 2 3 // Fig. 2. 24: fig 02_24. cpp // Using the do/while repetition structure. #include <iostream> 4 5 6 using std: : cout; using std: : endl; 7 8 9 10 11 // function main begins program execution int main() { int counter = 1; // initialize counter fig 02_24. cpp (1 of 1) 12 13 14 15 do { cout << counter << " "; } while ( ++counter <= 10 ); 16 17 cout << endl; 18 19 return 0; 20 21 1 Outline fig 02_24. cpp output (1 of 1) Notice the preincrement in loop-continuation test. // display counter // end do/while // indicate successful termination } // end function main 2 3 4 5 6 7 8 9 10 2003 Prentice Hall, Inc. All rights reserved. 43

44 2. 18 break and continue Statements • break statement – Immediate exit from while, for, do/while, switch – Program continues with first statement after structure • Common uses – Escape early from a loop – Skip the remainder of switch 2003 Prentice Hall, Inc. All rights reserved.

1 2 3 // Fig. 2. 26: fig 02_26. cpp // Using the break statement in a for structure. #include <iostream> 4 5 6 using std: : cout; using std: : endl; 7 8 9 10 // function main begins program execution int main() { Outline fig 02_26. cpp (1 of 2) 11 12 int x; 13 14 15 // loop 10 times for ( x = 1; x <= 10; x++ ) { // x declared here so it can be used after the loop Exits for structure when break executed. 16 17 18 19 // if x is 5, terminate loop if ( x == 5 ) break; // break loop only if x is 5 20 21 cout << x << " "; // display value of x 22 23 } // end for 24 25 cout << "n. Broke out of loop when x became " << x << endl; 2003 Prentice Hall, Inc. All rights reserved. 45

26 27 28 29 return 0; // indicate successful termination } // end function main 1 2 3 4 Broke out of loop when x became 5 Outline fig 02_26. cpp (2 of 2) fig 02_26. cpp output (1 of 1) 2003 Prentice Hall, Inc. All rights reserved. 46

47 2. 18 break and continue Statements • continue statement – Used in while, for, do/while – Skips remainder of loop body – Proceeds with next iteration of loop • while and do/while structure – Loop-continuation test evaluated immediately after the continue statement • for structure – Increment expression executed – Next, loop-continuation test evaluated 2003 Prentice Hall, Inc. All rights reserved.

1 2 3 // Fig. 2. 27: fig 02_27. cpp // Using the continue statement in a for structure. #include <iostream> 4 5 6 using std: : cout; using std: : endl; 7 8 9 10 11 12 // function main begins program execution int main() { // loop 10 times for ( int x = 1; x <= 10; x++ ) { Outline fig 02_27. cpp (1 of 2) Skips to next iteration of the loop. next iteration of loop 13 14 15 16 // if x is 5, continue with if ( x == 5 ) continue; // skip remaining code in loop body 17 18 cout << x << " "; // display value of x 19 20 } // end for structure 21 22 23 cout << "n. Used continue to skip printing the value 5" << endl; 24 25 return 0; // indicate successful termination 2003 Prentice Hall, Inc. All rights reserved. 48

26 27 } // end function main 1 2 3 4 6 7 8 9 10 Used continue to skip printing the value 5 Outline fig 02_27. cpp (2 of 2) fig 02_27. cpp output (1 of 1) 2003 Prentice Hall, Inc. All rights reserved. 49

2. 21 Structured-Programming Summary 2003 Prentice Hall, Inc. All rights reserved. 50

51 2. 21 Structured-Programming Summary • Structured programming – Programs easier to understand, test, debug and modify • Rules for structured programming – Only use single-entry/single-exit control structures – Rules 1) Begin with the “simplest flowchart” 2) Any rectangle (action) can be replaced by two rectangles (actions) in sequence 3) Any rectangle (action) can be replaced by any control structure (sequence, if/else, switch, while, do/while or for) 4) Rules 2 and 3 can be applied in any order and multiple times 2003 Prentice Hall, Inc. All rights reserved.

52 2. 21 Structured-Programming Summary 2003 Prentice Hall, Inc. All rights reserved.

53 2. 21 Structured-Programming Summary 2003 Prentice Hall, Inc. All rights reserved.

54 2. 21 Structured-Programming Summary 2003 Prentice Hall, Inc. All rights reserved.

55 2. 21 Structured-Programming Summary • All programs broken down into – Sequence – Selection • if, if/else, or switch • Any selection can be rewritten as an if statement – Repetition • while, do/while or for • Any repetition structure can be rewritten as a while statement 2003 Prentice Hall, Inc. All rights reserved.