Inheritance Set and Get Functions

[CoderParzival]

I'm trying to have my get and set functions with inheritance to work but I'm not sure what to do, here is my code.

  #ifndef lab10_h
#define lab10_h

#include <cstring>
#include <string>
#include <iostream>
using namespace std;

class Employee
{
protected:
    string name;
    string eid;
    double salary;
public:
    
    //Default Constructor
    Employee()
    {
        name = nullptr;
        eid = nullptr;
        salary = NULL;
    }
    //Parameteized Constructor
    Employee(string n, string nid, double sal)
    {
        name = n;
        eid = nid;
        salary = sal;
        
    }
    //Set method for name
    void setName(string n)
    { name = n;}
    
    //Set method for employee id
    void setEid(string nid)
    { eid = nid;}
    
    //Set method for salary
    void setSalary(double s)
    { salary = s;}
    
    //Get method for name
    string getName() const
    {return name;}
    
    //Get method for employee id
    string getId() const
    { return eid;}
    
    //Get method for salary
    double getSalary() const
    { return salary;}
};

class ProductionWorker : public Employee
{
private:
    int shift;
    int hours;
    double hourlyPayRate;
    
public:
    
    //Default Constructor
    ProductionWorker() : Employee ()
    {
        shift = NULL;
        hours = NULL;
        hourlyPayRate = NULL;
    }
    //Parameteized Constructor
    ProductionWorker(string n, string nid, double sal, int s, int h, double hpr) : Employee (n, nid, sal)
    {
        salary = h * hpr;
        shift = s;
        hours = h;
        hourlyPayRate = hpr;
    }
    //Set method for salary
    void setSalary(int h, double hpr)
    { salary = h * hpr;}
    
    //Set method for shift
    void setShift(int s)
    { shift = s;}
    
    //Set method for hours
    void setHours(int h)
    { hours = h;}
    
    //Set method for hourly pay rate
    void setHourlyPayRate(int hpr)
    { hourlyPayRate = hpr;}
    
    //Get method for shift
    string getShift() const
    {
        if( shift == 1)
            return "Day";
        if(shift == 2)
            return "Night";
        else
            return "Assign shift time";
    }
    
    //Get method for hours
    int getHours() const
    {return hours;}
    
    //Get method for hourly pay rate
    int getHourlyPayRate() const
    {return hourlyPayRate;}
};

class ShiftSupervisor : public Employee
{
private:
    double bonus;
public:
    
    //Default Constructor
    ShiftSupervisor()
    {
        bonus = NULL;
    }
    
    //Parameteized Constructor
    ShiftSupervisor(string n, string nid, double sal, double b) : Employee (n, nid, sal)
    {
        bonus = b;
        salary = b + sal;
    }
    
    //set method for salary
    void setSalary(double b, double sal)
    {
        salary = b + sal;
    }
    
    //set method for bonus
    void setBonus(double b)
    {bonus = b;}
    
    //get method for bonus
    double getBonus() const
    {return bonus;}
};

#endif /* lab10_h */  

[Thomas1965]

What do you want to do ?
What is the problem ?

[Enoizat]

Are you really assigning ‘nullptr’ to std::strings and ‘NULL’ to doubles? Doesn’t the compiler complain?
However, could you please tell us if the following version gives you the same errors?

#ifndef lab10_h
#define lab10_h

#include <iostream>
#include <string>

class Employee {
protected:
    std::string name;
    std::string eid;
    double salary;

public:
    Employee() { salary = 0.0; }
    Employee(std::string name_arg, std::string eid_arg, double salary_arg)
    {
        name = name_arg;
        eid = eid_arg;
        salary = salary_arg;
    }

    void setName(const std::string& name_arg) { name = name_arg; }
    void setEid(const std::string& eid_arg)   { eid = eid_arg; }
    void setSalary(const double salary_arg)   { salary = salary_arg; }

    std::string getName() const { return name; }
    std::string getId() const   { return eid; }
    double getSalary() const    { return salary; }
};

class ProductionWorker : public Employee {
private:
    int shift;
    int hours;
    double hourlyPayRate;

public:
    ProductionWorker() : Employee ()
    {
        shift = 0;
        hours = 0;
        hourlyPayRate = 0.0;
    }
    ProductionWorker( std::string name_arg,     std::string eid_arg,
                      double salary_arg,        int shift_arg,
                      int hours_arg,            double hourlyPayRate_arg )
        : Employee(name_arg, eid_arg, salary_arg)
    {
        hours = hours_arg;
        hourlyPayRate = hourlyPayRate_arg;
        salary = hours * hourlyPayRate;
        shift = shift_arg;
    }

    void setSalary(const int hours_arg, const double hourlyPayRate_arg)
    {
        hours = hours_arg;
        hourlyPayRate = hourlyPayRate_arg;
        salary = hours * hourlyPayRate;
    }
    void setShift(const int shift_arg)   { shift = shift_arg; }
    void setHours(const int hours_arg)   { hours = hours_arg; }
    void setHourlyPayRate(const int hourlyPayRate_arg)
        { hourlyPayRate = hourlyPayRate_arg; }
    
    std::string getShift() const
    {
        switch(shift) {
        case 1 : return "Day";
        case 2 : return "Night";
        default: return "Assign shift time";
        }
    }
    int getHours() const         { return hours; }
    int getHourlyPayRate() const { return hourlyPayRate; }
};

class ShiftSupervisor : public Employee {
private:
    double bonus;

public:
    ShiftSupervisor() { bonus = 0; }
    ShiftSupervisor( std::string name_arg,      std::string eid_arg,
                     double salary_arg,         double bonus_arg )
        : Employee(name_arg, eid_arg, salary_arg)
    {
        bonus = bonus_arg;
        salary += bonus;
    }

    void setSalary(const double bonus_arg, const double salary_arg)
    {
        bonus = bonus_arg;
        salary = bonus + salary_arg;
    }
    void setBonus(const double bonus_arg) { bonus = bonus_arg; }
    
    double getBonus() const { return bonus; }
};

#endif // lab10_h 

Note: You usually don’t need to initialise objects like std::strings and std::vectors. Their constructor take care of that.