基于C语言的卡丁车管理系统【控制台应用程序】

注意：需要提前创建对应的.dat文件
本项目实现了数据的永久存储，有用户的注册、登录。
管理员对卡丁车的管理、查看预约用户、修改帐户权限。
用户对个人信息的管理、查看并预约卡丁车、卡丁车维修上报。
维修员对卡丁车的维修状态上报、个人信息管理。

登录信息页面

login.h

//
// Created by SGCNB666 on 2024/12/27.
//

#ifndef GO_KARTS_LOGIN_H
#define GO_KARTS_LOGIN_H

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

// 账户机构提
typedef struct User
{
    char username[20]; // 用户名
    char password[20]; // 密码
    char permission;   // 权限
}User;

// 用户个人信息
typedef struct UserPerson
{
    char name[20]; //用户名
    char phone[15]; //电话
    int kart_booknot; //预约卡丁车编号
}UserPerson;

// 用户链表
typedef struct UserList
{
    User  data; // 用户信息
    struct UserList *next; // 指向下一个用户
}UserList;

// 用户个人信息链表
typedef struct UserPersonList
{
    UserPerson data; //用户个人信息
    struct UserPersonList *next; //指向下一个用户个信息
}UserPersonList;

/**
 * 登录验证
 * */
UserList* user(UserList *head);

/**
 * 注册
 * */
int enroll_user(UserList **head);

/**
 * 插入用户
 * */
int init_user_list(UserList **head, User user);

/**
 * 用户信息的添加
 * */
void add_user_person(UserPersonList **head, UserList *user);

/**
 * 创建用户个人信息
 * */
int init_user_Person_list(UserPersonList **head, UserPerson *userPerson);

/**
 * 销毁用户列表
 * */
void destroy_user_list(UserList *head);

/**
 *  销毁用户个人信息列表
 * */
void destroy_user_person_list(UserPersonList *head);

/**
 * 保存用户列表到文件
 * */
void save_user_file(UserList *head);

/**
 *  保存用户个人信息列表到文件
 * */
void save_user_person_file(UserPersonList *head);

/**
 * 从文件加载用户列表
 * */
void load_user_file(UserList **head);

/**
 * 从文件加载用户个人信息列表
 * */
void load_user_person_file(UserPersonList **head);

/**
 * 程序欢迎界面
 * */
void login_welcome();

/**
 * 登录主界面
 * */
UserList* login(UserList **head);

/**
 * 输出用户列表
 * */
void print_user_list(UserList *head);

#endif //GO_KARTS_LOGIN_H

login.c

#include "login.h"

/**
 * 登录验证
 * */
UserList* user(UserList *head)
{
    UserList *p = head; // p指向头节点
    User user;   // 用户信息

    printf("请输入用户名：");
    scanf("%s", user.username); // 输入用户名
    printf("请输入密码：");
    scanf("%s", user.password); // 输入密码

    while(p) // 遍历链表
    {
        if(!strcmp(p->data.username, user.username) && !strcmp(p->data.password, user.password)) // 用户名和密码都正确
        {
            return p;
        }
        p = p->next; // p指向下一个节点
    }
    return NULL;
}

/**
 * 注册
 * */
int enroll_user(UserList **head)
{

    User user; // 用户信息
    UserList *p = *head; // p指向头节点
    int flag = 1; // 标志位
    while(flag) // 循环输入用户名
    {
        printf("请输入用户名：");
        scanf("%s", user.username); // 输入用户名
        while (p)
        {
            if(!strcmp(p->data.username, user.username)) // 用户名已存在
            {
                printf("用户名已存在，请重新输入！\n");
                flag = 1;
                break;
            }
            flag = 0; // 没有找到相同的用户名，更改标志位
            p = p->next; // p指向下一个节点
        }
        p = *head; // p重新指向头节点
    }
    printf("请输入密码：");
    scanf("%s", user.password); // 输入密码

    if(strcmp(user.username, "admin")) // 如果是管理员，管理员有且仅有admin一个
    {
        user.permission = 'A'; // 管理员权限
    }
    else
    {
        user.permission = 'U'; // 否则是用户权限
    }

    if( init_user_list(head, user) ) // 插入用户
    {
        return -1;
    }
    return 0;
}

/**
 * 插入用户
 * */
int init_user_list(UserList **head, User user)
{
    UserList *pNew = (UserList *)malloc(sizeof (UserList)); // 分配内存
    UserList *p = *head; // p指向头节点
    if(!pNew) // 分配内存失败
    {
        perror("内存分配失败！");
        return -1;
    }

    if(*head != NULL) // 链表不为空
    {
        while(p->next) // 遍历链表
        {
            p = p->next; // p指向下一个节点
        }
        p->next  = pNew; // p指向新节点
        pNew->data = user; // 插入用户信息
        pNew->next = NULL; // 新节点的next指向NULL
        return 0;
    }
    pNew->next = NULL; // 新节点的next指向NULL
    pNew->data = user; // 插入用户信息
    *head = pNew; // 头节点指向新节点
    return 0;
}

/**
 * 用户信息的添加
 * */
void add_user_person(UserPersonList **head, UserList *user)
{
    UserPersonList *p = *head; // p指向头节点

    while(p) // 遍历链表
    {
        if(!strcmp(p->data.name, user->data.username)) // 找到相同的用户名
        {
            return;
        }
        p = p->next; // p指向下一个节点
    }
    UserPerson userPerson; // 用户个人信息
    printf("您是第一次登录，请完善个人信息\n");
    strcpy(userPerson.name ,user->data.username); // 用户名
    userPerson.kart_booknot = 0; // 默认没有预约，默认为0，1表示已经被预约
    printf("请输入您的手机号：");
    scanf("%s", userPerson.phone); // 手机号
    while (getchar()!= '\n');
    init_user_Person_list(head, &userPerson); // 插入用户个人信息
    return;
}

/**
 * 创建用户个人信息
 * */
int init_user_Person_list(UserPersonList **head, UserPerson *userPerson)
{
    UserPersonList *pNew = (UserPersonList *)malloc(sizeof (UserPersonList)); // 分配内存
    UserPersonList *p = *head; // p指向头节点
    if(!pNew) // 分配内存失败
    {
        perror("内存分配失败！");
        return -1;
    }

    if(*head != NULL) // 链表不为空
    {
        while(p->next) // 遍历链表
        {
            p = p->next; // p指向下一个节点
        }
        p->next  = pNew; // p指向新节点
        pNew->data = *userPerson; // 插入用户个人信息
        pNew->next = NULL; // 新节点的next指向NULL
        return 0;
    }
    pNew->next = NULL; // 新节点的next指向NULL
    pNew->data = *userPerson; // 插入用户个人信息
    *head = pNew; // 头节点指向新节点
    return 0;
}

/**
 * 销毁用户列表
 * */
void destroy_user_list(UserList *head)
{
    UserList *p = head, *q = NULL; // p指向头节点，q指向p的前一个节点
    while(p) // 遍历链表，指针尾随
    {
        q = p; // q指向p
        p = p->next; // p指向下一个节点
        free(q); // 释放q
    }
}

/**
 *  销毁用户个人信息列表
 * */
void destroy_user_person_list(UserPersonList *head)
{
    UserPersonList *p = head, *q = NULL; // p指向头节点，q指向p的前一个节点
    while(p)  // 遍历链表，指针尾随
    {
        q = p; // q指向p
        p = p->next; // p指向下一个节点
        free(q); // 释放q
    }
}

/**
 * 保存用户列表到文件
 * */
void save_user_file(UserList *head)
{
    FILE  *fp; // 文件指针
    fp = fopen("login_user.dat", "wb"); // 以二进制方式打开文件

    if(!fp) // 文件打开失败
    {
        perror("文件打开失败");
        return;
    }

    UserList *p = head; // p指向头节点
    while(p) // 遍历链表
    {
        fwrite(&(p->data), sizeof(User), 1, fp); // 写入文件，每次写入一个用户信息
        p = p->next; // p指向下一个节点
    }
    printf("保存成功！\n");
    fclose(fp); // 关闭文件
}

/**
 *  保存用户个人信息列表到文件
 * */
void save_user_person_file(UserPersonList *head)
{
    FILE  *fp; // 文件指针
    fp = fopen("person_info.dat", "wb"); // 以二进制方式打开文件

    if(!fp) // 文件打开失败
    {
        perror("文件打开失败");
        return;
    }

    UserPersonList *p = head; // p指向头节点
    while(p) // 遍历链表
    {
        fwrite(&(p->data), sizeof(UserPerson), 1, fp); // 写入文件，每次写入一个用户信息
        p = p->next; // p指向下一个节点
    }
    printf("保存成功！\n");
    fclose(fp); // 关闭文件
}

/**
 * 从文件加载用户列表
 * */
void load_user_file(UserList **head)
{
    FILE *fp; // 文件指针
    fp = fopen("login_user.dat", "rb"); // 以二进制方式打开文件
    if(!fp) // 文件打开失败
    {
        perror("文件打开失败");
        return;
    }

    User user; // 用户信息
    while(fread(&user, sizeof (User), 1, fp) == 1 ) // 读取文件，每次读取一个用户信息
    {
        init_user_list(head, user); // 读取用户列表
    }
    fclose(fp); // 关闭文件
}

/**
 * 从文件加载用户个人信息列表
 * */
void load_user_person_file(UserPersonList **head)
{
    FILE *fp; // 文件指针
    fp = fopen("person_info.dat", "rb"); // 以二进制方式打开文件
    if(!fp)
    {
        perror("文件打开失败");
        return;
    }

    UserPerson userPerson1; // 用户信息
    while(fread(&userPerson1, sizeof (UserPerson), 1, fp) == 1 ) // 读取文件，每次读取一个用户信息
    {
        init_user_Person_list( head,&userPerson1); // 读取用户列表
    }
    fclose(fp); // 关闭文件
}

/**
 * 程序欢迎界面
 * */
void login_welcome()
{
    system("clear"); // 清屏
    printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
    printf("┃                                                      ┃\n");
    printf("┃            欢迎进入卡丁车管理系统有系统              ┃\n");
    printf("┃                                                      ┃\n");
    printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
    printf("按任意键继续...\n");
    getchar();
}

/**
 * 登录主界面
 * */
UserList* login(UserList **head)
{
    printf("登录页面\n");
    UserList* p = NULL; // p指向头节点
    char ch;
    while(1)
    {
        system("clear"); // 清屏
        printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
        printf("┃ 1.登录               2.注册                3.退出    ┃\n");
        printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
        printf("请选择：");
        scanf("%c", &ch);
        switch (ch)
        {
            case '1':
                p = user(*head);
                if( p )
                {
                    printf("登录成功!\n");
                    return p;
                }
                else
                {
                    printf("密码错误，登录失败!\n");
                }
                break;
            case '2':
                enroll_user(head);
                break;
            case '3':
            {
                return NULL;
            }
                break;
            case '4':
                print_user_list(*head);
                break;
            default:
                printf("输入错误，请重新输入！\n");
                break;
        }
        while (getchar() != '\n');
        printf("按任意键继续...\n");
        getchar();
    }
}

/**
 * 打印用户列表
 * */
void print_user_list(UserList *head)
{
    UserList *p = head;
    while(p)
    {
        printf("用户名：%s\n", p->data.username);
        printf("密码：%s\n", p->data.password);
        printf("权限：%c\n", p->data.permission);
        p = p->next;
    }
}

登录后页面

home_face.h

//
// Created by SGCNB666 on 2024/12/31.
//

#ifndef GO_KARTS_HOME_FACE_H
#define GO_KARTS_HOME_FACE_H

#include <stdio.h>
#include "login.h"
#include "user.h"
#include "admin.h"
#include "repair.h"

/**
 * 显示管理员主页面
 */
void admin_home(UserPersonList* head_person,KartNode** head, UserList* head_user);

/**
 * 显示用户主页面
 */
void user_home(UserPersonList* head_person,KartNode* head_kart,UserList *user_List);

/**
 * 显示维修员主页面
 */
void repair_home(UserPersonList* head_person,KartNode* head_kart,UserList *user_List);

 /**
  * 卡丁车信息界面
  * */
void karts_info(KartNode** head);

/**
 * 权限管理页面
 * */
void user_info(UserList* head);

/**
 * 卡丁车预约界面
 * */
void katrs_book(UserPerson* head_person,KartNode* head_kart);

/**
 * 个人信息管理界面
 * */
void user_person(UserPerson* userPerson, UserList* user_List);

/**
 * 卡丁车报修界面
 * */
void karts_repair(KartNode* head_kart);

/**
 * 修改密码
 * */
void change_password(UserList* user);

#endif //GO_KARTS_HOME_FACE_H

home_face.c

//
// Created by SGCNB666 on 2024/12/31.
//

#include "home_face.h"

/**
 * 显示管理员主界面
 * */
void admin_home(UserPersonList* head_person,KartNode** head_kart, UserList* head_user)
{
    while(1)
    {
        system("clear"); // 清屏
        char ch;
        while (getchar() != '\n');
        printf("管理员主页面\n");
        printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
        printf("┃     1.退出       2.卡丁车信息管理       3.权限管理     4.删除用户      ┃\n");
        printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
        printf("请选择：");
        scanf("%c", &ch);
        switch (ch)
        {
            case '1':
                save_user_person_file(head_person);
                save_user_file(head_user);
                return;
                break;
            case '2':
                karts_info( head_kart);
                break;
            case '3':
                user_info(head_user);
                break;
            case '4':
                delete_User(&head_user, &head_person);
                break;
            default:
                printf("输入错误，请重新输入！\n");
                break;
        }
        while (getchar() != '\n');
        printf("按任意键继续...\n");
        getchar();
    }



}

/**
 * 显示用户主页面
 */
void user_home(UserPersonList* head_person,KartNode* head_kart,UserList *user_List)
{
    while (getchar() != '\n');
    UserPersonList *p = head_person;
    KartNode *p_kart = head_kart;
    while(p)
    {
        if(strcmp(p->data.name,user_List->data.username)==0)
        {
            break;
        }
        p = p->next;
    }

    UserPerson *userPerson = &(p->data);

    while(1)
    {
        system("clear"); // 清屏
        char ch;
        while (getchar()!= '\n');
        printf("用户主页面\n");
        printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
        printf("┃      1.退出               2.卡丁车预约管理              3.个人信息管理           ┃\n");
        printf("┃              4.卡丁车报修                  5.卡丁车信息查询                      ┃\n");
        printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
        printf("请选择：");
        scanf("%c", &ch);
        switch (ch)
        {
            case '1':
                user_kart_booknot_save(head_person,head_kart);
                return;
                break;
            case '2':
                katrs_book(&p->data,p_kart);
                break;
            case '3':
                user_person(&p->data,user_List);
                break;
            case '4':
                user_kart_repair(&p->data,p_kart);
                break;
            case '5':
                print_Kart_list(p_kart);
                break;
            default:
                printf("输入错误，请重新输入！\n");
                break;
        }
        printf("按任意键继续...\n");
        while (getchar()!= '\n');
        getchar();

    }

}

/**
 * 显示维修员主页面
 */
void repair_home(UserPersonList* head_person,KartNode* head_kart,UserList *user_List)
{
    while (getchar() != '\n');
    UserPersonList *p = head_person;
    KartNode *p_kart = head_kart;
    while(p)
    {
        if(strcmp(p->data.name,user_List->data.username)==0)
        {
            break;
        }
        p = p->next;
    }
    UserPerson *userPerson = &(p->data);
    while (1)
    {
        system("clear"); // 清屏
        char ch;
        printf("维修员主页面\n");
        printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
        printf("┃      1.退出               2.卡丁车报修管理             3.个人信息管理            ┃\n");
        printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
        printf("请选择：");
        scanf("%c", &ch);
        switch (ch)
        {
            case '1':
                user_kart_booknot_save(head_person,head_kart);
                return;
                break;
            case '2':
                karts_repair(head_kart);
                break;
            case '3':
                user_person(&p->data,user_List);
                break;
            default:
                printf("输入错误，请重新输入！\n");
                break;

        }
    }

}



/**
 * 卡丁车信息界面
 * */
void karts_info(KartNode** head)
{
    load_Kart_file(head);
    while(1)
    {
        system("clear"); // 清屏
        char ch;
        while (getchar() != '\n');
        printf("卡丁车信息管理页面\n");
        printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
        printf("┃    1.保存退出          2.增加卡丁车信息         3.删除卡丁车信息       ┃\n");
        printf("┃            4.修改卡丁车信息             5.查询卡丁车信息               ┃\n");
        printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
        printf("请选择：");
        scanf("%c", &ch);
        switch (ch)
        {
            case '1':
                save_Kart_file(*head);
                return;
                break;
            case '2':
                enroll_Kart(head);
                break;
            case '3':
                delete_Kart(head);
                break;
            case '4':
                modify_Kart(*head);
                break;
            case '5':
                print_Kart_list(*head);
                break;
            default:
                printf("输入错误，请重新输入！\n");
                break;
        }
        printf("按任意键继续...\n");
        while (getchar() != '\n');
        getchar();
    }
}

/**
 * 权限管理页面
 * */
void user_info(UserList* head)
{
    while(1)
    {
        system("clear"); // 清屏
        char ch;
        while (getchar() != '\n');
        printf("权限身份管理页面\n");
        printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
        printf("┃     1.保存退出                          2.修改用户权限身份标识         ┃\n");
        printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
        printf("请选择：");
        scanf("%c", &ch);
        while (getchar() != '\n');
        switch (ch)
        {
            case '1':
                save_user_file(head);
                return;
                break;
            case '2':
                revise_User_perm(head);
                break;
            default:
                printf("输入错误，请重新输入！\n");
                break;
        }
        printf("按任意键继续...\n");
        while (getchar() != '\n');
    }
}

/**
 * 卡丁车预约界面
 * */
void katrs_book(UserPerson* userPerson,KartNode* head_kart)
{
    while(1)
    {
        system("clear"); // 清屏
        char ch;
        while (getchar() != '\n');
        printf("预约管理页面\n");
        printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
        printf("┃     1.退出           2.卡丁车预约             3.卡丁车预约取消         ┃\n");
        printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
        printf("请选择：");
        scanf("%c", &ch);
        while (getchar() != '\n');
        switch (ch)
        {
            case '1':
                return;
                break;
            case '2':
                user_kart_booknot(userPerson,head_kart);
                break;
            case '3':
                user_kart_booknot_cancel(userPerson,head_kart);
                break;
            default:
                printf("输入错误，请重新输入！\n");
                break;
        }
        printf("按任意键继续...\n");
        while (getchar() != '\n');
    }
}

/**
 * 个人信息管理界面
 * */
void user_person(UserPerson* userPerson, UserList* user_List)
{
    while(1)
    {
        system("clear"); // 清屏
        char ch;
        while (getchar() != '\n');
        printf("个人信管理页面\n");
        printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
        printf("┃       1.退出       2.查看个人信息      3.修改个人信息     4.修改密码   ┃\n");
        printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
        printf("请选择：");
        scanf("%c", &ch);
        while (getchar() != '\n');
        switch (ch)
        {
            case '1':
                save_user_file(user_List);
                return;
                break;
            case '2':
                if(user_List->data.permission == 'R')
                {
                    print_repair_info(userPerson);
                }
                else
                {
                    print_user_info(userPerson);
                }

                break;
            case '3':
                revise_user_info(userPerson);
                break;
            case '4':
                change_password(user_List);
                break;
            default:
                printf("输入错误，请重新输入！\n");
                break;
        }
        printf("按任意键继续...\n");
        while (getchar() != '\n');
    }
}

/**
 * 卡丁车报修界面
 * */
void karts_repair(KartNode* head_kart)
{
    while(1)
    {
        system("clear"); // 清屏
        char ch;
        while (getchar() != '\n');
        printf("卡丁车报修管理页面\n");
        printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
        printf("┃      1.退出      2.查看待报修卡丁车      3.上报维修完成或无法维修进行报废处理       ┃\n");
        printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
        printf("请选择：");
        scanf("%c", &ch);
        while (getchar() != '\n');
        switch (ch)
        {
            case '1':
                save_Kart_file(head_kart);
                return;
                break;
            case '2':
                repair_karts_info(head_kart);
                break;
            case '3':
                report_repair_info(head_kart);
                break;
            default:
                printf("输入错误，请重新输入！\n");
                break;
        }
        printf("按任意键继续...\n");
        while (getchar() != '\n');
    }
}

/**
 * 修改密码
 * */
void change_password(UserList* user)
{
    printf("请输入新密码：");
    scanf("%s",user->data.password);
    return;
}

管理员功能页面

admin.h

//
// Created by SGCNB666 on 2024/12/31.
//

#ifndef GO_KARTS_ADMIN_H
#define GO_KARTS_ADMIN_H
#include <stdio.h>
#include <stdlib.h>
#include "login.h"

// 赛车结构体
typedef struct Kart
{
   int kart_id;     // 赛车编号
   char repair_not; // 是否需要维修
   char kart_name[20];  // 赛车名称
   char kart_type[20];  // 赛车类型
   char kart_color[20];  // 赛车颜色
   char book_not;  // 是否被预定
   char user_name[20];  // 预定用户
}Kart;

// 卡丁车链表
typedef struct KartNode
{
    Kart data;
    struct KartNode *next;
}KartNode;

/**
 * 添加卡丁车信息
 * */
void enroll_Kart(KartNode **head);
/**
 * 添加卡丁车节点
 * */
void init_Kart_List(KartNode **head, Kart data);

/**
 * 销毁卡丁车列表
 * */
void destroy_Kart_list(KartNode *head);

/**
 * 保存卡丁车列表到文件
 * */
void save_Kart_file(KartNode *head);

/**
 * 从文件加载卡丁车列表
 * */
void load_Kart_file(KartNode **head);

/**
 * 查询卡丁车列表
 * */
void print_Kart_list(KartNode *head);

/**
 * 删除卡丁车
 * */
void delete_Kart(KartNode **head);

/**
 * 修改卡丁车信息
 * */
void modify_Kart(KartNode *head);

/**
 * 修改用户权限身份
 * */
void revise_User_perm(UserList *head);

/**
 * 删除用户
 * */
void delete_User(UserList **head, UserPersonList **head_person);

/**
 * 删除用户信息
 * */
void delete_User_Person(UserList *head, UserPersonList **head_person);


#endif //GO_KARTS_ADMIN_H

admin.c

//
// Created by SGCNB666 on 2024/12/31.
//

#include "admin.h"

/**
 * 添加卡丁车信息
 * */
void enroll_Kart(KartNode **head)
{
    int id; // 生成卡丁车编号
    KartNode *p = *head; // p指向头节点
    if(!p) // 链表为空
    {
        id = 1001;
    }
    else
    {
        while(p)
        {
            id = p->data.kart_id + 1; // 生成卡丁车编号
            p = p->next; // p指向下一个节点
        }
    }
    Kart new_kart;
    new_kart.kart_id = id; // 生成卡丁车编号
    new_kart.repair_not = '0'; // 初始化是否维修，默认不需要维修
    new_kart.book_not = '0'; // 初始化是否预约，默认不需要预约
    new_kart.user_name[0] = '\0'; // 初始化预约人为空
    printf("添加编号为%d的车辆信息\n", id);
    printf("请输入卡丁车名称：");
    scanf("%s", new_kart.kart_name); // 输入卡丁车名称
    printf("请输入卡丁车类型：");
    scanf("%s", new_kart.kart_type); // 输入卡丁车类型
    printf("请输入卡丁车颜色：");
    scanf("%s", new_kart.kart_color); // 输入卡丁车颜色

    init_Kart_List(head, new_kart);
}

/**
 * 添加卡丁车节点
 * */
void init_Kart_List(KartNode **head, Kart data)
{
    KartNode *pNew = (KartNode *)malloc(sizeof(KartNode)); // 分配内存
    if(!pNew) // 分配内存失败
    {
        perror("内存分配失败\n");
        return;
    }

    KartNode *p = *head; // p指向头节点

    if(*head != NULL) // 链表不为空
    {
        while(p->next) // 找到链表的尾节点
        {
            p = p->next; // p指向下一个节点
        }
        p->next  = pNew; // 尾节点指向新节点
        pNew->data = data; // 新节点数据赋值
        pNew->next = NULL; // 新节点指向空
        return;
    }
    pNew->next = NULL; // 新节点指向空
    pNew->data = data; // 新节点数据赋值
    *head = pNew; // 头节点指向新节点
    return;
}

/**
 * 销毁卡丁车列表
 * */
void destroy_Kart_list(KartNode *head)
{
    KartNode *p = head, *q = NULL; // p指向头节点，q指向尾节点
    while(p) // 遍历链表
    {
        q = p; // q指向p
        p = p->next; // p指向下一个节点
        free(q); // 释放内存
    }
}

/**
 * 保存卡丁车列表到文件
 * */
void save_Kart_file(KartNode *head)
{
    FILE *fp = fopen("karts_info.dat", "wb"); // 以二进制方式打开文件
    if(!fp) // 打开文件失败
    {
        perror("文件打开失败！");
        return;
    }
    KartNode *p = head; // p指向头节点
    while(p) // 遍历链表
    {
        fwrite( &p->data, sizeof (Kart), 1, fp); // 写入文件
        p = p->next;
    }
    printf("保存成功！\n");
    fclose(fp); // 关闭文件
    return;
}

/**
 * 从文件加载卡丁车列表
 * */
void load_Kart_file(KartNode **head)
{
    FILE *fp = fopen("karts_info.dat", "rb"); // 以二进制方式打开文件
    if(!fp) // 打开文件失败
    {
        perror("文件打开失败！");
        return;
    }
    Kart data; // 卡丁车信息
    while(fread(&data, sizeof (Kart), 1, fp))   // 读取文件
    {
        init_Kart_List(head, data); // 添加卡丁车节点
    }
    fclose(fp); // 关闭文件
}

/**
 * 查询卡丁车列表
 * */
void print_Kart_list(KartNode *head)
{
    KartNode *p = head; // p指向头节点
    if(!p)
    {
        printf("卡丁车列表为空！\n");
        return;
    }

    printf("卡丁车编号\t卡丁车名称\t卡丁车类型\t卡丁车颜色\t是否维修或报废\t是否预约\t预约人\n");
    while(p) // 遍历链表
    {
        printf("%d\t\t", p->data.kart_id);
        printf("%s\t\t", p->data.kart_name);
        printf("%s\t\t", p->data.kart_type);
        printf("%s\t\t", p->data.kart_color);
        if(p->data.repair_not == '0')
        {
            printf("%c(无损坏)\t", p->data.repair_not);
        }
        else if(p->data.repair_not == '1')
        {
            printf("%c(报修中)\t", p->data.repair_not);
        }
        else
        {
            printf("%c(已报废)\t", p->data.repair_not);
        }

        printf("%c\t\t", p->data.book_not);
        printf("%s\t\t\n", p->data.user_name);
        p = p->next; // p指向下一个节点
    }
}

/**
 * 删除卡丁车
 * */
void delete_Kart(KartNode **head)
{
    KartNode *p = *head; // p指向头节点
    if(!p) // 链表为空
    {
        printf("卡丁车列表为空！\n");
    }
    int id;
    printf("请输入要删除的卡丁车编号：");
    scanf("%d", &id); // 输入卡丁车编号

    KartNode *q = NULL; // q置空

    while(p) // 遍历链表，指针尾随
    { 

        if(id == p->data.kart_id)
        {
            if(p == *head) // 要删除的是头节点
            {
                *head = p->next; // 头节点后移
                free(p); // 释放内存
                return;
            }
            else
            {
                q->next = p->next; // 前一个节点指向后一个节点
                free(p); // 释放内存
                return;
            }
        }
        q = p; // q指向p
        p = p->next; // p指向下一个节点
    }
    printf("卡丁车编号不存在！\n");
    return;
}

/**
 * 修改卡丁车信息
 * */
void modify_Kart(KartNode *head)
{
    KartNode *p = head, *q = NULL; // p指向头节点，q指向尾节点
    if(!p) // 链表为空
    {
        printf("卡丁车列表为空！\n");
    }
    int id; // 卡丁车编号
    printf("请输入要修改的卡丁车编号：");
    scanf("%d", &id); // 输入卡丁车编号
    while(p) // 遍历链表
    {

        if(id == p->data.kart_id) // 找到了要修改的卡丁车
        {
            while(1) // 循环修改卡丁车信息
            {
                printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
                printf("┃      1.全部修改                  2.是否维修               3.卡丁车名称           ┃\n");
                printf("┃      4.卡丁车类型             5.卡丁车颜色             6.预约用户名               ┃\n");
                printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
                while(getchar() != '\n'); // 清空缓冲区
                printf("请选择：\n");
                char ch;
                scanf("%c", &ch); // 输入选择
                while(getchar() != '\n'); // 清空缓冲区
                switch(ch)
                {
                    case '1':
                        printf("请输入卡丁车名称：");
                        scanf("%s", p->data.kart_name);
                        printf("请输入卡丁车类型：");
                        scanf("%s", p->data.kart_type);
                        printf("请输入卡丁车颜色：");
                        scanf("%s", p->data.kart_color);
                        while(getchar() != '\n');
                        printf("请输入是否维修：");
                        scanf("%c", &p->data.repair_not);
                        while(getchar() != '\n');
                        printf("请输入预约用户名：");
                        scanf("%s", p->data.user_name);
                        p->data.book_not = '1';
                        while(getchar() != '\n');
                        return;
                        break;
                    case '2':
                        printf("请输入是否维修：");
                        scanf("%c", &p->data.repair_not);
                        while(getchar() != '\n');
                        return;
                        break;
                    case '3':
                        printf("请输入卡丁车名称：");
                        scanf("%s", p->data.kart_name);
                        while(getchar() != '\n');
                        return;
                        break;
                    case '4':
                        printf("请输入卡丁车类型：");
                        scanf("%s", p->data.kart_type);
                        while(getchar() != '\n');
                        return;
                        break;
                    case '5':
                        printf("请输入卡丁车颜色：");
                        scanf("%s", p->data.kart_color);
                        while(getchar() != '\n');
                        return;
                        break;
                    case '6':
                        printf("请输入预约用户名：");
                        scanf("%s", p->data.user_name);
                        p->data.book_not = '1';
                        while(getchar() != '\n');
                        return;
                        break;
                    default:
                        printf("不存在该选项，请重新输入！\n");
                }
                printf("按回车健继续...");
                getchar();
            }
        }
        q = p;  // q指向p
        p = p->next; // p指向下一个节点
    }
    printf("卡丁车编号不存在！\n");
    return;
}

/**
 * 修改用户权限身份
 * */
void revise_User_perm(UserList *head)
{
    UserList *p = head; // p指向头节点
    if(!p) // 链表为空
    {
        printf("用户列表为空！\n");
        return;
    }
    char username[20]; // 用户名
    printf("请输入要修改权限的用户名：");
    scanf("%s", username); // 输入用户名
    while(getchar() != '\n');
    if(strcmp(username, "admin") == 0) // 要修改的是admin用户
    {
        printf("admin用户是管理员，不能修改权限！\n");
        return;
    }
    while(p) // 遍历链表
    {
        if(strcmp(username, p->data.username) == 0) // 找到了要修改的用户
        {
            printf("开始修改用户权限：('A'是普通用户,'R'是维修员)\n");
            scanf("%c", &p->data.permission);
            printf("修改成功！\n");
            printf("%s, %s, %c\n", p->data.username, p->data.password, p->data.permission);
            return;
        }
        p = p->next; // p指向下一个节点
    }
    printf("用户不存在！\n");
    return;
}

/**
 * 删除用户
 * */
void delete_User(UserList **head, UserPersonList **head_person)
{
    printf("请输入想要删除的用户名：\n");
    char username[20];
    scanf("%s", username);
    while(getchar()!= '\n');
    UserList *p = *head;
    if(strcmp(username, "admin") == 0)  // 要删除的是admin用户
    {
        printf("admin用户是管理员，不能删除！\n");
        return;
    }

    if(!p) // 链表为空
    {
        printf("用户列表为空！\n");
        return;
    }

    if(strcmp(username, p->data.username) == 0) // 要删除的是头节点
    {
        delete_User_Person(*head, head_person); // 删除用户信息
        *head = p->next; // 头节点后移
        free(p); // 释放内存
        return;
    }

    UserList *q = NULL;
    while(p) // 遍历链表
    {
        if(strcmp(username, p->data.username) == 0)  // 找到了要删除的用户
        { 
            delete_User_Person(*head, head_person); // 删除用户信息
            q->next = p->next;  // 前一个节点指向后一个节点
            free(p); // 释放内存
            return;
        }
        q = p; // q指向p
        p = p->next; // p指向下一个节点
    }

    printf("该用户不存在！\n");
    return;
}

/**
 * 删除用户信息
 * */
void delete_User_Person(UserList *user, UserPersonList **head_person)
{
    UserList *p_user = user; // p_user指向头节点
    UserPersonList *p_person = *head_person; // p_person指向头节点

    if(strcmp(p_user->data.username,p_person->data.name) == 0) // 要删除的是头节点
    {
        *head_person = p_person->next; // 头节点后移
        free(p_person); // 释放内存
        return;
    }

    UserPersonList *q_person = NULL; // q_person指向尾节点
    while(p_person) // 遍历链表
    {
        if(strcmp(p_user->data.username,p_person->data.name) == 0) // 找到了要删除的用户
        {
            q_person->next = p_person->next; // 前一个节点指向后一个节点
            free(p_person); // 释放内存
            return;
        }
        q_person = p_person; // q_person指向p_person
        p_person = p_person->next; // p_person指向下一个节点
    }

    printf("该用户不存在！\n");
    return;
}

用户功能页面

user.h

//
// Created by SGCNB666 on 2024/12/31.
//

#ifndef GO_KARTS_USER_H
#define GO_KARTS_USER_H

#include "admin.h"
#include "login.h"

/**
 * 卡丁车预约
 * */
void user_kart_booknot(UserPerson *userPerson,KartNode *kart);

/**
 * 卡丁车查询
 * */
void user_kart_booknot_query(KartNode *kart);

/**
 * 卡丁车预约取消
 * */
void user_kart_booknot_cancel(UserPerson *userPerson,KartNode *kart);

/**
 * 卡丁车预约信息保存
 * */
void user_kart_booknot_save(UserPersonList *head,KartNode *kart);

/**
 * 卡丁车预约信息加载
 * */
void user_kart_booknot_load(UserPersonList **head);

/**
 * 卡丁车报修
 * */
void user_kart_repair(UserPerson *userPerson,KartNode *kart);

/**
 * 个人信息查询
 * */
void print_user_info(UserPerson *userPerson);

/**
 * 个人信息修改
 * */
void revise_user_info(UserPerson *userPerson);



#endif //GO_KARTS_USER_H

user.c

//
// Created by SGCNB666 on 2024/12/31.
//

#include "user.h"

/**
 * 卡丁车预约
 * */
void user_kart_booknot(UserPerson *userPerson,KartNode *kart)
{
    KartNode *p = kart; // p指向头节点
    while(p) // 遍历链表
    {
        if(!strcmp(userPerson->name,p->data.user_name)) // 判断是否预约过
        {
            printf("您已经预约了卡丁车！\n");
            return;
        }
        p = p->next; // p指向下一个节点
    }
    p = kart; // p重新指向头节点

    print_Kart_list(p); // 打印卡丁车列表
    printf("请输入要预约的卡丁车编号：");
    int num; // 输入的编号
    scanf("%d", &num); // 输入编号
    while(getchar() != '\n');
    while(p) // 遍历链表
    {
        if(p->data.kart_id == num) // 找到了
        {
            p->data.book_not = '1'; // 预约成功
            userPerson->kart_booknot = num; // 修改用户个人信息
            strcpy(p->data.user_name ,userPerson->name); // 修改车辆信息
            printf("预约成功！\n");
            return;
        }
        p = p->next;
    }
    printf("查询不到该编号的卡丁车！\n");
    return;
}

/**
 * 卡丁车预约查询
 * */
void user_kart_booknot_query(KartNode *kart)
{
    KartNode *p = kart;   // p指向头节点
    print_Kart_list(kart);  // 打印卡丁车列表
}

/**
 * 卡丁车预约取消
 * */
void user_kart_booknot_cancel(UserPerson *userPerson,KartNode *kart)
{
    KartNode *p = kart; // p指向头节点
    print_Kart_list(p); // 打印卡丁车列表
    printf("请输取消预约的卡丁车编号：");
    int num; // 输入的编号
    scanf("%d", &num);
    while(getchar() != '\n'); // 清空缓冲区
    while(p) // 遍历链表
    { 
        if(p->data.kart_id == num) // 找到了
        {
            p->data.book_not = '0'; // 取消预约成功
            userPerson->kart_booknot = 0; // 修改用户个人信息
            strcpy(p->data.user_name ,""); // 修改车辆信息
            printf("取消预约成功！\n"); 
            return;
        }
        p = p->next; // p指向下一个节点
    }
    printf("查询不到该编号的卡丁车！\n");
    return;
}

/**
 * 卡丁车预约信息保存
 * */
void user_kart_booknot_save(UserPersonList *head,KartNode *kart)
{
    save_user_person_file(head); // 保存用户个人信息列表到文件
    save_Kart_file(kart); // 保存卡丁车列表到文件
}

/**
 * 卡丁车预约信息加载
 * */
void user_kart_booknot_load(UserPersonList **head)
{
    load_user_person_file(head); // 加载用户个人信息列表
}

/**
 * 卡丁车报修
 * */
void user_kart_repair(UserPerson *userPerson,KartNode *kart)
{
    KartNode *p = kart; // p指向头节点
    print_Kart_list(p); // 打印卡丁车列表
    printf("请输入要报修的卡丁车编号：");
    int num; // 输入的编号
    scanf("%d", &num); // 输入编号
    while(getchar() != '\n');
    while(p) // 遍历链表
    {
        if(p->data.kart_id == num) // 找到了
        {
            p->data.repair_not = '1'; // 报修成功
            printf("报修成功！\n");
            return;
        }
        p = p->next;  // p指向下一个节点
    }
    printf("查询不到该编号的卡丁车！\n");
    return;
}

/**
 * 个人信息查询
 * */
void print_user_info(UserPerson *userPerson)
{
    printf("个人信息如下：\n");
    printf("用户名：%s\n", userPerson->name);
    printf("手机号：%s\n", userPerson->phone);
    printf("预约卡丁车编号：%d\n", userPerson->kart_booknot);
    return;
}

/**
 * 个人信息修改
 * */
void revise_user_info(UserPerson *userPerson)
{
    printf("请输入新的手机号：");
    scanf("%s", userPerson->phone); // 输入新的手机号
    while(getchar()!= '\n');
    return;
}

维修员功能实现

repair.h

//
// Created by SGCNB666 on 2024/12/31.
//

#ifndef GO_KARTS_REPAIR_H
#define GO_KARTS_REPAIR_H

#include "admin.h"
#include "user.h"
#include "login.h"

/**
 * 显示维修员信息
 * */
void print_repair_info(UserPerson *userPerson);

/**
 * 显示待维修的车辆信息
 * */
void repair_karts_info(KartNode *head);

/**
 * 上报维修情况
 * */
void report_repair_info(KartNode *head);

#endif //GO_KARTS_REPAIR_H

repair.c

//
// Created by SGCNB666 on 2024/12/31.
//

#include "repair.h"

/**
 * 显示维修员信息
 * */
void print_repair_info(UserPerson *userPerson)
{
    printf("个人信息如下：\n");
    printf("用户名：%s\n", userPerson->name);
    printf("手机号：%s\n", userPerson->phone);
    return;
}

/**
 * 显示待维修的车辆信息
 * */
void repair_karts_info(KartNode *head)
{
    KartNode *p = head; // p指向头节点
    if(!p) // 如果链表为空
    {
        printf("卡丁车列表为空！\n");
        return;
    }
    while(p) // 遍历链表
    {
        if (p->data.repair_not == '1') // 如果需要维修
        {
            printf("编号：%d\t\t", p->data.kart_id);
            printf("名称：%s\t\t", p->data.kart_name);
            printf("类型：%s\t\t", p->data.kart_type);
            printf("颜色：%s\t\n", p->data.kart_color);
        }
        p = p->next; // p指向下一个节点
    }
}

/**
 * 上报维修情况
 * */
void report_repair_info(KartNode *head)
{
    KartNode *p = head; // p指向头节点
    if(!p) // 如果链表为空
    {
        printf("卡丁车列表为空！\n");
        return;
    }

    printf("请输入你想上报的卡丁车编号：");
    int id; // 输入的编号
    scanf("%d", &id); // 输入编号
    while(getchar() != '\n');

    while(p) // 遍历链表
    {
        if(id == p->data.kart_id) // 找到了
        {
            while(getchar()!= '\n');
            printf("请输入维修情况(1：报废无法维修，2：维修完成)：");
            char ch;
            scanf("%c", &ch); // 输入维修情况

            if(ch == '1')
            {
                p->data.repair_not = '3';
                printf("维修完成！\n");
            }
            else if(ch == '2')
            {
                p->data.repair_not = '0';
                printf("维修完成！\n");
            }
            else
            {
                printf("不存在该选项！\n");
            }

            return;
        }
        p = p->next; // p指向下一个节点
    }

    printf("卡丁车编号不存在！\n");
    return;
}

主函数main.c

/*************************************************************************
  > File Name:    main.c
  > Author:       sgc
  > Description:  卡丁车管理系统
  > Created Time: 2024年12月30日 星期一 17时53分14秒
 ************************************************************************/

#include <stdio.h>
#include "login.h"
#include "home_face.h"
#include "admin.h"

int main(int argc,char *argv[])
{
    UserList *head_user = NULL;
    KartNode *head_kart = NULL;
    UserPersonList *head_person = NULL;
    load_user_file(&head_user); // 加载用户列表
    login_welcome(); // 显示欢迎界面
    UserList *p = NULL;
    p = login(&head_user); // 登录主界面
    if(!p) // 判断是否是正常登录
    {
        save_user_file(head_user);
        return 0;
    }
    save_user_file(head_user); // 保存用户列表到文件


    // 显示管理员主界面
    if(p->data.permission == 'U') // 管理员
    {
        load_user_person_file(&head_person); // 加载用户个人信息列表
        save_user_person_file(head_person); // 保存用户个人信息列表到文件

        admin_home( head_person,&head_kart,head_user); // 管理员主界面
    }
    else if(p->data.permission == 'A') // 普通用户
    {
        load_user_person_file(&head_person); // 加载用户个人信息列表
        add_user_person(&head_person, p); // 添加用户个人信息
        save_user_person_file(head_person); // 保存用户个人信息列表到文件
        load_Kart_file(&head_kart); // 加载卡丁车列表

        user_home(head_person,head_kart,p); // 用户主界面
    }
    else if(p->data.permission == 'R') // 维修员
    {
        load_user_person_file(&head_person); // 加载用户个人信息列表
        add_user_person(&head_person, p); // 添加用户个人信息
        save_user_person_file(head_person); // 保存用户个人信息列表到文件
        load_Kart_file(&head_kart); // 加载卡丁车列表

        repair_home(head_person,head_kart,p); // 维修员主界面
    }
    else // 其他
    {
        printf("权限错误！请联系管理员进行修改！\n");
    }


    destroy_user_list(head_user); // 销毁用户列表
    destroy_user_person_list(head_person); // 销毁用户个人信息列表
    destroy_Kart_list(head_kart); // 销毁卡丁车列表
    return 0;
}