最新资讯

第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 项目设计思路

1. 使用随机数生成函数rand()生成1-100之间的随机数
2. 使用循环实现游戏的主体逻辑，直到玩家猜对数字
3. 使用条件判断语句根据玩家输入的数字给出相应的提示
4. 使用计数器记录玩家猜测的次数
5. 使用循环实现游戏的重新开始功能

14.2.3 代码实现

#include 
#include 
#include 

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("
========== 猜数字游戏 ==========
");
        printf("电脑已生成一个1-100之间的整数，开始猜测吧！
");
        
        // 游戏主体逻辑
        do {
            printf("请输入你猜测的数字：");
            scanf("%d", &guess);
            count++;
            
            if (guess > target) {
                printf("太大了！再试试吧。
");
            } else if (guess < target) {
                printf("太小了！再试试吧。
");
            } else {
                printf("恭喜你猜对了！数字是%d，你总共猜了%d次。
", target, count);
                if (count <= 5) {
                    printf("太棒了！你是猜数字高手！
");
                } else if (count <= 10) {
                    printf("不错！继续加油！
");
                } else {
                    printf("还需要练习哦！
");
                }
            }
        } while (guess != target);
        
        // 询问是否重新开始游戏
        printf("
是否想再玩一次？(y/n)：");
        scanf(" %c", &play_again);
    } while (play_again == 'y' || play_again == 'Y');
    
    printf("
游戏结束，谢谢参与！
");
}

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 项目设计思路

1. 使用结构体存储学生信息
2. 使用数组存储多个学生信息
3. 使用文件操作实现学生信息的持久化存储
4. 使用函数模块化实现各个功能
5. 使用菜单驱动的方式实现系统的交互

14.3.3 代码实现

#include 
#include 
#include 

#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("
感谢使用学生成绩管理系统！
");
                break;
            default:
                printf("
无效的选择，请重新输入！
");
        }
    } while (choice != 0);
    
    return 0;
}

// 显示菜单
void show_menu() {
    printf("
========== 学生成绩管理系统 ==========
");
    printf("1. 添加学生信息
");
    printf("2. 查询学生信息
");
    printf("3. 修改学生信息
");
    printf("4. 删除学生信息
");
    printf("5. 显示所有学生信息
");
    printf("6. 统计学生成绩
");
    printf("7. 保存学生信息到文件
");
    printf("0. 退出系统
");
    printf("====================================
");
}

// 添加学生信息
void add_student() {
    if (student_count >= MAX_STUDENTS) {
        printf("
学生数量已达上限，无法添加！
");
        return;
    }
    
    Student stu;
    
    printf("
请输入学生信息：
");
    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("
学生信息添加成功！
");
}

// 查询学生信息
void search_student() {
    if (student_count == 0) {
        printf("
暂无学生信息！
");
        return;
    }
    
    int choice;
    printf("
请选择查询方式：
");
    printf("1. 按学号查询
");
    printf("2. 按姓名查询
");
    printf("请输入你的选择：");
    scanf("%d", &choice);
    
    if (choice == 1) {
        // 按学号查询
        char id[20];
        int found = 0;
        printf("
请输入要查询的学号：");
        scanf("%s", id);
        
        printf("
学号	姓名	性别	年龄	成绩
");
        printf("====================================
");
        for (int i = 0; i < student_count; i++) {
            if (strcmp(students[i].id, id) == 0) {
                printf("%s	%s	%s	%d	%.1f
", 
                       students[i].id, students[i].name, students[i].gender, 
                       students[i].age, students[i].score);
                found = 1;
                break;
            }
        }
        if (!found) {
            printf("未找到学号为%s的学生！
", id);
        }
    } else if (choice == 2) {
        // 按姓名查询
        char name[20];
        int found = 0;
        printf("
请输入要查询的姓名：");
        scanf("%s", name);
        
        printf("
学号	姓名	性别	年龄	成绩
");
        printf("====================================
");
        for (int i = 0; i < student_count; i++) {
            if (strcmp(students[i].name, name) == 0) {
                printf("%s	%s	%s	%d	%.1f
", 
                       students[i].id, students[i].name, students[i].gender, 
                       students[i].age, students[i].score);
                found = 1;
            }
        }
        if (!found) {
            printf("未找到姓名为%s的学生！
", name);
        }
    } else {
        printf("
无效的选择！
");
    }
}

// 修改学生信息
void modify_student() {
    if (student_count == 0) {
        printf("
暂无学生信息！
");
        return;
    }
    
    char id[20];
    int found = 0;
    printf("
请输入要修改的学生学号：");
    scanf("%s", id);
    
    for (int i = 0; i < student_count; i++) {
        if (strcmp(students[i].id, id) == 0) {
            printf("
当前学生信息：
");
            printf("学号：%s
", students[i].id);
            printf("姓名：%s
", students[i].name);
            printf("性别：%s
", students[i].gender);
            printf("年龄：%d
", students[i].age);
            printf("成绩：%.1f
", students[i].score);
            
            printf("
请输入新的学生信息：
");
            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("
学生信息修改成功！
");
            found = 1;
            break;
        }
    }
    
    if (!found) {
        printf("
未找到学号为%s的学生！
", id);
    }
}

// 删除学生信息
void delete_student() {
    if (student_count == 0) {
        printf("
暂无学生信息！
");
        return;
    }
    
    char id[20];
    int found = 0;
    printf("
请输入要删除的学生学号：");
    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("
学生信息删除成功！
");
            found = 1;
            break;
        }
    }
    
    if (!found) {
        printf("
未找到学号为%s的学生！
", id);
    }
}

// 显示所有学生信息
void show_all_students() {
    if (student_count == 0) {
        printf("
暂无学生信息！
");
        return;
    }
    
    printf("
学号	姓名	性别	年龄	成绩
");
    printf("====================================
");
    for (int i = 0; i < student_count; i++) {
        printf("%s	%s	%s	%d	%.1f
", 
               students[i].id, students[i].name, students[i].gender, 
               students[i].age, students[i].score);
    }
    printf("====================================
");
    printf("总共有%d名学生
", student_count);
}

// 统计学生成绩
void statistics() {
    if (student_count == 0) {
        printf("
暂无学生信息！
");
        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("
学生成绩统计：
");
    printf("总人数：%d
", student_count);
    printf("平均分：%.1f
", sum / student_count);
    printf("最高分：%.1f
", max);
    printf("最低分：%.1f
", min);
}

// 保存学生信息到文件
void save_to_file() {
    FILE *fp = fopen(FILENAME, "wb");
    if (fp == NULL) {
        printf("
无法打开文件！
");
        return;
    }
    
    fwrite(&student_count, sizeof(int), 1, fp);
    fwrite(students, sizeof(Student), student_count, fp);
    fclose(fp);
    
    printf("
学生信息已成功保存到文件！
");
}

// 从文件中加载学生信息
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("
已从文件中加载%d名学生信息！
", 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 项目设计思路

1. 使用栈数据结构实现表达式的计算（后缀表达式转换和求值）
2. 使用字符数组存储用户输入的表达式
3. 使用循环实现连续运算功能
4. 使用条件判断实现各种功能键的处理

14.4.3 代码实现

#include 
#include 
#include 
#include 

#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！
");
                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("
========== 简易计算器 ==========
");
        printf("请输入表达式（支持+、-、*、/、%、^、()）：
");
        printf(">>> ");
        fgets(expr, MAX_EXPR, stdin);
        
        // 去除换行符
        expr[strcspn(expr, "
")] = 0;
        
        // 计算表达式的值
        double result = evaluate_expression(expr);
        printf("结果：%g
", result);
        
        printf("
是否继续计算？(y/n)：");
        scanf(" %c", &choice);
        // 清除输入缓冲区
        while (getchar() != '
');
    } while (choice == 'y' || choice == 'Y');
    
    printf("
感谢使用简易计算器！
");
    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 项目开发的基本流程

1. 需求分析：明确项目的功能需求和性能要求
2. 设计阶段：设计项目的架构、数据结构和算法
3. 编码实现：按照设计方案编写代码
4. 测试阶段：对项目进行功能测试和性能测试
5. 调试阶段：修复测试中发现的问题
6. 优化阶段：优化代码的性能和可读性
7. 维护阶段：对项目进行后续的维护和更新

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 项目设计思路

1. 使用双向链表存储文本内容，每一行作为一个节点
2. 使用结构体存储编辑器状态，包括当前光标位置、选中区域、撤销栈等
3. 使用文件操作实现文本的读写
4. 使用栈实现撤销和重做功能
5. 使用菜单驱动的方式实现系统的交互

14.5.3 系统架构设计

简单文本编辑器的系统架构可以分为以下几个模块：

• 用户界面模块：负责处理用户输入和显示文本内容
• 文本处理模块：负责文本的插入、删除、修改等操作
• 文件操作模块：负责文件的新建、打开、保存等操作
• 撤销/重做模块：负责记录和恢复文本操作
• 查找/替换模块：负责文本的查找和替换功能

14.5.4 代码实现

#include 
#include 
#include 

#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] = '';
    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 进行写入
", filename);
        return 0;
    }
    
    LineNode *line = editor.head;
    while (line != NULL) {
        fprintf(fp, "%s
", line->content);
        line = line->next;
    }
    
    fclose(fp);
    strcpy(editor.filename, filename);
    editor.modified = 0;
    printf("文件已保存到 %s
", filename);
    return 1;
}

// 打开文件
int open_file(char *filename) {
    FILE *fp = fopen(filename, "r");
    if (fp == NULL) {
        printf("无法打开文件 %s
", 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, "
")] = '';
        
        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
", filename);
    return 1;
}

// 显示编辑器内容
void display_editor() {
    system("cls"); // 清屏
    
    printf("================== 简单文本编辑器 ==================
");
    if (editor.filename[0] != '') {
        printf("文件: %s %s
", editor.filename, editor.modified ? "*" : "");
    } else {
        printf("未命名文件 %s
", editor.modified ? "*" : "");
    }
    printf("行: %d, 列: %d
", 
           (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("====================================================
");
    
    LineNode *line = editor.head;
    int line_num = 1;
    
    while (line != NULL) {
        // 显示行号
        printf("%4d: ", line_num);
        
        // 显示行内容
        printf("%s
", line->content);
        
        // 如果是当前行，显示光标位置
        if (line == editor.current_line) {
            printf("     ");
            for (int i = 0; i < editor.current_col; i++) {
                printf(" ");
            }
            printf("^
");
        }
        
        line = line->next;
        line_num++;
    }
    
    printf("====================================================
");
    printf("命令: 方向键移动, Ctrl+S 保存, Ctrl+O 打开, Ctrl+N 新建, Ctrl+Q 退出
");
    printf("      Ctrl+Z 撤销, Ctrl+Y 重做, Delete 删除, Backspace 退格
");
}

// 处理用户输入
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] = '';
        
        // 插入新行
        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("撤销功能尚未实现
");
    } else if (c == 25) {
        // Ctrl+Y，重做
        printf("重做功能尚未实现
");
    } else if (c == 19) {
        // Ctrl+S，保存
        if (editor.filename[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] == '') {
                    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语言知识，还可以提高解决实际问题的能力和项目开发能力。每个项目都包含了详细的设计思路、代码实现、优化技巧和测试方法，帮助读者理解完整的项目开发流程。

疑难解析：项目开发常见问题

1. 如何选择合适的数据结构？
   选择数据结构时，需要考虑数据的访问模式、插入删除频率、内存占用等因素。例如：
   • 如果需要频繁访问元素，数组是更好的选择
   • 如果需要频繁插入删除元素，链表是更好的选择
   • 如果需要快速查找元素，哈希表或二叉搜索树是更好的选择
2. 如何提高代码的可读性？
   提高代码可读性的方法包括：
   • 使用有意义的变量名和函数名
   • 添加必要的注释
   • 保持一致的代码风格
   • 避免复杂的嵌套结构
   • 将复杂的函数拆分为多个简单的函数
3. 如何处理错误？
   处理错误的方法包括：
   • 使用返回值表示错误状态
   • 使用errno全局变量存储错误码
   • 使用assert宏验证程序的假设
   • 添加适当的错误提示信息

易错部分：项目开发中的常见错误

1. 内存泄漏
   忘记释放动态分配的内存，导致内存泄漏。解决方法是使用malloc分配内存后，一定要使用free释放。
2. 缓冲区溢出
   输入数据超过了缓冲区的大小，导致缓冲区溢出。解决方法是使用安全的输入函数，如fgets代替gets，或者使用strncpy代替strcpy。
3. 空指针引用
   访问空指针指向的内存，导致程序崩溃。解决方法是在访问指针指向的内存之前，一定要检查指针是否为NULL。
4. 逻辑错误
   代码的逻辑不符合预期，导致程序运行结果错误。解决方法是仔细设计算法，进行充分的测试。
5. 未初始化的变量
   使用未初始化的变量，导致程序行为不确定。解决方法是在使用变量之前，一定要初始化。

在实际项目开发中，读者还需要注意以下几点：

• 选择合适的数据结构和算法
• 编写高效、可读、可维护的代码
• 添加适当的错误处理机制
• 进行充分的测试和调试
• 编写详细的项目文档

希望读者能够在实际开发中不断学习和进步，开发出更多实用、高效的C语言应用程序。

学习建议

• 先理解每个项目的设计思路，再阅读代码实现
• 尝试自己实现项目，遇到问题再参考示例代码
• 根据项目扩展建议，尝试扩展项目的功能
• 学习使用版本控制工具，如Git，管理项目代码
• 参与开源项目，积累实际开发经验
• 学习更多的C语言库和框架，扩展自己的知识面