As an array declaration, it is perfectly legal. However, consider what it does. It creates an array of 100 instances of the class 'Contract'. But, remember, as we have written the constructor for the class 'Contract' , every time an instance is created, the information on square footage, number of desks, and number of days must be provided. That is not being done in this declaration!

It turns out that in C++ it is not possible at array declaration time to provide the necessary property values for each element of an array of class instances. What we need to do is write a constructor that creates instances with default data. The idea is that if an instance being created is not given specific values for its instance variables, then it will use some values likely to be valid or that, at least, make sense as initial values. Notice that this is different from leaving the instance variables filled with garbage. When we use the term 'garbage' for a variable's value, we are referring to some value that was left over from the last time the memory associated with this variable was used. A default value is a value we explicitly put into the memory associated with a variable but which is, at best, a guess at the value that will ultimately go there.

For example, if we are dealing with instances of bank accounts where each instance has one property representing the amount of money in the account and a second property representing the interest rate, we might say that the default values are 0 for the amount and 4% for the interest rate - assuming:

1. that it is better to start an account with no money in it and adjust the amount later, rather than the other way around and,
2. that most accounts in this particular bank have a 4% interest rate.

In the case of the Contract class it makes most sense to set the values for the three instance variables to 0 if not told otherwise.

We could accomplish this by simply changing the constructor for the 'Contract' class so that it receives no parameters and sets the values of all properties to 0. This would mean, however, that we could not in the same program instantiate an instance of the class with specific values as we did before. We would be back where we were when we first looked at constructors. If you recall, before we wrote our first constructor, we simply declared our instances as empty and filled them in afterwards using the 'Change...' member functions.

At that time we talked about the system supplied, default constructor. That constructor, supplied by the system when the programmer did not declare one, is different from the new one we want here. That one left the data members filled with garbage. The one proposed here would initialize the data members of ALL instances created with it to some specific set of values - the so-called default values.

C. Function Overloading
What we want is the ability to instantiate instances both with and without specific property values and C++ allows us to do this. It is legal to write two functions (or as many as are needed) that have the same name but have different numbers and/or types of parameters. This is called function overloading. In our case then, we will have two constructors because, as we know, constructors are simply a special kind of function. They are shown below:

and

These constructor functions must have the same name because they are both to act as constructors for the "Contract' class and, by definition, a constructor for a class has the same name as the class. In general, the compiler knows which function to use (among a set of functions all with the same name) by looking at the number and type of the actual parameters used when the function is called. In our case, one constructor expects three integer parameters and the other none. If there are three actual parameters in an instantiation of a contract , all of which are integers, the first constructor is called. But, if there are no parameters, the second constructor is called. And, of course, the compiler will generate an error if we try to use a Contract constructor any other way.

Be aware that constructor calls are somewhat implicit. The call takes place when the instance is declared. Consider the instantiation:

We know that this means that the instance 'c1' is instantiated with the initial values of 300 for the square footage, 10 for the number of desks, and 5 for the number of days. We can also think of this line of code as a call to the version of the Contract constructor that has three formal parameters. Likewise, if we write:

we can interpret this as a call to the version of the Contract constructor that has no parameters.

In the case of the array declaration above, 100 instances are declared and therefore 100 calls are made to a constructor for the class 'Contract'. Since each call has no parameters, the constructor with no formal parameters is used. If we want all default property values to be 0, the constructor definition for this second version would look as follows:

Contract::Contract()
{

squareFootage = 0;
numberOfDesks = 0;
numberOfDaysPerWeek = 0;

}

You are allowed to overload functions in C++ as long as the there is something different about the parameter lists. The difference can be in terms of the number of parameters in the two functions, in terms of different types of parameters, or in terms of both. Note that one can have different types returned by the two functions, but the compiler does not look at this in deciding which function to use. In other words, if the number and type of parameters are the same but the return types are different, the compiler will have no way to determine which one to call at run time. For example, the declarations:

are valid since the first parameter in one declaration is of type 'int' while in the second declaration it is of type 'double'. On the other hand, the declarations:

are not valid because the only difference between them is in the return type.

Our attention for now will be on constructor overloading. However, overloading in general is a very powerful addition to C++. In addition to function overloading, it is also possible to overload operators such as +, -, and << or >>.

The new 'Contract' class declaration is shown below.

// Declaration of the class Contract
// File: contract.h

class Contract
{   public:
	Contract(int sqFootage, int numDesks, int numDays);
	/*
	Purpose:	to instantiate (create) an instance of the class Contract'.
	Goal:		a new instance of class 'contract' now exists

	Receives:	Square Footage, number of Desks, number of Days (all Integers)
	Returns:	NONE
	*/

	Contract();
	/*
	Purpose:	to instantiate (create) an instance of the class 'contract' 
			with default values.
	Goal:		a new instance of class 'contract' now exists

	Receives:	NONE
	Returns:	NONE
	*/

	void ChangeSquareFootage(int sqFootage);
	/*
	Purpose:	To change the value of the square footage data member
	Goal:		The square footage data member has a new value

	Receives	The New Square Footage (an integer)
	Returns:	NONE
	*/

	void ChangeNumberOfDesks( int numDesks);
			// Design comments go here.


	void ChangeNumberOfDays( int numDays);
			// Design comments go here.

	int ProvideSquareFootage();
	/*
	Purpose:	To Return the Square Footage of an Office
	Goal:		The Square Footage is returned
	
	Receives:	NONE
	Returns:	the Square Footage (an integer)
	*/

	int ProvideNumberOfDesks();
			// Design comments go here.

	int ProvideNumberOfDays();
			// Design comments go here.

	double ProvidePerWeekCharge ();
	/*
	Purpose:	To calculate and return the per week charge for an office
	Goal:		The per week charge is returned
	
	Receives:	Square Footage, number of Days Per Week, number of Desks (all
		 	integers)
	Returns:	The Per Week Charge (a double)
	*/

   private:
	int squareFootage;
	int numberOfDaysPerWeek;
	int numberOfDesks;
};