这是使用继承实际上有意义的罕见情况之一：

class Person {
    std:string name;
    int age;
public:
    Person(std::string const &name, int age) 
        : name(name), age(age) 
    {}

    std::string get_name() const { return name; }
    int get_age() const { return age; }

    virtual ~Person() = default;
};

class Worker : public Person {
    std::string level;
public:
    Person(std::string const &name, int age, std::string const &level) 
        : Person(name, age), level(level)
    {}

    std::string get_level() const { return level; }
};

int main() { 
    Worker ben("Beniah", 27, "base");

    std::cout << ben.get_name();
}

通过使用公共继承，我们AssertWorker是Person--或者更准确地说，在任何我们想要Person的情况下，总有人可以用Worker代替。
通过使用继承来AssertWorker是Person，我们已经确保了我们为Person定义的所有操作也为Worker定义，包括在Worker对象上调用Person::get_name，即使get_name只在Person中定义，而不是直接在Worker中定义。
继承肯定有一些缺点，所以在做出任何不可撤销的决定之前，您可能需要仔细检查它。
在任何情况下，如果你想为Worker添加一个接受Person和level的构造函数，你也可以很容易地完成。或者你可以（例如）在Worker中创建一个名为hire的静态成员函数，它将接受一个Person并创建一个Worker：

class Worker {
/// ...
    static Worker hire(Person p, int level);
};

这确实有一些人们可能不喜欢的影响，特别是在哲学层面上。例如，每次你hire一个Person，你都在创建一个包含Person的Worker对象，所以你可以说，当你雇用某人时，他们是一个全新的人，从现有的Person复制而来，而不是实际上是现有的Person。有些时候/情况下，这可能是一个问题（和其他地方，它不是）。

当你声明一个类的示例时，类的定义必须是已知的。如果不是，则只能使用指向类示例的指针或引用。
在这里，您只需在Person之前定义Worker。
顺便说一句，当一个ref就足够了的时候，你不应该传递一个Worker对象的副本，或者如果你声明了const方法（它实际上是什么），最好是一个const ref。
你的代码可以变成：

#include <iostream>
#include <string>

using std::cout;
using std::string;

class Worker {
public:
    Worker(string Level, string Name) {
        level = Level;
        name = Name;
    }
    string get_name() const {
        return name;
    }

private:
    string level;
    string name;
};

class Person {
public:
    Person(int Age, const Worker& worker) {
        age = Age;
        name = worker.get_name();
    }

    string get_name() {
        return name;
    }

private:
    int age;
    string name;
};

int main() {

    Worker worker1 = Worker("base", "Beniah");
    Person ben = Person(27, worker1);

    cout << ben.get_name();

    return 0;
}

或者，如果您有循环依赖项，您可以推迟实际使用Worker类的方法的定义。下面是对原始代码的最小更改，只是推迟了构造函数的定义：

#include <iostream>
#include <string>

using namespace std;

class Worker;

class Person {
public:
    // Worker is just a forward declaration here
    // just use it in the declaration part
    Person(int Age, Worker worker); /* {
        age = Age;
        name = worker.get_name();
    }*/

    string get_name() {
        return name;
    }

private:
    int age;
    string name;
};

class Worker {
public:
    Worker(string Level, string Name) {
        level = Level;
        name = Name;
    }
    string get_name() {
        return name;
    }

private:
    string level;
    string name;
};

// Worker is now fully defined, we can use it in Person ctor
Person::Person(int Age, Worker worker) {
    age = Age;
    name = worker.get_name();
}

int main() {

    Worker worker1 = Worker("base", "Beniah");
    Person ben = Person(27, worker1);

    cout << ben.get_name();

    return 0;
}