2.7 Object manipulation - inheritance  (Page 8/7)

Advanced constructors

In the last chapter, we already notice that constructors can provide a mechanism for initializing data members. However, constructors can do more than initializing data members. They can execute member functions and perform other type of initialization routines that a class may require when it first starts.

Parameterized constructors

Although constructor functions do not return values, they can accept parameters that a client can use to pass initialization values to the class.

Example: We can have a constructor function definition in the implementation file as follows:

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

dFedTax = dFed;

dStateTax = dState;

};

Once you create a parameterized constructor, you have to supply parameters when you instantiate a new object.

Example:

//Payroll.h

class Payroll{

public:

Payroll(double, double);

private:

double dFedTax;

double dStateTax;

}

//Payroll.cpp

#include “Payroll.h

#include<iostream.h>

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

dFedTax = dFed;

dStateTax = dState;

};

int main( ){

Payroll employee; //illegal

……

return 0;

}

Example

The program in this example finds the distance between two points using the pointer to class objects technique.

//points

#include<iostream.h>

#include<math.h>

class point {

private:

int x,y;

public:

point( int xnew, int ynew);

inline int getx(){

return(x);

}

inline int gety(){

return(y);

}

double finddist(point a, point b);

};

point::point(int xnew, ynew) //parameterized constructor

{

x = xnew;

y = ynew;

}

double point::finddist(point a, point b)

{

double temp;

temp = ((b.y – a.y)*(b.y – a.y) + (b.x – a.x)*(b.x – a.x));

return(sqrt(temp)):

}

int main()

{

double value;

point aobj(4,3), bobj(0, -1);

value = aobj.finddist(aobj, bobj);

cout<<“Distance between two points = “<<value<<endl;

return 0;

}

The output of the above program:

Distance between two points = 5.656855

Constructor functions can be overloaded , just like other functions. This means that you can instantiate different versions of a class, depending on the supplied parameters

Being able to overload a constructor function allows you to instantiate an object in multiple ways.

Example:

//Payroll.h

class Payroll{

public:

Payroll();

Payroll(double dFed);

Payroll(double dFed, double dState);

private:

double dFedTax;

double dStateTax;

}

//Payroll.cpp

#include “Payroll.h

#include<iostream.h>

Payroll::Payroll(){

dFedTax = 0.28;

dStateTax = 0.05;

};

Payroll::Payroll(double dFed){

dFedTax = dFed;

};

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

dFedTax = dFed;

dStateTax = dState;

};

int main( ){

Payroll employeeFL(0.28);

Payroll employeeMA(0.28, 0.0595);

return 0;