Welcome to the Most Reliable, Essay Writing Service on the internet

we-are-going-to-create-an-abstract-employee-class-and-two-pure-virtual-functions

Mar 23

We are going to create an abstract Employee class and two pure virtual functions – calculatePay() and
displayEmployee(). The abstract Employee class will prevent a programmer from creating an object
based on Employee, however, a pointer can still be created. Objects based on Salaried and Hourly will be
allowed. The pure virtual function calculatePay() in Employee will force the child classes to implement
calculatePay(). The other pure virtual function displayEmployee() in Employee will force the child classes
to implement displayEmployee().

#include
#include
#include
#include
#include

"stdafx.h"
<iostream>
<string>
<stdlib.h>
<iomanip>

using namespace std;
const
const
const
const
const
const

double MIN_SALARY = 50000;
double MAX_SALARY = 250000;
int MAX_DEPENDENTS = 10;
int MIN_DEPENDENTS = 0;
char DEFAULT_GENDER = ‘N’;
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
";
}
};

class iEmployee
{
public:
virtual double calculatePay() = 0;
};
class Employee : public iEmployee
{
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;
this->numEmployees += 1;
//benefits();
}
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;
const
const
const
const
const

double MIN_HOURS = 0;
double MAX_HOURS = 50;
double MIN_WAGE = 10;
double MAX_WAGE = 50;
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 << "
";
};

}

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;
}
};

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();
}

  

CLIENT TESTIMONIALS

The Service Is Okay. I won’t Complain

The writers on the website are courteous and the customer service responds quickly. My paper was handled well; They promised...

Writers here are very professional and are native British

Thanks a lot for helping me out with my PhD Thesis, Writers here are very professional and are native British!!

Jack, The United Kingdom

Very Very Helpful, and On time.

Very Very Helpful, and On time.

Adelio M, Spain

I scored complete A’s in 3 out of four courses

I scored complete A’s in 3 out of four courses

Anonymous, Illinoi Chicago

CLICK HERE  To order your paper

About Essaysmiths Assignment writing service

We are a professional paper writing website. If you have searched a question and bumped into our website just know you are in the right place to get help in your coursework. We offer HIGH QUALITY & PLAGIARISM FREE Papers.

How It Works

To make an Order you only need to click on “Order Now” and we will direct you to our Order Page. Fill Our Order Form with all your assignment instructions. Select your deadline and pay for your paper. You will get it few hours before your set deadline.

Are there Discounts?

All new clients are eligible for upto 20% off in their first Order. Our payment method is safe and secure.

 CLICK HERE to Order Your Assignment

 

Get access to cheap essays online, and forget about all your worries

Quality assurance

When we accept your assignment order, we treat it with the utmost seriousness. This means that only the best experts will conduct research on your topic and that they will deliver your paper only after making sure that it is insightful.

Total confidentiality

We use the SSL protocol to ensure that all the details of our customers are 100% safe and secure. So, forget about all worries when sharing personal information on our site. We never disclose the details of our clients.

All round service

24/7 customer support. We don’t want you to fail to submit your paper. So, we work 24 hours a day and 7 days a week to provide you with instant feedback.

Original Essays

One of the key principles of our work is to be creative and original. We hire only talented and experienced essay writers that are able to create authentic papers. Each regular essay or term paper is written from scratch in accordance with all your guidelines.

Cheap Service

Compared to our competitors, we offer a relatively cheap service. We allow you the comfort of a cheap paper writing service to improve your grades. If you are facing an academic problem, we’ll solve it by asking for a fair price.

Rocket fast Essay writing service

Don’t worry! We work in a timely manner to deliver orders before the due date. You’ll have enough time to check whether the finished paper corresponds to all your requirements. If not, provide us with feedback and ask for a revision.

Order Your Essay Today From  reliable Essay writing Service.

Order your Assignment today and save 15% with the discount code ESSAYHELP

X