--------------------------------------- Benefit --------------------------------

Question

---------------------------------------
Benefit
---------------------------------------
-healthInsurance: string
-lifeInsurance: double
-vacation: int
---------------------------------------
+Benefit()
+Benefit(in healthInsurance: String, in lifeInsurance: double, in vacation: int
+displayBenefits(): string
+getHealthInsurance(): String
+setHealthInsurance(in insurance: string): void
+getLifeInsurance(): double
+setLifeInsurance(in insurance: double) void
+getVacation(): int
+setVacation(in vacation: int) void
---------------------------------------
***********************************************************************/

#include <iostream>
#include <string>
#include <stdlib.h>
#include <iomanip>

using namespace std;

const double MIN_SALARY = 50000;
const double MAX_SALARY = 250000;
const int MAX_DEPENDENTS = 10;
const int MIN_DEPENDENTS = 0;
const char DEFAULT_GENDER = 'N'; //N stands for not identified
const int NUMBER_WEEKS = 52;

class Benefit
{
private:
string healthInsurance;
double lifeInsurance;
int vacation;

public:
Benefit()
{
this->healthInsurance = "not provided";
this->lifeInsurance = 0;
this->vacation = 14;
}
Benefit(string healthInsurance, double lifeInsurance, int vacation)
{
this->healthInsurance = healthInsurance;
this->lifeInsurance = lifeInsurance;
this->vacation = vacation;
}
Benefit(Benefit &mybenefit)
{
this->healthInsurance = mybenefit.healthInsurance;
this->lifeInsurance = mybenefit.lifeInsurance;
this->vacation = mybenefit.vacation;
}
string getHealthInsurance()
{
return healthInsurance;
}
void setHealthInsurance(string healthInsurance)
{
this->healthInsurance = healthInsurance;
}
double getLifeInsurance()
{
return lifeInsurance;
}
void setLifeInsurance(double lifeInsurance)
{
this->lifeInsurance = lifeInsurance;
}
int getVacation()
{
return vacation;
}
void setVacation(int vacation)
{
this->vacation = vacation;
}
void displayBenefits()
{
cout<<" Benefit Information ";
cout<<"____________________________________________________________ ";
cout<<"Health Insurance: " << healthInsurance << " ";
cout<<"Life Insurance: " << lifeInsurance << " ";
cout<<"Vacation: " << vacation << " days ";

}

};

/******************************************************************
* Course: CIS247C
* Week: 4
* Programmer: Prof.Nana Liu
* Date: 07/21/2011
*
* Class Name: Employee
* Class Description:
* The employee class implements the following UML class diagram:
---------------------------------------
Employee
---------------------------------------
-firstName: string
-lastName: string
-gender: char
-dependents int
-annualSalary double
-static numEmployees int
-benefits Benefits
---------------------------------------
+Employee()
+getBenefits Benefits
+setBenefits(in benefits: Benefits) void
+calculatePay() double
+static getNumberEmployees int
+displayEmployee() void
+getFirstName() string
+setFirstName(in name: string) void
+getLastName() string
+setLastName(in name: string) void
+getGender(): char
+setGender(in gen: char) void
+getDependents() int
+setDependents(in dep: int) void
+setDependents(in dep: string) void
getAnnualSalary() double
setAnnualSalary(in sal: double) void
setAnnualSalary(in sal: string) void
---------------------------------------
***********************************************************************/

class iEmployee
{
public:
virtual double calculatePay()=0;

};

class Employee : public iEmployee
{ //declare static variable accessible, which is accessible by all objects of the class
static int numEmployees;

protected:
string firstName;
string lastName;
char gender;
int dependents;
double annualSalary;

//declare a benefits object
Benefit benefits;

public:

Employee():benefits()//default constructor
{
firstName = "";
lastName = "";
gender = 'N';
dependents = 0;
annualSalary = 50000;
//each time a constructor is called, increment the the class level numEmployees variable
this->numEmployees += 1;
//Instantiate the Benefits object
//benefits();
}
//create a parameterized construct, not required and shown only for demonstration
Employee(string firstName, string lastName, char gender, int dependents, double salary, Benefit mybenefits):benefits(mybenefits)
{
//use the THIS keyword to distinguish between the class attributes and the parameters
this->firstName = firstName;
this->lastName = lastName;
this->gender = gender;
this->dependents = dependents;
this->annualSalary = salary;
//each time a constructor is called, increment the the class level numEmployees variable
this->numEmployees += 1;

}

Employee(string firstName, string lastName, char gender, int dependents, Benefit mybenefits):benefits(mybenefits)
{
//use the THIS keyword to distinguish between the class attributes and the parameters
this->firstName = firstName;
this->lastName = lastName;
this->gender = gender;
this->dependents = dependents;
//each time a constructor is called, increment the the class level numEmployees variable
this->numEmployees += 1;

}

//create the accessors and mutators for the benefit object
Benefit getBenefits()
{
return benefits;
}
void setBenefits(Benefit benefits)
{
this->benefits = benefits;
}

//a static method that returns the number of employee object that are created
static int getNumberEmployees()
{
return numEmployees;
}

//Accessors and mutators, one for each class attribute
string getFirstName()
{
return firstName;
}
void setFirstName(string name)
{
firstName = name;
}
string getLastName()
{
return lastName;
}
void setLastName(string name)
{
lastName = name;
}
char getGender()
{
return gender;
}
void setGender(char gen)
{
switch (gen)
{
case 'f':case 'F': case 'M':case 'm':
gender = gen;
break;
default:
gender = DEFAULT_GENDER;
}
}
int getDependents()
{
return dependents;
}
void setDependents(int dep)
{
if (dep >= MIN_DEPENDENTS && dep <= MAX_DEPENDENTS)
{
dependents = dep;
}
else if (dep < MIN_DEPENDENTS)
{
dep = MIN_DEPENDENTS;
}
else
{
dependents = MAX_DEPENDENTS;
}
}
double getAnnualSalary()
{
return annualSalary;
}
void setAnnualSalary(double salary)
{
if (salary >= MIN_SALARY && salary <= MAX_SALARY)
{
annualSalary = salary;
}
else if (salary < MIN_SALARY)
{
annualSalary = MIN_SALARY;
}
else
{
annualSalary = MAX_SALARY;
}
}
double calculatePay()
{
return annualSalary/NUMBER_WEEKS;
}
void displayEmployee()
{
cout<<"Employee Information ";
cout<<"____________________________________________________________ ";
cout<<"Name: " <<firstName << " " << lastName << " ";
cout<<"Gender: " << gender << " ";
cout<<"Dependents: " << dependents << " ";
cout<<"Annual Salary: " << setprecision(2)<<showpoint<<fixed<<annualSalary << " ";
cout<<"Weekly Salary: " << setprecision(2)<<showpoint<<fixed<<calculatePay()<<" ";

//show the benefits
this->benefits.displayBenefits();

}
};

int Employee::numEmployees=0;//supply initial value to static data members


/******************************************************************
* Course: CIS247C
* Week: 5
* Programmer: Nana Liu
* Date: 07/21/2011
*
* Class Name: Hourly
* Class Description:
* The Salaried class implements the following UML class diagram:
---------------------------------------
Hourly extends Employee
---------------------------------------
#wage double
#hours double
#category string
---------------------------------------
+Hourly()
+Hourly(in fname: string, in lname: string, in gen: char, in dep: int, in wage: double, in hours, in ben: Benefits)
+Hourly(in wage: double, in hours: double, in category: string
+calculatePay() double
+setAnnualSalary void
+displayEmployee void
---------------------------------------
It is assumed that each class attribute has appropriate
getter and setter methods created
***********************************************************************/

const double MIN_HOURS = 0;
const double MAX_HOURS = 50;
const double MIN_WAGE = 10;
const double MAX_WAGE = 50;
const int WORK_WEEKS = 50;

class Hourly :public Employee
{
protected:
double wage;
double hours;
string category;

public:
Hourly():Employee()
{

}
Hourly(string firstName, string lastName, char gender, int dependents, double wage, double hours, Benefit benefits, string category)
: Employee(firstName, lastName, gender, dependents, benefits)
{
//no employee constructor with correct arguments, either create a new constructor or set the attributes individually
//use the properties instead of the attributes to ensure all data is valid
setWage(wage);
setHours(hours);
setCategory(category);
setAnnualSalary(wage, hours);
}
Hourly(double wage, double hours, string category):Employee()//ensure the inherited fields are initialized
{
setWage(wage);
setHours(hours);
setCategory(category);
}
double getWage()
{
return wage;
}
void setWage(double wage)
{
if (wage >= MIN_WAGE && wage <= MAX_WAGE)
{
this->wage = wage;
}
else if (wage < MIN_WAGE)
{
this->wage = MIN_WAGE;
}
else
{
this->wage = MAX_WAGE;
}
}
double getHours()
{
return hours;
}
void setHours(double hours)
{
if (hours > MIN_HOURS && hours < MAX_HOURS)
{
this->hours = hours;
}
else if (hours <= MIN_HOURS)
{
this->hours = MIN_HOURS;
}
else
{
this->hours = MAX_HOURS;
}
}
string getCategory()
{
return category;
}
void setCategory(string category)
{
if (category.compare("temporary")==0)
{
this->category = category;
}
else if (category.compare("part time")==0)
{
this->category = category;
}
else if (category.compare("full time")==0)
{
this->category = category;
}
else
{
this->category = "Unknown";
}
}
double calculatePay()
{
return wage * hours;
}
void setAnnualSalary(double wage, double hours)
{
Employee::setAnnualSalary(calculatePay() * WORK_WEEKS);
}

void displayEmployee()
{
setAnnualSalary(wage, hours);
Employee::displayEmployee();
cout<<"Hourly Employee ";
cout<<"Category: " << category << " ";
cout<<"Wage: " << wage << " ";
cout<<"Hours: " << hours << " ";

}
};


/******************************************************************
* Course: CIS247C
* Week: 5
* Programmer: Nana Liu
* Date: 07/21/2011
*
* Class Name: Salaried
* Class Description:
* The Salaried class implements the following UML class diagram:
---------------------------------------
Salaried extends Employee
---------------------------------------
#managementLevel int
---------------------------------------
+Salaried()
+Salaried(in fname: string, in lname: string, in gen: char, in dep: int, in sal: double, in ben: Benefits)
+Salaried(in sal: double)
+calculatePay() double
+displayEmployee() void
---------------------------------------
It is assumed that each class attribute has appropriate
getter and setter methods created
***********************************************************************/

const int MIN_MANAGEMENT_LEVEL = 0;
const int MAX_MANAGEMENT_LEVEL = 3;
const double BONUS_PERCENT = .10;

class Salaried :public Employee
{
protected:
int managementLevel;

public:
Salaried():Employee()//initial the common employee attributes
{
managementLevel = MIN_MANAGEMENT_LEVEL;
}
Salaried(string firstName, string lastName, char gender, int dependents, double salary, Benefit benefits, int manLevel)
:Employee(firstName, lastName, gender, dependents, salary, benefits)
{
setManagementLevel(manLevel); //use the property to ensure valid data in the managementLevel attribute
}
Salaried(double salary, int manLevel):Employee()
{
Employee::setAnnualSalary(salary); //use the super class property to ensure valid data in the annual salary
setManagementLevel(manLevel);
}
void setManagementLevel(int manLevel)
{
if (manLevel >= MIN_MANAGEMENT_LEVEL && manLevel <= MAX_MANAGEMENT_LEVEL)
{
managementLevel = manLevel;
}
else
{
managementLevel = MIN_MANAGEMENT_LEVEL;
}
}
int getManagementLevel()
{
return managementLevel;
}
double calculatePay()
{
return Employee::calculatePay() * (1 + (managementLevel*BONUS_PERCENT));
}
void displayEmployee()
{
Employee::displayEmployee();
cout<<"Salaried Employee ";
cout<<"Management level: " << managementLevel;

}

};


/****************************************************************
* Description: Main testing function
*
* This program tests the Employee and derived class
* of the class and performing the following operations for each of the objects
*
* 1. Create an Employee object using the default constructor.
* 2. Prompt for and then set the first name, last name, gender, dependents, and annual salary. (Remember that you have to convert gender, dependents, and annual salary from strings to the appropriate data type.)
* 3. Display the employee information.
*
* Programmer: Nana Liu
* Course: CIS247C
* Week 5 Lab Assignment
* Date: 07/21/2011
* ****************************************************************/

void DisplayApplicationInformation()
{ cout<<"Welcome to your Object Oriented Program--Employee Class"
<<"CIS247C, Week 5 Lab"
<<"Name: Prof.Nana Liu";
}

void DisplayDivider(string message)
{cout<<" *************** " + message + " ********************* ";}

string GetInput( string message)
{ string mystring;
cout<<"Please enter your "<<message;
getline(cin, mystring);
return mystring;
}

void TerminateApplication()
{ cout<<" The end of the CIS247C Week5 iLab. ";}


int main()
{
char gender;
double lifeInsurance;
int vacation;
string str;
Benefit theBenefits;

//always provide some type of application information to the user--don't leave them cold!
DisplayApplicationInformation();

//use a utility method to keep a consistent format to the output
DisplayDivider("Employee 1");

//create a general Employee object
Employee genericEmp;
//access the employee objects members using the DOT notation
genericEmp.setFirstName(GetInput("First Name "));
genericEmp.setLastName(GetInput("Last Name "));

str = GetInput("Gender ");
gender = str.at(0);
genericEmp.setGender(gender);

genericEmp.setDependents(atoi( GetInput("Dependents ").c_str()));
genericEmp.setAnnualSalary(atof(GetInput("Annual Salary ").c_str()));

//set the benefit information
theBenefits.setHealthInsurance(GetInput("Health Insurance"));

theBenefits.setLifeInsurance(atof(GetInput("Life Insuarance").c_str()));

theBenefits.setVacation(atoi(GetInput("Vocation Days").c_str()));

//set the benefit information
genericEmp.setBenefits(theBenefits);

genericEmp.displayEmployee();

cout<<" --- Number of Employee Object Created ----";
cout<<" Number of employees: " << Employee::getNumberEmployees();

//use a utility method to keep a consistent format to the output
DisplayDivider("Employee 2");

//create a salaried employee, using the general employee information in the constructor
Salaried salariedEmp;
//access the employee objects members using the DOT notation
salariedEmp.setFirstName(GetInput("First Name "));
salariedEmp.setLastName(GetInput("Last Name "));

str = GetInput("Gender ");
gender = str.at(0);
salariedEmp.setGender(gender);

salariedEmp.setDependents(atoi( GetInput("Dependents ").c_str()));
//salariedEmp.setAnnualSalary(atof(GetInput("Annual Salary ").c_str()));

//set the benefit information
theBenefits.setHealthInsurance(GetInput("Health Insurance"));

theBenefits.setLifeInsurance(atof(GetInput("Life Insuarance").c_str()));

theBenefits.setVacation(atoi(GetInput("Vocation Days").c_str()));

//set the benefit information
salariedEmp.setBenefits(theBenefits);
salariedEmp.setManagementLevel(3);
salariedEmp.displayEmployee();

cout<<" --- Number of Employee Object Created ----";
cout<<" Number of employees: " << Employee::getNumberEmployees();

//use a utility method to keep a consistent format to the output
DisplayDivider("Employee 3");

//create a hourly employee, but use generic employee as a base
Hourly hourEmp(genericEmp.getFirstName(), genericEmp.getLastName(), genericEmp.getGender(),
genericEmp.getDependents(), 40.0, 50.0, genericEmp.getBenefits(), "Full Time");
//access the employee objects members using the DOT notation
hourEmp.setFirstName(GetInput("First Name "));
hourEmp.setLastName(GetInput("Last Name "));

str = GetInput("Gender ");
gender = str.at(0);
hourEmp.setGender(gender);

hourEmp.setDependents(atoi( GetInput("Dependents ").c_str()));

//set the benefit information
theBenefits.setHealthInsurance(GetInput("Health Insurance"));

theBenefits.setLifeInsurance(atof(GetInput("Life Insuarance").c_str()));

theBenefits.setVacation(atoi(GetInput("Vocation Days").c_str()));

//set the benefit information
hourEmp.setBenefits(theBenefits);
hourEmp.displayEmployee();

cout<<" --- Number of Employee Object Created ----";
cout<<" Number of employees: " << Employee::getNumberEmployees();


TerminateApplication();

}

Explanation / Answer

* Course: CIS247C * Week: 4 * Programmer: Prof.Nana Liu * Date: 07/21/2011 * * Class Name: Employee * Class Description: * The employee class implements the following UML class diagram: --------------------------------------- Employee --------------------------------------- -firstName: string -lastName: string -gender: char -dependents int -annualSalary double -static numEmployees int -benefits Benefits --------------------------------------- +Employee() +getBenefits Benefits +setBenefits(in benefits: Benefits) void +calculatePay() double +static getNumberEmployees int +displayEmployee() void +getFirstName() string +setFirstName(in name: string) void +getLastName() string +setLastName(in name: string) void +getGender(): char +setGender(in gen: char) void +getDependents() int +setDependents(in dep: int) void +setDependents(in dep: string) void getAnnualSalary() double setAnnualSalary(in sal: double) void setAnnualSalary(in sal: string) void --------------------------------------- ***********************************************************************/ class iEmployee { public: virtual double calculatePay()=0; }; class Employee : public iEmployee { //declare static variable accessible, which is accessible by all objects of the class static int numEmployees; protected: string firstName; string lastName; char gender; int dependents; double annualSalary; //declare a benefits object Benefit benefits; public: Employee():benefits()//default constructor { firstName = ""; lastName = ""; gender = 'N'; dependents = 0; annualSalary = 50000; //each time a constructor is called, increment the the class level numEmployees variable this->numEmployees += 1; //Instantiate the Benefits object //benefits(); } //create a parameterized construct, not required and shown only for demonstration Employee(string firstName, string lastName, char gender, int dependents, double salary, Benefit mybenefits):benefits(mybenefits) { //use the THIS keyword to distinguish between the class attributes and the parameters this->firstName = firstName; this->lastName = lastName; this->gender = gender; this->dependents = dependents; this->annualSalary = salary; //each time a constructor is called, increment the the class level numEmployees variable this->numEmployees += 1; } Employee(string firstName, string lastName, char gender, int dependents, Benefit mybenefits):benefits(mybenefits) { //use the THIS keyword to distinguish between the class attributes and the parameters this->firstName = firstName; this->lastName = lastName; this->gender = gender; this->dependents = dependents; //each time a constructor is called, increment the the class level numEmployees variable this->numEmployees += 1; } //create the accessors and mutators for the benefit object Benefit getBenefits() { return benefits; } void setBenefits(Benefit benefits) { this->benefits = benefits; } //a static method that returns the number of employee object that are created static int getNumberEmployees() { return numEmployees; } //Accessors and mutators, one for each class attribute string getFirstName() { return firstName; } void setFirstName(string name) { firstName = name; } string getLastName() { return lastName; } void setLastName(string name) { lastName = name; } char getGender() { return gender; } void setGender(char gen) { switch (gen) { case 'f':case 'F': case 'M':case 'm': gender = gen; break; default: gender = DEFAULT_GENDER; } } int getDependents() { return dependents; } void setDependents(int dep) { if (dep >= MIN_DEPENDENTS && dep

Related Questions

Navigate

• Browse (All)
• Browse #
• Subjects

---

---

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.