CSCI 159 Lab 2 exercises

• a basic/warmup exercise (basic2.cpp), worth 6 marks and due before the start of quiz 1 (Sept. 25/27)
• the main design/implementation exercise (lab2.cpp), worth 12 marks and due before the start of lab 3 (Oct. 7/9)

Refresher: logging in and setting up

1. logging in
   Login to one of our lab machines using the linux userid you were assigned last week and the new password you chose at that time. If you forget you userid the instructor can look that up, but if you forget your password you'll need to get our department tech, Merlin, to set a new temporary password for you. Details on how to do that can be found here: Student password resets

2. opening the browser and today's lab page
   Under the Applications menu select Internet then either Chromium or Firefox, and go to URL csci.viu.ca/~wesselsd/courses/csci159/labs.html and follow the link to lab2.

3. opening a terminal window
   Under the Applications menu select System Tools then MATE Terminal

4. using make159 to get lab2
   In your home directory enter the command
   make -f make159 csci159/lab2

5. getting into lab2 and the edit/compile/test/submit cycle
   From your home directory get into the lab2 directory by entering
   cd csci159/lab2
   When inside the lab2 directory, the key commands are
   • to edit: gedit lab2.cpp &
   • to compile basic2.cpp: make basic2x
   • to test basic2x: ./basic2x
   • to compile lab2.cpp: make lab2x
   • to test basic2x: ./lab2x
   • to submit: make submit
   As with lab1, when you first open the basic2.cpp or lab2.cpp files you'll see there's a skeletal main routine already written but not much beyond that. You'll be adding code to the main routines and, for lab2.cpp, creating and calling some additional functions of your own.

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

1. getting the feedback directory the first time
   To get your feedback directory, enter the following command:
   make -f make159 csci159/feedback
   Note: this command is only done this one time, in subsequent labs you'll use a different command to get feedback updates.

2. updating the feedback directory (for later labs)
   In lab3 and after, to get updated feedback you'll go into your feedback directory, i.e.
   cd ~/csci159/feedback
   And once there you'll enter the following command to 'pull' updates:
   git pull

3. seeing the feedback files
   In your feedback directory type in the command ls to see a list of the feedback files that have been posted for you so far, e.g. probably just a README file at this point, but if you do a "git pull" later in the week you'll also see a lab1 file with the results of the lab1 marking.
   To look at one of the files you can use any of the text editors we use to open and view the feedback, e.g.
   gedit README
   or, once Dave's finished marking them,
   gedit lab1

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

• code standards and 'coding to standards' as we write
  In order to produce quality code (easy to read, debug, and maintain) we follow a set of code standards covering a wide range of features.
  The code standards for this course are available here: csci.viu.ca/~wesselsd/courses/csci159/labs/standards.html
  Starting with today's lab, you should be attempting to follow the course code standards as you write the code for the lab.
  Most of the standards are for features we haven't introduced yet, so for this week just read through and attempt to follow the ones up to and including 'constants'
  • execution
  • compilation
  • attribution of others' work
  • sequence of events
  • program output
  • identifiers
  • layout
  • comments
  • constants
  Note that since a big reason for having the standards is to simplify debugging, we really want to follow the standards as we write the code, rather than thinking of the standards as a later 'clean up' step after we've got the code mostly working.

• 1. demonstrating integer division and modulo (remainder)
  The first code segment we'll add inside the main routine is one to illustrate what happens with integer division and remainders.
  • 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
    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 short, int, long, float, double
  Next we'll simply show the user the limits of the different numeric data types and what happens when we try to store a value that is too big for a given type.
  • 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
  Here we're going to try declaring, assigning, reading and writing char variables - variables that can only hold one single character.
  • 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
  Here we're going to try printing various variables from earlier sections, but using the setw function from the iomanip library to line the values up 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
  Finally we're going to try displaying floats and doubles but with a fixed number of digits after the decimal point.
  • 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 final '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.

  1. 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.

  2. 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 << ", the result 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.)

  3. 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;
       }
       

     • Once you're confident the routine works you can do a 'make submit' and move on to part 2 of the lab.

     • 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)

... t.b.a. ...