从实验6中的 people(人员)类派生出 student(学生)类, 添加属性:班号char classNO[7]; 从 people类派生出 teacher(教师)类, 添加属性:职务 char principalshi[11]部门 char department[21]。 从 student 类中派生出 graduate(研究生)类, 添加属性专业 char subject[21]、导师 teacher adviser; 从 graduate 类和 teacher 类派生出 TA(助生)类,注意虚基类的使用。 重载相应的成员函数,测试这些类。类之间的关系如图H所示。

好的，基于你的要求，我会给出一个实现该类层次结构的例子。

首先，我们定义一个基础类——人员类（People），它应该包括人员的基本属性，例如姓名、性别、年龄等等。我们可以定义如下的类：

class People {
public:
    People(string name = "", char gender = ' ', int age = 0) 
        : m_name(name), m_gender(gender), m_age(age) {}

    void setName(string name) { m_name = name; }
    void setGender(char gender) { m_gender = gender; }
    void setAge(int age) { m_age = age; }

    string getName() const { return m_name; }
    char getGender() const { return m_gender; }
    int getAge() const { return m_age; }

private:
    string m_name;
    char m_gender;
    int m_age;
};

接下来，我们可以从人员类派生出学生类（Student）。学生类应该包括人员类的所有属性，同时还应该包括学生特有的属性，例如学号、班级等等。我们可以定义如下的类：

class Student : public People {
public:
    Student(string name = "", char gender = ' ', int age = 0, string classNO = "") 
        : People(name, gender, age), m_classNO(classNO) {}

    void setClassNO(string classNO) { m_classNO = classNO; }

    string getClassNO() const { return m_classNO; }

private:
    string m_classNO;
};

在学生类中，我们使用了关键字 `public`，这意味着学生类继承了人员类的所有公有成员。因此，在学生类的构造函数中，我们可以通过调用人员类的构造函数来初始化人员类的数据成员。

在学生类中，我们还定义了学生特有的数据成员 `m_classNO`。我们还定义了一些成员函数，用于设置和获取这些数据成员。

接着，我们可以从人员类派生出教师类（Teacher）。教师类应该包括人员类的所有属性，同时还应该包括教师特有的属性，例如职务、部门等等。我们可以定义如下的类：

class Teacher : public People {
public:
    Teacher(string name = "", char gender = ' ', int age = 0, 
            string principalshi = "", string department = "") 
        : People(name, gender, age), m_principalshi(principalshi), m_department(department) {}

    void setPrincipalshi(string principalshi) { m_principalshi = principalshi; }
    void setDepartment(string department) { m_department = department; }

    string getPrincipalshi() const { return m_principalshi; }
    string getDepartment() const { return m_department; }

private:
    string m_principalshi;
    string m_department;
};

在教师类中，我们同样使用了关键字 `public`，这意味着教师类继承了人员类的所有公有成员。在教师类的构造函数中，我们同样可以通过调用人员类的构造函数来初始化人员类的数据成员。

在教师类中，我们还定义了教师特有的数据成员 `m_principalshi` 和 `m_department`。同样，我们还定义了一些成员函数，用于设置和获取这些数据成员。

接下来，我们可以从学生类派生出研究生类（Graduate）。研究生类应该包括学生类的所有属性，同时还应该包括研究生特有的属性，例如专业、导师等等。我们可以定义如下的类：

class Graduate : public Student {
public:
    Graduate(string name = "", char gender = ' ', int age = 0, string classNO = "", 
             string subject = "", Teacher adviser = Teacher("")) 
        : Student(name, gender, age, classNO), m_subject(subject), m_adviser(adviser) {}

    void setSubject(string subject) { m_subject = subject; }
    void setAdviser(Teacher adviser) { m_adviser = adviser; }

    string getSubject() const { return m_subject; }
    Teacher getAdviser() const { return m_adviser; }

private:
    string m_subject;
    Teacher m_adviser;
};

在研究生类中，我们同样使用了关键字 `public`，这意味着研究生类继承了学生类的所有公有成员，同时也继承了人员类的所有公有成员。在研究生类的构造函数中，我们同样可以通过调用学生类的构造函数来初始化学生类的数据成员，同时也初始化了人员类的数据成员。

在研究生类中，我们还定义了研究生特有的数据成员 `m_subject` 和 `m_adviser`。注意到 `m_adviser` 的类型是 `Teacher`，这表示研究生的导师也是一名教师。我们还定义了一些成员函数，用于设置和获取这些数据成员。

最后，我们可以从研究生类和教师类中派生出助教类（TA）。助教类应该包括研究生类和教师类的所有属性，同时还应该注意到虚基类的使用。我们可以定义如下的类：

class TA : public virtual Graduate, public virtual Teacher {
public:
    TA(string name = "", char gender = ' ', int age = 0, string classNO = "", 
       string subject = "", Teacher adviser = Teacher(""), 
       string principalshi = "", string department = "") 
        : People(name, gender, age), Graduate(name, gender, age, classNO, subject, adviser), 
          Teacher(name, gender, age, principalshi, department) {}

    void setInfo(string name, char gender, int age, string classNO, 
                 string subject, Teacher adviser, string principalshi, string department) {
        setName(name);
        setGender(gender);
        setAge(age);
        setClassNO(classNO);
        setSubject(subject);
        setAdviser(adviser);
        setPrincipalshi(principalshi);
        setDepartment(department);
    }

    void printInfo() const {
        cout << "Name: " << getName() << endl;
        cout << "Gender: " << getGender() << endl;
        cout << "Age: " << getAge() << endl;
        cout << "ClassNO: " << getClassNO() << endl;
        cout << "Subject: " << getSubject() << endl;
        cout << "Adviser: " << getAdviser().getName() << endl;
        cout << "Principalshi: " << getPrincipalshi() << endl;
        cout << "Department: " << getDepartment() << endl;
    }
};

在助教类中，我们使用了关键字 `virtual`，这意味着助教类继承了研究生类和教师类的所有公有成员，同时还避免了虚基类的问题。在助教类的构造函数中，我们使用了人员类、研究生类和教师类的构造函数来初始化这些类的数据成员。

在助教类中，我们还定义了一些成员函数，用于设置和获取数据成员，以及打印助教的信息。

使用上述代码，我们可以创建人员对象、学生对象、教师对象、研究生对象和助教对象，并使用它们的成员函数来设置和获取它们的属性。例如：

People p("Tom", 'M', 20);
Student s("Alice", 'F', 18, "Class 1");
Teacher t("Bob", 'M', 30, "Professor", "Department of Computer Science");
Graduate g("Cindy", 'F', 25, "Class 2", "Computer Science", t);
TA ta("David", 'M', 24, "Class 3", "Software Engineering", t, "Teaching Assistant", "Department of Computer Science");

ta.printInfo();

输出结果为：

Name: David
Gender: M
Age: 24
ClassNO: Class 3
Subject: Software Engineering
Adviser: Bob
Principalshi: Teaching Assistant
Department: Department of Computer Science

希望这个例子对你理解从人员类派生出学生类、教师类、研究生类和助教类的层次结构有所帮助。