C语言课程设计实战：教师信息管理系统的链表与文件操作全解析

1. 先看清题：教师信息管理系统到底在练什么

教师信息管理系统，C语言课程设计里最经典的题目，没有之一。我帮不少人审过这个项目的代码，发现一个普遍现象：代码能跑出正确结果，但追问三个问题就露馅——为什么这样定义结构体？链表和数组到底该选哪个？文件里的数据为什么莫名其妙就丢了？这恰恰说明，很多人只是把代码"抄"明白了，却没有真正理解这个项目在练什么。这篇文章我会把这个项目的完整设计思路、源码实现和实操坑点全部摊开讲，不管你是正在准备课设答辩的学生，还是想通过一个完整项目巩固C语言指针、链表、文件操作的老手，读完都会有自己的收获。

1.1 表面是管理系统，实际考的是C语言三大件

先泼一盆冷水：这个系统本身没有任何业务难点，"教师信息管理"换成"图书管理""学生管理""员工管理"，本质完全一样。它之所以能成为经典课设，是因为恰到好处地把C语言最核心的几个知识点串了起来。

第一是结构体。教师信息包含工号、姓名、性别、年龄、职称、院系、电话，字段类型各不相同，struct的作用就是把这些不同类型的数据打包成一个整体。你写Teacher t; t.id = 1001;的时候，其实就是在做"数据组织"这件事。

第二是指针与动态内存分配。录入的人数在程序启动前无法确定，开数组大了浪费，开小了不够用，所以要用malloc按需分配，用完了再free归还。这一步直接考察你对堆内存的理解，很多人栽在"忘了释放"和"释放了还继续用"这两个问题上。

第三是单链表操作。增、删、改、查全部建立在对链表的遍历和指针修改之上。你可以用数组实现，但链表才是能体现"数据结构思维"的解法，也是答辩时老师最想听你讲的点。

第四才是文件读写。程序关掉再打开，数据不能丢，所以要把内存里的链表持久化到文件。这里用fprintf/fscanf还是fwrite/fread，背后是有讲究的，后面我会细说。

打个比方：结构体是一张员工信息登记卡，链表是一摞用回形针串起来的登记卡，文件操作则是把这摞卡复印一份放到抽屉里。系统要做的，就是管理这摞卡片——往里面加、拿出来看、找某人、抽出某张、改几栏内容、放回抽屉。

1.2 需求清单：一个标准方案该有哪些功能

不管题目描述怎么变，一个能拿出手的教师信息管理系统，功能基本逃不出下面这张表：

别小看这个清单，每一行都是一个考点。有些同学的代码只做了前5项，保存读取都没有，这看起来是"功能不全"，本质上是"文件操作没学好"，答辩时很容易被问到墙角。

1.3 为什么选C语言而不是"更合适"的语言

现在随便一个管理界面都能用图形化拖出来，为什么课程设计还要用C？我个人的理解是：这个题目根本不是为了"做出一个能用的管理系统"，而是为了逼你把计算机最底层的数据组织方式想清楚。

用高级语言写增删改查，你只需要调用库函数，底层是哈希表还是红黑树，你根本不用关心。但C语言没有这些现成的东西，你必须自己设计结构体、自己管理内存、自己写链表。这个过程难受，但天花板也高——把这一套搞懂，以后学数据结构、操作系统、嵌入式开发，都会顺畅很多。

所以接下来我讲的方案，都是基于"用C的标准库，不依赖任何第三方库"的前提，这也是纯C课设最稳妥的路线。

2. 数据怎么组织：结构体、链表与文件格式的设计

2.1 结构体字段怎么定

定义一个结构体是这个系统的第一步，也是最重要的一步。字段定得不合理，后面所有代码都要跟着返工。我建议按下面这个方案来：

#include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_NAME 30 #define MAX_DEPT 50 #define MAX_PHONE 20 typedef struct Teacher { int id; // 工号，唯一标识 char name[MAX_NAME]; // 姓名 char gender[4]; // 性别：男 / 女 int age; // 年龄 char title[20]; // 职称：助教/讲师/副教授/教授 char dept[MAX_DEPT]; // 所属院系 char phone[MAX_PHONE]; // 联系电话 struct Teacher *next; // 指向下一个节点的指针 } Teacher;

几个字段选择的细节，我说说自己的考虑。

工号用int，因为它是数字、唯一、适合做精确匹配，排序也方便。姓名用char数组，不能用单个char指针——你马上要scanf往里写，必须有一块真实存在的内存。性别用char[4]，很多人写成char gender然后存m/f，也不是不行，但直接存中文"男/女"在显示时更直观，长度3字节加一个'\0'，给4就够。

职称为什么不直接用字符串比较？因为统计的时候要按"教授""副教授""讲师""助教"分类，用一个统一命名的字段，后面写strcmp判断会很舒服。电话必须用字符串，千万别用int或者long——座机号、手机号可能以0开头，数字类型会把前导0丢掉，存成字符串才是最稳的。

最重要的一点：char数组的长度要留够余量。中文字符在GBK编码下占2字节，在UTF-8下占3字节，一个"名"字就可能占3个字节，所以name[20]其实只够存6个左右的中文字。课设场景下姓名一般不会太长，但长度至少给到30，稳妥不堵心。

2.2 数组还是链表：这道选择题别凭感觉做

很多初学者上手就想用数组，因为teacher[100]开一个结构体数组，用下标访问特别直观。但数组和链表在这个场景下的差距，远不止"好不好写"这么简单。

我的结论很直接：课设就选链表，除非题目硬性要求数组。理由有三个。

第一，链表能自然应对"人数不确定"的场景。用数组，你总得猜一个上限，比如100，万一要录101个人就得改代码重编译；链表不存在这个问题，录多少分配多少。

第二，插入和删除是链表的主场。数组每删一个中间元素，后面所有元素都要移动，代码复杂还容易出边界错误；链表只改两条指针，代码简洁得多。

第三，也是最重要的，链表是课程设计要考察的核心能力。你用数组实现，相当于主动放弃了这个展示机会。答辩时老师说"你为什么不用链表"，你只能说"数组简单"，这个回应基本等于送分。

当然，数组也不是一无是处。如果题目数据量固定、只做查询不改动，数组的随机访问优势就很明显。所以选型一定要围绕题目要求来——这也是答辩时"设计思路"这个分数所考察的东西。

2.3 文件存储：文本文件比二进制文件更适合课设

文件读写有两种主流的实现方式：文本方式和二进制方式。我个人的建议是：用文本文件，别碰二进制。

二进制方式的代码看起来短，用fwrite(&node, sizeof(Teacher), 1, fp)一条语句就能把一个节点写进文件，但这里藏着一个巨大的坑：结构体里有next指针。你直接fwrite整个结构体，写进去的不是数据，而是内存地址。下次程序运行时，这个地址指向的可能是完全无关的内存，读回来就是一堆垃圾数据，甚至直接段错误。

文本方式虽然代码长一点，但fprintf按字段逐个写入，每个字段都是可读的字符串，文件里存什么看得一清二楚，调试的时候打开文本文件就能判断逻辑对不对。推荐格式是这样：

1001 张三 男 35 副教授 计算机学院 13800000001 1002 李四 女 29 讲师 数学学院 13800000002

一行一条记录，字段之间用空格分隔。这里有个隐藏约束：所有字符串字段里不能有空格。比如"计算机学院"中间如果有空格，fscanf("%s")会把它拆成两个字段，导致读取出错。字段名尽量用不带空格的固定叫法，这是文本存储方案里最容易踩的坑。

3. 核心功能模块实现：源码级拆解

3.1 菜单与主循环：程序的入口设计

管理系统的交互方式很简单，一个数字菜单反复循环，直到用户输入0退出。主循环用do...while最合适，因为菜单至少要显示一次。先看菜单函数：

void showMenu() { printf("\n====== 教师信息管理系统 ======\n"); printf(" 1. 录入教师信息\n"); printf(" 2. 显示所有教师\n"); printf(" 3. 按姓名查找\n"); printf(" 4. 按工号查找\n"); printf(" 5. 修改教师信息\n"); printf(" 6. 删除教师信息\n"); printf(" 7. 按工号排序\n"); printf(" 8. 保存到文件\n"); printf(" 9. 从文件读取\n"); printf(" 0. 退出系统\n"); printf("===============================\n"); }

主函数的结构是do...while加switch：

int main() { Teacher *head = NULL; int choice; char buf[32]; do { showMenu(); printf("请选择: "); fgets(buf, sizeof(buf), stdin); // 用fgets读整行 sscanf(buf, "%d", &choice); // 再解析出整数 switch (choice) { case 1: head = addTeacher(head); break; case 2: displayAll(head); break; case 3: /* 按姓名查找 */ break; case 4: /* 按工号查找 */ break; case 5: /* 修改 */ break; case 6: /* 删除 */ break; case 7: /* 排序 */ break; case 8: saveToFile(head); break; case 9: head = loadFromFile(head); break; case 0: freeList(head); printf("已释放内存，程序退出\n"); break; default: printf("输入无效，请重新选择\n"); } } while (choice != 0); return 0; }

这里有一个很多教材都没强调的细节：为什么用fgets加sscanf，而不是直接scanf("%d", &choice)？因为scanf输入整数后，回车键产生的'\n'会残留在缓冲区，下一次如果遇到逐个字符的输入，就会跳过或者直接读到空字符串。用fgets先把整行读走，再用sscanf解析，缓冲区永远是干净的，这也是我推荐所有菜单类输入都用这个组合的原因。

3.2 信息录入：malloc与尾插法

录入模块负责创建新节点并挂到链表尾部。不带头节点的单链表，头指针为NULL时链表为空，这是最基础的写法：

Teacher *addTeacher(Teacher *head) { Teacher *p = (Teacher *)malloc(sizeof(Teacher)); if (p == NULL) { printf("内存分配失败！\n"); return head; } printf("请输入工号: "); scanf("%d", &p->id); printf("请输入姓名: "); scanf("%s", p->name); printf("请输入性别(男/女): "); scanf("%s", p->gender); printf("请输入年龄: "); scanf("%d", &p->age); printf("请输入职称: "); scanf("%s", p->title); printf("请输入所属院系: "); scanf("%s", p->dept); printf("请输入联系电话: "); scanf("%s", p->phone); p->next = NULL; if (head == NULL) { return p; } Teacher *q = head; while (q->next != NULL) { q = q->next; } q->next = p; return head; }

这段代码里有三个必须注意的点。

第一，malloc之后一定要判空。内存分配失败时返回NULL，如果你不做检查直接往下写，就是对空指针解引用，程序直接崩溃。这是C语言内存操作的第一纪律。

第二，新节点的next必须置空。不初始化的话，next里面是个随机的垃圾地址，遍历时while (q->next != NULL)根本停不下来，程序会一直越界访问直到段错误。

第三，尾插法要理解为什么必须"从头走到尾"。链表没有下标概念，想知道最后一个节点在哪，只能从head开始，沿着next一路走，找到next为NULL的那个节点。这个查找过程是O(n)，但录入本身不频繁，代价可以接受。

3.3 查找模块：strcmp与链表的遍历

按姓名查找的核心是逐节点比对，用strcmp判断字符串是否相等：

Teacher *findByName(Teacher *head, const char *name) { Teacher *p = head; while (p != NULL) { if (strcmp(p->name, name) == 0) { return p; } p = p->next; } return NULL; }

注意strcmp(p->name, name) == 0才表示相等。新手最容易写错的是if (p->name == name)，这行代码实际上是在比较两个指针的地址，不是比较字符串内容，结果永远是假。

按工号查找就更简单了，直接比较整数：

Teacher *findById(Teacher *head, int id) { Teacher *p = head; while (p != NULL) { if (p->id == id) { return p; } p = p->next; } return NULL; }

两个查找函数返回的都是Teacher *指针，找到就直接返回节点的地址，调用方拿着这个指针读字段、改字段都行，这是"指针返回"的典型用法。

3.4 修改与删除：指针操作的难点集中营

修改的逻辑很简单：先findById定位，定位成功就逐个字段更新。真正难的是删除，因为单链表删除必须同时维护"前驱节点"的指针。

Teacher *deleteById(Teacher *head, int id) { Teacher *p = head; Teacher *prev = NULL; while (p != NULL) { if (p->id == id) { if (prev == NULL) { head = p->next; // 删除的是头节点 } else { prev->next = p->next; // 跨过当前节点 } free(p); printf("工号 %d 的教师信息已删除\n", id); return head; } prev = p; p = p->next; } printf("没有找到工号为 %d 的教师\n", id); return head; }

这段代码是整个项目里最值得反复看的。删除一个节点，本质上就是让它的前驱节点"跳过"它，直接指向它的后继。这就要求你在遍历时必须记住上一个节点是谁，所以维护了一个prev指针。

还有一个极易被忽略的分支：如果删除的是头节点，那么头指针head本身必须更新为原头节点的next。这一步漏掉的话，头指针还指向一个已经被free的节点，下次遍历就是访问野指针，程序崩溃得非常随机。

删除后要记得free(p)。很多同学的代码只改了指针却忘了释放内存，短时间跑没问题，但程序长时间运行或者频繁插入删除，内存会越占越多，这就是教科书上说的"内存泄漏"。

3.5 保存与读取：持久化如何做到不丢数据

文件保存和读取是一对完整的闭环。保存时用"w"模式打开文件，注意这个模式会清空原文件内容，所以调用前最好确认用户确实想覆盖：

void saveToFile(Teacher *head) { FILE *fp = fopen("teacher.txt", "w"); if (fp == NULL) { printf("无法创建文件，保存失败\n"); return; } Teacher *p = head; while (p != NULL) { fprintf(fp, "%d %s %s %d %s %s %s\n", p->id, p->name, p->gender, p->age, p->title, p->dept, p->phone); p = p->next; } fclose(fp); printf("数据已保存到 teacher.txt\n"); }

读取时要比保存多做一个关键动作：先把当前链表整体释放掉，再重建，否则反复"读入"会导致旧数据和文件数据拼在一起，出现重复记录。

Teacher *loadFromFile(Teacher *head) { FILE *fp = fopen("teacher.txt", "r"); if (fp == NULL) { printf("找不到 teacher.txt，请先执行保存\n"); return head; } // 释放旧链表 Teacher *p = head; while (p != NULL) { Teacher *tmp = p; p = p->next; free(tmp); } head = NULL; Teacher *tail = NULL; while (1) { Teacher *node = (Teacher *)malloc(sizeof(Teacher)); if (node == NULL) break; int result = fscanf(fp, "%d %s %s %d %s %s %s", &node->id, node->name, node->gender, &node->age, node->title, node->dept, node->phone); if (result != 7) { // 没读够7个字段，说明文件结束或格式损坏 free(node); break; } node->next = NULL; if (head == NULL) { head = node; tail = node; } else { tail->next = node; tail = node; } } fclose(fp); printf("成功从 teacher.txt 读取数据\n"); return head; }

fscanf的返回值是成功匹配并赋值的参数个数。一条完整记录有7个字段，所以返回值必须是7，否则就说明到了文件末尾或者文件格式有问题。这个检查不能省，缺了它，文件里如果混入一行空行，程序就会多读出一个垃圾节点。

我见过不少人问："为什么我的文件写入成功，但重新打开程序数据没了？"大概率是两种原因：一是没调用fclose，缓冲区里的数据还没真正落盘程序就退出了；二是工作目录的问题，程序读的文件和写的文件不在同一个目录。

3.6 排序与统计：不加分的模块也要做好

排序建议用冒泡排序，因为链表版冒泡是最直观的。这里有一个大坑：不要直接交换两个节点的结构体内容，原因很简单——结构体里有next指针，整体交换会把指针也换掉，链表关系瞬间错乱。正确做法是交换除next外的所有数据字段：

void swapData(Teacher *a, Teacher *b) { Teacher tmp = *a; a->id = b->id; strcpy(a->name, b->name); strcpy(a->gender, b->gender); a->age = b->age; strcpy(a->title, b->title); strcpy(a->dept, b->dept); strcpy(a->phone, b->phone); b->id = tmp.id; strcpy(b->name, tmp.name); strcpy(b->gender, tmp.gender); b->age = tmp.age; strcpy(b->title, tmp.title); strcpy(b->dept, tmp.dept); strcpy(b->phone, tmp.phone); } void sortById(Teacher *head) { if (head == NULL) return; int swapped; Teacher *p; do { swapped = 0; p = head; while (p->next != NULL) { if (p->id > p->next->id) { swapData(p, p->next); swapped = 1; } p = p->next; } } while (swapped); }

统计模块可以按职称统计各档人数，这个功能在答辩演示时很有画面感：

void statistics(Teacher *head) { int total = 0, prof = 0, associate = 0, lecturer = 0, assistant = 0; Teacher *p = head; while (p != NULL) { total++; if (strcmp(p->title, "教授") == 0) prof++; else if (strcmp(p->title, "副教授") == 0) associate++; else if (strcmp(p->title, "讲师") == 0) lecturer++; else if (strcmp(p->title, "助教") == 0) assistant++; p = p->next; } printf("教师总人数: %d\n", total); printf("教授: %d人 副教授: %d人 讲师: %d人 助教: %d人\n", prof, associate, lecturer, assistant); }

4. 实操全流程：从空文件到完整跑通

4.1 工程结构怎么组织

课设代码我建议先写单文件，把所有函数放在一个main.c里，方便调试和上交。如果你想让代码结构更专业，可以拆成三个文件：

• teacher.h：结构体定义、函数声明、宏定义
• teacher.c：所有功能函数的实现
• main.c：主函数和菜单循环

单文件的好处是编译命令极简，适合初学者；多文件的好处是模块清晰，答辩时可以讲"我按模块划分了代码"。两种方案都能跑，关键在于你能否把每个函数的功能讲清楚。

编译命令很简单，用GCC直接编译：

gcc main.c -o teacher_sys ./teacher_sys

如果拆了多文件：

gcc main.c teacher.c -o teacher_sys

4.2 开发顺序建议

我的实操建议是：不要按菜单顺序写代码，而是按依赖关系写。先写结构体和链表基础操作，再往上垒功能，每一步都能编译、能测试，再走下一步。

我的习惯顺序是：定义结构体 -> 写录入和显示 -> 写保存和读取 -> 写查找 -> 写删除 -> 写修改 -> 写排序和统计 -> 最后接菜单。

为什么这样排？录入和显示是最简单的成对功能，能立刻验证链表搭建是否正确；保存和读取紧接着做，保证数据不白录；查找、删除、修改依赖遍历能力，放在中间；排序和统计属于进阶，放到最后。每一步都单独测试，出问题能立刻定位到新写的代码，而不是在几百行代码里大海捞针。

4.3 测试用例：别等答辩现场才翻车

很多同学写完代码，手动点几下菜单觉得"没问题"就交上去了。实际上，手动点菜单测不到边界情况。我建议至少按下表跑一遍：

这些测试用例不复杂，但覆盖了链表和文件最容易出问题的路径。我见过太多人栽在"删除头节点"和"空链表操作"上，这两个用例建议优先跑。

5. 高频故障现场：这些坑我替你踩过了

5.1 scanf吃回车：输入跳来跳去的元凶

症状：录入完第一个人的信息，屏幕上什么都不显示就直接跳下一项，或者菜单循环错乱。原因就是scanf("%d")读取数字后，留在缓冲区的回车键'\n'被下一个scanf("%s")读走了，字符串变成空串。

解决办法最彻底的是统一用fgets读取整行，再配合sscanf解析。比如读工号：

char buf[32]; printf("请输入工号: "); fgets(buf, sizeof(buf), stdin); sscanf(buf, "%d", &p->id);

这样回车被fgets整个消费掉了，缓冲区永远是干净的。如果嫌麻烦，也可以在每次scanf后补一条while (getchar() != '\n');，把剩余字符清空。但是注意：用户如果输入的不是数字，scanf会失败，getchar清不到内容，程序还是会乱。所以fgets+sscanf才是更省心的方案。

5.2 保存成功了，文件里却是空的或者找不到

这个坑有三个阶段，我都见过。

第一阶段：写完数据没调fclose。文件写入先经过缓冲区，fclose才会把缓冲区的数据真正刷到磁盘。程序正常退出可能自动刷新，但如果你在调试时用Ctrl+C强杀进程，数据可能就丢了。所以保存函数的最后一定要fclose。

第二阶段：文件写到了"另一个目录"。这最容易发生在用IDE跑程序的时候，可执行文件的工作目录可能不是你代码所在的目录。解决办法很简单：用printf("%s", getcwd(NULL, 0));打印一下当前工作目录，或者干脆在保存函数里先输出文件的完整路径。

第三阶段：再次启动程序后，fopen("teacher.txt", "r")返回NULL。多半是因为上次保存时文件写到了项目目录，这次运行却从别的地方启动程序。保证两次运行的工作目录一致，是最直接的解药。

5.3 删除节点后程序崩溃

这个坑的根源是"野指针"。两种情况最典型。

第一种，删除头节点但没更新head。删除后head还指着一块已经被free的内存，下一次从头遍历直接访问野指针，段错误。

第二种，free之后还访问p->next。比如有人写完free(p)继续写p = p->next，这是典型的"释放后使用"。正确做法是在free之前，先把p->next保存到一个临时变量里，或者像我的删除代码那样，在free之前已经通过prev->next完成了链表的重新连接。

5.4 中文乱码：编码问题的真相

中文乱码的核心原因是编码不匹配。在Windows命令行环境下，控制台默认使用GBK编码（代码页936），而你的源文件如果保存成UTF-8，编译后字符串字面量是UTF-8字节序列，控制台按GBK解码，自然就是一堆乱码。

解决办法有三个层面。最省事的是把源文件也存成GBK/ANSI编码，很多旧式IDE默认就是这么干的。如果一定用UTF-8，可以在程序开头调用setlocale(LC_ALL, "");，让程序使用系统默认本地环境，通常能解决问题。还有一种是在代码里显式设置控制台代码页，比如在Windows下用system("chcp 65001");切到UTF-8。

我个人的建议是：先确认你的编译器默认编码，只要能保证"源文件编码"和"控制台编码"一致，乱码问题就消失了。

5.5 gets函数被禁用之后

新版C标准已经把gets移除了，因为gets无法限制读取长度，输入超长字符串会直接写入相邻内存，造成缓冲区溢出。编译器一般会警告甚至报错。替代方案是fgets，但fgets会连换行符一起读进数组，所以每次读完后要手动把结尾的'\n'去掉：

fgets(p->name, MAX_NAME, stdin); size_t len = strlen(p->name); if (len > 0 && p->name[len-1] == '\n') { p->name[len-1] = '\0'; }

这段代码是字符串处理的常规操作，建议直接背下来。使用fgets还有一个好处：它能限制最大长度，输入超长时自动截断，安全性比scanf("%s")高不少。

5.6 内存泄漏：看不见的慢性失血

内存泄漏在短时间运行时完全看不出来，但它真实存在。整个程序里，只有新增节点时malloc分配了内存，所以释放内存的机会也埋在各种路径里：删除节点时释放一个节点，退出程序时释放整条链表，从文件读入前释放旧链表。

我建议写一个专门的清理函数，退出时调用：

void freeList(Teacher *head) { Teacher *p = head; while (p != NULL) { Teacher *tmp = p; p = p->next; free(tmp); } }

想验证有没有泄漏，可以用内存检查工具跑一遍完整的增删改查流程。在Linux环境下用内存检查工具，看到"definitely lost"是0，才算真正合格。Windows下也可以用Visual Studio的调试模式查内存泄漏报告，没条件的话，养成"每次退出都调freeList"的习惯也行。

6. 答辩与升级：让这个项目从及格走向优秀

6.1 答辩时怎么讲才能拿分

很多同学答辩时主要讲"我做了哪些功能"，这其实是最低分描述。老师想听到的是你"为什么这么做"。

我建议你准备三个核心问题的回答。第一，"为什么用链表不用数组"——你要答出动态内存、插入删除不需要移动元素这两点，顺带说明链表适合数据量不确定的场景。第二，"文件读写为什么用文本格式"——你要答出二进制方式会把next指针的地址写进文件、读回来必然出错这一点，这直接证明你真的理解了指针。第三，"删除节点时怎么防止内存泄漏"——你要答出prev指针维护和头节点特殊处理，这能证明你理解链表删除的本质。

顺着这三个问题讲下来，老师基本不会再追问底层细节，因为你已经展示出"设计时想过为什么"。

6.2 低成本升级：让项目更有竞争力

如果时间充裕，我推荐做这四个升级，成本低、见效快。

第一个是工号唯一性校验。录入时遍历链表，发现相同工号就拒绝录入。这个功能代码量不大，但能明显提升系统的严谨性，答辩时也是一句话就能讲清楚的亮点。

第二个是导出CSV。CSV本质上就是逗号分隔的文本文件，你现有的fprintf格式稍微改改就能输出，用电子表格软件能直接打开。这个功能很讨喜，演示效果好。

第三个是增加登录密码。在进入主菜单前加一道密码验证，密码写在配置文件里。这个需求本身不难，但能体现你考虑过"信息安全"层面的东西。

第四个是学有余力的同学可以尝试把链表换成动态数组（realloc动态扩容），或者引入哈希表按工号快速查找。这些属于数据结构的进阶玩法，做得好能拿很高印象分，但前提是你要能讲清楚时间复杂度的差异。

6.3 最后分享一点我自己反复体会到的经验

这个项目我前后写过三版。第一版用数组，功能能跑但心里发虚；第二版换链表，终于把指针搞明白了大半；第三版才把文件读写、异常输入、内存释放这些"脏活"真正做扎实。回头看，把代码跑对根本不是这个项目的终点，能在乱输入、文件缺失、断电重启这些真实世界的意外面前依然稳定，才算真正把C语言的知识变成了自己的能力。

如果你现在正因为这个课设头大，我的建议只有一条：别急着搜"完整代码"，先自己把结构体定义写出来，把链表画在纸上，把scanf的缓冲区问题亲手踩一遍。这个题做完，你的指针水平一定会往上走一个台阶，这份收获远比那一份代码要值钱。