CS1440 - Lab (4)

 

 

Activity 4-1

 

Goals

The goal is to learn about:
    Predefined functions,
    Type casting using functions that convert values between types,
    Functions that return a value,
    Procedural abstraction and the importance of argument ordering,
    Scope of variables, and
    Function Overloading

Preparations

Before we begin this lab, please change your directory to 1440 and in that directory, create the Lab4 directory. Change to that directory and complete all your lab work in that directory. When the lab specifies a name for a file (or a program), you MUST use that name or risk losing all credit for that part of the lab.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Activity 4-2 - Predefined Functions
A function is a subprogram that is used in a C++ program to perform a particular task such as obtaining data, carrying out some calculations, displaying some information or messages, or displaying the output data.  In C++, there are many predefined functions that are written to simplify the computations, but all functions are used in the same way -- by "calling" the function..  This activity introduces you to several predefined functions: pow,sqrt, ceil, floor.

When you use a function in your C++ program, the compiler does some checking to see if you are using the function correctly.  It checks the return type, the number of arguments (or parameters) and, the types of the arguments.  The compiler does this by comparing information in the "call" to information provided by the function "prototype."  The prototypes for predefined functions are located in "header files" that you must #include into your C++ program. 

double   sqrt(double  value)

Prototype in:       math.h

Purpose:           Computes square root.

Example use:    double  d  =  sqrt(100.0);  //  d gets value 10.0

double   pow(double base,  double exponent)

Prototype in:       math.h

Purpose:           Computes base raised to power exponent:  base exponent

Example use:    double  d  =  pow(3,  4);  //  d gets value 81.0 = 34

int   ceil(double  value)

Prototype in:       math.h

Purpose:           Raises value to nearest whole number.

Example use:    double  d  =  ceil(3.4);  //  d gets value 4.0

int   floor(double  value)

Prototype in:       math.h

Purpose:           Lowers value to nearest whole number

Example use:    double  d  =  floor(3.7);  //  d gets value 3.0

For functions that take more than 1 input argument, the order of the arguments is extremely important.  For example, consider the pow( ) function described above.  If you wish to compute 34, which is 3*3*3*3 or 81, then you had better be sure to use pow(3,4).  If you get the order of the arguments wrong by using pow(4,3) you'll instead compute 43 which is 4*4*4 or 64, a quite different value.

Your text describes some other predefined functions.  You'll also see others (often without warning!) during the remainder of the term.

 

Activity Followup

Write a program that uses each of these predefined functions and one additional function of your choosing that is mentioned in your text but not in this activity.  For each function, your program should ask the user for the inputs they wish.  (So, for sqrt( ) you'll ask for one value (the number whose square root is to be computed), and for pow( ) you'll ask for the base and exponent values to pow.)

Save this program in a file named:   predefined.C

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Activity 4-3

Type Changing Functions - Type Casting

We've spoken about integer division and that it discards any "fractional part" of the quotient. This behavior is sometimes a problem -- sometimes we'd rather not lose that fraction.  One way to avoid losing the fractional part is to make sure that one of the division operands is not an integer.  It is easy enough to change an integer constant into a real (double) constant.  For example, just change 2 to 2.0 in your program.  But what do you do when both operands of the / are int variables?  Consider the following program fragment:

int  val1, val2, num_vals;
cin  >>  val1  >>  val2;
num_vals  =  2;
cout  <<  (val1 + val2)/num_vals;

The division in the last statement will be integer division. 
How can we avoid this? 
By changing one of the division operands to be a double value.
How can we do that?

Type changing predefined function to the rescue!!

All of our basic data types (int, char, double, see Chapter 2 again for a more complete list) also have predefined functions to change other types of data into their type of data.  So, if you need a type double value where you have an int expression, you can use the double( ) function to tell the compiler to use the type double version of the int value. For example, the code below tells the compiler to obtain the value of the int variable num_vals, figure out the equivalent type double value, and use that value as the divisor (in a type double divide):

cout  <<  (val1 + val2)/double(num_vals);

 

Activity Followup

Cut and paste the following program into a file called changing.C and compile and run it.  Then make some changes to continue experimenting with combinations of type changing functions and their inputs.  Carefully observe what the program execution results are!

#include  <iostream.h>

int main()
{
     int  i  =  37;
     char  c  =  'a';
     float  flo  =  76.4;
     float  fhi  =  96.8;
     double  d  =  116.8;

     cout  <<  "i  =  "  <<  i  <<  endl;
     cout  <<  "\t char(i)  =  "  <<  char(i) << endl;
     cout  <<  "\t float(i)  =  "  <<  float(i)  << endl;

     cout  <<  "flo  =  "  << flo << endl;
     cout  <<  "\t char(flo)  =  "  <<  char(flo)  << endl;
}

Not sure what changes you can make?  Try adding a bool variable and type changing function.  Try other combinations like double(i) and int(flo).  You can't break anything, so EXPERIMENT!  By the way, now is a good time to learn how to cut and paste in Pico if you don't know already! (If you're adventurous, this might be a good time to try using a more sophisticated editor like vi, vile, or emacs.)

 

 

 

 

 

 

 

 

 

 

 

 

 

Activity 4-4 - Functions that return a value
We can write our own functions to perform some computations.  The following program from your text will compute the total cost of purchases made in a store.  In this program, we will use a function that computes the cost plus 5% sales tax of  purchases made.

/* P44.C This program computes the total cost of purchases made */
#include <iostream.h>

// (1) Function prototype
//       total cost includes 5% sales tax,
//       on number_par items at a cost of price_par each.

double total_cost(int number_par, double price_par);

int main( )
{
        double  price,  bill;
        int  number;

        cout  <<  "Enter the number of items purchased: ";
        cin  >>  number;
        cout  <<  "Enter the price per item $";
        cin  >>  price;

        bill  =  total_cost(number,  price);  // (2) Function call

        /* The following three lines are used for formatting numbers. 
           Since a precision of 2 is set, then all type double numbers
           will be displayed with two decimal places.  When the

           numbers are money that is the way it should be.
           More on this in a couple of weeks.
        */

        cout.setf(ios::fixed);
        cout.setf(ios::showpoint);
        cout.precision(2);

        cout << number << " items at "
             << "$" << price << " each.\n"
             << "Final bill, including tax, is $" << bill
             << endl;

        return 0;
}

// (3) Function definition
double  total_cost(int  number_par,  double  price_par)   /* Function heading */
{   // Function body begins here
        const double TAX_RATE = 0.05; //5% sales tax
        double subtotal;

        subtotal = price_par * number_par;
        return (subtotal + subtotal*TAX_RATE);
}  // Function body ends here

As you can see, we have used a function called total_cost to compute the cost plus 5% tax.  Note that this function has computed the total cost and has returned a single value at
              return (subtotal + subtotal*TAX_RATE);
The returned value is of type double.

Remarks
There are 3 things that you must remember when you work with functions.

    1) A function must have a name. In the above program name was total_cost.
    2) A function must have a type. The type for the above function is double.
    3) A function must have correct parameter definitions.  This means that the parameters, if any, must have consistent types and correct ordering at the a) function prototype, b) function call, and c) function definition.

Violation of any of these three will result in syntax or logical (run-time) errors.

Please note that the function used in the above program is of type double.  Thus, it returns a value of type double and in the main function, that value was received by a variable of type double at:
bill = total_cost(number, price);

where bill is defined as double in the main function.

 

Activity Followup

Cut and paste the above program into a file named P44.C  and compile and run it.  Then change the program to do the following:

        Replace the final cout statement with a programmer (YOU!) defined function.
Note that this function will require 3 input arguments.  Also, the function does not need to return a value so the return type must be "void".

        Be sure to add a prototype for your new function.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Activity 4-5

Scope of a variable
Scope of a variable refers to the set of statements that can properly make explicit use of that variable -- the statements in which you can correctly write a use of that variable. The scope of a variable declared inside a function is the body of that function.  For example, in the above program, the variable bill is declared inside the body of the main function.  Thus, bill can be used in the main function, but it is unknown in the total_cost function.  If we attempt to use bill without declaring it in the function total_cost, we will get a syntax error that bill is undeclared.  If we put a declaration for bill in the function total_cost, that variable bill will be a different variable from the one declared in the main function. Similarly, variable subtotal is unknown to the main function, because it is a variable defined in the total_cost function and its scope is the body of the total_cost function only.  These kinds of variables are referred to as local variables.  They are local to the function in which they are declared. 

There is, however, a method to define a variable such that it is known to all functions.  These types of variables are defined at the top of the program right after the #include directives.  Any variable defined this way is known as a global variable.  You should use "const" with global variables.

The parameters passed to a function are also local to the function within which they are defined.  Thus, if the body of a function contains statements that change the value of one of the formal parameters of the function, those changes cannot be "seen" by the code that called the function. The function is working on a private copy of the value supplied in the call; it is not wrking with the actual thing in the call. This is referred to as call_by_value. The following example will help you understand all these definitions.

// scope.C
//    This program illustrates the ideas of variable scopes
//     and of call-by-value.

#include <iostream.h>

const  int  global  =  314;    // Here is a global variable

void  myfunc(int  local);    // Function prototype

int  main(void)
{
     int  local,  variable;

     variable  =  7;
     local  =  5;

     cout  <<  "Inside main BEFORE call to myfunc:"  <<  endl;
     cout  <<  "\t global = "  <<  global << endl;
     cout  <<  "\t local = "  <<  local << endl;
     cout  <<  "\t variable = "  <<  variable << endl;

     myfunc(variable);

     cout  <<  "Inside main AFTER call to myfunc:"  <<  endl;
     cout  <<  "\t global = "  <<  global << endl;
     cout  <<  "\t local = "  <<  local << endl;
     cout  <<  "\t variable = "  <<  variable << endl;


      return 0;
}

void  myfunc(int  local)
{
     int  variable;

     variable  =  112;
     local  =  113;

     cout  <<  "Inside myfunc:"  <<  endl;
     cout  <<  "\t global = "  <<  global << endl;
     cout  <<  "\t local = "  <<  local << endl;
     cout  <<  "\t variable = "  <<  variable << endl;

      return ;
}

 

Activity Followup

Cut and paste the program above into a file named scope.C and compile and run it.  Convince yourself that you understand why the output is NOT:

Inside main BEFORE call to myfunc:
     global = 314
     local = 5
     variable = 7
Inside myfunc:
     global = 314
     local = 113
     variable = 112
Inside main AFTER call to myfunc:
     global = 314
     local = 113
     variable = 112

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Post Lab Exercise
 

1.      Do Programming Project #1 on pages 168-9 of your text.  Put the program in a file named  mpg.C. Turn in a program listing.

2.      Do Programming Project #8 on pages 170-1 of your text.  Put the program in a file named  clothes.C.   Turn in a program listing.