CSCI 159 Lab 3 (Sept 29/Oct 1)

CSCI 159 Lab 3 exercises

Lab3 will consist of two parts:

a basic/warmup exercise (basic.cpp), worth 5 marks
the main design/implementation exercise (lab3.cpp), worth 10 marks
both parts are due before the start of lab 4

Hopefully most people complete all of the basic exercise and get a start on the main exercise within their scheduled lab section on Oct. 6/8.

Here is the collection of new C++ syntax elements we'll be using for lab3.

Follow our usual setup process

Log in, open a browser, go to the lab3 page, open a terminal window:
(see lab 2 if you need a refresher on any of the steps)
get lab 3:
make -f make159 csci159/lab3
Go into your lab3 directory and begin the edit/compile/test/submit routine:
- to edit basic.cpp: pluma basic.cpp &
- to compile basic.cpp: make basicx
- to test basicx: ./basicx
- to submit: make submit
  once we get to the second half of today's lab:
- to edit lab3.cpp: pluma lab3.cpp &
- to compile lab3.cpp to create lab3x: make lab3x
- to test lab3x: ./lab3x
- to submit: make submit
As with previous labs, you'll see that the two .cpp files are nearly empty to start with.

Part 1: the basics of this lab's new C++ features (basic.cpp)

For the first part of today's lab exercise we're adding code to a basic.cpp to experiment with the use of if/else if/else statements in C++ in several ways:

First: just the basic syntax and its use to show different results depending on the user's choice
Second: using it to check that user input matches
Third: using it to build recursive functions, functions that run themselves over and over until a desired condition is met. (In this case getting the user to keep trying until they give us valid input.)

As always, be sure you're following the course code standards as you write your code, and don't forget to 'make submit'.

0. Set up three different functions for main to run (for steps 1,2,3)
- To keep our main routine simpler, lets have it call three functions: one to run the code for step 1, one to run the code for step 2, and one to run the code for step 3.
- First let's build a stepOne function and have main call it:
  - It's not going to take any parameters (i.e. parameter list is just ()) nor will it return any values (i.e. return type is void), so the prototype above int main will just be
    void stepOne();
  - The call from inside main doesn't need to do anything but run the function, i.e.
    int main() { stepOne(); }
  - The implementation after the end of main will just print out a "This is step 1" message for now, we'll fill in more content later.
    void stepOne() { std::cout << "This is step one" << std::endl; }
  - Compile and run the program to be sure it works
- Now build similar functions for stepTwo and stepThree (prototypes and implementations) and have main call them in sequence, i.e.
  int main() { stepOne(); stepTwo(); stepThree(); }

1. Basic use of if/else in a program

For step 1, inside the body of your stepOne function at the bottom of the program, we'll experiment with the use of if/else if/else.
We'll get the user to enter their score for a test, and we'll tell them if it was an F, an A+, or somewhere in between.
First, get them to provide their score and store it in a variable, so declare a float variable for their score, prompt them with a cout, and read it with a cin.
void stepOne() { // get the user's score float score; std::cout << "Please enter your test score (0-100): "; std::cin >> score; }
(compile and run your program to be sure it works so far)

Now we'll add an if statement that checks if they got less than 49.5 (so an F):

void stepOne()
{
   // get the user's score
   float score;
   std::cout << "Please enter your test score (0-100): ";
   std::cin >> score;
   if (score < 49.5) {
      std::cout << "Sorry, but that is an F grade" << std::endl;
   }
}

Compile and run your program a couple of times with different values (a value less than 49.5, a value greater than 49.5, and try one run with exactly 49.5)

Otherwise (i.e. if it wasn't an F) we'll add a second case to see if they got at least 89.5 (an A+):

void stepOne()
{
   // get the user's score
   float score;
   std::cout << "Please enter your test score (0-100): ";
   std::cin >> score;

   // check for fail
   if (score < 49.5) {
      std::cout << "Sorry, but that is an F grade" << std::endl;
   }

   // check for A+
   else if (score >= 89.5) {
      std::cout << "Congrats, that is an A+ grade" << std::endl;
   }
}

Compile and test again with several values (something < 49.5, something > 89.5, exactly 49.5, exactly 89.5, and something in between).

Finally, we'll add a general case to catch the scores in the middle:

void stepOne()
{
   // get the user's score
   float score;
   std::cout << "Please enter your test score (0-100): ";
   std::cin >> score;

   // check for fail
   if (score < 49.5) {
      std::cout << "Sorry, but that is an F grade" << std::endl;
   }

   // check for A+
   else if (score >= 89.5) {
      std::cout << "Congrats, that is an A+ grade" << std::endl;
   }

   // give a message for anything in between
   else {
      std::cout << "That was somewhere in the D to A range" << std::endl;
   }
}

2. Checking of user input

For step 2 (in the body of your stepTwo function), we'll try catching instances where the user enters an invalid type of data. Specifically, if we ask them for a number and instead they enter text (e.g. "foo").

First let's set up a typical prompt/read scenario:

void stepTwo()
{
   // get a positive number (greater than zero) from the user
   float posNum;
   std::cout << "Please enter a number greater than zero, e.g. 17.123: ";
   std::cin >> posNum;
   std::cout << "You entered " << posNum << std::endl;
}

Compile it and test it several times, e.g. -1, 0, 13.5, and try one run with a non-number (e.g. blah).

Now lets get it to display an error message and try again when they enter a non-number.

We'll do this by using cin.fail to detect when the data type of what the user entered was incompatible with the variable we tried to store it in (e.g. our variable is a float but they type in foo).

When we give error messages it can be handy to use a second output stream, cerr, instead of cout. This works just like cout normally, but gives more advanced linux users the ability to send regular output one place and error information somewhere else (e.g. to an error log someplace).

void stepTwo()
{
   // get a positive number (greater than zero) from the user
   float posNum;
   std::cout << "Please enter a number greater than zero, e.g. 17.123: ";
   std::cin >> posNum;

   // check for non-numeric input causing cin to fail
   if (std::cin.fail()) {
      std::cerr << "Sorry, only numeric input is accepted, please try again" << std::endl;
      std::cin >> posNum;
   }

   // echo their response back to them
   std::cout << "You entered " << posNum << std::endl;
}

Try running your program and entering non-numeric input (e.g. foo) for the response.
Notice that the cin for trying again doesn't actually give you a chance to type anything! We'll fix that next.

The reason it didn't work is because when cin fails (since it can't read a text word into a float variable) it doesn't actually read the word in -- it leaves that word sitting in the input and doesn't put anything into the variable (as if the cin never happened).

What it does do is set up an internal error value someplace, saying that cin just failed.

To clean things up we need to do three things:

let the user know what's going on (i.e. give them an error and try again message)
clear that internal error value, so cin knows we're fixing the problem
clean the garbage input out of the buffer so the next cin doesn't grab the same bad input

Clearing the internal error is done with a cin.clear() command, while clearing the garbage out of the input buffer is done by telling cin to ignore (skip) a bunch of characters or until it hits the end of the line.

Our revised version adds the clear and ignore lines below:

void stepTwo()
{
   // get a positive number (greater than zero) from the user
   float posNum;
   std::cout << "Please enter a number greater than zero, e.g. 17.123: ";
   std::cin >> posNum;

   // check for non-numeric input causing cin to fail
   if (std::cin.fail()) {
      std::cerr << "Sorry, only numeric input is accepted, please try again" << std::endl;
      std::cin.clear();  // clean up the internal error
      std::cin.ignore(80, '\n'); // clean out the garbage text in the input buffer
      std::cin >> posNum;
   }

   // echo their response back to them
   std::cout << "You entered " << posNum << std::endl;
}

Now compile and test again, entering something like foo the first attempt but a valid value the second try.

Now let's get it to also check that the value they entered was greater than zero.

THE ORDER HERE IS IMPORTANT: test for non-numeric first, only test in-range if you're already sure the data type is correct.

void stepTwo()
{
   // get a positive number (greater than zero) from the user
   float posNum;
   std::cout << "Please enter a number greater than zero, e.g. 17.123: ";
   std::cin >> posNum;

   // check for non-numeric input causing cin to fail
   if (std::cin.fail()) {
      std::cerr << "Sorry, only numeric input is accepted, please try again" << std::endl;
      std::cin.clear();  // clean up the internal error
      std::cin.ignore(80, '\n'); // clean out the garbage text in the input buffer
      std::cin >> posNum;
   }

   // otherwise, i.e. if cin didn't fail, we can check if the value was too small
   else if (posNum <= 0) {
      std::cerr << "Sorry, your value (" << posNum << ") was not greater than zero.";
      std::cerr << "Please try again" << std::endl;
      std::cin >> posNum;
   }

   // echo their response back to them
   std::cout << "You entered " << posNum << std::endl;
}

Compile and try it out, entering a negative number or 0, and you should see it correctly catches the error and gets you to try again.

Note that we didn't do the clear/ignore this time because cin never actually failed: the user did enter a number (so cin worked fine), but we still need them to try again because the number wasn't one we wanted.

You may have noticed that the code only gives one chance to try again: if the user enters two consecutive invalid answers it doesn't do any error checking on the second one. We'll address that problem in step 3 below.

3. Intro to recursion

For step 3 we'll get the user to try again and again until they get it right: this time lets get them to give us an integer from 1 to 100.

We'll start with similar logic to step two, but we'll skip the second cin's for now and we'll add a section to catch numbers that are too big:

void stepThree()
{
   // get an integer in the range 1 to 100
   int score;
   std::cout << "Please enter an integer in the range 1-100: ";
   std::cin >> score;

   // check for non-integer input causing cin to fail
   if (std::cin.fail()) {
      std::cerr << "Sorry, only integer input is accepted, please try again" << std::endl;
      std::cin.clear();  // clean up the internal error
      std::cin.ignore(80, '\n'); // clean out the garbage text in the input buffer
   }

   // otherwise, i.e. if cin didn't fail, we can check if the value was too small
   else if (score < 1) {
      std::cerr << "Sorry, your value (" << score << ") was smaller than one.";
      std::cerr << "Please try again" << std::endl;
   }

   // otherwise we can check if it was too big
   else if (score > 100) {
      std::cerr << "Sorry, your value (" << score << ") was bigger than 100.";
      std::cerr << "Please try again" << std::endl;
   }

   // otherwise echo their response back to them
   else {
      std::cout << "You selected a valid value: " << score << std::endl;
   }
}

If you compile and test, you should see the error messages are correct, but it doesn't yet actually let you try again.

Each place where we need the user to try again we'll actually run the entire function anew: calling stepThree() to start a brand new run of the function (with its own score variable, to do its own cins and error checking on whatever the user types in next).

void stepThree()
{
   // get an integer in the range 1 to 100
   int score;
   std::cout << "Please enter an integer in the range 1-100: ";
   std::cin >> score;

   // check for non-integer input causing cin to fail
   if (std::cin.fail()) {
      std::cerr << "Sorry, only integer input is accepted, please try again" << std::endl;
      std::cin.clear();  // clean up the internal error
      std::cin.ignore(80, '\n'); // clean out the garbage text in the input buffer
      stepThree(); // start a new run of the function to try again
   }

   // otherwise, i.e. if cin didn't fail, we can check if the value was too small
   else if (score < 1) {
      std::cerr << "Sorry, your value (" << score << ") was smaller than one.";
      std::cerr << "Please try again" << std::endl;
      stepThree(); // start a new run of the function to try again
   }

   // otherwise we can check if it was too big
   else if (score > 100) {
      std::cerr << "Sorry, your value (" << score << ") was bigger than 100.";
      std::cerr << "Please try again" << std::endl;
      stepThree(); // start a new run of the function to try again
   }

   // otherwise echo their response back to them
   else {
      std::cout << "You selected a valid value: " << score << std::endl;
   }
}

If you compile and test again, you should see it now works correctly: letting the user try over and over, giving any sequence of invalid responses before eventually giving a correct one.

Tip for moving on to lab3.cpp (not a required step in stepThree):
the stepThree we just did works fine, but doesn't need to return a value. If we had something like "int stepThree();" that was actually supposed to return the valid value in the end then we'd need to store the correct values at each point and return them at the end, e.g.:

int stepThree()
{
   // get an integer in the range 1 to 100
   int score;
   std::cout << "Please enter an integer in the range 1-100: ";
   std::cin >> score;

   // check for non-integer input causing cin to fail
   if (std::cin.fail()) {
      std::cerr << "Sorry, only integer input is accepted, please try again" << std::endl;
      std::cin.clear();  // clean up the internal error
      std::cin.ignore(80, '\n'); // clean out the garbage text in the input buffer
      score = stepThree(); // run stepThree again, record the value it gives back
   }

   // otherwise, i.e. if cin didn't fail, we can check if the value was too small
   else if (score < 1) {
      std::cerr << "Sorry, your value (" << score << ") was smaller than one.";
      std::cerr << "Please try again" << std::endl;
      score = stepThree(); // run stepThree again, record the value it gives back
   }

   // otherwise we can check if it was too big
   else if (score > 100) {
      std::cerr << "Sorry, your value (" << score << ") was bigger than 100.";
      std::cerr << "Please try again" << std::endl;
      score = stepThree(); // run stepThree again, record the value it gives back
   }

   // otherwise echo their response back to them
   else {
      std::cout << "You selected a valid value: " << score << std::endl;
   }

   // return the valid value we wound up with
   return score;
}

Part 2: design and implementation exercise (lab3.cpp)

Now we want to take our new error checking and recursion capabilities and put them to good use in our HowManyFit program from the previous lab.

For this lab you must use a good modular (function based) design, and must use recursive functions for the repetition aspects.

If your lab2 solution already had a suitable design then feel free to use it as the starting point (and you'll probably find the second half of lab 3 to be relatively quick and painless), otherwise you are welcome to come up with a new design and/or use the lab2.cpp sample solution as a guide.

Since user input error checking, if/else if/else, and recursion are the things we are specifically trying to practice in this lab, the new behaviour and restrictions for our program are as follows:

Where-ever the user is asked to input a numeric value (i.e. where they're where they're asked the size of a container) you must call a recursive function to get their response, error check it, and repeat until a valid response is given.

Reminder: the appropriate cycle to get/check is:
  - attempt to read the value into your int variable
  - if they entered a non-number
       display a suitable error message (cerr)
       clear the error (cin.clear)
       clear the garbage input out of the buffer (cin.ignore)
       make a recursive call to try again, putting the returned value into your variable
  - otherwise if they entered a negative value
       display a suitable error message (cerr)
       make a recursive call to try again, putting the returned value into your variable
  - otherwise the value is fine
  - return the result

You must use recursive functions to get, check, (and repeat if necessary) the user input for the sizes of the containers.

The output below shows what a snippet of the program behaviour might look like while trying to get a container size from the user, here showing the user input in bold italics just for clarity. (The example below assumes they entered carton as the name of the container type.)

Please enter the size of a(n) carton in litres (e.g. 4.6): foo
Sorry, that was not a valid number, please try again.

Please enter the size of a(n) carton in litres (e.g. 4.6): -3
Sorry, the size must be a positive number, please try again.

Please enter the size of a(n) carton in litres (e.g. 4.6): huh?
Sorry, that was not a valid number, please try again.

Please enter the size of a(n) carton in litres (e.g. 4.6): 17.41

(at this point the program moves along normally)