C语言课程设计：十字交叉链表实现教务信息管理系统

简介：面向高校计算机相关专业学生与C语言课程设计指导教师，这份教务信息管理系统实验报告以辅导员管理年级成绩表为业务原型，完整呈现从需求分析到程序实现的课程设计过程。压缩包内仅含1个doc文档，约361KB，将实验报告正文、程序流程图与源代码清单整合在同一文件中，便于对照阅读代码结构与设计思路。内容以十字交叉链表组织班级、学生、课程与成绩四层数据，讲解结构体字段定义、链表创建与级联关系，并说明模块化编译、中文图形菜单、文件存取与模拟打印等实现要点，同时保留成绩不及格重修录入等业务细节。已有1120人学习，适合需要完成同类课程设计、参考数据结构选型与报告写法的读者，可据此梳理功能模块、理解多级链表操作并完善自己的设计文档与代码实现。

1. 从一张辅导员成绩表说起：这套教务信息管理系统到底管了什么

辅导员手里那张年级成绩表，一个班一行、一门课一列，期末核对靠尺子比着看，改一个学生的分数就得把班级均分、加权排名、不及格名单整个重算一遍。这份 C 语言课程设计干的就是把这张表搬进程序：某高校计算机学院课程设计题目「教务信息管理系统」，用四层十字交叉链表把班级、学生、课程、成绩串起来，图形菜单驱动，新建、插入、删除、修改、排序、查找全都有，还能统计班级均分、学生加权排名和不及格名单，结果落到 txt 报表里直接打印。

代码是 TC 时代的纯 C，八个源文件配一个.prj工程模块化编译，数据结构全部手写，没有使用任何第三方库。刚学完指针和结构体、想把链表练到形成本能反应的人，拿它当第一个完整项目很合适；想研究「不靠数据库怎么管层次数据」的人，它的四链设计和四文件落盘方案也值得完整拆一遍。

2. 数据结构拆解：四重十字交叉链表如何把班级、学生、课程、成绩串成一张网

这套系统最值得看的部分不是菜单，而是它怎么用四个结构体表达「一个年级有三个班、每个班有若干学生、每个学生修同样的几门课、每门课有多次考试记录」这种四层包含关系。原作者选的是多重链表，也就是常说的十字交叉链表：每一层结点里既存本层数据，又存下一层的头指针，还存一个指回上层的从属编码。听起来绕，落到代码上其实很直白。

2.1 四个结构体的字段设计与定长数组的取舍

先把四个结构体摆出来看。字段名沿用原始代码，长度一个都没改，因为这些长度决定了后面文件怎么存、怎么读。

/* 成绩结点：一条考试记录，一个学生的一门课可以挂多条（重修会往上加） */ typedef struct scores { char fall3[4]; /* 从属关系：fall3[0]=班号 fall3[1]=学生序号 fall3[2]=课程序号 */ char number[2]; /* 第几次考试，"1" 是初修，"2" 起是重修 */ char exam_score[4]; /* 卷面成绩，字符串存，最多三位 */ char usual_score[4]; /* 平时成绩 */ char coll_score[4]; /* 综合成绩，由平时和卷面按权重算出来 */ char date[11]; /* 考试时间或学期，如 "2005-2006" */ struct scores *next4; /* 同一门课下的下一条考试记录 */ } SCORE; /* 课程结点：一门课，挂一条成绩链 */ typedef struct subjects { char fall2[3]; /* fall2[0]=班号 fall2[1]=学生序号 */ char course_no[11]; /* 课程编号 */ char course_name[17]; /* 课程名称 */ char credit[4]; /* 学分，如 "2.5" */ struct subjects *next3; SCORE *chead; /* 分数链表的头指针 */ } SUBJECT; /* 学生结点：一个学生，挂一条课程链 */ typedef struct students { char fall1[2]; /* fall1[0]=所属班号 */ char student_no[13]; /* 学号，实际可用 12 位 */ char name[17]; char sex[2]; /* "0" 男，"1" 女 */ char age[3]; char phone[12]; /* 寝室电话 */ char com_phone[12]; /* 手机，填 "0" 表示没有 */ char jia_quan[7]; /* 加权分，如 "78.35" */ char all_credit[4]; /* 已得总学分 */ struct students *next2; SUBJECT *suhead; /* 课程链表的头指针 */ } STUDENT; /* 班级结点：一个班，挂一条学生链，是整个十字链表的入口 */ typedef struct classes { char class_no[5]; /* 班号，如 "0510" */ struct classes *next1; STUDENT *sthead; /* 学生链表的头指针 */ } CLASS;

先看字段类型：所有数值都用char数组存，学号、成绩、学分、加权分一个不例外。这不是偷懒，是那个年代的一种通用做法——TC 里没有strdup，定长数组的内存布局完全可预测，fgets读进来、strcmp比一下、fprintf写出去，中间不需要任何类型转换，落盘也不会出现浮点数精度丢失导致的乱码。代价是每个字段的可用长度比声明少一位（要给'\0'留位置），学号声明 13 位实际只能存 12 位，这一条在后面读文件那章还会再提。

再来是「已经算好的冗余字段」。学生的jia_quan（加权分）和all_credit（已得总学分）本来可以从课程链和成绩链实时算出来，但代码选择在学生结点里各留一个字段存结果。好处是排序和打印时不必每次遍历子树重算，坏处是任何一次成绩修改都必须回头更新这两个值，漏掉就会出现「改了分数但排名没变」这类情况。这正是典型的教学项目取舍：用一致性换性能，靠人工纪律保证。二次开发时把这两个字段改成函数实时计算，是第一个该动的地方。

提示：如果你把这套结构体复制到 64 位 GCC 上编译，指针会从 2 字节变 8 字节，sizeof(CLASS)会变化。代码本身没问题，但如果哪天真按sizeof做二进制落盘，换平台就会读串。

2.2 从属关系编码：fall1、fall2、fall3 是怎么当外键用的

四层链表的物理连接靠sthead、suhead、chead三个头指针，逻辑上的归属关系靠fall1、fall2、fall3三个编码数组。这套编码就是没有数据库时代的复合外键，思路是把「我属于谁」压进一个短字符串里。

fall3[4]是最完整的一条，三个字符分别指向班号、学生序号、课程序号。举个具体的：fall3 = "0" "1" "0"，表示这条成绩属于 0 号班、1 号学生、0 号课程。fall2[3]少一层，只有班号和学生序号，因为课程结点本身就挂在这个学生下面，它只需要说清自己属于哪个班的哪个学生。fall1[2]只记班号，学生的父级只有班级。

为什么不用指针直接回指父结点？因为指针回指会让释放逻辑变得很难写：删一个班，得先判断有多少学生指针指回来，容易形成循环引用，一free就野指针。用字符编码虽然要多存几个字节、改班号时要级联更新，但释放时只顺着next和head一条路走，绝不会漏。这是「结构简单优先」的典型选择，教课设的老师一般也认这个思路。

这里有个隐性约定：fall3[1]存的是学生在班内的序号，不是学号。序号从 0 开始按插入顺序递增。所以如果你在中间删掉一个学生，后面学生的序号不会重排，新插入的学生会拿新的序号，序号就成了一个只增不减的内部 ID。这个设计当时够用，但做二次开发时如果要做「按学号重新编序」的功能，就得遍历整棵树重写所有fall编码，工作量不小。

2.3 建链顺序与「00」回退约定

创建链表的过程是严格自外向内的：先建班级链，在每个班级里建学生链，在每个学生里建课程链，在每门课程里建成绩链。返回上一层的方式很朴素——输入"00"。这套约定比任何菜单都重要，用户必须记住它，否则会陷入「想退出却退不出来」的尴尬。

/* 建班级链：输入 "00" 表示整棵链表录入结束 */ CLASS *build_classes(void) { CLASS *head = NULL, *tail = NULL, *c; char buf[32]; while (1) { printf("请输入班号（输入 00 结束录入）："); gets(buf); /* TC 时代标准写法，换成 fgets 只是安全习惯 */ if (strcmp(buf, "00") == 0) break; if (strlen(buf) == 0 || strlen(buf) >= sizeof(c->class_no)) { printf("班号长度必须为 1-4 位，请重输\n"); continue; /* 长度校验必须卡死，否则后面定长落盘会串位 */ } c = (CLASS *)malloc(sizeof(CLASS)); if (c == NULL) { printf("内存不足\n"); return head; } memset(c, 0, sizeof(CLASS)); /* 定长字段先清零，避免尾部垃圾字符写进文件 */ strcpy(c->class_no, buf); c->next1 = NULL; c->sthead = build_students(c); /* 递归进入下一层 */ if (head == NULL) head = c; else tail->next1 = c; tail = c; } return head; }

这段代码做了三件事：读一个班号、校验长度、malloc一个结点并挂到链尾，然后递归调build_students进入学生层。memset那一行很关键，因为malloc出来的内存是脏的，如果不清零，后面fprintf写字符串时会顺着'\0'找不到边界，一路写到相邻字段里去，文件里就出现一长串乱码。很多人在调试时抱怨「保存出来的文件后面带一堆方块」，多数就是这个位置漏了清零。

递归进入下一层后，学生层的退出条件是输入"00"，返回班级层；课程层同理，返回学生层。整条链路是「输入 00 就退一层」，只有最外层退出才是真的结束录入。原文的示例数据里，三个班、七个学生、每门课一到两次考试记录，全部靠这个约定一次录完。理解了这个回退规则，后面看插入、删除功能的模块划分就顺畅多了——它们本质上是同一套build逻辑的局部版本，只是把「新建整条链」换成了「挂到已有链的某个位置」。

3. 工程组织：八个 .c 文件加一个 .prj，在 TC 里把上千行拆开编译

单文件写到两千行左右就开始出问题，这是那代 C 编译器的硬限制。原作者在原文里写得很实在：TC2.0 编到两千行就不行，换 Win-TC 撑到四千行，再换 TC3.0 撑到五千行，最后是同学教他用模块化才真正解决。这一节就把这套工程组织方式拆开，因为它是这个项目里除数据结构之外，最有迁移价值的部分。

3.1 模块划分：八个源文件各管什么

拆分的逻辑按功能域走，而不是按数据结构走。文件清单大概是这样：

这套划分的关键在in_out.c。所有字段输入都走同一个函数，长度校验、去空格、非法字符过滤只写一遍，其他模块调用它就行，不用每个功能都复制一份gets。这是当时少见的工程意识——一个课程设计做到这一步，说明作者已经吃过「同一个 bug 在六个地方各修一遍」的苦。

模块之间共享数据的方式是一个全局头指针，声明在某个公共头文件里，其他.c用extern引入：

/* common.h —— 所有模块共享的全局状态 */ #ifndef COMMON_H #define COMMON_H #include "structs.h" extern CLASS *g_class_head; /* 十字交叉链表的唯一入口 */ extern char g_file_name[64]; /* 当前打开/保存的文件名，不含后缀 */ extern int g_dirty; /* 脏标记：有未保存修改时为 1 */ void save_all(const char *name, CLASS *head); #endif

g_dirty这个标记是整套「退出前提示保存」功能的基础。新建、插入、删除、修改、排序，任何一个操作成功后把它置 1；保存成功后清 0。程序退出时只看这个标记，不用去比对内存和文件的差异——那种做法在千级结点上很慢，在 TC 里更是不能接受。这个思路很朴素，但能省掉大量提示逻辑。

全局变量在今天的工程规范里是要被批评的，但对这个规模的项目来说是合理选择：四层链表的入口只有一个，传参传十几层反而更容易出错。真正的问题在于缺少「谁改了这个链表」的约束，任何模块都能直接改g_class_head，调试时很难定位是哪个操作弄坏的。二次开发时至少可以给它套一层访问函数，把修改集中起来。

3.2 .prj 工程文件与 Ctrl+F9 构建

TC 的工程文件其实就是一个纯文本，一行一个源文件名，后缀必须是.prj。内容像这样：

main2.c in_out.c files.c edit.c search.c tongji.c da_yin.c help.c qita.c

把它存成jiaowu.prj，在 TC 的 Project 菜单里打开它，之后按Ctrl+F9就会先编译再链接，产出jiaowu.exe。看起来简单，但有几个选项必须设对，否则前面所有模块化的工作都会白费。

第一是内存模型。TC 默认 Small 模式，代码段和数据段各 64KB，几个班几十个学生就把数据段撑爆了。要在 Options → Compiler → Code generation 里把 Model 改成 Large，这样数据指针变成 far 指针，能寻址到 1MB。原文里作者说「去掉几个耗内存的语句就好了」，本质上就是在 Small 模式下勉强腾空间，治标不治本。

第二是 Output 目录。Options → Directories 里如果 Output 指向内存虚拟盘，超过一定大小就会链接失败，必须改成磁盘目录。这也是很多人「明明代码没错却生成不了 exe」的真实原因。

第三是graphics.h的链接。图形模式用initgraph时要指定 BGI 驱动路径，TC 一般装在C:\TC\BGI，在代码里写成initgraph(&gd, &gm, "C:\\TC\\BGI")。路径写死这件事在移植时是灾难，但当时就是这套规矩。

注意：大型工程按Ctrl+F9之前，先按Alt+F9单独编译当前文件，能更快定位是哪个模块报错。全量构建一次几十秒，在 DOS 里等起来很折磨。

3.3 图形界面下的菜单循环与键盘扫描码

界面这块用的不是普通printf，是 TC 自带的 BGI 图形库画出来的中文字和方框。主循环的逻辑说出来很普通：画菜单、读一个键、根据键值改当前选中项或者执行功能。

#include <stdio.h> #include <conio.h> #include <graphics.h> #include "common.h" #define MENU_N 7 /* 文件 / 编辑 / 打印 / 统计 / 查找 / 帮助 / 退出 */ static int cur = 0; int main(void) { int gd = DETECT, gm; unsigned key; initgraph(&gd, &gm, "C:\\TC\\BGI"); /* 进入图形模式 */ draw_welcome(); /* 动态登录界面 */ getch(); /* 任意键进入主界面 */ for (;;) { draw_menu(&cur); /* 重绘菜单，高亮当前项 */ key = bioskey(0); /* 阻塞读键，返回 16 位扫描码 */ switch (key) { case 0x4800: cur = (cur + MENU_N - 1) % MENU_N; break; /* 上方向键 */ case 0x5000: cur = (cur + 1) % MENU_N; break; /* 下方向键 */ case 0x0D00: do_menu(cur); break; /* 回车进入子菜单 */ case 0x1B00: closegraph(); return 0; /* Esc 退出 */ default: do_hotkey(key); break; /* 快捷键直达 */ } } }

bioskey(0)是这段代码的核心。它返回一个 16 位整数：低 8 位是 ASCII 码，高 8 位是扫描码。方向键没有 ASCII 码，低 8 位全是 0，所以上键整体是0x4800，下键是0x5000，回车是0x0D00，Esc 是0x1B00。这就是为什么判断方向键要用switch比十六位数，而普通字母键直接比低字节就行。

还有一处容易忽略：do_hotkey处理的是「按快捷键直达功能」的场景。原文里明确说「可以用给出的快捷键来操作」，实现方式就是在每个菜单项旁边画一个字母，用户在do_hotkey里按键匹配后直接跳到对应功能，不用先上下移动到那一项。这个交互在当时算比较贴心，代价是需要维护一张「按键到功能编号」的映射表，和菜单项的绘制顺序必须一致，改菜单时容易忘。

至于 Esc 返回上层菜单而不是退出程序，实现方式是每个子菜单函数自己也持有一个cur，进入子菜单后主循环换了一套判断逻辑，Esc 时返回主循环。这套「主菜单 + 子菜单」的嵌套状态如果只用一个cur变量，会很混乱；实际代码里是给每层各留一个静态游标，靠调用栈自动恢复。这也解释了为什么原文描述操作时会说「进入子选项后按上下键选择，按左右键进入其他主菜单的子选项，Esc 返回上层」——三个方向键分别对应三种状态切换，逻辑都在这几个循环里。

4. 数据落地：一个文件名派生四个 txt，定长字符串存盘的取舍

链表建在内存里，关掉程序就没了。这套系统的持久化方案很土但很有效：一个用户输入的文件名，派生出四个.txt文件，分别存四层链表。没用数据库，没用二进制序列化，纯文本，人眼可读。

4.1 保存：一个文件名派生四个文件

用户输入e:\abc，程序生成abc1.txt到abc4.txt，分别对应班级、学生、课程、成绩四个链表。用户只需要记一个名字，打开时同样只输一个名字，程序按同一套规则还原四个路径。这个设计在用户体验上是加分的——不用记四个文件名，也不容易漏保存某一层。

/* name 形如 "e:\\abc"，不含后缀；head 是班级链入口 */ int save_all(const char *name, CLASS *head) { char path[80]; FILE *fp; CLASS *c; STUDENT *s; SUBJECT *sub; SCORE *sc; /* 第一份：班级链，一行一条 */ sprintf(path, "%s1.txt", name); fp = fopen(path, "w"); if (fp == NULL) return -1; /* 路径非法或磁盘满，直接返回错误码 */ for (c = head; c != NULL; c = c->next1) fprintf(fp, "%s\n", c->class_no); fclose(fp); /* 第二份：学生链，字段用逗号分隔，顺序必须和读入时完全一致 */ sprintf(path, "%s2.txt", name); fp = fopen(path, "w"); if (fp == NULL) return -1; for (c = head; c != NULL; c = c->next1) for (s = c->sthead; s != NULL; s = s->next2) fprintf(fp, "%s,%s,%s,%s,%s,%s,%s,%s,%s\n", s->fall1, s->student_no, s->name, s->sex, s->age, s->phone, s->com_phone, s->jia_quan, s->all_credit); fclose(fp); /* 第三、四份结构相同：课程链存编号、名称、学分；成绩链存次数、分数、日期 */ /* ... 省略，逻辑同上 ... */ return 0; }

这段代码有几个必须讲清的点。sprintf(path, "%s1.txt", name)直接把用户输入拼上后缀，如果用户输入带反斜杠的路径，Windows 下要写成e:\\abc，少写一个斜杠就会变成转义字符。fopen返回NULL时立刻return -1，调用方据此弹出「文件打不开」的提示——这是原文里提到的错误处理，实际就是靠返回值传递。文件里每行一条记录，字段用逗号分隔，靠固定顺序对齐位置，读的时候按同样顺序fgets加切分即可。

为什么用四个文件而不是一个？因为四层数据的结构完全不同。硬塞进一个文件得加类型标记、得处理嵌套缩进，解析代码会翻倍。分开存虽然丧失了「整体一致性」，但每一层的读写逻辑都退化成最简单的循环，调试时打开文件就能看清某一层的数据对不对，这对课程设计来说价值更高。

4.2 定长字符串落盘：可读、可手改、无乱码

原文里有一句特别值得注意的话：保存的信息全部是字符串，包括浮点小数也被转成字符串，所以文件里可以清楚看见各个数据，没有乱码，可以直接在文件里改数据，只要注意长度不要改变。

这句话点出了整套持久化的核心约束——定长字段加定长解析。因为所有字段都是固定长度的char数组，读文件时按固定偏移切分就能还原结构，不需要处理不定长的分隔问题。好处是文件永远可读、可用记事本打开核对、可以手工修正一个错误分数。坏处是修改时必须严格守住长度：原本student_no12 位，你手改成 13 位，后面的字段整体右移，读回来就全串了，表现为「打开文件后姓名变成一串数字，性别变成年龄」。

这种设计在今天看来很危险，但在课设场景里反而合理：数据量小、单人使用、错误有明确反馈（打开后立刻能看出串行），调试成本低。对比一下更现代的做法，就是每行用\t或|分隔，读的时候按分隔符strtok，长度随便改。这套系统也可以这么改，工作量大概就是把四个保存函数和四个读取函数里的fprintf格式串换一下，再加一个字段数校验。

提示：如果你在二次开发中把字段长度放宽，务必同步修改结构体声明和输入校验里的strlen限制。两处不对称是最常见的隐藏 bug，编译期查不出来，运行到保存时才炸。

4.3 模拟打印：屏幕预览加一份可打印的 txt

原文说得很坦诚：没有打印机，不好调试，所以只写了模拟打印。实现方式是遍历整棵十字链表，把每一条记录格式化成一行表格，同时输出到屏幕和一个固定路径的文件（原文里写的是e:\student.txt），文件可以直接拿去打印。

这个功能的技术含量不高，但它把「展示」和「存储」两件事分开了。屏幕输出用于快速核对，文件输出用于留档，两者共用同一套格式化函数，保证看到的内容和打印出来的内容一致。格式化用的是printf的宽度修饰符，比如%-14s表示左对齐占 14 列，中文在 TC 的图形模式下按双字节渲染，宽度计算要按字节数算——这是当时调中文对齐最费劲的地方，一个中文字符占两个字节但显示宽度也是两列，勉强能对上，稍微换个字号就全歪。

打印函数还有一个隐含约束：它会打印整棵链表，包括那些没有成绩的课程、没有课程的学生。实现上就是三层嵌套for循环，外层班级、中层学生、内层课程再内层成绩。这种「全量导出」在数据量小时没问题，数据一多就会滚屏很久。二次开发时更合理的方式是按当前选中的班级或学生做过滤，加一个参数控制范围即可，改动量很小。

5. 常见问题排查：内存超限、编译器版本与链表野指针的五条踩坑记录

这一章的内容全部来自原文里那段很长的体会，加上这套代码结构本身容易出问题的位置。原作者写「一个错误可以调好几天都不知道在哪」，这些坑大部分都集中在这里。

5.1 编译与内存：三条环境相关的坑

现象一：程序编译通过，运行到录入第七八个学生时直接黑屏退出，没有任何错误信息。

原因基本可以确定：TC 默认 Small 内存模型，数据段只有 64KB。四层链表每个结点都带定长数组，一个学生结点加上挂着的课程和成绩，轻松上百字节，几十个学生就顶到上限。原文作者遇到这个问题时是「去掉几个耗内存的语句」临时解决，但那只够撑一会儿。正确做法是在 Options → Compiler → Code generation 里把 Model 改成 Large，让数据指针变成 far 指针，可用内存扩到 1MB 级别。另一个隐性内存占用来源是全屏图形缓冲区，BGI 模式下initgraph会吃掉一块，跑大数组前先确认剩余空间。

现象二：代码写到四千行，编译器开始报奇怪的内部错误，或者链接阶段直接失败。

这不是代码写错了，是编译器本身的天花板。TC2.0 对单个工程的符号表和代码段都有限制，超了就报一些看不懂的错误。原文作者的处理路径是 TC2.0 换 Win-TC，再换 TC3.0，最后一个同学提醒他模块化才彻底解决。这条经验今天依然成立：当编译器开始报内部错误而不是语法错误时，先怀疑工具链限制，不要继续在代码里找 bug。模块化拆文件既能绕开单文件行数限制，也能让每次只重编改动的那一个文件，迭代速度提升非常明显。

现象三：调用了教科书上抄来的函数，程序行为诡异，调了好几天都找不到原因。

原文作者遇到过一模一样的场景：以为书上给的函数肯定没问题，于是排查时一直跳过它，最后单独调试才发现是这个函数在当前编译器下不稳定。这是一个必须写下来的教训——第三方代码、教材代码、别人给的片段，都得先在最小用例里单独跑通，再合进主工程。合进去之后如果出问题，第一件事就是把可疑函数单独提出来验证，而不是在主流程里来回加打印。

5.2 链表与文件：两条数据层面的坑

现象四：删除一个学生之后，打印整表时程序崩溃，或者打印出上一秒已经删掉的数据。

原因是删除时只free了学生结点本身，没处理两件事：一是该学生下面挂着的课程链和成绩链，这些结点全部泄漏，指针还留在已释放的内存里；二是前驱结点的next2没更新，或者删除的是链头时sthead没改成next2。正确的删除顺序是先从班级的sthead里摘链（处理头结点和前驱两种情况），再递归释放suhead下的所有SUBJECT及其chead下的所有SCORE，最后free学生本体。顺序颠倒就会读到脏内存，表现为打印时出现乱码或者直接退出。

现象五：手工改过保存出来的 txt 文件，再打开程序时数据整体错位，姓名变成数字、性别变成年龄。

这是第 4 章提到的定长解析在起作用。程序按固定偏移和固定长度读取字段，你改内容没关系，改长度就全乱。解决办法只有两个：要么严格只改内容不改长度，要么把读取逻辑改成按分隔符切分并校验字段数量，后者是二次开发的推荐方向。还有一种更隐蔽的情况：在文件里加了空行或者行尾多了空格，fgets读进来之后字符串末尾带\n，strcmp比较班号时永远不相等，表现为「文件明明有数据，查班级却提示找不到」。读取后统一去掉尾部空白就能解决。

6. 二次开发：把这套链表代码搬到现代编译环境的三步改造

这套代码要真正拿来用作原型，第一步是让它能在 GCC 或 Clang 下编译跑通，第二步才是加功能。改造可以按依赖顺序分三步走，每一步都能单独验证。

第一步做接口替换，工作量最小也最容易验证。把bioskey换成getchar读方向键转义序列，把initgraph那一套整个拿掉，菜单用printf画出来，功能逻辑一行不用改。

/* 跨平台的读一个字符，替代 bioskey(0) 的阻塞语义 */ static int read_key(void) { int c = getchar(); if (c == '\n' || c == '\r') return KEY_ENTER; if (c == 27) { /* Esc：可能是方向键的转义前缀 */ int c2 = getchar(); if (c2 == '[') { int c3 = getchar(); if (c3 == 'A') return KEY_UP; /* 上 */ if (c3 == 'B') return KEY_DOWN; /* 下 */ } return KEY_ESC; } return c; }

这个替换把「图形模式下的扫描码」翻译成「终端里的转义序列」，是两个键盘模型的桥梁。方向键在终端里发的是ESC [ A三个字节，所以要先读ESC再判断后面跟的是不是[，避免把真正的 Esc 当成方向键。替换完成后，整套菜单循环和功能分发逻辑完全不用改，因为read_key返回的意图枚举和原来的switch分支是一一对应的。

第二步是输入层加固。原来所有gets调用换成fgets(buf, sizeof(buf), stdin)，然后写一个去尾函数统一处理。字段长度校验也要从「只在建链时校验」扩展到「所有入口都校验」，因为插入和修改功能也会写字段。这一步做完，原来那类「长度超了导致文件串行」的坑基本就绝迹了。

第三步是把存储换掉。save_all和open_all是两个天然的分界点，把里面的fprintf/fscanf换成 SQLite 的INSERT/SELECT，上层业务逻辑完全不用动。四张表的结构就是四个结构体，fall那几个编码字段变成外键 ID，jia_quan改成视图里实时计算。想验证改造是否成功，用原文给的那套样例数据当回归用例：三个班、七个学生、两门课，跑一遍新建、保存、重开、统计班级均分，比对学生加权分排名是否和手工算的一致。这套用例覆盖了建链、落盘、读取、统计四条主路径，任何一条改坏了都能立刻发现。

我自己的习惯是每次动这类老代码之前，先把原始版本完整跑一遍并录下关键输出，改完之后逐项对比，而不是只看程序有没有崩。从那以后我每次接手续航项目，都强制走一遍「跑通原版、留存基线输出、再动第一行代码」的流程，省下来的返工时间远比这一遍多。希望帮到你。

本文还有配套的精品资源，点击获取