实战项目模块

zzdxxz

学生成绩管理系统
文本加密解密工具
计算器程序开发
文件压缩基础实现

zzdxxz


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

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

typedef struct {
    char id[12];      // 学号
    char name[20];    // 姓名
    float chinese;    // 语文成绩
    float math;       // 数学成绩
    float english;    // 英语成绩
    float total;      // 总成绩
} Student;

Student students[MAX_STUDENTS];
int count = 0;

// 函数声明
void addStudent();
void displayAll();
void searchStudent();
void modifyStudent();
void deleteStudent();
void saveToFile();
void loadFromFile();
void showMenu();
void clearInputBuffer();

int main() {
    loadFromFile();
    while(1) {
        showMenu();
        int choice;
        printf("请输入选项：");
        scanf("%d", &choice);
        clearInputBuffer();

        switch(choice) {
            case 1: addStudent(); break;
            case 2: displayAll(); break;
            case 3: searchStudent(); break;
            case 4: modifyStudent(); break;
            case 5: deleteStudent(); break;
            case 6: saveToFile(); break;
            case 0: 
                saveToFile();
                printf("感谢使用，再见！\n");
                exit(0);
            default: 
                printf("无效选项，请重新输入！\n");
        }
    }
    return 0;
}

void showMenu() {
    printf("\n===== 学生成绩管理系统 =====\n");
    printf("1. 添加学生信息\n");
    printf("2. 显示所有学生\n");
    printf("3. 查找学生信息\n");
    printf("4. 修改学生成绩\n");
    printf("5. 删除学生记录\n");
    printf("6. 立即保存数据\n");
    printf("0. 退出系统\n");
    printf("===========================\n");
}

void addStudent() {
    if(count >= MAX_STUDENTS) {
        printf("学生数量已达上限！\n");
        return;
    }

    Student s;
    printf("\n--- 添加学生信息 ---\n");
    
    // 输入学号
    while(1) {
        printf("请输入学号(11位数字)：");
        scanf("%11s", s.id);
        clearInputBuffer();
        
        // 验证学号唯一性
        int exists = 0;
        for(int i=0; i<count; i++) {
            if(strcmp(students[i].id, s.id) == 0) {
                exists = 1;
                break;
            }
        }
        
        if(strlen(s.id) != 11 || !isdigit(s.id[0])) {
            printf("学号格式错误！\n");
        } else if(exists) {
            printf("该学号已存在！\n");
        } else {
            break;
        }
    }

    // 输入姓名
    printf("请输入姓名：");
    scanf("%19s", s.name);
    clearInputBuffer();

    // 输入成绩
    printf("请输入语文成绩：");
    while(scanf("%f", &s.chinese) != 1 || s.chinese <0 || s.chinese >150) {
        printf("成绩无效，请重新输入(0-150)：");
        clearInputBuffer();
    }
    
    printf("请输入数学成绩：");
    while(scanf("%f", &s.math) != 1 || s.math <0 || s.math >150) {
        printf("成绩无效，请重新输入(0-150)：");
        clearInputBuffer();
    }
    
    printf("请输入英语成绩：");
    while(scanf("%f", &s.english) != 1 || s.english <0 || s.english >150) {
        printf("成绩无效，请重新输入(0-150)：");
        clearInputBuffer();
    }

    // 计算总分
    s.total = s.chinese + s.math + s.english;

    students[count++] = s;
    printf("学生信息添加成功！\n");
}

void displayAll() {
    if(count == 0) {
        printf("当前没有学生记录！\n");
        return;
    }

    printf("\n%-12s %-20s %-8s %-8s %-8s %-8s\n", 
           "学号", "姓名", "语文", "数学", "英语", "总分");
    printf("------------------------------------------------------------\n");
    
    for(int i=0; i<count; i++) {
        printf("%-12s %-20s %-8.1f %-8.1f %-8.1f %-8.1f\n",
               students[i].id,
               students[i].name,
               students[i].chinese,
               students[i].math,
               students[i].english,
               students[i].total);
    }
}

void searchStudent() {
    char target[20];
    int found = 0;
    
    printf("\n请输入要查找的学号或姓名：");
    scanf("%19s", target);
    clearInputBuffer();

    printf("\n查询结果：\n");
    printf("%-12s %-20s %-8s %-8s %-8s %-8s\n", 
           "学号", "姓名", "语文", "数学", "英语", "总分");
    
    for(int i=0; i<count; i++) {
        if(strcmp(students[i].id, target) == 0 || 
           strcmp(students[i].name, target) == 0) {
            printf("%-12s %-20s %-8.1f %-8.1f %-8.1f %-8.1f\n",
                   students[i].id,
                   students[i].name,
                   students[i].chinese,
                   students[i].math,
                   students[i].english,
                   students[i].total);
            found = 1;
        }
    }
    
    if(!found) {
        printf("未找到匹配的学生记录！\n");
    }
}

void modifyStudent() {
    char id[12];
    int index = -1;
    
    printf("\n请输入要修改的学号：");
    scanf("%11s", id);
    clearInputBuffer();

    // 查找学生
    for(int i=0; i<count; i++) {
        if(strcmp(students[i].id, id) == 0) {
            index = i;
            break;
        }
    }
    
    if(index == -1) {
        printf("未找到该学生记录！\n");
        return;
    }

    printf("\n当前信息：\n");
    printf("1. 语文成绩：%.1f\n", students[index].chinese);
    printf("2. 数学成绩：%.1f\n", students[index].math);
    printf("3. 英语成绩：%.1f\n", students[index].english);
    
    int choice;
    printf("请选择要修改的项目（1-3）：");
    scanf("%d", &choice);
    clearInputBuffer();

    float newScore;
    printf("请输入新成绩：");
    while(scanf("%f", &newScore) != 1 || newScore <0 || newScore >150) {
        printf("成绩无效，请重新输入(0-150)：");
        clearInputBuffer();
    }

    switch(choice) {
        case 1: students[index].chinese = newScore; break;
        case 2: students[index].math = newScore; break;
        case 3: students[index].english = newScore; break;
        default: 
            printf("无效选项！\n");
            return;
    }

    // 重新计算总分
    students[index].total = students[index].chinese 
                          + students[index].math 
                          + students[index].english;
    printf("成绩修改成功！\n");
}

void deleteStudent() {
    char id[12];
    int index = -1;
    
    printf("\n请输入要删除的学号：");
    scanf("%11s", id);
    clearInputBuffer();

    // 查找学生
    for(int i=0; i<count; i++) {
        if(strcmp(students[i].id, id) == 0) {
            index = i;
            break;
        }
    }
    
    if(index == -1) {
        printf("未找到该学生记录！\n");
        return;
    }

    // 确认删除
    char confirm;
    printf("确定要删除 %s 的记录吗？(y/n): ", students[index].name);
    scanf("%c", &confirm);
    clearInputBuffer();

    if(confirm == 'y' || confirm == 'Y') {
        // 移动数组元素
        for(int i=index; i<count-1; i++) {
            students[i] = students[i+1];
        }
        count--;
        printf("记录删除成功！\n");
    } else {
        printf("取消删除操作\n");
    }
}

void saveToFile() {
    FILE *fp = fopen(FILENAME, "wb");
    if(fp == NULL) {
        perror("保存文件失败");
        return;
    }
    
    fwrite(&count, sizeof(int), 1, fp);
    fwrite(students, sizeof(Student), count, fp);
    fclose(fp);
    printf("数据保存成功！\n");
}

void loadFromFile() {
    FILE *fp = fopen(FILENAME, "rb");
    if(fp == NULL) {
        printf("未找到数据文件，将创建新文件\n");
        return;
    }
    
    fread(&count, sizeof(int), 1, fp);
    fread(students, sizeof(Student), count, fp);
    fclose(fp);
    printf("数据加载成功，共加载 %d 条记录\n", count);
}

void clearInputBuffer() {
    while(getchar() != '\n');
}

zzdxxz

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

// 加密/解密函数
// 参数：
//   data - 需要处理的数据指针
//   data_len - 数据长度
//   key - 密钥字符串
void encrypt_decrypt(char *data, size_t data_len, const char *key) {
    size_t key_len = strlen(key);
    if (key_len == 0) return;  // 空密钥不处理
    
    // 对每个字节使用异或运算进行加密/解密
    for (size_t i = 0; i < data_len; i++) {
        data[i] ^= key[i % key_len];  // 循环使用密钥中的字符
    }
}

// 处理文件函数
// 参数：
//   input_file - 输入文件名
//   output_file - 输出文件名
//   key - 加密/解密密钥
void process_file(const char *input_file, const char *output_file, const char *key) {
    FILE *fp_in, *fp_out;
    char *buffer;
    long file_size;

    // 打开输入文件（二进制模式）
    fp_in = fopen(input_file, "rb");
    if (!fp_in) {
        perror("无法打开输入文件");
        exit(EXIT_FAILURE);
    }

    // 获取文件大小
    fseek(fp_in, 0, SEEK_END);
    file_size = ftell(fp_in);
    rewind(fp_in);

    // 分配内存缓冲区
    buffer = (char *)malloc(file_size);
    if (!buffer) {
        perror("内存分配失败");
        fclose(fp_in);
        exit(EXIT_FAILURE);
    }

    // 读取文件内容
    if (fread(buffer, 1, file_size, fp_in) != (size_t)file_size) {
        perror("文件读取失败");
        fclose(fp_in);
        free(buffer);
        exit(EXIT_FAILURE);
    }

    // 关闭输入文件
    fclose(fp_in);

    // 执行加密/解密操作
    encrypt_decrypt(buffer, file_size, key);

    // 打开输出文件（二进制模式）
    fp_out = fopen(output_file, "wb");
    if (!fp_out) {
        perror("无法创建输出文件");
        free(buffer);
        exit(EXIT_FAILURE);
    }

    // 写入处理后的数据
    if (fwrite(buffer, 1, file_size, fp_out) != (size_t)file_size) {
        perror("文件写入失败");
        fclose(fp_out);
        free(buffer);
        exit(EXIT_FAILURE);
    }

    // 清理资源
    fclose(fp_out);
    free(buffer);

    printf("操作成功完成！\n");
}

int main() {
    int choice;
    char input_file[256];
    char output_file[256];
    char key[256];

    printf("文本文件加密/解密工具\n");
    printf("1. 加密文件\n");
    printf("2. 解密文件\n");
    printf("请选择操作：");
    scanf("%d", &choice);

    printf("请输入输入文件名：");
    scanf("%255s", input_file);
    printf("请输入输出文件名：");
    scanf("%255s", output_file);
    printf("请输入加解密密钥：");
    scanf("%255s", key);

    // 加密和解密使用相同的处理流程
    process_file(input_file, output_file, key);

    return 0;
}

zzdxxz

#include <stdio.h>
#include <ctype.h>   // 用于字符处理
#include <stdlib.h>  // 用于exit函数

// 函数声明
double add(double a, double b);
double subtract(double a, double b);
double multiply(double a, double b);
double divide(double a, double b);
void clear_input_buffer();
int get_valid_number(const char *prompt, double *num);
void print_menu();

// 主函数
int main() {
    char choice;
    double result = 0.0;
    double num1, num2;
    int use_previous_result = 0;

    printf("欢迎使用命令行计算器！\n");

    while (1) {
        // 显示菜单选项
        print_menu();

        printf("请输入选项（1-5）：");
        scanf(" %c", &choice);
        clear_input_buffer();  // 清除多余的输入

        // 处理退出选项
        if (choice == '5') {
            printf("\n感谢使用，再见！\n");
            exit(0);
        }

        // 获取第一个操作数
        if (!use_previous_result) {
            while (!get_valid_number("请输入第一个数字：", &num1)) {
                printf("无效输入，请重新输入！\n");
            }
            result = num1;
        }

        // 获取第二个操作数
        while (!get_valid_number("请输入第二个数字：", &num2)) {
            printf("无效输入，请重新输入！\n");
        }

        // 执行运算
        switch (choice) {
            case '1':
                result = add(result, num2);
                printf("结果：%.2lf\n", result);
                break;
            case '2':
                result = subtract(result, num2);
                printf("结果：%.2lf\n", result);
                break;
            case '3':
                result = multiply(result, num2);
                printf("结果：%.2lf\n", result);
                break;
            case '4':
                if (num2 == 0) {
                    printf("错误：除数不能为零！\n");
                    continue;
                }
                result = divide(result, num2);
                printf("结果：%.2lf\n", result);
                break;
            default:
                printf("无效选项，请重新选择！\n");
                continue;
        }

        // 询问是否继续使用当前结果
        printf("是否使用当前结果继续计算？(y/n)：");
        scanf(" %c", &choice);
        clear_input_buffer();
        use_previous_result = (tolower(choice) == 'y');
        
        if (!use_previous_result) {
            result = 0.0;  // 重置结果
            printf("\n");
        }
    }

    return 0;
}

// 加法运算
double add(double a, double b) {
    return a + b;
}

// 减法运算
double subtract(double a, double b) {
    return a - b;
}

// 乘法运算
double multiply(double a, double b) {
    return a * b;
}

// 除法运算（调用前需确保b不为0）
double divide(double a, double b) {
    return a / b;
}

// 清除输入缓冲区
void clear_input_buffer() {
    int c;
    while ((c = getchar()) != '\n' && c != EOF);
}

// 获取有效数字输入
int get_valid_number(const char *prompt, double *num) {
    printf("%s", prompt);
    while (scanf("%lf", num) != 1) {
        printf("无效输入，请输入数字：");
        clear_input_buffer();
        return 0;  // 获取失败
    }
    clear_input_buffer();
    return 1;      // 获取成功
}

// 打印菜单
void print_menu() {
    printf("\n===== 计算器菜单 =====\n");
    printf("1. 加法 (+)\n");
    printf("2. 减法 (-)\n");
    printf("3. 乘法 (*)\n");
    printf("4. 除法 (/)\n");
    printf("5. 退出程序\n");
    printf("======================\n");
}

zzdxxz

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

#define MAX_RUN_LENGTH 127  // 最大连续重复次数（使用单字节存储）

// RLE压缩函数
unsigned char* compress_data(const unsigned char* input, size_t input_len, size_t* output_len) {
    unsigned char* output = malloc(input_len * 2);  // 最坏情况分配双倍空间
    if (!output) return NULL;

    size_t out_index = 0;
    size_t in_index = 0;

    while (in_index < input_len) {
        unsigned char current = input[in_index];
        size_t run_length = 1;

        // 计算连续重复字符数量
        while (in_index + 1 < input_len && 
               input[in_index + 1] == current && 
               run_length < MAX_RUN_LENGTH) {
            run_length++;
            in_index++;
        }

        // 写入压缩数据（长度+字符）
        output[out_index++] = (unsigned char)(run_length);
        output[out_index++] = current;
        in_index++;
    }

    *output_len = out_index;
    return output;
}

// RLE解压函数
unsigned char* decompress_data(const unsigned char* input, size_t input_len, size_t* output_len) {
    size_t estimate_size = 0;
    
    // 计算解压后数据大小
    for (size_t i = 0; i < input_len; i += 2) {
        estimate_size += input[i];
    }

    unsigned char* output = malloc(estimate_size);
    if (!output) return NULL;

    size_t out_index = 0;
    
    for (size_t i = 0; i < input_len; i += 2) {
        unsigned char count = input[i];
        unsigned char value = input[i + 1];
        
        memset(output + out_index, value, count);
        out_index += count;
    }

    *output_len = out_index;
    return output;
}

// 文件压缩/解压处理函数
void process_file(const char* input_file, const char* output_file, int compress_mode) {
    FILE* fp_in = fopen(input_file, "rb");
    if (!fp_in) {
        perror("无法打开输入文件");
        exit(EXIT_FAILURE);
    }

    // 获取文件大小
    fseek(fp_in, 0, SEEK_END);
    long file_size = ftell(fp_in);
    rewind(fp_in);

    // 读取文件内容
    unsigned char* input_data = malloc(file_size);
    if (!input_data) {
        perror("内存分配失败");
        fclose(fp_in);
        exit(EXIT_FAILURE);
    }

    if (fread(input_data, 1, file_size, fp_in) != (size_t)file_size) {
        perror("文件读取失败");
        fclose(fp_in);
        free(input_data);
        exit(EXIT_FAILURE);
    }
    fclose(fp_in);

    // 处理数据
    unsigned char* output_data = NULL;
    size_t output_size = 0;

    if (compress_mode) {
        output_data = compress_data(input_data, file_size, &output_size);
    } else {
        output_data = decompress_data(input_data, file_size, &output_size);
    }

    if (!output_data) {
        perror("数据处理失败");
        free(input_data);
        exit(EXIT_FAILURE);
    }

    // 写入输出文件
    FILE* fp_out = fopen(output_file, "wb");
    if (!fp_out) {
        perror("无法创建输出文件");
        free(input_data);
        free(output_data);
        exit(EXIT_FAILURE);
    }

    if (fwrite(output_data, 1, output_size, fp_out) != output_size) {
        perror("文件写入失败");
        free(input_data);
        free(output_data);
        fclose(fp_out);
        exit(EXIT_FAILURE);
    }

    // 清理资源
    free(input_data);
    free(output_data);
    fclose(fp_out);

    printf("操作成功！原始大小：%ld，处理后大小：%zu\n", file_size, output_size);
}

int main(int argc, char* argv[]) {
    if (argc != 4) {
        printf("使用方法：\n");
        printf("压缩：%s -c 输入文件 输出文件\n", argv[0]);
        printf("解压：%s -d 输入文件 输出文件\n", argv[0]);
        return EXIT_FAILURE;
    }

    int compress_mode = 0;
    if (strcmp(argv[1], "-c") == 0) {
        compress_mode = 1;
    } else if (strcmp(argv[1], "-d") == 0) {
        compress_mode = 0;
    } else {
        printf("无效参数！\n");
        return EXIT_FAILURE;
    }

    process_file(argv[2], argv[3], compress_mode);
    return EXIT_SUCCESS;
}