学生信息管理系统代码优化（C++）

学生信息管理系统优化（C++）

学生信息管理系统优化（C++）

本文旨在展示如何运用 C++ 的强大面向对象特性，如类、继承以及智能指针等，对学生信息管理系统进行优化与实现。通过合理的代码模块化设计，不仅能够更加有序地管理学生和班级信息，还为后续功能的扩展提供了便利，使其能够更好地适应不断变化的实际需求。

一、学生与班级类定义（Grade.h）

（一）整体概述

Grade.h 文件作为整个系统的基础部分，定义了两个核心类：Student类和Class类，它们分别用于描述学生个体信息以及班级内学生信息的集合管理，为后续功能实现搭建了数据结构框架。

（二）Class类详细介绍

#pragma once

// 班级类
class Class {
public:
    int class_id;  // 班级唯一标识符，用于区分不同班级
    std::shared_ptr<Student> student_head;  // 指向班级内学生链表的头指针，通过链表结构存储班级中的学生信息
    std::shared_ptr<Class> next;  // 指向下一个班级的指针，可用于构建班级链表，便于多个班级信息的串联管理

    // 构造函数
    Class(int id) : class_id(id), student_head(nullptr), next(nullptr) {}

    // 添加学生
    void addStudent(int student_id, const std::string& name, float chinese, float math, float english);

    // 打印所有学生
    void printStudents() const;

    // 统计班级学生平均分
    void statisticsStudent() const;
};

该类主要用于管理班级层面的学生信息相关操作，通过student_head指针维护一个学生链表，实现对班级内多个学生信息的存储与组织。各个成员函数的作用如下：

• 构造函数：接受一个整数参数id，用于初始化班级的class_id，同时将student_head和next指针初始化为nullptr，确保新创建的班级对象处于合理的初始状态。
• addStudent函数：用于向班级的学生链表中添加新学生信息，接受学生的学号、姓名以及各科成绩作为参数，按照链表的添加逻辑将新学生信息插入到合适位置，后续会在Grade.cpp中详细实现其功能逻辑。
• printStudents函数：遍历班级的学生链表，并逐个调用学生对象的display函数，将班级内所有学生的详细信息输出显示，方便查看班级学生情况。
• statisticsStudent函数：通过遍历班级内学生链表，累加所有学生的总分，再除以学生数量，以此计算并输出班级学生的平均分，为教学质量评估等提供数据参考。

（三）Student类详细介绍

#pragma once

// 学生类
class Student {
public:
    int student_id;  // 学生的唯一学号，用于在班级内标识不同学生
    std::string student_name;  // 学生的姓名信息
    float chinese_score;  // 学生的中文科目成绩
    float math_score;  // 学生的数学科目成绩
    float english_score;  // 学生的英语科目成绩
    float total_score;  // 学生的总分，由三科成绩相加得出
    float average_score;  // 学生的平均分，通过总分除以科目数量（此处为 3）计算得到
    std::shared_ptr<Student> next;  // 指向下一个学生的链表指针，用于构建班级内学生链表结构

    // 构造函数
    Student(int id, const std::string& name, float chinese, float math, float english);

    // 计算总分和平均分
    void calculateScores();

    // 打印学生信息
    void display() const;
};

Student类聚焦于学生个体的各项信息存储与相关基本操作，具体如下：

• 构造函数：在创建学生对象时，接收学号、姓名以及三科成绩作为参数，初始化对应成员变量，并通过调用calculateScores函数自动计算总分和平均分，保证学生对象创建后各项成绩数据的完整性。
• calculateScores函数：按照成绩计算逻辑，将chinese_score、math_score和english_score相加得到总分，再除以 3 得出平均分，更新total_score和average_score成员变量的值，确保成绩数据的准确性和实时性。
• display函数：按照固定格式将学生的学号、姓名、各科成绩、总分以及平均分等信息输出显示，方便查看和了解单个学生的综合情况。

二、学生与班级功能实现（Grade.cpp）

（一）Student类构造函数实现

// Student 类构造函数
Student::Student(int id, const std::string& name, float chinese, float math, float english)
    : student_id(id), student_name(name), chinese_score(chinese), math_score(math), english_score(english), total_score(0), average_score(0) {
    calculateScores();
}

在构造函数的实现中，首先使用初始化列表对学生的学号、姓名以及各科成绩进行初始化赋值，将总分和平均分初始化为 0，随后立即调用calculateScores函数来计算并更新总分和平均分，确保学生对象创建时成绩数据的正确初始化。

（二）calculateScores函数实现（计算总分和平均分）

// 计算总分和平均分
void Student::calculateScores() {
    total_score = chinese_score + math_score + english_score;
    average_score = total_score / 3;
}

此函数实现了简单的成绩计算逻辑，将学生的中文、数学和英语成绩相加得到总分，再将总分除以 3 得到平均分，分别更新total_score和average_score这两个成员变量的值，使得学生对象中的成绩数据始终保持准确和完整。

（三）display函数实现（显示学生信息）

// 显示学生信息
void Student::display() const {
    std::cout << "学号: " << student_id << ", 姓名: " << student_name
        << ", 中文: " << chinese_score << ", 数学: " << math_score
        << ", 英语: " << english_score << ", 总分: " << total_score
        << ", 平均分: " << average_score << std::endl;
}

该函数按照清晰明了的格式，将学生对象的各项信息输出到标准输出流中，方便用户直观地查看学生的详细信息，例如在查询学生信息或者打印班级所有学生信息时会调用此函数来展示具体内容。

（四）Class类的addStudent函数实现（添加学生到班级）

// 添加学生到班级
void Class::addStudent(int student_id, const std::string& name, float chinese, float math, float english) {
    auto newStudent = std::make_shared<Student>(student_id, name, chinese, math, english);
    if (!student_head) {
        student_head = newStudent;
    }
    else {
        std::shared_ptr<Student> temp = student_head;
        while (temp->next) {
            temp = temp->next;
        }
        temp->next = newStudent;
    }
}

这个函数实现了向班级的学生链表中添加新学生的功能。首先，通过std::make_shared创建一个新的Student对象，传入相应的学生信息参数。接着，判断班级的学生链表是否为空，如果为空，则直接将新创建的学生对象赋值给student_head，使其成为链表的头节点；若链表不为空，则通过遍历链表找到最后一个节点（即当前next指针为nullptr的节点），然后将新学生对象插入到链表末尾，确保学生信息按照添加顺序依次存储在链表中。

（五）Class类的printStudents函数实现（打印班级所有学生信息）

// 打印班级所有学生信息
void Class::printStudents() const {
    std::shared_ptr<Student> temp = student_head;
    std::cout << "班级ID: " << class_id << std::endl;
    while (temp) {
        temp->display();
        temp = temp->next;
    }
}

该函数用于打印班级内所有学生的详细信息。从学生链表的头节点开始，通过循环遍历链表，每次调用当前学生对象的display函数输出其信息，直到遍历完整个链表，这样就能完整地展示出班级内所有学生的各项成绩和基本信息，方便查看班级整体学生情况。

（六）Class类的statisticsStudent函数实现（统计班级学生信息）

// 统计班级学生信息
void Class::statisticsStudent() const {
    int count = 0;
    float total = 0;
    std::shared_ptr<Student> temp = student_head;
    while (temp) {
        total += temp->total_score;
        count++;
        temp = temp->next;
    }
    if (count > 0) {
        std::cout << "班级 " << class_id << " 平均分: " << total / count << std::endl;
    }
}

此函数旨在统计班级学生的平均成绩。通过遍历班级的学生链表，累加每个学生的总分，同时记录学生的数量，最后在学生数量大于 0 的情况下，将总分除以学生数量得到平均分并输出显示，为了解班级整体学习水平提供了重要的数据参考。

三、功能实现类（StudentInfoImpl.h 和 StudentInfoImpl.cpp）

（一）整体架构

StudentInfoImpl类作为系统功能实现的核心类，继承自抽象基类StudentInfoBase（此处虽未展示抽象基类完整定义，但可理解为它定义了一系列学生信息管理相关操作的接口），负责具体实现如学生信息的录入、添加、删除、查询、修改、统计以及打印和排序等关键功能，是整个学生信息管理系统的业务逻辑层。

（二）StudentInfoImpl类声明（StudentInfoImpl.h）

// 学生信息操作
class StudentInfoImpl {
public:
    StudentInfoImpl();  // 构造函数，用于初始化对象相关状态
    ~StudentInfoImpl();  // 析构函数，负责清理对象占用的资源

    void inputInfo();          // 录入学生信息，实现批量输入班级和学生具体数据的功能
    void addStudent();         // 添加学生信息，支持向指定班级插入新学生信息
    void deleteStudent();      // 删除学生信息，可从指定班级移除特定学生的记录
    void searchStudent();      // 查询学生信息，按照班级和学号查找并展示学生详细情况
    void modifyStudent();      // 修改学生信息，允许更新指定学生的各项信息
    void statisticsStudent();  // 统计学生信息，例如计算各班学生的平均分等统计数据
    void printStudents();      // 打印所有学生信息，将系统中存储的所有学生信息以清晰格式输出展示
    void sortByTotalScore();   // 按总分排序学生信息，便于根据成绩对学生进行排名分析

    static void menu();        // 显示菜单，提供用户交互界面，展示可操作的功能选项

private:
    std::vector<Class> classes;  // 使用向量容器存储班级信息，方便动态管理不同数量的班级

    bool isValidClassId(int class_id) const;  // 检查班级ID是否有效，辅助其他函数进行输入合法性判断
    bool isValidStudentInClass(int class_id, int student_id) const;  // 检查学生是否在指定班级中，确保相关操作针对正确的学生对象
};

（三）StudentInfoImpl类各成员函数实现（StudentInfoImpl.cpp）

1. 构造函数与析构函数

// 构造函数
StudentInfoImpl::StudentInfoImpl() {}
// 析构函数
StudentInfoImpl::~StudentInfoImpl() {}

构造函数目前为空实现，可根据后续需求添加对成员变量的初始化操作，例如对classes向量进行必要的初始化设置等。析构函数同样为空实现，由于在代码中使用了智能指针来管理内存（如std::shared_ptr），智能指针会自动处理其所管理对象的内存释放，所以暂时不需要在析构函数中手动释放内存，但如果后续有其他资源需要清理，可在此处添加相应逻辑。

2. inputInfo函数（录入学生信息）

// 录入学生信息
void StudentInfoImpl::inputInfo() {
    int classCount, studentCount;
    cout << "请输入班级数量: ";
    cin >> classCount;
    cout << "请输入每个班级的学生数量: ";
    cin >> studentCount;

    // 录入每个班级的学生信息
    for (int i = 1; i <= classCount; ++i) {
        Class newClass(i);
        for (int j = 1; j <= studentCount; ++j) {
            string name;
            float chinese, math, english;
            cout << "请输入第" << i << "班第" << j << "个学生的姓名: ";
            cin >> name;
            cout << "请输入中文成绩: ";
            cin >> chinese;
            cout << "请输入数学成绩: ";
            cin >> math;
            cout << "请输入英语成绩: ";
            cin >> english;

            newClass.addStudent(j, name, chinese, math, english);
        }
        classes.push_back(newClass);
    }
}

该函数实现了批量录入学生信息的功能。首先，从用户输入获取班级数量和每个班级的学生数量，然后通过两层嵌套循环，针对每个班级及其内部的每个学生，依次获取学生的姓名和各科成绩信息，并调用Class类的addStudent函数将学生信息添加到对应的班级中，最后将班级对象添加到classes向量容器里，完成整个信息录入过程，使得系统能够存储多个班级及其所属学生的信息。

3. addStudent函数（添加学生信息）

// 添加学生信息
void StudentInfoImpl::addStudent() {
    int classID;
    cout << "请输入班级ID: ";
    cin >> classID;

    if (!isValidClassId(classID)) {
        cout << "班级ID无效!" << endl;
        return;
    }

    int student_id;
    cout << "请输入学生ID: ";
    cin >> student_id;

    // 检查学号是否已经存在
    if (isValidStudentInClass(classID, student_id)) {
        cout << "学生ID已存在!" << endl;
        return;
    }

    string name;
    float chinese, math, english;
    cout << "请输入学生姓名: ";
    cin >> name;
    cout << "请输入中文成绩: ";
    cin >> chinese;
    cout << "请输入数学成绩: ";
    cin >> math;
    cout << "请输入英语成绩: ";
    cin >> english;

    // 创建新学生对象
    auto newStudent = make_shared<Student>(student_id, name, chinese, math, english);

    Class& classObj = classes[classID - 1];

    // 如果班级为空，直接将新学生设为头节点
    if (!classObj.student_head) {
        classObj.student_head = newStudent;
        cout << "学生信息已添加!" << endl;
        return;
    }

    // 提供插入位置选择
    int position;
    cout << "请输入要插入的位置（1表示在第一个学生后面插入，2表示在第二个学生后面，以此类推）: ";
    cin >> position;

    // 检查位置是否有效
    int totalStudents = 0;
    shared_ptr<Student> temp = classObj.student_head;
    while (temp) {
        totalStudents++;
        temp = temp->next;
    }

    if (position < 1 || position > totalStudents + 1) {
        cout << "插入位置无效!" << endl;
        return;
    }

    // 如果选择的是插入到第一个位置前，直接修改头指针
    if (position == 1) {
        newStudent->next = classObj.student_head;
        classObj.student_head = newStudent;
    }
    else {
        // 否则，在指定位置插入
        temp = classObj.student_head;
        int currentPos = 1;
        while (currentPos < position - 1) {
            temp = temp->next;
            currentPos++;
        }

        // 插入新学生
        newStudent->next = temp->next;
        temp->next = newStudent;
    }

    cout << "学生信息已添加!" << endl;
}

这个函数用于向指定班级添加新学生信息。首先，获取用户输入的班级 ID 和学生 ID，通过调用isValidClassId和isValidStudentInClass函数分别验证班级 ID 是否有效以及学生 ID 是否已存在于该班级中，如果验证不通过则直接返回相应错误提示。接着，获取新学生的各项信息创建新的Student对象，然后根据班级当前学生链表情况决定插入位置。如果班级学生链表为空，直接将新学生设为头节点；若不为空，则让用户选择插入位置，并检查位置的有效性，最后按照链表插入逻辑将新学生插入到指定位置，完成学生信息的添加操作，并输出添加成功的提示信息。

4. deleteStudent函数（删除学生信息）

// 删除学生信息
void StudentInfoImpl::deleteStudent() {
    int classID, studentID;
    cout << "请输入班级ID: ";
    cin >> classID;
    cout << "请输入学生ID: ";
    cin >> studentID;

    if (!isValidClassId(classID)) {
        cout << "班级ID无效!" << endl;
        return;
    }

    Class& classObj = classes[classID - 1];
    shared_ptr<Student> temp = classObj.student_head;
    shared_ptr<Student> prev = nullptr;
    while (temp) {
        if (temp->student_id == studentID) {
            if (prev) {
                prev->next = temp->next;
            } else {
                classObj.student_head = temp->next;
            }
            cout << "学生已删除!" << endl;
            return;
        }
        prev = temp;
        temp = temp->next;
    }
    cout << "学生ID无效!" << endl;
}

此函数实现了从指定班级中删除学生信息的功能。首先，让用户输入要操作的班级 ID 和学生 ID，通过isValidClassId函数验证班级 ID 的有效性，若无效则给出提示并返回。接着获取对应班级对象，然后遍历该班级的学生链表，在遍历过程中查找要删除的学生节点。当找到目标学生节点时，根据其是否为链表头节点来进行不同的删除操作：如果是头节点，直接将头指针指向下一个节点；如果不是头节点，则通过调整前一个节点的next指针来跳过当前要删除的节点，完成删除操作后输出提示信息。若遍历完链表都未找到对应学生 ID 的节点，则输出学生 ID 无效的提示。

5. searchStudent函数（查询学生信息）

// 查询学生信息
void StudentInfoImpl::searchStudent() {
    int classID, studentID;
    cout << "请输入班级ID: ";
    cin >> classID;
    cout << "请输入学生ID: ";
    cin >> studentID;

    if (!isValidClassId(classID)) {
        cout << "班级ID无效!" << endl;
        return;
    }

    Class& classObj = classes[classID - 1];
    shared_ptr<Student> temp = classObj.student_head;
    while (temp) {
        if (temp->student_id == studentID) {
            temp->display();
            return;
        }
        temp = temp->next;
    }
    cout << "学生ID无效!" << endl;
}

searchStudent函数用于根据用户输入的班级 ID 和学生 ID 查询并展示特定学生的详细信息。先是获取班级 ID 和学生 ID 并验证班级 ID 的有效性，若无效则终止操作并提示。之后定位到对应班级，遍历其学生链表，一旦找到学生 ID 匹配的学生节点，就调用该学生对象的display函数来输出其详细信息，然后返回。若遍历完整个链表都未找到匹配的学生，则输出学生 ID 无效的提示信息，方便用户快速查找指定学生的情况。

6. modifyStudent函数（修改学生信息）

// 修改学生信息
void StudentInfoImpl::modifyStudent() {
    int classID, studentID;
    cout << "请输入班级ID: ";
    cin >> classID;
    cout << "请输入学生ID: ";
    cin >> studentID;

    if (!isValidClassId(classID)) {
        cout << "班级ID无效!" << endl;
        return;
    }

    Class& classObj = classes[classID - 1];
    shared_ptr<Student> temp = classObj.student_head;
    while (temp) {
        if (temp->student_id == studentID) {
            string name;
            float chinese, math, english;
            cout << "请输入新的学生姓名: ";
            cin >> name;
            cout << "请输入新的中文成绩: ";
            cin >> chinese;
            cout << "请输入新的数学成绩: ";
            cin >> math;
            cout << "请输入新的英语成绩: ";
            cin >> english;

            temp->student_name = name;
            temp->chinese_score = chinese;
            temp->math_score = math;
            temp->english_score = english;
            temp->calculateScores();
            cout << "学生信息已修改!" << endl;
            return;
        }
        temp = temp->next;
    }
    cout << "学生ID无效!" << endl;
}

该函数提供了修改指定学生信息的功能。首先要求用户输入班级 ID 和学生 ID，对班级 ID 进行有效性验证，若不符合要求则结束操作并提示错误。在获取到有效班级 ID 后，定位到对应班级并遍历其学生链表，查找要修改的学生节点。当找到目标学生节点后，提示用户依次输入新的学生姓名、各科成绩等信息，然后更新该学生对象相应的成员变量，并调用calculateScores函数重新计算总分和平均分，确保成绩数据的准确性，最后输出修改成功的提示信息并返回。若未找到对应学生 ID 的节点，则输出相应的错误提示。

7. statisticsStudent函数（统计学生信息）

// 统计学生信息
void StudentInfoImpl::statisticsStudent() {
    for (const auto& classObj : classes) {
        classObj.statisticsStudent();
    }
}

此函数用于统计系统中所有班级学生的相关信息，具体是通过遍历存储班级信息的classes向量容器，对每个班级对象调用其自身的statisticsStudent函数，来分别计算并输出每个班级的学生平均分等统计数据，这样能让用户从班级层面了解学生的整体学习水平情况，为教学分析等提供数据支持。

8. printStudents函数（打印所有学生信息）

// 打印所有学生信息
void StudentInfoImpl::printStudents() {
    for (const auto& classObj : classes) {
        classObj.printStudents();
    }
}

printStudents函数的功能是将系统中存储的所有学生信息进行完整输出展示。它通过遍历classes向量容器中的每个班级对象，然后针对每个班级对象调用其printStudents函数，这样就能依次输出各个班级内所有学生的详细信息，方便查看整个系统中所有学生的综合情况，例如生成学生信息报表等场景会用到该功能。

9. sortByTotalScore函数（按总分排序学生信息）

// 按总分排序学生信息
void StudentInfoImpl::sortByTotalScore() {
    vector<Student*> allStudents;
    for (auto& classObj : classes) {
        auto temp = classObj.student_head;
        while (temp) {
            allStudents.push_back(temp.get());
            temp = temp->next;
        }
    }

    // 按总分从高到低排序
    sort(allStudents.begin(), allStudents.end(), [](Student* a, Student* b) {
        return a->total_score > b->total_score;
        });

    cout << "按总分排序后的学生信息: " << endl;
    for (auto* student : allStudents) {
        student->display();
    }
}

该函数实现了按照学生总分对所有学生信息进行排序并展示的功能。首先，遍历classes向量容器中的每个班级，再遍历班级内的学生链表，将所有学生对象的指针收集到allStudents向量中。接着，使用std::sort算法结合自定义的 lambda 表达式，按照学生的总分从高到低对收集到的学生指针向量进行排序。最后，遍历排序后的学生指针向量，逐个调用学生对象的display函数，将排序后的学生信息展示出来，有助于对学生的整体学业表现进行排名分析等操作。

10. menu函数（显示菜单）

// 显示菜单
void StudentInfoImpl::menu() {
    cout << "****************************************\n";
    cout << "*******       学生信息系统       *******\n";
    cout << "****************************************\n";
    cout << "*******     1.录入学生信息       *******\n";
    cout << "*******--------------------------*******\n";
    cout << "*******     2.添加学生信息       *******\n";
    cout << "*******--------------------------*******\n";
    cout << "*******     3.删除学生信息       *******\n";
    cout << "*******--------------------------*******\n";
    cout << "*******     4.查询学生信息       *******\n";
    cout << "*******--------------------------*******\n";
    cout << "*******     5.修改学生信息       *******\n";
    cout << "*******--------------------------*******\n";
    cout << "*******     6.统计学生信息       *******\n";
    cout << "*******--------------------------*******\n";
    cout << "*******     7.打印学生信息       *******\n";
    cout << "*******--------------------------*******\n";
    cout << "*******     8.按总分排序学生信息 *******\n";
    cout << "*******--------------------------*******\n";
    cout << "*******     0.退出系统           *******\n";
    cout << "****************************************\n";
}

menu函数用于显示系统的操作菜单界面，通过向标准输出流输出一系列格式化的文本信息，清晰地展示出各个可供用户选择的功能选项，包括录入、添加、删除、查询、修改、统计、打印以及按总分排序学生信息等功能，还有退出系统的选项，为用户提供了直观便捷的交互入口，方便用户根据需求选择相应的操作。

11. 辅助验证函数

// 检查班级ID是否有效
bool StudentInfoImpl::isValidClassId(int class_id) const {
    return class_id > 0 && class_id <= classes.size();
}

// 检查学生ID是否在指定班级中
bool StudentInfoImpl::isValidStudentInClass(int class_id, int student_id) const {
    // 检查班级ID是否有效
    if (class_id <= 0 || class_id > classes.size()) {
        return false;  // 班级ID无效
    }

    // 获取指定班级
    const Class& classObj = classes[class_id - 1];

    // 遍历班级中的学生链表，查找是否有指定ID的学生
    shared_ptr<Student> temp = classObj.student_head;
    while (temp) {
        if (temp->student_id == student_id) {
            return true;  // 找到该学生
        }
        temp = temp->next;  // 移动到下一个学生
    }

    return false;  // 未找到该学生
}

isValidClassId函数用于检查给定的班级 ID 是否有效，判断依据是班级 ID 大于 0 且不超过系统中已存储的班级数量（即classes向量的大小），在多个涉及班级操作的函数中会调用该函数来提前验证用户输入的班级 ID 的合法性，避免后续因无效班级 ID 导致的错误操作。

isValidStudentInClass函数相对更复杂些，它首先检查班级 ID 的有效性，若无效则直接返回false。在班级 ID 有效的情况下，获取对应的班级对象，然后遍历该班级的学生链表，查找是否存在指定学生 ID 的学生，如果找到则返回true，表示学生在该班级中；若遍历完链表都未找到，则返回false，表明学生不在此班级。这个函数在涉及对特定班级内学生进行操作（如添加、删除、查询、修改等操作）的函数中被频繁调用，用于确保操作的目标学生确实存在于指定班级中，保障系统操作的准确性。

四、系统入口（main.cpp）

（一）整体功能

main.cpp 文件作为整个学生信息管理系统的入口点，通过创建StudentInfoImpl类的对象，并利用菜单驱动的交互方式，让用户能够方便地选择和执行不同的学生信息管理功能，实现与系统的交互操作，是连接用户与系统核心功能的桥梁。

（二）代码实现

#include <iostream>
#include <limits>
#include "StudentInfoImpl.h"
using namespace std;

int main() {
    StudentInfoImpl studentInfoSystem;
    int input = 0;

    do {
        studentInfoSystem.menu();  // 显示菜单

        cout << "请输入选择: ";
        while (!(cin >> input) || (input < 0 || input > 8)) {
            cin.clear();  // 清除错误状态
            cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');  // 清空输入缓冲区
            cout << "无效的选择，请输入 0 到 8 之间的数字！\n";
            cout << "请输入选择: ";
        }

        cout << "#########################################\n";

        // 根据用户选择执行相应操作
        switch (input) {
        case 1:
            cout << "录入学生信息...\n";
            studentInfoSystem.inputInfo();
            break;
        case 2:
            cout << "添加学生信息...\n";
            studentInfoSystem.addStudent();
            break;
        case 3:
            cout << "删除学生信息...\n";
            studentInfoSystem.deleteStudent();
            break;
        case 4:
            cout << "查询学生信息...\n";
            studentInfoSystem.searchStudent();
            break;
        case 5:
            cout << "修改学生信息...\n";
            studentInfoSystem.modifyStudent();
            break;
        case 6:
            cout << "统计学生信息...\n";
            studentInfoSystem.statisticsStudent();
            break;
        case 7:
            cout << "打印学生信息...\n";
            studentInfoSystem.printStudents();
            break;
        case 8:
            cout << "按总分排序学生信息...\n";
            studentInfoSystem.sortByTotalScore();
            break;
        case 0:
            cout << "退出系统\n";
            break;
        default:
            cout << "选择错误，请重新输入！\n";
            break;
        }

    } while (input!= 0);

    cout << "感谢使用学生信息管理系统，系统已退出。\n";
    return 0;
}

在main函数中，首先创建了StudentInfoImpl类的对象studentInfoSystem，用于调用系统提供的各类学生信息管理功能。然后通过一个do-while循环实现菜单的持续显示与用户交互操作，每次循环先调用menu函数展示操作菜单，接着获取用户输入的选择数字。在获取输入过程中，通过while循环进行输入合法性验证，若输入不合法（非 0 - 8 之间的数字），则清除输入流的错误状态，清空输入缓冲区，并提示用户重新输入。

当获取到合法的用户输入后，通过switch语句根据不同的选择执行相应的系统功能函数，例如选择 1 则调用inputInfo函数录入学生信息，选择 0 则执行退出系统的操作等。循环会一直持续，直到用户选择退出系统（输入为 0），最后输出感谢使用的提示信息，整个程序结束运行，完成一次完整的学生信息管理系统交互操作流程。

五、总结

通过本次对学生信息管理系统的优化实现，充分利用了 C++ 的面向对象编程特性，使得系统整体结构更加模块化、清晰易懂。各个类各司其职，Grade.h中定义的Student和Class类构建了基础的数据存储和操作结构，StudentInfoImpl类进一步封装了丰富的业务逻辑功能，而main.cpp则作为入口协调用户与系统的交互。

继承机制虽在文中未详细展开其复杂应用，但为系统未来的功能扩展预留了良好的设计空间，便于添加更多类型的学生信息或者衍生出不同管理模式的子类等。智能指针的运用更是一大亮点，有效避免了手动管理内存可能带来的内存泄漏、悬空指针等问题，使得系统在长时间运行和复杂操作下也能保持稳定可靠。

整体而言，这样的设计不仅让系统当前功能得以高效实现，满足日常学生信息管理的各种需求，同时也为后续的维护与功能拓展奠定了坚实基础，使其能够更好地适应不断变化的教育管理场景和实际应用需求。

你可以根据实际情况对上述优化后的内容进行调整，比如若需要更详细的某部分功能说明，或者要精简部分内容等都可以再做进一步修改。希望对你有所帮助！如果还有其他要求，欢迎继续向我提问。