C语言课程设计题目（24个选题）

原创已于 2024-10-01 01:16:33 修改 · 4.6k 阅读

46 ·

CC 4.0 BY-SA版权

文章标签：

#c语言 #课程设计 #开发语言

于 2024-09-24 19:00:54 首次发布

C/C++语言笔记专栏收录该内容

18 篇文章

订阅专栏

C语言课程设计题目

序号	系统设计题目	进度
1	职工信息管理系统设计	已完成，在本文下面
2	图书信息管理系统设计	已完成，在本文下面
3	图书管理系统设计	已完成，在本文下面
4	实验设备管理系统设计	已完成，在本文下面
5	西文下拉菜单的设计	已完成，在本文下面
6	学生信息管理系统设计	已完成，在本文下面
7	学生成绩管理系统设计	已完成，在本文下面
8	学生选修课程系统设计	已完成，课程管理系统
9	学生成绩记录簿设计	链接
10	学生籍贯信息记录簿设计	链接
11	学生通讯录管理系统设计	链接
12	职工工作量统计系统设计	链接
13	销售管理系统设计	链接
14	成绩管理系统设计	链接
15	通信录管理系统设计	链接
16	学生管理系统设计	链接
17	单项选择题标准化考试系统设计	链接
18	设计一个简单计算器	链接
19	编写一万年历系统	已完成，在本文下面
20	模拟时钟转动程序	链接
21	完整的学生成绩管理系统	链接
22	数字加一游戏	链接
23	聊天机器人	链接
24	音乐小天才	链接

一、设计要求与设计报告
设计要求

任意选定以下一个题目完成
模块化程序设计，建立项目工程
锯齿型（缩进）程序书写格式
必须上机调试通过

设计报告格式

设计任务和要求
总体设计（程序设计组成框图、流程图）
详细设计（模块功能说明（如函数功能、入口及出口参数说明，函数调用关系描述等）
调试与测试：调试方法，测试结果的分析与讨论，测试过程中遇到的主要问题及采取的解决措施
源程序工程包和执行结果：清单中应有足够的注释（另行打包）

二、检查要求

每个人必须有程序运行结果
每个人必须交《C语言课程设计报告》和设计程序工程包
课程设计任务必须由个人独立完成，禁止相互抄袭，如有发现，严肃处理

三、打分标准

根据平时上机考勤；注重平时上机成绩，教师要不定期检查学生进度，学生不得以自己有私人电脑为借口而不来上机（30%）
根据程序运行结果（50%），学生能熟练地演示自己的项目，对自己的程序面对教师提问并能熟练地解释清楚。
根据《C语言课程设计报告》要求完成项目报告（20%）。
以上三项缺一不可。由于课程设计各题目的难度不一，所以成绩的评定将根据各人完成题目的难度和完成情况的不同，分别评定成绩，如未能完成任何题目，则以不及格计算。

四、提交时间
课程设计任务完成时间为 18周 结束，届时上交课程设计报告和程序。学习委员于 18周前收齐报告纸质版、项目包和报告电子版各一份，按时提交。

五、选题要求
选择每个题目不能超过 3人，每人要独立完成，不能互相抄袭。

题目列表

题目一：职工信息管理系统设计

职工信息包括职工号、姓名、性别、年龄、学历、工资、住址、电话等（职工号不重复）。
设计职工信息管理系统，功能包括：

系统以菜单方式工作。
职工信息录入功能(职工信息用文件保存)－－输入。
职工信息浏览功能－－输出。
职工信息查询功能－－算法。
- 按学历查询等。
- 按职工号查询等。
职工信息删除、修改功能(可选项)。

题目二：图书信息管理系统设计

图书信息包括：登录号、书名、作者名、分类号、出版单位、出版时间、价格等。
设计图书信息管理系统，功能包括：

系统以菜单方式工作。
图书信息录入功能(图书信息用文件保存)－－输入。
图书信息浏览功能－－输出。
图书信息查询功能－－算法。
查询方式
- 按书名查询。
- 按作者名查询。
图书信息的删除与修改(可选项)。

题目三：图书管理系统设计

图书管理信息包括：图书名称、图书编号、单价、作者、存在状态、借书人姓名、性别、学号等。
主要功能：

新进图书基本信息的输入。
图书基本信息的查询。
对撤销图书信息的删除。
为借书人办理注册。
办理借书手续。
办理还书手续

要求： 使用二进制文件方式存储数据，系统以菜单方式工作。

题目四：实验设备管理系统设计

实验设备信息包括：设备编号，设备种类(如：微机、打印机、扫描仪等等)，设备名称，设备价格，设备购入日期，是否报废，报废日期等。
主要功能：

能够完成对设备的录入和修改。
对设备进行分类统计。
设备的破损耗费和遗损处理。
设备的查询。

要求： 采用二进制文件方式存储数据，系统以菜单方式工作。

题目五：西文下拉菜单的设计

主要功能：

完成一个类似 DevC++集成系统下拉菜单的设计。
不要求实现各子菜单的功能。

要求： 可以通过光标键的移动来选择不同的菜单项，被选择的菜单项反相显示，当选定某个菜单项后，按回车键可以实现一个简单的动作。

题目六：学生信息管理系统设计

学生信息包括：学号，姓名，年龄，性别，出生年月，地址，电话，E-mail等。设计学生信息管理系统，功能包括：

系统以菜单方式工作。
学生信息录入功能（学生信息用文件保存）－－输入。
学生信息浏览功能－－输出。
学生信息查询功能－－算法。
查询方式
- 按学号查询
- 按姓名查询
学生信息的删除与修改(可选项)。

题目七：学生成绩管理系统设计

学生成绩信息包括：学期，学号，班别，姓名，四门课程成绩(语文、数学、英语和计算机)等。
主要功能：

能按学期、按班级完成对学生成绩的录入、修改。
能按班级统计学生的成绩，求学生的总分及平均分。
能查询学生成绩，不及格科目及学生名单。
能按班级输出学生的成绩单。

要求： 使用二进制文件方式存储数据，系统以菜单方式工作。

题目八：学生选修课程系统设计

假定有 n门课程，每门课程有：课程编号，课程名称，课程性质(公共课、必修课、选修课)，总学时，授课学时，实验或上机学时，学分，开课学期等信息，学生可按要求（如总学分不得少于60）自由选课。设计选修课程系统，功能包括：

系统以菜单方式工作。
课程信息录入功能(课程信息用文件保存)－－输入。
课程信息浏览功能－－输出。
课程信息查询功能－－算法。
查询方式
- 按学分查询。
- 按课程性质查询。
学生选修课程(可选项)。

题目九：学生成绩记录簿设计

编制一个C语言成绩记录簿，每个学生信息包括：学号、姓名、C语言成绩。具体功能：

创建信息链表并以磁盘文件保存。
读取磁盘文件并显示输出所有学生的成绩。
按学号或姓名查询成绩。
添加成绩记录。
修改指定姓名或学号的学生的成绩并可存盘。
显示输出60分以下、60~79、80~89、90分以上各分数段的学生信息(可选项)。

题目十：学生籍贯信息记录簿设计

编制一个学生籍贯信息记录簿，每个学生信息包括：学号、姓名、籍贯。具体功能：

创建信息链表并以磁盘文件保存。
读取磁盘文件并显示输出所有学生的籍贯信息。
按学号或姓名查询其籍贯。
按籍贯查询并输出该籍贯的所有学生。
能添加、删除和修改学生的籍贯信息(可选项)。

题目十一：学生通讯录管理系统设计

设计一个学生通信录，学生通迅录数据信息构成内容可自行设计(如：姓名、家庭地址、邮政编码、电话号码等等)，通信录数据类型定义为结构体类型。
主要功能：

能建立、修改和增删学生通讯录。
能够按多种方式进行查询。

要求： 界面友好，易于操作，采用二进制文件存储数据。

题目十二：职工工作量统计系统设计

编写一个程序，该程序输入职工工号和完成的产品数量，程序允许同一职工有多次输入，由程序对其完成的产品数量实现累计。程序按完成数量对他们排序，并确定他们的名次。按完成的产品数量由多到少的顺序，输出名次、同一名次的职工人数及他们的工号(工号由小到大顺序输出)。要求程序用有序链表存储数据信息。

题目十三：销售管理系统设计

某公司有四个销售员（编号：1～4），负责销售五种产品（编号：1～5）。每个销售员都将当天出售的每种产品各写一张便条交上来。每张便条包含内容：（1）销售员的代号；（2）产品的代号；（3）这种产品的当天的销售额。每位销售员每天上缴1张便条。
设计便条管理系统，功能包括：

系统以菜单方式工作。
便条信息录入功能(便条信息用文件保存)－－输入。
收集到了上个月的所有便条后，读取销售情况。
- （1）计算每个人每种产品的销售额。
- （2）按销售额对销售员进行排序，输出排序结果（销售员代号）。
- （3）统计每种产品的总销售额，对这些产品按从高到底的顺序，输出排序结果（需输出产品的代号和销售额）(可选项)。

题目十四：成绩管理系统设计

现有学生成绩信息，内容如下

姓名	学号	语文	数学	英语
张明明	01	67	78	82
李成友	02	78	91	88
张辉灿	03	68	82	56
王露	04	56	45	77
陈东明	05	67	38	47
…

用C/C++编写一系统，实现学生信息管理，软件的入口界面应包括如下几个方面：
（一）功能要求：

信息维护：
- 要求：学生信息数据要以文件的形式保存，能实现学生信息数据的维护。此模块包括子模块有：增加学生信息、删除学生信息、修改学生信息
信息查询：
- 要求：查询时可实现按姓名查询、按学号查询
成绩统计：
- 要求：A输入任意的一个课程名（如数学）和一个分数段（如60–70），统计出在此分数段的学生情况。

（二）其它要求：

只能使用 C/C++语言，源程序要有适当的注释，使程序容易阅读
至少采用文本菜单界面（如果能采用图形菜单界面更好）
学生可自动增加新功能模块（视情况可另外加分）
写出课程设计报告，具体要求见相关说明文档

题目十五：通信录管理系统设计

用C/C++设计出模拟手机通信录管理系统，实现对手机中的通信录进行管理。
（一）功能要求

查看功能：选择此功能时，列出下列3类选择。
- A办公类
- B个人类
- C商务类
  当选中某类时，显示出此类所有数据中的姓名和电话号码
增加功能：能录入新数据（一个结点包括：姓名、电话号码、分类（可选项有：A 办公类 B 个人类 C 商务类）、电子邮件）。例如

杨春	13589664454	商务类	chuny@126.com

当录入了重复的姓名和电话号码时，则提示数据录入重复并取消录入；当通信录中超过15条信息时，存储空间已满，不能再录入新数据；录入的新数据能按递增的顺序自动进行条目编号。

拔号功能：能显示出通信录中所有人的姓名，当选中某个姓名时，屏幕上模拟打字机的效果依次显示出此人的电话号码中的各个数字，并伴随相应的拔号声音。
修改功能：选中某个人的姓名时，可对此人的相应数据进行修改
删除功能：选中某个人的姓名时，可对此人的相应数据进行删除，并自动调整后续条目的编号。

（二）其它要求：

只能使用 C/C++语言，源程序要有适当的注释，使程序容易阅读
至少采用文本菜单界面（如果能采用图形菜单界面更好）
建议使用结构和链表等数据结构
学生可自动增加新功能模块（视情况可另外加分）
写出课程设计报告，具体要求见相关说明文档

题目十六：学生管理系统设计

使用提供的数据，设计一个学籍管理系统，实现基本功能。

学生基本信息文件(A.TXT)内容：A.TXT 文件不需要编程录入数据，可用文本编辑工具直接生成。

学号	姓名	性别	宿舍号码	电话号码
01	张成成	男	501	87732111
02	李成华	女	101	87723112
03	王成凤	女	101	87723112
04	张明明	男	502	87734333
05	陈东	男	501	87732111
06	李果	男	502	87734333
07	张园园	女	102	87756122
…

学生成绩基本信息文件(B.TXT)内容：

学号	课程编号	课程名称	学分	平时成绩	实验成绩	卷面成绩
01	A01	大学物理	3	66	78	82
02	B03	高等数学	4	78	-1	90
01	B03	高等数学	4	45	-1	88
02	C01	VF	3	65	76	66
…

（一）功能要求及说明：

数据录入功能:
对B.TXT进行数据录入，录入学号、课程编号、课程名称、学分、平时成绩、实验成绩、卷面成绩，综合成绩和实得学分由程序根据条件自动计算。

（1）综合成绩计算规则：
- 如果实验成绩为-1，表示无实验，则：综合成绩 = 平时成绩 * 30% + 卷面成绩 * 70%
- 如果实验成绩不为-1，则：综合成绩 = 平时成绩 * 15% + 实验成绩 * 15% + 卷面成绩 * 70%
（2）实得学分的计算：采用等级学分制。
- 综合成在90-100之间，实得学分 = 学分 * 100%
- 综合成在80-90之间，实得学分 = 学分 * 80%
- 综合成在70-80之间，实得学分 = 学分 * 75%
- 综合成在60-70之间，实得学分 = 学分 * 60%
- 综合成在60以下，实得学分 = 学分 * 0%

查询功能：分为学生基本情况查询和成绩查询。

A：学生基本情况查询：
A1----输入一个学号或姓名（可实现选择），查出此生的基本信息并显示输出。
A2—输入一个宿舍号码，可查询出本室所有的学生的基本信息并显示输出。
B：成绩查询：
B1：输入一个学号时，查询出此生的所有课程情况，格式如下：

学号：xx	姓名：xxxxx
课程编号：xxx	课程名称：xxxxx	综合成绩：xxxx	实得学分: xx
课程编号：xxx	课程名称：xxxxx	综合成绩：xxxx	实得学分: xx
课程编号：xxx	课程名称：xxxxx	综合成绩：xxxx	实得学分: xx
……
共修：xx 科，实得总学分为: xxx

删除功能：
在A.TXT中删除一个学生时，B.TXT中该生所有信息也应自动删除。
排序功能：
按综合成绩或实得学分升序或降序排序并显示数据。

（二）其它要求：
1.只能使用 C/C++语言，源程序要有适当的注释，使程序容易阅读。
2.至少采用文本菜单界面（如果能采用图形菜单界面更好）。
3.学生可自动增加新功能模块（视情况可另外加分）。
4.写出课程设计报告，具体要求见相关说明文档。

题目十七：单项选择题标准化考试系统设计

功能要求：

使用文件保存试题库，每个试题包括题干、4个备选答案、标准答案。
实现试题录入功能，随时增加试题至试题库。
实现试题抽取功能，随机抽取N道题进行考试，N由键盘输入。
实现答题功能，用户输入答案。
实现自动判卷功能，根据用户答案与标准答案对比给出成绩。

其它要求：

使用C/C++语言，源程序应有适当注释。
至少采用文本菜单界面。
学生可自行增加新功能模块。
编写课程设计报告。

题目十八：设计一个简单计算器

要求： 功能上尽量模拟Windows操作系统中的计算器，界面设计不做强制要求。

题目十九：编写一万年历系统

要求： 模仿现实中的挂历，显示当前月的每一天及星期几，当系统日期变为下一个月时，自动翻页到下一个月。

题目二十：模拟时钟转动程序

要求： 能模拟机械钟表行走，同时准确显示日期和时间，屏幕上显示一个动态时钟，按下任意键时程序退出。

题目二十一：完整的学生成绩管理系统

（1）系统功能：

建立数据库文件数据结构，输入学生成绩数据，并以文件方式存盘。
对已建立文件进行修改，包括：增加课程、修改课程名、追加记录。
根据某一门课程成绩进行排序。
显示数据库文件信息。

（2）模块层次及功能：
系统的模块级功能如图，可以自行增加其他功能。
在这里插入图片描述

题目二十二：数字加一游戏

游戏功能：
数字加 1 是一款玩法非常简单的益智小游戏，在一个 5×5 的表格中，随机产生不大于 6 的数字。只要点击某一个数字让它加 1，并与相邻的二个以上的数字相同，这些数字就会合成 1 个加 1 的数字。

游戏规则：
游戏开始时，在一个 5*5 的表格中随机填入 1-6 的数字，初始表格中不能有3 个及以上相同数字的连通块，每个格子的颜色由格子填充的数字决定。当鼠标点击表格中某数字时其值自动加一；然后判断与该数字相连是否存在数字连通块，若存在就消弭使当前位置数字加 1，连通块中的其它数字变为空缺。空缺由上方的数字自动下落填补，上方掉落后的空缺随机填充 1-6 的数字。重复进行检查新的连通块，销弥、掉落、填补等过程，直到不能产生消弭。点击一次，步数就减一，消弭一次步数加一。用完步数游戏完毕。动画显示消弭和掉落过程。

游戏要求：

系统提供5次机会，每次点击消耗一次，每次合成增加一次，但总数不超过5次。
记录每次游戏的得分，每合成一次，积分增加相应的分数，最后记录总得分。每次合成的分数为：三个数及以上合成新数得 1 点，四个数合成新数得 2 点，五个数合成新数得 3点，以此类推，每次合成的得分为当前数字乘以点数。比如若有 3 个 3 合成为 4，则本次合成得分为 3×1=3 分，若有 3 个 4 合成为 5，则得分为 3×2=6 分。

题目二十三：基于C++聊天机器人

系统功能：

通过调用 Windows 系统自带的语音识别功能，随时识别用户通过麦克风说的每一句话并与语音数据库中的预存数据相比较，如果匹配，则回应相应的对话。语音数据库中的预存数据要自建，并逐步丰富。
朗诵诗词或讲故事。

题目二十四：基于C++的音乐小天才

系统功能：

通过Windows系统的声音函数，播放音乐。
自建音乐文件，播放歌曲。
利用键盘上的键，弹奏歌曲，自定义 1234567(中音),QWERTYU（低音）,ASDFGHJ（高音）。
在屏幕上绘制音乐键盘，鼠标点击发出声音。

题目一代码

在这里插入图片描述

employeeManagement.h

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义最大职工数量
#define MAX_EMPLOYEES 100

//定义职工结构体
typedef struct {
	int id;				// 职工号
	char name[50];		// 姓名
	char gender[50];    // 性别
	int age;			// 年龄
	char education[50];	// 学历
	double salary;		// 工资
	char address[100];	// 地址
	char phone[20];		// 电话
}Employee;
// 显示菜单
void showMenu();
// 主菜单函数
void menu(Employee* employees, int* count);
// 打印单个职工信息
void printEmployee(Employee emp);
// 检查职工号是否唯一
int isIdUnique(Employee* employees, int count, int id);
// 添加职工信息
void addEmployee(Employee* employees, int* count);
// 显示所有职工信息
void displayEmployee(Employee* employees, int count);
// 按学历查询职工信息
void searchByEducation(Employee* employees, int count);
// 按职工号查询职工信息
void searchById(Employee* employees, int count);
// 删除职工信息
void deleteEmployee(Employee* employees, int* count);
// 修改职工信息
void modifyEmployee(Employee* employees, int count);
// 保存职工信息到文件
void saveToFile(Employee* employees, int count);
// 加载职工信息
void loadFromFile(Employee* employees, int* count);

employeeManage.c

#include"employeeManagement.h"

// 显示菜单
void showMenu() {
	printf("\n");
	printf("+--------------------------+\n");
	printf("|    职工信息管理系统       |\n");
	printf("+--------------------------+\n");
	printf("|  1. 录入职工信息         |\n");
	printf("|  2. 浏览职工信息         |\n");
	printf("|  3. 按学历查询职工信息   |\n");
	printf("|  4. 按职工号查询职工信息 |\n");
	printf("|  5. 删除职工信息         |\n");
	printf("|  6. 修改职工信息         |\n");
	printf("|  7. 保存并退出           |\n");
	printf("+-------------------------+\n");
	printf("请选择操作: ");
}
// 主菜单函数
void menu(Employee* employees, int* count) {
	int choice;

	while (1) {
		showMenu();
		scanf("%d", &choice);

		switch (choice) {
		case 1:
			//printf("录入职工信息\n");
			addEmployee(employees, count);
			break;
		case 2:
			//printf("浏览职工信息\n");
			displayEmployee(employees, *count);
			break;
		case 3:
			//printf("按学历查询职工信息\n");
			searchByEducation(employees, *count);
			break;
		case 4:
			//printf("按职工号查询职工信息\n");
			searchById(employees, *count);
			break;
		case 5:
			//printf("删除职工信息\n");
			deleteEmployee(employees, count);
			break;
		case 6:
			//printf("修改职工信息\n");
			modifyEmployee(employees, *count);
			break;
		case 7:
			//printf("退出\n");
			saveToFile(employees, *count);
			return;
		default:
			printf("无效的选择，请重新输入。\n");
		}
	}
}
// 打印单个职工信息
void printEmployee(Employee emp) {
	printf("职工号: %d\n", emp.id);
	printf("姓名: %s\n", emp.name);
	printf("性别: %s\n", emp.gender);
	printf("年龄: %d\n", emp.age);
	printf("学历: %s\n", emp.education);
	printf("工资: %.2f\n", emp.salary);
	printf("地址: %s\n", emp.address);
	printf("电话: %s\n", emp.phone);
	printf("\n");
}
// 检查职工号是否唯一
int isIdUnique(Employee* employees, int count, int id) {
	for (int i = 0; i < count; i++) {
		if (employees[i].id == id) {
			return 0;	//职工号不唯一
		}
	}
	return 1;//职工号唯一
}
// 添加职工信息
void addEmployee(Employee* employees, int* count) {
	if (*count >= MAX_EMPLOYEES) {
		printf("已达到最大容量，无法添加更多职工。\n");
		return;
	}
	Employee* emp = &employees[*count];

	int id;
	printf("请输入职工号: ");
	scanf("%d", &id);

	if (!isIdUnique(employees, *count, id)) {
		printf("职工号已存在，请重新输入。\n");
		return;
	}

	emp->id = id;
	printf("请输入姓名: ");
	scanf("%s", emp->name);
	printf("请输入性别: ");
	scanf("%s", emp->gender);
	printf("请输入年龄: ");
	scanf("%d", &emp->age);
	printf("请输入学历: ");
	scanf("%s", emp->education);
	printf("请输入工资: ");
	scanf("%lf", &emp->salary);
	printf("请输入地址: ");
	scanf("%s", emp->address);
	printf("请输入电话: ");
	scanf("%s", emp->phone);
	(*count)++;
	printf("职工 %s 信息录入成功\n", emp->name);

}
// 显示所有职工信息
void displayEmployee(Employee* employees, int count) {
	for (int i = 0; i < count; i++) {
		printEmployee(employees[i]);
	}
}
// 按学历查询职工信息
void searchByEducation(Employee* employees, int count) {
	char education[50];
	printf("请输入学历进行查询:");
	scanf("%s", education);

	int found = 0;
	for (int i = 0; i < count; i++) {
		if (strcmp(employees[i].education, education) == 0) {
			printEmployee(employees[i]);
			found = 1;
		}
	}
	if (!found) {
		printf("没有找到符合条件的职工。\n");
	}
}
// 按职工号查询职工信息
void searchById(Employee* employees, int count) {
	int id;
	printf("请输入职工号进行查询: ");
	scanf("%d", &id);
	for (int i = 0; i < count; i++) {
		if (employees[i].id == id) {
			printEmployee(employees[i]);
			return;
		}
	}
	printf("没有找到该职工号的职工信息。\n");
}
// 删除职工信息
void deleteEmployee(Employee* employees, int* count) {
	int id;
	printf("请输入要删除的职工号: ");
	scanf("%d", &id);
	for (int i = 0; i < *count; i++) {
		if (employees[i].id == id) {
			//将要删除的职工信息后移
			for (int j = i; j < *count - 1; j++) {
				employees[j] = employees[j + 1];
			}
			(*count)--;//总数减一
			printf("职工号 %d 的信息已经删除。\n", id);
			return;
		}
	}
	printf("没有找到该职工号的职工信息，无法删除。\n");
}
// 修改职工信息
void modifyEmployee(Employee* employees, int count) {
	int id;
	printf("请输入要修改的职工号:");
	scanf("%d", &id);
	for (int i = 0; i < count; i++) {
		if (employees[i].id == id) {
			// 提示用户输入新的信息
			printf("请输入新的姓名: ");
			scanf("%s", employees[i].name);
			printf("请输入新的性别: ");
			scanf("%s", employees[i].gender);
			printf("请输入新的年龄: ");
			scanf("%d", &employees[i].age);
			printf("请输入新的学历: ");
			scanf("%s", employees[i].education);
			printf("请输入新的工资: ");
			scanf("%lf", &employees[i].salary);
			printf("请输入新的地址: ");
			scanf("%s", employees[i].address);
			printf("请输入新的电话: ");
			scanf("%s", employees[i].phone);
			printf("职工号 %d 的信息已修改。\n", id);
			return;
		}
	}
	printf("没有找到该职工号的职工信息，无法修改。\n");
}
// 保存职工信息到文件
void saveToFile(Employee* employees, int count) {
	FILE* file = fopen("employees.txt", "w");
	if (file == NULL) {
		printf("无法打开文件。\n");
		return;
	}

	for (int i = 0; i < count; i++) {
		Employee* emp = &employees[i];
		fprintf(file, "%d %s %s %d %s %.2f %s %s\n",
			emp->id, emp->name, emp->gender, emp->age,
			emp->education, emp->salary, emp->address, emp->phone);
	}

	fclose(file);
	printf("职工信息保存成功。\n");
}
// 加载职工信息
void loadFromFile(Employee* employees, int* count) {
	FILE* file = fopen("employees.txt", "r");
	if (file == NULL) {
		printf("无法打开文件。\n");
		return;
	}

	*count = 0;
	while (*count < MAX_EMPLOYEES && fscanf(file, "%d %s %s %d %s %lf %s %s",
		&employees[*count].id,
		employees[*count].name,
		employees[*count].gender,
		&employees[*count].age,
		employees[*count].education,
		&employees[*count].salary,
		employees[*count].address,
		employees[*count].phone) == 8) {
		(*count)++;
	}

	fclose(file);
	printf("从文件加载了 %d 条记录。\n", *count);
}

test.c

#include"employeeManagement.h"
int main() {
	Employee employees[MAX_EMPLOYEES];
	int count = 0;

	loadFromFile(employees, &count);

	menu(employees, &count);

	return 0;
}

调试验证
录入信息，并浏览
在这里插入图片描述

验证职工号唯一

保存职工信息，加载职工信息

在这里插入图片描述

在这里插入图片描述
按职工号进行查询

根据id删除职工
在这里插入图片描述
修改职工信息

在这里插入图片描述

题目二代码

在这里插入图片描述

bookManagement.h

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_BOOKS 100  // 最大图书数量
#define FILE_NAME "books.txt"  // 文件名

// 定义图书结构体
typedef struct {
    int loginNo;      // 登录号
    char title[100];  // 书名
    char author[100]; // 作者名
    char category[50]; // 分类号
    char publisher[100]; // 出版单位
    char publicationDate[20]; // 出版时间
    double price;     // 价格
} Book;

// 函数声明
void showMenu();
void menu(Book* books, int* count);
void printBook(Book book);
void addBook(Book* books, int* count);
void displayBooks(Book* books, int count);
void searchByTitle(Book* books, int count);
void searchByAuthor(Book* books, int count);
void deleteByTitle(Book* books, int* count);
void deleteByAuthor(Book* books, int* count);
void deleteByLoginNo(Book* books, int* count);
void modifyByLoginNoAndTitle(Book* books, int count);
void saveToFile(Book* books, int count);
void loadFromFile(Book* books, int* count);

bookManagement.c

#include"bookManagement.h"
void showMenu() {
    printf("\n");
    printf("+----------------------------------+\n");
    printf("|    图书信息管理系统              |\n");
    printf("+----------------------------------+\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("+----------------------------------+ \n");
    printf("请选择操作: ");
}
void menu(Book* books, int* count) {
    int choice;
    loadFromFile(books, count);  // 初始化时从文件加载图书信息
    while (1) {
        showMenu();
        scanf("%d", &choice);

        switch (choice) {
        case 1:
            addBook(books, count);  // 添加图书信息
            break;
        case 2:
            displayBooks(books, *count);  // 显示所有图书信息
            break;
        case 3:
            searchByTitle(books, *count);  // 按书名查询图书信息
            break;
        case 4:
            searchByAuthor(books, *count);  // 按作者名查询图书信息
            break;
        case 5:
            deleteByLoginNo(books, count);  // 按登录号删除图书信息
            break;
        case 6:
            deleteByTitle(books, count);  // 按书名删除图书信息
            break;
        case 7:
            deleteByAuthor(books, count);  // 按作者名删除图书信息
            break;
        case 8:
            modifyByLoginNoAndTitle(books, *count);  // 按登录号书名修改图书信息
            break;
        case 9:
            saveToFile(books, *count);  // 保存图书信息并退出
            return;
        default:
            printf("无效的选择，请重新输入。\n");
        }
    }
}
void printBook(Book book) {
    printf("登录号: %d\n", book.loginNo);
    printf("书名: %s\n", book.title);
    printf("作者名: %s\n", book.author);
    printf("分类号: %s\n", book.category);
    printf("出版单位: %s\n", book.publisher);
    printf("出版时间: %s\n", book.publicationDate);
    printf("价格: %.2f\n", book.price);
    printf("\n");
}
void addBook(Book* books, int* count) {
    if (*count >= MAX_BOOKS) {
        printf("已达到最大容量，无法添加更多图书。\n");
        return;
    }
    Book* book = &books[*count];

    printf("请输入登录号: ");
    scanf("%d", &book->loginNo);

    printf("请输入书名: ");
    scanf("%s", book->title);

    printf("请输入作者名: ");
    scanf("%s", book->author);

    printf("请输入分类号: ");
    scanf("%s", book->category);

    printf("请输入出版单位: ");
    scanf("%s", book->publisher);

    printf("请输入出版时间: ");
    scanf("%s", book->publicationDate);

    printf("请输入价格: ");
    scanf("%lf", &book->price);

    (*count)++;
    printf("图书信息录入成功\n");
}
void displayBooks(Book* books, int count) {
    for (int i = 0; i < count; i++) {
        printBook(books[i]);
    }
}
void searchByTitle(Book* books, int count) {
    char title[100];
    printf("请输入书名进行查询: ");
    scanf("%s", title);

    int found = 0;
    for (int i = 0; i < count; i++) {
        if (strcmp(books[i].title, title) == 0) {
            printBook(books[i]);
            found = 1;
        }
    }
    if (!found) {
        printf("没有找到符合条件的图书。\n");
    }
}
void searchByAuthor(Book* books, int count) {
    char author[100];
    printf("请输入作者名进行查询: ");
    scanf("%s", author);

    int found = 0;
    for (int i = 0; i < count; i++) {
        if (strcmp(books[i].author, author) == 0) {
            printBook(books[i]);
            found = 1;
        }
    }
    if (!found) {
        printf("没有找到符合条件的图书。\n");
    }
}
void deleteByTitle(Book* books, int* count) {
    char title[100];
    printf("请输入要删除的书名: ");
    scanf("%s", title);

    int deleted = 0;
    for (int i = 0; i < *count; i++) {
        if (strcmp(books[i].title, title) == 0) {
            for (int j = i; j < *count - 1; j++) {
                books[j] = books[j + 1];
            }
            (*count)--;
            printf("书名 %s 的图书信息已经删除。\n", title);
            deleted = 1;
            break;
        }
    }
    if (!deleted) {
        printf("没有找到符合条件的图书信息。\n");
    }
}
void deleteByAuthor(Book* books, int* count) {
    char author[100];
    printf("请输入要删除的作者名: ");
    scanf("%s", author);

    int deleted = 0;
    int newCount = 0;
    Book tempBooks[MAX_BOOKS];

    for (int i = 0; i < *count; i++) {
        if (strcmp(books[i].author, author) != 0) {
            tempBooks[newCount++] = books[i];
        }
        else {
            printf("作者名 %s 的图书信息已经删除。\n", author);
            deleted = 1;
        }
    }

    if (!deleted) {
        printf("没有找到符合条件的图书信息。\n");
    }

    // 更新书籍数组
    for (int i = 0; i < newCount; i++) {
        books[i] = tempBooks[i];
    }
    *count = newCount;
}
void deleteByLoginNo(Book* books, int* count) {
    int loginNo;
    printf("请输入要删除的登录号: ");
    scanf("%d", &loginNo);

    int newCount = 0;
    int deleted = 0;

    // 创建一个临时数组来存储未被删除的图书信息
    Book tempBooks[MAX_BOOKS];

    for (int i = 0; i < *count; i++) {
        if (books[i].loginNo != loginNo) {
            tempBooks[newCount++] = books[i];
        }
        else {
            deleted = 1;
        }
    }

    // 将未被删除的图书信息复制回原数组
    for (int i = 0; i < newCount; i++) {
        books[i] = tempBooks[i];
    }

    *count = newCount;

    if (deleted) {
        printf("登录号 %d 的所有图书信息已经删除。\n", loginNo);
    }
    else {
        printf("没有找到符合条件的图书信息。\n");
    }
}

void modifyByLoginNoAndTitle(Book* books, int count) {
    int loginNo;
    printf("请输入要修改的登录号: ");
    scanf("%d", &loginNo);

    int found = 0;
    for (int i = 0; i < count; i++) {
        if (books[i].loginNo == loginNo) {
            printf("当前信息:\n");
            printBook(books[i]);

            char confirm;
            printf("确认修改此图书信息吗？(y/n): ");
            scanf(" %c", &confirm);

            if (confirm == 'y' || confirm == 'Y') {
                char title[100];
                printf("请输入要修改的书名: ");
                scanf("%s", title);

                int modified = 0;
                for (int j = 0; j < count; j++) {
                    if (books[j].loginNo == loginNo && strcmp(books[j].title, title) == 0) {
                        printf("请输入新的书名: ");
                        scanf("%s", books[j].title);

                        printf("请输入新的作者名: ");
                        scanf("%s", books[j].author);

                        printf("请输入新的分类号: ");
                        scanf("%s", books[j].category);

                        printf("请输入新的出版单位: ");
                        scanf("%s", books[j].publisher);

                        printf("请输入新的出版时间: ");
                        scanf("%s", books[j].publicationDate);

                        printf("请输入新的价格: ");
                        scanf("%lf", &books[j].price);

                        printf("图书信息已更新。\n");
                        modified = 1;
                    }
                }

                if (!modified) {
                    printf("没有找到指定书名的图书信息。\n");
                }

                found = 1;
                break;
            }
            else {
                printf("取消修改。\n");
                break;
            }
        }
    }

    if (!found) {
        printf("没有找到指定登录号的图书信息。\n");
    }
}
void saveToFile(Book* books, int count) {
    FILE* fp = fopen(FILE_NAME, "w");
    if (fp == NULL) {
        printf("无法打开文件 '%s' 进行写入。\n", FILE_NAME);
        return;
    }

    for (int i = 0; i < count; i++) {
        fprintf(fp, "%d,%s,%s,%s,%s,%s,%.2f\n",
            books[i].loginNo,
            books[i].title,
            books[i].author,
            books[i].category,
            books[i].publisher,
            books[i].publicationDate,
            books[i].price);
    }

    fclose(fp);
    printf("图书信息保存成功。\n");
}
void loadFromFile(Book* books, int* count) {
    FILE* fp = fopen(FILE_NAME, "r");
    if (fp == NULL) {
        printf("文件 '%s' 不存在，创建新文件。\n", FILE_NAME);
        fp = fopen(FILE_NAME, "w");
        fclose(fp);
        return;
    }

    *count = 0;
    while (fscanf(fp, "%d,%[^,],%[^,],%[^,],%[^,],%[^,],%lf",
        &books[*count].loginNo,
        books[*count].title,
        books[*count].author,
        books[*count].category,
        books[*count].publisher,
        books[*count].publicationDate,
        &books[*count].price) != EOF) {
        (*count)++;
    }

    fclose(fp);
    printf("图书信息加载成功。\n");
}

test.c

#include"bookManagement.h"

int main() {
    Book books[MAX_BOOKS];
    int count = 0;

    menu(books, &count);

    return 0;
}

终端测试截图

添加图书
在这里插入图片描述
按下9 保存退出后，再次启动，按下2，浏览，没有问题

继续添加图书

199,西游记,吴承恩,I242.4,浙江古籍出版社,2010,35.00
199,鲁迅全集,鲁迅,略,略,略,900.00
199,呐喊,鲁迅,略,略,略,56.00
199,三国演义,罗贯中,略,略,略,79.00
89,红楼梦,曹雪芹,略,略,略,89.00
89,水浒传,施耐庵,略,略,略,99.00
19,测试,测试,测试,测试,测试,55.00
19,测试,测试,测试,测试,测试,35.00

根据书名查询图书
在这里插入图片描述
根据作者查询图书

一次性删除所有该登录号信息

199,西游记,吴承恩,I242.4,浙江古籍出版社,2010,35.00
199,鲁迅全集,鲁迅,略,略,略,900.00
199,呐喊,鲁迅,略,略,略,56.00
199,三国演义,罗贯中,略,略,略,79.00
89,红楼梦,曹雪芹,略,略,略,89.00
89,水浒传,施耐庵,略,略,略,99.00

在这里插入图片描述
没有登录号19的图书

删除图书

在这里插入图片描述
删除作者的图书

修改登录号下的图书

在这里插入图片描述

题目三代码

在这里插入图片描述

图书基本信息的查询
首先展示所有图书信息，再提供两个选项：1，根据图书名称查询图书；2，根据作者查询图书信息

保存图书信息，保存借书人信息

booksManagementSystem.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <string.h>

#define MAX_BOOKS 100
#define MAX_PEOPLE 100
#define BOOKS_FILE_NAME "books.bin"
#define PEOPLE_FILE_NAME "people.bin"

// 定义图书结构体
typedef struct {
    char name[50];         // 图书名称
    int number;            // 图书编号
    double price;          // 单价
    char author[50];       // 作者
    int status;            // 存在状态：0 表示可借，1 表示已借出
    char borrowerName[50]; // 借书人姓名
    char borrowerGender[10];// 借书人性别
    int borrowerID;        // 借书人学号
} Book;

// 定义借书人结构体
typedef struct {
    char name[50];     // 姓名
    char gender[10];   // 性别
    int studentID;     // 学号
} Person;

// 打印图书信息
void printBook(Book book);
// 打印借书人信息
void printPerson(Person person);
// 添加新图书的基本信息
void addBook(Book* books, int* count);
// 查询图书信息
void searchBook(Book* books, int count);
// 按书名查询图书信息
void searchBookByName(Book* books, int count);
// 按作者查询图书信息
void searchBookByAuthor(Book* books, int count);
// 删除指定编号的图书信息
void deleteBookByNumber(Book* books, int* count);
// 注册借书人信息
void registerBorrower(Person* people, int* count);
// 办理借书手续
void borrowBook(Book* books, int count, Person* people, int peopleCount);
// 办理还书手续
void returnBook(Book* books, int count);
// 查看所有借书人信息
void viewBorrowers(Person* people, int count);
// 将图书信息保存到文件
void saveBooksToFile(Book* books, int count);
// 从文件加载图书信息
void loadBooksFromFile(Book* books, int* count);
// 将借书人信息保存到文件
void savePeopleToFile(Person* people, int count);
// 从文件加载借书人信息
void loadPeopleFromFile(Person* people, int* count);

//菜单
void menu();

booksManagementSystem.c

#include"booksManagementSystem.h"

// 打印图书信息
void printBook(Book book) {
    printf("图书名称: %s\n", book.name);
    printf("图书编号: %d\n", book.number);
    printf("单价: %.2f\n", book.price);
    printf("作者: %s\n", book.author);
    if (book.status == 0) {
        printf("状态: 可借\n");
    }
    else {
        printf("状态: 已借出\n");
        printf("借书人姓名: %s\n", book.borrowerName);
        printf("借书人性别: %s\n", book.borrowerGender);
        printf("借书人学号: %d\n", book.borrowerID);
    }
    printf("\n");
}
// 打印借书人信息
void printPerson(Person person) {
    printf("姓名: %s\n", person.name);
    printf("性别: %s\n", person.gender);
    printf("学号: %d\n", person.studentID);
    printf("\n");
}
// 添加新图书的基本信息
void addBook(Book* books, int* count) {
    if (*count >= MAX_BOOKS) {
        printf("已达到最大容量，无法添加更多图书。\n");
        return;
    }
    Book* book = &books[*count];

    printf("请输入图书名称: ");
    scanf("%s", book->name);

    printf("请输入图书编号: ");
    scanf("%d", &book->number);

    printf("请输入单价: ");
    scanf("%lf", &book->price);

    printf("请输入作者: ");
    scanf("%s", book->author);

    book->status = 0; // 默认可借
    book->borrowerName[0] = '\0';
    book->borrowerGender[0] = '\0';
    book->borrowerID = 0;

    (*count)++;
    printf("图书信息录入成功\n");
}
// 查询图书信息
void searchBook(Book* books, int count) {
    printf("\n所有图书信息:\n");
    for (int i = 0; i < count; i++) {
        printBook(books[i]);
    }

    int choice;
    printf("\n请选择查询方式 (1-2):\n");
    printf("1. 根据图书名称查询\n");
    printf("2. 根据作者查询\n");
    printf("按其他为无效选择，返回上级菜单。\n");
    printf("请选择 (1-2): ");
    scanf("%d", &choice);

    switch (choice) {
    case 1:
        searchBookByName(books, count);
        break;
    case 2:
        searchBookByAuthor(books, count);
        break;
    default:
        printf("无效的选择，请重新选择。\n");
    }
}
// 按书名查询图书信息
void searchBookByName(Book* books, int count) {
    char name[50];
    printf("请输入书名进行查询: ");
    scanf("%s", name);

    int found = 0;
    for (int i = 0; i < count; i++) {
        if (strcmp(books[i].name, name) == 0) {
            printBook(books[i]);
            found = 1;
        }
    }
    if (!found) {
        printf("没有找到符合条件的图书。\n");
    }
}
// 按作者查询图书信息
void searchBookByAuthor(Book* books, int count) {
    char author[50];
    printf("请输入作者进行查询: ");
    scanf("%s", author);

    int found = 0;
    for (int i = 0; i < count; i++) {
        if (strcmp(books[i].author, author) == 0) {
            printBook(books[i]);
            found = 1;
        }
    }
    if (!found) {
        printf("没有找到符合条件的图书。\n");
    }
}
// 删除指定编号的图书信息
void deleteBookByNumber(Book* books, int* count) {
    int number;
    printf("请输入要删除的图书编号: ");
    scanf("%d", &number);

    int deleted = 0;
    for (int i = 0; i < *count; i++) {
        if (books[i].number == number) {
            for (int j = i; j < *count - 1; j++) {
                books[j] = books[j + 1];
            }
            (*count)--;
            printf("图书编号 %d 的图书信息已经删除。\n", number);
            deleted = 1;
            break;
        }
    }
    if (!deleted) {
        printf("没有找到符合条件的图书信息。\n");
    }
}
// 注册借书人信息
void registerBorrower(Person* people, int* count) {
    if (*count >= MAX_PEOPLE) {
        printf("已达到最大容量，无法添加更多借书人。\n");
        return;
    }
    Person* person = &people[*count];

    printf("请输入借书人姓名: ");
    scanf("%s", person->name);

    printf("请输入借书人性别: ");
    scanf("%s", person->gender);

    printf("请输入借书人学号: ");
    scanf("%d", &person->studentID);

    (*count)++;
    printf("借书人信息录入成功\n");
}
// 办理借书手续
void borrowBook(Book* books, int count, Person* people, int peopleCount) {
    int number;
    printf("请输入要借的图书编号: ");
    scanf("%d", &number);

    int found = 0;
    for (int i = 0; i < count; i++) {
        if (books[i].number == number && books[i].status == 0) {
            printf("请输入借书人学号: ");
            int studentID;
            scanf("%d", &studentID);

            int borrowerFound = 0;
            for (int j = 0; j < peopleCount; j++) {
                if (people[j].studentID == studentID) {
                    strcpy(books[i].borrowerName, people[j].name);
                    strcpy(books[i].borrowerGender, people[j].gender);
                    books[i].borrowerID = studentID;
                    books[i].status = 1;
                    printf("借书成功\n");
                    found = 1;
                    borrowerFound = 1;
                    break;
                }
            }

            if (!borrowerFound) {
                printf("没有找到该借书人信息。\n");
            }

            break;
        }
    }

    if (!found) {
        printf("没有找到符合条件的图书或图书已借出。\n");
    }
}
// 办理还书手续
void returnBook(Book* books, int count) {
    int number;
    printf("请输入要还的图书编号: ");
    scanf("%d", &number);

    int found = 0;
    for (int i = 0; i < count; i++) {
        if (books[i].number == number && books[i].status == 1) {
            books[i].status = 0;
            books[i].borrowerName[0] = '\0';
            books[i].borrowerGender[0] = '\0';
            books[i].borrowerID = 0;
            printf("还书成功\n");
            found = 1;
            break;
        }
    }

    if (!found) {
        printf("没有找到符合条件的图书或图书未借出。\n");
    }
}
// 查看所有借书人信息
void viewBorrowers(Person* people, int count) {
    if (count == 0) {
        printf("目前没有借书人信息。\n");
        return;
    }

    printf("借书人信息如下:\n");
    for (int i = 0; i < count; i++) {
        printPerson(people[i]);
    }
}
// 将图书信息保存到文件
void saveBooksToFile(Book* books, int count) {
    FILE* fp = fopen(BOOKS_FILE_NAME, "wb");
    if (fp == NULL) {
        printf("打开文件失败。\n");
        return;
    }

    fwrite(books, sizeof(Book), count, fp);
    fclose(fp);
    printf("图书信息保存成功。\n");
}
// 从文件加载图书信息
void loadBooksFromFile(Book* books, int* count) {
    FILE* fp = fopen(BOOKS_FILE_NAME, "rb");
    if (fp == NULL) {
        printf("打开文件失败。\n");
        return;
    }

    fseek(fp, 0, SEEK_END);
    *count = ftell(fp) / sizeof(Book);
    fseek(fp, 0, SEEK_SET);

    fread(books, sizeof(Book), *count, fp);
    fclose(fp);
    printf("图书信息加载成功。\n");
}
// 将借书人信息保存到文件
void savePeopleToFile(Person* people, int count) {
    FILE* fp = fopen(PEOPLE_FILE_NAME, "wb");
    if (fp == NULL) {
        printf("打开借书人文件失败。\n");
        return;
    }

    fwrite(people, sizeof(Person), count, fp);
    fclose(fp);
    printf("借书人信息保存成功。\n");
}
// 从文件加载借书人信息
void loadPeopleFromFile(Person* people, int* count) {
    FILE* fp = fopen(PEOPLE_FILE_NAME, "rb");
    if (fp == NULL) {
        printf("打开借书人文件失败。\n");
        return;
    }

    fseek(fp, 0, SEEK_END);
    *count = ftell(fp) / sizeof(Person);
    fseek(fp, 0, SEEK_SET);

    fread(people, sizeof(Person), *count, fp);
    fclose(fp);
    printf("借书人信息加载成功。\n");
}

void menu() {
    int choice;
    int bookCount = 0;
    int peopleCount = 0;
    Book books[MAX_BOOKS];
    Person people[MAX_PEOPLE];

    loadBooksFromFile(books, &bookCount);
    loadPeopleFromFile(people, &peopleCount);

    do {
        printf("\n");
        printf("+---------------------------+\n");
        printf("|        图书管理系统       |\n");
        printf("+---------------------------+\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("+---------------------------+\n");
        printf("请选择操作 (1-8): ");
        scanf("%d", &choice);

        switch (choice) {
        case 1:
            addBook(books, &bookCount);
            break;
        case 2:
            searchBook(books, bookCount);
            break;
        case 3:
            deleteBookByNumber(books, &bookCount);
            break;
        case 4:
            registerBorrower(people, &peopleCount);
            break;
        case 5:
            borrowBook(books, bookCount, people, peopleCount);
            break;
        case 6:
            returnBook(books, bookCount);
            break;
        case 7: 
            viewBorrowers(people, peopleCount);
            break;
        case 8:
            saveBooksToFile(books, bookCount);
            savePeopleToFile(people, peopleCount);
            printf("程序退出。\n");
            break;
        default:
            printf("无效的选择，请重新选择。\n");
        }
    } while (choice != 8);
}

test.c

#include"booksManagementSystem.h"

int main() {
    menu();
    return 0;
}

在这里插入图片描述

删除
在这里插入图片描述
注册，借书，还书

补充查询借书人信息，即借书人信息的保存和读取

题目四代码

在这里插入图片描述

equipmentManagement.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

#define EQUIPMENT_FILE_NAME "equipment.bin"
#define MAX_EQUIPMENT 100

//定义设备结构体
typedef struct {
    int id;               // 设备编号
    char type[50];        // 设备种类
    char name[50];        // 设备名称
    double price;         // 设备价格
    char purchaseDate[20]; // 购入日期
    int isScrapped;       // 是否报废 (0: 否, 1: 是)
    char scrappedDate[20]; // 报废日期
} Equipment;

// 设备的录入
void addEquipment(Equipment* equipment, int* count);
// 设备的修改
void modifyEquipment(Equipment* equipment, int count);
// 设备的分类统计
void classifyEquipment(Equipment* equipment, int count);
// 设备报废信息
void handleEquipmentDamage(Equipment* equipment, int count);
// 展示所有的设备信息
void displayAllEquipment(Equipment* equipment, int count);
// 按编号查询设备
void searchEquipmentById(Equipment* equipment, int count);
// 文件读写
void saveEquipmentToFile(Equipment* equipment, int count);
// 文件读取
void loadEquipmentFromFile(Equipment* equipment, int* count);
// 菜单
void menu();

equipmentManagement.c

#include"equipmentManagement.h"
// 设备的录入
void addEquipment(Equipment* equipment, int* count) {
    if (*count >= MAX_EQUIPMENT) {
        printf("已达到最大容量，无法添加更多设备。\n");
        return;
    }

    Equipment* eq = &equipment[*count];

    printf("请输入设备编号: ");
    scanf("%d", &eq->id);

    printf("请输入设备种类: ");
    scanf("%s", eq->type);

    printf("请输入设备名称: ");
    scanf("%s", eq->name);

    printf("请输入设备价格: ");
    scanf("%lf", &eq->price);

    printf("请输入购入日期 (格式: YYYY-MM-DD): ");
    scanf("%s", eq->purchaseDate);

    eq->isScrapped = 0; // 默认未报废
    eq->scrappedDate[0] = '\0'; // 默认报废日期为空

    (*count)++;
    printf("设备信息录入成功\n");
}
// 设备的修改
void modifyEquipment(Equipment* equipment, int count) {
    int id;
    printf("请输入要修改的设备编号: ");
    scanf("%d", &id);

    int found = 0;
    for (int i = 0; i < count; i++) {
        if (equipment[i].id == id) {
            printf("请选择修改项:\n");
            printf("1. 设备种类\n");
            printf("2. 设备名称\n");
            printf("3. 设备价格\n");
            printf("4. 购入日期\n");
            printf("5. 是否报废\n");
            printf("6. 报废日期\n");
            printf("请选择 (1-6): ");
            int choice;
            scanf("%d", &choice);

            switch (choice) {
            case 1:
                printf("请输入新的设备种类: ");
                scanf("%s", equipment[i].type);
                break;
            case 2:
                printf("请输入新的设备名称: ");
                scanf("%s", equipment[i].name);
                break;
            case 3:
                printf("请输入新的设备价格: ");
                scanf("%lf", &equipment[i].price);
                break;
            case 4:
                printf("请输入新的购入日期 (格式: YYYY-MM-DD): ");
                scanf("%s", equipment[i].purchaseDate);
                break;
            case 5:
                printf("请输入是否报废 (0: 否, 1: 是): ");
                scanf("%d", &equipment[i].isScrapped);
                break;
            case 6:
                if (equipment[i].isScrapped == 1) {
                    printf("请输入新的报废日期 (格式: YYYY-MM-DD): ");
                    scanf("%s", equipment[i].scrappedDate);
                }
                else {
                    printf("设备未报废，无法设置报废日期。\n");
                }
                break;
            default:
                printf("无效的选择，请重新选择。\n");
            }

            printf("设备信息修改成功\n");
            found = 1;
            break;
        }
    }

    if (!found) {
        printf("没有找到符合条件的设备。\n");
    }
}
// 设备的分类统计
void classifyEquipment(Equipment* equipment, int count) {
    char type[50];
    printf("请输入要统计的设备种类: ");
    scanf("%s", type);

    int countOfType = 0;
    for (int i = 0; i < count; i++) {
        if (strcmp(equipment[i].type, type) == 0) {
            countOfType++;
        }
    }

    printf("共有 %d 台 %s 类型的设备。\n", countOfType, type);
    // 输出该类型的所有设备信息
    printf("\n+--------------------------------------------------------------+\n");
    printf("|                       该类所有设备信息                       |\n");
    printf("+--------------------------------------------------------------+\n");
    printf("|编号| 种类 | 名称 | 价格 |  购入日期  | 是否报废 |  报废日期  |\n");
    printf("+--------------------------------------------------------------+\n");

    for (int i = 0; i < count; i++) {
        printf("|%-4d| %-8s | %-8s |%-8.2f|%-10s|%-2d|%-10s|\n",
            equipment[i].id,
            equipment[i].type,
            equipment[i].name,
            equipment[i].price,
            equipment[i].purchaseDate,
            equipment[i].isScrapped,
            equipment[i].scrappedDate);
        printf("+--------------------------------------------------------------+\n");
    }
}
// 设备报废信息
void handleEquipmentDamage(Equipment* equipment, int count) {
    int id;
    printf("请输入要处理的设备编号: ");
    scanf("%d", &id);

    int found = 0;
    for (int i = 0; i < count; i++) {
        if (equipment[i].id == id) {
            if (equipment[i].isScrapped == 0) {
                printf("该设备尚未报废，是否报废 (0: 否, 1: 是): ");
                scanf("%d", &equipment[i].isScrapped);

                if (equipment[i].isScrapped == 1) {
                    printf("请输入报废日期 (格式: YYYY-MM-DD): ");
                    scanf("%s", equipment[i].scrappedDate);
                }
            }
            else {
                printf("该设备已报废。\n");
            }

            printf("设备处理成功\n");
            found = 1;
            break;
        }
    }

    if (!found) {
        printf("没有找到符合条件的设备。\n");
    }
}
// 展示所有设备信息
void displayAllEquipment(Equipment* equipment, int count) {
    if (count == 0) {
        printf("当前没有设备信息。\n");
        return;
    }

    printf("\n+--------------------------------------------------------------+\n");
    printf("|                          所有设备信息                        |\n");
    printf("+--------------------------------------------------------------+\n");
    printf("|编号| 种类 | 名称 | 价格 |  购入日期  | 是否报废 |  报废日期  |\n");
    printf("+--------------------------------------------------------------+\n");

    for (int i = 0; i < count; i++) {
        printf("|%-4d| %-8s | %-8s |%-8.2f|%-10s|%-2d|%-10s|\n",
            equipment[i].id,
            equipment[i].type,
            equipment[i].name,
            equipment[i].price,
            equipment[i].purchaseDate,
            equipment[i].isScrapped,
            equipment[i].scrappedDate);
        printf("+--------------------------------------------------------------+\n");
    }
}
// 按编号查询设备
void searchEquipmentById(Equipment* equipment, int count) {
    int id;
    printf("请输入要查询的设备编号: ");
    scanf("%d", &id);

    int found = 0;
    for (int i = 0; i < count; i++) {
        if (equipment[i].id == id) {
            printf("设备编号: %d\n", equipment[i].id);
            printf("设备种类: %s\n", equipment[i].type);
            printf("设备名称: %s\n", equipment[i].name);
            printf("设备价格: %.2f\n", equipment[i].price);
            printf("购入日期: %s\n", equipment[i].purchaseDate);
            if (equipment[i].isScrapped == 0) {
                printf("是否报废: 否\n");
            }
            else {
                printf("是否报废: 是\n");
                printf("报废日期: %s\n", equipment[i].scrappedDate);
            }
            printf("\n");
            found = 1;
            break;
        }
    }

    if (!found) {
        printf("没有找到符合条件的设备。\n");
    }
}
// 文件读写
void saveEquipmentToFile(Equipment* equipment, int count) {
    FILE* fp = fopen(EQUIPMENT_FILE_NAME, "wb");
    if (fp == NULL) {
        printf("打开设备文件失败。\n");
        return;
    }

    fwrite(equipment, sizeof(Equipment), count, fp);
    fclose(fp);
    printf("设备信息保存成功。\n");
}
// 文件读取
void loadEquipmentFromFile(Equipment* equipment, int* count) {
    FILE* fp = fopen(EQUIPMENT_FILE_NAME, "rb");
    if (fp == NULL) {
        printf("打开设备文件失败。\n");
        return;
    }
    fseek(fp, 0, SEEK_END);
    *count = ftell(fp) / sizeof(Equipment);
    fseek(fp, 0, SEEK_SET);

    fread(equipment, sizeof(Equipment), *count, fp);
    printf("已加载实验设备文件信息。\n");

    fclose(fp);

}

// 主菜单
void menu() {
    int choice;
    int equipmentCount = 0;
    Equipment equipment[MAX_EQUIPMENT];

    loadEquipmentFromFile(equipment, &equipmentCount);

    do {
        printf("\n");
        printf("+---------------------------+\n");
        printf("|        设备管理系统       |\n");
        printf("+---------------------------+\n");
        printf("| 1. 录入设备信息           |\n");
        printf("| 2. 修改设备信息           |\n");
        printf("| 3. 分类统计设备           |\n");
        printf("| 4. 修改设备报废信         |\n");
        printf("| 5. 展示所有的设备信息     |\n");
        printf("| 6. 按编号查询设备信息     |\n");
        printf("| 7. 保存并退出             |\n");
        printf("+---------------------------+\n");
        printf("请选择操作 (1-7): ");
        scanf("%d", &choice);

        switch (choice) {
        case 1:
            addEquipment(equipment, &equipmentCount);
            break;
        case 2:
            modifyEquipment(equipment, equipmentCount);
            break;
        case 3:
            classifyEquipment(equipment, equipmentCount);
            break;
        case 4:
            handleEquipmentDamage(equipment, equipmentCount);
            break;
        case 5:
            displayAllEquipment(equipment, equipmentCount);
            break;
        case 6:
            searchEquipmentById(equipment, equipmentCount);
            break;
        case 7:
            saveEquipmentToFile(equipment, equipmentCount);
            printf("程序退出。\n");
            break;
        default:
            printf("无效的选择，请重新选择。\n");
        }
    } while (choice != 7);
}

test.c

#include"equipmentManagement.h"

int main() {
    menu();
    return 0;
}

在这里插入图片描述

题目五代码

先学习一下键盘事件
百度搜菜鸟教程->C/C++ 获取键盘事件
https://www.runoob.com/w3cnote/c-get-keycode.html#:~:text=C/C++%20%E8%8E%B7%E5%8F%96%E9%94%AE%E7%9B%98

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<conio.h>  //用于获取键盘输入
#include<Windows.h>

#define MAX_MENU_ITEMS 10

typedef struct {
	char name[50];
}MenuItem;

void drawMenu(MenuItem* items, int itemCount, int selectedItem){
	system("cls");
	printf("\n");
	printf("+-----------------------------+\n");
	printf("|         西文下拉菜单        |\n");
	printf("+-----------------------------+\n");

	for (int i = 0; i < itemCount; i++) {
		if (i == selectedItem) {
			//当前选中项反相显示
			printf("| [>] %-23s |\n", items[i].name);  
		}
		else {
			printf("|    %-24s |\n", items[i].name);
		}
	}
	printf("+-----------------------------+\n");
}

int main() {
	MenuItem menu[MAX_MENU_ITEMS] = {
		{"新建文件"},
		{"打开文件"},
		{"保存文件"},
		{"另存为"},
		{"关闭文件"},
		{"测试文本"},
		{"测试文本"},
		{"测试文本"},
		{"测试文本"},
		{"退出"}
	};
	//计算menu长度
	int itemCount = sizeof(menu) / sizeof(menu[0]);
	int selectedItem = 0;

	while (1) {
		drawMenu(menu, itemCount, selectedItem);
		// 获取键盘输入
		int key = _getch();
		switch (key) {
			// 上箭头
		case 72:
			if (selectedItem > 0) {
				selectedItem--;
			}
			break;
			// 下箭头
		case 80:
			if (selectedItem < itemCount - 1) {
				selectedItem++;
			}
			break;
			//回车键
		case 13:
			printf("\n选择了: %s \n", menu[selectedItem].name);
			Sleep(1000);
			break;
		}
	}
	return 0;
}

在这里插入图片描述

设计子菜单

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<conio.h>  //用于获取键盘输入
#include<Windows.h>

// 主菜单最多显示多少行
#define MAX_MENU_ITEMS 10
// 子菜单最多显示多少行
#define MAX_SUBMENU_ITEMS 5

typedef struct {
	char name[50];
	//子菜单数量
	int submenuCount;
	//子菜单以数组存储
	char submenu[MAX_SUBMENU_ITEMS][50];
}MenuItem;

// 西文下拉菜单
void drawMenu(MenuItem* items, int itemCount, int selectedItem,int subMenuIndex){
	system("cls");
	printf("\n");
	printf("+-----------------------------+\n");
	printf("|         西文下拉菜单        |\n");
	printf("+-----------------------------+\n");

	for (int i = 0; i < itemCount; i++) {
		if (i == selectedItem) {
			//当前选中项反相显示
			printf("| [>] %-23s |\n", items[i].name);  
		}
		else {
			printf("|    %-24s |\n", items[i].name);
		}
	}
	printf("+-----------------------------+\n");

	if (subMenuIndex != -1 && items[selectedItem].submenuCount > 0) {
		printf("\n+-----------------------------+\n");
		printf("|     子菜单: %s     |\n", items[selectedItem].name);
		printf("+-----------------------------+\n");

		for (int j = 0; j < items[selectedItem].submenuCount; j++) {
			if (j == subMenuIndex) {
				// 当前选中项反相显示
				printf("| [>] %-23s |\n", items[selectedItem].submenu[j]);
			}
			else {
				printf("|    %-24s |\n", items[selectedItem].submenu[j]);
			}
		}
		printf("+-----------------------------+\n");
	}
}

int main() {
	MenuItem menu[MAX_MENU_ITEMS] = {
		{"新建文件",0},
		{"打开文件",0},
		{"保存文件",0},
		{"另存为",0},
		{"关闭文件",0},
		{"测试子菜单",3,{"子菜单1", "子菜单2", "子菜单3"}},
		{"测试文本",2,{"子菜单A", "子菜单B"}},
		{"测试文本",0},
		{"退出",0}
	};
	//计算menu长度
	int itemCount = sizeof(menu) / sizeof(menu[0]);
	int selectedItem = 0;
	// 
	int subMenuIndex = -1;

	while (1) {
		drawMenu(menu, itemCount, selectedItem,subMenuIndex);
		// 获取键盘输入
		int key = _getch();
		switch (key) {
		// 上箭头
		case 72:
			if (subMenuIndex != -1 && selectedItem < itemCount && menu[selectedItem].submenuCount > 0) {
				if (selectedItem > 0) {
					selectedItem--;
				}
			}
			else {
				if (selectedItem > 0) {
					selectedItem--;
					subMenuIndex = -1;
				}
			}
			break;
		// 下箭头
		case 80:
			if (subMenuIndex != -1 && selectedItem < itemCount && menu[selectedItem].submenuCount > 0) {
				if (subMenuIndex < menu[selectedItem].submenuCount - 1) {
					subMenuIndex++;
				}
			}
			else {
				if (selectedItem < itemCount - 1) {
					selectedItem++;
					subMenuIndex = -1;
				}
			}
			break;
			
		// 左箭头
		case 75:  
			if (subMenuIndex != -1 && selectedItem < itemCount && menu[selectedItem].submenuCount > 0) {
				subMenuIndex = -1;
			}
			break;
		// 右箭头
		case 77: 
			if (selectedItem < itemCount && menu[selectedItem].submenuCount > 0) {
				subMenuIndex = 0;
			}
			break;
		//回车键
		case 13: 
			if (subMenuIndex == -1) {
				printf("\n选择了: %s\n", menu[selectedItem].name);
			}
			else {
				printf("\n选择了: %s -> %s\n", menu[selectedItem].name, menu[selectedItem].submenu[subMenuIndex]);
			}
			Sleep(1000);
			break;
		}
	}
	return 0;
}

在这里插入图片描述

题目六代码

studentInformationManagement.c

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable : 6031)
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define STUDENTS_FILE "students.dat"
#define MAX_STUDENTS 100

typedef struct {
	// 你说学号会不会有英文符号呢?  本来写的int类型,身份证号都有一个X,那学号写成char
	// 学号不能带\0  警告	C6054	可能没有为字符串“id”添加字符串零终止符。
	char id[20];
	char name[50];
	int age;
	char gender[10];
	char birth[20];
	char address[100];
	char phone[20];
	char email[50];
}Student;

// 确定Win/Linux操作系统,清屏
void clearScreen();
// 保存学生信息
void saveStudentsToFile(Student students[], int count);
// 加载学生信息(每次启动程序,加载信息)
void loadStudentsFromFile(Student students[], int* count);
// 添加学生信息
void addStudent(Student students[], int* count);
// 展示所有学生信息
void displayStudents(Student students[], int count);
// 根据学号查询学生信息
void searchStudentById(Student students[], int count);
// 根据姓名查询学生信息
void searchStudentByName(Student students[], int count);
// 根据学号删除学生信息
void deleteStudentById(Student students[], int* count);
// 修改学生信息
void modifyStudentById(Student students[], int count);

studentInformationManagement.c

#include"studentInformationManagement.h"


// 确定Win/Linux操作系统,清屏
void clearScreen() {
#ifdef _WIN32
    system("cls");
#else
    system("clear");
#endif
}

// 保存学生信息
void saveStudentsToFile(Student students[], int count) {
    FILE* file = fopen(STUDENTS_FILE, "wb");
    if (file == NULL) {
        printf("无法打开文件 %s !\n", STUDENTS_FILE);
        return;
    }
    fwrite(students, sizeof(Student), count, file);
    fclose(file);
}

// 加载学生信息
void loadStudentsFromFile(Student students[], int* count) {
    FILE* file = fopen(STUDENTS_FILE, "rb");
    if (file == NULL) {
        printf("无法打开文件 %s!\n", STUDENTS_FILE);
        *count = 0;
        return;
    }
    size_t temporaryCount = fread(students, sizeof(Student), MAX_STUDENTS, file);
    printf("读取了 %zu 条记录。\n", temporaryCount);
    *count = (int)temporaryCount;
    fclose(file);
}

// 添加学生信息
void addStudent(Student students[], int* count) {
    if (*count >= MAX_STUDENTS) {
        printf("学生信息已满，无法继续添加。\n");
        return;
    }
    Student newStudent;
    printf("请输入学号: ");
    scanf("%s", newStudent.id);
    printf("请输入姓名: ");
    scanf("%s", newStudent.name);
    printf("请输入年龄: ");
    while (scanf("%d", &newStudent.age) != 1 || newStudent.age <= 0) {
        printf("年龄输入无效，请重新输入: ");
        while (getchar() != '\n');
    }
    printf("请输入性别: ");
    scanf("%s", newStudent.gender);
    printf("请输入出生年月: ");
    scanf("%s", newStudent.birth);
    printf("请输入地址: ");
    scanf("%s", newStudent.address);
    printf("请输入电话: ");
    scanf("%s", newStudent.phone);
    printf("请输入E-mail: ");
    scanf("%s", newStudent.email);

    students[*count] = newStudent;
    (*count)++;
    saveStudentsToFile(students, *count);
    printf("学生信息已保存。\n");
}

// 展示所有学生信息
void displayStudents(Student students[], int count) {
    printf("\n+-----------------------------------+\n");
    printf("|          学生信息列表             |\n");
    printf("+-----------------------------------+\n");
    printf("| 学号 | 姓名 | 年龄 | 性别 | 出生年月 | 地址 | 电话 | E-mail |\n");
    printf("+-----------------------------------+\n");

    for (int i = 0; i < count; i++) {
        printf("| %-6s | %-6s | %-3d | %-6s | %-10s | %-10s | %-10s | %-10s |\n",
            students[i].id, students[i].name, students[i].age, students[i].gender,
            students[i].birth, students[i].address, students[i].phone, students[i].email);
    }
    printf("+-----------------------------------+\n");
}

// 通过学生id找到索引
int findStudentIndexById(Student students[], int count, const char* id) {
    for (int i = 0; i < count; i++) {
        if (strcmp(students[i].id, id) == 0) {
            return i;
        }
    }
    return -1;
}

// 通过学生名字找到索引
int findStudentIndexByName(Student students[], int count, const char* name) {
    for (int i = 0; i < count; i++) {
        if (strcmp(students[i].name, name) == 0) {
            return i;
        }
    }
    return -1;
}

// 展示单个学生信息
void displayStudent(Student student) {
    printf("\n+-----------------------------------+\n");
    printf("|          学生信息                 |\n");
    printf("+-----------------------------------+\n");
    printf("| 学号 | 姓名 | 年龄 | 性别 | 出生年月 | 地址 | 电话 | E-mail |\n");
    printf("+-----------------------------------+\n");
    printf("| %-6s | %-6s | %-3d | %-6s | %-10s | %-10s | %-10s | %-10s |\n",
        student.id, student.name, student.age, student.gender,
        student.birth, student.address, student.phone, student.email);
    printf("+-----------------------------------+\n");
}

// 通过学生id查询学生信息
void searchStudentById(Student students[], int count) {
    char id[20];
    printf("请输入要查询的学生学号: ");
    scanf("%19s", id);
    int index = findStudentIndexById(students, count, id);
    if (index != -1) {
        displayStudent(students[index]);
    }
    else {
        printf("未找到学号为 %s 的学生。\n", id);
    }
}

// 通过学生姓名查询学生信息
void searchStudentByName(Student students[], int count) {
    char name[50];
    printf("请输入要查询的学生姓名: ");
    scanf("%49s", name);
    int index = findStudentIndexByName(students, count, name);
    if (index != -1) {
        displayStudent(students[index]);
    }
    else {
        printf("未找到姓名为 %s 的学生。\n", name);
    }
}

// 根据学号删除学生信息
void deleteStudentById(Student students[], int* count) {
    char id[20];
    printf("请输入要删除的学号: ");
    scanf("%s", id);

    for (int i = 0; i < *count; i++) {
        if (strcmp(students[i].id, id) == 0) {
            printf("确认删除学生 %s 吗？(y/n): ", students[i].name);
            char confirm;
            scanf(" %c", &confirm);
            if (confirm == 'y' || confirm == 'Y') {
                for (int j = i; j < *count - 1; j++) {
                    students[j] = students[j + 1];
                }
                (*count)--;
                saveStudentsToFile(students, *count);
                printf("学生信息已删除。\n");
            }
            else {
                printf("取消删除。\n");
            }
            return;
        }
    }
    printf("未找到该学号的学生信息。\n");
}

// 修改学生信息
void modifyStudentById(Student students[], int count) {
    char id[20];
    printf("请输入要修改的学号: ");
    scanf("%s", id);
    int found = 0;
    for (int i = 0; i < count; i++) {
        if (strcmp(students[i].id, id) == 0) {
            printf("请选择要修改的信息:\n");
            printf("1. 姓名\n");
            printf("2. 年龄\n");
            printf("3. 性别\n");
            printf("4. 出生年月\n");
            printf("5. 地址\n");
            printf("6. 电话\n");
            printf("7. E-mail\n");
            int choice;
            printf("请输入选项: ");
            scanf("%d", &choice);
            switch (choice) {
            case 1:
                printf("请输入新的姓名: ");
                scanf("%s", students[i].name);
                break;
            case 2:
                printf("请输入新的年龄: ");
                scanf("%d", &students[i].age);
                break;
            case 3:
                printf("请输入新的性别: ");
                scanf("%s", students[i].gender);
                break;
            case 4:
                printf("请输入新的出生年月: ");
                scanf("%s", students[i].birth);
                break;
            case 5:
                printf("请输入新的地址: ");
                scanf("%s", students[i].address);
                break;
            case 6:
                printf("请输入新的电话: ");
                scanf("%s", students[i].phone);
                break;
            case 7:
                printf("请输入新的E-mail: ");
                scanf("%s", students[i].email);
                break;
            default:
                printf("无效的选择。\n");
                break;
            }
            saveStudentsToFile(students, count);
            printf("学生信息已修改。\n");
            found = 1;
            break;
        }
    }
}

void menu() {
    printf("\n+-----------------------------------+\n");
    printf("|       学生信息管理系统            |\n");
    printf("+-----------------------------------+\n");
    printf("| 1. 添加学生信息                   |\n");
    printf("| 2. 显示所有学生信息               |\n");
    printf("| 3. 按学号查询学生信息             |\n");
    printf("| 4. 按姓名查询学生信息             |\n");
    printf("| 5. 删除学生信息                   |\n");
    printf("| 6. 修改学生信息                   |\n");
    printf("| 7. 退出系统                       |\n");
    printf("+-----------------------------------+\n");
    printf("请选择功能: ");
}

void runMenu() {
    Student students[MAX_STUDENTS];
    int count = 0;
    loadStudentsFromFile(students, &count);

    int choice;
    do {
        menu();
        scanf("%d", &choice);
        switch (choice) {
        case 1:
            addStudent(students, &count);
            break;
        case 2:
            displayStudents(students, count);
            break;
        case 3:
            searchStudentById(students, count);
            break;
        case 4:
            searchStudentByName(students, count);
            break;
        case 5:
            deleteStudentById(students, &count);
            break;
        case 6:
            modifyStudentById(students, count);
            break;
        case 7:
            printf("退出程序\n");
            break;
        default:
            printf("无效的输入,请重新输入\n");
            break;
        }
        getchar();
        system("pause");
        clearScreen();
    } while (choice != 7);
}

test.c

#include"studentInformationManagement.h"
int main() {
    runMenu();
    return 0;
}

在这里插入图片描述

项目七代码

在这里插入图片描述
studentPerformance.h

#define _CRT_SECURE_NO_WARNINGS 
#pragma warning(disable:6031)
#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define STUDENTS_FILE "students.dat"
#define MAX_STUDENTS 100
#define MIN_PASS_SCORE 60

typedef struct {
    char term[20];      // 学期
    char student_id[20]; // 学号
    char class_name[20]; // 班级
    char name[50];      // 姓名
    int chinese;        // 语文成绩
    int math;           // 数学成绩
    int english;        // 英语成绩
    int computer;       // 计算机成绩
} Student;

// 函数声明
void clearScreen();
void saveStudentsToFile(Student students[], int count);
void loadStudentsFromFile(Student students[], int* count);
void inputStudentInfo(Student* student);
void addStudent(Student students[], int* count);
void modifyStudent(Student students[], int count);
void calculateStatistics(Student students[], int count);
void searchStudent(Student students[], int count);
void printReportCard(Student students[], int count);
void mainMenu(Student students[], int* count);

studentPerformance.c

#include"studentPerformance.h"


// 确定Win/Linux操作系统,清屏
void clearScreen() {
#ifdef _WIN32
    system("cls");
#else
    system("clear");
#endif
}

// 保存学生信息
void saveStudentsToFile(Student students[], int count) {
    FILE* file = fopen(STUDENTS_FILE, "wb");
    if (file == NULL) {
        printf("无法打开文件 %s!\n", STUDENTS_FILE);
        return;
    }
    fwrite(students, sizeof(Student), count, file);
    fclose(file);
}

// 加载学生信息
void loadStudentsFromFile(Student students[], int* count) {
    FILE* file = fopen(STUDENTS_FILE, "rb");
    if (file == NULL) {
        printf("无法打开文件 %s!\n", STUDENTS_FILE);
        *count = 0;
        return;
    }
    size_t numRead = fread(students, sizeof(Student), MAX_STUDENTS, file);
    *count = (int)numRead;
    fclose(file);
}

// 输入学生信息
void inputStudentInfo(Student* student) {
    printf("请输入学期: ");
    scanf("%s", student->term);
    printf("请输入学号: ");
    scanf("%s", student->student_id);
    printf("请输入班级: ");
    scanf("%s", student->class_name);
    printf("请输入姓名: ");
    scanf("%s", student->name);
    printf("请输入语文成绩: ");
    scanf("%d", &student->chinese);
    printf("请输入数学成绩: ");
    scanf("%d", &student->math);
    printf("请输入英语成绩: ");
    scanf("%d", &student->english);
    printf("请输入计算机成绩: ");
    scanf("%d", &student->computer);
}

// 添加学生信息
void addStudent(Student students[], int* count) {
    if (*count >= MAX_STUDENTS) {
        printf("学生信息已满，无法继续添加。\n");
        return;
    }
    Student newStudent;
    inputStudentInfo(&newStudent);
    students[*count] = newStudent;
    (*count)++;
    saveStudentsToFile(students, *count);
    printf("学生信息已保存。\n");
}

// 修改学生信息
void modifyStudent(Student students[], int count) {
    char student_id[20];
    printf("请输入要修改的学号: ");
    scanf("%s", student_id);

    int found = 0;
    for (int i = 0; i < count; i++) {
        if (strcmp(students[i].student_id, student_id) == 0) {
            printf("找到的学生信息:\n");
            printf("学期: %s\n", students[i].term);
            printf("学号: %s\n", students[i].student_id);
            printf("班级: %s\n", students[i].class_name);
            printf("姓名: %s\n", students[i].name);
            printf("语文成绩: %d\n", students[i].chinese);
            printf("数学成绩: %d\n", students[i].math);
            printf("英语成绩: %d\n", students[i].english);
            printf("计算机成绩: %d\n", students[i].computer);

            inputStudentInfo(&students[i]);

            saveStudentsToFile(students, count);
            printf("学生信息已更新。\n");
            found = 1;
            break;
        }
    }
    if (!found) {
        printf("未找到该学号的学生信息。\n");
    }
}

// 统计学生成绩
void calculateStatistics(Student students[], int count) {
    char class_name[20];
    printf("请输入要统计的班级: ");
    scanf("%s", class_name);

    int totalStudents = 0;
    double totalScore = 0;
    double averageScore = 0;

    for (int i = 0; i < count; i++) {
        if (strcmp(students[i].class_name, class_name) == 0) {
            int total = students[i].chinese + students[i].math + students[i].english + students[i].computer;
            totalScore += total;
            totalStudents++;
        }
    }

    if (totalStudents > 0) {
        averageScore = totalScore / totalStudents;
        printf("班级 %s 的总人数: %d\n", class_name, totalStudents);
        printf("班级 %s 的总分: %.2f\n", class_name, totalScore);
        printf("班级 %s 的平均分: %.2f\n", class_name, averageScore);
    }
    else {
        printf("未找到该班级的学生信息。\n");
    }
}

// 查询学生成绩
void searchStudent(Student students[], int count) {
    char student_id[20];
    printf("请输入要查询的学号: ");
    scanf("%s", student_id);

    int found = 0;
    for (int i = 0; i < count; i++) {
        if (strcmp(students[i].student_id, student_id) == 0) {
            printf("\n找到的学生信息:\n");
            printf("学期: %s\n", students[i].term);
            printf("学号: %s\n", students[i].student_id);
            printf("班级: %s\n", students[i].class_name);
            printf("姓名: %s\n", students[i].name);
            printf("语文成绩: %d\n", students[i].chinese);
            printf("数学成绩: %d\n", students[i].math);
            printf("英语成绩: %d\n", students[i].english);
            printf("计算机成绩: %d\n", students[i].computer);

            int total = students[i].chinese + students[i].math + students[i].english + students[i].computer;
            printf("总分: %d\n", total);

            printf("不及格科目:\n");
            if (students[i].chinese < MIN_PASS_SCORE) printf("语文\n");
            if (students[i].math < MIN_PASS_SCORE) printf("数学\n");
            if (students[i].english < MIN_PASS_SCORE) printf("英语\n");
            if (students[i].computer < MIN_PASS_SCORE) printf("计算机\n");

            found = 1;
            break;
        }
    }
    if (!found) {
        printf("未找到该学号的学生信息。\n");
    }
}

// 输出学生成绩单
void printReportCard(Student students[], int count) {
    char class_name[20];
    printf("请输入要输出成绩单的班级: ");
    scanf("%s", class_name);

    int found = 0;
    printf("\n+-----------------------------------+\n");
    printf("|         学生成绩单                |\n");
    printf("+-----------------------------------+\n");
    printf("| 学期 | 学号 | 班级 | 姓名 | 语文 | 数学 | 英语 | 计算机 |\n");
    printf("+-----------------------------------+\n");

    for (int i = 0; i < count; i++) {
        if (strcmp(students[i].class_name, class_name) == 0) {
            printf("| %-6s | %-6s | %-6s | %-6s | %-3d | %-3d | %-3d | %-3d |\n",
                students[i].term, students[i].student_id, students[i].class_name,
                students[i].name, students[i].chinese, students[i].math,
                students[i].english, students[i].computer);
            found = 1;
        }
    }

    if (!found) {
        printf("未找到该班级的学生信息。\n");
    }
    printf("+-----------------------------------+\n");
}

// 函数菜单
void mainMenu(Student students[], int* count) {
    int choice;
    do {
        clearScreen();
        printf("学生成绩管理系统\n");
        printf("1. 录入学生成绩\n");
        printf("2. 修改学生成绩\n");
        printf("3. 统计学生成绩\n");
        printf("4. 查询学生成绩\n");
        printf("5. 输出学生成绩单\n");
        printf("6. 退出系统\n");
        printf("请选择功能: ");
        scanf("%d", &choice);

        switch (choice) {
        case 1:
            addStudent(students, count);
            break;
        case 2:
            modifyStudent(students, *count);
            break;
        case 3:
            calculateStatistics(students, *count);
            break;
        case 4:
            searchStudent(students, *count);
            break;
        case 5:
            printReportCard(students, *count);
            break;
        case 6:
            printf("退出系统。\n");
            break;
        default:
            printf("无效的选择，请重新输入。\n");
            break;
        }

        getchar(); // 清除输入缓冲区中的换行符
        system("pause"); // 暂停程序，等待用户按键
    } while (choice != 6);
}

test.c

#include"studentPerformance.h"

int main() {
    int count = 0;
    Student students[MAX_STUDENTS];

    loadStudentsFromFile(students, &count);
    mainMenu(students, &count);
    saveStudentsToFile(students, count);

    return 0;
}

题目十九代码

在这里插入图片描述

calendar.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include"stdio.h"
#include"time.h"
#include"windows.h"
//判断闰年
int isLeapYear(int year);
//获取每个月的天数
int getDaysInMonth(int year, int month);
//获取某年某月某日的星期几 {星期日:0, 星期一 : 1星期二 : 2, 星期三 : 3, 星期四 : 4, 星期五 : 5, 星期六 : 6}
int getWeekday(int year, int month, int day);
//显示日历
void displayCalender(int year, int month);
// 运行年历系统
void runCalendar();

calendar.c

#include"calendar.h"

//判断闰年
int isLeapYear(int year) {
	return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

//获取每个月的天数
int getDaysInMonth(int year, int month) {
	switch (month)
	{
	case 1:case 3:case 5:case 7: case 8:case 10:case 12:
		return 31;
	case 4:case 6: case 9: case 11:
		return 30;
	case 2:
		return isLeapYear(year) ? 29 : 28;
	default:
		return 0;
	}
}


//获取某年某月某日的星期几 
// {星期日:0, 星期一 : 1星期二 : 2, 
// 星期三 : 3, 星期四 : 4, 星期五 : 5, 星期六 : 6}
int getWeekday(int year, int month, int day) {
	
	struct tm time_in = { 0 };
	//tm_year是从1900年开始算的
	time_in.tm_year = year - 1900;
	//tm_mon是0到11表示1月到12月
	time_in.tm_mon = month - 1;
	time_in.tm_mday = day;
	//通过mktime函数计算星期几
	mktime(&time_in);
	return time_in.tm_wday;
}

//显示日历
void displayCalender(int year, int month) {
	printf("===== %d年 %d月 =====\n", year, month);
	printf("日 一 二 三 四 五 六\n");

	//计算某年某月有多少天
	int daysInMonth = getDaysInMonth(year, month);
	//计算出某年某月的1号是星期几
	int startDay = getWeekday(year, month, 1);

	//打印空白,一个中文字符占2个空格,间隔是一个空格,所以打印三个空格
	for (int i = 0; i < startDay; i++) {
		printf("   ");
	}
	//打印日期  
	for (int j = 1; j <= daysInMonth; j++) {
		printf("%2d ", j);
		//一星期最后一天换行
		if ((j + startDay) % 7 == 0) {
			printf("\n");
		}
	}
	printf("\n");
}
//运行日历
void runCalendar(){
	time_t now = time(NULL);
	struct tm* t = localtime(&now);

	//获取当年年份
	int currentYear = t->tm_year + 1900;
	//获取当前月份
	int currentMonth = t->tm_mon + 1;

	displayCalender(currentYear, currentMonth);
	
	while (1) {
		time_t newNow = time(NULL);
		struct tm* new_t = localtime(&newNow);

		int newYear = new_t->tm_year + 1900;
		int newMonth = new_t->tm_mon + 1;

		//检查是否进入下一个月
		if (newMonth != currentMonth || newYear != currentYear) {
			currentYear = newYear;
			currentMonth = newMonth;
			displayCalender(currentYear, currentMonth);
		}
		//每隔一分钟检查一次
		Sleep(60000);
	}
}

test.c
获取当前系统时间
计算当前月的1号是星期几。
根据年份和月份，确定该月的天数。（闰年，一月到十二月天数）
显示该月的日历，按星期排列
进入下一个月时，更新日历（调试时间）

#include"calendar.h"
int main(){
	/*
	int test_1 = 0;
	test_1= isLeapYear(2009);
	//2009不是闰年  为0
	printf("%d\n", test_1); 

	int test_2 = 0;
	test_2=getDaysInMonth(2008, 2);
	printf("%d\n", test_2);

	int test_3 = 0;
	//2024年9月26日是星期四
	test_3 = getWeekday(2024, 9, 26);
	printf("%d\n", test_3);
	//输出是4

	int test_4 = 0;
	//2024年9月1日是星期日
	test_4 = getWeekday(2024, 9, 1);
	printf("%d\n", test_4);
	//输出是0

	displayCalender(2024, 9);
	displayCalender(2024, 10);
	*/

	runCalendar();
	return 0;
}

在这里插入图片描述