1 / 48

COMPUTER SCIENCE 145

COMPUTER SCIENCE 145. Introduction to Computing for Engineers. Fall 2008 - TR 8:00-9:15 AM - EB 0012. INSTRUCTOR: BILL WHITE. Engineering Building 3041. (618)650-3483. wwhite@siue.edu. OFFICE HOURS. MTWR 9:30 AM - 1:00 PM. a nd by appointment. COURSE OVERVIEW

ludlow
Download Presentation

COMPUTER SCIENCE 145

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. COMPUTER SCIENCE 145 Introduction to Computing for Engineers Fall 2008 - TR 8:00-9:15 AM - EB 0012 INSTRUCTOR: BILL WHITE Engineering Building 3041 (618)650-3483 wwhite@siue.edu OFFICE HOURS MTWR 9:30 AM - 1:00 PM and by appointment

  2. COURSE OVERVIEW • Weeks 1-5: Basic C++ programming; Expressions; Conditionals; Loops • Week 6-10: Functions; Structures; Classes; Arrays • Week 11-16: Matrices; Files; Numerical Analysis (and Thanksgiving Break!) • Week 17: Final Exam • GRADING • Two 25-point programming mini-assignments • Ten 50-point programming assignments • Three 100-point exams • One 150-point comprehensive final exam LATE POLICY No late assignments without verifiable medical documentation! ACADEMIC MISCONDUCT No one sees your code except your teammates & the instructor! All designs must be original!

  3. CHAPTER 1 Computers: Revolutionary Machines with a Simple Design • Computer Components • Computer Software • Object-Oriented Programming CHAPTER 1 - Computers: Revolutionary Machines with a Simple Design 3

  4. COMPUTER COMPONENTS The primary components of a computer include its input devices (e.g., keyboard, mouse), its out put devices (e.g., display), memory devices (e.g., RAM, hard drive, optical disk drive), and processor (e.g., CPU). CPU RAM EXPANSION CARDS MOTHERBOARD POWER SUPPLY DISPLAY OPTICALDISK DRIVE HARD DRIVE MOUSE KEYBOARD CHAPTER 1 - Computers: Revolutionary Machines with a Simple Design 4

  5. INPUT & OUTPUT The principal output device for a computer is a display monitor, composed of hundreds of thousands of tiny pixels, the colors of which are repeatedly refreshed to provide the user with interactive responses and real-time animation. CRT PLASMA DISPLAY LCD Input devices like the keyboard and the mouse provide the means for the user to dynamically provide information to a computer program while it’s running. KEYBOARD MOUSE CHAPTER 1 - Computers: Revolutionary Machines with a Simple Design 5

  6. CENTRAL PROCESSING UNIT The CPU retrieves data and programming instructions from main memory, whereupon the Control Unit decodes the binary instructions and sends the data to the proper components (including the Arithmetic Logic Unit) for processing. CHAPTER 1 - Computers: Revolutionary Machines with a Simple Design 6

  7. RANDOM ACCESS MEMORY A computer’s main memory, or RAM, is electronic, making its contents “volatile” (i.e., everything stored in RAM is lost when the computer’s power is cut off). Copies of all active programs and their data are kept in RAM. CHAPTER 1 - Computers: Revolutionary Machines with a Simple Design 7

  8. NON-VOLATILE MEMORY To retain information after the computer has been turned off, secondary memory devices are needed. HARD DRIVE A magnetic memory device internal to the computer, typically storing hundreds of gigabytes of information. DVD DRIVE An optical memory device using portable disks, each of which can store several gigabytes of information. FLASH DRIVE A non-volatile electronic memory device that is also portable, typically storing several gigabytes of information. CHAPTER 1 - Computers: Revolutionary Machines with a Simple Design 8

  9. MEMORY RETRIEVAL Return Individual Instruction or Data Item Request Program and/or Data to be Loaded Load Program and/or Data to Main Memory CHAPTER 1 - Computers: Revolutionary Machines with a Simple Design 9

  10. COMPUTER SOFTWARE Application software is the type of software that most users are most familiar with: word processors, e-mail, video games, spreadsheets, etc. The operating system (Windows, Unix, Linux, etc.) is the software that interprets hardware events (e.g., mouse and keyboard clicks) for the application software and transmits application messages (e.g., instructions to the display, sound card, etc.) to the hardware. CHAPTER 1 - Computers: Revolutionary Machines with a Simple Design 10

  11. MACHINE LANGUAGE The CPU is designed to deal with binary instructions... 11110101010001100111101011000001 00100011110001010100100101001000 10100010101111111000101010110110 01100101011011111001010000010111 While easy for a CPU to deal with, such code is tedious for human programmers to write, resulting in the development of high-level programming languages like C++. CHAPTER 1 - Computers: Revolutionary Machines with a Simple Design 11

  12. COMPILATION Lexical Analysis Code Generation Parsing Object Program (in Machine Language) Source Program (in C++) Lexical Analysis The compiler takes the C++ program (called the source program), determines which strings of characters form separate items (e.g., “if (count > 100)” is split into “if”, “(”, “count”, “>”, “100”, and “)”), and deletes all comments and white space (blanks, line feeds, etc.). Parsing The compiler then analyzes the grammatical syntax of the program (e.g., “if”, “(”, “count”, “>”, “100”, “)” is determined to make sense, but a syntax error would be noticed in “if”, “count”, “>”, “100”, “)”.) Code Generation Once the program has been satisfactorily parsed, the compiler translates it into an equivalent program in machine language (called the object program). CHAPTER 1 - Computers: Revolutionary Machines with a Simple Design 12

  13. LINKING & LOADING Object Program Load Module Executable Program Link Load Compile Since the individual portions of the C++ program are compiled as separate units (e.g., your program, a math library, a graphics library, etc.), the resulting machine code cannot be executed until all of the units are connected together as a single machine language program. Source Program Linking A C++ programmer usually relies on pre-compiled libraries of code (math functions, graphics routines, I/O operations, etc.) that are connected to the programmer’s code prior to execution by a linker program. Loading Finally, a special loader program places the resulting machine code in main memory, tying up all loose ends (e.g., associating instructions and data with ttheir locations in memory) so the code is ready for execution. CHAPTER 1 - Computers: Revolutionary Machines with a Simple Design 13

  14. OBJECT-ORIENTED PROGRAMMING Traditional programming languages (e.g., Fortran, Cobol, Basic, C) have accentuated the procedures that are used to manipulate the data, concentrating on how everything is being done. More modern languages like C++ emphasize what is being manipulated. This facilitates programming applications such as databases and graphics, and makes it easier to reuse objects that were created in one program in a different program. CHAPTER 1 - Computers: Revolutionary Machines with a Simple Design 14

  15. THE 3 PRINCIPLES OF OOP CHAPTER 1 - Computers: Revolutionary Machines with a Simple Design 15

  16. CHAPTER 2 Basic Elements of a C++ Program • Directives • Constant & Variable Declaration • Data Types • Input & Output Statements • Assignment Statements • Arithmetic Expressions & Operators • Integer Operators • Math Functions CHAPTER 2 - Basic Elements of a C++ Program 16

  17. A SIMPLE C++ PROGRAM #include <iostream> // This library facilitates input & output. using namespace std; // Use the standard C++ naming conventions. void main() // Every C++ program must have a "main" function. { // Opening brace to contain main's statements. const double PI = 3.1415926535; // Declare constant value for Pi. double radius; // Declare variable "radius" to be double-precision. double circum; // Declare variable "circumference" to be double-precision. double area; // Declare variable "area" to be double-precision. cout << "Enter the radius of " // Output a message to the memory file associated with the << "the circle: "; // monitor (i.e., cout), requesting the circle's radius. cin >> radius; // Input from the file associated with keyboard (cin). circum = 2 * PI * radius; // Calculate the circumference of the circle. area = PI * radius * radius; // Calculate the area of the circle. // Output a message to the cout file concerning the value of // radius and the consequent values of circum and area. cout << "The circle with radius " << radius << " has circumference " << circum << " and area " << area << "." << endl << endl << endl; return; // Terminate the program's execution. } // Closing brace to indicate end of main function. CHAPTER 2 - Basic Elements of a C++ Program 17

  18. DIRECTIVES #include <iostream> // This library facilitates input & output. using namespace std; // Use the standard C++ naming conventions. Certain programming functionality is not built into C++, but must be added via preprocessing statements using #include directives. Here, for example, the ability to use the input operator (<<), the output operator (>>), the common input file (cin), and the common output file (cout) requires the inclusion of the iostream library. For larger programs, usually written by multiple programmers, it is important to ensure that naming conventions are consistent, so namespaces are used to guarantee that items named one thing in one part of the program do not interfere with items named the same thing somewhere else in the program. CHAPTER 2 - Basic Elements of a C++ Program 18

  19. MAIN FUNCTION Every C++ program must have a main function containing the principal lines of code (called statements). void main() // Every C++ program must have a "main" function. { // Opening brace to contain main's statements. The main function here is defined to be void, meaning that it doesn’t return any value. Notice that the last line of code in the function is a return statement, which here returns nothing. All of the statements within the function are enclosed in a set of brackets. The portions of the lines beginning with double slashes are comments, intended to facilitate reading the code, but deleted during the lexical analysis phase of compilation. return; // Terminate the program's execution. } // Closing brace to indicate end of main function. CHAPTER 2 - Basic Elements of a C++ Program 19

  20. CONSTANTS & VARIABLES const double PI = 3.1415926535; // Declare constant value for Pi. double radius; // Declare variable "radius" to be double-precision. double circum; // Declare variable "circumference" to be double-precision. double area; // Declare variable "area" to be double-precision. Memory must be reserved for the values that will be used during the course of the program’s execution. The value of a constant is set when it is declared and cannot be changed later. In this case, the constant PI is defined to be a specific double-precision floating-point value. The variables radius, circum, and area are also defined to be doubles, but have not been initialized. CHAPTER 2 - Basic Elements of a C++ Program 20

  21. DATA TYPES Constants and variables may be defined to be of any one of several types, including integer (int), character (char), and single-precision floating-point (float). const double PI = 3.1415926535; const intMONTHS_IN_YEAR = 12; const char PUNCTUATE = '!'; const float PI2DECIMALPLACES = 3.14; intcurrentMonth = 9; charmiddleInitial = PUNCTUATE; double imprecision = PI - PI2DECIMALPLACES; Variables may also be provided with initial values when they are declared. In this case, currentMonth is initialized to 9, middleInitial is initialized to ‘!’, and imprecision is initialized to 0.0015926535. Unlike the constants, however, the variables may be assigned different values during the course of the program. CHAPTER 2 - Basic Elements of a C++ Program 21

  22. INPUT & OUTPUT STATEMENTS The common output file (i.e., the output from the computer to the monitor) is accessed via the << operator, which can be cascaded to allow a sequence of output contents. cout << "Enter the radius of " // Output a message to the memory file associated with the << "the circle: "; // monitor (i.e., cout), requesting the circle's radius. cin >> radius; // Input from the file associated with keyboard (cin). The common input file permits user input during the program’s execution. // Output a message to the cout file concerning the value of // radius and the consequent values of circum and area. cout << "The circle with radius " << radius << " has circumference " << circum << " and area " << area << "." << endl << endl << endl; Output can include double-quoted character strings and numerical values, as well as line feeds. CHAPTER 2 - Basic Elements of a C++ Program 22

  23. ASSIGNMENT STATEMENTS In addition to input statements, a program may assign new values to variables via assignment statements, using the assignment operator (=). The left operand in an assignment statement must be a variable, while the right operand may be an arithmetic expression. circum = 2 * PI * radius; // Calculate the circumference of the circle. area = PI * radius * radius; // Calculate the area of the circle. The arithmetic expression is completely evaluated, using the current values of all variables that are used, and the resulting value is assigned to the variable on the left of the assignment statement. CHAPTER 2 - Basic Elements of a C++ Program 23

  24. ARITHMETIC EXPRESSIONS & OPERATORS doublefirstValue = 98.6; doublesecondValue = 103.2; doublemeanValue; meanValue = (firstValue + secondValue) / 2; // New meanValue: 100.9 meanValue = firstValue + secondValue / 2; // New meanValue: 150.2 The evaluation of arithmetic expressions follows specific rules: 1. Parenthesized subexpressions are evaluated first. 2. Arithmetic operators are evaluated according to precedence: Top: Negative and positive unary operators Middle: Multiplication, division, and modulo Bottom: Addition and subtraction 3. Operators of the same precedence are handled in left-to-right order CHAPTER 2 - Basic Elements of a C++ Program 24

  25. INTEGER OPERATORS The division operator (/) is interpreted as integer division (i.e., the remainder is ignored) when both operands are integers. Also, the modulo operator (%) is available when both operators are integers; it calculates the remainder of the associated quotient. #include <iostream> using namespace std; void main() { intscore; inthundredsDigit; inttensDigit; intonesDigit; cout << "Enter the score: "; cin >> score; hundredsDigit = score / 100; tensDigit = score / 10 - hundredsDigit * 10; onesDigit = score % 10; cout << endl << "SCORE" << endl << " " << hundredsDigit << endl << " " << tensDigit<< endl << " " << onesDigit << endl << endl; return; } CHAPTER 2 - Basic Elements of a C++ Program 25

  26. MATH FUNCTIONS #include <iostream> #include <cmath> using namespace std; void main() { const double PI = 3.1415926535; doublelengthSideA; doublelengthSideB; doublehypotenuseC; intangleCA; intangleCB; cout << "RIGHT TRIANGLE MEASUREMENTS" << endl; cout << "---------------------------" << endl << endl; cout << "Enter side A's length: "; cin >> lengthSideA; cout << "Enter side B's length: "; cin >> lengthSideB; hypotenuseC = sqrt( pow(lengthSideA, 2) + pow(lengthSideB, 2) ); angleCA = (int) (asin(lengthSideA / hypotenuseC) * 180 / PI); angleCB = 90 - angleCA; cout << endl << "Hypotenuse C: " << hypotenuseC << endl << "Angle between A and C: " << angleCA << " degrees" << endl << "Angle between B and C: " << angleCB << " degrees" << endl << endl; return; } Various mathematical functions (like sqrt, pow, and asin, illustrated here) are available via the cmath library. CHAPTER 2 - Basic Elements of a C++ Program 26

  27. CHAPTER 3 Control Structures • Conditions • Logical Operators • If Statements • If-Else Statements • Nested If-Else Statements • Switch Statements CHAPTER 3 - Control Structures 27

  28. CONDITIONS Occasions arise in programs where certain statements should only be executed if particular conditions exist. • The patient’s temperature is above normal (e.g., temp > 98.6) • The user specified a particular input value (e.g., inputChar == ‘Y’) • A payment adequately covers a purchase (e.g., price + salesTax <= paymentAmount) • Two consecutive values are not repeated (e.g., newValue != oldValue) CHAPTER 3 - Control Structures 28

  29. LOGICAL OPERATORS Multiple conditions sometimes must be checked when options are analyzed within a program. • The AND operator (&&) checks if both conditions are true (e.g., (temp > 98.6) && (pulse < 60)) • The OR operator (||) checks if either condition is true (e.g., (day <= 0) || (day > 31)) • The NOT operator (!) checks if the complement of the condition is true (e.g., !((inputChar == ‘y’) || (inputChar == ‘Y’))) CHAPTER 3 - Control Structures 29

  30. IF STATEMENTS #include <iostream> using namespace std; void main() { const double WATER_BOILING_POINT = 99.97; const double WATER_FREEZING_POINT = 0.00; chartemperatureType; boolusingCelsius; double temperature; cout << "Enter the water temperature: "; cin >> temperature; cout << "Enter C if you are using Celsius: "; cin >> temperatureType; usingCelsius = ((temperatureType == 'C') || (temperatureType == 'c')); if (!usingCelsius) temperature = (temperature - 32.0) / 1.8; if (temperature <= WATER_FREEZING_POINT) cout << "That's not water - it's ice!" << endl << endl; if (temperature >= WATER_BOILING_POINT) cout << "That's not water - it's steam!" << endl << endl; if ((temperature > WATER_FREEZING_POINT) && (temperature < WATER_BOILING_POINT)) cout << "That's water all right!" << endl << endl; return; } If statements allow a program to check a condition and execute the accompanying instruction only when the condition evaluates to true. CHAPTER 3 - Control Structures 30

  31. IF-ELSE STATEMENTS #include <iostream> using namespace std; void main() { const double SAMPLE_MAXIMUM = 1000.0; const double SAMPLE_MINIMUM = 10.0; const double BASE_TEMPERATURE = 21.0; const double TIME_MAXIMUM = 300.0; const double TIME_MINIMUM = 5.0; doublesampleSize; double temperature; doubleevaporationRate; doubletotalTime; doublefinalSampleSize; cout << "Enter the sample size (in milligrams): "; cin >> sampleSize; if (sampleSize > SAMPLE_MAXIMUM) { cout << "Size limit exceeded. " << SAMPLE_MAXIMUM << " milligrams assumed." << endl; sampleSize = SAMPLE_MAXIMUM; } else if (sampleSize < SAMPLE_MINIMUM) { cout << "Size too small. " << SAMPLE_MINIMUM << " milligrams assumed." << endl; sampleSize = SAMPLE_MINIMUM; } If-else statements provide the programmer with the ability to cascade multiple options and their associated instructions. When an option requires multiple instructions, those instructions are placed inside a pair of braces. CHAPTER 3 - Control Structures 31

  32. cout << "Enter the exposure temperature (in Celsius): "; cin >> temperature; if (temperature <= BASE_TEMPERATURE) evaporationRate = 0.00; else evaporationRate = (temperature - BASE_TEMPERATURE) / BASE_TEMPERATURE; cout << "Enter the experiment time (in seconds): "; cin >> totalTime; if (totalTime > TIME_MAXIMUM) { cout<< "Time limit exceeded. " << TIME_MAXIMUM << " seconds assumed." << endl; totalTime = TIME_MAXIMUM; } else if (totalTime < TIME_MINIMUM) { cout << "Time limit too small. " << TIME_MINIMUM << " seconds assumed." << endl; totalTime = TIME_MINIMUM; } finalSampleSize = sampleSize - evaporationRate * totalTime * sampleSize; cout << endl << "Original Sample Size: " << sampleSize << " milligrams" << endl; cout << "Experiment Temperature: " << temperature << " degrees (Celsius)" << endl; cout << "ExperimentDuration: " << totalTime << " seconds" << endl << endl; if (finalSampleSize > 0.0) cout << "Resulting Sample Size: " << finalSampleSize << " milligrams" << endl; else cout << "Result: ENTIRE SAMPLE EVAPORATED" << endl; return; } CHAPTER 3 - Control Structures 32

  33. NESTED IF-ELSE STATEMENTS #include <iostream> using namespace std; void main() { int month; int year; int sampleDay1; int sampleDay2; cout << "Enter an integer representing the month: "; cin >> month; cout << "Enter the four-digit year: "; cin >> year; if ((month == 2) && (year % 4 != 0)) sampleDay1 = 14; else sampleDay1 = 15; if (month == 2) { if (year % 4 == 0) sampleDay2 = 29; else sampleDay2 = 28; } else { if ((month == 4) || (month == 6) || (month == 9) || (month == 11)) sampleDay2 = 30; else sampleDay2 = 31; } If statements and if-else statements are just like any other C++ statements, so they can also be placed inside other if and if-else statements. cout << "This month's soil sample days are " << month << '/' << sampleDay1 << '/'; if (year % 100 < 10) cout << '0' << (year % 100); else cout << (year % 100); cout << " and " << month << '/' << sampleDay2 << '/'; if (year % 100 < 10) cout << '0' << (year % 100) << ".\n\n"; else cout << (year % 100) << ".\n\n"; return; } CHAPTER 3 - Control Structures 33

  34. SWITCH STATEMENTS Nested if-else statements can be tedious for a programmer to write and difficult to decipher once they are written, making switch statements a useful alternative. #include <iostream> using namespace std; void main() { chartopShoulderColor; charbottomShoulderColor; charYorN; boolbottomShoulderExists; cout << "COMPRESSED GAS CYLINDER ANALYZER" << endl; cout << "--------------------------------" << endl; cout << "Enter the first letter of the color at" << endl << "the top of the gas cylinder in question" << endl << "R(ed), Y(ellow), G(reen), or B(lue) ONLY: "; cin >> topShoulderColor; cout << endl << "Does the gas cylinder shoulder have a" << endl << "second color, just below the color you've" << endl << "already specified? (Answer Y or N) "; cin >> YorN; bottomShoulderExists = ((YorN == 'Y') || (YorN == 'y')); if (bottomShoulderExists) { cout << endl << "Enter the first letter of the lower color" << endl << "at the top of the gas cylinder in question" << endl << "R(ed), Y(ellow), G(reen), or B(lue) ONLY: "; cin >> bottomShoulderColor; } CHAPTER 3 - Control Structures 34

  35. cout << endl << "Gas Cylinder Contents Are "; switch(topShoulderColor) { case'r': case'R': { cout << "Flammable"; break; } case'y': case'Y': { cout << "Toxic/Corrosive"; break; } case'g': case'G': { cout << "Inert"; break; } case'b': case'B': { cout << "Oxidizing"; break; } default: { cout << "Unknown"; break; } } if (bottomShoulderExists) { cout << " And "; switch(bottomShoulderColor) { case'r': case'R': { cout << "Flammable"; break; } case'y': case'Y': { cout << "Toxic/Corrosive"; break; } case'g': case'G': { cout << "Inert"; break; } case'b': case'B': { cout << "Oxidizing"; break; } default: { cout << "Unknown"; break; } } } cout << endl << endl; return; } Any case in the switch statement that doesn’t end with a break statement automatically causes the next case’s instructions to be executed as well! If none of the case values apply, then the default code is executed (if it exists). CHAPTER 3 - Control Structures 35

  36. CHAPTER 4 Repetition Structures • While Loops • External Input Files • External Output Files • For Loops • Do-While Loops CHAPTER 4 - RepetitionStructures 36

  37. WHILE LOOPS #include <iostream> using namespace std; void main() { const intMAX_EXPIRATION = 90; charisItPerishable; intnbrDaysUntilExpire = MAX_EXPIRATION; cout << "Is the test sample perishable? (Enter Y or N) "; cin >> isItPerishable; while ((isItPerishable != 'Y') && (isItPerishable != 'y') && (isItPerishable != 'N') && (isItPerishable != 'n')) { cout << "Invalid response. Enter Y or N: "; cin >> isItPerishable; } if ((isItPerishable == 'Y') || (isItPerishable == 'y')) { cout << "Enter the number of days until the sample expires: "; cin >> nbrDaysUntilExpire; while (nbrDaysUntilExpire <= 0) { cout << "Invalid response. Enter a positive number: "; cin >> nbrDaysUntilExpire; } } if (nbrDaysUntilExpire < 7) cout << endl << "CAREFUL!"; cout << endl << "The test sample expires in " << nbrDaysUntilExpire << " days." << endl << endl; return; } When the same sequence of instructions must be executed multiple times, a loop is needed. A condition is checked at the beginning of a while loop. If the condition is true, the instructions inside the loop are executed and then the condition is checked again. CHAPTER 4 - RepetitionStructures 37

  38. #include <iostream> using namespace std; void main() { intresistorCount = 0; double resistance; doubleseriesTotal = 0.00; doubleparallelTotal = 0.00; charSorP; boolisParallel; cout << "RESISTANCE CALCULATOR" << endl; cout << "---------------------" << endl; cout << "In Series (S) Or Parallel (P)? "; cin >> SorP; while ((SorP != 'S') && (SorP != 's') && (SorP != 'P') && (SorP != 'p')) { cout << "You must enter either the " << "letter S or the letter P: "; cin >> SorP; } isParallel = (SorP == 'P') || (SorP == 'p'); cout << "Enter the resistance (in ohms) " << "of each resistor." << endl; cout << "When finished, enter 0." << endl << endl; cout << "Resistor " << (resistorCount + 1) << ": "; cin >> resistance; while (resistance > 0.00) { resistorCount++; seriesTotal += resistance; parallelTotal += 1/resistance; cout << "Resistor " << (resistorCount + 1) << ": "; cin >> resistance; } if (isParallel) { cout << endl << "Total Parallel Resistance: " << parallelTotal << " ohms" << endl; cout << "(Corresponding Series Resistance: " << seriesTotal << " ohms)" << endl << endl; } else { cout << endl << "Total Series Resistance: " << seriesTotal << " ohms" << endl; cout << "(Corresponding Parallel Resistance: " << parallelTotal << " ohms)" << endl << endl; } return; } If the while loop’s condition is not true the first time it’s encountered, the loop is never entered. The programmer must set the condition up so it will be evaluated properly each time through the loop, and so it will ultimately lead to the termination of the loop. CHAPTER 4 - RepetitionStructures 38

  39. AK 1.3 23.8 21.9 AL 80.7 38.8 20.7 AR 25.6 26.2 11.9 AZ 40.3 37.8 18.8 CA 6.5 261.5 130.9 CO 36.9 32.9 23.2 CT 4.2 32.7 8.6 DC 0.1 2.2 1.8 DE 5.1 9.3 2.5 FL 66.2 151.9 39.9 GA 79.0 75.2 21.5 HI 1.8 20.7 0.2 IA 41.9 27.8 12.1 ID 1.2 10.3 4.1 IL 101.2 92.6 50.7 IN 152.6 58.7 28.6 KS 36.5 26.9 14.4 KY 91.0 48.6 11.9 LA 24.1 85.3 71.2 MA 9.9 53.2 20.5 MD 31.0 39.3 10.4 ME 0.7 18.6 4.0 MI 73.2 68.3 48.4 MN 35.9 47.7 19.3 MO 76.4 49.3 14.1 MS 17.5 32.3 15.4 MT 18.5 13.0 3.5 NC 74.1 66.2 12.0 ND 37.7 9.0 3.2 NE 21.2 16.3 6.1 NH 4.1 14.4 3.4 NJ 10.6 84.4 33.6 NM 29.3 17.5 12.2 NV 18.3 18.0 11.6 NY 26.1 131.5 59.0 OH 131.6 88.0 44.0 OK 35.2 35.6 29.5 OR 3.5 26.2 12.9 PA 139.4 104.3 38.9 RI 0.0 7.0 4.0 SC 41.0 38.4 8.1 SD 4.1 7.6 2.3 TN 61.2 50.5 11.9 TX 153.4 296.6 202.4 UT 37.8 19.1 8.8 VA 42.8 71.3 14.9 VT 0.0 6.5 0.5 WA 10.6 58.1 14.1 WI 47.2 41.2 20.3 WV 88.7 17.2 7.1 WY 47.4 10.7 5.8 EXTERNAL INPUT FILES Rather than burdening the user with excessive interactions, external data files may be used. #include <iostream> #include <fstream> using namespace std; void main() { const intMAX_STATE_COUNT = 51; boolstateLocated = false; intstateCount = 0; charuserFirstLetter; charuserSecondLetter; charstateFirstLetter; charstateSecondLetter; doublecoalEmission; doublepetroleumEmission; doublenaturalGasEmission; ifstreamemissionsFile; The fstream library must be included in order to use variables of type ifstream (i.e., input file streams). CHAPTER 4 - RepetitionStructures 39

  40. cout << "Specify the two-letter abbreviation for the" << endl << "state whose emissions you wish to examine: "; cin >> userFirstLetter >> userSecondLetter; emissionsFile.open("StateEmissions.txt"); while ((stateCount < MAX_STATE_COUNT) && (!stateLocated)) { stateCount++; emissionsFile >> stateFirstLetter >> stateSecondLetter; emissionsFile >> coalEmission; emissionsFile >> petroleumEmission; emissionsFile >> naturalGasEmission; stateLocated = ((userFirstLetter == stateFirstLetter) && (userSecondLetter == stateSecondLetter)); } emissionsFile.close(); if (!stateLocated) cout << endl << "The two-letter state abbreviation " << endl << "you provided was improper." << endl << endl; else { cout << endl << stateFirstLetter << stateSecondLetter << " Fuel Emissions (in Millions of " << endl << "Metric Tons of Carbon Dioxide)" << endl; cout << "Coal: " << coalEmission << endl; cout << "Petroleum: " << petroleumEmission << endl; cout << "Natural Gas: " << naturalGasEmission << endl << endl; } return; } CHAPTER 4 - RepetitionStructures 40

  41. EXTERNAL OUTPUT FILES #include <iostream> #include <fstream> #include <string> // Allows character string variables, so user can input file names. #include <cassert> // Allows programmer to terminate program for faulty external files. using namespace std; void main() { charstateFirstLetter; charstateSecondLetter; doublecoalEmission; doublepetroleumEmission; doublenaturalGasEmission; doubletotalEmission; string initialEmissionsFileName; ifstreaminitialEmissionsFile; string finalEmissionsFileName; ofstreamfinalEmissionsFile; cout << "Enter the name of the file containing the initial state emissions data: "; cin >> initialEmissionsFileName; initialEmissionsFile.open(initialEmissionsFileName.c_str()); assert(!initialEmissionsFile.fail()); cout << endl; cout << "Enter the name of the file that will contain the final state emissions data: "; cin >> finalEmissionsFileName; finalEmissionsFile.open(finalEmissionsFileName.c_str()); assert(!finalEmissionsFile.fail()); cout << endl; External files may be used for output, instead of crowding all of the output onto the display monitor. CHAPTER 4 - RepetitionStructures 41

  42. initialEmissionsFile >> stateFirstLetter; // Prime the EOF loop while (!initialEmissionsFile.eof()) { initialEmissionsFile >> stateSecondLetter; initialEmissionsFile >> coalEmission; initialEmissionsFile >> petroleumEmission; initialEmissionsFile >> naturalGasEmission; finalEmissionsFile << stateFirstLetter << stateSecondLetter << " Fuel Emissions (in Millions of“ << endl << " Metric Tons of Carbon Dioxide" << endl << "---------------------------------" << endl; finalEmissionsFile << " Coal: " << coalEmission << endl; finalEmissionsFile << " Petroleum: " << petroleumEmission << endl; finalEmissionsFile << " Natural Gas: " << naturalGasEmission << endl; finalEmissionsFile << " TOTAL: " << coalEmission + petroleumEmission + naturalGasEmission << endl << endl << endl; initialEmissionsFile >> stateFirstLetter; // Reprime the EOF loop } initialEmissionsFile.close(); finalEmissionsFile.close(); cout << "New file " << finalEmissionsFileName << " created and loaded." << endl << endl; return; } AK Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 1.3 Petroleum: 23.8 Natural Gas: 21.9 TOTAL: 47 AL Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 80.7 Petroleum: 38.8 Natural Gas: 20.7 TOTAL: 140.2 AR Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 25.6 Petroleum: 26.2 Natural Gas: 11.9 TOTAL: 63.7 AZ Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 40.3 Petroleum: 37.8 Natural Gas: 18.8 TOTAL: 96.9 CA Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 6.5 Petroleum: 261.5 Natural Gas: 130.9 TOTAL: 398.9 CO Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 36.9 Petroleum: 32.9 Natural Gas: 23.2 TOTAL: 93 CT Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 4.2 Petroleum: 32.7 Natural Gas: 8.6 TOTAL: 45.5 DC Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 0.1 Petroleum: 2.2 Natural Gas: 1.8 TOTAL: 4.1 DE Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 5.1 Petroleum: 9.3 Natural Gas: 2.5 TOTAL: 16.9 FL Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 66.2 Petroleum: 151.9 Natural Gas: 39.9 TOTAL: 258 GA Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 79 Petroleum: 75.2 Natural Gas: 21.5 TOTAL: 175.7 HI Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 1.8 Petroleum: 20.7 Natural Gas: 0.2 TOTAL: 22.7 IA Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 41.9 Petroleum: 27.8 Natural Gas: 12.1 TOTAL: 81.8 ID Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 1.2 Petroleum: 10.3 Natural Gas: 4.1 TOTAL: 15.6 IL Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 101.2 Petroleum: 92.6 Natural Gas: 50.7 TOTAL: 244.5 IN Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 152.6 Petroleum: 58.7 Natural Gas: 28.6 TOTAL: 239.9 KS Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 36.5 Petroleum: 26.9 Natural Gas: 14.4 TOTAL: 77.8 KY Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 91 Petroleum: 48.6 Natural Gas: 11.9 TOTAL: 151.5 LA Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 24.1 Petroleum: 85.3 Natural Gas: 71.2 TOTAL: 180.6 MA Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 9.9 Petroleum: 53.2 Natural Gas: 20.5 TOTAL: 83.6 MD Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 31 Petroleum: 39.3 Natural Gas: 10.4 TOTAL: 80.7 ME Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 0.7 Petroleum: 18.6 Natural Gas: 4 TOTAL: 23.3 MI Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 73.2 Petroleum: 68.3 Natural Gas: 48.4 TOTAL: 189.9 MN Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 35.9 Petroleum: 47.7 Natural Gas: 19.3 TOTAL: 102.9 MO Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 76.4 Petroleum: 49.3 Natural Gas: 14.1 TOTAL: 139.8 MS Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 17.5 Petroleum: 32.3 Natural Gas: 15.4 TOTAL: 65.2 MT Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 18.5 Petroleum: 13 Natural Gas: 3.5 TOTAL: 35 NC Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 74.1 Petroleum: 66.2 Natural Gas: 12 TOTAL: 152.3 ND Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 37.7 Petroleum: 9 Natural Gas: 3.2 TOTAL: 49.9 NE Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 21.2 Petroleum: 16.3 Natural Gas: 6.1 TOTAL: 43.6 NH Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 4.1 Petroleum: 14.4 Natural Gas: 3.4 TOTAL: 21.9 NJ Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 10.6 Petroleum: 84.4 Natural Gas: 33.6 TOTAL: 128.6 NM Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 29.3 Petroleum: 17.5 Natural Gas: 12.2 TOTAL: 59 NV Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 18.3 Petroleum: 18 Natural Gas: 11.6 TOTAL: 47.9 NY Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 26.1 Petroleum: 131.5 Natural Gas: 59 TOTAL: 216.6 OH Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 131.6 Petroleum: 88 Natural Gas: 44 TOTAL: 263.6 OK Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 35.2 Petroleum: 35.6 Natural Gas: 29.5 TOTAL: 100.3 OR Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 3.5 Petroleum: 26.2 Natural Gas: 12.9 TOTAL: 42.6 PA Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 139.4 Petroleum: 104.3 Natural Gas: 38.9 TOTAL: 282.6 RI Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 0 Petroleum: 7 Natural Gas: 4 TOTAL: 11 SC Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 41 Petroleum: 38.4 Natural Gas: 8.1 TOTAL: 87.5 SD Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 4.1 Petroleum: 7.6 Natural Gas: 2.3 TOTAL: 14 TN Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 61.2 Petroleum: 50.5 Natural Gas: 11.9 TOTAL: 123.6 TX Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 153.4 Petroleum: 296.6 Natural Gas: 202.4 TOTAL: 652.4 UT Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 37.8 Petroleum: 19.1 Natural Gas: 8.8 TOTAL: 65.7 VA Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 42.8 Petroleum: 71.3 Natural Gas: 14.9 TOTAL: 129 VT Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 0 Petroleum: 6.5 Natural Gas: 0.5 TOTAL: 7 WA Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 10.6 Petroleum: 58.1 Natural Gas: 14.1 TOTAL: 82.8 WI Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 47.2 Petroleum: 41.2 Natural Gas: 20.3 TOTAL: 108.7 WV Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 88.7 Petroleum: 17.2 Natural Gas: 7.1 TOTAL: 113 WY Fuel Emissions (in Millions of Metric Tons of Carbon Dioxide --------------------------------- Coal: 47.4 Petroleum: 10.7 Natural Gas: 5.8 TOTAL: 63.9 CHAPTER 4 - RepetitionStructures 42

  43. FOR LOOPS Under certain circumstances (e.g., when a loop has a specific number of iterations), then a for loop is somewhat easier to use than a while loop. #include <iostream> #include <fstream> using namespace std; void main() { const intMAXIMUM_BAR_LENGTH = 25; const char MINIMUM_BAR_CHAR = '+'; const char MEAN_BAR_CHAR = '#'; const char MAXIMUM_BAR_CHAR = '$‘; ifstreamdataFile; ofstreamresultsFile; intnbrDaysInYear; intnbrDaysInMonth; intcurrentDayOfYear; intcurrentMonth; intcurrentDayOfMonth; int month; int day; intnbrVehicles; intminNbrVehicles; intmaxNbrVehicles; inttotalNbrVehicles; intmeanNbrVehicles; intabsoluteMaxNbrVehicles; intnbrBarChars; intbarCharIndex; CHAPTER 4 - RepetitionStructures 43

  44. // Open the data file and determine the maximum number of vehicles // entering the parking garage for any day during the year. dataFile.open("ParkingGarageData.txt"); dataFile >> nbrDaysInYear; absoluteMaxNbrVehicles = 0; for (currentDayOfYear = 1; currentDayOfYear <= nbrDaysInYear; currentDayOfYear++) { dataFile >> month >> day >> nbrVehicles; if (nbrVehicles > absoluteMaxNbrVehicles) absoluteMaxNbrVehicles = nbrVehicles; } dataFile.close(); // Reopen the data file and calculate monthly min/max/mean values, // outputting those values to the results file in a bar chart format. dataFile.open("ParkingGarageData.txt"); resultsFile.open("ParkingGarageResults.txt"); dataFile >> nbrDaysInYear; resultsFile << "MONTH-BY-MONTH TABULATION OF VEHICLES ENTERING PARKING GARAGE" << endl << "-------------------------------------------------------------" << endl << endl; for (currentMonth = 1; currentMonth <= 12; currentMonth++) { // Determine number of days in current month. switch (currentMonth) { case 2: { if (nbrDaysInYear == 365) nbrDaysInMonth = 28; else nbrDaysInMonth = 29; break; } case 4: case 6: case 9: case 11: { nbrDaysInMonth = 30; break; } default: { nbrDaysInMonth = 31; break; } } CHAPTER 4 - RepetitionStructures 44

  45. // Use the first day's data to initialize the // month's minimum, maximum, and total values. dataFile >> month >> day >> nbrVehicles; minNbrVehicles = nbrVehicles; maxNbrVehicles = nbrVehicles; totalNbrVehicles = nbrVehicles; // Loop through the rest of the month to determine its // actual minimum, maximum, and total values, and then // calculate the month's mean value. for (currentDayOfMonth = 2; currentDayOfMonth <= nbrDaysInMonth; currentDayOfMonth++) { dataFile >> month >> day >> nbrVehicles; if (nbrVehicles < minNbrVehicles) minNbrVehicles = nbrVehicles; if (nbrVehicles > maxNbrVehicles) maxNbrVehicles = nbrVehicles; totalNbrVehicles += nbrVehicles; } meanNbrVehicles = totalNbrVehicles / nbrDaysInMonth; CHAPTER 4 - RepetitionStructures 45

  46. // Output the results for the month in a horizontal bar chart. if (month < 10) resultsFile << ' '; resultsFile << month << ": "; nbrBarChars = maxNbrVehicles * MAXIMUM_BAR_LENGTH / absoluteMaxNbrVehicles; for (barCharIndex = 1; barCharIndex <= nbrBarChars; barCharIndex++) { if (barCharIndex <= minNbrVehicles * MAXIMUM_BAR_LENGTH / absoluteMaxNbrVehicles) resultsFile << MINIMUM_BAR_CHAR; else if (barCharIndex <= meanNbrVehicles * MAXIMUM_BAR_LENGTH / absoluteMaxNbrVehicles) resultsFile << MEAN_BAR_CHAR; else resultsFile << MAXIMUM_BAR_CHAR; } for (barCharIndex = nbrBarChars + 1; barCharIndex <= MAXIMUM_BAR_LENGTH; barCharIndex++) resultsFile << ' '; resultsFile << " (Min.: " << minNbrVehicles << " Max.: " << maxNbrVehicles << " Mean: " << meanNbrVehicles << ')' << endl << endl; } dataFile.close(); resultsFile.close(); cout << "Results File Created" << endl << endl; return; } CHAPTER 4 - RepetitionStructures 46

  47. 366 1 1 201 1 2 650 1 3 354 1 4 846 1 5 668 1 6 583 1 7 480 1 8 916 1 9 858 1 10 797 1 11 339 1 12 887 1 13 768 1 14 610 1 15 443 1 16 211 1 17 273 1 18 491 1 19 317 1 20 332 1 21 990 1 22 556 1 23 295 1 24 203 1 25 207 1 26 502 1 27 625 1 28 656 1 29 681 1 30 685 1 31 332 5 1 524 5 2 423 5 3 654 5 4 745 5 5 804 5 6 777 5 7 580 5 8 298 5 9 494 5 10 867 5 11 228 5 12 613 5 13 730 5 14 540 5 15 283 5 16 959 5 17 937 5 18 639 5 19 476 5 20 577 5 21 499 5 22 877 5 23 453 5 24 564 5 25 417 5 26 986 5 27 438 5 28 791 5 29 653 5 30 356 5 31 809 2 1 730 2 2 560 2 3 481 2 4 245 2 5 686 2 6 826 2 7 842 2 8 615 2 9 441 2 10 900 2 11 781 2 12 964 2 13 940 2 14 631 2 15 313 2 16 569 2 17 388 2 18 889 2 19 367 2 20 823 2 21 874 2 22 997 2 23 999 2 24 689 2 25 513 2 26 412 2 27 437 2 28 872 2 29 218 3 1 500 3 2 274 3 3 741 3 4 244 3 5 207 3 6 935 3 7 420 3 8 418 3 9 670 3 10 752 3 11 870 3 12 781 3 13 587 3 14 364 3 15 794 3 16 574 3 17 566 3 18 959 3 19 795 3 20 286 3 21 679 3 22 508 3 23 788 3 24 687 3 25 657 3 26 489 3 27 321 3 28 380 3 29 540 3 30 842 3 31 613 4 1 991 4 2 801 4 3 476 4 4 335 4 5 725 4 6 593 4 7 250 4 8 759 4 9 603 4 10 317 4 11 959 4 12 313 4 13 924 4 14 754 4 15 442 4 16 541 4 17 256 4 18 973 4 19 746 4 20 322 4 21 901 4 22 857 4 23 665 4 24 353 4 25 342 4 26 853 4 27 580 4 28 324 4 29 603 4 30 785 6 1 871 6 2 518 6 3 600 6 4 912 6 5 221 6 6 995 6 7 658 6 8 240 6 9 625 6 10 355 6 11 874 6 12 701 6 13 726 6 14 358 6 15 873 6 16 298 6 17 287 6 18 794 6 19 451 6 20 952 6 21 428 6 22 469 6 23 312 6 24 786 6 25 867 6 26 766 6 27 680 6 28 797 6 29 402 6 30 315 7 1 201 7 2 248 7 3 844 7 4 882 7 5 368 7 6 292 7 7 642 7 8 211 7 9 291 7 10 563 7 11 801 7 12 748 7 13 634 7 14 259 7 15 549 7 16 361 7 17 756 7 18 432 7 19 549 7 20 385 7 21 662 7 22 626 7 23 702 7 24 328 7 25 603 7 26 970 7 27 756 7 28 939 7 29 351 7 30 468 7 31 342 8 1 996 8 2 565 8 3 998 8 4 278 8 5 700 8 6 275 8 7 550 8 8 945 8 9 238 8 10 915 8 11 432 8 12 381 8 13 815 8 14 528 8 15 361 8 16 702 8 17 683 8 18 561 8 19 573 8 20 678 8 21 707 8 22 883 8 23 863 8 24 699 8 25 776 8 26 652 8 27 500 8 28 347 8 29 790 8 30 644 8 31 924 9 1 394 9 2 351 9 3 683 9 4 758 9 5 667 9 6 481 9 7 595 9 8 264 9 9 792 9 10 689 9 11 696 9 12 752 9 13 843 9 14 319 9 15 660 9 16 894 9 17 929 9 18 691 9 19 782 9 20 234 9 21 734 9 22 981 9 23 452 9 24 655 9 25 444 9 26 339 9 27 286 9 28 895 9 29 880 9 30 795 10 1 323 10 2 461 10 3 263 10 4 261 10 5 712 10 6 856 10 7 636 10 8 558 10 9 527 10 10 438 10 11 572 10 12 600 10 13 322 10 14 458 10 15 790 10 16 451 10 17 861 10 18 967 10 19 898 10 20 780 10 21 440 10 22 955 10 23 301 10 24 252 10 25 827 10 26 619 10 27 687 10 28 964 10 29 257 10 30 900 10 31 723 11 1 457 11 2 283 11 3 604 11 4 381 11 5 432 11 6 935 11 7 640 11 8 730 11 9 291 11 10 594 11 11 503 11 12 597 11 13 834 11 14 607 11 15 505 11 16 750 11 17 625 11 18 685 11 19 516 11 20 204 11 21 766 11 22 280 11 23 698 11 24 890 11 25 593 11 26 797 11 27 597 11 28 504 11 29 828 11 30 642 12 1 485 12 2 964 12 3 704 12 4 341 12 5 499 12 6 305 12 7 794 12 8 961 12 9 689 12 10 222 12 11 463 12 12 244 12 13 711 12 14 305 12 15 877 12 16 891 12 17 677 12 18 777 12 19 883 12 20 211 12 21 301 12 22 766 12 23 693 12 24 374 12 25 252 12 26 335 12 27 699 12 28 472 12 29 455 12 30 494 12 31 728 MONTH-BY-MONTH TABULATION OF VEHICLES ENTERING PARKING GARAGE ------------------------------------------------------------- 1: +++++########$$$$$$$$$$$ (Min.: 201 Max.: 990 Mean: 540) 2: +++++###########$$$$$$$$$ (Min.: 218 Max.: 999 Mean: 655) 3: +++++#########$$$$$$$$$ (Min.: 207 Max.: 959 Mean: 588) 4: ++++++#########$$$$$$$$$ (Min.: 250 Max.: 991 Mean: 611) 5: +++++##########$$$$$$$$$ (Min.: 228 Max.: 986 Mean: 612) 6: +++++##########$$$$$$$$$ (Min.: 221 Max.: 995 Mean: 604) 7: +++++########$$$$$$$$$$$ (Min.: 201 Max.: 970 Mean: 540) 8: +++++###########$$$$$$$$ (Min.: 238 Max.: 998 Mean: 643) 9: +++++##########$$$$$$$$$ (Min.: 234 Max.: 981 Mean: 631) 10: ++++++#########$$$$$$$$$ (Min.: 252 Max.: 967 Mean: 601) 11: +++++#########$$$$$$$$$ (Min.: 204 Max.: 935 Mean: 592) 12: +++++#########$$$$$$$$$$ (Min.: 211 Max.: 964 Mean: 566) CHAPTER 4 - RepetitionStructures 47

  48. DO-WHILE LOOPS #include <iostream> #include <fstream> #include <string> #include <cassert> using namespace std; void main() { const intMAX_TEMP_GAP = 40; ifstreaminputFile; string inputFileName; intdayNumber = 0; intlowTemp; inthighTemp; While loops require some initialization before determining whether or not to execute their internal statements. Do-while loops eliminate this extra work, with the assumption that the internal statements will always be executed at least once. 89 100 92 105 74 99 78 101 75 103 76 100 72 97 68 92 66 90 67 93 63 98 62 103 67 101 73 97 77 91 70 95 64 98 62 97 60 95 52 98 cout << "Enter the name of the low/high temperature file: "; cin >> inputFileName; inputFile.open(inputFileName.c_str()); assert(!inputFile.fail()); cout << endl; do { inputFile >> lowTemp >> highTemp; dayNumber++; } while ( (highTemp - lowTemp <= MAX_TEMP_GAP) && (!inputFile.eof()) ); if (highTemp - lowTemp > MAX_TEMP_GAP) cout << "Maximum temperature gap exceeded on day #" << dayNumber << " (Low: " << lowTemp << ", High: " << highTemp << ")." << endl << endl; else cout << "No days exceeding maximum temperature gap." << endl << endl; return; } CHAPTER 4 - RepetitionStructures 48

More Related