Hey guys pretty much the overloaded constructor

[alicialng]

Hey guys pretty much the overloaded constructor
error C2661: 'Employee::Employee' : no overloaded function takes 5 arguments
Hourly(string firstName, string lastName, char gender, int dependents, double wage, double hours, Benefit benefits, string category):Employee(firstName, lastName, gender, dependents, benefits
Having problems on line 68 and 69 hourly

 // Program Name: Class Development
// Programmer: Alicia Long
//CIS247C: Week 5 lab
//Program Description: Provide a description of the program

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