CSCI 159 Lab 2 Design Example

The example in the bulk of this page is the problem from a previous lab2:part 2, showing a detailed approach to designing and coding a solution.

This year's part 2 is (obviously) a different coding problem, but if you're struggling to design a solution then following the same approach should help, though perhaps in this year's I'd envision the design using a main and functions more like:

// comments from sample solution profiles and main  

// welcome() gives the user an introduction to our program

// getName(adjective) prompts the user to enter an employee name, reads and returns it
// (the adjective is to for qualifiers like "first", "second", etc)

// getCallsAnswered(empname) prompts the user to enter the number of calls that
//     the named employee answered, reads and returns the value

// getCallsUnanswered() prompts the user to enter the number of calls that went unanswered

//  calcHours(callsAns, totCalls) takes the number of calls answered and the
//     total calls made, then calculates and returns an estimate for the
//     number of hours worked that week

// displayResults(emp1name, emp1hours, emp2name, emp2 hours, emp3name, emp3hours, unstaffedhours) -
//     this function takes the names and hour estimates for each employee, plus the estimate
//     for the unstaffed hours, and displays it all in a nice format

int main()
{
   // declare string variables for each of the three employee names

   // declare int variables for each of the 3 employee calls-answered,
   //    plus one for the total calls made and one for the calls-unanswered

   // declare float variables for each of the 3 employee hour estimates
   //    plus one more for the unstaffed estimate

   // call welcome function, to display overall program instructions

   // get the employee names, calling getName once for each employee, storing the results

   // call getCallsAnswered once per employee, storing the results

   // obtain the number of calls that were unanswered

   // calculate the total calls made

   // call calcHours once per employee and once for unanswered, in each case
   //    passing the number of calls answered and the total calls made,
   //    and storing the resulting hours estimate for the employee

   // call display results, passing all the names and estimates

   return 0;
}

Old Example 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.

Thinking about the design

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)

Full Sample solution

#include <iostream>

// constants for the buildings handled
const int B210 = 210;
const int B315 = 315;
const int B460 = 460;

// counts of the number of stairs from building to building
const int Stairs_210_315 = 75;
const int Stairs_315_460 = 60;

// counts of the number of stairs from floor to floor
const int Stairs_315_F1_F2 = 16;

const int FlightStairs = 14;

// displays the welcome message/instru tion
void displayIntro();

// displays the final results: both the total number of stairs
//    and an approximation of the number of floors of stairs
void displayTotals(int stairCount);

// asks the user how often they go up from one floor to another within a specific building,
// then computes and returns how many total stairs that involved
// (oneTrip is the number of stairs between them for a single trip)
int betweenFloors(int bldg, int lowerFl, int upperFlr, int oneTrip);

// asks the user how often they go up from one specific building to another,
// then computes and returns how many total stairs that involved
// (oneTrip is the number of stairs between them for a single trip)
int betweenBuildings(int lowerBld, int upperBld, int oneTrip);

int main()
{
   displayIntro();
   int totalCount = 0;
   totalCount += betweenBuildings(B210, B315, Stairs_210_315);
   totalCount += betweenFloors(B315, 1, 2, Stairs_315_F1_F2);
   totalCount += betweenBuildings(B315, B460, Stairs_315_460);
   displayTotals(totalCount);
}

void displayIntro()
{
   std::cout << std::endl;
   std::cout << "Welcome to the StairCounter!" << std::endl;
   std::cout << std::endl;
   std::cout << "We calculate your total stair climbing for your Math/CS courses based on ";
   std::cout << "how often you go from building to building";
   std::cout << " and from floor to floor." << std::endl;
   std::cout << std::endl;
   std::cout << "(At the moment it just handles buildings 210, 315, and 460.)" << std::endl;
   std::cout << std::endl;
}

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

int betweenBuildings(int lowerBld, int upperBld, int oneTrip)
{
   std::cout << "How often did you travel from building " << lowerBld;
   std::cout << " to building " << upperBld << "?" << std::endl;
   int trips;
   std::cin >> trips;
   return (trips*oneTrip);
}

int betweenFloors(int bldg, int lowerFl, int upperFl, int oneTrip)
{
   std::cout << "Within building " << bldg <<", how often did you travel from floor ";
   std::cout << lowerFl << " up to floor " << upperFl << "?" << std::endl;
   int trips;
   std::cin >> trips;
   return (trips*oneTrip);
}