Chapter 7, Pause Reflect

• 7.1--7.5

• 7.6--7.11

• 7.12--7.18

• 7.19--7.24

• 7.25--7.30

• 7.1 : If the RandGen class then client programs like roll.cpp do NOT need to change, nor does it need to be recompiled. However, it will need to be relinked iwth the new compiled version of dice.cpp which must be recompiled to cope with changes in RandGen

• 7.2 : The behaviors of CTimer are
  • Start -- starts the timer
  • Stop -- stops the timer
  • Reset -- resets the timer (to zero)
  • CumulativeTime -- return the total ticking time of the timer
  • ElapsedTime -- return the time between the last Start/Stop calls

• 7.3 : A Coin class should support flipping and generating heads/tails with equal probability. The method Coin::Flip could return 0 for heads and 1 for tails, or there could be methods that are bool values like Coin c; if (c.FlipIsHeads()) // flipped heads else // flipped tails if (c.FlipIsTails()) // flipped tails

  These bool methods flip the coin and return whether the flip is heads or tails, respectively. The Coin class could also support Coin::NumFlips like the corresponding method in the class Dice.

• 7.4 : Libraries check out books, cds, movies/videos, and other things as well (e.g., children's puzzles). Most libraries allow borrowers to check out a limited number of items, but this limit can be big. Libraries also support inter-library loans (borrowing from a library in a neighboring town, for example.)

  Many other details need to be filled in here.

• 7.5 : Candidate classes include the following, not all would be used in a program (e.g., Chip probably wouldn't be a class).
  • Wheel
  • Bet
  • Bankroll
  • Player
  • Chip

  More details will emerge as you write your own description.

7.6 -- 7.11

• 7.6 : myQuestion is constructed in the Quiz::Quiz constructor.

• 7.7 : The parameter s to Quiz::GiveQuestionTo must be reference parameter because s will be modified during the quiz, e.g., to record the number of correct and incorrect responses. Because these values will be stored in instance variables, e.g., myCorrectCount, and these variables change, the parameter cannot be const since const parameters don't change.

• 7.8 : Here's a reasonable postcondition, there are others: bool Student::RespondTo(const Question& q) // post: returns true if response to q is correct, else returns false

• 7.9 : In the original version of RespondTo in Program 7.2, the function was void -- the user typed in an answer and a correct/incorrect response was printed. In the version in Program 7.3, the function returns a bool value of true if the response is correct, client code can print a message. It's appropriate to change the function so that different messages can be printed. For example, in Program 7.3 a re-try to answer again is given to the user. It wouldn't be possible to use different strings to respond to the user if the strings were hard-wired into the function as in the original version.

• 7.10 : The Question parameter to Student::RespondTo can be const-reference. The student RespondTo function generates a question (using Question::Ask) and determines if the response is correct (using Question::IsCorrect). Both of these functions can be executed without changing a Question, so the Question parameter can be const. Note that in the code furnished with the book it's a reference parameter, not a const-reference parameter, but it can be changed to const.

• 7.11 : The correct answer is probably determined when the question is asked, and stored in a private variable like myAnswer. The answer must be generated when the question is asked, but it's not used until later (when the function Answer is called, for example.)

7.12-- 7.18

• 7.12 : Create a private instance variable string myColor; In the function Create roll a 2-sided dice and set myColor to blue or red depending on the roll (any two colors can be used). Then access myColor in the function Answer, just execute return myColor.

• 7.13 : Values that are not valid floating-point expressions are converted to zero by atof.

• 7.14 : Yes, if a user types "23skidoo" when prompted for an int, the 23 is read and the remainder of the string: "skidoo" remains on the input stream.

• 7.15 : The function Question::Ask is const because it doesn't modify any internal state (instance variables) of the class Question.

• 7.16 : Here's the constructor: Game::Game() : myCube(6), myBankRoll(5000) { }

  An initializer list is required because the class Dice doesn't have a default/parameterless constructor.

• 7.17 : Here's one version of the function void reportScores(const Student& s, int numQuestions) // post: print a message reporting student's score based on a quiz // of numQuestions questions { cout << s.Name() << " score:\t" << s.Score() << " out of " << numQuestions << " = " << double(s.Score())/numQuestions * 100 << "%" << endl; }

• 7.18 : If Question::Ask is called without creating a question the question printed will be:

         0
      +  0
    -------
  

  But the answer will never be correct since the value returned by Answer is the string "*** error ***". These values are set in the constructor Question::Question.

7.19-- 7.24

• 7.19: Spaces aren't used so that the strings can be read using the extraction operator >>. If spaces were used then New York would be read as "New", leaving "York" still on the stream for reading.

• 7.20 : The header file <string> has lines at the top of it similar to this: #ifndef _STRING_H #define _STRING_H // string stuff here #endif

  That prevent a file from being included more than once by the preprocessor. The actual values defined and tested may not be _STRING_H, but the idea applies regardless of the value.

• 7.21: quiz.cpp does not depend on "randgen.h" since quiz.cpp includes the header file "capquest.h", but doesn't include the file capquest.cpp. A file depends only on those files it includes (and the files that these included files include, and so on).

• 7.22 : Since quiz.cpp includes capquest.h (or mathquest.h) quiz.cpp depends on this header file and on whatever .h files capquest.h includes. However, "randgen.h" is NOT included in capquest.h or in files it includes, so a change to "randgen.h" doesn't require recompiling quiz.cpp (see question 7.20). However, quiz.cpp will need to be relinked to get the new version of capquest.cpp which was recompiled since it included "randgen.h".

• 7.23 : The file could be read once in the Question constructor counting the lines. This value could be stored in an instance/data variable myLines. Then the value of myLines could be used instead of 49 as follows: int toSkip = gen.RandInt(0, myLines-1);

• 7.24 : You could change the declaration of Question in "capquest.h" so that it includes the following: class Question { public: Question(const string& filename, const string& prompt); // other stuff as in original version private: string myAnswer; string myQuestion; WordStreamIterator myIter; string myPrompt; // prompt for response };

  Then to create a question about artists/groups construct a Question object as follows:

  Question("artists.txt", "What group created"); So that the program might be run showing:

    What group created The_Joshua_Tree ? U2
    yes, that's correct
    What group created A_Live_One ? fish
    no, try one more time
    What group created A_Live_One ? whales
    no, correct answer is Phish
  

7.25 -- 7.30

• 7.25 : A do-while loop would be useful (assuming the number of steps from the start is positive). The code might resemble what's shown below.
  #include <iostream> #include <cmath> // for fabs using namespace std; #include "dice.h" #include "prompt.h" // simulate one-dimensional random walk // until end-point reached int main() { int finalPos = PromptRange("enter final position",0,1000000); int numSteps = 0; // # of steps taken int position = 0; // "frog" starts at position 0 Dice die(2); // used for "coin flipping" do { switch (die.Roll()) { case 1: position++; // step to the right break; case 2: position--; // step to the left break; } numSteps++; } while (fabs(position) != finalPos); cout << "number of steps = " << numSteps << endl; return 0; }
• 7.26 : One possible header: void DoSimulation(int numSteps, int & distFinal, int & distMax) // precondition: numSteps = duration of random walk simulation // postcondition: distFinal = final distance from start of simulated // random walk, distMax = maximal distance from start

• 7.27 : One such expression is shown below.

          position += 2*die.Roll() - 1;
  

  since 2*die.Roll() is either 0 or 2, the right-hand-side of the expression evaluates to either -1 or +1.

• 7.28 : To simulate a walk on a lattice (sometimes this kind of distance is called Manhattan-geometry after the gridwork-like layout of streets in New York City), a four sided die could be rolled with the outcome indicating whether a step is taken in the North/South/East/West direction. It is necessary to keep both x/y coordinates so the class RandomWalk2D is more appropriate than RandomWalk although the coordinates are integers for lattice-walking instead of doubles.

  Another approach might use a coin or two-sided die to determine whether the north/south OR the east/west direction would change. Another two sided die could determine up/down or left/right.

  For RandomWalk2D the function RandomWalk2D:TakeStep would need to be modified to use a four-sided Dice rather than the RandGen variable (although it's possible to use RandInt instead of RandReal, but the Dice class takes care of this for you).

• 7.29 : It is more likely that the one-dimensional random walk will visit the origin than that the two-dimensional walk will return to the origin. In both cases it is possible for this to happen. However, it is extremely unlikely in the 2-D case that the coordinates will be exactly (0.0, 0.0) once the walker takes one step.

• 7.30 : Imagine a circle of n lilly-pads. If the pads are arranged in a circle, jumping from one to the other is like walking in a circle. This can be done by equating pads with numbers 0, 1, 2, ... (n-1). A "left" jump in the walk.cpp implementation corresponds to subtracting 1 from the current "pad". However, an if statement can be used to equate -1 with (n-1) so that such a jump continues around the circle. void RandomWalk::TakeStep() { Dice coin(2); switch (coin.Roll()) { case 1: myPosition--; break; case 2: myPosition++; break; } if (myPosition >= myNumPads) { myPosition = 0; } else if (myPosition < 0) { myPosition = myNumPads - 1; } mySteps++; } It's possible to replace the if-else statement with a calculation using %, but % doesn't always work properly for negative numbers.