C/C++代码混淆器

已于 2022-07-24 15:23:09 修改
阅读量3.5k 收藏 9
点赞数
文章标签： c++
于 2022-07-24 15:01:07 首次发布
原文链接：https://www.foxzzz.com/c-cpp-disorder/
版权

title: C/C++代码混淆器
urlname: c-cpp-disorder
date: 2021-06-06 23:02:23
tags: [‘C/C++’, ‘代码混淆器’]
原文链接：https://www.foxzzz.com/c-cpp-disorder/

试图通过混淆 C/C++源代码以达到保护知识产权的目的的做法其实就是自欺欺人，因为不论如何混淆代码，到了编译阶段代码终究是要被还原成它本来的样子，说到底，这只是一层窗户纸而已。

我曾利用 宏机制实现过一个 C/C++代码混淆器，效果乍一看还真能给人一种眼前一亮的神奇，但在 行家 眼里这真就是一层窗户纸而已——捅破它只需一个编译命令 gcc -E 。但若只为了阻挡伸手党白嫖你的代码，嘿嘿，它还是能起到一定的作用滴٩(๑>◡<๑)۶

混淆效果

  • 找一段 C语言代码测试下混淆效果，下面是原始代码
/********************************************
* 图书信息管理系统
* Copyright (C) i@foxzzz.com
*
* C语言实现的命令行模式下的信息管理系统。
*********************************************/

#define _CRT_SECURE_NO_WARNINGS

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

#define BORROW_COUNT_MAX 10     /*最多可借阅的图书数量*/
#define SHOW_BOOK_PAGE_COUNT 20 /*一页显示的图书条目*/

/*用户权限*/
enum UserRank {
    NORMAL,     /*普通用户*/
    MANAGER     /*管理员*/
};

/*用户结构体*/
typedef struct _tUserInfo {
    char id[128];               /*账号*/
    char name[256];             /*姓名*/
    char password[256];         /*密码*/
    int rank;                   /*权限*/
    struct _tUserInfo* next;    /*下一个节点*/
} UserInfo, * pUserInfo;

/*图书结构体*/
typedef struct _tBookInfo {
    char id[128];               /*编号*/
    char name[256];             /*书名*/
    char author[256];           /*作者*/
    char press[256];            /*出版社*/
    char type[256];             /*类型*/
    char time[256];             /*出版时间*/
    double price;               /*价格*/
    int stock;                  /*库存*/
    struct _tBookInfo* next;    /*下一个节点*/
} BookInfo, * pBookInfo;

/*借阅记录结构体*/
typedef struct _tRecordInfo {
    char user_id[128];                      /*借阅人账号*/
    char book_id[BORROW_COUNT_MAX][128];    /*图书编号*/
    int count;                              /*借阅数量*/
    struct _tRecordInfo* next;              /*下一个节点*/
} RecordInfo, * pRecordInfo;

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

/*等待按下任意键*/
void waitingPressAnyKey() {
    emptyStdin();
    getchar();
}

/*清屏*/
void clearScreen() {
    system("cls");
}

/*从标准输入一行文本*/
void inputLine(char* line, int capacity) {
    while (1) {
        if (fgets(line, capacity, stdin)) {
            size_t len = strlen(line);
            if (len > 1) {
                line[len - 1] = '\0';
                break;
            }
        }
    }
}

/*输入密码*/
void inputPassword(char* password, int capacity) {
    int index = 0;
    while (index < capacity) {
        int ch = _getch();
        if (ch == '\n' || ch == '\r') {
            if (index > 0) {
                password[index] = '\0';
                putchar('\n');
                break;
            } else continue;
        }
        if (ch == '\b') {
            if (index > 0) {
                --index;
                putchar('\b');
                putchar(' ');
                putchar('\b');
            }
        } else {
            password[index++] = ch;
            putchar('*');
        }
    }
}

/*添加用户节点，返回链表首节点指针*/
pUserInfo addUserInfoNode(pUserInfo head, pUserInfo node) {
    if (head) {
        pUserInfo cursor = head;
        while (cursor->next) {
            cursor = cursor->next;
        }
        /*将新节点插入到链表尾部*/
        cursor->next = node;
        return head;
    } else {
        /*链表为空返回该节点*/
        return node;
    }
}

/*删除用户节点，返回链表首节点指针*/
pUserInfo removeUserInfoNode(pUserInfo head, pUserInfo node) {
    if (head) {
        if (head == node) {
            /*删除节点为首节点*/
            head = node->next;
            /*删除该节点*/
            free(node);
        } else {
            pUserInfo cursor = head;
            while (cursor->next) {
                /*找到要删除节点的上一个节点*/
                if (cursor->next == node) {
                    /*将上一个节点指向删除节点的下一个节点*/
                    cursor->next = node->next;
                    /*删除该节点*/
                    free(node);
                    break;
                }
                cursor = cursor->next;
            }
        }
    }
    return head;
}

/*通过账号查找用户节点*/
pUserInfo findUserInfoNode(pUserInfo head, char* id) {
    pUserInfo cursor = head;
    while (cursor) {
        /*匹配用户*/
        if (strcmp(cursor->id, id) == 0) {
            return cursor;
        }
        cursor = cursor->next;
    }
    return NULL;
}

/*计算用户节点数*/
int countUserInfoNode(pUserInfo head) {
    pUserInfo cursor = head;
    int count = 0;
    while (cursor) {
        ++count;
        cursor = cursor->next;
    }
    return count;
}

/*添加图书节点，返回链表首节点指针*/
pBookInfo addBookInfoNode(pBookInfo head, pBookInfo node) {
    if (head) {
        pBookInfo cursor = head;
        while (cursor->next) {
            cursor = cursor->next;
        }
        /*将新节点插入到链表尾部*/
        cursor->next = node;
        return head;
    } else {
        /*链表为空返回该节点*/
        return node;
    }
}

/*删除图书节点，返回链表首节点指针*/
pBookInfo removeBookInfoNode(pBookInfo head, pBookInfo node) {
    if (head) {
        if (head == node) {
            /*删除节点为首节点*/
            head = node->next;
            /*删除该节点*/
            free(node);
        } else {
            pBookInfo cursor = head;
            while (cursor->next) {
                /*找到要删除节点的上一个节点*/
                if (cursor->next == node) {
                    /*将上一个节点指向删除节点的下一个节点*/
                    cursor->next = node->next;
                    /*删除该节点*/
                    free(node);
                    break;
                }
                cursor = cursor->next;
            }
        }
    }
    return head;
}

/*通过账号查找图书节点*/
pBookInfo findBookInfoNodeByID(pBookInfo head, char* id) {
    pBookInfo cursor = head;
    while (cursor) {
        /*匹配图书*/
        if (strcmp(cursor->id, id) == 0) {
            return cursor;
        }
        cursor = cursor->next;
    }
    return NULL;
}

/*通过书名查找图书节点*/
pBookInfo findBookInfoNodeByName(pBookInfo head, char* name) {
    pBookInfo cursor = head;
    while (cursor) {
        /*匹配图书*/
        if (strcmp(cursor->name, name) == 0) {
            return cursor;
        }
        cursor = cursor->next;
    }
    return NULL;
}

/*通过作者查找图书节点*/
pBookInfo findBookInfoNodeByAuthor(pBookInfo head, char* author) {
    pBookInfo cursor = head;
    while (cursor) {
        /*匹配图书*/
        if (strcmp(cursor->author, author) == 0) {
            return cursor;
        }
        cursor = cursor->next;
    }
    return NULL;
}

/*通过出版社查找图书节点*/
pBookInfo findBookInfoNodeByPress(pBookInfo head, char* press) {
    pBookInfo cursor = head;
    while (cursor) {
        /*匹配图书*/
        if (strcmp(cursor->press, press) == 0) {
            return cursor;
        }
        cursor = cursor->next;
    }
    return NULL;
}

/*计算图书节点数*/
int countBookInfoNode(pBookInfo head) {
    pBookInfo cursor = head;
    int count = 0;
    while (cursor) {
        ++count;
        cursor = cursor->next;
    }
    return count;
}

/*添加记录节点，返回链表首节点指针*/
pRecordInfo addRecordInfoNode(pRecordInfo head, pRecordInfo node) {
    if (head) {
        pRecordInfo cursor = head;
        while (cursor->next) {
            cursor = cursor->next;
        }
        /*将新节点插入到链表尾部*/
        cursor->next = node;
        return head;
    } else {
        /*链表为空返回该节点*/
        return node;
    }
}

/*删除记录节点，返回链表首节点指针*/
pRecordInfo removeRecordInfoNode(pRecordInfo head, pRecordInfo node) {
    if (head) {
        if (head == node) {
            /*删除节点为首节点*/
            head = node->next;
            /*删除该节点*/
            free(node);
        } else {
            pRecordInfo cursor = head;
            while (cursor->next) {
                /*找到要删除节点的上一个节点*/
                if (cursor->next == node) {
                    /*将上一个节点指向删除节点的下一个节点*/
                    cursor->next = node->next;
                    /*删除该节点*/
                    free(node);
                    break;
                }
                cursor = cursor->next;
            }
        }
    }
    return head;
}

/*通过账号查找记录节点*/
pRecordInfo findRecordInfoNodeByID(pRecordInfo head, char* id) {
    pRecordInfo cursor = head;
    while (cursor) {
        /*匹配用户*/
        if (strcmp(cursor->user_id, id) == 0) {
            return cursor;
        }
        cursor = cursor->next;
    }
    return NULL;
}

/*计算记录节点数*/
int countRecordInfoNode(pRecordInfo head) {
    pRecordInfo cursor = head;
    int count = 0;
    while (cursor) {
        ++count;
        cursor = cursor->next;
    }
    return count;
}

/*将用户信息存储到文件*/
void saveUserInfoFile(const pUserInfo head) {
    pUserInfo cursor = head;
    FILE* file = fopen("userinfo.dat", "wb");
    if (file) {
        int count = countUserInfoNode(head);
        /*将用户节点总数写入文件起始位置*/
        fwrite(&count, sizeof(int), 1, file);
        while (cursor) {
            fwrite(cursor, sizeof(UserInfo), 1, file);
            cursor = cursor->next;
        }
        fclose(file);
    } else {
        printf("写文件失败！\n");
    }
}

/*从文件中加载用户信息*/
pUserInfo loadUserInfoFile() {
    pUserInfo head = NULL;
    FILE* file = fopen("userinfo.dat", "rb");
    if (file) {
        int count = 0;
        /*读取文件起始位置的节点总数*/
        fread(&count, sizeof(int), 1, file);
        while (count--) {
            pUserInfo user = (pUserInfo)malloc(sizeof(UserInfo));
            memset(user, 0, sizeof(UserInfo));
            fread(user, sizeof(UserInfo), 1, file);
            /*将指向下个节点的指针重置成NULL*/
            user->next = NULL;
            head = addUserInfoNode(head, user);
        }
        fclose(file);
    } else {
        printf("读文件失败！\n");
    }
    return head;
}

/*清理用户列表，回收内存*/
void clearUserInfoList(pUserInfo head) {
    while (head) {
        head = removeUserInfoNode(head, head);
    }
}

/*将图书信息存储到文件*/
void saveBookInfoFile(const pBookInfo head) {
    pBookInfo cursor = head;
    FILE* file = fopen("bookinfo.dat", "wb");
    if (file) {
        int count = countBookInfoNode(head);
        /*将用户节点总数写入文件起始位置*/
        fwrite(&count, sizeof(int), 1, file);
        while (cursor) {
            fwrite(cursor, sizeof(BookInfo), 1, file);
            cursor = cursor->next;
        }
        fclose(file);
    } else {
        printf("写文件失败！\n");
    }
}

/*从文件中加载用户信息*/
pBookInfo loadBookInfoFile() {
    pBookInfo head = NULL;
    FILE* file = fopen("bookinfo.dat", "rb");
    if (file) {
        int count = 0;
        /*读取文件起始位置的节点总数*/
        fread(&count, sizeof(int), 1, file);
        while (count--) {
            pBookInfo book = (pBookInfo)malloc(sizeof(BookInfo));
            memset(book, 0, sizeof(BookInfo));
            fread(book, sizeof(BookInfo), 1, file);
            /*将指向下个节点的指针重置成NULL*/
            book->next = NULL;
            head = addBookInfoNode(head, book);
        }
        fclose(file);
    } else {
        printf("读文件失败！\n");
    }
    return head;
}

/*清理图书列表，回收内存*/
void clearBookInfoList(pBookInfo head) {
    while (head) {
        head = removeBookInfoNode(head, head);
    }
}

/*将记录信息存储到文件*/
void saveRecordInfoFile(const pRecordInfo head) {
    pRecordInfo cursor = head;
    FILE* file = fopen("recordinfo.dat", "wb");
    if (file) {
        int count = countRecordInfoNode(head);
        /*将用户节点总数写入文件起始位置*/
        fwrite(&count, sizeof(int), 1, file);
        while (cursor) {
            fwrite(cursor, sizeof(RecordInfo), 1, file);
            cursor = cursor->next;
        }
        fclose(file);
    } else {
        printf("写文件失败！\n");
    }
}

/*从文件中加载记录信息*/
pRecordInfo loadRecordInfoFile() {
    pRecordInfo head = NULL;
    FILE* file = fopen("recordinfo.dat", "rb");
    if (file) {
        int count = 0;
        /*读取文件起始位置的节点总数*/
        fread(&count, sizeof(int), 1, file);
        while (count--) {
            pRecordInfo book = (pRecordInfo)malloc(sizeof(RecordInfo));
            memset(book, 0, sizeof(RecordInfo));
            fread(book, sizeof(RecordInfo), 1, file);
            /*将指向下个节点的指针重置成NULL*/
            book->next = NULL;
            head = addRecordInfoNode(head, book);
        }
        fclose(file);
    } else {
        printf("读文件失败！\n");
    }
    return head;
}

/*清理记录列表，回收内存*/
void clearRecordInfoList(pRecordInfo head) {
    while (head) {
        head = removeRecordInfoNode(head, head);
    }
}

/*显示用户信息*/
void showUser(pUserInfo user) {
    printf("┌-------------------------------------------------┐\n");
    printf("    账号：%s\n", user->id);
    printf("    姓名：%s\n", user->name);
    printf("    密码：%s\n", user->password);
    switch (user->rank) {
    case NORMAL:
        printf("    权限：%s\n", "普通用户");
        break;
    case MANAGER:
        printf("    权限：%s\n", "管理员");
        break;
    }
    printf("└-------------------------------------------------┘\n");
}

/*编辑用户信息*/
void editUser(pUserInfo user) {
    printf("┌-------------------------------------------------┐\n");
    printf("    账号：");
    scanf("%s", user->id);
    printf("    姓名：");
    inputLine(user->name, sizeof(user->name));
    printf("    密码：");
    inputPassword(user->password, sizeof(user->password));
    printf("    权限：（0：普通用户， 1：管理员）");
    scanf("%d", &user->rank);
    if (user->rank != NORMAL && user->rank != MANAGER) {
        user->rank = NORMAL;
    }
    printf("└-------------------------------------------------┘\n");
}

/*显示图书信息*/
void showBook(pBookInfo book) {
    printf("┌-------------------------------------------------┐\n");
    printf("    编号：");
    printf("%s\n", book->id);
    printf("    书名：");
    printf("%s\n", book->name);
    printf("    作者：");
    printf("%s\n", book->author);
    printf("    出版社：");
    printf("%s\n", book->press);
    printf("    类型：");
    printf("%s\n", book->type);
    printf("    出版时间：");
    printf("%s\n", book->time);
    printf("    价格：");
    printf("%.2lf\n", book->price);
    printf("    库存：");
    printf("%d\n", book->stock);
    printf("└-------------------------------------------------┘\n");
}

/*编辑图书信息*/
void editBook(pBookInfo book) {
    printf("┌-------------------------------------------------┐\n");
    printf("    编号：");
    if (strlen(book->id)) {
        printf("%s\n", book->id);
    } else {
        scanf("%s", book->id);
    }
    printf("    书名：");
    inputLine(book->name, sizeof(book->name));
    printf("    作者：");
    inputLine(book->author, sizeof(book->author));
    printf("    出版社：");
    inputLine(book->press, sizeof(book->press));
    printf("    类型：");
    scanf("%s", book->type);
    printf("    出版时间：");
    scanf("%s", book->time);
    printf("    价格：");
    scanf("%lf", &book->price);
    printf("    库存：");
    scanf("%d", &book->stock);
    printf("└-------------------------------------------------┘\n");
}

/*显示用户清单选项*/
void showUserListOption(pUserInfo head) {
    pUserInfo cursor = head;
    while (cursor) {
        showUser(cursor);
        cursor = cursor->next;
    }
    printf("\n按回车键返回上级菜单...\n");
    waitingPressAnyKey();
}

/*添加用户选项*/
void createUserOption(pUserInfo* head) {
    pUserInfo user = (pUserInfo)malloc(sizeof(UserInfo));
    memset(user, 0U, sizeof(UserInfo));
    clearScreen();
    printf("        ┌------------------------┐\n");
    printf("               #添加用户#\n");
    printf("        └------------------------┘\n");
    editUser(user);
    if (findUserInfoNode(*head, user->id)) {
        free(user);
        printf("\n用户创建失败，存在相同用户！\n");
    } else {
        *head = addUserInfoNode(*head, user);
        /*同步文件信息*/
        saveUserInfoFile(*head);
        printf("\n用户创建成功！\n");
    }
    waitingPressAnyKey();
}

/*修改用户选项*/
void updateUserOption(pUserInfo head, pUserInfo me) {
    char id[128] = { 0 };
    pUserInfo target = NULL;
    clearScreen();
    printf("        ┌------------------------┐\n");
    printf("               #修改用户#\n");
    printf("\n");
    printf("             账号：");
    scanf("%s", id);
    printf("        └------------------------┘\n");
    target = findUserInfoNode(head, id);
    if (target) {
        showUser(target);
        printf("┌-------------------------------------------------┐\n");
        printf("    账号：");
        printf("%s\n", target->id);
        printf("    姓名：");
        inputLine(target->name, sizeof(target->name));
        printf("    密码：");
        inputPassword(target->password, sizeof(target->password));
        if (target != me) {
            printf("    权限：（0：普通用户， 1：管理员）");
            scanf("%d", &target->rank);
            if (target->rank != NORMAL && target->rank != MANAGER) {
                target->rank = NORMAL;
            }
        }
        printf("└-------------------------------------------------┘\n");
        /*同步文件信息*/
        saveUserInfoFile(head);
        printf("\n用户修改成功！\n");
    } else {
        printf("\n未找到该用户！\n");
    }
    waitingPressAnyKey();
}

/*删除用户选项*/
void removeUserOption(pUserInfo* head, pUserInfo me) {
    char id[128] = { 0 };
    pUserInfo target = NULL;
    clearScreen();
    printf("        ┌------------------------┐\n");
    printf("               #删除用户#\n");
    printf("\n");
    printf("             账号：");
    scanf("%s", id);
    printf("        └------------------------┘\n");
    target = findUserInfoNode(*head, id);
    if (target) {
        if (target == me) {
            printf("\n不允许删除自己！\n");
        } else {
            showUser(target);
            *head = removeUserInfoNode(*head, target);
            /*同步文件信息*/
            saveUserInfoFile(*head);
            printf("\n用户删除成功！\n");
        }
    } else {
        printf("\n未找到该用户！\n");
    }
    waitingPressAnyKey();
}

/*显示图书清单选项*/
void showBookListOption(pBookInfo head) {
    if (head) {
        pBookInfo cursor = head;
        int page_current = 0;
        int page_total = countBookInfoNode(head);
        page_total = ((page_total - 1) / SHOW_BOOK_PAGE_COUNT) + 1;
        while (cursor) {
            int count = 0;
            clearScreen();
            printf("        ┌------------------------┐\n");
            printf("               #图书清单#\n");
            printf("        └------------------------┘\n");
            printf("               【%2d/%-2d】\n", ++page_current, page_total);
            while (cursor) {
                showBook(cursor);
                cursor = cursor->next;
                if (++count == SHOW_BOOK_PAGE_COUNT) {
                    break;
                }
            }
            if (cursor) {
                printf("\n【 1 下一页 | 0 返回上级菜单】\n");
                int option;
                scanf("%d", &option);
                switch (option) {
                case 1:
                    break;
                case 0:
                    return;
                }
            }
        }
    }
    printf("\n按回车键返回上级菜单...\n");
    waitingPressAnyKey();
}

/*添加图书选项*/
void createBookOption(pBookInfo* head) {
    pBookInfo book = (pBookInfo)malloc(sizeof(BookInfo));
    memset(book, 0U, sizeof(BookInfo));
    clearScreen();
    printf("        ┌------------------------┐\n");
    printf("               #添加图书#\n");
    printf("        └------------------------┘\n");
    editBook(book);
    if (findBookInfoNodeByID(*head, book->id)) {
        free(book);
        printf("\n图书添加失败，存在相同图书编号！\n");
    } else {
        *head = addBookInfoNode(*head, book);
        /*同步文件信息*/
        saveBookInfoFile(*head);
        printf("\n图书添加成功！\n");
    }
    waitingPressAnyKey();
}

/*修改图书选项*/
void updateBookOption(pBookInfo head) {
    char id[128] = { 0 };
    pBookInfo target = NULL;
    clearScreen();
    printf("        ┌------------------------┐\n");
    printf("               #修改图书#\n");
    printf("\n");
    printf("             编号：");
    scanf("%s", id);
    printf("        └------------------------┘\n");
    target = findBookInfoNodeByID(head, id);
    if (target) {
        showBook(target);
        editBook(target);
        /*同步文件信息*/
        saveBookInfoFile(head);
        printf("\n图书修改成功！\n");
    } else {
        printf("\n未找到该图书！\n");
    }
    waitingPressAnyKey();
}

/*删除图书选项*/
void removeBookOption(pBookInfo* head) {
    char id[128] = { 0 };
    pBookInfo target = NULL;
    clearScreen();
    printf("        ┌------------------------┐\n");
    printf("               #删除图书#\n");
    printf("\n");
    printf("             编号：");
    scanf("%s", id);
    printf("        └------------------------┘\n");
    target = findBookInfoNodeByID(*head, id);
    if (target) {
        showBook(target);
        *head = removeBookInfoNode(*head, target);
        /*同步文件信息*/
        saveBookInfoFile(*head);
        printf("\n图书删除成功！\n");
    } else {
        printf("\n未找到该图书！\n");
    }
    waitingPressAnyKey();
}

/*按编号查询图书选项*/
void searchBookByIDOption(pBookInfo head) {
    char id[128] = { 0 };
    pBookInfo target = NULL;
    clearScreen();
    printf("        ┌------------------------┐\n");
    printf("               #按编号查询#\n");
    printf("\n");
    printf("             编号：");
    scanf("%s", id);
    printf("        └------------------------┘\n");
    target = findBookInfoNodeByID(head, id);
    if (target) {
        showBook(target);
    } else {
        printf("\n未找到该图书！\n");
    }
    waitingPressAnyKey();
}

/*按书名查询图书选项*/
void searchBookByNameOption(pBookInfo head) {
    char name[128] = { 0 };
    pBookInfo target = NULL;
    clearScreen();
    printf("        ┌------------------------┐\n");
    printf("               #按书名查询#\n");
    printf("\n");
    printf("             书名：");
    inputLine(name, sizeof(name));
    printf("        └------------------------┘\n");
    target = findBookInfoNodeByName(head, name);
    if (target) {
        do {
            showBook(target);
            target = findBookInfoNodeByName(target->next, name);
        } while (target);
    } else {
        printf("\n未找到该图书！\n");
    }
    waitingPressAnyKey();
}

/*按作者查询图书选项*/
void searchBookByAuthorOption(pBookInfo head) {
    char author[128] = { 0 };
    pBookInfo target = NULL;
    clearScreen();
    printf("        ┌------------------------┐\n");
    printf("               #按作者查询#\n");
    printf("\n");
    printf("             作者：");
    inputLine(author, sizeof(author));
    printf("        └------------------------┘\n");
    target = findBookInfoNodeByAuthor(head, author);
    if (target) {
        do {
            showBook(target);
            target = findBookInfoNodeByAuthor(target->next, author);
        } while (target);
    } else {
        printf("\n未找到该图书！\n");
    }
    waitingPressAnyKey();
}

/*按出版社查询图书选项*/
void searchBookByPressOption(pBookInfo head) {
    char press[128] = { 0 };
    pBookInfo target = NULL;
    clearScreen();
    printf("        ┌------------------------┐\n");
    printf("               #按出版神查询#\n");
    printf("\n");
    printf("             出版社：");
    inputLine(press, sizeof(press));
    printf("        └------------------------┘\n");
    target = findBookInfoNodeByPress(head, press);
    if (target) {
        do {
            showBook(target);
            target = findBookInfoNodeByPress(target->next, press);
        } while (target);
    } else {
        printf("\n未找到该图书！\n");
    }
    waitingPressAnyKey();
}

/*添加借书记录*/
pRecordInfo addRecord(pRecordInfo* head, char* user_id, char* book_id) {
    pRecordInfo target = findRecordInfoNodeByID(*head, user_id);
    if (!target) {
        target = (pRecordInfo)malloc(sizeof(RecordInfo));
        memset(target, 0, sizeof(RecordInfo));
        strcpy(target->user_id, user_id);
        *head = addRecordInfoNode(*head, target);
    }
    if (target->count < BORROW_COUNT_MAX) {
        int index;
        for (index = 0; index < BORROW_COUNT_MAX; ++index) {
            if (strlen(target->book_id[index]) == 0) {
                strcpy(target->book_id[index], book_id);
                ++target->count;
                saveRecordInfoFile(*head);
                return target;
            }
        }
    }
    return NULL;
}

/*删除借书记录*/
pRecordInfo removeRecord(pRecordInfo* head, char* user_id, char* book_id) {
    pRecordInfo target = findRecordInfoNodeByID(*head, user_id);
    if (target) {
        int index;
        for (index = 0; index < BORROW_COUNT_MAX; ++index) {
            if (strcmp(target->book_id[index], book_id) == 0) {
                memset(target->book_id[index], 0, 128);
                --target->count;
                if (target->count == 0) {
                    *head = removeRecordInfoNode(*head, target);
                }
                saveRecordInfoFile(*head);
                return target;
            }
        }
    }
    return NULL;
}

/*借书*/
void borrowBookOption(pBookInfo bookhead, pRecordInfo* recordhead, pUserInfo me) {
    char id[128] = { 0 };
    pBookInfo target = NULL;
    clearScreen();
    printf("        ┌------------------------┐\n");
    printf("               #借书#\n");
    printf("\n");
    printf("             编号：");
    scanf("%s", id);
    printf("        └------------------------┘\n");
    target = findBookInfoNodeByID(bookhead, id);
    if (target) {
        showBook(target);
        if (target->stock > 0) {
            if (addRecord(recordhead, me->id, target->id)) {
                /*同步文件信息*/
                --target->stock;
                saveBookInfoFile(bookhead);
                printf("\n操作成功！\n");
            } else {
                printf("\n您的借阅数量已达上限，请先归还图书！\n");
            }
        } else {
            printf("\n没有库存！\n");
        }
    } else {
        printf("\n未找到该图书！\n");
    }
    waitingPressAnyKey();
}

/*还书*/
void returnBookOption(pBookInfo bookhead, pRecordInfo* recordhead, pUserInfo me) {
    char id[128] = { 0 };
    pBookInfo target = NULL;
    clearScreen();
    printf("        ┌------------------------┐\n");
    printf("               #还书#\n");
    printf("\n");
    printf("             编号：");
    scanf("%s", id);
    printf("        └------------------------┘\n");
    target = findBookInfoNodeByID(bookhead, id);
    if (target) {
        showBook(target);
        if (removeRecord(recordhead, me->id, target->id)) {
            /*同步文件信息*/
            ++target->stock;
            saveBookInfoFile(bookhead);
            printf("\n操作成功！\n");
        } else {
            printf("\n您没有借阅该图书！\n");
        }
    } else {
        printf("\n未找到该图书！\n");
    }
    waitingPressAnyKey();
}

/*借阅清单*/
void showRecordOption(pBookInfo bookhead, pRecordInfo recordhead, pUserInfo me) {
    pRecordInfo target = NULL;
    clearScreen();
    printf("        ┌------------------------┐\n");
    printf("               #借阅清单#\n");
    printf("\n");
    target = findRecordInfoNodeByID(recordhead, me->id);
    printf("           %-10s%-10s\n", "编号", "书名");
    if (target) {
        int index;
        for (index = 0; index < BORROW_COUNT_MAX; ++index) {
            char* book_id = target->book_id[index];
            pBookInfo book = findBookInfoNodeByID(bookhead, book_id);
            if (book) {
                printf("           %-10s%-10s\n", book_id, book->name);
            }
        }
    }
    printf("        └------------------------┘\n");
    waitingPressAnyKey();
}

/*用户设置选项*/
void settingUserOption(pUserInfo head, pUserInfo me) {
    clearScreen();
    printf("        ┌------------------------┐\n");
    printf("               #用户设置#\n");
    printf("        └------------------------┘\n");
    printf("┌-------------------------------------------------┐\n");
    printf("    账号：");
    printf("%s\n", me->id);
    printf("    姓名：");
    printf("%s\n", me->name);
    printf("    密码：");
    inputPassword(me->password, sizeof(me->password));
    printf("└-------------------------------------------------┘\n");
    /*同步文件信息*/
    saveUserInfoFile(head);
    printf("\n用户设置成功！\n");
    waitingPressAnyKey();
}

/*用户管理菜单*/
void manageUsersOption(pUserInfo* head, pUserInfo me) {
    int option;
    while (1) {
        clearScreen();
        printf("        ┌-------------------------------┐\n");
        printf("                 #用户管理#\n");
        printf("\n");
        printf("              【1】 用户清单\n");
        printf("              【2】 添加用户\n");
        printf("              【3】 修改用户\n");
        printf("              【4】 删除用户\n");
        printf("              【0】 返回\n");
        printf("\n");
        printf("        └-------------------------------┘\n");
        printf("\n");
        scanf("%d", &option);
        switch (option) {
        case 1:
            showUserListOption(*head);
            break;
        case 2:
            createUserOption(head);
            break;
        case 3:
            updateUserOption(*head, me);
            break;
        case 4:
            removeUserOption(head, me);
            break;
        case 0:
            return;
        }
    }
}

/*图书浏览菜单*/
void browseBooksOption(pBookInfo head) {
    int option;
    while (1) {
        clearScreen();
        printf("        ┌-------------------------------┐\n");
        printf("                 #图书浏览#\n");
        printf("\n");
        printf("              【1】 图书清单\n");
        printf("              【2】 按编号查询\n");
        printf("              【3】 按书名查询\n");
        printf("              【4】 按作者查询\n");
        printf("              【5】 按出版社查询\n");
        printf("              【0】 返回\n");
        printf("\n");
        printf("        └-------------------------------┘\n");
        printf("\n");
        scanf("%d", &option);
        switch (option) {
        case 1:
            showBookListOption(head);
            break;
        case 2:
            searchBookByIDOption(head);
            break;
        case 3:
            searchBookByNameOption(head);
            break;
        case 4:
            searchBookByAuthorOption(head);
            break;
        case 5:
            searchBookByPressOption(head);
            break;
        case 0:
            return;
        }
    }
}

/*图书管理菜单*/
void manageBooksOption(pBookInfo* head) {
    int option;
    while (1) {
        clearScreen();
        printf("        ┌-------------------------------┐\n");
        printf("                 #图书管理#\n");
        printf("\n");
        printf("              【1】 添加图书\n");
        printf("              【2】 修改图书\n");
        printf("              【3】 删除图书\n");
        printf("              【0】 返回\n");
        printf("\n");
        printf("        └-------------------------------┘\n");
        printf("\n");
        scanf("%d", &option);
        switch (option) {
        case 1:
            createBookOption(head);
            break;
        case 2:
            updateBookOption(*head);
            break;
        case 3:
            removeBookOption(head);
            break;
        case 0:
            return;
        }
    }
}

/*登录验证*/
pUserInfo checkLogin(pUserInfo head, char* id, char* password) {
    pUserInfo target = findUserInfoNode(head, id);
    if (target) {
        if (strcmp(target->password, password) == 0) {
            return target;
        }
    }
    return NULL;
}

/*普通用户系统主菜单*/
void mainNormalOption(pUserInfo* userhead, pUserInfo me, pBookInfo* bookhead, pRecordInfo* recordhead) {
    while (1) {
        int option;
        clearScreen();
        printf("        ┌-------------------------------┐\n");
        printf("               #图书信息管理系统#\n");
        printf("\n");
        printf("              【1】 浏览图书\n");
        printf("              【2】 用户设置\n");
        printf("              【3】 借书\n");
        printf("              【4】 还书\n");
        printf("              【5】 借阅清单\n");
        printf("              【0】 退出系统\n");
        printf("\n");
        printf("             账号：%s 姓名：%s 权限：%s\n", me->id, me->name, "普通用户");
        printf("        └-------------------------------┘\n");
        printf("\n");
        scanf("%d", &option);
        switch (option) {
        case 1:
            browseBooksOption(*bookhead);
            break;
        case 2:
            settingUserOption(*userhead, me);
            break;
        case 3:
            borrowBookOption(*bookhead, recordhead, me);
            break;
        case 4:
            returnBookOption(*bookhead, recordhead, me);
            break;
        case 5:
            showRecordOption(*bookhead, *recordhead, me);
            break;
        case 0:
            return;
        }
    }
}

/*管理员系统主菜单*/
void mainManagerOption(pUserInfo* userhead, pUserInfo me, pBookInfo* bookhead) {
    while (1) {
        int option;
        clearScreen();
        printf("        ┌-------------------------------┐\n");
        printf("               #图书信息管理系统#\n");
        printf("\n");
        printf("              【1】 浏览图书\n");
        printf("              【2】 用户管理\n");
        printf("              【3】 图书管理\n");
        printf("              【0】 退出系统\n");
        printf("\n");
        printf("             账号：%s 姓名：%s 权限：%s\n", me->id, me->name, "管理员");
        printf("        └-------------------------------┘\n");
        printf("\n");
        scanf("%d", &option);
        switch (option) {
        case 1:
            browseBooksOption(*bookhead);
            break;
        case 2:
            manageUsersOption(userhead, me);
            break;
        case 3:
            manageBooksOption(bookhead);
            break;
        case 0:
            return;
        }
    }
}

/*首次登录，初始化管理员账号*/
void firstLogin(pUserInfo* head) {
    pUserInfo user = (pUserInfo)malloc(sizeof(UserInfo));
    memset(user, 0U, sizeof(UserInfo));
    clearScreen();
    printf("        ┌-------------------------------┐\n");
    printf("               #图书信息管理系统#\n");
    printf("           #首次使用，需创建管理员用户#\n");
    printf("\n");
    printf("             账号 : ");
    scanf("%s", user->id);
    printf("             姓名 : ");
    inputLine(user->name, sizeof(user->name));
    printf("             密码 : ");
    scanf("%s", user->password);
    user->rank = MANAGER;
    printf("        └-------------------------------┘\n");
    *head = addUserInfoNode(*head, user);
    saveUserInfoFile(*head);
}

/*用户登录*/
pUserInfo userLogin(pUserInfo head) {
    char id[128] = { 0 };
    char password[128] = { 0 };
    pUserInfo user = NULL;
    clearScreen();
    printf("        ┌-------------------------------┐\n");
    printf("           #欢迎登录图书信息管理系统#\n");
    printf("\n");
    printf("\n");
    printf("             账号 : ");
    scanf("%s", id);
    printf("             密码 : ");
    inputPassword(password, sizeof(password));
    printf("        └-------------------------------┘\n");
    return checkLogin(head, id, password);
}

/*进入系统*/
void process(pUserInfo* userhead, pBookInfo* bookhead, pRecordInfo* recordhead) {
    pUserInfo me = NULL;
    do {
        me = userLogin(*userhead);
        if (!me) {
            printf("\n登录失败，账号或密码错误！\n");
            waitingPressAnyKey();
        }
    } while (!me);
    switch (me->rank) {
    case NORMAL:
        mainNormalOption(userhead, me, bookhead, recordhead);
        break;
    case MANAGER:
        mainManagerOption(userhead, me, bookhead);
        break;
    }
}

int main() {
    /*从文件中加载用户数据*/
    pUserInfo userhead = loadUserInfoFile();
    /*从文件中加载图书数据*/
    pBookInfo bookhead = loadBookInfoFile();
    /*从文件中加载记录数据*/
    pRecordInfo recordhead = loadRecordInfoFile();
    /*首次登录，设置管理员用户*/
    if (!userhead) {
        firstLogin(&userhead);
    }
    /*进入系统*/
    process(&userhead, &bookhead, &recordhead);
    /*清理用户列表*/
    clearUserInfoList(userhead);
    /*清理图书列表*/
    clearBookInfoList(bookhead);
    /*清理记录列表*/
    clearRecordInfoList(recordhead);
    return 0;
}
  • 下面是混淆后的代码，它跟上面的原始代码一样都能顺利编译，执行效果并无差别，但是已经不可阅读了
/*!
**************************************
*        # C/C++代码混淆器 #
*
*          --- 狐狸の窝 ---
*  Copyright (C) https://foxzzz.com
**************************************
*/
#define J27B printf("             账号：%s 姓名：%s 权限：%s\n", me->id, me->name, "普通用户");
#define J27A printf("             账号：%s 姓名：%s 权限：%s\n", me->id, me->name, "管理员");
#define J279 printf("               【%2d/%-2d】\n", ++page_current, page_total);
#define J278 printf("\n您的借阅数量已达上限，请先归还图书！\n");
#define J277 printf("└-------------------------------------------------┘\n");
#define J276 printf("┌-------------------------------------------------┐\n");
#define J275 printf("           #首次使用，需创建管理员用户#\n");
#define J274 printf("\n图书添加失败，存在相同图书编号！\n");
#define J273 printf("    权限：（0：普通用户， 1：管理员）");
#define J272 printf("           #欢迎登录图书信息管理系统#\n");
#define J271 char user_id[128];                      /*借阅人账号*/
#define J270 struct _tRecordInfo* next;              /*下一个节点*/
#define J26F printf("        ┌-------------------------------┐\n");
#define J26E printf("        └-------------------------------┘\n");
#define J26D /*将上一个节点指向删除节点的下一个节点*/
#define J26C printf("\n用户创建失败，存在相同用户！\n");
#define J26B printf("\n【 1 下一页 | 0 返回上级菜单】\n");
#define J26A char book_id[BORROW_COUNT_MAX][128];    /*图书编号*/
#define J269 int count;                              /*借阅数量*/
#define J268 printf("           %-10s%-10s\n", book_id, book->name);
#define J267 printf("           %-10s%-10s\n", "编号", "书名");
#define J266 printf("\n登录失败，账号或密码错误！\n");
#define J265 printf("               #图书信息管理系统#\n");
#define J264 printf("              【5】 按出版社查询\n");
#define J263 /*添加图书节点，返回链表首节点指针*/
#define J262 /*添加记录节点，返回链表首节点指针*/
#define J261 /*删除用户节点，返回链表首节点指针*/
#define J260 /*删除图书节点，返回链表首节点指针*/
#define J25F /*添加用户节点，返回链表首节点指针*/
#define J25E /*删除记录节点，返回链表首节点指针*/
#define J25D printf("        └------------------------┘\n");
#define J25C printf("        ┌------------------------┐\n");
#define J25B printf("              【4】 按作者查询\n");
#define J25A printf("              【2】 按编号查询\n");
#define J259 printf("              【3】 按书名查询\n");
#define J258 /*将用户节点总数写入文件起始位置*/
#define J257 printf("               #按出版神查询#\n");
#define J256 printf("\n按回车键返回上级菜单...\n");
#define J255 printf("              【1】 添加图书\n");
#define J254 printf("              【1】 用户清单\n");
#define J253 printf("              【2】 修改图书\n");
#define J252 struct _tUserInfo* next;    /*下一个节点*/
#define J251 /*将指向下个节点的指针重置成NULL*/
#define J250 struct _tBookInfo* next;    /*下一个节点*/
#define J24F printf("              【1】 浏览图书\n");
#define J24E printf("              【4】 删除用户\n");
#define J24D printf("              【2】 用户管理\n");
#define J24C printf("              【2】 添加用户\n");
#define J24B printf("              【5】 借阅清单\n");
#define J24A printf("              【3】 图书管理\n");
#define J249 printf("              【2】 用户设置\n");
#define J248 printf("              【3】 删除图书\n");
#define J247 printf("              【1】 图书清单\n");
#define J246 printf("              【3】 修改用户\n");
#define J245 printf("              【0】 退出系统\n");
#define J244 printf("               #按编号查询#\n");
#define J243 printf("               #按书名查询#\n");
#define J242 printf("               #按作者查询#\n");
#define J241 char time[256];             /*出版时间*/
#define J240 printf("                 #图书管理#\n");
#define J23F printf("                 #用户管理#\n");
#define J23E printf("                 #图书浏览#\n");
#define J23D while ((c = getchar()) != '\n' && c != EOF);
#define J23C printf("    权限：%s\n", "普通用户");
#define J23B printf("    密码：%s\n", user->password);
#define J23A /*读取文件起始位置的节点总数*/
#define J239 /*找到要删除节点的上一个节点*/
#define J238 FILE* file = fopen("recordinfo.dat", "wb");
#define J237 FILE* file = fopen("recordinfo.dat", "rb");
#define J236 /*首次登录，初始化管理员账号*/
#define J235 printf("               #删除用户#\n");
#define J234 printf("               #修改用户#\n");
#define J233 printf("               #删除图书#\n");
#define J232 printf("               #借阅清单#\n");
#define J231 printf("               #图书清单#\n");
#define J230 printf("               #用户设置#\n");
#define J22F printf("               #添加用户#\n");
#define J22E printf("               #修改图书#\n");
#define J22D printf("\n您没有借阅该图书！\n");
#define J22C printf("               #添加图书#\n");
#define J22B FILE* file = fopen("userinfo.dat", "wb");
#define J22A FILE* file = fopen("bookinfo.dat", "wb");
#define J229 char press[256];            /*出版社*/
#define J228 printf("              【3】 借书\n");
#define J227 printf("              【4】 还书\n");
#define J226 printf("              【0】 返回\n");
#define J225 FILE* file = fopen("userinfo.dat", "rb");
#define J224 FILE* file = fopen("bookinfo.dat", "rb");
#define J223 printf("    权限：%s\n", "管理员");
#define J222 /*首次登录，设置管理员用户*/
#define J221 (pRecordInfo)malloc(sizeof(RecordInfo));
#define J220 printf("    姓名：%s\n", user->name);
#define J21F printf("\n不允许删除自己！\n");
#define J21E char type[256];             /*类型*/
#define J21D char id[128];               /*编号*/
#define J21C char name[256];             /*书名*/
#define J21B char name[256];             /*姓名*/
#define J21A char id[128];               /*账号*/
#define J219 char author[256];           /*作者*/
#define J218 findBookInfoNodeByAuthor(target->next,
#define J217 int rank;                   /*权限*/
#define J216 char password[256];         /*密码*/
#define J215 printf("    账号：%s\n", user->id);
#define J214 double price;               /*价格*/
#define J213 int stock;                  /*库存*/
#define J212 /*通过出版社查找图书节点*/
#define J211 findBookInfoNodeByPress(target->next,
#define J210 /*清理图书列表，回收内存*/
#define J20F /*清理用户列表，回收内存*/
#define J20E /*将新节点插入到链表尾部*/
#define J20D /*清理记录列表，回收内存*/
#define J20C printf("\n图书修改成功！\n");
#define J20B findBookInfoNodeByName(target->next,
#define J20A printf("\n图书添加成功！\n");
#define J209 printf("\n未找到该图书！\n");
#define J208 printf("\n图书删除成功！\n");
#define J207 printf("\n用户设置成功！\n");
#define J206 printf("             出版社：");
#define J205 printf("\n用户删除成功！\n");
#define J204 (pUserInfo)malloc(sizeof(UserInfo));
#define J203 printf("\n用户创建成功！\n");
#define J202 (pBookInfo)malloc(sizeof(BookInfo));
#define J201 printf("               #借书#\n");
#define J200 printf("\n未找到该用户！\n");
#define J1FF printf("               #还书#\n");
#define J1FE printf("\n用户修改成功！\n");
#define J1FD /*从文件中加载图书数据*/
#define J1FC findBookInfoNodeByAuthor(pBookInfo
#define J1FB searchBookByAuthorOption(pBookInfo
#define J1FA findRecordInfoNodeByID(recordhead,
#define J1F9 /*从文件中加载用户信息*/
#define J1F8 /*从文件中加载记录数据*/
#define J1F7 /*从文件中加载用户数据*/
#define J1F6 /*通过账号查找记录节点*/
#define J1F5 /*从文件中加载记录信息*/
#define J1F4 /*通过书名查找图书节点*/
#define J1F3 /*通过作者查找图书节点*/
#define J1F2 /*通过账号查找用户节点*/
#define J1F1 /*通过账号查找图书节点*/
#define J1F0 /*按出版社查询图书选项*/
#define J1EF findRecordInfoNodeByID(pRecordInfo
#define J1EE /*将记录信息存储到文件*/
#define J1ED /*将用户信息存储到文件*/
#define J1EC /*将图书信息存储到文件*/
#define J1EB printf("             编号：");
#define J1EA searchBookByPressOption(pBookInfo
#define J1E9 printf("             密码 : ");
#define J1E8 printf("             作者：");
#define J1E7 printf("             书名：");
#define J1E6 printf("             姓名 : ");
#define J1E5 findBookInfoNodeByPress(pBookInfo
#define J1E4 printf("             账号：");
#define J1E3 printf("             账号 : ");
#define J1E2 searchBookByNameOption(pBookInfo
#define J1E1 clearRecordInfoList(recordhead);
#define J1E0 findBookInfoNodeByName(pBookInfo
#define J1DF removeRecordInfoNode(pRecordInfo
#define J1DE searchBookByAuthorOption(head);
#define J1DD (strlen(target->book_id[index])
#define J1DC /*按书名查询图书选项*/
#define J1DB (strcmp(target->book_id[index],
#define J1DA /*按编号查询图书选项*/
#define J1D9 clearRecordInfoList(pRecordInfo
#define J1D8 printf("%.2lf\n", book->price);
#define J1D7 /*普通用户系统主菜单*/
#define J1D6 /*从标准输入一行文本*/
#define J1D5 inputPassword(target->password,
#define J1D4 if (ch == '\n' || ch == '\r') {
#define J1D3 /*链表为空返回该节点*/
#define J1D2 countRecordInfoNode(pRecordInfo
#define J1D1 /*按作者查询图书选项*/
#define J1D0 printf("读文件失败！\n");
#define J1CF printf("写文件失败！\n");
#define J1CE findBookInfoNodeByID(pBookInfo
#define J1CD searchBookByPressOption(head);
#define J1CC findBookInfoNodeByAuthor(head,
#define J1CB printf("\n操作成功！\n");
#define J1CA printf("\n没有库存！\n");
#define J1C9 findBookInfoNodeByID(bookhead,
#define J1C8 memset(target->book_id[index],
#define J1C7 printf("    出版时间：");
#define J1C6 strcpy(target->book_id[index],
#define J1C5 searchBookByIDOption(pBookInfo
#define J1C4 findBookInfoNodeByPress(head,
#define J1C3 addRecordInfoNode(pRecordInfo
#define J1C2 printf("%s\n", book->author);
#define J1C1 inputPassword(user->password,
#define J1C0 findRecordInfoNodeByID(*head,
#define J1BF browseBooksOption(*bookhead);
#define J1BE searchBookByNameOption(head);
#define J1BD settingUserOption(*userhead,
#define J1BC /*删除节点为首节点*/
#define J1BB scanf("%s", user->password);
#define J1BA removeUserInfoNode(pUserInfo
#define J1B9 removeBookInfoNode(pBookInfo
#define J1B8 showBookListOption(pBookInfo
#define J1B7 /*管理员系统主菜单*/
#define J1B6 manageBooksOption(bookhead);
#define J1B5 manageBooksOption(pBookInfo*
#define J1B4 /*显示图书清单选项*/
#define J1B3 (findBookInfoNodeByID(*head,
#define J1B2 mainManagerOption(pUserInfo*
#define J1B1 printf("%s\n", book->press);
#define J1B0 printf("%d\n", book->stock);
#define J1AF clearBookInfoList(bookhead);
#define J1AE findBookInfoNodeByName(head,
#define J1AD manageUsersOption(pUserInfo*
#define J1AC NORMAL,     /*普通用户*/
#define J1AB clearUserInfoList(userhead);
#define J1AA /*显示用户清单选项*/
#define J1A9 showUserListOption(pUserInfo
#define J1A8 printf("    出版社：");
#define J1A7 printf("%s\n", book->name);
#define J1A6 printf("%s\n", book->time);
#define J1A5 printf("%s\n", target->id);
#define J1A4 removeBookOption(pBookInfo*
#define J1A3 removeRecordInfoNode(*head,
#define J1A2 removeUserOption(pUserInfo*
#define J1A1 returnBookOption(*bookhead,
#define J1A0 saveBookInfoFile(bookhead);
#define J19F scanf("%d", &target->rank);
#define J19E scanf("%lf", &book->price);
#define J19D searchBookByIDOption(head);
#define J19C settingUserOption(pUserInfo
#define J19B showRecordOption(*bookhead,
#define J19A borrowBookOption(*bookhead,
#define J199 browseBooksOption(pBookInfo
#define J198 clearBookInfoList(pBookInfo
#define J197 clearUserInfoList(pUserInfo
#define J196 countBookInfoNode(pBookInfo
#define J195 countUserInfoNode(pUserInfo
#define J194 createBookOption(pBookInfo*
#define J193 createUserOption(pUserInfo*
#define J192 findBookInfoNodeByID(*head,
#define J191 printf("%s\n", book->type);
#define J190 inputPassword(me->password,
#define J18F mainManagerOption(userhead,
#define J18E mainNormalOption(pUserInfo*
#define J18D manageUsersOption(userhead,
#define J18C findBookInfoNodeByID(head,
#define J18B sizeof(target->password));
#define J18A mainNormalOption(userhead,
#define J189 showUserListOption(*head);
#define J188 countRecordInfoNode(head);
#define J187 findUserInfoNode(pUserInfo
#define J186 removeRecordInfoNode(head,
#define J185 returnBookOption(pBookInfo
#define J184 borrowBookOption(pBookInfo
#define J183 updateUserOption(pUserInfo
#define J182 showRecordOption(pBookInfo
#define J181 saveRecordInfoFile(*head);
#define J180 scanf("%d", &book->stock);
#define J17F updateBookOption(pBookInfo
#define J17E (strcmp(target->password,
#define J17D MANAGER     /*管理员*/
#define J17C showBookListOption(head);
#define J17B /*等待按下任意键*/
#define J17A /*借阅记录结构体*/
#define J179 /*清空输入缓冲区*/
#define J178 removeBookInfoNode(*head,
#define J177 (removeRecord(recordhead,
#define J176 printf("%s\n", me->name);
#define J175 addBookInfoNode(pBookInfo
#define J174 removeRecord(pRecordInfo*
#define J173 addUserInfoNode(pUserInfo
#define J172 removeUserInfoNode(*head,
#define J171 printf("%s\n", book->id);
#define J170 /*计算记录节点数*/
#define J16F /*计算用户节点数*/
#define J16E /*计算图书节点数*/
#define J16D scanf("%d", &user->rank);
#define J16C countBookInfoNode(head);
#define J16B scanf("%s", book->time);
#define J16A saveUserInfoFile(*head);
#define J169 addRecordInfoNode(*head,
#define J168 saveRecordInfoFile(const
#define J167 scanf("%s", book->type);
#define J166 printf("    价格：");
#define J165 removeUserInfoNode(head,
#define J164 removeBookInfoNode(head,
#define J163 saveBookInfoFile(*head);
#define J162 printf("    账号：");
#define J161 (findUserInfoNode(*head,
#define J160 (strcmp(cursor->user_id,
#define J15F printf("    编号：");
#define J15E printf("    类型：");
#define J15D printf("    库存：");
#define J15C printf("    密码：");
#define J15B printf("    书名：");
#define J15A updateBookOption(*head);
#define J159 printf("    姓名：");
#define J158 sizeof(user->password));
#define J157 countUserInfoNode(head);
#define J156 printf("    作者：");
#define J155 inputLine(book->author,
#define J154 updateUserOption(*head,
#define J153 strcpy(target->user_id,
#define J152 addRecordInfoNode(head,
#define J151 target->book_id[index];
#define J150 inputPassword(password,
#define J14F saveUserInfoFile(head);
#define J14E (strcmp(cursor->author,
#define J14D saveBookInfoFile(head);
#define J14C createUserOption(head);
#define J14B inputLine(target->name,
#define J14A createBookOption(head);
#define J149 removeBookOption(head);
#define J148 printf("%s\n", me->id);
#define J147 password[index] = '\0';
#define J146 findUserInfoNode(*head,
#define J145 /*用户管理菜单*/
#define J144 /*显示图书信息*/
#define J143 /*显示用户信息*/
#define J142 /*添加借书记录*/
#define J141 /*添加图书选项*/
#define J140 sizeof(me->password));
#define J13F sizeof(book->author));
#define J13E /*编辑图书信息*/
#define J13D scanf("%s", user->id);
#define J13C /*编辑用户信息*/
#define J13B /*修改用户选项*/
#define J13A scanf("%s", book->id);
#define J139 addBookInfoNode(*head,
#define J138 (strcmp(cursor->press,
#define J137 /*清理记录列表*/
#define J136 /*添加用户选项*/
#define J135 saveUserInfoFile(const
#define J134 sizeof(target->name));
#define J133 /*用户设置选项*/
#define J132 addRecord(pRecordInfo*
#define J131 addUserInfoNode(*head,
#define J130 saveBookInfoFile(const
#define J12F firstLogin(&userhead);
#define J12E /*清理用户列表*/
#define J12D findUserInfoNode(head,
#define J12C removeUserOption(head,
#define J12B (addRecord(recordhead,
#define J12A /*删除借书记录*/
#define J129 inputLine(book->press,
#define J128 /*清理图书列表*/
#define J127 /*修改图书选项*/
#define J126 /*同步文件信息*/
#define J125 /*图书浏览菜单*/
#define J124 /*删除图书选项*/
#define J123 /*图书管理菜单*/
#define J122 /*删除用户选项*/
#define J121 loadRecordInfoFile();
#define J120 scanf("%d", &option);
#define J11F addUserInfoNode(head,
#define J11E inputLine(book->name,
#define J11D (strcmp(cursor->name,
#define J11C userLogin(*userhead);
#define J11B inputLine(user->name,
#define J11A waitingPressAnyKey();
#define J119 addBookInfoNode(head,
#define J118 sizeof(book->press));
#define J117 firstLogin(pUserInfo*
#define J116 line[len - 1] = '\0';
#define J115 SHOW_BOOK_PAGE_COUNT)
#define J114 checkLogin(pUserInfo
#define J113 sizeof(book->name));
#define J112 sizeof(RecordInfo));
#define J111 loadRecordInfoFile()
#define J110 sizeof(user->name));
#define J10F waitingPressAnyKey()
#define J10E inputPassword(char*
#define J10D /*图书结构体*/
#define J10C /*用户结构体*/
#define J10B loadBookInfoFile();
#define J10A sizeof(RecordInfo),
#define J109 userLogin(pUserInfo
#define J108 loadUserInfoFile();
#define J107 /*删除该节点*/
#define J106 (strcmp(cursor->id,
#define J105 editBook(pBookInfo
#define J104 editUser(pUserInfo
#define J103 sizeof(password));
#define J102 sizeof(UserInfo));
#define J101 sizeof(BookInfo));
#define J100 loadBookInfoFile()
#define JFF loadUserInfoFile()
#define JFE showUser(pUserInfo
#define JFD (strlen(book->id))
#define JFC process(pUserInfo*
#define JFB process(&userhead,
#define JFA showBook(pBookInfo
#define JF9 editBook(target);
#define JF8 showUser(cursor);
#define JF7 sizeof(UserInfo),
#define JF6 password[index++]
#define JF5 BORROW_COUNT_MAX)
#define JF4 sizeof(BookInfo),
#define JF3 showBook(target);
#define JF2 showBook(cursor);
#define JF1 BORROW_COUNT_MAX;
#define JF0 inputLine(author,
#define JEF showUser(target);
#define JEE if (ch == '\b') {
#define JED /*匹配图书*/
#define JEC /*匹配用户*/
#define JEB /*用户权限*/
#define JEA /*用户登录*/
#define JE9 /*登录验证*/
#define JE8 /*输入密码*/
#define JE7 /*进入系统*/
#define JE6 checkLogin(head,
#define JE5 inputLine(press,
#define JE4 scanf("%s", id);
#define JE3 sizeof(author));
#define JE2 ++target->count;
#define JE1 ++target->stock;
#define JE0 --target->count;
#define JDF --target->stock;
#define JDE /*借阅清单*/
#define JDD editBook(book);
#define JDC sizeof(press));
#define JDB inputLine(name,
#define JDA editUser(user);
#define JD9 inputLine(char*
#define JD8 putchar('\b');
#define JD7 sizeof(name));
#define JD6 memset(target,
#define JD5 fwrite(&count,
#define JD4 fwrite(cursor,
#define JD3 putchar('\n');
#define JD2 clearScreen();
#define JD1 (cursor->next)
#define JD0 (target->stock
#define JCF (target->count
#define JCE system("cls");
#define JCD &recordhead);
#define JCC clearScreen()
#define JCB (cursor->next
#define JCA putchar(' ');
#define JC9 emptyStdin();
#define JC8 putchar('*');
#define JC7 fclose(file);
#define JC6 (target->rank
#define JC5 printf("\n");
#define JC4 password[128]
#define JC3 cursor->next;
#define JC2 fread(&count,
#define JC1 strlen(line);
#define JC0 memset(user,
#define JBF page_current
#define JBE memset(book,
#define JBD _tRecordInfo
#define JBC target->id))
#define JBB ((page_total
#define JBA sizeof(int),
#define JB9 target->rank
#define JB8 emptyStdin()
#define JB7 *recordhead,
#define JB6 (user->rank)
#define JB5 (fgets(line,
#define JB4 cursor->next
#define JB3 recordhead);
#define JB2 pRecordInfo;
#define JB1 pRecordInfo*
#define JB0 recordhead)
#define JAF (user->rank
#define JAE recordhead,
#define JAD author[128]
#define JAC (!userhead)
#define JAB RecordInfo,
#define JAA pRecordInfo
#define JA9 node->next;
#define JA8 fread(book,
#define JA7 fread(user,
#define JA6 free(book);
#define JA5 free(node);
#define JA4 free(user);
#define JA3 bookhead);
#define JA2 pBookInfo*
#define JA1 (me->rank)
#define JA0 page_total
#define J9F &bookhead,
#define J9E press[128]
#define J9D /*还书*/
#define J9C pUserInfo;
#define J9B book->id))
#define J9A /*借书*/
#define J99 /*清屏*/
#define J98 getchar();
#define J97 user->rank
#define J96 user->next
#define J95 user->id))
#define J94 _tUserInfo
#define J93 _tBookInfo
#define J92 book->next
#define J91 password);
#define J90 recordhead
#define J8F pBookInfo;
#define J8E continue;
#define J8D (count--)
#define J8C (!target)
#define J8B password,
#define J8A BookInfo,
#define J89 (target);
#define J88 capacity,
#define J87 capacity)
#define J86 _getch();
#define J85 UserInfo,
#define J84 password)
#define J83 bookhead,
#define J82 pBookInfo
#define J81 pUserInfo
#define J80 bookhead)
#define J7F book_id);
#define J7E user_id);
#define J7D userhead,
#define J7C name[128]
#define J7B bookhead
#define J7A MANAGER;
#define J79 ++index)
#define J78 (target)
#define J77 (option)
#define J76 UserRank
#define J75 me->id);
#define J74 target);
#define J73 author);
#define J72 ++count;
#define J71 (cursor)
#define J70 MANAGER:
#define J6F (++count
#define J6E MANAGER)
#define J6D user_id,
#define J6C userhead
#define J6B book_id)
#define J6A --index;
#define J69 return;
#define J68 option;
#define J67 typedef
#define J66 me->id,
#define J65 id[128]
#define J64 press);
#define J63 stdin))
#define J62 NORMAL:
#define J61 target;
#define J60 NORMAL;
#define J5F book_id
#define J5E (target
#define J5D cursor;
#define J5C author)
#define J5B size_t
#define J5A return
#define J59 (!me);
#define J58 press)
#define J57 (book)
#define J56 (file)
#define J55 user);
#define J54 target
#define J53 file);
#define J52 head);
#define J51 index;
#define J50 book);
#define J4F cursor
#define J4E main()
#define J4D (head)
#define J4C NORMAL
#define J4B (index
#define J4A count;
#define J49 switch
#define J48 struct
#define J47 name);
#define J46 break;
#define J45 node)
#define J44 head)
#define J43 index
#define J42 head,
#define J41 line,
#define J40 head;
#define J3F char*
#define J3E count
#define J3D book)
#define J3C name)
#define J3B 128);
#define J3A node;
#define J39 (head
#define J38 *head
#define J37 (!me)
#define J36 user)
#define J35 NULL;
#define J34 while
#define J33 id);
#define J32 user
#define J31 head
#define J30 me);
#define J2F case
#define J2E enum
#define J2D else
#define J2C char
#define J2B void
#define J2A (len
#define J29 book
#define J28 me,
#define J27 for
#define J26 0U,
#define J25 id)
#define J24 int
#define J23 me)
#define J22 id,
#define J21 (1)
#define J20 ch;
#define J1F len
#define J1E 3:
#define J1D 1:
#define J1C 2:
#define J1B do
#define J1A if
#define J19 me
#define J18 ch
#define J17 &&
#define J16 1,
#define J15 1)
#define J14 1;
#define J13 ==
#define J12 0,
#define J11 0)
#define J10 c;
#define JF !=
#define JE 0:
#define JD 5:
#define JC 4:
#define JB 0;
#define JA };
#define J9 /
#define J8 <
#define J7 +
#define J6 -
#define J5 0
#define J4 *
#define J3 >
#define J2 {
#define J1 }
#define J0 =
/********************************************
* 图书信息管理系统
* Copyright (C) i@foxzzz.com
*
* C语言实现的命令行模式下的信息管理系统。
*********************************************/
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <conio.h>
#define BORROW_COUNT_MAX 10     /*最多可借阅的图书数量*/
#define SHOW_BOOK_PAGE_COUNT 20 /*一页显示的图书条目*/
#define J27C JEB J2E J76 J2 J1AC J17D JA J10C J67 J48
#define J27D J94 J2 J21A J21B J216 J217 J252 J1 J85 J4
#define J27E J9C J10D J67 J48 J93 J2 J21D J21C J219 J229
#define J27F J21E J241 J214 J213 J250 J1 J8A J4 J8F J17A
#define J280 J67 J48 JBD J2 J271 J26A J269 J270 J1 JAB
#define J281 J4 JB2 J179 J2B JB8 J2 J24 J10 J23D J1
#define J282 J17B J2B J10F J2 JC9 J98 J1 J99 J2B JCC
#define J283 J2 JCE J1 J1D6 J2B JD9 J41 J24 J87 J2
#define J284 J34 J21 J2 J1A JB5 J88 J63 J2 J5B J1F
#define J285 J0 JC1 J1A J2A J3 J15 J2 J116 J46 J1
#define J286 J1 J1 J1 JE8 J2B J10E J8B J24 J87 J2
#define J287 J24 J43 J0 JB J34 J4B J8 J87 J2 J24
#define J288 J18 J0 J86 J1D4 J1A J4B J3 J11 J2 J147
#define J289 JD3 J46 J1 J2D J8E J1 JEE J1A J4B J3
#define J28A J11 J2 J6A JD8 JCA JD8 J1 J1 J2D J2
#define J28B JF6 J0 J20 JC8 J1 J1 J1 J25F J81 J173
#define J28C J42 J81 J45 J2 J1A J4D J2 J81 J4F J0
#define J28D J40 J34 JD1 J2 J4F J0 JC3 J1 J20E JB4
#define J28E J0 J3A J5A J40 J1 J2D J2 J1D3 J5A J3A
#define J28F J1 J1 J261 J81 J1BA J42 J81 J45 J2 J1A
#define J290 J4D J2 J1A J39 J13 J45 J2 J1BC J31 J0
#define J291 JA9 J107 JA5 J1 J2D J2 J81 J4F J0 J40
#define J292 J34 JD1 J2 J239 J1A JCB J13 J45 J2 J26D
#define J293 JB4 J0 JA9 J107 JA5 J46 J1 J4F J0 JC3
#define J294 J1 J1 J1 J5A J40 J1 J1F2 J81 J187 J42
#define J295 J3F J25 J2 J81 J4F J0 J40 J34 J71 J2
#define J296 JEC J1A J106 J25 J13 J11 J2 J5A J5D J1
#define J297 J4F J0 JC3 J1 J5A J35 J1 J16F J24 J195
#define J298 J44 J2 J81 J4F J0 J40 J24 J3E J0 JB
#define J299 J34 J71 J2 J72 J4F J0 JC3 J1 J5A J4A
#define J29A J1 J263 J82 J175 J42 J82 J45 J2 J1A J4D
#define J29B J2 J82 J4F J0 J40 J34 JD1 J2 J4F J0
#define J29C JC3 J1 J20E JB4 J0 J3A J5A J40 J1 J2D
#define J29D J2 J1D3 J5A J3A J1 J1 J260 J82 J1B9 J42
#define J29E J82 J45 J2 J1A J4D J2 J1A J39 J13 J45
#define J29F J2 J1BC J31 J0 JA9 J107 JA5 J1 J2D J2
#define J2A0 J82 J4F J0 J40 J34 JD1 J2 J239 J1A JCB
#define J2A1 J13 J45 J2 J26D JB4 J0 JA9 J107 JA5 J46
#define J2A2 J1 J4F J0 JC3 J1 J1 J1 J5A J40 J1
#define J2A3 J1F1 J82 J1CE J42 J3F J25 J2 J82 J4F J0
#define J2A4 J40 J34 J71 J2 JED J1A J106 J25 J13 J11
#define J2A5 J2 J5A J5D J1 J4F J0 JC3 J1 J5A J35
#define J2A6 J1 J1F4 J82 J1E0 J42 J3F J3C J2 J82 J4F
#define J2A7 J0 J40 J34 J71 J2 JED J1A J11D J3C J13
#define J2A8 J11 J2 J5A J5D J1 J4F J0 JC3 J1 J5A
#define J2A9 J35 J1 J1F3 J82 J1FC J42 J3F J5C J2 J82
#define J2AA J4F J0 J40 J34 J71 J2 JED J1A J14E J5C
#define J2AB J13 J11 J2 J5A J5D J1 J4F J0 JC3 J1
#define J2AC J5A J35 J1 J212 J82 J1E5 J42 J3F J58 J2
#define J2AD J82 J4F J0 J40 J34 J71 J2 JED J1A J138
#define J2AE J58 J13 J11 J2 J5A J5D J1 J4F J0 JC3
#define J2AF J1 J5A J35 J1 J16E J24 J196 J44 J2 J82
#define J2B0 J4F J0 J40 J24 J3E J0 JB J34 J71 J2
#define J2B1 J72 J4F J0 JC3 J1 J5A J4A J1 J262 JAA
#define J2B2 J1C3 J42 JAA J45 J2 J1A J4D J2 JAA J4F
#define J2B3 J0 J40 J34 JD1 J2 J4F J0 JC3 J1 J20E
#define J2B4 JB4 J0 J3A J5A J40 J1 J2D J2 J1D3 J5A
#define J2B5 J3A J1 J1 J25E JAA J1DF J42 JAA J45 J2
#define J2B6 J1A J4D J2 J1A J39 J13 J45 J2 J1BC J31
#define J2B7 J0 JA9 J107 JA5 J1 J2D J2 JAA J4F J0
#define J2B8 J40 J34 JD1 J2 J239 J1A JCB J13 J45 J2
#define J2B9 J26D JB4 J0 JA9 J107 JA5 J46 J1 J4F J0
#define J2BA JC3 J1 J1 J1 J5A J40 J1 J1F6 JAA J1EF
#define J2BB J42 J3F J25 J2 JAA J4F J0 J40 J34 J71
#define J2BC J2 JEC J1A J160 J25 J13 J11 J2 J5A J5D
#define J2BD J1 J4F J0 JC3 J1 J5A J35 J1 J170 J24
#define J2BE J1D2 J44 J2 JAA J4F J0 J40 J24 J3E J0
#define J2BF JB J34 J71 J2 J72 J4F J0 JC3 J1 J5A
#define J2C0 J4A J1 J1ED J2B J135 J81 J44 J2 J81 J4F
#define J2C1 J0 J40 J22B J1A J56 J2 J24 J3E J0 J157
#define J2C2 J258 JD5 JBA J16 J53 J34 J71 J2 JD4 JF7
#define J2C3 J16 J53 J4F J0 JC3 J1 JC7 J1 J2D J2
#define J2C4 J1CF J1 J1 J1F9 J81 JFF J2 J81 J31 J0
#define J2C5 J35 J225 J1A J56 J2 J24 J3E J0 JB J23A
#define J2C6 JC2 JBA J16 J53 J34 J8D J2 J81 J32 J0
#define J2C7 J204 JC0 J12 J102 JA7 JF7 J16 J53 J251 J96
#define J2C8 J0 J35 J31 J0 J11F J55 J1 JC7 J1 J2D
#define J2C9 J2 J1D0 J1 J5A J40 J1 J20F J2B J197 J44
#define J2CA J2 J34 J4D J2 J31 J0 J165 J52 J1 J1
#define J2CB J1EC J2B J130 J82 J44 J2 J82 J4F J0 J40
#define J2CC J22A J1A J56 J2 J24 J3E J0 J16C J258 JD5
#define J2CD JBA J16 J53 J34 J71 J2 JD4 JF4 J16 J53
#define J2CE J4F J0 JC3 J1 JC7 J1 J2D J2 J1CF J1
#define J2CF J1 J1F9 J82 J100 J2 J82 J31 J0 J35 J224
#define J2D0 J1A J56 J2 J24 J3E J0 JB J23A JC2 JBA
#define J2D1 J16 J53 J34 J8D J2 J82 J29 J0 J202 JBE
#define J2D2 J12 J101 JA8 JF4 J16 J53 J251 J92 J0 J35
#define J2D3 J31 J0 J119 J50 J1 JC7 J1 J2D J2 J1D0
#define J2D4 J1 J5A J40 J1 J210 J2B J198 J44 J2 J34
#define J2D5 J4D J2 J31 J0 J164 J52 J1 J1 J1EE J2B
#define J2D6 J168 JAA J44 J2 JAA J4F J0 J40 J238 J1A
#define J2D7 J56 J2 J24 J3E J0 J188 J258 JD5 JBA J16
#define J2D8 J53 J34 J71 J2 JD4 J10A J16 J53 J4F J0
#define J2D9 JC3 J1 JC7 J1 J2D J2 J1CF J1 J1 J1F5
#define J2DA JAA J111 J2 JAA J31 J0 J35 J237 J1A J56
#define J2DB J2 J24 J3E J0 JB J23A JC2 JBA J16 J53
#define J2DC J34 J8D J2 JAA J29 J0 J221 JBE J12 J112
#define J2DD JA8 J10A J16 J53 J251 J92 J0 J35 J31 J0
#define J2DE J152 J50 J1 JC7 J1 J2D J2 J1D0 J1 J5A
#define J2DF J40 J1 J20D J2B J1D9 J44 J2 J34 J4D J2
#define J2E0 J31 J0 J186 J52 J1 J1 J143 J2B JFE J36
#define J2E1 J2 J276 J215 J220 J23B J49 JB6 J2 J2F J62
#define J2E2 J23C J46 J2F J70 J223 J46 J1 J277 J1 J13C
#define J2E3 J2B J104 J36 J2 J276 J162 J13D J159 J11B J110
#define J2E4 J15C J1C1 J158 J273 J16D J1A JAF JF J4C J17
#define J2E5 J97 JF J6E J2 J97 J0 J60 J1 J277 J1
#define J2E6 J144 J2B JFA J3D J2 J276 J15F J171 J15B J1A7
#define J2E7 J156 J1C2 J1A8 J1B1 J15E J191 J1C7 J1A6 J166 J1D8
#define J2E8 J15D J1B0 J277 J1 J13E J2B J105 J3D J2 J276
#define J2E9 J15F J1A JFD J2 J171 J1 J2D J2 J13A J1
#define J2EA J15B J11E J113 J156 J155 J13F J1A8 J129 J118 J15E
#define J2EB J167 J1C7 J16B J166 J19E J15D J180 J277 J1 J1AA
#define J2EC J2B J1A9 J44 J2 J81 J4F J0 J40 J34 J71
#define J2ED J2 JF8 J4F J0 JC3 J1 J256 J11A J1 J136
#define J2EE J2B J193 J44 J2 J81 J32 J0 J204 JC0 J26
#define J2EF J102 JD2 J25C J22F J25D JDA J1A J161 J95 J2
#define J2F0 JA4 J26C J1 J2D J2 J38 J0 J131 J55 J126
#define J2F1 J16A J203 J1 J11A J1 J13B J2B J183 J42 J81
#define J2F2 J23 J2 J2C J65 J0 J2 J5 JA J81 J54
#define J2F3 J0 J35 JD2 J25C J234 JC5 J1E4 JE4 J25D J54
#define J2F4 J0 J12D J33 J1A J78 J2 JEF J276 J162 J1A5
#define J2F5 J159 J14B J134 J15C J1D5 J18B J1A J5E JF J23
#define J2F6 J2 J273 J19F J1A JC6 JF J4C J17 JB9 JF
#define J2F7 J6E J2 JB9 J0 J60 J1 J1 J277 J126 J14F
#define J2F8 J1FE J1 J2D J2 J200 J1 J11A J1 J122 J2B
#define J2F9 J1A2 J42 J81 J23 J2 J2C J65 J0 J2 J5
#define J2FA JA J81 J54 J0 J35 JD2 J25C J235 JC5 J1E4
#define J2FB JE4 J25D J54 J0 J146 J33 J1A J78 J2 J1A
#define J2FC J5E J13 J23 J2 J21F J1 J2D J2 JEF J38
#define J2FD J0 J172 J74 J126 J16A J205 J1 J1 J2D J2
#define J2FE J200 J1 J11A J1 J1B4 J2B J1B8 J44 J2 J1A
#define J2FF J4D J2 J82 J4F J0 J40 J24 JBF J0 JB
#define J300 J24 JA0 J0 J16C JA0 J0 JBB J6 J15 J9
#define J301 J115 J7 J14 J34 J71 J2 J24 J3E J0 JB
#define J302 JD2 J25C J231 J25D J279 J34 J71 J2 JF2 J4F
#define J303 J0 JC3 J1A J6F J13 J115 J2 J46 J1 J1
#define J304 J1A J71 J2 J26B J24 J68 J120 J49 J77 J2
#define J305 J2F J1D J46 J2F JE J69 J1 J1 J1 J1
#define J306 J256 J11A J1 J141 J2B J194 J44 J2 J82 J29
#define J307 J0 J202 JBE J26 J101 JD2 J25C J22C J25D JDD
#define J308 J1A J1B3 J9B J2 JA6 J274 J1 J2D J2 J38
#define J309 J0 J139 J50 J126 J163 J20A J1 J11A J1 J127
#define J30A J2B J17F J44 J2 J2C J65 J0 J2 J5 JA
#define J30B J82 J54 J0 J35 JD2 J25C J22E JC5 J1EB JE4
#define J30C J25D J54 J0 J18C J33 J1A J78 J2 JF3 JF9
#define J30D J126 J14D J20C J1 J2D J2 J209 J1 J11A J1
#define J30E J124 J2B J1A4 J44 J2 J2C J65 J0 J2 J5
#define J30F JA J82 J54 J0 J35 JD2 J25C J233 JC5 J1EB
#define J310 JE4 J25D J54 J0 J192 J33 J1A J78 J2 JF3
#define J311 J38 J0 J178 J74 J126 J163 J208 J1 J2D J2
#define J312 J209 J1 J11A J1 J1DA J2B J1C5 J44 J2 J2C
#define J313 J65 J0 J2 J5 JA J82 J54 J0 J35 JD2
#define J314 J25C J244 JC5 J1EB JE4 J25D J54 J0 J18C J33
#define J315 J1A J78 J2 JF3 J1 J2D J2 J209 J1 J11A
#define J316 J1 J1DC J2B J1E2 J44 J2 J2C J7C J0 J2
#define J317 J5 JA J82 J54 J0 J35 JD2 J25C J243 JC5
#define J318 J1E7 JDB JD7 J25D J54 J0 J1AE J47 J1A J78
#define J319 J2 J1B J2 JF3 J54 J0 J20B J47 J1 J34
#define J31A J89 J1 J2D J2 J209 J1 J11A J1 J1D1 J2B
#define J31B J1FB J44 J2 J2C JAD J0 J2 J5 JA J82
#define J31C J54 J0 J35 JD2 J25C J242 JC5 J1E8 JF0 JE3
#define J31D J25D J54 J0 J1CC J73 J1A J78 J2 J1B J2
#define J31E JF3 J54 J0 J218 J73 J1 J34 J89 J1 J2D
#define J31F J2 J209 J1 J11A J1 J1F0 J2B J1EA J44 J2
#define J320 J2C J9E J0 J2 J5 JA J82 J54 J0 J35
#define J321 JD2 J25C J257 JC5 J206 JE5 JDC J25D J54 J0
#define J322 J1C4 J64 J1A J78 J2 J1B J2 JF3 J54 J0
#define J323 J211 J64 J1 J34 J89 J1 J2D J2 J209 J1
#define J324 J11A J1 J142 JAA J132 J42 J3F J6D J3F J6B
#define J325 J2 JAA J54 J0 J1C0 J7E J1A J8C J2 J54
#define J326 J0 J221 JD6 J12 J112 J153 J7E J38 J0 J169
#define J327 J74 J1 J1A JCF J8 JF5 J2 J24 J51 J27
#define J328 J4B J0 JB J43 J8 JF1 J79 J2 J1A J1DD
#define J329 J13 J11 J2 J1C6 J7F JE2 J181 J5A J61 J1
#define J32A J1 J1 J5A J35 J1 J12A JAA J174 J42 J3F
#define J32B J6D J3F J6B J2 JAA J54 J0 J1C0 J7E J1A
#define J32C J78 J2 J24 J51 J27 J4B J0 JB J43 J8
#define J32D JF1 J79 J2 J1A J1DB J6B J13 J11 J2 J1C8
#define J32E J12 J3B JE0 J1A JCF J13 J11 J2 J38 J0
#define J32F J1A3 J74 J1 J181 J5A J61 J1 J1 J1 J5A
#define J330 J35 J1 J9A J2B J184 J83 JB1 JAE J81 J23
#define J331 J2 J2C J65 J0 J2 J5 JA J82 J54 J0
#define J332 J35 JD2 J25C J201 JC5 J1EB JE4 J25D J54 J0
#define J333 J1C9 J33 J1A J78 J2 JF3 J1A JD0 J3 J11
#define J334 J2 J1A J12B J66 JBC J2 J126 JDF J1A0 J1CB
#define J335 J1 J2D J2 J278 J1 J1 J2D J2 J1CA J1
#define J336 J1 J2D J2 J209 J1 J11A J1 J9D J2B J185
#define J337 J83 JB1 JAE J81 J23 J2 J2C J65 J0 J2
#define J338 J5 JA J82 J54 J0 J35 JD2 J25C J1FF JC5
#define J339 J1EB JE4 J25D J54 J0 J1C9 J33 J1A J78 J2
#define J33A JF3 J1A J177 J66 JBC J2 J126 JE1 J1A0 J1CB
#define J33B J1 J2D J2 J22D J1 J1 J2D J2 J209 J1
#define J33C J11A J1 JDE J2B J182 J83 JAA JAE J81 J23
#define J33D J2 JAA J54 J0 J35 JD2 J25C J232 JC5 J54
#define J33E J0 J1FA J75 J267 J1A J78 J2 J24 J51 J27
#define J33F J4B J0 JB J43 J8 JF1 J79 J2 J3F J5F
#define J340 J0 J151 J82 J29 J0 J1C9 J7F J1A J57 J2
#define J341 J268 J1 J1 J1 J25D J11A J1 J133 J2B J19C
#define J342 J42 J81 J23 J2 JD2 J25C J230 J25D J276 J162
#define J343 J148 J159 J176 J15C J190 J140 J277 J126 J14F J207
#define J344 J11A J1 J145 J2B J1AD J42 J81 J23 J2 J24
#define J345 J68 J34 J21 J2 JD2 J26F J23F JC5 J254 J24C
#define J346 J246 J24E J226 JC5 J26E JC5 J120 J49 J77 J2
#define J347 J2F J1D J189 J46 J2F J1C J14C J46 J2F J1E
#define J348 J154 J30 J46 J2F JC J12C J30 J46 J2F JE
#define J349 J69 J1 J1 J1 J125 J2B J199 J44 J2 J24
#define J34A J68 J34 J21 J2 JD2 J26F J23E JC5 J247 J25A
#define J34B J259 J25B J264 J226 JC5 J26E JC5 J120 J49 J77
#define J34C J2 J2F J1D J17C J46 J2F J1C J19D J46 J2F
#define J34D J1E J1BE J46 J2F JC J1DE J46 J2F JD J1CD
#define J34E J46 J2F JE J69 J1 J1 J1 J123 J2B J1B5
#define J34F J44 J2 J24 J68 J34 J21 J2 JD2 J26F J240
#define J350 JC5 J255 J253 J248 J226 JC5 J26E JC5 J120 J49
#define J351 J77 J2 J2F J1D J14A J46 J2F J1C J15A J46
#define J352 J2F J1E J149 J46 J2F JE J69 J1 J1 J1
#define J353 JE9 J81 J114 J42 J3F J22 J3F J84 J2 J81
#define J354 J54 J0 J12D J33 J1A J78 J2 J1A J17E J84
#define J355 J13 J11 J2 J5A J61 J1 J1 J5A J35 J1
#define J356 J1D7 J2B J18E J7D J81 J28 JA2 J83 JB1 JB0
#define J357 J2 J34 J21 J2 J24 J68 JD2 J26F J265 JC5
#define J358 J24F J249 J228 J227 J24B J245 JC5 J27B J26E JC5
#define J359 J120 J49 J77 J2 J2F J1D J1BF J46 J2F J1C
#define J35A J1BD J30 J46 J2F J1E J19A JAE J30 J46 J2F
#define J35B JC J1A1 JAE J30 J46 J2F JD J19B JB7 J30
#define J35C J46 J2F JE J69 J1 J1 J1 J1B7 J2B J1B2
#define J35D J7D J81 J28 JA2 J80 J2 J34 J21 J2 J24
#define J35E J68 JD2 J26F J265 JC5 J24F J24D J24A J245 JC5
#define J35F J27A J26E JC5 J120 J49 J77 J2 J2F J1D J1BF
#define J360 J46 J2F J1C J18D J30 J46 J2F J1E J1B6 J46
#define J361 J2F JE J69 J1 J1 J1 J236 J2B J117 J44
#define J362 J2 J81 J32 J0 J204 JC0 J26 J102 JD2 J26F
#define J363 J265 J275 JC5 J1E3 J13D J1E6 J11B J110 J1E9 J1BB
#define J364 J97 J0 J7A J26E J38 J0 J131 J55 J16A J1
#define J365 JEA J81 J109 J44 J2 J2C J65 J0 J2 J5
#define J366 JA J2C JC4 J0 J2 J5 JA J81 J32 J0
#define J367 J35 JD2 J26F J272 JC5 JC5 J1E3 JE4 J1E9 J150
#define J368 J103 J26E J5A JE6 J22 J91 J1 JE7 J2B JFC
#define J369 J7D JA2 J83 JB1 JB0 J2 J81 J19 J0 J35
#define J36A J1B J2 J19 J0 J11C J1A J37 J2 J266 J11A
#define J36B J1 J1 J34 J59 J49 JA1 J2 J2F J62 J18A
#define J36C J28 J83 JB3 J46 J2F J70 J18F J28 JA3 J46
#define J36D J1 J1 J24 J4E J2 J1F7 J81 J6C J0 J108
#define J36E J1FD J82 J7B J0 J10B J1F8 JAA J90 J0 J121
#define J36F J222 J1A JAC J2 J12F J1 JE7 JFB J9F JCD
#define J370 J12E J1AB J128 J1AF J137 J1E1 J5A JB J1 
#define J371 J27C J27D J27E J27F J280 J281 J282 J283 J284 J285
#define J372 J286 J287 J288 J289 J28A J28B J28C J28D J28E J28F
#define J373 J290 J291 J292 J293 J294 J295 J296 J297 J298 J299
#define J374 J29A J29B J29C J29D J29E J29F J2A0 J2A1 J2A2 J2A3
#define J375 J2A4 J2A5 J2A6 J2A7 J2A8 J2A9 J2AA J2AB J2AC J2AD
#define J376 J2AE J2AF J2B0 J2B1 J2B2 J2B3 J2B4 J2B5 J2B6 J2B7
#define J377 J2B8 J2B9 J2BA J2BB J2BC J2BD J2BE J2BF J2C0 J2C1
#define J378 J2C2 J2C3 J2C4 J2C5 J2C6 J2C7 J2C8 J2C9 J2CA J2CB
#define J379 J2CC J2CD J2CE J2CF J2D0 J2D1 J2D2 J2D3 J2D4 J2D5
#define J37A J2D6 J2D7 J2D8 J2D9 J2DA J2DB J2DC J2DD J2DE J2DF
#define J37B J2E0 J2E1 J2E2 J2E3 J2E4 J2E5 J2E6 J2E7 J2E8 J2E9
#define J37C J2EA J2EB J2EC J2ED J2EE J2EF J2F0 J2F1 J2F2 J2F3
#define J37D J2F4 J2F5 J2F6 J2F7 J2F8 J2F9 J2FA J2FB J2FC J2FD
#define J37E J2FE J2FF J300 J301 J302 J303 J304 J305 J306 J307
#define J37F J308 J309 J30A J30B J30C J30D J30E J30F J310 J311
#define J380 J312 J313 J314 J315 J316 J317 J318 J319 J31A J31B
#define J381 J31C J31D J31E J31F J320 J321 J322 J323 J324 J325
#define J382 J326 J327 J328 J329 J32A J32B J32C J32D J32E J32F
#define J383 J330 J331 J332 J333 J334 J335 J336 J337 J338 J339
#define J384 J33A J33B J33C J33D J33E J33F J340 J341 J342 J343
#define J385 J344 J345 J346 J347 J348 J349 J34A J34B J34C J34D
#define J386 J34E J34F J350 J351 J352 J353 J354 J355 J356 J357
#define J387 J358 J359 J35A J35B J35C J35D J35E J35F J360 J361
#define J388 J362 J363 J364 J365 J366 J367 J368 J369 J36A J36B
#define J389 J36C J36D J36E J36F J370 
#define J38A J371 J372 J373 J374 J375 J376 J377 J378 J379 J37A
#define J38B J37B J37C J37D J37E J37F J380 J381 J382 J383 J384
#define J38C J385 J386 J387 J388 J389 
#define J38D J38A J38B J38C 
#define J38E(__FOX__) __FOX__
J38E(J38D)

软件使用

CodeDisorder

  1. 选择 C/C++源文件进行混淆
  1. 为混淆后的代码添加的声明信息
  2. 勾选 行分模式将以 行为颗粒拆分代码，否则以 词为颗粒拆分代码
  3. 混淆后的代码是否保留注释
  4. 代码的部分混淆，0表示所有代码都混淆，50表示50行之前的代码保持原状，50行之后的代码进行混淆
  5. 设置混淆后的代码的使用期限，0表示混淆后的代码无使用期限，1440表示混淆后的代码自混淆时间起有1440分钟（24小时）的使用期限
  6. 查看每次操作的混淆代码和原始代码的存档
  7. 若不想指定源文件进行混淆，可直接粘贴代码快速混淆

软件下载

下载链接：CodeDisorder

codehelper666
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
c语言代码混淆器,工具：c 混淆器——AvIator
weixin_42521558的博客
05-19 2814
本文转载自【微信公众号：MicroPest，ID：gh_696c36c5382b】从文章的受欢迎程度来看，大多数人还是喜欢工具类的，也可以理解，谁不想短平快一点呢。这里就介绍一个工具，对shellcode混淆的工具AvIator。据文章作者说，用它混淆过后可以过很多种杀软，效果非常得好；地址：https://github.com/Ch0pin/AVIator，在这里提供了编译好的x64和x86的E...
c语言代码混淆器,代码混淆
weixin_35327824的博客
05-19 2871
代码混淆(Obfuscated code)亦称花指令，是将计算机程序的代码，转换成一种功能上等价，但是难于阅读和理解的形式的行为。代码混淆可以用于程序源代码，也可以用于程序编译而成的中间代码。执行代码混淆的程序被称作代码混淆器。目前已经存在许多种功能各异的代码混淆器。将代码中的各种元素，如变量，函数，类的名字改写成无意义的名字。比如改写成单个字母，或是简短的无意义字母组合，甚至改写成“__”这样的...
有什么好用的C/C++源代码混淆工具？
2301_79527128的博客
12-26 1084
iOS加固保护是直接针对ios ipa二进制文件的保护技术，可以对iOS APP中的可执行文件进行深度混淆、加密。使用任何工具都无法逆向、破解还原源文件。对APP进行完整性保护，防止应用程序中的代码及资源文件被恶意篡改。Ipa Guard通过修改 ipa 文件中的 macho 文件中二进制数据（代码模块配置）进行操作，无需源码。不限定开发技术平台。支持oc，swift，cocos2d-x、unity3d、quick-cocos，html5 ，react native等等各种开发技术。
【教程】一个比较良心的C++代码混淆器
憧憬个人博客
02-05 484
本文介绍了一个比较良心的C++代码混淆器，它可以用于信息竞赛训练和保护代码的安全性。我们展示了混淆器的界面截图、已知的bug，并提供了一个示例来演示混淆器的使用方法。希望这个混淆器能够帮助开发者保护他们的代码并提高代码的安全性。
如何提升代码的安全性 —— 代码混淆
ZP1015
05-25 1716
目录一、背景1.1 Android应用安全存在多重隐患二、代码混淆2.1 代码混淆的原理2.2 代码混淆的方法2.3 常见的代码混淆方式三、 C/C++ 代码混淆3.1 Obfuscator-LLVM实现C/C++混淆3.1.1 常见的混淆方法3.1.2其他常见的C/C++混淆手段：四、代码混淆可能带来的问题 一、背景 1.1 Android应用安全存在多重隐患 代码可逆向：客户端App的逻辑能够被轻易获取和逆向，得到代码和程序中的敏感数据； 功能泄漏：客户端App中高权限行为和功能被其他未授权的应
c语言、头文件代码混淆器
11-15
自治c语言代码混淆器，可选择移除c语言注释、变量名混淆、函数名混淆，#pragma行删除，#region行删除，空行删除。 可屏蔽不被混淆的关键词、导入导出关键词列表，清空关键词等功能。 可以保护在需要将源码给出时保护代码不被别人看懂。
ProGuard代码混淆器如何使用
m0_54892309的博客
07-11 2246
ProGuard 是一个免费的 Java 类文件的压缩，优化，混肴器。它删除没有用的类，字段，方法与属性。使字节码最大程度地优化，使用简短且无意义的名字来重命名类、字段和方法 。
c代码混淆
woailp___2005的专栏
01-07 1563
#include<stdio.h> #include<string.h> int my_test_fuction(int a,int b) { return a+b; } int main () { printf("%d\n",my_test_fuction(3,5)); return ( 0 ); } #include<stdio.h&...
C++ 垃圾代码生成器
12-05
垃圾代码生成器，本人在IOS 项目中生成垃圾代码使用，如有需要，大家可以下载试试
代码混淆器，专业混淆
10-24
代码混淆器，可用于代码混淆，打扰代码原有顺序
C/C++，FEISTDLIB的部分源代码
05-14
C/C++，FEISTDLIB的部分源代码
C/C++，判断索引超出了数组的界限的Sunday算法及其源代码
05-14
C/C++，判断索引超出了数组的界限的Sunday算法及其源代码
C/C++，数值计算-快速幂（Quick Pow）的几种算法源代码
最新发布
05-14
C/C++，数值计算——快速幂（Quick Pow）的几种算法源代码
关于代码混淆，看这篇就够了
m0_57042151的博客
02-13 1037
推荐使用 proguard ：开源， 使用简单 ，文档丰富完善。rename混淆名称 ：主要用于修改类名，属性名，方法名以及参数名等。shrink收缩代码 ： 主要用于从多个入口点中删除所有无法访问的类、字段和方法。keepkeep是rename和shrink的子元素，用于指定从父级rename或shrink任务中排除的元素。ProGuard 是一个开源的 Java 类文件收缩器、优化器、混淆器和预验证器。因此，ProGuard 处理的应用程序和库更小、更快，并且在一定程度上可以抵御逆向工程。
【教程】代码混淆详解
2301_79527119的博客
01-09 1131
Java是一种跨平台的解释型语言，其源代码编译成中间“字节码”存储于class文件中。由于Java字节码中包括了很多源代码信息，如变量名、方法名等，因此很容易被反编译成Java源代码。为了防止这种现象，我们可以使用Java混淆器对Java字节码进行混淆。混淆就是对发布出去的程序进行重新组织和处理，使得处理后的代码与处理前代码完成相同的功能，而混淆后的代码很难被反编译。本文详细介绍了代码混淆的概念、ProGuard混淆文件的参数设置、代码混淆的方法以及Ipa Guard工具的使用方法。
C语言易混淆问题
爵主 的博客
05-02 550
1.break和continue break continue 使用break语句是跳出当前循环，并执行当前循环之后的语句； continue语句是终止当前循环，并继续执行下一次循环； 2.switch语句case后有无break 有break 无break 跳出 继续执行下面的语句，直到遇见break eg： #include <stdio.h> main() { int a=0,i; for(i=1;i<5;i++){
c/c++代码混淆技术和方法
06-11
C/C++代码混淆技术和方法是用于保护源代码的一种技术。以下是一些常用的C/C++代码混淆技术和方法： 1. 重命名变量和函数名称：将变量和函数名称替换为无意义的字符串或者数字，使得代码难以阅读和理解。 2. 拆分函数：将一个函数拆分成多个小函数，使得代码难以理解。 3. 加密代码：使用算法对代码进行加密，使得代码难以被解密和理解。 4. 插入垃圾代码：在代码中插入无用的代码和语句，使得代码难以理解和分析。 5. 隐藏关键代码：将关键代码隐藏在大量的无用代码中，使得代码难以被发现和分析。 6. 混淆控制流：使用条件语句、循环语句等控制流语句对代码进行混淆，使得代码难以理解和分析。 7. 压缩代码：使用压缩算法对代码进行压缩，使得代码难以阅读和理解。 需要注意的是，代码混淆技术和方法虽然可以增加代码的安全性，但也会降低代码的可读性和可维护性。因此，在使用代码混淆技术和方法时需要谨慎考虑。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值