CSCI 159 Lab 2 (Sept 18th/20th)

CSCI 159 Lab 2 exercises

Lab2 will consist of two parts:

a basic/warmup exercise (basic.cpp), worth 6 marks
the main design/implementation exercise (lab2.cpp), worth 12 marks
DEADLINE CHANGED: both parts are due before the start of lab 3 (Oct. 7/9), but part 1 is very useful practice for the first quiz so I'd still recommend getting through as much of it as possible before your quiz on the 23rd or 25th.

Hopefully most people complete all of the basic exercise and get a good start on the main exercise within their scheduled lab section on Sept. 16/18th.

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

Today we'll also experiment with a different editor, pluma

Refresher: logging in and setting up

logging in
opening the browser and today's lab page
opening a terminal window
using make159 to get lab2
getting into lab2 and the edit/compile/test/submit cycle

New: getting feedback/marks from the previous lab(s)

getting the feedback directory the first time
updating the feedback directory (for later labs)
seeing the feedback files

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 program to experiment with some of of the more unusual behaviour and limitations of simple data types, while also learning to 'code to standards' as we go. Of course we'll get more practice with the edit/compile/test/submit cycle as we go.

We'll also try to create and call a function of our own: passing data to it, having it perform computation and return a result which our main routine can then use.

Go through the various steps, adding each to your basic.cpp main routine as you go.

code standards and 'coding to standards' as we write
1. demonstrating integer division and modulo (remainder)
- Add a comment saying this is the code section for step 1
- Declare four int variables, numerator, denominator, quotient and remainder.
- Use cout to prompt the user to enter two integer values.
- Use cin to read the user's values into the numerator and denominator variables.
- Compute the quotient and remainder using the / and % operators:
```
  quotient = numerator / denominator;
  remainder = numerator % denominator;
```
- Use cout to display the four variables with reasonable clarifying text, e.g. so the end result would look something like "After dividing 13 by 5 the quotient is 2 and the remainder is 3"
- Compile and debug your program and run it several times testing with different combinations of numerator and denominator. Some sample test values and expected results might be:
  user inputs expected output
  
  numerator denominator quotient remainder
  
  17 5 3 2
  
  11 13 0 11
  
  12 4 3 0
  
  (make sure you're clear on why these are the expected results)
- Do a 'make submit' when you're confident this works.
2. exploring the limits of integer and floating point variables
- Add #include statements for two additional libraries at the top of the program: <cfloat> and <climits>. (You'll need two #include statements, one for each library.) These libraries include the definitions of the constants that tell us what the biggest allowable short, int, long, float, and double are.
  The rest of the code for step 2 will go in the main routine, after the end of your step 1 code - for the sake of readability be sure to have at least one blank line between the two sections.
- Add a comment saying this is the code section for step 2.
- Have a look at the syntax examples, declare a variable of type int and a variable of type float and assign the maximum allowable value to each (INT_MAX and FLT_MAX), and use a cout to display each (with a clear message for the user so they understand what's being displayed).
- Add one to the int variable then display its new value (with a clear message).
- Double the value in the float variable (e.g. f = f * 2;) then display its new value (again with a clear message).
- Make sure you understand why we get the behaviour we see from the steps above,
  then do a 'make submit'.
3. using the char datatype for single characters
- After the end of your step 2 code, add a blank line or two and a comment saying this is the code section for step 3.
- Declare two variables, named userInitial and testChar, each of type char.
- For the testChar variable, assign it a value of '!' (char variables can hold any single typed character: upper or lowercase letters, digits, or punctuation)
- Use cout to prompt the user to enter their initial, and cin to read it into the userInitial variable.
- Use cout to display both userInitial and testChar.
- Compile, debug, and test your program.
- Do a 'make submit' when you're confident this works.
4. using setw to format data in columns
- At the top of the program, add a #include for the <iomanip> library.
- After the end of your step 3 code in main, add a blank line or two and a comment saying this is the code section for step 4.
- Declare a const int for the column width we want to use, say 15:
  const int ColWidth = 15;
- Now we'll use a series of cout statements, one per line, using setw to set the column width for each value we're printing out:
```
   std::cout << std::setw(ColWidth) << numerator << std::endl;
   std::cout << std::setw(ColWidth) << denominator << std::endl;
   std::cout << std::setw(ColWidth) << userInitial << std::endl;
   std::cout << std::setw(ColWidth) << "And this!" << std::endl;
```
- Compile, debug, and run your program - the four values it displays at the end should all line up under each other on the right hand side.
- Do a 'make submit' when you're confident this works.
5. using setprecision for floats/doubles
- After the end of your step 4 code, add a blank line or two and a comment saying this is the code section for step 5
- Specify the program is going to used fixed-precision display (for floats/doubles) and that you want cout to show exactly 5 digits after the decimal point:
```
   std::cout << std::setiosflags(std::ios::fixed);
   std::cout << std::setprecision(5);
```
- Declare a const double named Pi, assigned a value of 3.1415.
- Declare a double variable named third, assigned a value of one third using
```
  double third = 1/3.0;
```
- Now try couts of both variables, i.e.
```
   std::cout << Pi << std::endl;
   std::cout << third << std::endl;
```
- Compile, debug, and test your program, observe how third gets rounded to 5 digits (after the decimal) and Pi gets padded (with zeros) to fill it out to 5 digits.
- Do a 'make submit' when you're confident this works.

6. Creating and calling a function
So far, all the functions we have used are ones that were built into the various libraries we've #included. Now we want to create a function of our own that accepts data values as parameters, performs some simple computation, and returns a result. We'll then try calling the function from our main routine and display the results.

There are three parts involved in this process:

Writing a short (one-line) prototype of the function near the top of our .cpp file, giving the compiler a short-hand outline of the function (and to conform to the course coding standards, which require a prototype for every function).
Calling (using) the function from one or more places inside our main routine (or even from inside other functions).
Writing the full version of the function near the bottom of our .cpp file.

The specific function we're going to write is going to take two real numbers as parameters, say x and y, and compute and return the square root of x-squared plus y squared.

Writing the prototype:
- This is a one-line 'shorthand' version of the function, showing its return type, name, and types/names for each of its parameters, e.g.
  double rootOfSumSquares(double x, double y);
  In this case we're showing that the function returns a double and expects two parameters (x and y), each of type double.
- Note that it ends with a semi-colon, unlike the full version later which will have { and } surrounding the body of the function. This is how the compiler recognizes that this is just a prototype.
- The prototype goes above the start of the main routine, but typically comes after all the #includes and any global constant declarations.
Calling the function and using its results in main:
- We can call (use) the function from inside the main routine or from inside any other functions.
- When we call the function we need to send it numeric values to use for x and y and we need to specify where the returned/computed value should be placed.
- In the code snippet below, we'll get two values from the user, pass them to the function, store the result, then display all three pieces of information.
```
   double xVal, yVal;  // two values to be supplied by the user
   double answer;      // location where we'll store the result of our call
   std::cout << "Enter two numeric values:" << std::endl;
   std::cin >> xVal >> yVal;
   answer = rootOfSumSquares(xVal, yVal);
   std::cout << "For inputs " << xVal << " and " << yVal;
   std::cout << ", the root of the sum of their squares is ";
   std::cout << answer << std::endl;
```
- Make sure you understand what the code above is doing, then add it to the end of your main routine (below step 5 but before the return 0), then proceed to the step below.
- (If you try compiling the program right now, you'll get complaints from the compiler because we haven't yet written the full version of the function.)

Writing the full version of the function:

The full version of the function comes after the end of the main routine, i.e. after that final }
The first line of the full implementation is identical to the function's prototype except without the ; at the end, e.g.
double rootOfSumSquares(double x, double y)
This is followed by the function body, enclosed in { }
The function body can declare and use its own (local) variables to hold values during its computation process.
The function sends a value back to whoever called it (main in our case) with a return statement

For our function, the full version might thus look something like

double rootOfSumSquares(double x, double y)
{
   double sumSqs; // will hold the sum of the two squares
   double root;   // will hold the root of the sum of the squares (our final answer)
   sumSqs = x*x + y*y;
   root = sqrt(sumSqs);
   return root;
}

Note that you'll need to #include the cmath library along with the other #includes, otherwise it won't recognize the sqrt routine.
Once you're confident the routine works you can do a 'make submit' and move on to part 2 of the lab, the main exercise.

Note that if you were to write multiple functions of your own then they must each come separately after the main routine, e.g.

// sample structure for a program with its own functions foo and blah

#includes and constants

// prototypes
int foo(double a, int b, float c);
double blah(int m)

// main routine
int main()
{
    ... main's code ...
}

// full versions
int foo(double a, int b, float c);
{
   ... foo's code ...
}

double blah(int m)
{
   ... blah's code ...
}

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

Now that we've practiced using each of our new C++ features, our objective is to design, write, test, and debug a more interesting program in our lab2.cpp file.

The program we'll be creating is supposed to estimate how much stair climbing the user has effectively performed while going from class to class for Math/CS courses, going between buildings 210, 315, and 460 and counting sections of uphill/ramps as an equivalent to stairs.

The behaviour we want from our program is as follows:

The program displays a short welcome message/set of instructions for the user.
The program asks the user how often they went up from building 210 to 315, how often they went up from building 315 to 460, and within building 315 it asks how often they went from floor 1 to floor 2.
The program then calculates and displays how many stairs they climbed in total and roughly how many flights of stairs this equates to (e.g. based on an assumption like 14 stairs equates to one flight).

For the calculations to be correct, of course, you'll have to count how many stairs there are between the three buildings and between 315's floors along your preferred routes plus account for any uphill/ramp travel. This is discussed in greater detail in the 'Field Research' section below.

No error checking is required at this point, you can trust that the user will provide valid data. (When testing your submission for this lab I'll only use valid data.)

Sample output/behaviour

Below is a sample run of the program, but using totally fictional counts for the actual number of stairs between the various buildings and floors. I'll trust you to do the research to count the actual number of stairs :)

Just for the sake of readability the run below shows the user input in bold italics - that of course is something your program couldn't actually do.

Your output doesn't have to look exactly like the output shown below, and the numbers certainly won't, but should provide a similar level of detail and functionality.

 
Welcome to the StairCounter! 
 
We calculate your total stair climbing for your Math/CS courses based on how often you go from building to building and from floor to floor. 
 
At the moment it just handles travel between buildings 210 (2nd floor), 315 (floors 1 and 2), and 460 (3rd floor).
 
How many times did you travel from building 210 to the ground floor of building 315? 
4 
Within building 315, how many times did you travel from floor 1 up to floor 2? 
2 
How many times did you travel from the upper floor of building 315 to the third floor of building 460? 
3 
Based on the information you provided you climbed 578 total stairs, 
or roughly the equivalent of 41 flights of stairs 

Thanks for using StairCounter!

Field Research

You'll need to do a little investigation to determine for yourself how many stairs each travel section equates to. This will involve picking a route between buildings or floors (what path to follow, what set of stairs to use), then counting the stairs along the route and adding an adjustment for any sections of uphill walking. (E.g. perhaps assuming that when following a ramp or uphill section of sidewalk count every three paces as equivalent to one stair.)

Of course this will result in different students' programs coming up with different numbers, but it's the planning process, design, and program implementation that are the important parts of this exercise.

Feel free to share/compare the route counts with each other: the design and implementation of your program must be done individually, but basic background facts like 'how many stairs are there between floor X and Y in building Z' can be shared. Future modifications

This initial version of our program is pretty limited: not very robust, not very user friendly. In future labs we'll be improving and expanding upon our design (adding error checking, adding a wider range of buildings/floors, making it easier for the user to pick/choose their start/end building/floor, tracking and reporting on information over longer periods of time, etc.)

Designing your solution

Take some time to come up with a design - figuring out what functions you want/need to write/call, what you want each of them to do, and how you want to structure your logic in the main routine.

Taking the time to come up with a good design will, in the long run, result in much cleaner and better organized code: code that is easier to write, understand, debug, and maintain.

Good design takes practice though. Don't worry if you have to significantly revise your original design a couple of times as you work through the coding practice: it's normal to recognize the need for some changes as you start getting deeper into the actual code.

If you're having trouble getting started, go to the lecture resources and check out the sections on design and modularity listed under Sept. 23-27. There are also many good resources online to help new programmers learning to design.

In next week's lab time (Sept 23/25) we'll spend about 45 minutes on the first quiz, but the instructor will be available for the rest of the lab to talk about your design ideas/issues. (And, since there are no labs the week of Sept 30-Oct 4th, you'll have just under two weeks to finish up.)

Standards and submission

Remember to put all your code for this part of the exercise in your lab2.cpp file in your lab2 directory, and submit it prior to the deadline using the "make submit" command.

As with the other lab exercises, you can 'make submit' as often as you like, it basically just copies your latest version to a place where I can access it.

Do remember that your code needs to follow the course code standards, and that it is most effective to code-to-standards as you go.

Prepping for next week's in-lab quiz

You can find discussion of quiz 1 topics, prep ideas, cheat sheet, etc here: csci.viu.ca/~wesselsd/courses/csci159/quizzes/q1/

Thinking about the design (added for post-quiz discussion)

Hopefully over the past week folks have had some time to think about potential designs for the lab2.cpp program, and there's a week left to carry out the implementation and submit it.

VERSION A If you're struggling with an approach to the design, here's a sample process for writing it as 'one big main routine':

Outline the key steps we'll want the program to follow

include needed libraries
declare needed constants
declare needed variables
for each trip (210-315, 315A-315B, 315-460) ask the user how often they made the trip and read/store their response
calculate the total number of stairs across all the trips
calculate the total number of flights of stairs
display the final results

Identify the libraries we'll probably need
Probably just the iostream library

we don't have any column formatting or precision to deal with, so no iomanip
we don't have any fancy math to do (just multiplication and addition), so no cmath
we're not doing any text input (just integers), so no string

Identify the constants we'll need for fixed values The integer constants we'll likely need will be for the stair counts for each of the routes and how many stairs we regard as one 'flight':

the number of stairs from 210 to 315,
the number of stairs from 315's first to second floor,
the number of stairs from 315 to 460,
the number of stairs we decided is average for a flight of stairs.

These can be declared after the #includes before the main routine.

Identify the variables we'll need for data storage The integer variables we'll likely need will be for the grand total stairs and flights and for how often the user takes each route

the number of trips from 210 to 315,
the number of trips from 315's first floor to second,
the number of trips from 315 to 460,
the final calculated stair count,
the calculated number of flights of stairs.

These can be declared inside the main routine (likely before anything else in the main).

Write a skeleton for the program, but with comments where the code will go

// #include the libraries we need

// declare constants for the stair counts for each route

int main()
{
   // declare variables for the number of times each trip is made
   // a variable for the total calculated stair count
   // a variable for the total calculated number of flights

   // prompt (cout) the user for the number of times they traveled 210-315
   // read (cin) their response

   // prompt the user for the number of times they traveled 315  floor one to floor two
   // read (cin) their response

   // prompt the user for the number of times they traveled 315-460
   // read (cin) their response

   // calculate the sum of the total distances and store in the final result variable
   //   (# times each trip was made * the stair count for that route)

   // calculate how many flights of stairs this represents
   //   (the total number of stairs / our constant for stairs per flight)

   // display (cout) the final results
}

Take an iterative approach to adding code for each comment
Working from the top down, go through the following cycle repeatedly until done:

write the C++ code for the next section of comments,
compile and debug the code so far until it does what you expect.

VERSION B: ideally, we'll create and use our own functions to carry out portions of the code. Normally we would design our program using functions as a core part of the design right from the start, but this time let's start from our working program (VERSION A above) and replace some of the code with functions, one step at a time.

The display of the final results might be the easiest place to start:

the function would take the final stair count and number of flights as parameters and wouldn't return anything (just do couts)
a suitable prototype (below the constant declarations) might be
void displayResults(int stairCount, int numFlights);
and the corresponding call from the main routine might be
displayResults(totalStairs, totalFlights);
(here assuming that in the main routine we had called our final two variables totalStairs and totalFlights)

and at the bottom of the program a suitable implementation might be

void displayResults(int stairCount, int numFlights)
{
   std::cout << "Based on the information you provided, you climbed " << stairCount;
   std::cout << " total stairs" << std::endl;
   std::cout << "or roughly the equivalent of " << numFlights;
   std::cout << " flights of stairs" << std::endl << std::endl;
   std::cout << "Thanks for using Stair Counter!" << std::endl << std::endl;
}

Perhaps next we we'll replace the calculation of the number of flights of stairs with a call to a function:

the function would take the number of stairs as a parameter (as an int?) and would return the calculated equivalent in flights (also as an int?)
a suitable prototype might thus be:
int calcFlights(int stairCount);
a suitable call in main might then be
totalFlights = calcFlights(totalStairs);
(again assuming that main's variable declarations were for totalFlights and totalStairs)
and a suitable implementation might be
```
int calcFlights(int stairCount)
{
   int flights;
   flights = stairCount / StairsPerFlight;
   return flights;
}
```
(assuming our constant up top for the number of stairs in a flight had been declared using the name StairsPerFlight)

Then we could do similarly with the calculation of the total number of stairs:

(left as an exercise for the reader)

Finally, we could write a function that took the names of the start/destination building/floor as string parameters (e.g. "B210", "B315-Flr1"), did the cout/cin to get the number of trips from the user, and then returned that result to main (to be stored in the corresponding variable).

(left as an exercise for the reader)

user inputs		expected output
numerator	denominator	quotient	remainder
17	5	3	2
11	13	0	11
12	4	3	0