in both class declaration files. Remember that the #include preprocessor directive (see the C++ Essentials text for more information on such directives) instructs the system to copy the contents of a file into the file containing the directive. In other words, both class declaration files will have the code found in 'common.h'. There is no problem here until we write the main program with '#include' commands to copy in both class declaration files. Now, all the code found in both files is copied into the main program which means that the code from 'common.h is included twice! That file has the lines:

which will result in an error because the constants TRUE and FALSE would be defined twice!

This problem occurs all the time in C++ so there is a simple solution. You should place another set of preprocessor directives:

at the top of all '.h' files ( 'dot h' files - meaning files that end in '.h' and are used as 'include' files).

And, at the bottom of all '.h' files include the line:

Here is 'common.h' with the added code:

// A set of basic type and function declarations common to many programs

// file: common.h

#ifndef COMMON_H
#define COMMON_H
typedef int Boolean;
const Boolean TRUE = 1;
const Boolean FALSE = 0;
#endif

asks the question, "Has the term 'COMMON_H' been defined yet?" The first time the file 'common.h' is read into a piece of code, the answer is no and the next line is executed. This line,

defines the term 'COMMON_H'. Afterwards, the rest of the lines are executed ending with the line

and the system goes to the rest of the code in the file that has directly or indirectly included 'common.h'.

If these lines are encountered again in the file, as they would be in the case of our main program, the line,

is again processed but this time 'COMMON_H' has already been defined so the lines from here to the line,

are skipped! Thus, the constants TRUE and FALSE are not declared and defined again and there is no error. Note the purpose of the '#endif'. Without it the system would not know how many lines to skip.

That is the only change in the file 'common.h'. Again, it is strongly recommended that you get in the habit of always including the three lines:

#ifndef some_name #define some_name
.
.
#endif

B. Redeclaring the Contract Class
We now move onto the declarations for the class 'Contract'. The need for an ID property in the this class causes a few additions to the class declaration:

• a new data member (instance variable) called 'contractID' of type 'int';
• a new function member, 'ChangeID';
• a new function member, 'ProvideID';
• a new parameter, representing the contract ID, for the first constructor

This new code can be viewed under the file name contrct2.h.

The file containing the definitions for this class, 'contrct2.cpp' also has some changes:

• code for the new functions, 'ChangeID' and 'ProvideID,' must be coded. These take exactly the same form as their sister 'Change...' and 'Provide...' functions.
• assignment statements to the two constructors to initialize the value of 'contractID'.

// Class Declarations for ListOfContracts
// File: ch8list1.h

#include "common.h"
#include "contrct2.h"  // Uses the modified version of the contract class.

const
	MAX_CONTRACTS = 5;// arbitrary number chosen for test purposes

typedef
	Contract ContractArray[MAX_CONTRACTS];


class ListOfContracts
{
public:
	ListOfContracts();
   	/*
		Purpose: To instantiate (create) an instance of the class 'ListOfContracts'.
		Goal:	A new instance of class 'ListOfContracts' now exists

		Inputs: 	NONE
		Outputs:	NONE
		Receives:	NONE
		RETURNS:	NONE
	*/

	void Add(Contract contract);
	/*
		Purpose: To add an instance of the class 'Contract' to the list.
		Goal:	A new instance of class 'contract' is on the list

		Inputs: 	NONE
		Outputs:	Error message if list is full
		Receives:	a contract
		Returns: 	NONE:
	*/


	void Delete(int contractNum);
	/*
		Purpose:	To delete an instance of the class 'Contract' from the list.
		Goal:		The instance of class 'contract' is deleted

		Inputs: 	NONE
		Outputs:	Error message if contractNum is not a valid contract number
		Receives:	 A contract number
		Returns: 	NONE:
	*/

	Boolean FindContract(int ID, Contract& contract);
	/*
		Purpose: To find out if a contract is in the list and, if so, return it
		Goal:	 If the list holds a contract with id 'ID', the function 
			 returns that contract in the variable 'contract' and 
			 the function returns true
			 If not, the function returns false and 'contract' holds garbage.'

		Inputs:	NONE
		Outputs:  NONE
		Receives: A contract ID
		Returns:  Whether or not the contract was found AND, if found, the 
			  contract itself.
	*/

	void ReplaceContract (Contract contract);
	/*
		Purpose: To replace the properties of one contract in the list
		Goal:    The properties of the contract in the list with the ID of
			 'contract' have been replaced

		Inputs:	NONE
		Outputs:	NONE
		Receives:	A contract
		Returns:	NONE
	*/

	void DisplayAll();
	/*
		Purpose:	To display all the contracts in the list
		Goal:		All the contracts are displayed on the screen

		Inputs:	NONE
		Outputs:	All the contracts in the list
		Receives:	NONE
		Returns:	NONE
	*/


private:
	int numContracts;  	// indicates next available slot in list
	int limit;         	// The maximum number of contracts
	ContractArray listOfContracts;

};

What confuses people sometimes is that it is possible for one programmer to act as both the designer and user of a class. However, even this is typical human behavior. The person who designs an airplane probably does not think about it as he or she is flying it to visit grand-ma. As a matter of fact, it is likely that he or she does everything possible to keep from thinking about the design so as to accomplish other things while flying. Maintaining awareness of the internal workings of the airplane - or worse, listening for 'noises' - only makes it difficult for him or her to focus on other tasks. Similarly, once you as a programmer are finished with work on a class or a function, it is best to forget about the inner workings of your work or you will not be able to put your full attention on the next task.

C. Viewing Data Members as a Structure
Before we look at the member functions for 'ListOfContracts, we need to understand the data structure employed here. By this is meant how the data members of the class are related to and support each other. Up to now, the data members for our classes have been pretty much independent from each other. They were simply unrelated properties. With 'ListOfContracts' this is no longer true.

We have already talked in general about the three data members for this class. The last one, 'listOfContracts' is an array. We know this from the code because it is declared to be of type 'ContractArray' - the type we declared at the top of the file. By the way, note that the class is named 'ListOfContracts' with an upper case 'L' while our array has the same name except that we use a lower case 'l'. Some people think this is neat, others feel it just adds to the confusion. You decide for yourself in your own work.

The first data member, 'numContracts' is the counter we talked about above. When the list is empty, it has the value 0, when one element is in the list, it has the value 1, etc. (If you would like to see some pictures demonstrating this, click here.) Note the relationship between 'numContracts' and 'listOfContracts'. The data member 'numContracts' tells the system which elements of 'listOfContracts' hold actual contracts and which ones hold garbage.

The one other data member 'limit' is not really useful but we included it because we said we would in earlier discussion. Remember, it will have the same value as the constant, MAX_CONTRACTS. Later, in an expanded version of this program, we will see a real value for this data member and it's relationship to both other data members.

These three data members make up a structure that we can use to represent a list. Such a structure is only useful, however, if there are also functions to manipulate it. Developing these is our next step.

D. The Member Functions - Declarations and Definitions
The declaration along with the design of the six member functions is based on the following:

• The constructor will set the data member 'numContracts' to 0, indicating an empty list, and will set 'limit' to MAX_CONTRACTS. Nothing needs be done to the array of contracts. As long as 'numContracts' is zero, the program 'knows' (if we write our code correctly) that there can not be any contracts in the list.
  

• 'Add' works by receiving a contract and adding it to the list.
  

• 'Delete' works by receiving the ID of the contract to be deleted and searching the list of contracts for a match. If a match is found, the deletion takes place.
   

• 'FindContract' also searches through the list looking for a match with the ID it has been given. The code is very similar to the search in 'Delete' and 'Add' but is just different enough that it is probably easier to develop its code separately.
  

• 'ReplaceContract' does just what it says as does 'DisplayAll'.

// Class Definitions for ListOfContracts
// File: ch8list1.cpp

#include 
#include "common.h"
#include "ch8list1.h"

ListOfContracts :: ListOfContracts()
{
	numContracts = 0;
	limit = MAX_CONTRACTS;
}


void ListOfContracts :: Add(Contract contract)
{
	if (numContracts < MAX_CONTRACTS)
	{	int index = 0;
		Boolean found;
		found = FALSE;
		int contractNum = contract.ProvideID();
		while ((!found) && (index < numContracts)) // keep searching until ID found	
                                                       
		// or no more contracts in list
		{	if (contractNum == listOfContracts[index].ProvideID())
			{	found = TRUE;
			}
			else
			{	index++;
			}
		}
		if (!found) // contract with this ID does not exist
		{
			listOfContracts[numContracts] =  contract; // copy contract into
			list
			numContracts++;
		}
		else		{                                                        cout<< "\nA contract with this ID already
		exists.\n";		} }  else
			{	cout  <<
			"There
			was
			no	room
			to
		add
		the contract\n\n"; } } void ListOfContracts :: Delete(int contractNum) {
		int
			index = 0;
Boolean
	found; found = 	FALSE;  while
	((!found) && (index < numContracts)) // keep searching until ID found 
         				    
	 // or no more contracts in list.
	{	if (contractNum == listOfContracts[index].ProvideID())
		{	found = TRUE;
		}
		else
		{	index++;
		}
	}
	if (found) // the contract to be deleted exists
	{	for (int i = index; i < numContracts - 1; i++)
		{	listOfContracts[i] = listOfContracts[i+1];
		}
		numContracts--;
	}
	else
	{	cout << "Invalid Contract ID\n\n";
	}
}


Boolean ListOfContracts :: FindContract(int ID, Contract& contract)
{
	int index = 0;
	while (index < numContracts) 	// keep searching until ID found
						// or no more contracts in list.
	{	if (ID == listOfContracts[index].ProvideID())
		{	contract = listOfContracts[index];
			return TRUE;

		}
		else
		{	index++;
		}
	}
	return FALSE;  // contract ID not found in list
}

void ListOfContracts :: ReplaceContract (Contract contract)
{
	int index = 0;
	Boolean found;
	found = FALSE;
	int ID = contract.ProvideID();  
// Get ID of the contract so we can search for it in
                                   			     // in the list.
	while ((! found) && (index < numContracts)) 
	
// keep searching until ID found
				                    		      
// or no more contracts in list.
	{	if (ID == listOfContracts[index].ProvideID())
		{	found = TRUE;
		}
		else
		{	index++;
		}
	}
	if (found) // the contract to be replaced exists
	{	listOfContracts[index] = contract;
	}
	else
	{	cout << "\nContract to be replaced does not exist in the list.\n";
	}
}

void ListOfContracts :: DisplayAll()
{
	int contractID;
	int sqFootage;
	int numDesks;
	int numDays;
	double charge;

	cout << endl << endl;  // To set off the output
	for (int contract = 0; contract < numContracts; contract++)
	{
		contractID = listOfContracts[contract].ProvideID();
		sqFootage = listOfContracts[contract].ProvideSquareFootage();
		cout << "The square footage for contract " << contractID << " is: "
			  << sqFootage << endl;

		numDesks = listOfContracts[contract].ProvideNumberOfDesks();
		cout << "The number of desks for contract " << contractID << " is: "
			  << numDesks << endl;

		numDays = listOfContracts[contract].ProvideNumberOfDays();
		cout << "The number of days for contract " << contractID << " is: "
			  << numDays << endl;


		charge = listOfContracts[contract].ProvidePerWeekCharge();
		cout << "The per week charge for contract " << contractID <<"  is: "
			  << charge << endl;
		cout << endl << endl;
	}

}

This causes the contract in the variable 'contract' to be copied to the memory location 'listOfCOntracts[0]'. After this, 'numContracts' is incremented to 1 and the next time an add takes place, the new contract will be placed in the memory location symbolized by ' 'listOfContracts[1]'.

(Be sure that you understand that the values 0 and 1 used here refer to the values held by 'numContracts' at different times.)

Let's step back and go over this function from the top - The first step is to make sure that there is not already a contract in the list with the ID of the new contract. (Duplicates can't be allowed if we want to be able to delete a contract based on it's ID.) The line

gets the ID of the contract to be added and the while loop examines all the contracts to check for a duplicate. Here we see another use of a boolean variable. A search can end for two reasons:

1. The item searched for has been found;
2. There are no more items to search

Thus there are two test conditions in the while loop. Note that 'found' is set to FALSE to indicate that a match has not been found when the loop starts. One by one the loop compares the contracts in the list (using 'index' as the subscript into the array of contracts) with the ID of the new contract (as stored in 'contractNum'). If a match occurs, found is set to TRUE and this is used to stop the search loop. If there is no match, 'index' is incremented and the next element in the array is used in the comparison. Eventually, if some contract in the list has an ID equal to the ID in 'contractNum', the loop will stop with the 'index' acting as an indicator of which element in the array had the match. If there is no match in the list, the loop will eventually stop when 'index' reaches 'numContracts'. Note that in this case, 'found' is never set to TRUE.

The second step is to insert the contract if no match was found. The line:

performs the check to make sure there was no match. If so, the contract is added to the list and the number of contracts is incremented. The rest of the code simply adds appropriate messages.

Delete is somewhat the same as 'Add' but with a few twists. The code again does a search followed by a test. This time, however, the test is to see if a match was found and is written as:

The test here is the opposite of the test in 'Add' because the action takes place only if a match exists - one cannot delete something if it is not there to be deleted.

The other main difference in the code is in the lines:

for (int i = index; i < numContracts - 1; i++)
{

listOfContracts[i] = listOfContracts[i+1];

}
numContracts--;

is encountered in 'FindContract', the code leaves the loop in the process of leaving the whole function. So, if a match is found, the function stops executing and returns TRUE. (Notice that if a match is found, this function also places the matching contract into the parameter 'contract' and this contract is then also returned.) As long as a match is not found, the index variable is incremented and the loop continues. If the loop terminates, it can only be because all contracts in the list have been examined. This means that no matching ID was found in the list and the function returns FALSE.

'ReplaceContract' is yet another example of the same search/action pattern. This time the goal is to find the location of the contract to be replaced and then copy into that location the contract passed as a parameter. The 'else' part of the 'if' statement in the code for this function is mostly for debugging. Used properly, there should always be a match. However, one should always code defensively and consider the possibility of the impossible!

The last function 'DisplayAll' is different but very simply. The code shows us why we decided to make this a member function. It is so easy to simply walk through the list using a 'for' loop to output the property values of all the contracts. Note that 'contract' is used here in the way 'index' was used above and that the loop tests for:

instead of comparing ' contract' with MAX_CONTRACTS or 'limit'. The goal is to display all the contracts that actually exist not the values in all possible contract locations.

E. Variations on a Theme
That is all there is to the function definitions for 'ListOfContracts'. As is so often the case, however, such code can be written in more than one way. One possible change is in the search code and involves the 'for' statement which is actually much more powerful than we have let on so far. Using this statement, the search routines we saw above could have been written as follows:

for (index = 0; index < numContracts, !found; index++)
{

if (contractNum == listOfContracts[index].ProvideID())
{

found = TRUE;

}

}

with the word 'int' included in the parentheses. This is simply a matter of convenience - if one needs a variable for a 'for' loop and the variable has not been declared, do so when you initialize the variable. In the example here, however, we are making a quick change to existing code. In that code 'index' is already declared so let's take advantage of that fact and not declare it again.

It turns out that the 'for' statement is one of the most versatile statements in C++. We shall see more of this versatility later.

A second change we might consider making involves the repeated use of the same search code in 'Add', 'Delete' and 'ReplaceContract'. You will see that each of these member functions has the same lines of code:

while ((!found) && (index < numContracts))
	   // keep searching until ID found
					// or no more contracts
	{	if (contractNum == listOfContracts[index].ProvideID())
		{	found = TRUE;
		}
		else
		{	index++;
		}
	}

   private:
      int numContracts;  // indicates next available slot in list
      int limit;                  // The maximum number of contracts
      ContractArray listOfContracts;

      int Search(int contractID);
      /*   Purpose:   To search through the list of contracts for a contract with an ID
                      that matches 'contractID'.
           Goal:      The list had been searched and the contract found if it exists
	
           Inputs:    NONE
           Outputs:   NONE

           Receives:  a contract's ID
           Returned:   the index of the contract with a matching ID or the value of
                       'numContracts' to indicate that there was no match
      */
  

Regarding the declaration itself: all the searches use the contractID so it must be received by the function. A careful look at the old code might lead you to expect that this function should return a Boolean since all the searches set a variable 'found' to TRUE or FALSE. Unfortunately, there is a small complication here that won't let us do that. Note that 'Delete' and 'ReplaceContract' both need to know the location of the contract to be deleted or replaced. If our 'Search' function just returns TRUE or FALSE, these functions will not know where the contract was found. Therefore, we will return the location where the contract was found or return the value in 'numContracts' as an indicator that the contract ID was NOT found. (Remember, 'numContracts' holds the location of the next free element of the array of contracts. Thus, if 'Search' returns 'numContracts' it is an indication that all contracts were examined and none matched.)

A look at the definition for 'Search' might help. We will use a 'for' loop version just to show some variation.

	int ListOfContracts ::  Search(int contractID)
	{
		int index;
		for (index = 0; index < numContracts; index++)
		{	if (contractID == listOfContracts[index].ProvideID())
				{	return index;
				}
		}
		return index;
	}

Now that we have this function we can simplify each of the functions that used to do their own searching. Consider 'ReplaceContract':

	void ListOfContracts :: ReplaceContract (Contract contract)
	{
		int index;;
		int ID = contract.ProvideID();  
// Get ID of the contract so we can find it in
								// in the list.
		index = Search(ID);
		if (index < numContracts) // the contract to be replaced exists
		{	listOfContracts[index] = contract;
		}
		else
		{	cout << "\nContract to be replaced does not exist in the list.\n";
		}
	}

The other two functions, as rewritten, are included below.

	void ListOfContracts :: Add(Contract contract)
	{
		if (numContracts < MAX_CONTRACTS)	   // is there room in the list?
		{

			int contractNum = contract.ProvideID();
			int index = Search(contractNum);

			
			if (index == numContracts) //contract with this ID does not exist
			{
				listOfContracts[numContracts] = contract; 
					// copy contract into list
				numContracts++;
			}
			else
			{	cout << "\nA contract with this ID already exists.\n";
			}
		}
		else
		{	cout << "There was no room to add the contract\n\n";
		}
	}

	void ListOfContracts :: Delete(int contractNum)
	{
		int index;
		index = Search(contractNum);
		if (index <  numContracts) // the contract to be deleted exists
		{	for (int i = index; i < numContracts - 1; i++)
			{	listOfContracts[i] = listOfContracts[i+1];
			}
			numContracts--;
		}
		else
		{	cout << "Invalid Contract ID\n\n";
		}
	}