[已解决]这个，我刚刚写的代码。功能都正常，但是文件里有东西就奔溃

御坂19090

这个是奔溃的样子

文件是这样的
清空就可以打开，
功能都可以正常运行 但是，文件里面有东西的话，一运行就不行

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #include <stdlib.h>
   
4. 
   
5. #define MAX 1024
   
6. 
   
7. struct Book *book_pool = NULL;//内存池
   
8. int count_book = 0;
   
9. struct User *user_pool = NULL;
   
10. int count_user = 0;
    
11. 
    
12. struct Date{
    
13.         int year;
    
14.         int month;
    
15.         int day;
    
16. };
    
17. 
    
18. struct Book{
    
19.         char name[40];//书名
    
20.         char author[128];//作者
    
21.         char publisher[40];//出版社
    
22.         int exist;
    
23.         struct Date date;//日期
    
24.         struct Book *next;
    
25. };
    
26. 
    
27. struct User{
    
28.         char name[40];//用户名
    
29.         char cypher[32];//密码
    
30.         struct Date date;//注册日期
    
31.         struct User *next;
    
32. };
    
33. 
    
34. void welcome(struct Book **book, struct User **user);//打印欢迎和使用说明
    
35. void consumer(void);//打印用户使用说明
    
36. void manage(void);//打印管理员使用说明
    
37. int log_on(struct User *head);//登录
    
38. int administrator(void);//登录管理员
    
39. //用户相关的函数
    
40. struct User *seek_user(struct User *head);//寻找用户，返回地址
    
41. void print_user_one(struct User *head);//根据地址打印用户的信息
    
42. void increase(struct User **head);//增加用户
    
43. void reduce(struct User **head);//减少用户
    
44. void query(struct User *book);//查询用户信息
    
45. void modify(struct User *head);//修改用户信息
    
46. void display(struct User *head);//显示所有用户信息
    
47. //图书相关的函数
    
48. struct Book *seek_book(struct Book *head);//寻找图书，返回地址
    
49. void print_book_one(struct Book *head);//根据地址打印图书的信息
    
50. void insert(struct Book **head);//录入新的图书
    
51. void searchEvent(struct Book *book);//查找已有的图书
    
52. void change(struct Book **head);//更改已有的图书
    
53. void delete(struct Book **head);//删除已有的图书
    
54. void print(struct Book *head);//打印所有的图书信息
    
55. void enter(struct Book *book, struct User *user);//结束程序时将信息放入文件
    
56. void borrow(void){//借书/
    
57. }
    
58. 
    
59. void still(void){//还书/
    
60. }
    
61. 
    
62. void welcome(struct Book **head_book, struct User **head_user){//打印欢迎和使用说明
    
63.         FILE *fp1, *fp2;
    
64.         struct Book *temp_book = NULL, *book = *head_book;
    
65.         struct User *temp_user = NULL, *user = *head_user;
    
66.         int i;
    
67. 
    
68.         printf("| 欢迎使用图书馆程序 |\n");
    
69.         printf("|----- 1:注册 -----|\n");
    
70.         printf("|----- 2:登录 -----|\n");
    
71.         printf("|----- 3:退出 -----|\n");
    
72.         printf("|--------------------|\n");
    
73. 
    
74.         if ((fp1 = fopen("book.txt", "r")) == NULL){//fopen获取文件指针
    
75.                 printf("打开文件失败！\n");
    
76.                 exit(EXIT_FAILURE);
    
77.         }
    
78.         if ((fp2 = fopen("user.txt", "r")) == NULL){//fopen获取文件指针
    
79.                 printf("打开文件失败！\n");
    
80.                 exit(EXIT_FAILURE);
    
81.         }
    
82.         printf("aaa");
    
83.         i = 0;
    
84.         while (1){
    
85.                 fread(temp_book, sizeof(struct Book), 1, fp1);// 将文件数据读取出来
    
86.                 if (feof(fp1)){
    
87.                         if (!i){
    
88.                                 break;
    
89.                         }
    
90.                         else{
    
91.                                 user = temp_user;
    
92.                                 user = user->next;
    
93.                                 i++;
    
94.                                 break;
    
95.                         }
    
96.                 }
    
97.                 book = temp_book;
    
98.                 book = book->next;
    
99.                 i++;
    
100.         }
     
101.         i = 0;
     
102.         while (1){
     
103.                 fread(temp_user, sizeof(struct User), 1, fp2);// 将文件数据读取出来
     
104.                 if (feof(fp2)){
     
105.                         if (!i){
     
106.                                 break;
     
107.                         }
     
108.                         else{
     
109.                                 user = temp_user;
     
110.                                 user = user->next;
     
111.                                 i++;
     
112.                                 break;
     
113.                         }
     
114.                 }
     
115.                 user = temp_user;
     
116.                 user = user->next;
     
117.                 i++;
     
118.         }
     
119. 
     
120.         fclose(fp1);//关闭文件!!!!
     
121.         fclose(fp2);
     
122. }
     
123. 
     
124. void consumer(void){//打印用户使用说明
     
125.         printf("| 欢迎使用图书馆参观程序 |\n");
     
126.         printf("|--- 1:查找已有图书 -----|\n");
     
127.         printf("|--- 2:显示当前图书库 ---|\n");
     
128.         printf("|--- 3:进入管理员模式 ---|\n");
     
129.         printf("|--- 4:退出图书馆程序 ---|\n");
     
130.         printf("|----------------------|\n");
     
131. }
     
132. 
     
133. void manage(void){//打印管理员使用说明
     
134.         printf("| 欢迎使用图书馆管理程序 |\n");
     
135.         printf("|--- 1:插入新的图书 -----|\n");
     
136.         printf("|--- 2:更改已有图书 -----|\n");
     
137.         printf("|--- 3:删除已有图书 -----|\n");
     
138.         printf("|--- 4:显示当前图书库 ---|\n");
     
139.         printf("|--- 5:更改用户信息 -----|\n");
     
140.         printf("|--- 6:查询用户信息 -----|\n");
     
141.         printf("|--- 7:删除用户信息 -----|\n");
     
142.         printf("|--- 8:显示用户名单 -----|\n");
     
143.         printf("|--- 9:退出图书馆程序 ---|\n");
     
144.         printf("|----------------------|\n");
     
145. }
     
146. 
     
147. int log_on(struct User *head){//登录/
     
148.         struct User *user;
     
149.         char mm[32];
     
150.         user = seek_user(head);
     
151.         printf("请输入密码：");
     
152.         scanf("%s", mm);
     
153.         if (!strcmp(user->cypher, mm)){
     
154.                 printf("登录成功");
     
155.                 return 1;
     
156.         }
     
157.         printf("登录失败");
     
158.         return 0;
     
159. }
     
160. 
     
161. int administrator(void){
     
162.         char mm[32];
     
163. 
     
164.         printf("请输入管理员密码：");
     
165.         scanf("%s", mm);
     
166.         if (!strcmp("123456", mm)){
     
167.                 printf("登录成功");
     
168.                 return 1;
     
169.         }
     
170.         printf("登录失败");
     
171.         return 0;
     
172. }
     
173. 
     
174. struct User *seek_user(struct User *head){//寻找用户，返回地址
     
175.         struct User *target;
     
176.         char name[40];
     
177. 
     
178.         printf("请输入用户：");
     
179.         scanf("%s", name);
     
180. 
     
181.         target = head;
     
182.         while (target != NULL && strcmp(target->name, name)){
     
183.                 target = target->next;
     
184.         }
     
185. 
     
186.         return target;
     
187. }
     
188. 
     
189. void print_user_one(struct User *head){//根据地址打印用户的信息
     
190.         printf("密码：%s\n", head->cypher);
     
191.         printf("注册日期(aa-bb-cc)：%d-%d-%d\n", head->date.year, head->date.month, head->date.day);
     
192. }
     
193. 
     
194. void increase(struct User **head){//增加用户/
     
195.         struct User *user;
     
196.         struct User *temp;
     
197. 
     
198.         if (user_pool != NULL){//如果内存池非空，直接从里面获取空间
     
199.                 user = user_pool;
     
200.                 user_pool = user_pool->next;
     
201.                 count_user--;
     
202.         }
     
203.         else{//如果内存池空，使用malloc申请内存
     
204.                 user = (struct User *)malloc(sizeof(struct User));
     
205.                 if(user == NULL){
     
206.                         printf("内存分配失败了。\n");
     
207.                         exit(1);
     
208.                 }
     
209.         }
     
210.         printf("请输入用户名：");
     
211.         scanf("%s", user->name);
     
212.         printf("请设置密码：");
     
213.         scanf("%s", user->cypher);
     
214.         printf("请输入注册日期(aa-bb-cc)");
     
215.         scanf("%d-%d-%d", &user->date.year, &user->date.month, &user->date.day);
     
216. 
     
217.         if (*head != NULL){
     
218.                 temp = *head;
     
219.                 *head = user;
     
220.                 user->next = temp;
     
221.         }
     
222.         else{
     
223.                 *head = user;
     
224.                 user->next = NULL;
     
225.         }
     
226. }
     
227. 
     
228. void reduce(struct User **head){//减少用户/
     
229.         struct User *target;//目标
     
230.         struct User *now;
     
231.         struct User *temp;//上一次
     
232. 
     
233.         target = seek_user(*head);// 先找到待删除的节点指针
     
234. 
     
235.         if (target == NULL){
     
236.                 printf("找不到该用户！\n");
     
237.         }
     
238.         else{
     
239.                 now = *head;
     
240.                 temp = NULL;
     
241. 
     
242.                 while (now != NULL && now != target){// current定位到待删除的节>点
     
243.                         temp = now;
     
244.                         now = now->next;
     
245.                 }
     
246.                 if (temp == NULL){// 待删除的节点是第一个节点
     
247.                         *head = now->next;
     
248.                 }
     
249.                 else{// 待删除的节点不是第一个节点
     
250.                         temp->next = now->next;
     
251.                 }
     
252. 
     
253.                 if (count_user < MAX){//判断内存池有没有空位
     
254.                         if (user_pool != NULL){
     
255.                                 temp = user_pool;
     
256.                                 user_pool = target;
     
257.                                 target->next = NULL;
     
258.                         }                        
     
259.                         else{
     
260.                                 user_pool = target;
     
261.                                 target->next = NULL;
     
262.                         }
     
263.                         count_user++;
     
264.                 }
     
265.                 else{
     
266.                         free(target);
     
267.                 }
     
268.         }
     
269. }
     
270. 
     
271. 
     
272. void query(struct User *head){//查询用户信息/
     
273.         struct User *user;
     
274.         char name[32];
     
275. 
     
276.         printf("请输入用户名：");
     
277.         scanf("%s", name);
     
278. 
     
279.         user = head;
     
280. 
     
281.         while (user != NULL){
     
282.                 if (!strcmp(user->name, name)){
     
283.                         break;
     
284.                 }
     
285.                 user = user->next;
     
286.         }
     
287.         if(user == NULL){
     
288.                 printf("抱歉，没有找到。\n");
     
289.         }
     
290.         else{
     
291.                 print_user_one(user);
     
292.         }
     
293. }
     
294. 
     
295. void modify(struct User *head){//修改用户信息/
     
296.         struct User *target;
     
297. 
     
298.         char name[32];
     
299. 
     
300.         target = seek_user(head);// 先找到待更改的节点指针
     
301. 
     
302.         if (target == NULL){
     
303.                 printf("找不到该书名！\n");
     
304.         }
     
305.         else{
     
306.                 printf("请设置用户名：");
     
307.                 scanf("%s", target->name);
     
308.               printf("请设置密码：");
     
309.                 scanf("%s", target->cypher);
     
310.                 printf("请设置注册日期(aa-bb-cc)");
     
311.                 scanf("%d-%d-%d", &target->date.year, &target->date.month, &target->date.day);
     
312.         }
     
313. }
     
314. 
     
315. void display(struct User *head){//显示所有用户信息/
     
316.         struct User *now;
     
317. 
     
318.         now = head;
     
319.         while (now != NULL){
     
320.                 printf("用户名：%s\n", now->name);
     
321.                 print_user_one(now);
     
322.                 now = now->next;
     
323.         }
     
324. }
     
325. //--------------------------图书------------------------------
     
326. struct Book *seek_book(struct Book *head){//寻找图书，返回地址
     
327.         struct Book *target;
     
328.         char name[40];
     
329.    
     
330.         printf("请输入书名：");
     
331.         scanf("%s", name);
     
332.    
     
333.         target = head;
     
334.         while (target != NULL && strcmp(target->name, name)){
     
335.                 target = target->next;
     
336.         }
     
337.    
     
338.         return target;
     
339. }
     
340. 
     
341. void print_one(struct Book *head){//根据地址打印图书的信息
     
342.         printf("作者：%s\n", head->author);
     
343.         printf("出版社：%s\n", head->publisher);
     
344.         printf("日期：%d-%d-%d\n", head->date.year, head->date.month, head->date.day);
     
345.         printf("书籍状态：");
     
346.         switch (head->exist){
     
347.                 case 1: printf("可借取\n");break;
     
348.                 case 0: printf("不可借取\n");break;
     
349.         }
     
350. }
     
351. 
     
352. void insert(struct Book **head){//录入新的图书
     
353.         struct Book *book;
     
354.         struct Book *temp;
     
355. 
     
356.         if (book_pool != NULL){//如果内存池非空，直接从里面获取空间
     
357.                 book = book_pool;
     
358.                 book_pool = book_pool->next;
     
359.                 count_book--;
     
360.         }
     
361.         else{//如果内存池空，使用malloc申请内存
     
362.                 book = (struct Book *)malloc(sizeof(struct Book));
     
363.                 if(book == NULL){
     
364.                         printf("内存分配失败了。\n");
     
365.                         exit(1);
     
366.                 }
     
367.         }
     
368.         printf("请输入书名：");
     
369.         scanf("%s", book->name);
     
370.         printf("请输入作者：");
     
371.         scanf("%s", book->author);
     
372.         printf("请输入出版社：");
     
373.         scanf("%s", book->publisher);
     
374.         printf("请输入日期(aa-bb-cc)：");
     
375.         scanf("%d-%d-%d", &book->date.year, &book->date.month, &book->date.day);
     
376.         book->exist = 1;
     
377. 
     
378.         if (*head != NULL){
     
379.                 temp = *head;
     
380.                 *head = book;
     
381.                 book->next = temp;
     
382.         }
     
383.         else{
     
384.                 *head = book;
     
385.                 book->next = NULL;
     
386.         }
     
387.         putchar('\n');
     
388. }
     
389. 
     
390. 
     
391. void searchEvent(struct Book *head){//查找已有的书名
     
392.         struct Book *book;
     
393.         char name[32];
     
394. 
     
395.         printf("请输入书名：");
     
396.         scanf("%s", name);
     
397. 
     
398.         book = head;
     
399.        
     
400.         while (book != NULL){
     
401.                 if (!strcmp(book->name, name)){
     
402.                         break;
     
403.                 }
     
404.                 book = book->next;
     
405.         }
     
406.         if(book == NULL){
     
407.                 printf("抱歉，没有找到。\n");
     
408.         }
     
409.         else{
     
410.                 print_one(book);
     
411.         }
     
412. }
     
413. 
     
414. void change(struct Book **head){//更改
     
415.         struct Book *target;
     
416. 
     
417.         char name[32];
     
418. 
     
419.         target = seek_book(*head);// 先找到待更改的节点指针
     
420. 
     
421.         if (target == NULL){
     
422.                 printf("找不到该书名！\n");
     
423.         }
     
424.         else{
     
425.                 printf("请输入作者：");
     
426.                 scanf("%s", target->author);
     
427.                 printf("请输入出版社：");
     
428.                 scanf("%s", target->publisher);
     
429.                 printf("请输入日期(aa-bb-cc)：");
     
430.                 scanf("%d-%d-%d", &target->date.year, &target->date.month, &target->date.day);
     
431.                 printf("是否可借取(1/0)：");
     
432.                 scanf("%d", &target->exist);
     
433.         }
     
434. }
     
435. 
     
436. void delete(struct Book **head){//删除
     
437.         struct Book *target;//目标
     
438.         struct Book *now;
     
439.         struct Book *temp;//上一次
     
440. 
     
441.         target = seek_book(*head);// 先找到待删除的节点指针
     
442. 
     
443.         if (target == NULL){
     
444.                 printf("找不到该书名！\n");
     
445.         }
     
446.         else{
     
447.                 now = *head;
     
448.                 temp = NULL;
     
449.    
     
450.                 while (now != NULL && now != target){// current定位到待删除的节点
     
451.                         temp = now;
     
452.                         now = now->next;
     
453.                 }
     
454.                 if (temp == NULL){// 待删除的节点是第一个节点
     
455.                         *head = now->next;
     
456.                 }
     
457. 
     
458.                 else{// 待删除的节点不是第一个节点
     
459.                         temp->next = now->next;
     
460.                 }
     
461. 
     
462.                 if (count_book < MAX){//判断内存池有没有空位
     
463.                         if (book_pool != NULL){
     
464.                                 temp = book_pool;
     
465.                                 book_pool = target;
     
466.                                 target->next = NULL;
     
467.                         }
     
468.                         else{
     
469.                                 book_pool = target;
     
470.                                 target->next = NULL;
     
471.                         }
     
472.                         count_book++;
     
473.                 }
     
474.                 else{
     
475.                         free(target);
     
476.                 }
     
477.         }
     
478. }
     
479. 
     
480. void print(struct Book *head){//打印
     
481.         struct Book *now;
     
482. 
     
483.         now = head;
     
484.         while (now != NULL){
     
485.                 printf("书名：%s\n", now->author);
     
486.                 print_one(now);
     
487.                 now = now->next;
     
488.         }
     
489. }
     
490. 
     
491. void enter(struct Book *book, struct User *user){//结束程序时将图书信息放入文件
     
492.         struct Book *book_temp;
     
493.         struct User *user_temp;
     
494.         FILE *fp1, *fp2;
     
495. 
     
496.         if ((fp1 = fopen("book.txt", "wb")) == NULL){//fopen获取文件指针
     
497.                 printf("打开文件失败！\n");
     
498.                 exit(EXIT_FAILURE);
     
499.         }
     
500. 
     
501.         if ((fp2 = fopen("user.txt", "wb")) == NULL){//fopen获取文件指针
     
502.                 printf("打开文件失败！\n");
     
503.                 exit(EXIT_FAILURE);
     
504.         }
     
505. 
     
506.         while (book != NULL){
     
507.                 fwrite(book, sizeof(struct Book), 1, fp1);// 将数据写入到文件中,释放内存
     
508.                 book_temp = book;
     
509.                 book = book->next;
     
510.                 free(book_temp);
     
511.         }
     
512. 
     
513.         while (user != NULL){
     
514.                 fwrite(user, sizeof(struct User), 1, fp2);// 将数据写入到文件中,释放内存
     
515.                 user_temp = user;
     
516.                 user = user->next;
     
517.                 free(user_temp);
     
518.         }
     
519. 
     
520.         fclose(fp1);//关闭文件!!!!
     
521.         fclose(fp2);
     
522. 
     
523.         while (user_pool != NULL){//释放内存池
     
524.                 user_temp = user_pool;
     
525.                 user_pool = user_pool->next;
     
526.                 free(user_temp);
     
527.         }
     
528.         while (book_pool != NULL){//释放内存池
     
529.                 book_temp = book_pool;
     
530.                 book_pool = book_pool->next;
     
531.                 free(book_temp);
     
532.         }
     
533. }
     
534. 
     
535. int main(void){
     
536.         struct Book *book = NULL;
     
537.         struct User *user = NULL;
     
538.         char name[32];
     
539.         int i;
     
540. 
     
541.         welcome(&book, &user);
     
542. 
     
543.         while (1){
     
544.                 printf("\n请输入指令代码：");
     
545.                 scanf("%d", &i);
     
546.                 switch (i){
     
547.                         case 1: increase(&user);break;
     
548.                         case 2: if (log_on(user)){
     
549.                                         consumer();
     
550.                                         while (1){
     
551.                                                 printf("\n请输入指令代码：");
     
552.                                                 scanf("%d", &i);
     
553.                                                 switch (i){
     
554.                                                         case 1: searchEvent(book);break;
     
555.                                                         case 2: print(book);break;
     
556.                                                         case 3:if (administrator()){
     
557.                                                                         manage();
     
558.                                                                         while (1){
     
559.                                                                                 printf("\n请输入指令代码：");
     
560.                                                                                 scanf("%d", &i);
     
561.                                                                                 switch (i){
     
562.                                                                                         case 1: insert(&book);break;
     
563.                                                                                         case 2: change(&book);break;
     
564.                                                                                         case 3: delete(&book);break;
     
565.                                                                                         case 4: print(book);break;
     
566.                                                                                         case 5: modify(user);break;
     
567.                                                                                         case 6: query(user);break;
     
568.                                                                                         case 7: reduce(&user);break;
     
569.                                                                                         case 8: display(user);break;
     
570.                                                                                         case 9: enter(book, user);exit(i);
     
571.                                                                                 }
     
572.                                                                         }
     
573.                                                                 }
     
574.                                                                 else{
     
575.                                                                         printf("密码错误\n");
     
576.                                                                 }break;
     
577.                                                         case 4: enter(book, user);exit(i);
     
578.                                                 }
     
579.                                         }
     
580.                                 }
     
581.                                 else{
     
582.                                         printf("密码错误\n");
     
583.                                 }break;
     
584.                         case 3: enter(book, user);exit(i);
     
585.                 }
     
586.         }
     
587.         return 0;
     
588. }

复制代码

最佳答案

月排行榜 / 总排行榜

ba21

2022-12-9 22:18:14

void welcome(struct Book **head_book, struct User **head_user){//打印欢迎和使用说明
        FILE *fp1, *fp2;
        struct Book *temp_book = NULL // 请分配内存空间
        struct User *temp_user = NULL // 请分配内存空间

跳转到最佳答案楼层

ba21

void welcome(struct Book **head_book, struct User **head_user){//打印欢迎和使用说明
        FILE *fp1, *fp2;
        struct Book *temp_book = NULL // 请分配内存空间
        struct User *temp_user = NULL // 请分配内存空间

ba21

参考下https://baike.baidu.com/item/fread/10942353?fr=aladdin

御坂19090

ba21 发表于 2022-12-9 22:18
void welcome(struct Book **head_book, struct User **head_user){//打印欢迎和使用说明
        FILE *f ...

谢谢，明白了

御坂19090

ba21 发表于 2022-12-9 22:27
参考下https://baike.baidu.com/item/fread/10942353?fr=aladdin

稍微改了一下

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #include <stdlib.h>
   
4. 
   
5. #define MAX 1024
   
6. 
   
7. struct Book *book_pool = NULL;//内存池
   
8. int count_book = 0;
   
9. struct User *user_pool = NULL;
   
10. int count_user = 0;
    
11. 
    
12. struct Date{
    
13.         int year;
    
14.         int month;
    
15.         int day;
    
16. };
    
17. 
    
18. struct Book{
    
19.         char name[40];//书名
    
20.         char author[128];//作者
    
21.         char publisher[40];//出版社
    
22.         int exist;
    
23.         struct Date date;//日期
    
24.         struct Book *next;
    
25. };
    
26. 
    
27. struct User{
    
28.         char name[40];//用户名
    
29.         char cypher[32];//密码
    
30.         struct Date date;//注册日期
    
31.         struct User *next;
    
32. };
    
33. 
    
34. void welcome(struct Book **book, struct User **user);//打印欢迎和使用说明
    
35. void consumer(void);//打印用户使用说明
    
36. void manage(void);//打印管理员使用说明
    
37. int log_on(struct User *head);//登录
    
38. int administrator(void);//登录管理员
    
39. //用户相关的函数
    
40. struct User *seek_user(struct User *head);//寻找用户，返回地址
    
41. void print_user_one(struct User *head);//根据地址打印用户的信息
    
42. void increase(struct User **head);//增加用户
    
43. void reduce(struct User **head);//减少用户
    
44. void query(struct User *book);//查询用户信息
    
45. void modify(struct User *head);//修改用户信息
    
46. void display(struct User *head);//显示所有用户信息
    
47. //图书相关的函数
    
48. struct Book *seek_book(struct Book *head);//寻找图书，返回地址
    
49. void print_book_one(struct Book *head);//根据地址打印图书的信息
    
50. void insert(struct Book **head);//录入新的图书
    
51. void searchEvent(struct Book *book);//查找已有的图书
    
52. void change(struct Book **head);//更改已有的图书
    
53. void delete(struct Book **head);//删除已有的图书
    
54. void print(struct Book *head);//打印所有的图书信息
    
55. void enter(struct Book *book, struct User *user);//结束程序时将信息放入文件
    
56. void borrow(void);//借书/
    
57. void still(void);//还书/
    
58. 
    
59. void welcome(struct Book **head_book, struct User **head_user){//打印欢迎和使用说明
    
60.         FILE *fp1, *fp2;
    
61.         struct Book *temp_book = NULL, *book;
    
62.         struct User *temp_user = NULL, *user;
    
63. 
    
64.         book = *head_book;
    
65.         user = *head_user;
    
66. 
    
67.         printf("| 欢迎使用图书馆程序 |\n");
    
68.         printf("|------ 1:注册 ------|\n");
    
69.         printf("|------ 2:登录 ------|\n");
    
70.         printf("|------ 3:退出 ------|\n");
    
71.         printf("|--------------------|\n");
    
72. 
    
73.         if ((fp1 = fopen("book.txt", "rb")) == NULL){//fopen获取文件指针
    
74.                 printf("打开文件失败！\n");
    
75.                 exit(EXIT_FAILURE);
    
76.         }
    
77.         while (1){
    
78.                 if (book_pool != NULL){//如果内存池非空，直接从里面获取空间
    
79.                         temp_book = book_pool;
    
80.                         book_pool = book_pool->next;
    
81.                         count_book--;
    
82.                 }
    
83.                 else{//如果内存池空，使用malloc申请内存
    
84.                         temp_book = (struct Book *)malloc(sizeof(struct Book));
    
85.                         if(temp_book == NULL){
    
86.                                 printf("内存分配失败了。\n");
    
87.                                 exit(EXIT_FAILURE);
    
88.                         }
    
89.                 }
    
90. 
    
91.                 fread(temp_book, sizeof(struct Book), 1, fp1);// 将文件数据读取出来
    
92.                 if (feof(fp1)){
    
93.                         if (temp_user == NULL){
    
94.                                 free(temp_book);
    
95.                         }
    
96.                         break;
    
97.                 }
    
98. 
    
99.                 if (*head_book != NULL){
    
100.                         temp_book = *head_book;
     
101.                         *head_book = book;
     
102.                         book->next = temp_book;
     
103.                 }
     
104.                 else{
     
105.                         *head_book = book;
     
106.                         book->next = NULL;
     
107.                 }
     
108.         }
     
109.         fclose(fp1);//关闭文件!!!!
     
110. 
     
111.         if ((fp2 = fopen("user.txt", "rb")) == NULL){//fopen获取文件指针
     
112.                 printf("打开文件失败！\n");
     
113.                 exit(EXIT_FAILURE);
     
114.         }
     
115.         while (1){
     
116.                 if (user_pool != NULL){//如果内存池非空，直接从里面获取空间
     
117.                         temp_user = user_pool;
     
118.                         user_pool = user_pool->next;
     
119.                         count_user--;
     
120.                 }
     
121.                 else{//如果内存池空，使用malloc申请内存
     
122.                         temp_user = (struct User *)malloc(sizeof(struct User));
     
123.                         if(temp_user == NULL){
     
124.                                 printf("内存分配失败了。\n");
     
125.                                 exit(EXIT_FAILURE);
     
126.                         }
     
127.                 }
     
128. 
     
129.                 fread(temp_user, sizeof(struct User), 1, fp2);// 将文件数据读取出来
     
130.                 if (feof(fp2)){
     
131.                         if (temp_user == NULL){
     
132.                                 free(temp_user);
     
133.                         }
     
134.                         break;
     
135.                 }
     
136. 
     
137.                 if (*head_user != NULL){
     
138.                         temp_user = *head_user;
     
139.                         *head_user = user;
     
140.                         user->next = temp_user;
     
141.                 }
     
142.                 else{
     
143.                         *head_user = user;
     
144.                         user->next = NULL;
     
145.                 }
     
146.         }
     
147.         fclose(fp2);
     
148. }
     
149. 
     
150. void consumer(void){//打印用户使用说明
     
151.         printf("| 欢迎使用图书馆参观程序 |\n");
     
152.         printf("|--- 1:查找已有图书 -----|\n");
     
153.         printf("|--- 2:显示当前图书库 ---|\n");
     
154.         printf("|--- 3:进入管理员模式 ---|\n");
     
155.         printf("|--- 4:进入管理员模式 ---|\n");
     
156.         printf("|--- 5:进入管理员模式 ---|\n");
     
157.         printf("|--- 6:退出图书馆程序 ---|\n");
     
158.         printf("|----------------------|\n");
     
159. }
     
160. 
     
161. void manage(void){//打印管理员使用说明
     
162.         printf("| 欢迎使用图书馆管理程序 |\n");
     
163.         printf("|--- 1:插入新的图书 -----|\n");
     
164.         printf("|--- 2:更改已有图书 -----|\n");
     
165.         printf("|--- 3:删除已有图书 -----|\n");
     
166.         printf("|--- 4:显示当前图书库 ---|\n");
     
167.         printf("|--- 5:更改用户信息 -----|\n");
     
168.         printf("|--- 6:查询用户信息 -----|\n");
     
169.         printf("|--- 7:删除用户信息 -----|\n");
     
170.         printf("|--- 8:显示用户名单 -----|\n");
     
171.         printf("|--- 9:退出图书馆程序 ---|\n");
     
172.         printf("|----------------------|\n");
     
173. }
     
174. 
     
175. int log_on(struct User *head){//登录/
     
176.         struct User *user;
     
177.         char mm[32];
     
178.         user = seek_user(head);
     
179.         printf("请输入密码：");
     
180.         scanf("%s", mm);
     
181.         while (user != NULL){
     
182.                 if (!strcmp(user->cypher, mm)){
     
183.                         printf("登录成功");
     
184.                         return 1;
     
185.                 }
     
186.                 user = user->next;
     
187.         }
     
188.         printf("登录失败");
     
189.         return 0;
     
190. }
     
191. 
     
192. int administrator(void){
     
193.         char mm[32];
     
194. 
     
195.         printf("请输入管理员密码：");
     
196.         scanf("%s", mm);
     
197.         if (!strcmp("123456", mm)){
     
198.                 printf("登录成功");
     
199.                 return 1;
     
200.         }
     
201.         printf("登录失败");
     
202.         return 0;
     
203. }
     
204. 
     
205. struct User *seek_user(struct User *head){//寻找用户，返回地址
     
206.         struct User *target;
     
207.         char name[40];
     
208. 
     
209.         printf("请输入用户：");
     
210.         scanf("%s", name);
     
211. 
     
212.         target = head;
     
213.         while (target != NULL && strcmp(target->name, name)){
     
214.                 target = target->next;
     
215.         }
     
216. 
     
217.         return target;
     
218. }
     
219. 
     
220. void print_user_one(struct User *head){//根据地址打印用户的信息
     
221.         printf("密码：%s\n", head->cypher);
     
222.         printf("注册日期(aa-bb-cc)：%d-%d-%d\n", head->date.year, head->date.month, head->date.day);
     
223. }
     
224. 
     
225. void increase(struct User **head){//增加用户/
     
226.         struct User *user;
     
227.         struct User *temp;
     
228. 
     
229.         if (user_pool != NULL){//如果内存池非空，直接从里面获取空间
     
230.                 user = user_pool;
     
231.                 user_pool = user_pool->next;
     
232.                 count_user--;
     
233.         }
     
234.         else{//如果内存池空，使用malloc申请内存
     
235.                 user = (struct User *)malloc(sizeof(struct User));
     
236.                 if(user == NULL){
     
237.                         printf("内存分配失败了。\n");
     
238.                         exit(1);
     
239.                 }
     
240.         }
     
241.         printf("请输入用户名：");
     
242.         scanf("%s", user->name);
     
243.         printf("请设置密码：");
     
244.         scanf("%s", user->cypher);
     
245.         printf("请输入注册日期(aa-bb-cc)");
     
246.         scanf("%d-%d-%d", &user->date.year, &user->date.month, &user->date.day);
     
247. 
     
248.         if (*head != NULL){
     
249.                 temp = *head;
     
250.                 *head = user;
     
251.                 user->next = temp;
     
252.         }
     
253.         else{
     
254.                 *head = user;
     
255.                 user->next = NULL;
     
256.         }
     
257. }
     
258. 
     
259. void reduce(struct User **head){//减少用户
     
260.         struct User *target;//目标
     
261.         struct User *now;
     
262.         struct User *temp;//上一次
     
263. 
     
264.         target = seek_user(*head);// 先找到待删除的节点指针
     
265. 
     
266.         if (target == NULL){
     
267.                 printf("找不到该用户！\n");
     
268.         }
     
269.         else{
     
270.                 now = *head;
     
271.                 temp = NULL;
     
272. 
     
273.                 while (now != NULL && now != target){// current定位到待删除的节>点
     
274.                         temp = now;
     
275.                         now = now->next;
     
276.                 }
     
277.                 if (temp == NULL){// 待删除的节点是第一个节点
     
278.                         *head = now->next;
     
279.                 }
     
280.                 else{// 待删除的节点不是第一个节点
     
281.                         temp->next = now->next;
     
282.                 }
     
283. 
     
284.                 if (count_user < MAX){//判断内存池有没有空位
     
285.                         if (user_pool != NULL){
     
286.                                 temp = user_pool;
     
287.                                 user_pool = target;
     
288.                                 target->next = NULL;
     
289.                         }                        
     
290.                         else{
     
291.                                 user_pool = target;
     
292.                                 target->next = NULL;
     
293.                         }
     
294.                         count_user++;
     
295.                 }
     
296.                 else{
     
297.                         free(target);
     
298.                 }
     
299.         }
     
300. }
     
301. 
     
302. 
     
303. void query(struct User *head){//查询用户信息
     
304.         struct User *user;
     
305.         char name[32];
     
306. 
     
307.         printf("请输入用户名：");
     
308.         scanf("%s", name);
     
309. 
     
310.         user = head;
     
311. 
     
312.         while (user != NULL){
     
313.                 if (!strcmp(user->name, name)){
     
314.                         break;
     
315.                 }
     
316.                 user = user->next;
     
317.         }
     
318.         if(user == NULL){
     
319.                 printf("抱歉，没有找到。\n");
     
320.         }
     
321.         else{
     
322.                 print_user_one(user);
     
323.         }
     
324. }
     
325. 
     
326. void modify(struct User *head){//修改用户信息/
     
327.         struct User *target;
     
328. 
     
329.         char name[32];
     
330. 
     
331.         target = seek_user(head);// 先找到待更改的节点指针
     
332. 
     
333.         if (target == NULL){
     
334.                 printf("找不到该书名！\n");
     
335.         }
     
336.         else{
     
337.                 printf("请设置用户名：");
     
338.                 scanf("%s", target->name);
     
339.               printf("请设置密码：");
     
340.                 scanf("%s", target->cypher);
     
341.                 printf("请设置注册日期(aa-bb-cc)");
     
342.                 scanf("%d-%d-%d", &target->date.year, &target->date.month, &target->date.day);
     
343.         }
     
344. }
     
345. 
     
346. void display(struct User *head){//显示所有用户信息/
     
347.         struct User *now;
     
348. 
     
349.         now = head;
     
350.         while (now != NULL){
     
351.                 printf("用户名：%s\n", now->name);
     
352.                 print_user_one(now);
     
353.                 now = now->next;
     
354.         }
     
355. }
     
356. //--------------------------图书------------------------------
     
357. struct Book *seek_book(struct Book *head){//寻找图书，返回地址
     
358.         struct Book *target;
     
359.         char name[40];
     
360.    
     
361.         printf("请输入书名：");
     
362.         scanf("%s", name);
     
363.    
     
364.         target = head;
     
365.         while (target != NULL && strcmp(target->name, name)){
     
366.                 target = target->next;
     
367.         }
     
368.    
     
369.         return target;
     
370. }
     
371. 
     
372. void print_one(struct Book *head){//根据地址打印图书的信息
     
373.         printf("作者：%s\n", head->author);
     
374.         printf("出版社：%s\n", head->publisher);
     
375.         printf("日期：%d-%d-%d\n", head->date.year, head->date.month, head->date.day);
     
376.         printf("书籍状态：");
     
377.         switch (head->exist){
     
378.                 case 1: printf("可借取\n");break;
     
379.                 case 0: printf("不可借取\n");break;
     
380.         }
     
381. }
     
382. 
     
383. void insert(struct Book **head){//录入新的图书
     
384.         struct Book *book;
     
385.         struct Book *temp;
     
386. 
     
387.         if (book_pool != NULL){//如果内存池非空，直接从里面获取空间
     
388.                 book = book_pool;
     
389.                 book_pool = book_pool->next;
     
390.                 count_book--;
     
391.         }
     
392.         else{//如果内存池空，使用malloc申请内存
     
393.                 book = (struct Book *)malloc(sizeof(struct Book));
     
394.                 if(book == NULL){
     
395.                         printf("内存分配失败了。\n");
     
396.                         exit(1);
     
397.                 }
     
398.         }
     
399.         printf("请输入书名：");
     
400.         scanf("%s", book->name);
     
401.         printf("请输入作者：");
     
402.         scanf("%s", book->author);
     
403.         printf("请输入出版社：");
     
404.         scanf("%s", book->publisher);
     
405.         printf("请输入日期(aa-bb-cc)：");
     
406.         scanf("%d-%d-%d", &book->date.year, &book->date.month, &book->date.day);
     
407.         book->exist = 1;
     
408. 
     
409.         if (*head != NULL){
     
410.                 temp = *head;
     
411.                 *head = book;
     
412.                 book->next = temp;
     
413.         }
     
414.         else{
     
415.                 *head = book;
     
416.                 book->next = NULL;
     
417.         }
     
418.         putchar('\n');
     
419. }
     
420. 
     
421. 
     
422. void searchEvent(struct Book *head){//查找已有的书名
     
423.         struct Book *book;
     
424.         char name[32];
     
425. 
     
426.         printf("请输入书名：");
     
427.         scanf("%s", name);
     
428. 
     
429.         book = head;
     
430.        
     
431.         while (book != NULL){
     
432.                 if (!strcmp(book->name, name)){
     
433.                         break;
     
434.                 }
     
435.                 book = book->next;
     
436.         }
     
437.         if(book == NULL){
     
438.                 printf("抱歉，没有找到。\n");
     
439.         }
     
440.         else{
     
441.                 print_one(book);
     
442.         }
     
443. }
     
444. 
     
445. void change(struct Book **head){//更改
     
446.         struct Book *target;
     
447. 
     
448.         char name[32];
     
449. 
     
450.         target = seek_book(*head);// 先找到待更改的节点指针
     
451. 
     
452.         if (target == NULL){
     
453.                 printf("找不到该书名！\n");
     
454.         }
     
455.         else{
     
456.                 printf("请输入作者：");
     
457.                 scanf("%s", target->author);
     
458.                 printf("请输入出版社：");
     
459.                 scanf("%s", target->publisher);
     
460.                 printf("请输入日期(aa-bb-cc)：");
     
461.                 scanf("%d-%d-%d", &target->date.year, &target->date.month, &target->date.day);
     
462.                 printf("是否可借取(1/0)：");
     
463.                 scanf("%d", &target->exist);
     
464.         }
     
465. }
     
466. 
     
467. void delete(struct Book **head){//删除
     
468.         struct Book *target;//目标
     
469.         struct Book *now;
     
470.         struct Book *temp;//上一次
     
471. 
     
472.         target = seek_book(*head);// 先找到待删除的节点指针
     
473. 
     
474.         if (target == NULL){
     
475.                 printf("找不到该书名！\n");
     
476.         }
     
477.         else{
     
478.                 now = *head;
     
479.                 temp = NULL;
     
480.    
     
481.                 while (now != NULL && now != target){// current定位到待删除的节点
     
482.                         temp = now;
     
483.                         now = now->next;
     
484.                 }
     
485.                 if (temp == NULL){// 待删除的节点是第一个节点
     
486.                         *head = now->next;
     
487.                 }
     
488. 
     
489.                 else{// 待删除的节点不是第一个节点
     
490.                         temp->next = now->next;
     
491.                 }
     
492. 
     
493.                 if (count_book < MAX){//判断内存池有没有空位
     
494.                         if (book_pool != NULL){
     
495.                                 temp = book_pool;
     
496.                                 book_pool = target;
     
497.                                 target->next = NULL;
     
498.                         }
     
499.                         else{
     
500.                                 book_pool = target;
     
501.                                 target->next = NULL;
     
502.                         }
     
503.                         count_book++;
     
504.                 }
     
505.                 else{
     
506.                         free(target);
     
507.                 }
     
508.         }
     
509. }
     
510. 
     
511. void print(struct Book *head){//打印
     
512.         struct Book *now;
     
513. 
     
514.         now = head;
     
515.         while (now != NULL){
     
516.                 printf("书名：%s\n", now->author);
     
517.                 print_one(now);
     
518.                 now = now->next;
     
519.         }
     
520. }
     
521. 
     
522. void enter(struct Book *book, struct User *user){//结束程序时将图书信息放入文件
     
523.         struct Book *book_temp;
     
524.         struct User *user_temp;
     
525.         FILE *fp1, *fp2;
     
526. 
     
527.         if ((fp1 = fopen("book.txt", "wb")) == NULL){//fopen获取文件指针
     
528.                 printf("打开文件失败！\n");
     
529.                 exit(EXIT_FAILURE);
     
530.         }
     
531. 
     
532.         if ((fp2 = fopen("user.txt", "wb")) == NULL){//fopen获取文件指针
     
533.                 printf("打开文件失败！\n");
     
534.                 exit(EXIT_FAILURE);
     
535.         }
     
536. 
     
537.         while (book != NULL){
     
538.                 fwrite(book, sizeof(struct Book), 1, fp1);// 将数据写入到文件中,释放内存
     
539.                 book_temp = book;
     
540.                 book = book->next;
     
541.                 free(book_temp);
     
542.         }
     
543. 
     
544.         while (user != NULL){
     
545.                 fwrite(user, sizeof(struct User), 1, fp2);// 将数据写入到文件中,释放内存
     
546.                 user_temp = user;
     
547.                 user = user->next;
     
548.                 free(user_temp);
     
549.         }
     
550. 
     
551.         fclose(fp1);//关闭文件!!!!
     
552.         fclose(fp2);
     
553. 
     
554.         while (user_pool != NULL){//释放内存池
     
555.                 user_temp = user_pool;
     
556.                 user_pool = user_pool->next;
     
557.                 free(user_temp);
     
558.         }
     
559.         while (book_pool != NULL){//释放内存池
     
560.                 book_temp = book_pool;
     
561.                 book_pool = book_pool->next;
     
562.                 free(book_temp);
     
563.         }
     
564. }
     
565. 
     
566. int main(void){
     
567.         struct Book *book = NULL;
     
568.         struct User *user = NULL;
     
569.         char name[32];
     
570.         int i;
     
571. 
     
572.         welcome(&book, &user);
     
573. 
     
574.         while (1){
     
575.                 printf("\n请输入指令代码：");
     
576.                 scanf("%d", &i);
     
577.                 switch (i){
     
578.                         case 1: increase(&user);break;
     
579.                         case 2: if (log_on(user)){
     
580.                                         consumer();
     
581.                                         while (1){
     
582.                                                 printf("\n请输入指令代码：");
     
583.                                                 scanf("%d", &i);
     
584.                                                 switch (i){
     
585.                                                         case 1: searchEvent(book);break;
     
586.                                                         case 2: ;break;
     
587.                                                         case 3: ;break;
     
588.                                                         case 4: print(book);break;
     
589.                                                         case 5:if (administrator()){
     
590.                                                                         manage();
     
591.                                                                         while (1){
     
592.                                                                                 printf("\n请输入指令代码：");
     
593.                                                                                 scanf("%d", &i);
     
594.                                                                                 switch (i){
     
595.                                                                                         case 1: insert(&book);break;
     
596.                                                                                         case 2: change(&book);break;
     
597.                                                                                         case 3: delete(&book);break;
     
598.                                                                                         case 4: print(book);break;
     
599.                                                                                         case 5: modify(user);break;
     
600.                                                                                         case 6: query(user);break;
     
601.                                                                                         case 7: reduce(&user);break;
     
602.                                                                                         case 8: display(user);break;
     
603.                                                                                         case 9: enter(book, user);exit(i);
     
604.                                                                                 }
     
605.                                                                         }
     
606.                                                                 }
     
607.                                                                 else{
     
608.                                                                         printf("密码错误\n");
     
609.                                                                 }
     
610.                                                                 break;
     
611.                                                         case 6: enter(book, user);exit(i);
     
612.                                                 }
     
613.                                         }
     
614.                                 }
     
615.                                 else{
     
616.                                         printf("密码错误\n");
     
617.                                 }
     
618.                                 break;
     
619.                         case 3: enter(book, user);exit(i);
     
620.                 }
     
621.         }
     
622.         return 0;
     
623. }

复制代码

，然后不知道哪里错了，感觉是这里有问题，但是又没有改这个部分