Keep getting no overload function takes 5 arguments

[alicialng]

Write your question here.

[code]
#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';
const int NUMBER_WEEKS = 52;

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

const double MIN_WAGE = 10;
const double MAX_WAGE = 75;
const double MIN_HOURS = 0;
const double MAX_HOURS = 50;

const int WORK_WEEKS = 50;


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

public:
Benefit()
{
healthInsurance = "not provided";
lifeInsurance = 0;
vacation = 14;
}

Benefit(string healthInsurance, double lifeInsurance, int vacation)
{
healthInsurance=healthInsurance;
lifeInsurance=lifeInsurance;
vacation=vacation;
}

Benefit(Benefit &mybenefit)
{
healthInsurance = mybenefit.healthInsurance;
lifeInsurance = mybenefit.lifeInsurance;
vacation = mybenefit.vacation;
}

string getHealthInsurance()
{
return healthInsurance;
}

void setHealthInsurance(string healthInsurance)
{
healthInsurance = healthInsurance;
}

double getLifeInsurance()
{
return lifeInsurance;
}

void setLifeInsurance (double lifeInsurance)
{
lifeInsurance = lifeInsurance;
}

int getVacation()
{
return vacation;
}

void setVacation(int vacation)
{
vacation = vacation;
}

void displayBenefits()
{
cout<<"\nBenefit Information\n";
cout<<"__________________________________________\n";
cout<<"Health Insurance:\t" <<healthInsurance << "\n";
cout<<"Life Insurance:\t\t" <<lifeInsurance << "\n";
cout<<"Vacation:\t\t" <<vacation << " days\n";
}
};

class Employee
{
static int numEmployees;

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

Benefit benefits;

public:

Employee():benefits()
{
firstName = "";
lastName = "";
gender = 'N';
annualSalary = 50000;
numEmployees += 1;
}

Employee(string firstName, string lastName, char gender, int dependents, double salary, Benefit mybenefits):benefits(mybenefits)
{
firstName = firstName;
lastName = lastName;
gender = gender;
dependents = dependents;
annualSalary = salary;
numEmployees += 1;
}

Benefit getBenefits()
{
return benefits;
}
void setBenefits(Benefit benefits)
{
benefits = benefits;
}

static int getNumberEmployees()
{
return numEmployees;
}

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;
}
}
void setDependents (string dep)
{
dependents = atoi(dep.c_str());
}
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;
}
}

void setAnnualSalary(string salary)
{
annualSalary = atof(salary.c_str());
}
double calculatePay()
{
return annualSalary/NUMBER_WEEKS;
}

void displayEmployee()
{
cout<<"First Name:\t"<<firstName<<endl;
cout<<"Last Name:\t"<<lastName<<endl;
cout<<"Gender:\t"<<gender<< "\n";
cout<<"Dependents:\t"<<dependents<< "\n";
cout<<"Annual Salary:\t" << setprecision(2)<<showpoint<<fixed<<annualSalary << "\n";
cout<<"Weekly Salary:\t" << setprecision(2)<<showpoint<<fixed<<calculatePay() << "\n";
benefits.displayBenefits();

}
};

[alicialng]

class Salaried :public Employee
{
protected:
int managementLevel;

public:

Salaried():Employee()
{
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);
}

Salaried(double salary, int manLevel):Employee()
{
Employee::setAnnualSalary(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\n";
cout<<"Management level:\t" << managementLevel;
}

};

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)
{
setWage(wage);
setHours(hours);
setCategory(category);
setAnnualSalary(wage, hours);
}

Hourly(double wage, double hours, string category):Employee()
{
setWage(wage);
setHours(hours);
setCategory(category);
}

double getWage()
{
return wage;
}

void setWage(double wage)
{
if (wage >= MIN_WAGE && wage <=MAX_WAGE)
{
wage = wage;
}
else if (wage < MIN_WAGE)
{
wage = MIN_WAGE;
}
else
{
wage = MAX_WAGE;
}
}
double getHours()
{
return hours;
}
void setHours (double hours)
{
if (hours > MIN_HOURS && hours < MAX_HOURS)
{
hours = hours;
}
else if (hours <= MIN_HOURS)
{
hours = MIN_HOURS;
}
else
{
hours = MAX_HOURS;
}
}
string getCategory()
{
return category;
}
void setCategory(string category)
{
if (category.compare("temporary")==0)
{
category = category;
}
else if (category.compare("part time")==0)
{
category = category;
}
else if (category.compare("full time")==0)
{
category=category;
}
else
{
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\n";
cout<<"Category:\t\t" << category << "\n";
cout<<"Wage:\t\t\t" << wage << "\n";
cout<<"Hours:\t\t\t" << hours << "\n";
}

};

int Employee::numEmployees=0;
void DisplayApplicationInformation()
{
cout<<"Welcome the Basic User Interface Program"<<endl;
cout<<"CIS247, Week 5 lab"<<endl;
cout<<"Name: Alicia Long"<<endl;
cout<<"This program accepts user input as a string, then makes the appropriate data conversion" << endl;
}

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

string GetUserInput(string message)
{
string mystring;
cout<<"Enter the "<<message;
getline(cin, mystring);
return mystring;
}

void TerminateApplication()
{
cout<<"Thank you for using the Basic User Interface program";
}

int main()
{
Employee genericEmp;
char gender;
string str;
double lifeInsurance;
int vacation;

DisplayApplicationInformation();

DisplayDivider("Employee 1");

genericEmp.setFirstName(GetUserInput("First Name "));
genericEmp.setLastName(GetUserInput("Last Name "));

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

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

Benefit theBenefits;

theBenefits.setHealthInsurance(GetUserInput("Health Insurance "));
theBenefits.setLifeInsurance(atof(GetUserInput("Life Insurance ").c_str()));
theBenefits.setVacation(atoi(GetUserInput("Vacation Days ").c_str()));
genericEmp.setBenefits(theBenefits);
genericEmp.displayEmployee();

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

DisplayDivider("Employee 2");

Salaried salariedEmp;
salariedEmp.setFirstName(GetUserInput("First Name "));
salariedEmp.setLastName(GetUserInput("Last Name "));
str = GetUserInput("Gender ");
gender = str.at(0);
salariedEmp.setGender(gender);
salariedEmp.setDependents(atoi( GetUserInput("Dependents ").c_str()));
salariedEmp.setAnnualSalary(atof(GetUserInput("Annual Salary ").c_str()));

theBenefits.setHealthInsurance(GetUserInput("Health Insurance "));
theBenefits.setLifeInsurance(atof(GetUserInput("Life Insurance ").c_str()));
theBenefits.setVacation(atoi(GetUserInput("Vacation Days ").c_str()));
salariedEmp.setBenefits(theBenefits);
salariedEmp.setManagementLevel(3);
salariedEmp.displayEmployee();


cout<<"\n---Number of Employee Object Created ---";
cout<<"tNumber of Employees:"<<Employee::getNumberEmployees();

DisplayDivider("Employee 3");

Hourly hourEmp(genericEmp.getFirstName(), genericEmp.getLastName(), genericEmp.getGender(), genericEmp.getDependents(), 40.0, 50.0, genericEmp.getBenefits(), "Full Time");

hourEmp.setFirstName(GetUserInput("First Name "));
hourEmp.setLastName(GetUserInput("Last Name "));

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

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

theBenefits.setHealthInsurance(GetUserInput("Health Insurance "));
theBenefits.setLifeInsurance(atof(GetUserInput("Life Insurance ").c_str()));
theBenefits.setVacation(atoi(GetUserInput("Vacation Days ").c_str()));

hourEmp.setBenefits(theBenefits);
hourEmp.displayEmployee();

cout<<"\n---Number of Employee Object Created ---";
cout<<"tNumber of Employees:"<<Employee::getNumberEmployees();

TerminateApplication();

system ("Pause");
return 0;