CSCI 160 Lab exercise 2, F21N01/N02

In lab exercise 2 we'll start gettting into significantly larger programs than in lab 1, so following good coding practices becomes much more important (incremental design, following code standards).

As with lab 1, there are several key syntax elements you'll need to be familiar with. The core part 2 syntax elements can be found here.

Again, you'll be following similar steps as in lab 1 except that you'll be creating and working in labex2.

Refer back to the lab1 part 1 instructions if you forget the specifics of different steps.

Open the powershell window
ssh into your csci account
obtain the csci160/labex2 content using the make160 makefile command
cd into your csci160/labex2 directory
use ls to see which files are present (hopefully a makefile and labex2.cpp)
edit the labex2.cpp file, creating source code to match the objectives described below
save and exit the editor
compile the program using make
repeat the edit/save/compile cycle until it compiles cleanly
try a test run of your revised program, and repeat the edit/save/compile/test cycle until you get the desired behaviour
make sure your program follows the course code standards
submit the lab (again, it's ok to submit multiple times if you revise the .cpp file more later)

labex2.cpp objectives

In this lab exercise we want to practice the development and use of our own functions, and the use of if/else to apply error checking to user input (either through checking cin.fail() or through checking scanf's return value).

The applied objective for this exercise is to create and submit a complete and correct C++ program, adhering the the course code standards, with the following behaviour and restrictions:

The bulk of the program functionality will be carried out by four functions (to be written/implemented by the student):
- welcomeUser
  This function is simply a sequence of printfs or couts, briefly outlining for the user what the program does for them. (This should be written appropriately from the perspective of a user - don't tell them about code details.)
- getUserData
  This function returns a long integer and expects a single long integer parameter, representing the largest value the user is permitted to enter. The function behaviour is as follows:
  - prompts the user to enter an integer less than or equal to whatever maximum value was passed in the parameter (i.e. the prompt would wind up looking something like "Enter an integer less than 613")
  - reads their response and stores it in a suitably declared variable
  - checks if the attempted read succeeded (i.e. checking scanf's return value or checking cin.fail)
  - if the read was NOT successful then the function displays an error message letting the user know their entry was not a valid integer, clears the input buffer (using the *s with scanf or the cin.ignore) then returns 0
  - if the read was successful but the user value was too big then the function displays an error message letting the user know their entry was too large, and then returns the maximum allowable value (the value from the passed parameter)
  - if the read was successful and the user value is small enough then the function simply returns the value
- computeResults
  This function returns an long and expects a single long integer parameter, the data value to be processed. The function behaviour is as follows:
  - the function computes the square root of the data value, and stores it in a suitably declared long integer variable
    (use cmath's sqrt routine, it is ok to pass a long to sqrt, and to store the returned result in a long)
  - the function returns 2 * the computed square root
- displayResult
  (Corrected: this originally said the function returns a long)
  This function does not return a value, and expects two long integer parameters, the data value that was processed and the computed value to be displayed. The function behaviour is as follows:
  - the function displays the value that was processed and the result that was computed, clearly indicating which is which
    e.g. "processed value XXXX, result YYYY"
    (be sure there is at least one newline/endl at the end of your program's final output)
The main routine's sequence of events will be to
- declare a constant for the maximum permitted user value, 2047
- call the welcomeUser function
- call the getUserData function, passing the maximum permitted user value as the parameter and (in a suitably-declared variable) store the value returned
- call the computeResults function (passing the stored user data) and (in a suitably-declared variable) store the result returned
- call the displayResult function (passing the stored user data and the computed result)

Note: you may use either the iostream (cin/cout) or the cstdio (scanf/printf) approach for I/O, but pick one approach or the other, don't mix and match.

Deadlines and late penalties

Submission deadlines and late penalties for all lab exercises are provided on the main labs page.

Reminders

Don't forget to do your "make submit" when finished, and don't forget about the tools/tips from week 2 of labex1 (ssh'ing to the pups, getting your lab feedback, and use of X2Go).

Don't forget the code standards, particularly those for indentation, variable and constant naming, layout and function prototypes, and appropriate commenting of your code.

Remember you must be in the correct directory, e.g. csci160/labex1, whenever you are working on the program, otherwise the necessary makefile and source code files are not present.
If you're unsure which directory you are in, enter the command
pwd
If you find you are in an incorrect directory then you can jump directly to the labex1 directory using the following command:
cd ~/csci160/labex2

Suggested (iterative) development process

As with lab1, I strongly recommend adding and testing small parts of the program at a time.

get the skeletal #includes and main routine compiling, possibly with any variables and constants you think main will need
write the welcome function prototype and implementation, put in a call from main, compile and test it out
write the getUserData function, prototype, and call from main, but without any of the error checking in getUserData yet, compile and test it out (maybe just print the returned value in main for now)
write the computeResults function, prototype, and call from main and test it out (again, possibly just printing the returned value in main for now)
write the displayResults function and test it out (now you can get rid of any extra printfs you put in main earlier)
go back to the getUserData function and add the error checking and test it out

(I've posted an example of the first few steps in case folks are having trouble getting started.)