Chapter 9, Pause Reflect

• 9.1--9.8

• 9.9--9.12

• 9.13--9.17

• 9.18--9.23

• 9.1: To make the function todigit more robust it should trap values that aren't digits and return equivalent values:
  if (isdigit(c)) { return c - '0'; } else { return c; // return value unchanged, not a digit } This way the function returns a value even when its precondition isn't satisfied.

• 9.2: "Zebra" < "aardvark" because, in the ASCII system, the character 'Z' preceeds the character 'a'. In fact all uppercase letters come before any lowercase letter. When the case is the same, as with "aardvark" and "yak" the ASCII order is the same as lexicographical (alphabetical) order.

• 9.3: The statement cout << 'a' + 3 << endl; prints 100 because addition promotes its operands to the 'higher' type, in this case to int. As an int, 'a' is 97 in ASCII, so 100 is printed. When 100 is cast to a char by the statement cout << char ('a' + 3) << endl; then 'd' is printed because 100 is ASCII for 'd'.

• 9.4: iscntrl('\t') is true (non-zero) because tab, the char '\t' is a control character (it's CNTRL-I). isspace('\t') is true (non-zero) as well since the tab character is whitespace. Finally, islower('\t') is false (zero) since the tab character is not in the range 'a'..'z'.

• 9.5: One version is shown below: bool IsVowel(char ch) // postcondition: returns 1 if ch is a vowel, i.e., 'a', 'e', 'i', 'o',' u' // returns 0 otherwise { char check = tolower(ch); // make lowercase if (check == 'a' || check == 'e' || check == 'i' || check == 'o' || check == 'u') { return true; } else { return false; } }

  Alternatively the body can be:

  return (check == 'a' || check == 'e' || check == 'i' || check == 'o' || check == 'u');

  To write IsConsonant, just use as the function body:

  return ! IsVowel(ch); since any non-vowel is a consonant.

• 9.6: One version below: bool IsPalindrome(const string& s) // postcondition: returns true if s is a palindrome, else false { int mid = s.length()/2; // middle char int last = s.length() - 1; // last char for(k=0; k < mid; k++) { if (s[k] != s[last]) { return false; } last--; // move towards 'left' } return true; // all chars match, is palindrome }

  It's possible to dispense with local variable 'last' and use as the if statement:

  if (s[k] != s[len-k-1]) where int len = s.length(); However, it's harder to see immediately (for most people) that this is correct.

• 9.7: One version below, s is a reference parameter since the string changes and the changes must be communicated back to the statement making the call to MakeLower. void MakeLower(string & s) // postcondition: all letters in s are lower case { int len = s.length(); int k; for(k=0; k < len; k++) { s[k] = tolower(s[k]); // converts to lower as necessary } }

• 9.8: The version below doesn't work for negative numbers: int atoi(const string& s) // pre: s represents a valid integer, e.g., "1234", NOT "a123" // this function only deals with non-negative numbers // post: returns int equivalent of s { int value = 0; int k; int len = s.length(); for(k=0; k < len; k++) { value *= 10; // shift to the left (multiply by 10) value += todigit(s[k]); // see problem 9.1 above } return value; } To work for negative numbers, one easy fix is to check s[0] == '-'. If this is true, skip the character when processing digits, and remember (use a flag variable) that the number is negative. Before returning value, multiply by -1 if the s[0] was '-'.

9.9 -- 9.12

• 9.9: One solution below. It's important to use getline for all user-input when it's used anywhere. Since getline eats the newline at the end of a line, but >> does NOT, mixing these two methods for processing input is hard because it's easy for coders to forget whether a newline is still sitting on the input stream waiting to be processed. #include <iostream> #include <fstream> #include <string> using namespace std; int main() { string filename, group, groupLine,titleLine; cout << "enter name of file: "; getline(cin,filename); cout << "enter name of group: "; getline(cin,group); ifstream input(filename.c_str()); // bound to filename textfile if (input.fail()) { cout << "could not open " << filename << endl; exit(1); } while (getline(input,groupLine)) { getline(input,titleLine); // read title (line after group) if (groupLine == group) { cout << titleLine << endl; } } return 0; }

• 9.10: Since the statement input.get(ch); sets 'ch' to have a value, it must be passed by reference (a value parameter cannot be changed when it is passed to a function with the change communicated back).

• 9.11: To prompt for the name of the output file the following can be used (alternatively, use PromptString to prompt, use output.open(filename.c_str()) to open file file after defining output). cout << "enter name of output file: "; cin >> filename; ofstream output(filename.c_str());

  and the body of the while loop can be the single statement:

  output << ch;

  or, alternatively,

  output.put(ch);

  Where the put member function is the 'opposite' of the get function.

• 9.12: To modify upper to lower case letters, use the statement: output << tolower(ch);

9.13 -- 9.17

• 9.13: All the output from the program is done in the function Echo(char ch). To modify the program so that the output goes to a file (whose name is specified by the user) the simplest approach is to use a global variable: ofstream output;

  In main() prompt the user for a file name and open the file:

  string outfilename = PromptString("enter filename for output: "); output.open(outfilename.c_str());

  Then modify Echo() as shown:

  void Echo(char ch) { output << ch; }

  To avoid the global variable in the current program, pass output to Echo() each time Echo() is called (make sure to pass streams by reference).

• 9.14: The diagram here shows one state transition sequence for removing /* ... */ comments.

• 9.15: Here's a program with two states: #include <iostream> #include <fstream> #include <cstdlib> // for exit using namespace std; #include "prompt.h" // Owen Astrachan 7/4/1996, revised 5/4/99 // state-machine approach for removing all // comments from a file // (doesn't handle // in a string, e.g., " test // comment " class Decomment { public: Decomment(); void Transform(istream& input, ostream& output); private: void Echo(char ch, ostream& output); const char SLASH; const char NEWLINE; enum ReadState{TEXT, FIRST_SLASH}; }; Decomment::Decomment() : SLASH('/'), NEWLINE('\n') { // constants initialized } void Decomment::Echo(char ch, ostream& output) { output << ch; } void Decomment::Transform(istream& input, ostream& output) { char ch; ReadState currentState = TEXT; while (input.get(ch)) // read one char at a time { switch(currentState) { case TEXT: if (ch == SLASH) // potential comment begins { currentState = FIRST_SLASH; } else { Echo(ch); } break; case FIRST_SLASH: if (ch == SLASH) { string dummy; getline(input,dummy); Echo(NEWLINE); currentState = TEXT; } else // one slash not followed by another { Echo(SLASH); // print the slash from last time Echo(ch); // and the current character currentState = TEXT; // reading uncommented text } break; } } } int main() { string filename = PromptString("enter filename: "); ifstream input(filename.c_str()); if (input.fail()) { cout << "could not open " << filename << " for reading" << endl; exit(1); } Decomment dc; dc.Transform(input,cout); return 0; }

• 9.16 To avoid removing // sequences in a string, you will need to recognize strings. Have a state called STRING that is entered when a double quote " is read when in the state TEXT. Echo characters until a double quote is read again when the state goes back to text.

  Summary:

  • From TEXT move to STRING when reading ", echo the ".
  • From STRING move to TEXT when reading ", echo the ".
  • From STRING stay in STRING on any non " char, echo the char
  No other changes.

• 9.17 (coming soon)

9.18 -- 9.23

• 9.18: The reason that leading whitespace is included in the title is because the getline(input,seconds,' ') used to read the seconds reads up to the first space, and discards the space. If there are more spaces these will be read by the getline(input,title) and be part of the string title. The easiest way to remove leading spaces (and trailing spaces) is to call the function StripWhite in the library of string functions in strutils.h and strutils.cpp. You can look at the code in strutils.cpp to see how to do this.

• 9.19: You want to use data that tests many cases in the addition of two ClockTime values. This would include data that needs two carries (the 40 + 20 carry results in the second carry of 20 + 39 + 1)

  0 20 40    0 39 20
  

  You probably want to test "bad" values too:

   1 70 80 1 20 90
  

  You may want to test zero values so just hours are added (similarly just minutes or just seconds).

   1 0 0 2 0 0
  

• 9.20: The parameters are const reference parameters because:
  • Pass by reference to avoid making a copy (basically for efficiency reasons).
  • Pass as const because the operators do not change the parameter, so const if used for safety, so that programmers who use const can call the functions -- since they don't alter the ClockTime object the parameter should be defined as const.
  In general, except for built-in types like int, double, and bool you should pass other types by reference or by const reference, not by value --- avoid making copies. If you need a copy, you can make one in the function, e.g., the function below makes a copy of the parameter foo: void DoThis(const Thing& foo) { Thing copyOfFoo(foo); // also could use Thing copyOfFoo = foo; // use copyOfFoo instead of foo here }

• 9.21: The output is shown below:

  1:16:71
  1:62:05
  0:00:12
  0:00:00
  

• 9.23: It's almost always easier to implement operator -= first, then use this to implement operator - (as done in the text for += and +). An implementation of operator -= is below: (not fully tested) ClockTime& ClockTime::operator -=(const ClockTime & ct) { // code below could result in negative time, e.g., 1:00:00 - 2:00:00 mySeconds -= ct.mySeconds; // subtract seconds if (mySeconds < 0) { mySeconds += 60; // borrow 60 seconds from minutes myMinutes -= 1; } myMinutes -= ct.myMinutes; // subtract minutes if (myMinutes < 0) { myMinutes += 60; // borrow 60 mintues from hours myHours -= 1; } myHours -= ct.myHours; Normalize(); // be safe return *this; }

• 9.23: The statement input >> seconds will stop reading the string seconds when whitespace is reached (whitespace is space, tab, or newline), because operator >> delimits strings with whitespace. However, using >> will leave the whitespace on the stream so that every title will begin with some whitespace (but see pause/reflect question 9.18). If seconds is an int, it's possible to use operator >> since the operator can read ints, strings, doubles, etc..