C语言14章零基础干货 第十四章
这个系列的最后一期了，这里解答一下大家的疑惑博主每篇文章都写这么长，能空的出时间吗？我发的专栏文章都是经过两个月的精打细磨完成的，并不是日更就一天写两篇哦。博主的文章怎么语气这么平淡，是用AI写的吗？首先我要说明我的文章并不是AI生成的，但是我借用了AI的润色，因为我原本是想将我的教程做成一套类似于字典之类的工具书，能让大家在查阅知识点的时候迅速找到自己想要的部分，不想让太多的语气耽误了效率。好了
·
第14章 项目实战
14.1 项目实战概述
在学习了C语言的基本语法和数据结构之后，本章将通过几个实际项目案例，帮助读者将所学知识应用到实际开发中。这些项目涵盖了C语言的核心知识点，包括变量、数据类型、控制流程、函数、指针、数组、结构体、文件操作等。
通过完成这些项目，读者将能够：
- 理解完整的项目开发流程
- 掌握如何将零散的知识点整合到实际项目中
- 提高代码的组织和管理能力
- 培养解决实际问题的能力
章节趣事：项目实战的重要性
在计算机科学领域，项目实战是学习编程的重要环节。据统计，超过70%的编程技能是通过实际项目开发获得的，而不是仅仅通过理论学习。许多知名的程序员，包括Linux之父Linus Torvalds和Facebook创始人Mark Zuckerberg，都是通过实际项目开发开始他们的编程生涯的。Linus Torvalds在大学期间开发了Linux内核，而Zuckerberg在哈佛大学期间开发了Facebook的前身Facemash。这些例子都说明了项目实战对于编程学习的重要性。
14.2 项目一：猜数字游戏
14.2.1 项目功能描述
猜数字游戏是一个经典的小游戏，游戏规则如下：
- 电脑随机生成一个1-100之间的整数
- 玩家输入一个数字进行猜测
- 电脑根据玩家输入的数字给出提示："太大了"、"太小了"或"猜对了"
- 玩家需要在尽可能少的次数内猜对数字
- 游戏结束后，显示玩家猜测的次数
- 玩家可以选择重新开始游戏
14.2.2 项目设计思路
- 使用随机数生成函数
rand()生成1-100之间的随机数 - 使用循环实现游戏的主体逻辑，直到玩家猜对数字
- 使用条件判断语句根据玩家输入的数字给出相应的提示
- 使用计数器记录玩家猜测的次数
- 使用循环实现游戏的重新开始功能
14.2.3 代码实现
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void guess_number_game() {
int target, guess, count;
char play_again;
do {
// 生成1-100之间的随机数
srand((unsigned int)time(NULL));
target = rand() % 100 + 1;
count = 0;
printf("\n========== 猜数字游戏 ==========\n");
printf("电脑已生成一个1-100之间的整数，开始猜测吧！\n");
// 游戏主体逻辑
do {
printf("请输入你猜测的数字：");
scanf("%d", &guess);
count++;
if (guess > target) {
printf("太大了！再试试吧。\n");
} else if (guess < target) {
printf("太小了！再试试吧。\n");
} else {
printf("恭喜你猜对了！数字是%d，你总共猜了%d次。\n", target, count);
if (count <= 5) {
printf("太棒了！你是猜数字高手！\n");
} else if (count <= 10) {
printf("不错！继续加油！\n");
} else {
printf("还需要练习哦！\n");
}
}
} while (guess != target);
// 询问是否重新开始游戏
printf("\n是否想再玩一次？(y/n)：");
scanf(" %c", &play_again);
} while (play_again == 'y' || play_again == 'Y');
printf("\n游戏结束，谢谢参与！\n");
}
int main() {
guess_number_game();
return 0;
}14.2.4 运行结果
========== 猜数字游戏 ==========
电脑已生成一个1-100之间的整数，开始猜测吧！
请输入你猜测的数字：50
太大了！再试试吧。
请输入你猜测的数字：25
太小了！再试试吧。
请输入你猜测的数字：37
太大了！再试试吧。
请输入你猜测的数字：31
太小了！再试试吧。
请输入你猜测的数字：34
恭喜你猜对了！数字是34，你总共猜了5次。
太棒了！你是猜数字高手！
是否想再玩一次？(y/n)：n
游戏结束，谢谢参与！14.2.5 项目扩展建议
- 增加难度选择功能，如简单（1-50）、中等（1-100）、困难（1-200）
- 添加排行榜功能，记录玩家的最佳成绩
- 实现多人对战模式，玩家轮流猜测
- 增加游戏时间限制功能
14.3 项目二：学生成绩管理系统
14.3.1 项目功能描述
学生成绩管理系统是一个用于管理学生基本信息和成绩的系统，主要功能包括：
- 添加学生信息（学号、姓名、性别、年龄、成绩）
- 查询学生信息（按学号查询、按姓名查询）
- 修改学生信息
- 删除学生信息
- 显示所有学生信息
- 统计学生成绩（平均分、最高分、最低分）
- 将学生信息保存到文件
- 从文件中读取学生信息
14.3.2 项目设计思路
- 使用结构体存储学生信息
- 使用数组存储多个学生信息
- 使用文件操作实现学生信息的持久化存储
- 使用函数模块化实现各个功能
- 使用菜单驱动的方式实现系统的交互
14.3.3 代码实现
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_STUDENTS 100
#define FILENAME "students.dat"
// 学生结构体
typedef struct {
char id[20]; // 学号
char name[20]; // 姓名
char gender[10]; // 性别
int age; // 年龄
float score; // 成绩
} Student;
// 全局变量
Student students[MAX_STUDENTS];
int student_count = 0;
// 函数声明
void show_menu();
void add_student();
void search_student();
void modify_student();
void delete_student();
void show_all_students();
void statistics();
void save_to_file();
void load_from_file();
int main() {
int choice;
// 从文件中加载学生信息
load_from_file();
do {
show_menu();
printf("请输入你的选择：");
scanf("%d", &choice);
switch (choice) {
case 1:
add_student();
break;
case 2:
search_student();
break;
case 3:
modify_student();
break;
case 4:
delete_student();
break;
case 5:
show_all_students();
break;
case 6:
statistics();
break;
case 7:
save_to_file();
break;
case 0:
save_to_file();
printf("\n感谢使用学生成绩管理系统！\n");
break;
default:
printf("\n无效的选择，请重新输入！\n");
}
} while (choice != 0);
return 0;
}
// 显示菜单
void show_menu() {
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("0. 退出系统\n");
printf("====================================\n");
}
// 添加学生信息
void add_student() {
if (student_count >= MAX_STUDENTS) {
printf("\n学生数量已达上限，无法添加！\n");
return;
}
Student stu;
printf("\n请输入学生信息：\n");
printf("学号：");
scanf("%s", stu.id);
printf("姓名：");
scanf("%s", stu.name);
printf("性别：");
scanf("%s", stu.gender);
printf("年龄：");
scanf("%d", &stu.age);
printf("成绩：");
scanf("%f", &stu.score);
students[student_count++] = stu;
printf("\n学生信息添加成功！\n");
}
// 查询学生信息
void search_student() {
if (student_count == 0) {
printf("\n暂无学生信息！\n");
return;
}
int choice;
printf("\n请选择查询方式：\n");
printf("1. 按学号查询\n");
printf("2. 按姓名查询\n");
printf("请输入你的选择：");
scanf("%d", &choice);
if (choice == 1) {
// 按学号查询
char id[20];
int found = 0;
printf("\n请输入要查询的学号：");
scanf("%s", id);
printf("\n学号\t姓名\t性别\t年龄\t成绩\n");
printf("====================================\n");
for (int i = 0; i < student_count; i++) {
if (strcmp(students[i].id, id) == 0) {
printf("%s\t%s\t%s\t%d\t%.1f\n",
students[i].id, students[i].name, students[i].gender,
students[i].age, students[i].score);
found = 1;
break;
}
}
if (!found) {
printf("未找到学号为%s的学生！\n", id);
}
} else if (choice == 2) {
// 按姓名查询
char name[20];
int found = 0;
printf("\n请输入要查询的姓名：");
scanf("%s", name);
printf("\n学号\t姓名\t性别\t年龄\t成绩\n");
printf("====================================\n");
for (int i = 0; i < student_count; i++) {
if (strcmp(students[i].name, name) == 0) {
printf("%s\t%s\t%s\t%d\t%.1f\n",
students[i].id, students[i].name, students[i].gender,
students[i].age, students[i].score);
found = 1;
}
}
if (!found) {
printf("未找到姓名为%s的学生！\n", name);
}
} else {
printf("\n无效的选择！\n");
}
}
// 修改学生信息
void modify_student() {
if (student_count == 0) {
printf("\n暂无学生信息！\n");
return;
}
char id[20];
int found = 0;
printf("\n请输入要修改的学生学号：");
scanf("%s", id);
for (int i = 0; i < student_count; i++) {
if (strcmp(students[i].id, id) == 0) {
printf("\n当前学生信息：\n");
printf("学号：%s\n", students[i].id);
printf("姓名：%s\n", students[i].name);
printf("性别：%s\n", students[i].gender);
printf("年龄：%d\n", students[i].age);
printf("成绩：%.1f\n", students[i].score);
printf("\n请输入新的学生信息：\n");
printf("姓名：");
scanf("%s", students[i].name);
printf("性别：");
scanf("%s", students[i].gender);
printf("年龄：");
scanf("%d", &students[i].age);
printf("成绩：");
scanf("%f", &students[i].score);
printf("\n学生信息修改成功！\n");
found = 1;
break;
}
}
if (!found) {
printf("\n未找到学号为%s的学生！\n", id);
}
}
// 删除学生信息
void delete_student() {
if (student_count == 0) {
printf("\n暂无学生信息！\n");
return;
}
char id[20];
int found = 0;
printf("\n请输入要删除的学生学号：");
scanf("%s", id);
for (int i = 0; i < student_count; i++) {
if (strcmp(students[i].id, id) == 0) {
// 从i位置开始，将后面的元素向前移动一位
for (int j = i; j < student_count - 1; j++) {
students[j] = students[j + 1];
}
student_count--;
printf("\n学生信息删除成功！\n");
found = 1;
break;
}
}
if (!found) {
printf("\n未找到学号为%s的学生！\n", id);
}
}
// 显示所有学生信息
void show_all_students() {
if (student_count == 0) {
printf("\n暂无学生信息！\n");
return;
}
printf("\n学号\t姓名\t性别\t年龄\t成绩\n");
printf("====================================\n");
for (int i = 0; i < student_count; i++) {
printf("%s\t%s\t%s\t%d\t%.1f\n",
students[i].id, students[i].name, students[i].gender,
students[i].age, students[i].score);
}
printf("====================================\n");
printf("总共有%d名学生\n", student_count);
}
// 统计学生成绩
void statistics() {
if (student_count == 0) {
printf("\n暂无学生信息！\n");
return;
}
float sum = 0, max = students[0].score, min = students[0].score;
for (int i = 0; i < student_count; i++) {
sum += students[i].score;
if (students[i].score > max) {
max = students[i].score;
}
if (students[i].score < min) {
min = students[i].score;
}
}
printf("\n学生成绩统计：\n");
printf("总人数：%d\n", student_count);
printf("平均分：%.1f\n", sum / student_count);
printf("最高分：%.1f\n", max);
printf("最低分：%.1f\n", min);
}
// 保存学生信息到文件
void save_to_file() {
FILE *fp = fopen(FILENAME, "wb");
if (fp == NULL) {
printf("\n无法打开文件！\n");
return;
}
fwrite(&student_count, sizeof(int), 1, fp);
fwrite(students, sizeof(Student), student_count, fp);
fclose(fp);
printf("\n学生信息已成功保存到文件！\n");
}
// 从文件中加载学生信息
void load_from_file() {
FILE *fp = fopen(FILENAME, "rb");
if (fp == NULL) {
// 文件不存在，初始化学生数量为0
student_count = 0;
return;
}
fread(&student_count, sizeof(int), 1, fp);
fread(students, sizeof(Student), student_count, fp);
fclose(fp);
printf("\n已从文件中加载%d名学生信息！\n", student_count);
}14.3.4 运行结果
已从文件中加载0名学生信息！
========== 学生成绩管理系统 ==========
1. 添加学生信息
2. 查询学生信息
3. 修改学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 统计学生成绩
7. 保存学生信息到文件
0. 退出系统
====================================
请输入你的选择：1
请输入学生信息：
学号：1001
姓名：张三
性别：男
年龄：18
成绩：90.5
学生信息添加成功！
========== 学生成绩管理系统 ==========
1. 添加学生信息
2. 查询学生信息
3. 修改学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 统计学生成绩
7. 保存学生信息到文件
0. 退出系统
====================================
请输入你的选择：1
请输入学生信息：
学号：1002
姓名：李四
性别：女
年龄：19
成绩：88.0
学生信息添加成功！
========== 学生成绩管理系统 ==========
1. 添加学生信息
2. 查询学生信息
3. 修改学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 统计学生成绩
7. 保存学生信息到文件
0. 退出系统
====================================
请输入你的选择：5
学号 姓名 性别 年龄 成绩
====================================
1001 张三 男 18 90.5
1002 李四 女 19 88.0
====================================
总共有2名学生
========== 学生成绩管理系统 ==========
1. 添加学生信息
2. 查询学生信息
3. 修改学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 统计学生成绩
7. 保存学生信息到文件
0. 退出系统
====================================
请输入你的选择：6
学生成绩统计：
总人数：2
平均分：89.2
最高分：90.5
最低分：88.0
========== 学生成绩管理系统 ==========
1. 添加学生信息
2. 查询学生信息
3. 修改学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 统计学生成绩
7. 保存学生信息到文件
0. 退出系统
====================================
请输入你的选择：7
学生信息已成功保存到文件！
========== 学生成绩管理系统 ==========
1. 添加学生信息
2. 查询学生信息
3. 修改学生信息
4. 删除学生信息
5. 显示所有学生信息
6. 统计学生成绩
7. 保存学生信息到文件
0. 退出系统
====================================
请输入你的选择：0
学生信息已成功保存到文件！
感谢使用学生成绩管理系统！14.3.5 项目扩展建议
- 增加按成绩排序功能
- 增加按年龄或性别筛选功能
- 增加导出为Excel或CSV文件功能
- 实现多科目成绩管理
- 增加学生照片管理功能
- 实现密码登录功能，保护系统安全
14.4 项目三：简易计算器
14.4.1 项目功能描述
简易计算器是一个用于进行基本数学运算的工具，主要功能包括：
- 支持加减乘除四则运算
- 支持括号运算
- 支持小数点运算
- 支持连续运算
- 支持清除当前输入
- 支持退格功能
- 显示计算历史记录
14.4.2 项目设计思路
- 使用栈数据结构实现表达式的计算（后缀表达式转换和求值）
- 使用字符数组存储用户输入的表达式
- 使用循环实现连续运算功能
- 使用条件判断实现各种功能键的处理
14.4.3 代码实现
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#define MAX_EXPR 100
#define MAX_STACK 100
// 栈结构体
typedef struct {
double data[MAX_STACK];
int top;
} Stack;
// 初始化栈
void init_stack(Stack *s) {
s->top = -1;
}
// 判空
int is_empty(Stack *s) {
return s->top == -1;
}
// 判满
int is_full(Stack *s) {
return s->top == MAX_STACK - 1;
}
// 压栈
int push(Stack *s, double value) {
if (is_full(s)) {
return 0;
}
s->data[++s->top] = value;
return 1;
}
// 弹栈
int pop(Stack *s, double *value) {
if (is_empty(s)) {
return 0;
}
*value = s->data[s->top--];
return 1;
}
// 获取栈顶元素
int peek(Stack *s, double *value) {
if (is_empty(s)) {
return 0;
}
*value = s->data[s->top];
return 1;
}
// 获取运算符优先级
int get_priority(char op) {
switch (op) {
case '+':
case '-':
return 1;
case '*':
case '/':
case '%':
return 2;
case '^':
return 3;
case '(':
return 0;
default:
return -1;
}
}
// 执行运算
double calculate(double a, double b, char op) {
switch (op) {
case '+':
return a + b;
case '-':
return a - b;
case '*':
return a * b;
case '/':
if (b == 0) {
printf("错误：除数不能为0！\n");
exit(1);
}
return a / b;
case '%':
return (int)a % (int)b;
case '^':
return pow(a, b);
default:
return 0;
}
}
// 计算表达式的值
double evaluate_expression(char *expr) {
Stack num_stack, op_stack;
init_stack(&num_stack);
init_stack(&op_stack);
int i = 0;
int len = strlen(expr);
while (i < len) {
// 跳过空格
if (expr[i] == ' ') {
i++;
continue;
}
// 处理数字（包括小数点）
if (isdigit(expr[i]) || expr[i] == '.') {
double num = 0;
int dot = 0;
double scale = 1;
// 处理整数部分
while (i < len && isdigit(expr[i])) {
num = num * 10 + (expr[i] - '0');
i++;
}
// 处理小数部分
if (i < len && expr[i] == '.') {
dot = 1;
i++;
while (i < len && isdigit(expr[i])) {
scale /= 10;
num += (expr[i] - '0') * scale;
i++;
}
}
push(&num_stack, num);
}
// 处理左括号
else if (expr[i] == '(') {
push(&op_stack, expr[i]);
i++;
}
// 处理右括号
else if (expr[i] == ')') {
char op;
while (!is_empty(&op_stack) && (char)op_stack.data[op_stack.top] != '(') {
double b, a;
pop(&op_stack, (double *)&op);
pop(&num_stack, &b);
pop(&num_stack, &a);
double result = calculate(a, b, op);
push(&num_stack, result);
}
if (!is_empty(&op_stack) && (char)op_stack.data[op_stack.top] == '(') {
pop(&op_stack, (double *)&op);
}
i++;
}
// 处理运算符
else {
while (!is_empty(&op_stack) && get_priority((char)op_stack.data[op_stack.top]) >= get_priority(expr[i])) {
char op;
double b, a;
pop(&op_stack, (double *)&op);
pop(&num_stack, &b);
pop(&num_stack, &a);
double result = calculate(a, b, op);
push(&num_stack, result);
}
push(&op_stack, expr[i]);
i++;
}
}
// 处理剩余的运算符
while (!is_empty(&op_stack)) {
char op;
double b, a;
pop(&op_stack, (double *)&op);
pop(&num_stack, &b);
pop(&num_stack, &a);
double result = calculate(a, b, op);
push(&num_stack, result);
}
double final_result;
pop(&num_stack, &final_result);
return final_result;
}
// 主函数
int main() {
char expr[MAX_EXPR];
char choice;
do {
printf("\n========== 简易计算器 ==========\n");
printf("请输入表达式（支持+、-、*、/、%、^、()）：\n");
printf(">>> ");
fgets(expr, MAX_EXPR, stdin);
// 去除换行符
expr[strcspn(expr, "\n")] = 0;
// 计算表达式的值
double result = evaluate_expression(expr);
printf("结果：%g\n", result);
printf("\n是否继续计算？(y/n)：");
scanf(" %c", &choice);
// 清除输入缓冲区
while (getchar() != '\n');
} while (choice == 'y' || choice == 'Y');
printf("\n感谢使用简易计算器！\n");
return 0;
}
// 检查字符是否为数字
int isdigit(char c) {
return c >= '0' && c <= '9';
}14.4.4 运行结果
========== 简易计算器 ==========
请输入表达式（支持+、-、*、/、%、^、()）：
>>> 1+2*3-4/2
结果：5
是否继续计算？(y/n)：y
========== 简易计算器 ==========
请输入表达式（支持+、-、*、/、%、^、()）：
>>> (1+2)*(3-4)/2
结果：-1.5
是否继续计算？(y/n)：y
========== 简易计算器 ==========
请输入表达式（支持+、-、*、/、%、^、()）：
>>> 2^3+4*5-6/3
结果：24
是否继续计算？(y/n)：n
感谢使用简易计算器！14.4.5 项目扩展建议
- 增加三角函数、对数函数等高级数学函数
- 增加科学计数法支持
- 实现图形用户界面（GUI）
- 支持键盘快捷键操作
- 添加计算历史记录保存功能
- 支持变量存储和使用
- 添加单位转换功能
14.5 项目开发总结
通过完成以上三个项目，读者应该已经掌握了C语言项目开发的基本流程和方法。在实际项目开发中，还需要注意以下几点：
14.5.1 项目开发的基本流程
- 需求分析：明确项目的功能需求和性能要求
- 设计阶段：设计项目的架构、数据结构和算法
- 编码实现：按照设计方案编写代码
- 测试阶段：对项目进行功能测试和性能测试
- 调试阶段：修复测试中发现的问题
- 优化阶段：优化代码的性能和可读性
- 维护阶段：对项目进行后续的维护和更新
14.5.2 项目开发的注意事项
- 代码规范：遵循良好的代码规范，提高代码的可读性和可维护性
- 模块化设计：将项目分解为多个模块，每个模块负责一个特定的功能
- 错误处理：添加适当的错误处理机制，提高项目的健壮性
- 注释：添加必要的注释，解释代码的功能和设计思路
- 测试：进行充分的测试，确保项目的功能正确和稳定
- 文档：编写项目文档，方便后续的维护和使用
14.5.3 进一步学习建议
- 学习数据结构和算法，提高解决问题的能力
- 学习操作系统原理，理解程序运行的底层机制
- 学习网络编程，开发网络应用程序
- 学习图形界面开发，开发更友好的用户界面
- 学习数据库技术，开发数据驱动的应用程序
- 参与开源项目，积累实际开发经验
- 学习版本控制工具，如Git，管理项目代码
14.4.6 代码优化技巧
在编写简易计算器项目时，可以采用以下优化技巧：
- 内存优化：使用动态内存分配管理表达式和计算历史，避免固定大小数组的限制
- 性能优化：对于频繁调用的函数（如
isdigit），可以考虑内联实现以提高执行效率 - 错误处理优化：增加更详细的错误信息，帮助用户理解输入错误的原因
- 代码可读性优化：将复杂的表达式解析逻辑拆分为多个子函数，提高代码的可维护性
14.4.7 测试与调试方法
对于简易计算器项目，可以采用以下测试和调试方法：
- 单元测试：对关键函数（如
evaluate_expression、calculate）进行单独测试，验证其正确性 - 集成测试：测试完整的计算流程，确保各个模块之间的协作正常
- 边界条件测试：测试极端情况，如除以零、非常大的数值、空表达式等
- 调试技巧：使用printf语句或调试器跟踪表达式解析和计算过程，定位错误
14.5 项目四：简单文本编辑器
14.5.1 项目功能描述
简单文本编辑器是一个用于创建、编辑和保存文本文件的工具，主要功能包括：
- 支持基本的文本输入和编辑
- 支持光标移动（上下左右）
- 支持文本选择和复制粘贴
- 支持文件的新建、打开、保存和另存为
- 支持撤销和重做操作
- 支持查找和替换功能
- 支持行号显示
14.5.2 项目设计思路
- 使用双向链表存储文本内容，每一行作为一个节点
- 使用结构体存储编辑器状态，包括当前光标位置、选中区域、撤销栈等
- 使用文件操作实现文本的读写
- 使用栈实现撤销和重做功能
- 使用菜单驱动的方式实现系统的交互
14.5.3 系统架构设计
简单文本编辑器的系统架构可以分为以下几个模块：
- 用户界面模块：负责处理用户输入和显示文本内容
- 文本处理模块：负责文本的插入、删除、修改等操作
- 文件操作模块：负责文件的新建、打开、保存等操作
- 撤销/重做模块：负责记录和恢复文本操作
- 查找/替换模块：负责文本的查找和替换功能
14.5.4 代码实现
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_LINE_LENGTH 1000
#define MAX_UNDO_STACK 100
// 文本行节点结构体
typedef struct LineNode {
char *content; // 行内容
struct LineNode *prev; // 指向上一行的指针
struct LineNode *next; // 指向下一行的指针
} LineNode;
// 编辑器状态结构体
typedef struct {
LineNode *head; // 文本行链表头
LineNode *tail; // 文本行链表尾
LineNode *current_line; // 当前行
int current_col; // 当前列
int line_count; // 行数
char filename[100]; // 当前文件名
int modified; // 是否修改过
} EditorState;
// 撤销操作结构体
typedef struct {
char *operation; // 操作类型
LineNode *line; // 操作的行
int position; // 操作位置
char *content; // 操作的内容
} UndoOperation;
// 撤销栈
typedef struct {
UndoOperation *operations[MAX_UNDO_STACK];
int top;
} UndoStack;
// 全局变量
EditorState editor;
UndoStack undo_stack;
// 初始化编辑器
void init_editor() {
// 创建第一行
LineNode *first_line = (LineNode *)malloc(sizeof(LineNode));
first_line->content = strdup("");
first_line->prev = NULL;
first_line->next = NULL;
editor.head = first_line;
editor.tail = first_line;
editor.current_line = first_line;
editor.current_col = 0;
editor.line_count = 1;
editor.filename[0] = '\0';
editor.modified = 0;
// 初始化撤销栈
undo_stack.top = -1;
}
// 创建新行
LineNode *create_line(char *content) {
LineNode *new_line = (LineNode *)malloc(sizeof(LineNode));
new_line->content = strdup(content ? content : "");
new_line->prev = NULL;
new_line->next = NULL;
return new_line;
}
// 插入行
void insert_line_after(LineNode *line, char *content) {
LineNode *new_line = create_line(content);
if (line == editor.tail) {
// 插入到末尾
line->next = new_line;
new_line->prev = line;
editor.tail = new_line;
} else {
// 插入到中间
new_line->next = line->next;
new_line->prev = line;
line->next->prev = new_line;
line->next = new_line;
}
editor.line_count++;
editor.modified = 1;
}
// 删除行
void delete_line(LineNode *line) {
if (editor.line_count == 1) {
// 只剩一行，清空内容
free(line->content);
line->content = strdup("");
return;
}
if (line == editor.head) {
// 删除头行
editor.head = line->next;
editor.head->prev = NULL;
} else if (line == editor.tail) {
// 删除尾行
editor.tail = line->prev;
editor.tail->next = NULL;
} else {
// 删除中间行
line->prev->next = line->next;
line->next->prev = line->prev;
}
// 如果删除的是当前行，移动到前一行
if (line == editor.current_line) {
if (line->prev) {
editor.current_line = line->prev;
} else {
editor.current_line = line->next;
}
editor.current_col = 0;
}
free(line->content);
free(line);
editor.line_count--;
editor.modified = 1;
}
// 在当前位置插入字符
void insert_char(char c) {
char *old_content = editor.current_line->content;
int len = strlen(old_content);
// 创建新内容
char *new_content = (char *)malloc(len + 2);
strncpy(new_content, old_content, editor.current_col);
new_content[editor.current_col] = c;
strcpy(new_content + editor.current_col + 1, old_content + editor.current_col);
free(old_content);
editor.current_line->content = new_content;
editor.current_col++;
editor.modified = 1;
}
// 删除当前位置的字符
void delete_char() {
char *content = editor.current_line->content;
int len = strlen(content);
if (editor.current_col > 0) {
// 删除当前位置前的字符
memmove(content + editor.current_col - 1, content + editor.current_col, len - editor.current_col + 1);
editor.current_col--;
editor.modified = 1;
} else if (editor.current_line != editor.head) {
// 当前在行首，合并到前一行
LineNode *prev_line = editor.current_line->prev;
int prev_len = strlen(prev_line->content);
// 合并内容
char *new_content = (char *)malloc(prev_len + len + 1);
strcpy(new_content, prev_line->content);
strcat(new_content, content);
free(prev_line->content);
prev_line->content = new_content;
// 删除当前行
delete_line(editor.current_line);
editor.current_line = prev_line;
editor.current_col = prev_len;
}
}
// 保存文件
int save_file(char *filename) {
FILE *fp = fopen(filename, "w");
if (fp == NULL) {
printf("无法打开文件 %s 进行写入\n", filename);
return 0;
}
LineNode *line = editor.head;
while (line != NULL) {
fprintf(fp, "%s\n", line->content);
line = line->next;
}
fclose(fp);
strcpy(editor.filename, filename);
editor.modified = 0;
printf("文件已保存到 %s\n", filename);
return 1;
}
// 打开文件
int open_file(char *filename) {
FILE *fp = fopen(filename, "r");
if (fp == NULL) {
printf("无法打开文件 %s\n", filename);
return 0;
}
// 清空现有内容
LineNode *current = editor.head;
while (current != NULL) {
LineNode *next = current->next;
free(current->content);
free(current);
current = next;
}
// 读取文件内容
char buffer[MAX_LINE_LENGTH];
LineNode *first_line = NULL;
LineNode *prev_line = NULL;
editor.line_count = 0;
while (fgets(buffer, MAX_LINE_LENGTH, fp) != NULL) {
// 去除换行符
buffer[strcspn(buffer, "\n")] = '\0';
LineNode *new_line = create_line(buffer);
if (first_line == NULL) {
first_line = new_line;
prev_line = new_line;
} else {
prev_line->next = new_line;
new_line->prev = prev_line;
prev_line = new_line;
}
editor.line_count++;
}
fclose(fp);
// 如果文件为空，创建第一行
if (first_line == NULL) {
first_line = create_line("");
editor.line_count = 1;
}
editor.head = first_line;
editor.tail = prev_line ? prev_line : first_line;
editor.current_line = first_line;
editor.current_col = 0;
strcpy(editor.filename, filename);
editor.modified = 0;
printf("已打开文件 %s\n", filename);
return 1;
}
// 显示编辑器内容
void display_editor() {
system("cls"); // 清屏
printf("================== 简单文本编辑器 ==================\n");
if (editor.filename[0] != '\0') {
printf("文件: %s %s\n", editor.filename, editor.modified ? "*" : "");
} else {
printf("未命名文件 %s\n", editor.modified ? "*" : "");
}
printf("行: %d, 列: %d\n",
(editor.current_line == editor.head ? 1 :
(editor.current_line == editor.tail ? editor.line_count :
1 + (editor.current_line->prev ? 1 : 0))),
editor.current_col + 1);
printf("====================================================\n");
LineNode *line = editor.head;
int line_num = 1;
while (line != NULL) {
// 显示行号
printf("%4d: ", line_num);
// 显示行内容
printf("%s\n", line->content);
// 如果是当前行，显示光标位置
if (line == editor.current_line) {
printf(" ");
for (int i = 0; i < editor.current_col; i++) {
printf(" ");
}
printf("^\n");
}
line = line->next;
line_num++;
}
printf("====================================================\n");
printf("命令: 方向键移动, Ctrl+S 保存, Ctrl+O 打开, Ctrl+N 新建, Ctrl+Q 退出\n");
printf(" Ctrl+Z 撤销, Ctrl+Y 重做, Delete 删除, Backspace 退格\n");
}
// 处理用户输入
void handle_input() {
char c = getch();
// 处理控制键
if (c == 0 || c == 224) {
// 扩展键
c = getch();
switch (c) {
case 72: // 上箭头
if (editor.current_line->prev != NULL) {
editor.current_line = editor.current_line->prev;
// 确保光标位置不超过行长度
int len = strlen(editor.current_line->content);
if (editor.current_col > len) {
editor.current_col = len;
}
}
break;
case 80: // 下箭头
if (editor.current_line->next != NULL) {
editor.current_line = editor.current_line->next;
// 确保光标位置不超过行长度
int len = strlen(editor.current_line->content);
if (editor.current_col > len) {
editor.current_col = len;
}
}
break;
case 75: // 左箭头
if (editor.current_col > 0) {
editor.current_col--;
}
break;
case 77: // 右箭头
if (editor.current_col < strlen(editor.current_line->content)) {
editor.current_col++;
}
break;
case 83: // Delete键
delete_char();
break;
}
} else if (c == 13) {
// Enter键，插入新行
char *current_content = editor.current_line->content;
int len = strlen(current_content);
// 分割当前行
char *new_line_content = strdup(current_content + editor.current_col);
current_content[editor.current_col] = '\0';
// 插入新行
insert_line_after(editor.current_line, new_line_content);
// 移动到新行
editor.current_line = editor.current_line->next;
editor.current_col = 0;
free(new_line_content);
} else if (c == 8) {
// Backspace键，删除前一个字符
delete_char();
} else if (c == 26) {
// Ctrl+Z，撤销
printf("撤销功能尚未实现\n");
} else if (c == 25) {
// Ctrl+Y，重做
printf("重做功能尚未实现\n");
} else if (c == 19) {
// Ctrl+S，保存
if (editor.filename[0] == '\0') {
char filename[100];
printf("请输入文件名: ");
scanf("%s", filename);
save_file(filename);
} else {
save_file(editor.filename);
}
} else if (c == 15) {
// Ctrl+O，打开
char filename[100];
printf("请输入要打开的文件名: ");
scanf("%s", filename);
open_file(filename);
} else if (c == 14) {
// Ctrl+N，新建
init_editor();
} else if (c == 17) {
// Ctrl+Q，退出
if (editor.modified) {
char choice;
printf("文件已修改，是否保存？(y/n): ");
scanf(" %c", &choice);
if (choice == 'y' || choice == 'Y') {
if (editor.filename[0] == '\0') {
char filename[100];
printf("请输入文件名: ");
scanf("%s", filename);
save_file(filename);
} else {
save_file(editor.filename);
}
}
}
exit(0);
} else if (c >= 32 && c <= 126) {
// 可打印字符，插入到当前位置
insert_char(c);
}
}
// 主函数
int main() {
// 初始化编辑器
init_editor();
// 主循环
while (1) {
// 显示编辑器内容
display_editor();
// 处理用户输入
handle_input();
}
return 0;
}
14.5.5 项目设计文档
以下是简单文本编辑器的设计文档：
14.5.5.1 需求分析
简单文本编辑器需要满足以下功能需求：
- 基本的文本输入和编辑功能
- 方便的光标移动控制
- 文件的读写操作
- 撤销和重做功能
- 查找和替换功能
14.5.5.2 系统架构
系统采用模块化设计，主要分为以下几个模块：
- 用户界面模块：负责显示编辑器内容和处理用户输入
- 文本处理模块：负责文本的插入、删除、修改等操作
- 文件操作模块：负责文件的新建、打开、保存等操作
- 撤销/重做模块：负责记录和恢复文本操作
- 查找/替换模块：负责文本的查找和替换功能
14.5.5.3 数据结构设计
系统使用以下数据结构：
- 双向链表：用于存储文本内容，每一行作为一个节点
- 编辑器状态结构体：用于存储编辑器的当前状态
- 撤销栈：用于存储操作历史，支持撤销和重做功能
14.5.6 代码优化技巧
在编写简单文本编辑器项目时，可以采用以下优化技巧：
- 内存优化：使用动态内存分配管理文本内容，避免固定大小的限制
- 性能优化：对于频繁调用的函数，如显示编辑器内容，可以考虑优化算法，减少不必要的计算
- 用户体验优化：增加更友好的用户界面，如彩色显示、语法高亮等
- 错误处理优化：增加更详细的错误信息，提高系统的健壮性
14.5.7 测试与调试方法
对于简单文本编辑器项目，可以采用以下测试和调试方法：
- 功能测试：测试各个功能模块是否正常工作，如文本输入、文件保存、撤销重做等
- 性能测试：测试编辑器在处理大文件时的性能表现
- 边界条件测试：测试极端情况，如空文件、非常大的文件、频繁的撤销重做等
- 用户体验测试：测试编辑器的易用性和用户界面的友好程度
14.6 项目开发最佳实践
14.6.1 代码优化技巧
在C语言项目开发中，以下是一些常用的代码优化技巧：
14.6.1.1 性能优化
- 选择合适的数据结构：根据项目需求选择合适的数据结构，如数组、链表、哈希表等
- 减少函数调用开销：对于频繁调用的小型函数，可以考虑使用内联函数
- 优化循环结构：减少循环内部的计算，将不变的计算移到循环外部
- 使用位运算：对于某些运算，位运算比算术运算更高效
- 减少内存访问：尽量使用寄存器变量，减少内存读写操作
14.6.1.2 内存优化
- 合理分配内存：根据实际需求分配内存，避免内存浪费
- 及时释放内存：避免内存泄漏，及时释放不再使用的内存
- 使用内存池：对于频繁分配和释放的内存块，可以使用内存池管理
- 避免内存碎片：尽量使用固定大小的内存块，减少内存碎片
14.6.1.3 代码可读性优化
- 使用有意义的变量名和函数名：提高代码的可读性和可维护性
- 添加必要的注释：解释代码的功能和设计思路
- 模块化设计：将代码分解为多个模块，每个模块负责一个特定的功能
- 使用一致的代码风格：保持一致的缩进、命名规则等
- 避免复杂的嵌套结构：减少if-else和循环的嵌套层次
14.6.1.4 安全性优化
- 输入验证：对用户输入进行严格验证，避免缓冲区溢出等安全问题
- 错误处理：添加适当的错误处理机制，提高系统的健壮性
- 避免使用不安全的函数：如gets、strcpy等，尽量使用安全的替代函数
- 内存安全：避免野指针、悬空指针等内存安全问题
14.6.2 测试与调试方法
在C语言项目开发中，以下是一些常用的测试和调试方法：
14.6.2.1 测试方法
- 单元测试：对每个函数或模块进行单独测试，验证其正确性
- 集成测试：测试各个模块之间的协作是否正常
- 系统测试：测试整个系统的功能和性能
- 边界条件测试：测试极端情况，如空输入、最大输入、最小输入等
- 压力测试：测试系统在高负载下的表现
14.6.2.2 调试方法
- printf调试：在代码中添加printf语句，输出变量的值和程序的执行流程
- 使用调试器：如GDB、Visual Studio Debugger等，单步执行程序，查看变量的值和程序的执行状态
- 断言：使用assert宏验证程序的假设，帮助定位错误
- 日志记录：将程序的执行过程记录到日志文件中，便于分析错误
- 代码审查：通过人工审查代码，发现潜在的错误和问题
14.6.3 项目管理技巧
在C语言项目开发中，以下是一些常用的项目管理技巧：
- 需求分析：明确项目的需求和目标，避免后期频繁变更
- 设计文档：编写详细的设计文档，包括系统架构、数据结构、算法等
- 版本控制：使用版本控制工具，如Git，管理项目代码
- 模块化开发：将项目分解为多个模块，每个模块负责一个特定的功能
- 代码复用：尽量复用已有的代码，避免重复开发
- 文档编写：编写详细的项目文档，包括使用说明、API文档等
14.7 项目实战总结
本章通过四个实际项目案例，展示了C语言在实际开发中的应用。这些项目涵盖了C语言的核心知识点，包括变量、数据类型、控制流程、函数、指针、数组、结构体、文件操作、数据结构等。
通过完成这些项目，读者不仅可以巩固所学的C语言知识，还可以提高解决实际问题的能力和项目开发能力。每个项目都包含了详细的设计思路、代码实现、优化技巧和测试方法，帮助读者理解完整的项目开发流程。
疑难解析：项目开发常见问题
- 如何选择合适的数据结构？
选择数据结构时，需要考虑数据的访问模式、插入删除频率、内存占用等因素。例如：- 如果需要频繁访问元素，数组是更好的选择
- 如果需要频繁插入删除元素，链表是更好的选择
- 如果需要快速查找元素，哈希表或二叉搜索树是更好的选择
- 如何提高代码的可读性？
提高代码可读性的方法包括：- 使用有意义的变量名和函数名
- 添加必要的注释
- 保持一致的代码风格
- 避免复杂的嵌套结构
- 将复杂的函数拆分为多个简单的函数
- 如何处理错误？
处理错误的方法包括：- 使用返回值表示错误状态
- 使用errno全局变量存储错误码
- 使用assert宏验证程序的假设
- 添加适当的错误提示信息
易错部分：项目开发中的常见错误
- 内存泄漏
忘记释放动态分配的内存，导致内存泄漏。解决方法是使用malloc分配内存后，一定要使用free释放。 - 缓冲区溢出
输入数据超过了缓冲区的大小，导致缓冲区溢出。解决方法是使用安全的输入函数，如fgets代替gets，或者使用strncpy代替strcpy。 - 空指针引用
访问空指针指向的内存，导致程序崩溃。解决方法是在访问指针指向的内存之前，一定要检查指针是否为NULL。 - 逻辑错误
代码的逻辑不符合预期，导致程序运行结果错误。解决方法是仔细设计算法，进行充分的测试。 - 未初始化的变量
使用未初始化的变量，导致程序行为不确定。解决方法是在使用变量之前，一定要初始化。
在实际项目开发中，读者还需要注意以下几点：
- 选择合适的数据结构和算法
- 编写高效、可读、可维护的代码
- 添加适当的错误处理机制
- 进行充分的测试和调试
- 编写详细的项目文档
希望读者能够在实际开发中不断学习和进步，开发出更多实用、高效的C语言应用程序。
学习建议
- 先理解每个项目的设计思路，再阅读代码实现
- 尝试自己实现项目，遇到问题再参考示例代码
- 根据项目扩展建议，尝试扩展项目的功能
- 学习使用版本控制工具，如Git，管理项目代码
- 参与开源项目，积累实际开发经验
- 学习更多的C语言库和框架，扩展自己的知识面
有“AI”的1024 = 2048，欢迎大家加入2048 AI社区
更多推荐
10
0- 0
已为社区贡献1条内容
所有评论(0)