实现学生类（学生姓名，学号）、选课记录类（课程号，学生号，成绩）、课程类（课程号，课程名）， 实现一个某个学校的学校学生成绩单类（学校名称，多学生，多课程，多人成绩） 1自行初始化学校学生成绩单； 2根据输入的学生姓名 可以得到 该学生的所选的课程； 3 根据输入的课程名称可以得到选该课的学生 4 根据输入的课程名称每一门课程的平均分 5 根据输入的学号，输出该学生的的平均分 6 可以使用 vector模板 find模板函数 7 学生的的平均分大于60的所有学生

好的，我来实现这个需求。

首先是学生类、选课记录类和课程类的实现：

#include <string>
#include <vector>

class Student {
public:
    Student(std::string name, std::string id)
        : name_(name), id_(id) {}

    const std::string& name() const { return name_; }
    const std::string& id() const { return id_; }

private:
    std::string name_;
    std::string id_;
};

class CourseRecord {
public:
    CourseRecord(std::string course_id, std::string student_id, int score)
        : course_id_(course_id), student_id_(student_id), score_(score) {}

    const std::string& course_id() const { return course_id_; }
    const std::string& student_id() const { return student_id_; }
    int score() const { return score_; }

private:
    std::string course_id_;
    std::string student_id_;
    int score_;
};

class Course {
public:
    Course(std::string id, std::string name)
        : id_(id), name_(name) {}

    const std::string& id() const { return id_; }
    const std::string& name() const { return name_; }

private:
    std::string id_;
    std::string name_;
};

接下来是学校学生成绩单类的实现：

#include <string>
#include <vector>
#include <algorithm>
#include <numeric>

class SchoolGradeReport {
public:
    SchoolGradeReport(std::string school_name, const std::vector<Student>& students,
                      const std::vector<Course>& courses, const std::vector<CourseRecord>& course_records)
        : school_name_(school_name), students_(students), courses_(courses), course_records_(course_records) {}

    const std::string& school_name() const { return school_name_; }
    const std::vector<Student>& students() const { return students_; }
    const std::vector<Course>& courses() const { return courses_; }
    const std::vector<CourseRecord>& course_records() const { return course_records_; }

    std::vector<CourseRecord> course_records_of_student(const std::string& student_name) const {
        auto student_it = std::find_if(students_.begin(), students_.end(),
                                       [&](const Student& student) { return student.name() == student_name; });
        if (student_it == students_.end()) {
            return {};
        }

        std::vector<CourseRecord> result;
        std::copy_if(course_records_.begin(), course_records_.end(), std::back_inserter(result),
                     [&](const CourseRecord& course_record) { return course_record.student_id() == student_it->id(); });
        return result;
    }

    std::vector<Student> students_of_course(const std::string& course_name) const {
        auto course_it = std::find_if(courses_.begin(), courses_.end(),
                                      [&](const Course& course) { return course.name() == course_name; });
        if (course_it == courses_.end()) {
            return {};
        }

        std::vector<Student> result;
        for (const auto& course_record : course_records_) {
            if (course_record.course_id() == course_it->id()) {
                auto student_it = std::find_if(students_.begin(), students_.end(),
                                               [&](const Student& student) { return student.id() == course_record.student_id(); });
                if (student_it != students_.end()) {
                    result.push_back(*student_it);
                }
            }
        }
        return result;
    }

    float average_score_of_course(const std::string& course_name) const {
        auto course_it = std::find_if(courses_.begin(), courses_.end(),
                                      [&](const Course& course) { return course.name() == course_name; });
        if (course_it == courses_.end()) {
            return 0.0f;
        }

        std::vector<int> scores;
        for (const auto& course_record : course_records_) {
            if (course_record.course_id() == course_it->id()) {
                scores.push_back(course_record.score());
            }
        }

        if (scores.empty()) {
            return 0.0f;
        } else {
            return static_cast<float>(std::accumulate(scores.begin(), scores.end(), 0)) / scores.size();
        }
    }

    float average_score_of_student(const std::string& student_name) const {
        auto student_it = std::find_if(students_.begin(), students_.end(),
                                       [&](const Student& student) { return student.name() == student_name; });
        if (student_it == students_.end()) {
            return 0.0f;
        }

        std::vector<int> scores;
        for (const auto& course_record : course_records_) {
            if (course_record.student_id() == student_it->id()) {
                scores.push_back(course_record.score());
            }
        }

        if (scores.empty()) {
            return 0.0f;
        } else {
            return static_cast<float>(std::accumulate(scores.begin(), scores.end(), 0)) / scores.size();
        }
    }

    std::vector<Student> students_with_average_score_above(float threshold) const {
        std::vector<Student> result;
        for (const auto& student : students_) {
            if (average_score_of_student(student.name()) > threshold) {
                result.push_back(student);
            }
        }
        return result;
    }

private:
    std::string school_name_;
    std::vector<Student> students_;
    std::vector<Course> courses_;
    std::vector<CourseRecord> course_records_;
};

这个类的构造函数需要传入学校名称、学生列表、课程列表和选课记录列表。接下来可以使用这个类来实现各种需求。

1. 自行初始化学校学生成绩单

std::vector<Student> students = {
    {"Alice", "001"},
    {"Bob", "002"},
    {"Charlie", "003"}
};

std::vector<Course> courses = {
    {"101", "Math"},
    {"102", "English"},
    {"103", "Science"}
};

std::vector<CourseRecord> course_records = {
    {"101", "001", 90},
    {"101", "002", 85},
    {"102", "001", 80},
    {"102", "003", 92},
    {"103", "002", 88},
    {"103", "003", 95}
};

SchoolGradeReport report("School Name", students, courses, course_records);

2. 根据输入的学生姓名可以得到该学生的所选的课程

std::vector<CourseRecord> records = report.course_records_of_student("Alice");
for (const auto& record : records) {
    const auto& course = std::find_if(courses.begin(), courses.end(),
                                      [&](const Course& course) { return course.id() == record.course_id(); });
    if (course != courses.end()) {
        std::cout << course->name() << std::endl;
    }
}

3. 根据输入的课程名称可以得到选该课的学生

std::vector<Student> students = report.students_of_course("Math");
for (const auto& student : students) {
    std::cout << student.name() << std::endl;
}

4. 根据输入的课程名称每一门课程的平均分

float avg_score = report.average_score_of_course("Math");
std::cout << "Math: " << avg_score << std::endl;

5. 根据输入的学号，输出该学生的的平均分

float avg_score = report.average_score_of_student("Alice");
std::cout << "Alice: " << avg_score << std::endl;

6. 可以使用 vector模板 find模板函数

上面的代码已经演示了如何使用 `std::find_if` 函数查找学生和课程。

7. 学生的的平均分大于60的所有学生

std::vector<Student> students = report.students_with_average_score_above(60.0f);
for (const auto& student : students) {
    std::cout << student.name() << std::endl;
}