2.11 Assignment Operators. Assignment expression abbreviations c = c + 3; can be abbreviated as c += 3; using the addition assignment operator

Transcription

1 2.11 Assignment Operators 1 Assignment expression abbreviations c = c + 3; can be abbreviated as c += 3; using the addition assignment operator Statements of the form variable = variable operator expression; can be rewritten as variable operator= expression; Examples of other assignment operators include: d -= (d = d - ) e *= 5 (e = e * 5) f /= 3 (f = f / 3) g %= 9 (g = g % 9) 2.11 Assignment Operators 2 A ssig n m e n t o p e ra to r Sa m p le e xp re ssio n Exp la n a tio n Assume: int c = 3, d = 5, e =, f = 6, g = 12; A ssig n s += c += 7 c = c to c -= d -= d = d - 1 to d *= e *= 5 e = e * 5 20 to e /= f /= 3 f = f / 3 2 to f %= g %= 9 g = g % 9 3 to g Fig A rith m e t ic a ssig n m e n t o p e ra t o rs. 1

2 2.12 Increment and Decrement Operators Increment operator (++) can be used instead of c += 1 Decrement operator (--) can be used instead of c -= Increment and Decrement Operators Preincrement When the operator is used before the variable (++c or c) Variable is changed, then the expression it is in is evaluated. Postincrement When the operator is used after the variable (c++ or c--) Expression the variable is in executes, then the variable is changed If c = 5, then cout << ++c; prints out 6 (c is changed before cout is executed) cout << c++; prints out 5 (cout is executed before the increment. c now has the value of 6) 2

3 2.12 Increment and Decrement Operators 5 When not in an expression preincrementing and postincrementing have the same effect. For example, ++c; cout << c; and c++; cout << c; have the same effect Increment and Decrement Operators 6 O p e ra t o r C a lle d Sa m p le e xp re ssio n Exp la n a t io n ++ preincrem ent ++a Increment a by 1, then use the new value of a in the expression in which a resides. ++ postincrem ent a++ U se the current value of a in the expression in which a resides, then increment a by predecrem ent --b D ecrement b by 1, then use the new value of b in the expression in which b resides. -- postdecrement b-- U se the current value of b in the expression in which b resides, then decrement b by 1. Fig The inc re m e n t a nd d e c re m e n t o p e ra t o rs. 3

4 1 // Fig. 2.1: fig02_1.cpp 2 // Preincrementing and postincrementing 3 #include <iostream> 5 using std::cout; 6 using std::endl; 7 8 int main() 9 { 10 int c; c = 5; 13 cout << c << endl; // print 5 1 cout << c++ << endl; // print 5 then postincrement 15 cout << c << endl << endl; // print c = 5; 18 cout << c << endl; // print 5 19 cout << ++c << endl; // preincrement then print 6 20 cout << c << endl; // print return 0; // successful termination 23 } Outline 1. Initialize variables 2. Postincrement variable 3. Preincrement variable Program Output Increment and Decrement Operators 8 O p e ra t o rs A sso c ia tivity Typ e () left to right parentheses static_cast<type>() left to right unary (postfix) right to left unary (prefix) * / % left to right multiplicative + - left to right additive << >> left to right insertion/extraction < <= > >= left to right relational ==!= left to right equality?: right to left conditional = += -= *= /= %= right to left assignm ent, left to right comma Fig Pre c e d e nc e o f th e o p e ra to rs e nc o un te re d so fa r in th e te xt.

5 2.13 Essentials of Counter-Controlled Repetition Counter-controlled repetition requires: The name of a control variable (or loop counter). The initial value of the control variable. The condition that tests for the final value of the control variable (i.e., whether looping should continue). The increment (or decrement) by which the control variable is modified each time through the loop. Example: int counter =1; //initialization while (counter <= 10){ //repetition condition cout << counter << endl; ++counter; //increment } Essentials of Counter-Controlled Repetition The declaration int counter = 1; Names counter Declares counter to be an integer Reserves space for counter in memory Sets counter to an initial value of

6 1 // Fig. 2.16: fig02_16.cpp 2 // Counter-controlled repetition 3 #include <iostream> 5 using std::cout; 6 using std::endl; 7 8 int main() 9 { 10 int counter = 1; // initialization while ( counter <= 10 ) { // repetition condition 13 cout << counter << endl; 1 ++counter; // increment 15 } return 0; 18 } Outline 1.Initialize counter 2. Repetition condition 3. Increment counter Program Output 2.1 The for Repetition Structure 12 The general format when using for loops is for ( initialization; LoopContinuationTest; increment ) statement Example: for( int counter = 1; counter <= 10; counter++ ) cout << counter << endl; Prints the integers from one to ten No semicolon after last statement 6

7 2.1 The for Repetition Structure 13 for loops can usually be rewritten as while loops: initialization; while ( loopcontinuationtest ){ statement increment; } Initialization and increment as comma-separated lists for (int i = 0, j = 0; j + i <= 10; j++, i++) cout << j + i << endl; 1 // Fig. 2.17: fig02_17.cpp 2 // Counter-controlled repetition with the for structure 3 #include <iostream> 5 using std::cout; 6 using std::endl; 7 8 int main() 9 { 10 // Initialization, repetition condition, and incrementing 11 // are all included in the for structure header for ( int counter = 1; counter <= 10; counter++ ) 1 cout << counter << endl; return 0; 17 } Outline 1.Initialization 2. Repetition condition 3. Incrementing counter Program Output 7

8 2.1 The for Repetition Structure 15 for keyword Control variable name Final value of control variable for which the condition is true for ( var counter = 1; counter <= 7; ++counter ) Initial value of control variable Increment of control variable Loop-continuation condition Fig Components of a typical for header. 2.1 The for Repetition Structure 16 Establish initial value of control variable counter = 1 Determine if final value of control variable has been reached counter <= 10 false true cout << counter << endl; Body of loop (this may be many statements) counter++ Increment the control variable Fig Flowcharting a typical for repetition structure. 8

9 2.15 Examples Using the for Structure 17 Examples: Vary control variable from 1 to 100 in increments of 1 for (int i = 1, i <= 100; i++) Vary control variable from 100 to 1 in decrements of -1 for (int i = 100, i >= 1; i--) Vary control variable from 7 to 77 in steps of 7 for (int i = 7, i <= 77; i += 7) 1 // Fig. 2.20: fig02_20.cpp 2 // Summation with for 3 #include <iostream> 5 using std::cout; 6 using std::endl; 7 8 int main() 9 { 10 int sum = 0; for ( int number = 2; number <= 100; number += 2 ) 13 sum += number; 1 15 cout << "Sum is " << sum << endl; return 0; 18 } Outline 1. Summation with for loop 18 Sum is 2550 Program Output 9

10 1 // Fig. 2.21: fig02_21.cpp 2 // Calculating compound interest 3 #include <iostream> 5 using std::cout; 6 using std::endl; 7 using std::ios; 8 9 #include <iomanip> using std::setw; 12 using std::setiosflags; 13 using std::setprecision; 1 15 #include <cmath> int main() 18 { 19 double amount, // amount on deposit 20 principal = , // starting principal 21 rate =.05; // interest rate cout << "Year" << setw( 21 ) 2 << "Amount on deposit" << endl; // set the floating-point number format 27 cout << setiosflags( ios::fixed ios::showpoint ) 28 << setprecision( 2 ); for ( int year = 1; year <= 10; year++ ) { 31 amount = principal * pow( rate, year ); 32 cout << setw( ) << year << setw( 21 ) << amount << endl; 33 } 3 35 return 0; 36 } Outline 1. Using setprecision to specify floatingpoint precision 2. Calculating compound interest using a for loop The switch Multiple-Selection Structure switch Useful when variable or expression is tested for multiple values Consists of a series of case labels and an optional default case 20 10

11 1 // Fig. 2.22: fig02_22.cpp 2 // Counting letter grades 3 #include <iostream> 5 using std::cout; 6 using std::cin; 7 using std::endl; 8 9 int main() 10 { 11 int grade, // one grade 12 acount = 0, // number of A's 13 bcount = 0, // number of B's 1 ccount = 0, // number of C's 15 dcount = 0, // number of D's 16 fcount = 0; // number of F's cout << "Enter the letter grades." << endl 19 << "Enter the EOF character to end input." << endl; while ( ( grade = cin.get() )!= EOF ) { 22 Notice how the case statement is used 23 switch ( grade ) { // switch nested in while 2 25 case 'A': // grade was uppercase A 26 case 'a': // or lowercase a 27 ++acount; 28 break; // necessary to exit switch case 'B': // grade was uppercase B 31 case 'b': // or lowercase b 32 ++bcount; 33 break; 3 Outline 1. Initialize variables 2. Input data 3. Use switch loop to update count case 'C': // grade was uppercase C 36 case 'c': // or lowercase c 37 ++ccount; Outline 38 break; 39. Use switch loop 0 case 'D': // grade was uppercase D break causes switch to end and to update count 1 case 'd': // or lowercase d first 2 ++dcount; the program continues with the 3 break; statement after the switch structure. 5 case 'F': // grade was uppercase F 5. Print results 6 case 'f': // or lowercase f 7 ++fcount; 8 break; 9 50 case '\n': // ignore newlines, 51 case '\t': // tabs, 52 case ' ': // and spaces in input Notice the default statement. 53 break; 5 55 default: // catch all other characters 56 cout << "Incorrect letter grade entered." 57 << " Enter a new grade." << endl; 58 break; // optional 59 } 60 } cout << "\n\ntotals for each letter grade are:" 63 << "\na: " << acount 6 << "\nb: " << bcount 65 << "\nc: " << ccount 66 << "\nd: " << dcount 67 << "\nf: " << fcount << endl; return 0; 70 } 2000 Prentice Hall, Inc. All rights reserved

12 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 Totals for each letter grade are: A: 3 B: 2 C: 3 D: 2 F: 1 Outline Program Output The switch Multiple-Selection Structure 2 true case a case a action(s) break false true case b case b action(s) break false... true case z case z action(s) break false default action(s) Fig The switch multiple-selection structure with breaks. 12

13 2.17 The do/while Repetition Structure 25 The do/while repetition structure is similar to the while structure, Condition for repetition tested after the body of the loop is executed Format: do { statement } while ( condition ); action(s) Example (letting counter = 1): do { true cout << counter << " "; condition } while (++counter <= 10); false This prints the integers from 1 to 10 All actions are performed at least once. 1 // Fig. 2.2: fig02_2.cpp 2 // Using the do/while repetition structure 3 #include <iostream> 5 using std::cout; 6 using std::endl; 7 8 int main() 9 { 10 int counter = 1; do { 13 cout << counter << " "; 1 } while ( ++counter <= 10 ); cout << endl; return 0; 19 } Outline 1. Initialize counter 2. Use the do/while loop 3. Repetition condition 26 13

14 2.17 The do/while Repetition Structure 27 action(s) condition true false Fig Flowcharting the do/while repetition structure The break and continue Statements 28 break Causes immediate exit from a while, for, do/while or switch structure Program execution continues with the first statement after the structure Common uses of the break statement: Escape early from a loop Skip the remainder of a switch structure 1

15 2.18 The break and continue Statements 29 continue Skips the remaining statements in the body of a while, for or do/while structure and proceeds with the next iteration of the loop In while and do/while, the loop-continuation test is evaluated immediately after the continue statement is executed In the for structure, the increment expression is executed, then the loop-continuation test is evaluated 2.27 code 30 15

16 1 // Fig. 2.27: fig02_07.cpp 2 // Using the continue statement in a for structure 3 #include <iostream> 5 using std::cout; 6 using std::endl; 7 8 int main() 9 { 10 for ( int x = 1; x <= 10; x++ ) { if ( x == 5 ) 13 continue; // skip remaining code in loop 1 // only if x is cout << x << " "; 17 } cout << "\nused continue to skip printing the value 5" 20 << endl; 21 return 0; 22 } Outline 1. continue statement Used continue to skip printing the value Logical Operators 32 && (logical AND) Returns true if both conditions are true (logical OR) Returns true if either of its conditions are true! (logical NOT, logical negation) Reverses the truth/falsity of its condition Returns true when its condition is false Is a unary operator, only takes one condition 16

17 2.19 Logical Operators 33 expression1 expression2 expression1 && expression2 false false false false true false true false false true true true Fig Truth table for the && (logical AND) operator Logical Operators 3 expression1 expression2 expression1 expression2 false false false false true true true false true true true true Fig Truth table for the (logical OR) operator. 17

18 2.19 Logical Operators 35 exp ression!exp ression false true true false Fig Truth tab le fo r ope ra tor! (lo gic a l ne ga tion) Logical Operators 36 Operators Associativity Type () left to right parentheses static_cast<type>() left to right unary (postfix) right to left unary (prefix) * / % left to right multiplicative + - left to right additive << >> left to right insertion/extraction < <= > >= left to right relational ==!= left to right equality && left to right logical AND left to right logical OR?: right to left conditional = += -= *= /= %= right to left assignment, left to right comma Fig Op era tor p rec ed enc e and a ssoc ia tivity. 18

19 2.20 Confusing Equality (==) and Assignment (=) Operators These errors are damaging because they do not ordinarily cause syntax errors. Recall that any expression that produces a value can be used in control structures. Nonzero values are true, and zero values are false Example: if ( paycode == ) cout << "You get a bonus!" << endl; Checks the paycode, and if it is then a bonus is awarded If == was replaced with = if ( paycode = ) cout << "You get a bonus!" << endl; Sets paycode to is nonzero, so the expression is true and a bonus is awarded, regardless of paycode. 37 Lvalues 2.20 Confusing Equality (==) and Assignment (=) Operators Expressions that can appear on the left side of an equation Their values can be changed Variable names are a common example (as in x = ;) Rvalues Expressions that can only appear on the right side of an equation Constants, such as numbers (i.e. you cannot write = x;) Lvalues can be used as rvalues, but not vice versa 38 19

20 2.21 Structured-Programming Summary 39 Structured programming Programs are easier to understand, test, debug and, modify. Rules for structured programming Only single-entry/single-exit control structures are used 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, if/else, switch, while, do/while or for). ) Rules 2 and 3 can be applied in any order and multiple times Structured-Programming Summary 0 Rules for Form ing Struc tured Program s 1) Begin with the simplest flowchart (Fig. 2.3). 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, if/else, switch, while, do/while or for). ) Rules 2 and 3 can be applied as often as you like and in any order. Fig Rules for fo rm ing struc tured p rog ra ms. 20

21 2.21 Structured-Programming Summary 1 Fig. 2.3 The simplest flowchart Structured-Programming Summary 2 Rule 2 Rule 2 Rule 2... Fig Repeatedly applying rule 2 of Fig to the simplest flowchart. 21

22 2.21 Structured-Programming Summary 3 Rule 3 Rule 3 Rule 3 Fig Applying rule 3 of Fig to the simplest flowchart Structured-Programming Summary All programs can be 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 22

23 2.21 Structured-Programming Summary 5 Stacked building blocks Nested building blocks Overlapping building blocks (Illegal in structured programs) Fig Stacked, nested and overlapped building blocks Structured-Programming Summary 6 Fig An unstructured flowchart. 23