Иерархия классов C++

#include <iostream>
#include <string>
 
struct NodeBase { //структура
    NodeBase* next;
    NodeBase* prev;
    NodeBase() : next(this), prev(this) {}
    NodeBase(NodeBase* next_, NodeBase* prev_) : next(next_), prev(prev_) {
        next_->prev = prev_->next = this;
    }
    virtual ~NodeBase() {
        next->prev = prev;
        prev->next = next;
    }
};
 
struct Node;
 
class Person {
public:
    explicit Person(const std::string& name);
    virtual ~Person();
    std::string& name() { return name_; }
    void name(const std::string& name) { name_ = name; }
    virtual void print() {
        std::cout<< std::endl
            << "Person:" << std::endl
            << "Name: " << name()<< std::endl;
    }
    static NodeBase base;
    static void print_all();
private:
    Person(const Person& other); // не позволять копирование
    Person& operator=(const Person& other); // не позволять копирование
    std::string name_;
};
 
NodeBase Person::base;
 
struct Node : public NodeBase {
    Node() : NodeBase() {}
    Node(NodeBase* next_, NodeBase* prev_, Person* person_)
        : NodeBase(next_, prev_), person(person_) {}
    Person* person;
};
 
void Person::print_all() {
    NodeBase* current = base.next;
    while (current != &base) {
        (static_cast<Node*>(current))->person->print();
        current = current->next;
    }
}
Person::Person(const std::string& name) : name_(name) {
    new Node(&base, base.prev, this);
}
Person::~Person() {
    NodeBase* node = base.next;
    while (static_cast<Node*>(node)->person != this && node != &base)
        node = node->next;
    if (node != &base)
        delete node;
}
 
 
class Employee : public Person {
public:
    Employee(const std::string& name, const std::string& office)
        : Person(name), office_(office) {}
    std::string& office() { return office_; }
    void office(const std::string& office) { office_ = office; }
    virtual void print() {
        std::cout << std::endl
            << "Employee:" << std::endl
            << "Name: " << name() << std::endl
            << "Office: " << office() << std::endl;
    }
private:
    Employee(const Employee& other); // не позволять копирование
    Employee& operator=(const Employee& other); // не позволять копирование
    std::string office_;
};
 
 
class Engineer : public Employee {
public:
    Engineer(const std::string& name, const std::string& office, size_t los)
        : Employee(name, office), los_(los) {}
    size_t los() { return los_; }
    void los(size_t los) { los_ = los; }
    virtual void print() {
        std::cout << std::endl
            << "Ingeneer:" << std::endl
            << "Name: " << name() << std::endl
            <<"Office: " << office() << std::endl
        << "Length of service: " << los() << "year(s)." << std::endl;
    }
private:
    Engineer(const Engineer& other);
    Engineer& operator=(const Engineer& other);
    size_t los_;
};
 
class Worker : public Person {
public:
    Worker(const std::string& name, size_t stag)
        : Person(name), stag_(stag) {}
    size_t stag() { return stag_; }
    void stag(size_t stag) { stag_ = stag; }
    virtual void print() {
        std::cout << std::endl
            << "Worker:" << std::endl
            << "Name: " << name() << std::endl
            
            << "Stag: " << stag() << "year(s)." << std::endl;
    }
private:
    Worker(const Worker& other);
    Worker& operator=(const Worker& other);
    size_t stag_;
};
 
int main(int argc, char* argv[]) {
    // статические работники
    Person a("Ivan");
    Employee b("Kolya", "204-a");
    Engineer c("Vasya", "205-b", 15);
    Worker g("Aleksandr", 5);
 
    // динамический работник
    Person* d = new Employee("Petya", "204-c"); // создание работника
    a.print_all(); // просмотр списка. Petya имеется.
    delete d; // удаление работника
    b.print_all(); // работник "Petya" пропал из списка.
    return 0;
}