2.7 Object manipulation - inheritance  (Page 2/7)

}

In the above example, the Payroll class has two parameterized constructor functions: one for states that have a state income tax and one for states that do not have a state income tax.

Initialization lists

Initialization lists , or member initialization lists, are another way of assigning initial values to a class’s data members.

An initialization list is placed after a function header’s closing parenthesis, but before the function’s opening curly braces.

Example: Given the simple constructor that assigns parameter values to the Payroll class.

Payroll::Payroll(double dFed, double dState){

dFedTax = dFed;

dStateTax = dState;

};

You can use initialization list to rewrite the above constructor function.

Payroll::Payroll(double dFed, double dState)

:dFedTax(dFed), dStateTax(dState){

};

Parameterized constructors that uses default arguments

To create a parameterized constructor that uses default arguments, we can put the default values at the constructor prototype.

In the following example, the class Employee has a constructor with the prototype:

Employee(const int id = 999, const double hourly = 5.65);

This format provides the constructor function with default values for two arguments. When we create an Employee object, the default values in the constructor function prototype are assigned to the class variables.

Example

#include<iostream.h>

class Employee{

private:

int idNum;

double hourlyRate;

public:

Employee(const int id = 9999, const double hourly = 5.65);

void setValues(const int id, const double hourly);

void displayValues();

};

Employee::Employee(const int id, const double hourly)

{

idNum = id;

hourlyRate = hourly;

}

void Employee::displayValues()

{

cout<<”Employee #<<idNum<<” rate $”<<

hourlyRate<<“ per hour “<<endl;

}

void Employee::setValues(const int id, const double hourly)

{

idNum = id;

hourlyRate = hourly;

}

int main(){

Employee assistant;

cout<<“Before setting values with setValues()”<<endl;

assistant.displayValues();

assistant.setValues(4321, 12.75);

cout<<“After setting values with setValues()”<<endl;

assistant.displayValues();

return 0;

}

The output of the above program:

Before setting values with setValues()

Employee #9999 rate $5.65 per hour

After setting values with setValues()

Employee #4321 rate $12.75 per hour

Destructors

A default destructor cleans up any resources allocated to an object once the object is destroyed. The default constructor is sufficient for most classes, except when you have allocated memory on the heap.

To delete any heap variables declared by your class, you must write your own destructor function.

You create a destructor function using the name of the class, the same as a constructor function, preceded by a tilde ~. Destructor functions cannot be overloaded. A destructor accepts no parameter and returns no value.

A destructor is called in two ways:

- when a stack object loses scope when the function in which it is declared ends.

- when a heap object is destroyed with the delete operator.

The destructor itself does not actually destroy the object – it performs termination house keeping before the system reclaims the object’s memory so that memory may be reused to hold new objects.