吾爱汇编论坛

 找回密码
 立即注册

QQ登录

绑定QQ避免忘记帐号

查看: 1664|回复: 88

[C/C++] 成绩信息管理系统豪华完整版,带详细注释,欢迎学习,文件读写、封装、多文件等等

  [复制链接]

  离线 

升级   23.33%

gwgirl 发表于 2022-1-2 11:18 | 显示全部楼层 |阅读模式


编程环境:windows
编程语言:vs2019
涉及工具:C语言
是否讲解思路和原理:是
以下为主题内容
61d1185f95d9e.png 61d118713d2cd.png 61d1188220aef.png
main.cpp 主文件内容
  1. #include"infoAdimSys.h"
  2. #if 0
  3. 1.C语言基础
  4. 2.C语言结构体
  5. 3.数据结构基本的结构:链式结构
  6. 4.文件操作
  7. ---------------------------------------------------------- -
  8.         死流程
  9. 1.登录界面:登录验证
  10. 2.菜单设计
  11. 3.按键交互
  12. 4.选择存储数据的方式、结构
  13.         数据结构
  14.         数组:结构数组
  15.         链式结构
  16. #endif // 0

  17. int main()
  18. {
  19.         openFile();        
  20.         while (true)
  21.         {
  22.                 menu();
  23.                 system("pause");
  24.                 system("cls");
  25.         }
  26.         return 0;
  27. }
复制代码
function.cpp
  1. #include"infoAdimSys.h"
  2. struct HDname_ HDfun;
  3. struct Node* tempList = createList();
  4. struct student tempData;//定义一个临时的Data用来存储临时的信息

  5. char* FilePath()
  6. {
  7.         char* FilePath = (char*)"D:/student.txt";
  8.         return FilePath;
  9. }

  10. void openFile()
  11. {
  12.         readInfoFormFile(FilePath(), tempList);
  13. }

  14. //输入一个int数据
  15. int keyInt(uint32_t data)
  16. {
  17.         if (!scanf_s("%d", &data))
  18.         {
  19.                 while (getchar() != '\n');//清空缓存区  防止输入错误产生死循环
  20.         }
  21.         return data;
  22. }

  23. //输入一个str数据
  24. char* keyStr(char* data)
  25. {
  26.         if (!scanf_s("%s", data, 50))
  27.         {
  28.                 while (getchar() != '\n');//清空缓存区  防止输入错误产生死循环
  29.         }
  30.         return data;
  31. }

  32. //查找学生信息
  33. void findinfo()
  34. {
  35.         while (true)
  36.         {
  37.                 system("cls");
  38.                 printf("\n");
  39.                 system("TITLE 欢迎使用XXXXXXXXXXXXXXXXXXXXXX豪华信息管理系统");//设置CMD打开标题
  40.                 printf("欢迎使用XXXXXXXXXXXXXXXXXXXXXX豪华信息管理系统\n");
  41.                 printf("\n");
  42.                 printf("\n");
  43.                 printf("┏━━━━━━━━━━━━━━━━━ %s成绩管理系统━━━━━━━━━━━━━━━━┓\n",HDfun.userItem);
  44.                 printf("┃          ★★★★★          ┃\n");
  45.                 printf("┃                         ┃\n");
  46.                 printf("┃         1.按%s查询        ┃\n",HDfun.userNumber);
  47.                 printf("┃                         ┃\n");
  48.                 printf("┃         2.按%s查询        ┃\n",HDfun.userName);
  49.                 printf("┃                         ┃\n");
  50.                 printf("┃         3.按%s查询        ┃\n",HDfun.userGrade);
  51.                 printf("┃                         ┃\n");
  52.                 printf("┃         4.按%s查询        ┃\n",HDfun.userTerm);
  53.                 printf("┃                         ┃\n");
  54.                 printf("┃         5.%s名单       ┃\n",HDfun.dataRange);
  55.                 printf("┃                         ┃\n");
  56.                 printf("┃         6.返回管理系统首页       ┃\n");
  57.                 printf("┃                         ┃\n");
  58.                 printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
  59.                 printf("请输入菜单编号(只可以输入数字1-6):\n");
  60.                 int userKey = 0;
  61.                 switch (keyInt(userKey))
  62.                 {
  63.                 case 1:
  64.                         printf("1.请输入要查询的%s:\n",HDfun.userNumber);
  65.                         findNodeInt(tempList, keyInt(tempData.number));//按学号查找
  66.                         break;
  67.                 case 2:
  68.                         printf("2.请输入要查询的%s:\n", HDfun.userName);
  69.                         findNodeStr(tempList, keyStr(tempData.name));//按学号查找
  70.                         break;
  71.                 case 3:
  72.                         printf("3.请输入要查询的%s:\n", HDfun.userGrade);
  73.                         findGradeNodeStr(tempList, keyStr(tempData.grade));//按班级查找
  74.                         break;
  75.                 case 4:
  76.                         printf("4.请输入要查询的%s:\n", HDfun.userTerm);
  77.                         findTermNodeStr(tempList, keyStr(tempData.term));//按学期查找
  78.                         break;
  79.                 case 5:
  80.                         printf("5.请输入%s:\n",HDfun.dataRange);
  81.                         findMathNodeInt(tempList, keyInt(tempData.number));
  82.                         break;
  83.                 case 6:
  84.                         printf("6.返回管理系统首页:\n");
  85.                         return;
  86.                         break;
  87.                 default:
  88.                         printf("你输入的信息有误请重新输入:\n");
  89.                         break;
  90.                 }
  91.                 system("pause");
  92.                 system("cls");
  93.         }
  94. }

  95. //目录菜单
  96. void menu()
  97. {
  98.         
  99.         //system("mode con cols=130 lines=40");//设置CMD打开窗口固定大小  设置后没有滚动条
  100.         printf("\n");
  101.         system("TITLE 欢迎使用XXXXXXXXXXXXXXXXXXXXXX豪华信息管理系统");//设置CMD打开标题
  102.         printf("欢迎使用XXXXXXXXXXXXXXXXXXXXXX豪华信息管理系统\n");
  103.         printf("\n");
  104.         printf("\n");
  105.         printf("┏━━━━━━━━━━━━━━━━━ %s成绩管理系统━━━━━━━━━━━━━━━━┓\n", HDfun.userItem);
  106.         printf("┃          ★★★★★          ┃\n");
  107.         printf("┃                         ┃\n");
  108.         printf("┃         1.查看全部信息         ┃\n");
  109.         printf("┃                         ┃\n");
  110.         printf("┃         2.查找%s信息         ┃\n", HDfun.userItem);
  111.         printf("┃                         ┃\n");
  112.         printf("┃         3.添加%s信息         ┃\n", HDfun.userItem);
  113.         printf("┃                         ┃\n");
  114.         printf("┃         4.修改%s信息         ┃\n", HDfun.userItem);
  115.         printf("┃                         ┃\n");
  116.         printf("┃         5.删除%s信息         ┃\n", HDfun.userItem);
  117.         printf("┃                         ┃\n");
  118.         printf("┃         6.退出%s系统         ┃\n", HDfun.userItem);
  119.         printf("┃                         ┃\n");
  120.         printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
  121.         printf("请输入菜单编号(只可以输入数字1-6):\n");
  122.         int userKey = 0;
  123.         switch (keyInt(userKey))
  124.         {
  125.         case 1:
  126.                 printf("查看全部信息:\n");
  127.                 loopPrintList(tempList);//  打印列表全部信息
  128.                 break;
  129.         case 2:
  130.                 printf("查找%s信息:\n",HDfun.userItem);
  131.                 findinfo();
  132.                 break;
  133.         case 3:
  134.                 printf("添加%s信息:\n", HDfun.userItem);
  135.                 addNode(tempList, tempData);
  136.                 break;
  137.         case 4:
  138.                 printf("修改%s信息:\n", HDfun.userItem);
  139.                 editNodeAppointStr(tempList, keyStr(tempData.name));
  140.                 break;
  141.         case 5:
  142.                 printf("删除%s信息:\n", HDfun.userItem);
  143.                 deleteNodeAppointInt(tempList, keyInt(tempData.number));
  144.                 break;
  145.         case 6:
  146.                 printf("退出%s系统:\n", HDfun.userItem);
  147.                 system("pause");
  148.                 exit(0);
  149.                 break;
  150.         default:
  151.                 printf("你输入的信息有误请重新输入:\n");
  152.                 break;
  153.         }
  154. }
复制代码
createList.cpp
  1. #include"infoAdimSys.h"

  2. struct HDname_ HDnameList;
  3. #pragma once
  4. //写数据结构
  5. //死写法:
  6. //1.抽象单一个体
  7. //2.描述最初状态:初始化--->初始化变量
  8. //3.插入,删除
  9. //4.打印遍历
  10. //1.1 链表就是结构体变量和结构体变量链接在了一起
  11. //1.2 指针变为变量的方式:是通过动态内存申请
  12. //1.3                无表头链表:第一个节点不存储数据
  13. //                        有表头链表:第一个节点不存储数据

  14. //定义结构体链表==方法1
  15. //typedef struct student_
  16. //{
  17. //        uint32_t number;                //学号                3140602001   31亿 int类型存不下31亿
  18. //        char name[10];                //姓名
  19. //        char grade[50];                //班级
  20. //        char term[50];                        //学期
  21. //        float        math;                                //数学
  22. //        float        chinese;                        //语文
  23. //        float        english;                        //英语
  24. //        float        computer;                //计算机
  25. //
  26. //        //next指针,指向下一个节点
  27. //        struct student_* next;
  28. //}Student, * List;                                //取别名,为了列表和节点

  29. //<1> 这个需要定义到头文件才能在main调用 定义结构体链表 == 方法2 == 定义一个结构体.定义数据格式(定义一个User)
  30. //struct student
  31. //{
  32. //        uint32_t                number;        //学号                3140602001   31亿 int类型存不下31亿
  33. //        char        name[10];                //姓名
  34. //        char        grade[50];                //班级
  35. //        char        term[50];                        //学期
  36. //        float        math;                                //数学
  37. //        float        chinese;                        //语文
  38. //        float        english;                        //英语
  39. //        float        computer;                //计算机
  40. //};


  41. //<2>定义结构体链表==方法2==定义一个结构体.定义数据格式(定义一个User)
  42. //struct Node
  43. //{
  44. //        struct student Data;
  45. //        struct Node* next;        //Node 尾指针
  46. //};

  47. //<3>定义结构体链表==方法2==定义一个结构体指针==通过动态内存申请是指针变为结构体变量
  48. //这里第一个节点就创建完成了,用一个节点表示整个链表,这是一个有表头链表
  49. struct Node* createList()
  50. {
  51.         //1.3                有表头链表:第一个节点不存储数据
  52.         //                        无表头链表:第一个节点存储数据
  53.         //1. 产生一个结构体变量==创建指针,指向一块申请的内存
  54.         struct Node* listHeadNode = (struct Node*)malloc(sizeof(struct Node)); //链表头指向动态空间
  55.         if (!listHeadNode)        //判断是否申请成功
  56.                 {
  57.                         printf("分配空间失败!");
  58.                         free(listHeadNode);
  59.                         return NULL;
  60.                 }
  61.         //2. 初始化一个变量
  62.         listHeadNode->next = NULL;
  63.         return listHeadNode;
  64. };

  65. //<4>创建新节点---第二个节点 --> (实际是数据的第一个节点 ,从这里开始有数据) 把定义的user
  66. struct Node* createNode(struct student Data)
  67. {
  68.         //1.3                有表头链表:第一个节点不存储数据
  69.         //                        无表头链表:第一个节点存储数据
  70.         //1.                产生一个结构体变量==创建指针,指向一块申请的内存
  71.         struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); //链表头指向动态空间
  72.         if (!newNode)//判断是否申请成功
  73.         {
  74.                 printf("分配空间失败!");
  75.                 free(newNode);
  76.                 return NULL;
  77.         }
  78.         //2.                初始化一个变量  让我们新节点的number = number
  79.         newNode->Data= Data;
  80.         newNode->next = NULL;
  81.         return newNode;
  82. }

  83. //<5>头插入新节点==插入节点通过头部( 插入哪个表头指向列表?,  插入的数据是多少):对应的功能就是录入信息
  84. void insertNodeByHead(struct Node* listHeadNode, student Data)
  85. {
  86.         //想不清楚就去画,看看流程
  87.         //插入
  88.         struct Node* newNode = createNode(Data);//新建一个节点指针 = 创建一个新节点

  89.         newNode->next = listHeadNode->next;  //先让新表指向 头链表指向的下一个列表
  90.         listHeadNode->next = newNode;                        //再把头链接的的下一个指针指向这个新列表,完成插入
  91. }

  92. //<6>尾插入新节点==插入节点通过尾部( 插入哪个表头指向列表?,  插入的数据是多少): 对应的功能就是录入信息
  93. void insertNodeByEnd(struct Node* listHeadNode, student Data)
  94. {
  95.         //想不清楚就去画,看看流程
  96.         //插入
  97.         struct Node* newNode = createNode(Data);
  98.         //传进来的节点指向的下一节点,指向新节点
  99.         struct Node* newNodeCurrent = listHeadNode->next;
  100.                 if (newNodeCurrent==NULL)
  101.                 {
  102.                         listHeadNode->next = newNode;  //先让新表指向 头链表指向的下一个列表
  103.                         newNode->next = NULL;                        //再把头链接的的下一个指针指向这个新列表,完成插入
  104.                 }
  105.                 else
  106.                 {
  107.                         while (newNodeCurrent->next)
  108.                         {
  109.                                 newNodeCurrent = newNodeCurrent->next;
  110.                         }
  111.                         newNodeCurrent->next = newNode;  //先让新表指向 头链表指向的下一个列表
  112.                         newNode->next = NULL;                        //再把头链接的的下一个指针指向这个新列表,完成插入
  113.                 }
  114. }

  115. //<8>删除指定字符串列表 删除节点指定 (删除哪个表头指向列表?, 指定一个正确位置-数据 )先找到再删除
  116. void deleteNodeAppointStr(struct Node* listHeadNode, char* positionData)//通过字符串查找删除,我们就按名字查找吧
  117. {
  118.         if (positionData == NULL)//我们删除之前,要先判断一下这个链表有没有这项数据
  119.         {
  120.                 printf("无相关内容,无法删除!\n");//如果没有就提示下用户;
  121.                 return; //然后直接返回
  122.         }
  123.         else {
  124.                 //删除前我们先做准备工作,定义两个链表节点指针;
  125.                 //定义一个节点指针“posintionFrontData”指向我们要操作节点的上一个节点,我们先要查找的节点是 "listHeadNode->next"
  126.                 struct Node* posintionFrontNode = listHeadNode;
  127.                 //由于我们的表头是没有数据的,需要
  128.                 struct Node* posintionNode = listHeadNode->next;//定义一个节点的指针指向找到的数据节点的下一个节点,用这个指针遍历链表
  129.                 //现在我们开始遍历链表找到我们要删除的节表
  130.                 while (strcmp("posintionData->Data.name " , "positionData"))//如果posintionData->number的值不等于要查找的<positionData>值
  131.                 {
  132.                         if (positionData == NULL)//我们不能让他一直找下去,当找到这个链表的最后一节还没有找到数据
  133.                         {
  134.                                 printf("无相关内容,无法删除!\n");//提示下用户没找到;
  135.                                 return; //然后直接返回
  136.                         }
  137.                         else
  138.                         {
  139.                                 //那就找下一个节点,让当前节点的上一节点指针指向这个节点
  140.                                 posintionFrontNode = posintionNode;//让我们定义<posintionFrontData>指针 指向现在操作的节点
  141.                                 //让当前节点的指针posintionData ,指向它的下一个节点继续查找数据
  142.                                 posintionNode = posintionFrontNode->next; //然后我们再把<posintionData>指向我们下次要操作的节点,继续while开始比对数据
  143.                         }
  144.                 }
  145.                 posintionFrontNode->next = posintionNode->next; //让这个节点的上一个节点指向下一个节点的位置指向这个节点的下一节点
  146.                 free(posintionNode);//释放掉这节点,达到删除目的
  147.         }
  148. }

  149. //<9>查找单行打印列表   要打印谁就把谁传进来 把要打印的链表表头传进来
  150. void printList(struct  Node* listHeadNode)
  151. {
  152.         system("cls");
  153.                 struct Node* pMove = listHeadNode->next;//我们的第一个链表头没有数据,所以要从第二个节表打印
  154.                 if (listHeadNode)
  155.                 {
  156.                         printf("请按照要求输入%s、%s、%s、%s、%s、%s、%s、%s:\n", HDnameList.userNumber, HDnameList.userName, HDnameList.userGrade, HDnameList.userTerm,HDnameList.userMath, HDnameList.userChinese, HDnameList.userEnglish, HDnameList.userComputer);
  157.                         printf_s("%d\t %s\t %s\t 第%s学期\t %0.2f\t %0.2f\t %0.2f\t %0.2f\t\n", pMove->Data.number, pMove->Data.name,
  158.                                 pMove->Data.grade, pMove->Data.term, pMove->Data.math, pMove->Data.chinese, pMove->Data.english, pMove->Data.computer);//打印里面的数据
  159.                         printf("\n-------------------------------华丽的换行符----------------------------------\n");
  160.                 }
  161.                 else
  162.                 {
  163.                         printf("无法找到数据\n");
  164.                 }        
  165. }

  166. //<9.1>循环打印列表   要打印谁就把谁传进来 把要打印的链表表头传进来
  167. void loopPrintList(struct  Node* listHeadNode)
  168. {
  169.         system("cls");
  170.         struct Node* pMove = listHeadNode->next;//我们的第一个链表头没有数据,所以要从第二个节表打印
  171.         printf("请按照要求输入%s、%s、%s、%s、%s、%s、%s、%s:\n", HDnameList.userNumber, HDnameList.userName, HDnameList.userGrade, HDnameList.userTerm,HDnameList.userMath, HDnameList.userChinese, HDnameList.userEnglish, HDnameList.userComputer);
  172.         while (pMove)//当前列表指针指向的链表是空的就不需要打印了
  173.         {
  174.                 printf_s("%d\t %s\t %s\t 第%s学期\t %0.2f\t %0.2f\t %0.2f\t %0.2f\t\n", pMove->Data.number, pMove->Data.name,
  175.                         pMove->Data.grade, pMove->Data.term, pMove->Data.math, pMove->Data.chinese, pMove->Data.english, pMove->Data.computer);//打印里面的数据
  176.                 pMove = pMove->next;//打印完了我们去下一个节点
  177.         }
  178.         printf("\n-------------------------------华丽的换行符----------------------------------\n");
  179. }

  180. //<9.2>打印当前   要打印谁就把谁传进来 把要打印的链表表头传进来
  181. void printNode(struct  Node* curNode)
  182. {
  183.         system("cls");
  184.         struct Node* pMove = curNode;
  185.         if (curNode)
  186.         {
  187.                 printf("请按照要求输入%s、%s、%s、%s、%s、%s、%s、%s:\n", HDnameList.userNumber, HDnameList.userName, HDnameList.userGrade, HDnameList.userTerm,HDnameList.userMath, HDnameList.userChinese, HDnameList.userEnglish, HDnameList.userComputer);
  188.                 printf_s("%d\t %s\t %s\t 第%s学期\t %0.2f\t %0.2f\t %0.2f\t %0.2f\t\n", pMove->Data.number, pMove->Data.name,
  189.                         pMove->Data.grade, pMove->Data.term, pMove->Data.math, pMove->Data.chinese, pMove->Data.english, pMove->Data.computer);//打印里面的数据
  190.                 printf("\n-------------------------------华丽的换行符----------------------------------\n");
  191.         }
  192.         else
  193.         {
  194.                 printf("无法找到数据\n");
  195.         }
  196. }

  197. //<11.0>按编号查找    (要查找的链表   要查找的数据)
  198. struct Node* searchNodeByAppoinNum(struct Node* ListHeadNode, uint32_t num)
  199. {
  200.         struct Node* pMove = ListHeadNode->next;
  201.         if (pMove == NULL)
  202.         {
  203.                 return pMove;
  204.         }
  205.         else
  206.         {
  207.                 while (pMove->Data.number != num)
  208.                 {
  209.                         pMove = pMove->next;
  210.                         if (pMove == NULL)
  211.                         {
  212.                                 break;
  213.                         }
  214.                 }
  215.                 return pMove;
  216.         }
  217. }

  218. //<11.1>按姓名查找    (要查找的链表   要查找的数据)
  219. struct Node* searchNodeByAppoinNane(struct Node* ListHeadNode, char* name)
  220. {
  221.         struct Node* pMove = ListHeadNode->next;
  222.         if (pMove == NULL)
  223.         {
  224.                 return pMove;
  225.         }
  226.         else
  227.         {
  228.                 while (strcmp(pMove->Data.name , name))
  229.                 {
  230.                         pMove = pMove->next;
  231.                         if (pMove == NULL)
  232.                         {
  233.                                 break;
  234.                         }
  235.                 }
  236.                 return pMove;
  237.         }
  238. }

  239. //<11.1>按班级查找    (要查找的链表   要查找的数据)
  240. struct Node* searchNodeByAppoinGrade(struct Node* ListHeadNode, char* name)
  241. {
  242.         struct Node* pMove = ListHeadNode->next;
  243.         if (pMove == NULL)
  244.         {
  245.                 return pMove;
  246.         }
  247.         else
  248.         {
  249.                 while (strcmp(pMove->Data.grade, name))
  250.                 {
  251.                         pMove = pMove->next;
  252.                         if (pMove == NULL)
  253.                         {
  254.                                 break;
  255.                         }
  256.                 }
  257.                 return pMove;
  258.         }
  259. }

  260. //<11.3>按期数查找    (要查找的链表   要查找的数据)
  261. struct Node* searchNodeByAppoinTerm(struct Node* ListHeadNode, char* name)
  262. {
  263.         struct Node* pMove = ListHeadNode->next;
  264.         if (pMove == NULL)
  265.         {
  266.                 return pMove;
  267.         }
  268.         else
  269.         {
  270.                 while (strcmp(pMove->Data.term, name))
  271.                 {
  272.                         pMove = pMove->next;
  273.                         if (pMove == NULL)
  274.                         {
  275.                                 break;
  276.                         }
  277.                 }
  278.                 return pMove;
  279.         }
  280. }
复制代码
operationData.cpp
  1. #include"infoAdimSys.h"

  2. struct HDname_ HDname;

  3. //<10>添加成员信息
  4. void addNode(struct Node* listHeadNode, struct student tempData)
  5. {
  6.         printf("请按照要求输入%s、%s、%s、%s、%s、%s、%s、%s:\n", HDname.userNumber, HDname.userName, HDname.userGrade, HDname.userTerm,
  7.                                                                                                                                                                                                                 HDname.userMath, HDname.userChinese, HDname.userEnglish, HDname.userComputer);
  8.         printf("请按格式输入%s:20210900001\n",HDname.userNumber);
  9.         scanf_s("%u", &tempData.number);
  10.         printf("请按格式输入%s:中文不超过5个汉字!\n",HDname.userName);
  11.         scanf_s("%s", tempData.name, 10);
  12.         printf("请按格式输入%s:例:TCT201309 \n",HDname.userGrade);
  13.         scanf_s("%s", tempData.grade, 50);
  14.         printf("请按格式输入第几%s:例:一 \n",HDname.userTerm);
  15.         scanf_s("%s", tempData.term, 50);
  16.         printf("请按格式输入%s:100或90.5  \n",HDname.userMath);
  17.         scanf_s("%f", &tempData.math);
  18.         printf("请按格式输入%s:100或90.5  \n",HDname.userChinese);
  19.         scanf_s("%f", &tempData.chinese);
  20.         printf("请按格式输入%s:100或90.5  \n",HDname.userEnglish);
  21.         scanf_s("%f", &tempData.english);
  22.         printf("请按格式输入%s:100或90.5  \n",HDname.userComputer);
  23.         scanf_s("%f", &tempData.computer);
  24.         insertNodeByEnd(listHeadNode, tempData);
  25.         printf("\n------------------------------添加完成----------------------------------\n");
  26.         loopPrintList(listHeadNode);
  27.         saveInfoFormFile(FilePath(), listHeadNode);
  28. }

  29. //<10>修改指定字符串列表 修改节点指定 (修改哪个表头指向列表?, 指定一个正确位置-数据 )先找到再修改
  30. void editNodeAppointStr(struct Node* listHeadNode, char* EditData)//通过字符串查找删除,我们就按名字查找吧
  31. {
  32.         struct Node* curNode = searchNodeByAppoinNane(listHeadNode, EditData);
  33.         printf("请按照要求输入%s、%s、%s、%s、%s、%s、%s、%s:\n", HDname.userNumber, HDname.userName, HDname.userGrade, HDname.userTerm,
  34.                 HDname.userMath, HDname.userChinese, HDname.userEnglish, HDname.userComputer);
  35.         printf("请按格式输入%s:20210900001\n", HDname.userNumber);
  36.         scanf_s("%u", &curNode->Data.number);
  37.         printf("请按格式输入%s:中文不超过5个汉字!\n", HDname.userName);
  38.         scanf_s("%s", curNode->Data.name, 10);
  39.         printf("请按格式输入%s:例:TCT201309 \n", HDname.userGrade);
  40.         scanf_s("%s", curNode->Data.grade, 50);
  41.         printf("请按格式输入第几%s:例:一 \n", HDname.userTerm);
  42.         scanf_s("%s", curNode->Data.term, 50);
  43.         printf("请按格式输入%s:100或90.5  \n", HDname.userMath);
  44.         scanf_s("%f", &curNode->Data.math);
  45.         printf("请按格式输入%s:100或90.5  \n", HDname.userChinese);
  46.         scanf_s("%f", &curNode->Data.chinese);
  47.         printf("请按格式输入%s:100或90.5  \n", HDname.userEnglish);
  48.         scanf_s("%f", &curNode->Data.english);
  49.         printf("请按格式输入%s:100或90.5  \n", HDname.userComputer);
  50.         scanf_s("%f", &curNode->Data.computer);
  51.         printf("\n------------------------------添加完成----------------------------------\n");
  52.         loopPrintList(listHeadNode);
  53.         saveInfoFormFile(FilePath(), listHeadNode);
  54. }

  55. //<7>删除指定Int列表 删除节点指定 (删除哪个表头指向列表?, 指定一个正确位置-数据 )先找到再删除
  56. void deleteNodeAppointInt(struct Node* listHeadNode, int positionData)//通过整数查找删除
  57. {
  58.         if (positionData == NULL)//我们删除之前,要先判断一下这个链表有没有这项数据
  59.         {
  60.                 printf("无相关内容,无法删除!\n");//如果没有就提示下用户;
  61.                 return; //然后直接返回
  62.         }
  63.         else {
  64.                 //删除前我们先做准备工作,定义两个链表节点指针;
  65.                 //定义一个节点指针“posintionFrontData”指向我们要操作节点的上一个节点,我们先要查找的节点是 "listHeadNode->next"
  66.                 struct Node* posintionFrontData = listHeadNode;
  67.                 //由于我们的表头是没有数据的,需要
  68.                 struct Node* posintionData = listHeadNode->next;//定义一个节点的指针指向找到的数据节点的下一个节点,用这个指针遍历链表
  69.                 //现在我们开始遍历链表找到我们要删除的节表
  70.                 while (posintionData->Data.number != positionData)//如果posintionData->number的值不等于要查找的<positionData>值
  71.                 {
  72.                         if (positionData == NULL)//我们不能让他一直找下去,当找到这个链表的最后一节还没有找到数据
  73.                         {
  74.                                 printf("无相关内容,无法删除!\n");//提示下用户没找到;
  75.                                 return; //然后直接返回
  76.                         }
  77.                         else
  78.                         {
  79.                                 //那就找下一个节点,让当前节点的上一节点指针指向这个节点
  80.                                 posintionFrontData = posintionData;//让我们定义<posintionFrontData>指针 指向现在操作的节点
  81.                                 //让当前节点的指针posintionData ,指向它的下一个节点继续查找数据
  82.                                 posintionData = posintionFrontData->next; //然后我们再把<posintionData>指向我们下次要操作的节点,继续while开始比对数据
  83.                         }
  84.                 }
  85.                 posintionFrontData->next = posintionData->next; //让这个节点的上一个节点指向下一个节点的位置指向这个节点的下一节点
  86.                 free(posintionData);//释放掉这节点,达到删除目的
  87.         }
  88.         saveInfoFormFile(FilePath(), listHeadNode);
  89. }


  90. //<11.1>按编号查找成员信息
  91. void findNodeInt(struct Node* listHeadNode, uint32_t findData)
  92. {
  93.         printNode(searchNodeByAppoinNum(listHeadNode, findData));
  94. }

  95. //<11.2>按名称查找成员信息
  96. void findNodeStr(struct Node* listHeadNode, char* findData)
  97. {
  98.         printNode(searchNodeByAppoinNane(listHeadNode, findData));
  99. }

  100. //<11.3>按分级查找成员信息
  101. void findGradeNodeStr(struct Node* listHeadNode, char* findData)
  102. {
  103.         struct Node* findNode = searchNodeByAppoinGrade(listHeadNode, findData);
  104.         if (findNode)
  105.         {
  106.                 int cnt = 0; double gradesum = 0, gradeMean = 0;
  107.                 while (findNode)
  108.                 {
  109.                         if (strcmp(findNode->Data.grade, findData) == 0)
  110.                         {
  111.                                 double sum = 0, mean = 0;
  112.                                 printNode( findNode);

  113.                                 cnt++;//统计打印过多少次,作为找的多少个匹配的人数

  114.                                 sum = findNode->Data.math + findNode->Data.chinese + findNode->Data.english + findNode->Data.computer;//数学总成绩
  115.                                 mean = sum / 4.0; //语文总成绩
  116.                                 gradesum += sum;
  117.                                 gradeMean = gradesum / cnt,
  118.                                         printf(" \n该%s的总成绩是%0.2f, 平均成绩为%0.2f!\n\n", HDname.userItem,sum, mean);
  119.                                 findNode = findNode->next;
  120.                         }
  121.                         else
  122.                         {
  123.                                 findNode = findNode->next;
  124.                         }
  125.                 }
  126.                 printf("第%s%s的平均总分成绩为%0.2f!\n", findData, HDname.userGrade, gradeMean);
  127.                 printf("本次共为您找到了%d位第%s%s的%s!\n", cnt, HDname.userGrade, findData, HDname.userItem);
  128.         }
  129.         else
  130.         {
  131.                 printf("未找到第%s%s的%s\n\n\n", findData, HDname.userGrade, HDname.userItem);
  132.         }
  133. }


  134. //<11.3>按期数查找成员信息
  135. void findTermNodeStr(struct Node* listHeadNode, char* findData)
  136. {
  137.         struct Node* findNode = searchNodeByAppoinTerm(listHeadNode, findData);
  138.         if (findNode)
  139.         {
  140.                 int cnt = 0; double gradesum = 0, gradeMean = 0;
  141.                 while (findNode)
  142.                 {
  143.                         if (strcmp(findNode->Data.term, findData) == 0)
  144.                         {
  145.                                 double sum = 0, mean = 0;
  146.                                 printNode(findNode);

  147.                                 cnt++;//统计打印过多少次,作为找的多少个匹配的人数

  148.                                 sum = findNode->Data.math + findNode->Data.chinese + findNode->Data.english + findNode->Data.computer;//数学总成绩
  149.                                 mean = sum / 4.0; //语文总成绩
  150.                                 gradesum += sum;
  151.                                 gradeMean = gradesum / cnt,
  152.                                         printf("\n该%s的总成绩是%0.2f, 平均成绩为%0.2f!\n\n", HDname.userItem,sum, mean);
  153.                                 findNode = findNode->next;
  154.                         }
  155.                         else
  156.                         {
  157.                                 findNode = findNode->next;
  158.                         }
  159.                 }
  160.                 printf("第%s第%s期的平均总分成绩为%0.2f!\n", findData, HDname.userTerm, gradeMean);
  161.                 printf("本次共为您找到了%d位第%s%s的%s!\n", cnt, HDname.userTerm, findData, HDname.userItem);
  162.         }
  163.         else
  164.         {
  165.                 printf("未找到第%s%s的%s\n\n\n", findData, HDname.userTerm, HDname.userItem);
  166.         }
  167. }

  168. //<11.4>按不及格数据查找成员信息
  169. void findMathNodeInt(struct Node* listHeadNode, int findData)
  170. {
  171.         if (listHeadNode->next == NULL)//我们删除之前,要先判断一下这个链表有没有这项数据
  172.         {
  173.                 printf("无数据,无法查找!\n");//如果没有就提示下用户;
  174.                 return; //然后直接返回
  175.         }
  176.         else {
  177.                 struct Node* findForntNode = listHeadNode;//这里如果我们需要返回列表到循环打印,需要返回要打印的前一节链表
  178.                 struct Node* findNode = listHeadNode->next;
  179.                 if (findData == NULL)
  180.                 {
  181.                         printf("请正确输入数据,请重新输入要查找%s!", HDname.userMath);
  182.                 }
  183.                 else
  184.                 {
  185.                         int cnt = 0;
  186.                         while (findNode)
  187.                         {
  188.                                 if (findNode->Data.math <= findData || findNode->Data.chinese <= findData || findNode->Data.english <= findData || findNode->Data.computer <= findData)//其中一项不合格就符合打印条件
  189.                                 {
  190.                                         if (findNode->Data.math <= findData && findNode->Data.chinese <= findData && findNode->Data.english <= findData && findNode->Data.computer <= findData)//数学 语文 英语 计算机
  191.                                         {
  192.                                                 printf("姓名:%s\t  班级:%s\t  数学:%0.2f\t  语文:%0.2f\t  英语:%0.2f\t  计算机:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.math, findNode->Data.chinese, findNode->Data.english, findNode->Data.computer);
  193.                                         }
  194.                                         else if (findNode->Data.math <= findData && findNode->Data.chinese <= findData && findNode->Data.english <= findData)//数学 语文 英语
  195.                                         {
  196.                                                 printf("姓名:%s\t  班级:%s\t  数学:%0.2f\t  语文:%0.2f\t  英语:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.math, findNode->Data.chinese, findNode->Data.english);
  197.                                         }
  198.                                         else if (findNode->Data.math <= findData && findNode->Data.chinese <= findData && findNode->Data.computer <= findData)//数学 语文 计算机
  199.                                         {
  200.                                                 printf("姓名:%s\t  班级:%s\t  数学:%0.2f\t  语文:%0.2f\t  计算机:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.math, findNode->Data.chinese, findNode->Data.computer);
  201.                                         }
  202.                                         else if (findNode->Data.math <= findData && findNode->Data.english <= findData && findNode->Data.computer <= findData)//数学 英语 计算机
  203.                                         {
  204.                                                 printf("姓名:%s\t  班级:%s\t  数学:%0.2f\t  英语:%0.2f\t  计算机:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.math, findNode->Data.english, findNode->Data.computer);
  205.                                         }
  206.                                         else if (findNode->Data.chinese <= findData && findNode->Data.english <= findData && findNode->Data.computer <= findData)//语文 英语 计算机
  207.                                         {
  208.                                                 printf("姓名:%s\t  班级:%s\t  语文:%0.2f\t  英语:%0.2f\t  计算机:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.chinese, findNode->Data.english, findNode->Data.computer);
  209.                                         }
  210.                                         else if (findNode->Data.math <= findData && findNode->Data.chinese <= findData)//数学 语文
  211.                                         {
  212.                                                 printf("姓名:%s\t  班级:%s\t  数学:%0.2f\t  语文:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.math, findNode->Data.chinese);
  213.                                         }
  214.                                         else if (findNode->Data.math <= findData && findNode->Data.english <= findData)//数学 英语
  215.                                         {
  216.                                                 printf("姓名:%s\t  班级:%s\t  数学:%0.2f\t  英语:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.math, findNode->Data.english);
  217.                                         }
  218.                                         else if (findNode->Data.math <= findData && findNode->Data.computer <= findData)//数学 计算机
  219.                                         {
  220.                                                 printf("姓名:%s\t  班级:%s\t  数学:%0.2f\t  计算机:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.math, findNode->Data.computer);
  221.                                         }
  222.                                         else if (findNode->Data.chinese <= findData && findNode->Data.english <= findData)//语文 英语
  223.                                         {
  224.                                                 printf("姓名:%s\t  班级:%s\t  语文:%0.2f\t  英语:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.chinese, findNode->Data.english);
  225.                                         }
  226.                                         else if (findNode->Data.chinese <= findData && findNode->Data.computer <= findData)//语文 计算机
  227.                                         {
  228.                                                 printf("姓名:%s\t  班级:%s\t  语文:%0.2f\t  计算机:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.chinese, findNode->Data.computer);
  229.                                         }
  230.                                         else if (findNode->Data.english <= findData && findNode->Data.computer <= findData)//英语 计算机
  231.                                         {
  232.                                                 printf("姓名:%s\t  班级:%s\t  英语:%0.2f\t  计算机:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.english, findNode->Data.computer);
  233.                                         }
  234.                                         else if (findNode->Data.math <= findData)//数学
  235.                                         {
  236.                                                 printf("姓名:%s\t  班级:%s\t  语文:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.math);
  237.                                         }
  238.                                         else if (findNode->Data.chinese <= findData)//语文
  239.                                         {
  240.                                                 printf("姓名:%s\t  班级:%s\t  语文:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.chinese);
  241.                                         }
  242.                                         else if (findNode->Data.english <= findData)//英语
  243.                                         {
  244.                                                 printf("姓名:%s\t  班级:%s\t  语文:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.english);
  245.                                         }
  246.                                         else if (findNode->Data.computer <= findData)//计算机
  247.                                         {
  248.                                                 printf("姓名:%s\t  班级:%s\t  语文:%0.2f\n\n", findNode->Data.name, findNode->Data.grade, findNode->Data.computer);
  249.                                         }
  250.                                         cnt++; //记录打印次数
  251.                                 }
  252.                                 if (findNode->next == NULL)
  253.                                 {
  254.                                         printf("查询结束,请重新输入要查找%s!\n", HDname.userMath);
  255.                                         break;
  256.                                 }
  257.                                 findNode = findNode->next;
  258.                         }
  259.                         printf("共有%d位科目不及格的%s!\n", cnt, HDname.userItem);
  260.                 }
  261.         }
  262. }
复制代码
游客,如果您要查看本帖隐藏内容请回复



评分

参与人数 25威望 +1 HB +39 THX +13 收起 理由
agan8888 + 1
皮娜十 + 1 [吾爱汇编论坛52HB.COM]-感谢楼主热心分享,小小评分不成敬意!
a8035451 + 1
勇敢的安丽娜丝 + 1 [吾爱汇编论坛52HB.COM]-吃水不忘打井人,给个评分懂感恩!
zi_wu_shu + 1
可爱的狗狗 + 1 [吾爱汇编论坛52HB.COM]-吃水不忘打井人,给个评分懂感恩!
yhfyhf + 1
pmm018 + 1
用户名小秒 + 1
hackysh + 1
chenyuanpojie + 1
Hackers + 2 + 1 [吾爱汇编论坛52HB.COM]-感谢楼主热心分享,小小评分不成敬意!
土豆家的土豆 + 1 + 1 [吾爱汇编论坛52HB.COM]-软件反汇编逆向分析,软件安全必不可少!
xx001 + 1
longge188 + 1 [吾爱汇编论坛52HB.COM]-软件反汇编逆向分析,软件安全必不可少!
allenzjb + 1 + 1
小声点我布隆 + 1 [吾爱汇编论坛52HB.COM]-感谢楼主热心分享,小小评分不成敬意!
wbxs2077 + 2 + 1 [吾爱汇编论坛52HB.COM]-感谢楼主热心分享,小小评分不成敬意!
brswbx201610 + 1
king51999 + 1 [吾爱汇编论坛52HB.COM]-吃水不忘打井人,给个评分懂感恩!
52bug + 6 + 1 [吾爱汇编论坛52HB.COM]-吃水不忘打井人,给个评分懂感恩!
保安 + 2 [吾爱汇编论坛52HB.COM]-学破解防破解,知进攻懂防守!
快乐の神 + 2 + 1 [吾爱汇编论坛52HB.COM]-感谢楼主热心分享,小小评分不成敬意!
boot + 2 + 1 [吾爱汇编论坛52HB.COM]-感谢楼主热心分享,小小评分不成敬意!
Shark恒 + 1 + 10 + 1 [吾爱汇编论坛52HB.COM]-吃水不忘打井人,给个评分懂感恩!

查看全部评分

吾爱汇编论坛-学破解,防破解!知进攻,懂防守!逆向分析,软件安全!52HB.COM

  离线 

Shark恒 发表于 2022-1-2 11:35 | 显示全部楼层
吾爱汇编论坛-学破解,防破解!知进攻,懂防守!逆向分析,软件安全!52HB.COM

  离线 

升级   9%

阿桂哥 发表于 2022-1-2 11:38 | 显示全部楼层


豪华版,人见人爱
吾爱汇编论坛-学破解,防破解!知进攻,懂防守!逆向分析,软件安全!52HB.COM

  离线 

升级   15%

woaini 发表于 2022-1-2 11:55 | 显示全部楼层
吾爱汇编论坛-学破解,防破解!知进攻,懂防守!逆向分析,软件安全!52HB.COM

  离线 

升级   8%

保安 发表于 2022-1-2 13:35 | 显示全部楼层


支持一波 等学会C++再来拿代码
吾爱汇编论坛-学破解,防破解!知进攻,懂防守!逆向分析,软件安全!52HB.COM

  离线 

升级   0%

Elizer 发表于 2022-1-2 15:48 | 显示全部楼层
吾爱汇编论坛-学破解,防破解!知进攻,懂防守!逆向分析,软件安全!52HB.COM

  在线 

升级   12%

snak2020 发表于 2022-1-2 16:55 | 显示全部楼层


感谢分享,收藏
吾爱汇编论坛-学破解,防破解!知进攻,懂防守!逆向分析,软件安全!52HB.COM

  离线 

升级   5%

liouyuwei 发表于 2022-1-2 21:56 | 显示全部楼层


学习一下
吾爱汇编论坛-学破解,防破解!知进攻,懂防守!逆向分析,软件安全!52HB.COM

  离线 

升级   20%

神秘 发表于 2022-1-3 01:36 | 显示全部楼层


多谢分享
吾爱汇编论坛-学破解,防破解!知进攻,懂防守!逆向分析,软件安全!52HB.COM

  离线 

升级   40%

wbxs2077 发表于 2022-1-3 20:03 | 显示全部楼层


这也太细致详细了 ,LZNB
吾爱汇编论坛-学破解,防破解!知进攻,懂防守!逆向分析,软件安全!52HB.COM
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则 警告:本站严惩灌水回复,尊重自己从尊重他人开始!

1层
2层
3层
4层
5层
6层
7层
8层
9层
10层

免责声明

吾爱汇编论坛(www.52hb.com)所发布的破解补丁、注册机、逆向教程、逆向文章等,包含但不限于上述内容,仅限用于学习和研究目的,不得用于非法途径或商业行为。否则,一切后果请用户自行承担。本站内容源于网络,版权争议与本站无关。您必须在下载后的24个小时之内,从您的电脑中彻底删除。如果您喜欢某程序,请购买正版,支持正版,获得正版优质服务。如有侵权请邮件或微信与我们联系处理。

站长邮箱:SharkHeng@iCloud.com
站长微信:SharkHeng


QQ|RSS|手机版|小黑屋|帮助|吾爱汇编论坛 ( 京公网安备11011502005403号 , 京ICP备20003498号 )

GMT+8, 2022-5-28 08:30 , Processed in 0.679804 second(s), 77 queries .

Powered by Discuz!

吾爱汇编论坛 www.52hb.com

快速回复 返回顶部 返回列表