We will return to the 'Employee Salary' problem in a bit but first let's look at a second example of this new pattern. In chapter 3 we had a number of variations of a program where the user was to enter the price of items to be discounted. A decomposition of this problem would lead us to the conclusion that one of the tasks was to get the price. Since this function has as its purpose, "to get a value from a user", it follows the "Basic Input" pattern used in the 'GetRateOfPay' function. Here is the design:

GetPrice
Purpose:	To get the price of an item to be discounted from a user
Goal:		<price>, a double,  contains the price

Receives:	Nothing
Returns	       <price>

Algorithm:
	Get the price of an item from the user

The instruction return is new but it does exactly what it says - it is the function's mechanism for returning a value. A function can only return one value using the return instruction. If our design indicates that a function returns nothing, the return instruction is skipped. We will see later how to return more than one value. (The fact that functions in C++ can return no more than one value should tip you off that these are not exactly mathematical functions.)

A word about the variable 'payRate' and the use of variables inside functions: Variables like 'payRate' that are declared inside functions are said to be local variables. What this means is first, that they are 'known' only inside the function. You can visualize a function as a private room inside which some operation is performed. If that operation requires that the operator take notes or write down some temporary value, the outside world need not have any knowledge about what was written down or what the operator called the temporary value. All the outside world cares about is the value returned.

In the case of 'GetRateOfPay' the variable 'payRate' is local - the rest of the program knows nothing about it and, indeed, a different function in some other part of the program could also have the same variable name. Using the same 'private room' analogy, there could be one room in which the daily sales of vegetables are summed up and a clerk calls the result 'theSum' and there could be another room in which the daily sales of meat are summed up and another clerk again calls the result, 'theSum'. As long as both clerks stick to themselves, there is no problem with them using the same name for two different calculations.

To emphasize this, it should be pointed out that we could change the name of 'payRate' to 'rateOfPay - the variable name found in 'main'. This was not done originally to avoid confusion on your part but the machine does not care. It easily keeps track of the fact that one 'rateOfPay' variable belongs to the function 'main' and one to the function 'GetRateOfPay'.

The second important fact about local variables is that they exist in memory only as long as the code in the function is executing. Thus, only when 'GetRateOfPay' is called is memory set aside for the local variable 'payRate'. Likewise, this memory for 'payRate' is returned to the system when 'GetRateOfPay' executes the 'return' instruction and stops.

One little, ugly point that gets programmers all the time: A declaration ends with a semicolon BUT, neither the first line of a function definition nor the whole definition, ends with a semicolon. You can think of this as something designed just to keep you on your toes.

It is now time to put the whole program together:

// A program to calculate the salaries for 10 employees using functions and the 'for' loop
// File: ch4prg1.cpp

// The specifications go here

#include <iostream.h>

const  int REGULAR_HOURS = 40; // Number of hours before overtime kicks in
const  double OVERTIME_ADJUSTMENT = 1.5;  // Overtime pay adjustment
const  int NUM_TIMES = 10;	// Number of employees to work with


double GetRateOfPay();
/*
Purpose:	To get the rate of pay for an employee from a user
Goal:		 <rateOfPay>, a double,  contains the rate of pay for an employee

Receives:	Nothing
Returns		<rateOfPay>
*/

void main()
// Purpose: 	to calculate salaries for 10 employees
// Receives:	NONE
// Returns:	NONE
{
	double rateOfPay;
	double overtimeRateOfPay;
	
	double regularSalary;
	double overtimeSalary;
	double fullSalary;		  
	double hoursWorked;  // can be a fraction of an hour

	for (int count = 0; count < NUM_TIMES; count++)

	{	rateOfPay = GetRateOfPay();
		cout << "Please enter the hours worked this week for this employee ";
		cin >> hoursWorked;
		if (hoursWorked > REGULAR_HOURS)
		{	regularSalary = REGULAR_HOURS * rateOfPay;
			overtimeRateOfPay = rateOfPay * OVERTIME_ADJUSTMENT;
			overtimeSalary = (hoursWorked - REGULAR_HOURS) * 
						  overtimeRateOfPay; 
			fullSalary = regularSalary + overtimeSalary;
		}
		else
		{ 	fullSalary	 = hoursWorked * rateOfPay;
		}

		cout << "The employee's salary is: " << fullSalary << endl;

	} 

}

double GetRateOfPay()
{	double payRate;
	cout << "Please enter an employee's rate of pay ";
            cin >> payRate;
	return payRate;
}