【数据结构实习】学生信息管理系统2.0

Student.h

#include<iostream>
#include<string>
#include<fstream>
using namespace std;
const int MAXSIZE = 5;//最大班级数目
/*
学生结点，即每个学生的信息
*/
struct Stu_Node {
    string name;//学生姓名
    int sex;//性别
    int age;//年龄
    string stu_number;//学号
    double *stu_grade;//科目成绩
    double stu_average;//平均分
    int stu_rank;//成绩排名
    Stu_Node *next;
};
/*
Class_Node结点即为班级，负责记录班级姓名以及每一个班级的链表的首地址
其中，科目为每一个班的通用信息
*/
struct Class_Node {
    string *stu_lesson;//科目
    int lesson_number;//科目数量
    string class_name;//班级名称
    Stu_Node *address;//首地址
    int stu_total;//该班级学生人数
};

class STUDENT {
private:
    Class_Node *data;
    int class_number;//班级个数
    //初始化班级，形参列表为：班级名称，课程数，课程名称
    void init_class(string class_name[]);//初始化班级
    void init_grade(int location);
    int search_className(string name);//返回班级地址下标，-1代表未找到
    //添加学生信息，形参列表为:班级地址，学生数目
    void add_stu(int location, int number, string name);
    Stu_Node* search_stuName(string name, int location);//未找到返回空
    void delete_stu(Stu_Node *&p, Stu_Node *&head);
    void print(int loc);//打印学生信息
    void average_grade(int loc);
    void sort_select(int loc);
    void exchange(Stu_Node *&p, Stu_Node *&q, int loc);
    void print_grade(int loc);
    bool grade_premisson(int loc);
    void add_class(string name);//一次只能增加一个班级
    void print_stu(Stu_Node *p);
    void save_data(int mode);
    bool save_premisson();
public:
    STUDENT(int class_number);//构造函数
    STUDENT(bool flag,bool &result);//存档的构造函数
    void deleteStu();//删除学生
    void initSystem();//初始化系统
    void addStu();//添加学生
    void Print();//打印信息
    void averageStu();//求平均成绩
    void sortStu();//排序
    void initGrade();//录入成绩
    void printGrade();//打印学生成绩
    void addClass();//添加班级
    void searchStu();//查找学生
    void saveData(int mode);
};

Student.cpp

#include "Student.h"
void STUDENT::print_stu(Stu_Node *p)
{
    if (p == NULL)
    {
        cout << "未找到该学生！" << endl;
    }
    else
    {
        cout << "姓名: " << p->name << " 学号:" << p->stu_number;
        cout << " 性别:";
        if (p->sex)
            cout << "男";
        else
            cout << "女";
        if (p->stu_average > 0)
        {
            cout << " 平均分:" << p->stu_average << " 排名:" << p->stu_rank << endl;
        }
    }
}

void STUDENT::save_data(int mode)
{
    //存储操作，将用户录入的数据存入本地
    fstream ofile;
    if (mode == 1)
        ofile.open("userDataBase.txt", ios::out);
    else
        ofile.open("EXdataBase.txt", ios::out);
    if (ofile.fail())
    {
        cout << "打开文件失败！" << endl;
        return;
    }
    ofile << class_number << endl;//写入班级个数
    for (int i = 0; i < class_number; i++)
    {
        ofile << data[i].class_name << " ";//写入班级名称
        ofile << data[i].lesson_number << " ";
        for (int j = 0; j < data[i].lesson_number; j++)
        {
            ofile << data[i].stu_lesson[j] << " ";//输出课程名称
        }
        ofile << endl;
    }
    for (int i = 0; i < class_number; i++)//写入学生信息
    {
        ofile << data[i].stu_total << endl;//学生个数
        Stu_Node *p = data[i].address;
        while (p != NULL)
        {
            ofile << p->name << " " << p->age << " " << p->sex << " " << p->stu_number << " ";
            for (int j = 0; j < data[i].lesson_number; j++)
            {
                ofile << p->stu_grade[j] << " ";
            }
            ofile << endl;
            p = p->next;
        }
    }
    ofile.close();
}

bool STUDENT::save_premisson()
{
    for (int i = 0; i < class_number; i++)
    {
        if (data[i].stu_total == 0)
        {
            return false;
        }
        else
        {
            if (data[i].address->stu_rank == 0)
                return false;
        }
    }
    return true;
}

/*
函数名称：初始化班级
函数类型：私有函数
函数参数：班级名称的字符串
函数功能：初始化班级名称以及学科
函数原理：
          1.分别给这class_number个班级进行赋值
          2.为班级逐个指定课程和课程名称
*/
void STUDENT::init_class(string class_name[])
{
    for (int i = 0; i < class_number; i++)
    {
        data[i].class_name = class_name[i];
        cout << "请输入 " << class_name[i] << " 的课程数和课程名称：" << endl;
        cin >> data[i].lesson_number;
        data[i].stu_lesson = new string[data[i].lesson_number];
        for (int j = 0; j < data[i].lesson_number; j++)
        {
            cin >> data[i].stu_lesson[j];
        }
    }
}
/*
函数名称：初始化学生成绩
函数类型：私有函数
函数参数：班级下标
函数功能：为班级学生的科目成绩赋值
函数原理：
          1.判断对应班级的链表中学生的信息是否存在
          2.通过遍历链表逐一赋值
*/
void STUDENT::init_grade(int location)
{
    Stu_Node *p = data[location].address;
    if (p == NULL)
    {
        cout << "错误！请检查该班级是否已录入学生信息！" << endl;
    }
    else
    {
        while (p != NULL)
        {
            cout << "请输入" << p->name << "的成绩：" << endl;
            p->stu_grade = new double[data[location].lesson_number];
            for (int i = 0; i < data[location].lesson_number; i++)
            {
                cout << data[location].stu_lesson[i] << " ";
                cin >> p->stu_grade[i];
            }
            p = p->next;
        }
    }
}
/*
函数名称：查找班级
函数类型：私有函数
函数参数：班级名称，返回班级下标
函数功能：遍历数组查找指定班级名称，查找失败返回-1
函数原理：
          1.简单查找，逐一比对
          2.成功返回对应地址下标，否则返回-1
*/
int STUDENT::search_className(string name)
{
    for (int i = 0; i < class_number; i++)
    {
        if (data[i].class_name == name)
        {
            return i;
        }
    }
    return -1;
}
/*
函数名称：添加学生信息
函数类型：私有函数
函数参数：班级地址，添加学生数量，班级名称
函数功能：指定班级添加学生信息
函数原理：
          1.判断是否存在该班级
          2.若存在则增加班级人数并逐一赋值
          3.若不存在则提示是否创建班级
            否结束函数
            是则判断是否可以添加
              可以就添加班级信息
              不可以提示已满
*/
void STUDENT::add_stu(int location, int number, string name)
{
    if (location == -1)//未找到指定班级
    {
        cout << "未找到该班级，是否添加？(y/n)" << endl;
        char option;
        cin >> option;
        if (option == 'y')
        {
            add_class(name);
            location++;
        }
        else
            return;
    }
    //下面开始赋值
    data[location].stu_total = data[location].stu_total + number;//添加学生个数
    cout << "请分别输入这" << number << "个学生的 姓名 年龄 性别（0/1） 学号 " << endl;
    Stu_Node *end = data[location].address;//从首地址开始
    if (end == NULL)//如果首地址为空则说明该班级人数为空，需要创建头节点
    {
        end = new Stu_Node();
        cin >> end->name;
        cin >> end->age;
        cin >> end->sex;
        cin >> end->stu_number;
        end->next = NULL;
        number--;//头节点就是一个学生，故需要在总数里减少一个
        data[location].address = end;
    }
    while (end->next != NULL)//移动到最后一个节点处
        end = end->next;
    for (int i = 0; i < number; i++)
    {
        //这里其实可以直接在结构体里定义一个构造函数可能会更简洁一点
        Stu_Node *add = new Stu_Node;
        cin >> add->name;
        cin >> add->age;
        cin >> add->sex;
        cin >> add->stu_number;
        add->next = NULL;
        add->stu_average = 0;
        add->stu_rank = 0;
        add->stu_grade = NULL;
        end->next = add;
        end = add;
    }
}
/*
函数名称：搜索学生
函数类型：私有函数
函数参数：学生姓名，班级地址
函数功能：查找指定班级的学生姓名
函数原理：
          1.创建一个指针指向班级的首地址
          2.若不为空进行遍历操作，相等则返回学生指针地址
          3.未找到则返回空指针
*/
Stu_Node* STUDENT::search_stuName(string name, int location)
{
    Stu_Node *p = data[location].address;
    while (p != NULL)
    {
        if (p->name == name)
            return p;
        p = p->next;
    }
    return NULL;
}
/*
函数名称：删除学生
函数类型：私有函数
函数参数：班级的首地址，学生的地址
函数功能：删除学生信息
函数原理：
          1.创建一个temp指针找到要删除的学生的前一个地址
          2.进行删除操作
          3.删除p指针
*/
void STUDENT::delete_stu(Stu_Node *& p, Stu_Node *&head)
{
    Stu_Node *temp = head;
    if (p == NULL)
    {
        cout << "未找到该学生或者该班级学生信息不存在！" << endl;
        return;
    }

    if (temp == p && temp->next == NULL)//头结点
    {
        delete head;
        head = NULL;
    }
    else if (temp == p && temp->next != NULL)
    {
        temp = temp->next;
        head = temp;
        delete p;
    }
    else
    {
        while (temp->next != p)
            temp = temp->next;
        temp->next = p->next;
        delete p;
    }
}
void STUDENT::print(int loc)
{
    if (loc == -1)
    {
        cout << "未找到班级，请重试！" << endl;
        return;
    }
    Stu_Node *p = data[loc].address;
    while (p != NULL)
    {
        cout << "姓名: " << p->name << " 学号:" << p->stu_number;
        cout << " 性别:";
        if (p->sex)
            cout << "男";
        else
            cout << "女";
        cout << endl;
        p = p->next;

    }
}
/*
函数名称：计算平均分
函数类型：私有函数
函数参数：班级地址
函数功能：计算指定班级的平均分
函数原理：
          1.判断地址是否合法，不合法返回
          2.地址合法 判断是否grade已经赋值，若没有赋值询问是否录入（调用函数）
          3.获取该班级的科目总数并sum每个学生的成绩
*/
void STUDENT::average_grade(int loc)
{
    if (loc == -1)
    {
        cout << "未找到班级，请重试" << endl;
        return;
    }
    //判断是否为空
    if (data[loc].address == NULL)
    {
        cout << "该班级的成绩还未录入，是否录入？(y/n)" << endl;
        char option;
        cin >> option;
        if (option == 'y')
        {
            init_grade(loc);
        }
        else
        {
            return;//退出程序
        }
    }
    //下面是计算
    Stu_Node *p = data[loc].address;
    while (p != NULL)
    {
        double sum = 0.0;
        for (int i = 0; i < data[loc].lesson_number; i++)
        {
            sum = sum + p->stu_grade[i];
        }
        p->stu_average = sum / data[loc].lesson_number;
        p = p->next;
    }

}
/*
函数名称：选择排序
函数类型：私有函数
函数参数：班级地址
函数功能：通过平均分来排序
函数原理：
          1.判断地址是否合法，不合法返回
          2.地址合法 进行排序
            需要两个指针，一个指向当前比较，一个指向下一个交替进行
          3.排序完以后由于学生信息已经是有序的了，故直接给rank赋值即可，按照1-n

*/
void STUDENT::sort_select(int loc)
{
    if (loc == -1)
    {
        cout << "指定班级不存在OK？重试一次吧！" << endl;
        return;
    }
    //需要两个指针 
    Stu_Node *p = data[loc].address;
    Stu_Node *q;
    while (p != NULL)
    {
        Stu_Node *tag = p;
        q = tag->next;
        while (q != NULL)
        {
            if (p->stu_average < q->stu_average)
            {
                exchange(p, q, loc);
            }
            q = q->next;
        }
        p = p->next;
    }
    //排序完成后对rank进行赋值
    p = data[loc].address;
    int rank_number = 1;
    while (p != NULL)
    {
        p->stu_rank = rank_number;
        rank_number++;
        p = p->next;
    }
}
/*
函数名称：交换函数
函数类型：私有函数
函数参数：两个结构指针，班级地址
函数功能：在排序中调用，负责交换两个结点的信息
函数原理：
          1.为其中一个创建数据副本
          2.两个数据进行赋值
          3.副本对另一个数据进行赋值
*/
void STUDENT::exchange(Stu_Node *& p, Stu_Node *& q, int loc)
{
    string temp_name = p->name;
    int temp_sex = p->sex;
    int temp_age = p->age;
    string temp_stu_number = p->stu_number;
    double *temp_grade = new double[data[loc].lesson_number];
    for (int i = 0; i < data[loc].lesson_number; i++)
    {
        temp_grade[i] = p->stu_grade[i];
    }
    double temp_average = p->stu_average;
    int temp_rank = p->stu_rank;

    p->name = q->name;
    p->sex = q->sex;
    p->age = q->age;
    p->stu_number = q->stu_number;
    for (int i = 0; i < data[loc].lesson_number; i++)
    {
        p->stu_grade[i] = q->stu_grade[i];
    }
    p->stu_average = q->stu_average;
    p->stu_rank = q->stu_rank;

    q->name = temp_name;
    q->sex = temp_sex;
    q->age = temp_age;
    temp_stu_number = p->stu_number;
    for (int i = 0; i < data[loc].lesson_number; i++)
    {
        q->stu_grade[i] = temp_grade[i];
    }
    q->stu_average = temp_average;
    q->stu_rank = temp_rank;
}
/*
函数名称：打印成绩
函数类型：私有函数
函数参数：班级地址
函数功能：打印班级对应学生的成绩信息
函数原理：
          1.判断地址是否合法，不合法返回
          2.地址合法 打印学生对应的成绩
*/
void STUDENT::print_grade(int loc)
{
    if (loc == -1)
    {
        cout << "指定班级不存在，请重试！" << endl;
        return;
    }
    Stu_Node *p = data[loc].address;
    while (p != NULL)
    {
        cout << p->name << " ";
        for (int i = 0; i < data[loc].lesson_number; i++)
        {
            cout << data[loc].stu_lesson[i] << ": " << p->stu_grade[i] << "  ;";
        }
        cout << "平均分:" << p->stu_average << " 排名:" << p->stu_rank << endl;
        p = p->next;
    }
}
/*
函数名称：打印许可
函数类型：私有函数
函数参数：班级地址
函数功能：判断是否可以打印学生成绩信息
函数原理：
          1.判断地址是否合法，不合法返回
          2.地址合法 判断 rank grade average 是否已被赋值
*/
bool STUDENT::grade_premisson(int loc)
{
    if (loc == -1)
        return false;
    else if (data[loc].address != NULL)
    {
        if (data[loc].address->stu_rank != 0 && data[loc].address->stu_grade != NULL && data[loc].address->stu_average != 0)
            return true;
        else
            return false;
    }
    else
        return false;
}

/*
函数名称：构造函数
函数类型：共有函数
函数参数：班级数量
函数功能：创建类对象并为number数量个班级进行赋值操作
函数原理：
          1.判断数目是否合法或者超出最大存储范围，不合法报错
          2.地址合法 逐一初始化操作
*/
STUDENT::STUDENT(int class_number)
{
    if (class_number < MAXSIZE&&class_number>0)
    {
        this->class_number = class_number;
        data = new Class_Node[MAXSIZE];
        for (int i = 0; i < class_number; i++)
        {
            data[i].stu_lesson = NULL;//科目
            data[i].lesson_number = 0;//科目数量
            data[i].class_name = " ";//班级名称
            data[i].address = NULL;//首地址
            data[i].stu_total = 0;//该班级学生人数
        }
    }
    else
    {
        cerr << "错误！超出最大范围或输入不合法！" << endl;
        exit(1);
    }

}
/*
函数名称：构造函数
函数类型：共有函数
函数参数：班级数量
函数功能：从本地读取进行赋值
函数原理：
          读取根目录下的database.txt进行赋值操作
*/
STUDENT::STUDENT(bool flag,bool &result)
{
    fstream ifile;
    if (flag)
        ifile.open("userDataBase.txt", ios::_Nocreate);
    else
        ifile.open("EXdataBase.txt", ios::in);
    if (ifile.fail())
    {
        result = false;
        return;
    }
    ifile >> class_number;//从文件中读取班级个数
    if (class_number < MAXSIZE&&class_number>0)//先对所有的进行一次初始化
    {
        data = new Class_Node[MAXSIZE];
        for (int i = 0; i < class_number; i++)
        {
            data[i].stu_lesson = NULL;//科目
            data[i].lesson_number = 0;//科目数量
            data[i].class_name = " ";//班级名称
            data[i].address = NULL;//首地址
            data[i].stu_total = 0;//该班级学生人数
        }
    }
    else
    {
        result = false;
        return;
    }
    for (int i = 0; i < class_number; i++)//初始化班级
    {
        ifile >> data[i].class_name;
        ifile >> data[i].lesson_number;
        data[i].stu_lesson = new string[data[i].lesson_number];
        for (int j = 0; j < data[i].lesson_number; j++)
        {
            ifile >> data[i].stu_lesson[j];
        }
    }
    int stu_number;
    //录入学生信息
    for (int i = 0; i < class_number; i++)
    {
        ifile >> stu_number;
        data[i].stu_total = stu_number;
        Stu_Node *end = data[i].address;//从首地址开始
        if (end == NULL)//如果首地址为空则说明该班级人数为空，需要创建头节点
        {
            end = new Stu_Node();
            ifile >> end->name;
            ifile >> end->age;
            ifile >> end->sex;
            ifile >> end->stu_number;
            end->next = NULL;
            end->stu_average = 0;
            end->stu_rank = 0;
            end->stu_grade = new double[data[i].lesson_number];
            stu_number--;//头节点就是一个学生，故需要在总数里减少一个
            data[i].address = end;
            for (int j = 0; j < data[i].lesson_number; j++)
            {
                ifile >> end->stu_grade[j];
            }
        }
        while (end->next != NULL)//移动到最后一个节点处
            end = end->next;
        for (int k= 0; k < stu_number; k++)
        {
            //这里其实可以直接在结构体里定义一个构造函数可能会更简洁一点
            Stu_Node *add = new Stu_Node;
            ifile>>add->name;
            ifile >> add->age;
            ifile >> add->sex;
            ifile >> add->stu_number;
            add->next = NULL;
            add->stu_average = 0;
            add->stu_rank = 0;
            add->stu_grade = new double[data[i].lesson_number];
            for (int j = 0; j < data[i].lesson_number; j++)
            {
                ifile >> add->stu_grade[j];
            }
            end->next = add;
            end = add;
        }
    }
    ifile.close();
    averageStu();
    sortStu();
}
/*
函数名称：删除学生
函数类型：共有函数
函数参数：无
函数功能：调用对应私有函数进行删除操作
*/
void STUDENT::deleteStu()
{
    cout << "请输入要删除的学生的班级:" << endl;
    string class_name;
    int loc;
    cin >> class_name;
    loc = search_className(class_name);
    if (loc == -1)
    {
        cout << "错误！未找到该班级，请检查后重试！" << endl;
    }
    else
    {
        cout << "请输入学生姓名：";
        string stu_name;
        cin >> stu_name;
        Stu_Node *p = search_stuName(stu_name, loc);
        if (p == NULL)
        {
            cout << "未找到该学生" << endl;
            return;
        }
        else
        {
            delete_stu(p, data[loc].address);
            cout << stu_name << "已经被删除!" << endl;
        }
    }
}
/*
函数名称：初始化系统
函数类型：共有函数
函数参数：无
函数功能：调用对应私有函数init_class进行班级初始化操作
*/
void STUDENT::initSystem()
{
    cout << "请分别输入这" << class_number << "个班级名称：" << endl;
    string *name_class;
    name_class = new string[class_number];
    for (int i = 0; i < class_number; i++)
    {
        cin >> name_class[i];
    }
    init_class(name_class);//初始化班级

}
/*
函数名称：添加学生信息
函数类型：共有函数
函数参数：无
函数功能：调用对应私有函数add_stu进行学生信息添加操作
*/
void STUDENT::addStu()
{
    cout << "请输入要增添学生的班级和添加的人数" << endl;
    string name_class;
    int number;
    cin >> name_class;
    cin >> number;
    add_stu(search_className(name_class), number, name_class);
}
/*
函数名称：打印学生信息
函数类型：共有函数
函数参数：无
函数功能：调用对应私有函数print进行学生信息打印操作
*/
void STUDENT::Print()
{
    //打印，打印班级学生信息
    cout << "请选择打印模式：1.打印指定班级学生信息 2.打印全部班级" << endl;
    int option;
    string name;
    cin >> option;
    switch (option)
    {
    case 1:
        cout << "请输入要打印的班级:";
        cin >> name;
        print(search_className(name));
        break;
    case 2:
        for (int i = 0; i < class_number; i++)
        {
            cout << data[i].class_name << "班: " << endl;
            print(i);
        }
        break;
    default:
        cout << "您输入的选项有误，请重试！" << endl;
    }
}
/*
函数名称：计算平均分
函数类型：共有函数
函数参数：无
函数功能：调用对应私有函数print进行学生信息打印操作
*/
void STUDENT::averageStu()
{
    for (int i = 0; i < class_number; i++)
    {
        average_grade(i);
    }
}
/*
函数名称：排序
函数类型：共有函数
函数参数：无
函数功能：调用对应私有函数sort_select进行学生成绩排序操作，必须执行成绩录入和求平均数
*/
void STUDENT::sortStu()
{
    for (int i = 0; i < class_number; i++)
    {
        sort_select(i);
    }
}
/*
函数名称：初始化成绩
函数类型：共有函数
函数参数：无
函数功能：调用私有函数init_grade
*/
void STUDENT::initGrade()
{
    cout << "请选择录入模式 1.全部 2.输入指定班级" << endl;
    int option;
    cin >> option;
    string name;
    switch (option)
    {
    case 1:
        for (int i = 0; i < class_number; i++)
        {
            cout << "请录入第" << i + 1 << " 个班级的学生成绩:" << endl;
            init_grade(i);
        }
        break;
    case 2:
        cout << "请输入要录入成绩的班级:" << endl;
        cin >> name;
        init_grade(search_className(name));
        break;
    default:
        cout << "Oops！您输入的选项错误！" << endl;
    }
}
/*
函数名称：打印班级学生成绩信息
函数类型：共有函数
函数参数：无
函数功能：打印成绩信息
函数原理：
          调用私有函数print_grade 函数
          支持指定班级打印和全部打印
*/
void STUDENT::printGrade()
{
    cout << "请选择打印模式：1.打印指定班级学生成绩 2.打印全部班级" << endl;
    int option;
    string name;
    cin >> option;
    switch (option)
    {
    case 1:
        cout << "请输入要打印的班级:";
        cin >> name;
        if (grade_premisson(search_className(name)))
        {
            cout << "成绩未录入或者排序/平均分还未计算，请重试！" << endl;
            return;
        }
        print_grade(search_className(name));
    case 2:

        for (int i = 0; i < class_number; i++)
        {
            if (grade_premisson(i))
            {
                cout << data[i].class_name << "班: " << endl;
                print_grade(i);
            }
        }
        break;
    default:
        cout << "您输入的选项有误，请重试！" << endl;
    }
}
/*
函数名称：添加班级
函数类型：私有函数
函数参数：班级名称
函数功能：添加班级
函数原理：
        1.逻辑判断系统空间是否足够即 class_number<MAXSIZE
        2.若空间足够则赋值且class_number++
*/
void STUDENT::add_class(string name)
{
    if (class_number + 1 < MAXSIZE)//判断存储空间是否足够
    {
        data[class_number].class_name = name;
        data[class_number].stu_total = 0;
        data[class_number].address = NULL;
        cout << "请输入 " << name << " 的课程数和课程名称：" << endl;
        cin >> data[class_number].lesson_number;
        data[class_number].stu_lesson = new string[data[class_number].lesson_number];
        for (int j = 0; j < data[class_number].lesson_number; j++)
        {
            cin >> data[class_number].stu_lesson[j];
        }
        class_number++;//班级个数加1
    }
    else
    {
        cout << "已达到最大存储空间，添加失败" << endl;
    }
}
/*
函数名称：添加班级
函数类型：共有函数
函数参数：无
函数功能：添加班级
函数原理：
          调用私有函数add_class(string name)函数
*/
void STUDENT::addClass()
{
    cout << "请输入要添加的班级的姓名:";
    string name;
    cin >> name;
    add_class(name);
    cout << "添加班级功能执行完毕！" << endl;
}
void STUDENT::searchStu()
{
    cout << "请输入要查询学生所属班级：" << endl;
    string name_class, name_stu;
    cin >> name_class;
    int loc = search_className(name_class);
    if (loc == -1)
    {
        cout << "您所输入的班级不存在，请重试!" << endl;
        return;
    }
    cout << "请输入要查询的学生名称:" << endl;
    cin >> name_stu;
    Stu_Node *p = search_stuName(name_stu, loc);
    print_stu(p);
}

void STUDENT::saveData(int mode)
{
    if (save_premisson())
    {
        cout << "保存数据会覆盖原来的数据，是否继续？(y/n)" << endl;
        char option;
        cin >> option;
        if (option == 'y')
        {
            save_data(mode);
            cout << "数据保存成功！" << endl;
        }
        else
        {
            return;
        }
    }
    else
    {
        cout << "保存失败！请检查数据是否完整！" << endl;
    }
}

源.cpp

#include"Student.h"
void mainMenu()
{
    cout << "----------------Student Administration System-------------------" << endl;
    cout << "|                                                              |" << endl;
    cout << "|       1____________增加班级                                  |" << endl;
    cout << "|       2____________添加学生信息                              |" << endl;
    cout << "|       3____________删除学生信息                              |" << endl;
    cout << "|       4____________录入学生成绩                              |" << endl;
    cout << "|       5____________更新成绩                                  |" << endl;
    cout << "|       6____________输出学生信息                              |" << endl;
    cout << "|       7____________查询学生成绩                              |" << endl;
    cout << "|       8____________查找学生                                  |" << endl;
    cout << "|       9____________保存数据                                  |" << endl;
    cout << "|       0____________返回主界面                                |" << endl;
    cout << "|                                                              |" << endl;
    cout << "----------------------------------------------------------------" << endl;
}
void welcomeMenu()
{
    cout << "----------------------欢迎使用学生信息管理系统------------------" << endl;
    cout << "|                                                              |" << endl;
    cout << "|       1____________进入系统管理界面                          |" << endl;
    cout << "|       2____________读取本地存档                              |" << endl;
    cout << "|       0____________退出                                      |" << endl;
    cout << "|                                                              |" << endl;
    cout << "----------------------------------------------------------------" << endl;
}
void continueMenu()
{
    cout << "----------------Student Administration System-------------------" << endl;
    cout << "|                                                              |" << endl;
    cout << "|       1____________输出学生信息                              |" << endl;
    cout << "|       2____________查询学生成绩                              |" << endl;
    cout << "|       3____________查找学生                                  |" << endl;
    cout << "|       0____________返回主界面                                |" << endl;
    cout << "|                                                              |" << endl;
    cout << "----------------------------------------------------------------" << endl;
}
int main()
{
    welcomeMenu();//进入欢迎界面
    int option;
    
    while (1)
    {
        cin >> option;
        if(option==1)
        {
                int number;
                system("cls");//清一下屏
                cout << "请输入要创建的班级个数:" << endl;
                cin >> number;
                STUDENT user(number);
                user.initSystem();//初始化
                int selection;
                int end_misson = 0;
                while (end_misson!=1)
                {
                    mainMenu();
                    cin >> selection;
                    switch (selection)
                    {
                    case 1:
                        user.addClass();
                        break;
                    case 2:
                        user.addStu();
                        break;
                    case 3:
                        user.deleteStu();
                        break;
                    case 4:
                        user.initGrade();
                        break;
                    case 5:
                        user.averageStu();
                        user.sortStu();
                        cout << "数据更新完毕！" << endl;
                        break;
                    case 6:
                        user.Print();
                        break;
                    case 7:
                        user.printGrade();
                        break;
                    case 8:
                        user.searchStu();
                        break;
                    case 9:
                        user.saveData(1);
                        break;
                    case 0:
                        system("cls");
                        welcomeMenu();
                        end_misson = 1;
                        break;
                    default:
                        cout << "您的输入有误，请重试！" << endl;;
                    }
                }
        }
        else if (option == 2)
        {
            int mode;
            bool flag;
            bool result = true;//读取存档结果，默认为true
            cout << "请选择读取存档的模式：1.样例演示 2.用户存档(若不存在系统会自动退出！)" << endl;
            while (1)
            {
                cin >> mode;
                if (mode == 1)
                {
                    flag = false;
                    break;
                }
                else if (mode == 2)
                {
                    flag = true;
                    break;
                }
                else
                {
                    cout << "您的输入有误！" << endl;
                }
            }
            STUDENT loc(flag,result);
            if (result)
            {
                int selection;
                system("cls");
                int end_misson = 0;
                while (end_misson != 1)
                {
                    continueMenu();
                    cin >> selection;
                    switch (selection)
                    {
                    case 1:
                        loc.Print();
                        break;
                    case 2:
                        loc.printGrade();
                        break;
                    case 3:
                        loc.searchStu();
                        break;
                    case 0:
                        system("cls");
                        welcomeMenu();
                        end_misson = 1;
                        break;
                    default:
                        cout << "您输入的有误！" << endl;
                    }
                }
            }
            else
            {
                cout << "文件损坏，读取失败！" << endl;
                welcomeMenu();
            }
        }
        else if (option == 0)
        {
            return 0;
        }
        else
        {
            cout << "您输入的有误！" << endl;
        }
    }
    
}
    

EXdataBase.txt

2
计算机1171 6 大学英语 数字逻辑设计 毛概 图论与近世代数 数据结构 线性代数
计算机1172 7 大学英语 数字逻辑设计 毛概 图论与近世代数 数据结构 线性代数 创新创业基础
7
黄梓轩 19 1 117101 98.5 95 80 75 80 84
冯煜航 19 1 117102 85   92 85  62 70 58
姜贤彬 19 0 117103 85 77 88 99 80 98 
朱歆婷 19 0 117104 89 85 84 87 85 81 
李浩鹏 19 1 117105 85   84   82   70 62  59
唐紫涵 19 0 117106 90   85   92   91  84  88
田语晨 19 0 117107 92   85   88.5 94  70 81.5
5
洪丽芳 19 0 117201 91 87 88 88 95 75 85
冯鹏旭 18 1 117202 87 76 91 74 95 84 75
黄雨彤 19 0 117203 87 76 74 88 90 84 80 
黄奕轩 19 1 117204 94   85 74  85  90 60.5 82
李彦龙 20 1 117205 94   83.5 75 84 78 89 100

userDataBase.txt

2
计算机1171 2 离散数学 线性代数 
计算机1172 3 离散数学 数据结构 线性代数 
2
小亮 19 1 117101 98 95 
小明 19 1 117102 94 85 
2
小芳 19 0 117201 91 87 88 
小蔡 18 1 117202 87 76 91