C++ C++；：如何通过这种方式建立SRTUCT之间的关系？

我是c+的初学者，我在一个项目中工作：“教育管理系统”，当我开始编写对象之间的关系以及它们访问彼此的方式时，我发现这很困难，也很困难，所以我的方法是：

struct doctor
{
    person info;
    vector <course> courses;
};

struct student
{
    person info;
    vector <course> courses;
    vector <assignmentSolution> assignmentSolutions;
};

struct course
{
    int code;
    string title;
    doctor lecturer;
    vector <student> registeredStudents;
    vector <assignment> assignments;
};


vector <doctor> doctors;
vector <student> students;
vector <course> courses;

---

这是错误的，但我想知道如何在memmory中只创建一次，但请记住，学生将在之后注册课程。

可能有点过火，但使用访问者模式可以扩展课程系统： 基本上你有一个拥有这些课程的班级。学校成员可以通过调用registerMember（代码，member）进行注册。课程本身并不拥有学校成员，只是指向他们的指针

#include <map>
#include <memory>
#include <string>
#include <vector>

struct Course;
struct School;

struct Person {
  std::string name;
  int age;
};

struct SchoolMember {
  Person info;  // composition unless person has functionality that SchoolMember
                // needs
  std::vector<Course*> courses;  // maybe map for easier deletion
  School* school;

  virtual ~SchoolMember() {}
  virtual void visit(Course* course) = 0;
};

struct Student;
struct Doctor;

struct Course {
  int code;
  std::string title;
  Doctor* mainDoctor;
  std::vector<Student*> students;

  virtual ~Course() {}

  virtual void accept(Student* student) = 0;
  virtual void accept(Doctor* doctor) = 0;

  virtual void cleanUp() {
    // remove me from student'S lists etc.
  }
};

struct Student final : SchoolMember {
  void visit(Course* course) override {
    courses.emplace_back(course);
    course->accept(this);
    // additional stuff
  }
};

struct Doctor final : SchoolMember {
  void visit(Course* course) override {
    courses.emplace_back(course);
    course->accept(this);
    // additional stuff
  }
};

struct Course101 final : Course {
  void accept(Student* student) {
    // Reject advanced students, etc.
    students.emplace_back(student);
  }
  void accept(Doctor* doctor) {
    // Replace current doctor
  }
};

struct CourseAdvanced final : Course {
  Doctor* secondaryDoctor;

  void accept(Student* student) {
    // Reject 101 students, etc.
    students.emplace_back(student);
  }
  void accept(Doctor* doctor) {
    // I can have multiple doctors!

  }
};

struct School {
  std::map<int, std::unique_ptr<Course>> courses; // School owns the courses

  void addCourse(int code /**/) {
    // create new course
  }

  void registerMember(int code, SchoolMember* member) {
    if(auto it = courses.find(code); it != courses.end()) {
      member->visit(it->second.get());
    }
  }

  void removeCourse(int code) {
    if(auto it = courses.find(code); it != courses.end()) {
      it->second->cleanUp();
      courses.erase(it);
    }
  }
};

#包括
#包括
#包括
#包括
结构课程；
结构学校；
结构人{
std：：字符串名；
智力年龄；
};
结构成员{
Person info；//除非Person具有该学校成员的功能
//需要
std:：vector courses；//可能映射以便于删除
学校*学校；
虚拟~SchoolMember（）{}
虚拟无效访问（课程*课程）=0；
};
结构学生；
结构博士；
结构课程{
int代码；
std：：字符串标题；
医生*主要医生；
性病：病媒学生；
虚拟~Course（）{}
虚拟无效接受（学生*学生）=0；
虚拟作废接受（医生*医生）=0；
虚拟空间清理（）{
//将我从学生名单中删除等。
}
};
结构学生期末考试：学校成员{
无效访问（课程*课程）覆盖{
课程。向后安置（课程）；
课程->接受（这个）；
//附加材料
}
};
结构博士决赛：校友{
无效访问（课程*课程）覆盖{
课程。向后安置（课程）；
课程->接受（这个）；
//附加材料
}
};
结构课程101期末：课程{
无效接受（学生*学生）{
//拒绝高级学生等。
学生。安置（学生）；
}
无效接受（医生*医生）{
//更换现任医生
}
};
结构课程高级期末：课程{
医生*二级医生；
无效接受（学生*学生）{
//拒绝101名学生等。
学生。安置（学生）；
}
无效接受（医生*医生）{
//我可以有多个医生！
}
};
结构学校{
std:：map课程；//课程归学校所有
void addCourse（整数代码/**/）{
//创建新课程
}
无效注册表成员（整数代码，学校成员*成员）{
if（auto it=courses.find（code）；it！=courses.end（））{
成员->访问（it->second.get（））；
}
}
无效removeCourse（内部代码）{
if（auto it=courses.find（code）；it！=courses.end（））{
它->第二->清理（）；
删除（它）；
}
}
};

让成员向量存储每个课程/作业/学生的索引。@ViktorSehr删除课程时，这不会导致问题吗？我认为@ViktorSehr方法很好。但是您应该有一个从id到医生的良好映射，可以使用

std:：map

或

std:：vector

。通过这种方式，您可以删除医生而不会使所有ID无效。（重新）阅读教科书中的“指针”一章，并检查

std:：shared\u ptr

。本课程了解

医生讲师

。

#include <map>
#include <memory>
#include <string>
#include <vector>

struct Course;
struct School;

struct Person {
  std::string name;
  int age;
};

struct SchoolMember {
  Person info;  // composition unless person has functionality that SchoolMember
                // needs
  std::vector<Course*> courses;  // maybe map for easier deletion
  School* school;

  virtual ~SchoolMember() {}
  virtual void visit(Course* course) = 0;
};

struct Student;
struct Doctor;

struct Course {
  int code;
  std::string title;
  Doctor* mainDoctor;
  std::vector<Student*> students;

  virtual ~Course() {}

  virtual void accept(Student* student) = 0;
  virtual void accept(Doctor* doctor) = 0;

  virtual void cleanUp() {
    // remove me from student'S lists etc.
  }
};

struct Student final : SchoolMember {
  void visit(Course* course) override {
    courses.emplace_back(course);
    course->accept(this);
    // additional stuff
  }
};

struct Doctor final : SchoolMember {
  void visit(Course* course) override {
    courses.emplace_back(course);
    course->accept(this);
    // additional stuff
  }
};

struct Course101 final : Course {
  void accept(Student* student) {
    // Reject advanced students, etc.
    students.emplace_back(student);
  }
  void accept(Doctor* doctor) {
    // Replace current doctor
  }
};

struct CourseAdvanced final : Course {
  Doctor* secondaryDoctor;

  void accept(Student* student) {
    // Reject 101 students, etc.
    students.emplace_back(student);
  }
  void accept(Doctor* doctor) {
    // I can have multiple doctors!

  }
};

struct School {
  std::map<int, std::unique_ptr<Course>> courses; // School owns the courses

  void addCourse(int code /**/) {
    // create new course
  }

  void registerMember(int code, SchoolMember* member) {
    if(auto it = courses.find(code); it != courses.end()) {
      member->visit(it->second.get());
    }
  }

  void removeCourse(int code) {
    if(auto it = courses.find(code); it != courses.end()) {
      it->second->cleanUp();
      courses.erase(it);
    }
  }
};