Хранение в контейнере указателей на объекты класса

class Employee {
public:
    const string name;
    const Date date_of_employment;
    const double base_salary;
    vector <Employee*> subordinate;
 
    friend ostream& operator << (ostream& os, const Employee& employee);
 
    Employee (const string& name, const Date& date,
              double salary) : name(name), date_of_employment(date),
              base_salary(salary) {}
    virtual ~Employee () {
        //--id;
    }
    virtual pair <double, double> GetSalary (const Date& date) const {
        if (date < date_of_employment) {
            return {0, 0};
        } else {
            double max_loyalty = base_salary * 0.3;
            double loyalty = (date - date_of_employment) * base_salary * 0.03;
            double result = base_salary +
                    (loyalty > max_loyalty ? max_loyalty : loyalty);
            return {result, result};
        }
    }
};
 
class Manager : public Employee {
public:
    double max_persent = 0.4;
public:
    Manager (const string& name, const Date& date,
              double salary) : Employee (name, date, salary)  {}
 
   virtual pair <double, double> GetSalary (const Date& date) const override {
        if (date < date_of_employment) {
            return {0, 0};
        } else {
            double max_loyalty = base_salary * 0.4;
            double loyalty = (date - date_of_employment) * base_salary * 0.05;
            double result = base_salary +
                    (loyalty > max_loyalty ? max_loyalty : loyalty);
            double all_salary = 0;
            for (const auto& i : subordinate) {
                auto p = i->GetSalary (date);
                result += p.first * 0.005;
                all_salary += p.second;
            }
            all_salary += result;
            return {result, all_salary};
        }
    }
    virtual void AddSubordinate (Employee* subordinate_) {
        subordinate.push_back(subordinate_);
    }
    virtual void RemoveSubordinate (Employee* subordinate_) {
        auto it = find(subordinate.begin(), subordinate.end(), subordinate_);
        if (it != subordinate.end()) {
        subordinate.erase(it);
        }
    }
    virtual void ShowSubordinate (ostream& os, const Date& date) const {
 
            if (subordinate.empty()) {
                os << "The employee " << this->name << " has no subordinates!\n";
            } else {
                for (const auto& i : subordinate) {
                    os << this->name << i;
                }
            }
        }
 
 
 
 
};
 
class Sales : public Manager {
public:
    double max_persent = 0.35;
    Sales (const string& name, const Date& date,
              double salary) : Manager (name, date, salary) {}
    pair <double, double> GetSalary (const Date& date) const override {
        if (date < date_of_employment) {
            return {0, 0};
        } else {
            double max_loyalty = base_salary * 0.35;
            double loyalty = (date - date_of_employment) * base_salary * 0.01;
            double result = base_salary +
                    (loyalty > max_loyalty ? max_loyalty : loyalty);
            double all_salary = 0;
            for (const auto& i : subordinate) {
                auto p = i->GetSalary (date);
                all_salary += p.second;
            }
            result += all_salary * 0.003;
            return {result, all_salary};
        }
    }
 
};
ostream& operator << (ostream& os, const Employee& employee) {
    os << " NAME: " << employee.name << " DATE OF EMPLOYMENT: " <<
    employee.date_of_employment << " BASE SALARY: " << employee.base_salary << '\n';
        return os;
}

enum class Employees {
    EMPLOYEE,
    MANAGER,
    SALES,
};
 
class Company {
private:
 deque <Employee> employees;
 deque <Manager> managers;
 deque <Sales> sales;
   // deque <shared_ptr<Employee>> employees;
 const string name;
public:
 
    Company (const string& name) : name(name) {}
    template <typename Container>
    void AddSubordinate (Container& c, Employee* empl, const string& chief_name) {
        if (!(chief_name.empty())) {
        for (auto& i : c) {
 
            if (i.name == chief_name) {
                i.subordinate.push_back(empl);
                break;
            }
        }
    }
}
    void AddEmployee (const string& name, const Date& date,
                      double salary, Employees employee_type,
                      const string& chief_name = "") {
        if (employee_type == Employees::EMPLOYEE) {
            employees.push_back({name, date, salary});
            AddSubordinate (employees, &employees[employees.size()-1], chief_name);
        } else if (employee_type == Employees::MANAGER) {
            managers.push_back({name, date, salary});
            AddSubordinate (managers, &managers[managers.size()-1], chief_name);
        } else {
            sales.push_back({name, date, salary});
            AddSubordinate (sales, &sales[sales.size()-1], chief_name);
        }
      }
       void ShowSubordinate (ostream& os, const string& name, const Date& date) const {
            auto it = find_if(managers.begin(), managers.end(), [name] (const Employee& e) {
                           return (name == e.name);});
            if (it != managers.end()) {
                (*it).ShowSubordinate(os, date);
            }
        }
 
};