Chapter 5 Repetition and Loop Statements Problem Solving

Chapter 5: Repetition and Loop Statements Problem Solving, Abstraction, and Design using C++ 6 e by Frank L. Friedman and Elliot B. Koffman Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley

Control Structures • Sequence • Selection • Repetition Copyright © 2007 Pearson Education, Inc.

5. 1 Counting Loops and while • Loop – a control structure that repeats a group of statements in a program • Loop body – the statements that are repeated in a loop Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 3

Counter-Controlled Loop • Repetition managed by a loop control variable whose value represents a count • Counting Loop – Set loop control variable to an initial value of 0 – While loop control variable < final value • … • Increase loop control variable by 1 Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 4

Counter-Controlled Loop • Used when we can determine prior to loop execution how many loop repetitions will be needed to solve problem • Number of repetitions should appear as the final count in the while condition Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 5

Listing 5. 1 Program fragment with a loop Copyright © 2007 Pearson Education, Inc.

The while Statement - Example • Loop Body – Compound statement – Gets an employee’s payroll data – Computes and displays employee’s pay • After 7 weekly pay amounts are displayed, the statement following loop body executes – Displays message “All employees processed. ” Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 7

The while Statement - Example • count. Emp = 0; – Sets initial value of 0, representing the count of employees processed so far • Condition evaluated (count. Emp < 7) – If true, loop body statements are executed – If false, loop body is skipped and control passes to the display statement (cout) that follows the loop body Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 8

The while Statement - Example • count. Emp = count. Emp + 1; – Increments the current value of the counter by 1 • After executing the last statement of the loop body – Control returns to the beginning of the while – The condition is reevaluated Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 9

Loop Repetition Condition • • Follows while reserved word Surrounded by parentheses When true, the loop body is repeated When false, exit the loop Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 10

Figure 5. 1 Flowchart for a while loop Copyright © 2007 Pearson Education, Inc.

Loop Control Variable • Initialize • Test • Update Copyright © 2007 Pearson Education,

while Statement Syntax • Form while (loop repetition condition) statement; • E. g. count. Star = 0; while (count. Star < n) { cout << “*”; count. Star = count. Star + 1; } Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 13

Loop Notes • If the loop control variable is not properly updated, an infinite loop can result. • If the loop repetition condition evaluates to false the first time it’s tested, the loop body statements are never executed. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 14

5. 2 Accumulating a Sum or Product in a Loop • Loops often accumulate a sum or product by repeating an addition of multiplication operation. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 15

Listing 5. 2 Program to compute company payroll Copyright © 2007 Pearson Education, Inc.

Listing 5. 2 Program to compute company payroll (continued) Copyright © 2007 Pearson Education,

Example – Compute Payroll • Initialization statements total. Pay = 0. 0; count. Emp = 0; // pay accumulator // loop control variable that // counts number of // employees processed • Accumulation total. Pay = total. Pay + pay; // add next pay • Incrementation count. Emp = count. Emp + 1; Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 18

Writing General Loops • Process exactly 7 employees while (count. Emp < 7) • Process an indefinite number of employees; number of employees must be read into variable number. Emp before the while statement executes while (count. Emp < number. Emp) Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 19

Multiplying a List of Numbers product = 1; while (product < 10000) { cout << product << endl; // display product so far cout << “Enter data item: “; cin >> item; product = product * item; // update product } Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 20

Conditional Loop 1. Initialize the loop control variable 2. While a condition involving the loop control variable is true 3. Continue processing 4. Update the loop control variable Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 21

Compound Assignment Operators • General form of common operations variable = variable op expression; • E. g. count. Emp = count. Emp + 1; time = time - 1; total. Pay = total. Pay + pay; product = product * item; Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 22

Special Assignment Operators • += -= *= /= %= • general form variable op= expression; • E. g. count. Emp += 1; time -= 1; total. Pay += pay; product *= item; Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 23

The for Statement • Especially useful for counting loops • Form for (initializing expression; loop repetition condition; update expression) statement; Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 24

The for Statement • E. g. for (count. Star = 0; count. Star <

Listing 5. 3 Using a for statement in a counting loop Copyright © 2007

Formatting the for Statement • Placement of expressions can be on one line or separate lines • Body of loop indented • Position of { } align with for keyword on separate lines (style for this book) Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 27

Increment and Decrement Operators • ++ - • Apply to a single variable • Side effect - a change in the value of a variable as a result of carrying out an operation Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 28

Increment and Decrement Operators • Prefix operator – E. g. m = 3; n = ++m; • Postfix operator – E. g. m = 3; n = m++; • Often used to update loop control variable Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 29

Listing 5. 4 Function to compute factorial Copyright © 2007 Pearson Education, Inc. Publishing

Localized Declarations of Variables • Commonly used for loop control variables • Declared at point of first reference • Value has meaning (i. e. can be referenced) only inside loop. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 31

Example - Localized Variables string first. Name; cout << “Enter your first name: “’ cin >> first. Name; for (int pos. Char = 0; pos. Char < first. Name. length( ); pos. Char++; ) cout << first. Name. at(pos. Char) << endl; Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 32

Listing 5. 5 Converting Celsius to Fahrenheit Copyright © 2007 Pearson Education, Inc. Publishing

Listing 5. 5 Converting Celsius to Fahrenheit (continued) Copyright © 2007 Pearson Education, Inc.

Output - Celsius to Fahrenheit Celsius 10 5 0 -5 Fahrenheit 50. 00 41.

Displaying a Table of Values • setw( ) manipulator helps create neat columns • It is a member function of the iomanip class. • Requires the iomanip library to be included Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 36

Conditional Loops • Used when you can’t determine before loop execution begins exactly how many loop repetitions are needed. • The number of repetitions is generally stated by a condition that must remain true in order for the loop to continue. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 37

Conditional Loop Initialize the loop control variable. While a condition involving the loop control variable is true Continue processing. Update the loop control variable Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 38

Case Study: Monitoring Oil Supply • Problem We want to monitor the amount of oil remaining in a storage tank at the end of each day. The initial supply of oil in the tank and the amount taken out each day are data items. Our program should display the amount left in the tank at the end of each day and it should also display a warning when the amount left is less than or equal to 10 percent of the tank’s capacity. At this point, no more oil can be removed until the tank is refilled. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 39

Case Study: Analysis • Clearly, the problem inputs are the initial oil supply and the amount taken out each day. The outputs are the oil remaining at the end of each day and a warning message when the oil left in the tank is less than or equal to 10 percent of its capacity. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 40

Case Study: Data Requirements • Problem Constants CAPACITY = 1000 MINPCT = 0. 10 // tank capacity // minimum % • Problem Input float supply // initial oil supply Each day’s oil use Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 41

Case Study: Data Requirements • Problem Output float oil. Level // final oil amount Each day’s oil supply A warning message when the oil supply is less than minimum. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 42

Case Study: Data Requirements • Program Variable float min. Oil // minimum oil supply • Formulas Minimum oil supply is 10 percent of tank’s capacity Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 43

Case Study: Initial Algorithm 1. Get the initial oil supply. 2. Compute the minimum oil supply. 3. Compute and display the amount of oil left each day (implement as function monitor. Oil). 4. Display the oil left and a warning message if necessary. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 44

Analysis for Function monitor. Oil • Function monitor. Oil must display a table showing the amount of oil left at the end of each day. To accomplish this, the function must read each day’s usage and deduct that amount from the oil remaining. The function needs to receive the initial oil supply and the minimum oil supply as inputs (arguments) from the main function. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 45

Function Interface for monitor. Oil • Input Parameters float supply float min. Oil // initial oil supply // minimum oil supply • Output Returns the final oil amount • Local Data float usage // input from user - each day’s oil use float oil. Left // output from user - each day’s oil supply Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 46

Design of monitor. Oil • The body of monitor. Oil is a loop that displays the oil usage table. We can’t use a counting loop because we don’t know in advance how many days if will take to bring the supply to the critical level. We do know the initial supply of oil, and we know that we want to continue to compute and display the amount of oil remaining (oil. Left) as long as the amount of oil remaining does not fall below the minimum. So the loop control variable must be oil. Left. We need to initialize oil. Left to the initial supply and to repeat the loop as long as oil. Left > min. Oil is true. The update step should deduct the daily usage (a data value) from oil. Left. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 47

Initial Algorithm for monitor. Oil 1. Initialize oil. Left to supply. 2. While (oil. Left > min. Oil) 2. 1 Read in the daily usage. 2. 2 Deduct the daily usage from oil. Left 2. 3 Display the value of oil. Left Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 48

Listing 5. 6 Program to monitor oil supply // File: oil. Supply. cpp Displays daily usage and amount left in oil tank. #include <iostream> using namespace std; float monitor. Oil(float, float); int main() { const float CAPACITY = 10000; const float MINPCT = 10. 0; float supply; float oil. Left; float min. Oil; // tank capacity // minimum percent // input - initial oil supply // output - oil left in tank // minimum oil supply Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 49

Listing 5. 6 Program to monitor oil supply (continued) // Get the initial oil supply. cout << "Enter initial oil supply: "; cin >> supply; // Compute the minimum oil supply. min. Oil = CAPACITY * (MINPCT / 100. 0); // Compute and display the amount of oil left each day oil. Left = monitor. Oil(supply, min. Oil); // Display warning message if supply is less than minimum cout << endl << oil. Left << " gallons left in tank. " << endl; return 0; } Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 50

Listing 5. 6 Program to monitor oil supply (continued) float monitor. Oil(float supply, float min. Oil) { // Local data. . . float usage; // input from user - Each day's oil use float oil. Left; // Amount left each day oil. Left = supply; while (oil. Left > min. Oil) { cout << "Enter amount used today: "; cin >> usage; oil. Left -= usage; cout << "After removal of " << usage << " gallons, "; cout << "number of gallons left is " << oil. Left << endl; } return oil. Left; } Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 51

Case Study: Testing • To test the program, try running it with a few samples of input data. One sample should bring the oil level remaining to exactly 10 percent of the capacity. For example, if the capacity is 10, 000 gallons, enter a final daily usage amount that brings the oil supply to 1, 000 gallons and see what happens. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 52

Case Study: Testing Enter initial oil supply: 7000 Enter amount used today: 1000 After removal of 1000 gallons, number of gallons left is 6000 Enter amount used today: 4000 After removal of 4000 gallons, number of gallons left is 2000 Enter amount used today: 1500 After removal of 1500 gallons, number of gallons left is 500 gallons left in tank Warning - amount of oil left is below minimum! Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 53

5. 5 Loop Design and Loop Patterns initialization • Sentinel-Controlled Loops 1. Read the first data item. 2. While the sentinel value has not been read 3. Process the data item. 4. Read the next data item. update Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley Loop repetition condition 54

Sentinel-Controlled Loops • A sentinel is a specific predetermined value used to terminate one type of eventcontrolled loop • It is the same type as the other data being processed • It is outside the range of valid values for the data Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 55

Example: Sum Exam Scores 1. Initialize sum to zero 2. Read first score 3. While score is not the sentinel 4. Add score to sum 5. Read next score Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 56

Listing 5. 7 A sentinel-controlled loop // File: sum. Scores. cpp // Accumulates the sum of exam scores. #include <iostream> using namespace std; void display. Grade(int); int main() { const int SENTINEL = -1; int score; int sum; int count; int average; Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 57

Listing 5. 7 A sentinel-controlled loop (continued) // Process all exam scores until sentinel is read count = 0; sum = 0; cout << "Enter scores one at a time as requested. " << endl; cout << "When done, enter " << SENTINEL << " to stop. " << endl; cout << "Enter the first score: "; cin >> score; while (score != SENTINEL) { sum += score; count++; display. Grade(score); cout << endl << "Enter the next score: "; cin >> score; } Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 58

Listing 5. 7 A sentinel-controlled loop (continued) cout << endl; cout << "Number of scores processed is " << count << endl; cout << "Sum of exam scores is " << sum << endl; // Compute and display average score. if (count > 0) { average = sum / count; cout << "Average score is " << average; } return 0; } Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 59

Listing 5. 7 A sentinel-controlled loop (continued) // Displays the letter grade corresponding to an exam // score assuming a normal scale. void display. Grade(int score) // IN: exam score { if (score >= 90) cout << “Grade is A” << endl; else if (score >= 80) cout << “Grade is B” << endl; else if (score >= 70) cout << “Grade is C” << endl; else if (score >= 60) cout << “Grade is D” << endl; else cout << “Grade is F” << endl; } Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 60

Testing: sum. Scores Enter the scores one at a time as requested. When done, enter -1 to stop. Enter the first score: 85 Grade is B Enter the next score: 33 Grade is F Enter the next score: 77 Grade is C Enter the next score: -1 Number of scores processed is 3 Sum of exam scores is 195 Average score is 65 Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 61

Calculating an Average • Requires keeping a count of the number of values processed (e. g. count in sum. Scores) • Counter is initialized to zero before loop begins • Counter is incremented (e. g. count++; ) within loop body • Counter is not the loop control variable in this case Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 62

Flag Controlled Loops initialization 1. Set the flag to false. 2. While the flag is false 3. Perform some action. 4. Reset the flag to true if the anticipated event occurred. Loop repetition condition update Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 63

Flag Controlled Loops • Type bool variables often used as flags • Flag initialized to false before loop entry • Flag reset to true when a particular event occurs • Note: because flag is initially false, the loop condition uses ! (not) operator to reverse the flag’s value Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 64

Listing 5. 8 Function get. Digit Copyright © 2007 Pearson Education, Inc. Publishing

5. 6 The do-while Statement • The do while statement is similar to the while loop, but the do while loop has the test at the end. General form: do { statement; } while ( expression ) ; • Notice the iterative part executes before the loop-test) Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 66

Data-validation Loop • do prompt for and read a data item while data item is not valid • E. g. do { cout << “Enter number of employees: “; cin >> num. Emp; } while (num. Emp < 0); Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 67

Listing 5. 9 Function get. Int. Range Copyright © 2007 Pearson Education, Inc. Publishing

do-while and Menus • Often used to control a menu-driven program • Display a

Typical Menu List of edit operations: D - Delete a substring F - Find a string I - Insert a string R - Replace a substring Q - Quit Enter D, F, I, R, or Q as your selection: Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 70

Main Control Routine do Display the menu Read the user’s choice Perform the user’s choice Display the edited string while the choice is not Quit Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 71

Listing 5. 10 Main function for text editor program Copyright © 2007 Pearson Education,

Listing 5. 10 Main function for text editor program (continued) Copyright © 2007 Pearson

Listing 5. 11 Finding the largest value Copyright © 2007 Pearson Education, Inc. Publishing

Listing 5. 11 Finding the largest value (continued) Copyright © 2007 Pearson Education, Inc.

5. 7 Review of Loop Forms • while – most commonly used when repetition is not counter controlled – condition test precedes each loop repetition – loop body may not be executed at all Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 76

Review of Loop Forms • for – used to implement a counting loop – also convenient for other loops with simple initialization and update steps – condition test precedes the execution of the loop body – loop body may not be executed at all Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 77

Review of Loop Forms • do-while – convenient when at least one repetition of

5. 8 Nested Loops • As with if statements, loop statements can be nested • Each time outer loop is repeated, any inner loop is restarted - loop control components are reevaluated and all required iterations are performed Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 79

Listing 5. 13 Nested for loop program Copyright © 2007 Pearson Education, Inc. Publishing

Listing 5. 13 Nested for loop program (continued) Copyright © 2007 Pearson Education, Inc.

Listing 5. 14 Displaying the multiplication table Copyright © 2007 Pearson Education, Inc. Publishing

Listing 5. 14 Displaying the multiplication table (continued) Copyright © 2007 Pearson Education, Inc.

5. 9 Debugging and Testing Programs • Modern Integrated Development Environments (IDEs) include features to help you debug a program while it is executing. • If you cannot use a debugger, insert extra diagnostic output statements to display intermediate results at critical points in your program. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 84

Debugging Without a Debugger • Insert diagnostic output statements – at locations where you suspect things are going wrong or other critical points in the code • beginning and end of functions • after complex calculations – to display intermediate results, e. g. variables affected by each major algorithm step • Remove extra output statements when problem solved, or use // to “comment out” Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 85

Off-by-one Errors • Common logic error - a loop that executes one time too many or one time too few • Check initial and final values for loop control variables • Check loop repetition condition • Check loop boundaries during testing Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 86

Testing • Thorough testing necessary • Check all paths through decision statements and the number of iterations for loops • Make enough test runs to verify that the program works properly for representative samples of all possible data combinations Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 87

5. 10 Common Programming Errors • • Omitting braces ( { }) Omitting a closing brace ( } ) Infinite loop Misuse of = for == Bad sentinel value Using do-while instead of while Incorrect use of compound assignment Incorrect use of increment and decrement operators Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 88

Loops in graphics programs - quilt The program in Listing 5. 15 draws a "quilt" consisting of nested filled rectangles. It first draws a large black bar which fills the output window. Each subsequent bar is centered inside the previous one, overwriting its pixels in a new color, so only a border from the previous rectangle remains on the screen. • • The statements step. X = width / (2 * num. Bars); // x increment step. Y = height / (2 * num. Bars); // y increment define the change in x- and y-values for the corners of each bar and are computed so that there will be room to display all the bars. • • • In the for loop, the statements fore. Color = i % 16; // 0 <= fore. Color <= 15 setcolor(fore. Color); setfillstyle(i % 12, fore. Color); // set fill style. bar(x 1, y 1, x 2, y 2); // draw a bar. set the foreground color to one of 16 colors, based on the value of loop variable i. Similarly, function setfillstyle sets the fill pattern to one of 12 possible patterns. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 89

Quilt cont’d • After each bar is drawn, the statements • x 1 = x 1 + step. X; y 1 = y 1 + step. Y; // change top left • x 2 = x 2 - step. X; y 2 = y 2 - step. Y; // change bottom right • change the top-left corner (point x 1, y 1) and the bottom-right corner (point x 2, y 2) for the next bar, moving them closer together. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 90

Quilt Program #include <graphics. h> #include <iostream> using namespace std; int main() { int x 1, y 1, x 2, y 2; int step. X, step. Y; int fore. Color; int num. Bars; int width, height; // // // coordinates of corner points change in coordinate values foreground color number of bars screen width and height cout << "Enter number of bars: "; cin >> num. Bars; width = getmaxwidth(); height = getmaxheight(); initwindow(width, height, "Quilt"); // Set corner points of outermost bar and // set increments for inner bars Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 91

Quilt Program cont’d x 1 = 0; y 1 = 0; x 2 = width; y 2 = height; step. X = width / (2 * num. Bars); step. Y = height / (2 * num. Bars); // Draw nested bars for (int i = 1; i <= num. Bars; i++) { fore. Color = i % 16; setcolor(fore. Color); setfillstyle(i % 12, fore. Color); bar(x 1, y 1, x 2, y 2); x 1 = x 1 + step. X; y 1 = y 1 + step. Y; x 2 = x 2 - step. X; y 2 = y 2 - step. Y; } getch(); closegraph(); return 0; // top left corner // bottom right corner // x increment // y increment // 0 <= fore. Color <= 15 // // Set fill style Draw a bar Change top left corner Change bottom right // pause } Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 92

Quilt Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 93

Animation • In graphics animation, motion is achieved by displaying a series of frames in which the object is in a slightly different position in the current frame than it was in the previous frame, so it appears that the object is moving. Each frame is displayed for a few milliseconds. • Like flip-books for children in which objects were drawn in slightly different positions on each page of the book. As you flipped the pages, the object moved. • The program in Listing 5. 16 draws a ball that moves around the screen like the ball in a pong game. It starts moving down the screen and to the right until it reaches a "wall" (a window edge) and then reverses its x- or y-direction depending on which wall it hit. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 94

Double Buffering • A technique called double buffering reduces the screen flicker and makes the motion seem smoother. • In single buffering, a single memory area (or buffer) is used to hold the frame that will be shown next on the screen. After the buffer is filled, its bytes are sent to the graphics hardware for display. When done, the bytes for the next frame are loaded into the buffer. • In double buffering, while the bytes in one buffer are being sent to the graphics display, the second buffer is being filled with the bytes for the next frame. Then, the contents of the second buffer are sent to the graphics hardware, while the first buffer is being filled. The extra buffer enables the screen display to be refreshed more frequently, resulting in less flicker between transitions. In graphics. h, double-buffering is turned on by setting the sixth argument for initwindow to true. initwindow(width, height, "Pong - close window to quit", 0, 0, true); Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 95

Program to Draw Moving Ball // File animate. cpp // Draws a ball that moves around the screen like in pong #include <graphics. h> using namespace std; int main() { const int PAUSE = 20; // delay between frames const int DELTA = 5; // change in x or y value const int RADIUS = 30; // ball radius const int COLOR = RED; int int int width; height; x; int y; step. X; step. Y; // // // width of screen height of screen center of ball increment for x increment for y // Open a full-screen window with double buffering width = getmaxwidth(); height = getmaxheight(); initwindow(width, height, "Pong - close window to quit", 0, 0, true); x = RADIUS; y = RADIUS; step. X = DELTA; step. Y = DELTA; // Start ball at top-left corner // Move down and to the right Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 96

Program to Draw Moving Ball cont’d // Draw the moving ball while (true) { // Clear the old frame and draw the new one. clearviewport(); setfillstyle(SOLID_FILL, COLOR); fillellipse(x, y, RADIUS); // Draw the ball // After drawing the frame, swap the buffers swapbuffers(); delay(PAUSE); // If ball is too close to a window boundary, change direction if (x <= RADIUS) // Is ball too close to left/right edge? step. X = DELTA; // Move right else if (x >= width - RADIUS) step. X = -DELTA; // Move left if (y <= RADIUS) // Is ball too close to top/bottom? step. Y = DELTA; // Move down else if (y >= height - RADIUS) step. Y = -DELTA; // Move up // Move the ball x = x + step. X; y = y + step. Y; } Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 97

Changing the Ball Direction • The loop executes "forever", or until the user closes the window. The loop begins by clearing the window for the new frame (function clearviewport). Next, it draws the ball in the new frame (stored in the second buffer). Then the buffers are swapped (function swapbuffers) and there is a delay of 20 milliseconds while the ball is displayed in its new position. swapbuffers(); delay(PAUSE); • The if statements change the direction of motion when the ball reaches an edge. In the statement below, the first condition is true if the current x position is closer to the left edge than the radius of the ball. In that case, the ball should move to the right (step. X is positive). • if (x <= RADIUS) // Is ball too close to left/right edge • step. X = DELTA; // Move right • else if (x >= width - RADIUS) • step. X = -DELTA; // Move left • The condition directly above is true if the x position of the ball is to too close to the right edge, so the ball should move to the left (step. X is negative). The assignment statements at the end of the loop compute the position of the ball for the next frame. Copyright © 2007 Pearson Education, Inc. Publishing as Pearson Addison-Wesley 98