Usunięcie starego i utworzenie nowego obiektu na który wskazuje shared_ptr, rozróżnianie obiektów

0

Mam klasę bazową Employee po której dziedziczą inne, np. Worker. Chcę odróżniać klasy dziedziczące więc użyłem enum class z polami "Worker", "Intern" i "Manager i przydzielam polu "status" kazdej klasy, odpowiednik z enuma o tej samej nazwie. Ponoć jest to szybsze niż użycie np.std::string status = "Worker". Nie wiem jak inaczej ewentualnie by to zrobić. Następnie chcę te klasy rozróżniać i wywołując np funkcje Promote, chcę znaleźć odpowiedniego pracownika, sprawdzić jego ```
status
, a następnie w zależności od niego, awansować go w ten sposób, że np. gdy był on Workerem, usuwam obiekt workera i podmieniam na obiekt Managera z zachowanymi wszystkimi bazowymi polami.** Z góry przepraszam za formatowanie tekstu, ale próbowałem zrobić to dobrze 2 razy, niestety coś się ewidentnie spier****ło.**

class Employee {
public:
    enum class Status {
        Intern,
        Worker,
        Manager
    };
protected:

    int employeeID;
    std::string Name;
    std::string Surname;
    int Salary;
    bool Hired;
...
}

class Worker : public Employee {

protected:

    Status status = Status::Worker;
}


Przechowuje obiekty w ```
vector<shared_ptr<Employee>> Firm;
``` i zarządzam polami przez referencje ```
sourceEmployee[index]
```.

Obecnie wygląda to tak:

 ```            auto it = std::find_if(sourceEmployee.begin(), sourceEmployee.end(),
                              [&sourceEmployee, id](const auto &obj) { return obj->getID() == id; });

            if (it != sourceEmployee.end()) {
auto index = std::distance(sourceEmployee.begin(), it);
 
         switch(sourceEmployee[index]->getStatus()) { // returning status
 
             case Intern::Status::Intern: // tutaj nie wiem czy dobrze rozpoznaje objekt?
 
                 auto tmp0 = std::move(*it);
                 (*it).reset();                         // Nie wiem czy dobrze podmieniam obiekty
                 *it = std::make_shared<Worker>(tmp0);
 
                 cout << "Employee " << id << " has been promoted" << endl;
                 break;```
0

Nie wystarczy (*it).reset(new Manager) (zakładając, że pod it masz np. workera.)? BTW, po co jazda po indeksie tablicy, skoro możesz wołać metody z iteratora (ale nie widzę całego kodu, może gdzieś tego jeszcze używasz).
EDIT: pomyłka z new/make_shared

1

Zawsze jak musisz sprawdzać typ w takim kontekście znaczy, że coś jest źle zaprojektowane.

Powinieneś to raczej zrobić jakoś tak:

class Employee {
public:
    virtual std::shared_ptr<Employee> promoted() const = 0;

    …
};

class Intern : public Employee {
public:
     std::shared_ptr<Employee> promoted() const {
           return std::make_shared<Worker>(*this);
     }
};


class Worker 
    : public Employee
    , public std::enable_shared_from_this<Worker> {
public:
    explicit Worker(const Intern &intern) {
         …
    }

     std::shared_ptr<Employee> promoted() const {
           return std::make_shared<Manager>(*this);
     }
};

class Manager 
    : public Employee
    , public std::enable_shared_from_this<Manager> {
public:
    explicit Manager(const Worker &intern) {
         …
    }

     std::shared_ptr<Employee> promoted() const {
           return shared_from_this();
     }
};

1 użytkowników online, w tym zalogowanych: 0, gości: 1