这个，第一次打开，所有功能都没问题，但是，有录入数据后，就错误。不知道为什么....

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

复制代码

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

复制代码

了，有一个问题，为什么在函数里不行，一模一样的搬到int main（）里面就可以了？

jhq999

你没有考虑过第一次启动吗？

御坂19090

jhq999 发表于 2022-12-10 13:00
你没有考虑过第一次启动吗？

第一次可以呀。唔文件已经创建了

御坂19090

想要问一下[attachimg]163155[/attachim

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #include <stdlib.h>
   
4. 
   
5. struct User *user_pool = NULL;
   
6. int count_user = 0;
   
7. 
   
8. struct Date{
   
9.         int year;
   
10.         int month;
    
11.         int day;
    
12. };
    
13. 
    
14. struct User{
    
15.         char name[40];//用户名
    
16.         char cypher[32];//密码
    
17.         int amount;//借取书本量
    
18.         struct Date date;//注册日期
    
19.         struct User *next;
    
20. };
    
21. 
    
22. struct User *read(FILE *fp1, struct User **head_user);
    
23. 
    
24. struct User *read(FILE *fp1, struct User **head_user){       
    
25.         struct User *temp_user;
    
26.         struct User *user;
    
27. 
    
28.         if (user_pool != NULL){//如果内存池非空，直接从里面获取空间
    
29.                 temp_user = user_pool;
    
30.                 user_pool = user_pool->next;
    
31.                 count_user--;
    
32.         }
    
33.         else{//如果内存池空，使用malloc申请内存
    
34.                 user = (struct User *)malloc(sizeof(struct User));
    
35.                 if(user == NULL){
    
36.                         printf("内存分配失败了。\n");
    
37.                         exit(EXIT_FAILURE);
    
38.                 }
    
39.         }
    
40. 
    
41.         if (fread(user, sizeof(struct User), 1, fp1) == 0){// 将文件数据读取出来
    
42.                 free(user);
    
43.         }
    
44.         if (*head_user != NULL){
    
45.                 temp_user = *head_user;
    
46.                 *head_user = user;
    
47.                 user->next = temp_user;
    
48.         }
    
49.         else{
    
50.                 *head_user = user;
    
51.                 user->next = NULL;
    
52.         }
    
53. 
    
54.         return user;
    
55. }
    
56. 
    
57. int main(){
    
58.         FILE *fp1;
    
59.         struct User **head_user;
    
60.         struct User *temp_user;       
    
61.         struct User *user;
    
62. 
    
63.         *head_user = NULL;
    
64. 
    
65.         if ((fp1 = fopen("user.txt", "rb")) == NULL){//fopen获取文件指针
    
66.                 printf("打开文件失败！\n");
    
67.                 exit(EXIT_FAILURE);
    
68.         }
    
69. 
    
70.         //user = read(fp1, head_user);
    
71.                
    
72.         if (user_pool != NULL){//如果内存池非空，直接从里面获取空间
    
73.                 temp_user = user_pool;
    
74.                 user_pool = user_pool->next;
    
75.                 count_user--;
    
76.         }
    
77.         else{//如果内存池空，使用malloc申请内存
    
78.                 user = (struct User *)malloc(sizeof(struct User));
    
79.                 if(user == NULL){
    
80.                         printf("内存分配失败了。\n");
    
81.                         exit(EXIT_FAILURE);
    
82.                 }
    
83.         }
    
84. 
    
85.         if (fread(user, sizeof(struct User), 1, fp1) == 0){// 将文件数据读取出来
    
86.                 free(user);
    
87.         }
    
88.         if (*head_user != NULL){
    
89.                 temp_user = *head_user;
    
90.                 *head_user = user;
    
91.                 user->next = temp_user;
    
92.         }
    
93.         else{
    
94.                 *head_user = user;
    
95.                 user->next = NULL;
    
96.         }
    
97. 
    
98.         printf("用户名：%s\n", user->name);
    
99.         printf("密码：%s\n", user->cypher);
    
100.         printf("注册日期：%d-%d-%d\n", user->date.year, user->date.month, user->date.day);
     
101.         printf("借取图书 %d 本\n", user->amount);
     
102. 
     
103.         fclose(fp1);
     
104.         return 0;
     
105. }

复制代码

g]这个为什么放到函数里面就不行了？

御坂19090

jhq999 发表于 2022-12-10 13:00
你没有考虑过第一次启动吗？

文件没创建的确不行，但是这个不难，可以后面加。和现在的问题没有关系

jhq999

御坂19090 发表于 2022-12-10 14:46
文件没创建的确不行，但是这个不难，可以后面加。和现在的问题没有关系

没多少人有时间用眼睛给你找错，把book.txt上传上来

御坂19090

jhq999 发表于 2022-12-10 15:15
没多少人有时间用眼睛给你找错，把book.txt上传上来

唔，里面没有东西。