[已解决]急求作业题酒店点菜系统

ccczd666

感谢大佬帮助，最好不用指针

最佳答案

月排行榜 / 总排行榜

782353676

2020-12-22 18:44:40

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. int main()
   
4. {
   
5.     int num,m,n;
   
6.     printf("欢迎光临\n");
   
7.     printf("请选择餐桌号: ");
   
8.     scanf("%d",&m);
   
9.     printf("成功占座%d号!",m);
   
10.     printf("1.酸菜鱼  2.宫保鸡丁 3.可口可乐\n");
    
11.     printf("你好,请点餐:");
    
12.     while(1)
    
13.     {
    
14.         scanf("%d",&n);
    
15.     printf("1.确认 2.返回");
    
16.     scanf("%d",&num);
    
17.     if(num==1)
    
18.         break;
    
19.     else
    
20.     {
    
21.         return 0;
    
22.         break;
    
23.     }
    
24. 
    
25.     }
    
26. 
    
27.     switch(n)
    
28.     {
    
29.         case 1:printf("成功点餐酸菜鱼");break;
    
30.         case 2:printf("成功点餐宫保鸡丁");break;
    
31.         case 3:printf("成功点餐可口可乐");break;
    
32.         default :printf("你走吧,小店没有你要的");
    
33.     }
    
34. 
    
35. }
    

复制代码

跳转到最佳答案楼层

782353676

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. int main()
   
4. {
   
5.     int num,m,n;
   
6.     printf("欢迎光临\n");
   
7.     printf("请选择餐桌号: ");
   
8.     scanf("%d",&m);
   
9.     printf("成功占座%d号!",m);
   
10.     printf("1.酸菜鱼  2.宫保鸡丁 3.可口可乐\n");
    
11.     printf("你好,请点餐:");
    
12.     while(1)
    
13.     {
    
14.         scanf("%d",&n);
    
15.     printf("1.确认 2.返回");
    
16.     scanf("%d",&num);
    
17.     if(num==1)
    
18.         break;
    
19.     else
    
20.     {
    
21.         return 0;
    
22.         break;
    
23.     }
    
24. 
    
25.     }
    
26. 
    
27.     switch(n)
    
28.     {
    
29.         case 1:printf("成功点餐酸菜鱼");break;
    
30.         case 2:printf("成功点餐宫保鸡丁");break;
    
31.         case 3:printf("成功点餐可口可乐");break;
    
32.         default :printf("你走吧,小店没有你要的");
    
33.     }
    
34. 
    
35. }
    

复制代码

782353676

1. 
   
2. //当注册用户名为：root，密码为：root的账号时，系统默认为初始管理员
   
3. 
   
4. //头文件
   
5. #include<stdio.h>
   
6. #include<stdlib.h>
   
7. #include<time.h>
   
8. #include<conio.h>
   
9. #include<windows.h>
   
10. #include<string.h>
    
11. 
    
12. 
    
13. //宏定义区
    
14. #define M  sizeof(struct User)//用户表的大小
    
15. #define N  sizeof(struct stapleFood)//主食 表大小
    
16. #define P  sizeof(struct non_stapleFood)//副食表大小
    
17. #define Q  sizeof(struct Drink_beverage) //饮品表大小
    
18. #define X  sizeof(struct Table)//餐桌表大小
    
19. #define Y  sizeof(struct Form)//订单表大小
    
20. 
    
21. //结构体
    
22. 
    
23. struct User    //用户表
    
24. {
    
25.         char userName[10];//用户名
    
26.         char passWord[18];//密码
    
27.         int isVIP;//会员标记
    
28.         int isAdministrator;//管理员标记
    
29.         float money;//余额
    
30.         struct User *next;//指针域
    
31. };
    
32. typedef struct User user;
    
33. typedef user* pUser;
    
34. 
    
35. struct stapleFood   //主食
    
36. {
    
37.         char name[20];
    
38.         float price;
    
39.         struct stapleFood *next;
    
40. };
    
41. typedef struct stapleFood staple_food;
    
42. typedef staple_food *pStapleFood;
    
43. 
    
44. struct non_stapleFood   //副食
    
45. {
    
46.         char name[20];
    
47.         float price;
    
48.         struct non_stapleFood *next;
    
49. };
    
50. typedef struct non_stapleFood non_staple_food;
    
51. typedef non_staple_food *pNon_stapleFood;
    
52. 
    
53. struct Drink_beverage  //饮品
    
54. {
    
55.         char name[20];
    
56.         float price;
    
57.         struct Drink_beverage *next;
    
58. };
    
59. typedef struct Drink_beverage drinkBeverage;
    
60. typedef drinkBeverage *pDrinkBeverage;
    
61. 
    
62. struct Table   //餐桌
    
63. {
    
64.         int ID;//餐桌编号
    
65.         int People;//已坐人数
    
66.         int count;//可容纳人数
    
67.         char Username[10];//订餐人
    
68.         struct Table *next;
    
69. };
    
70. typedef struct Table table;
    
71. typedef table *pTable;
    
72. 
    
73. 
    
74. struct Form    //订单
    
75. {
    
76.         char name[20];
    
77.         float price;
    
78.         struct Form *next;
    
79. };
    
80. typedef struct Form orderForm;
    
81. typedef orderForm *pOrder;
    
82. 
    
83. 
    
84. //自定义函数区
    
85. 
    
86.         //用户客户端
    
87. 
    
88. void Default();//欢迎界面
    
89. void User_Login();//用户登录界面
    
90. void Logon();//注册界面
    
91. pUser readUserFile();//从文件中读取用户信息，返回一个表头地址
    
92. void save_User(pUser p1);//将用户信息保存到文件中
    
93. void User_Menu();//用户菜单  
    
94. void User_Order();//点餐
    
95. void Order_StapleFood();//主食
    
96. void Order_nonStapleFood();//副食
    
97. void Order_DrinkBeverage();//饮品
    
98. void Order_Form(int ID,int number);//订单
    
99. void User_List_Table();//餐桌列表
    
100. void Apply_VIP_Menu();//会员办理菜单
     
101. void Add_money(pUser head);//充值
     
102. void Updata_User(pUser head);//更新用户表
     
103. void Apply_VIP(pUser head);//办理会员
     
104. void User_Wallet();//我的钱包
     
105. 
     
106. 
     
107.         //管理员客户端
     
108. void Administrator_Menu();//管理员菜单
     
109. void Administrator_Login();//管理员登录
     
110. void Check_User();//查看用户
     
111. void Find_User();//查找用户
     
112. void All_User();//查看所有用户
     
113. void All_VIP();//本店会员
     
114. void Setup_administrator();//设置管理员
     
115. void Food();//菜品信息
     
116. void Add_Food();//添加菜单
     
117. void save_stapleFood(pStapleFood p);//保存主食信息
     
118. void save_non_stapleFood(pNon_stapleFood p);//保存副食信息
     
119. void save_drinkBeverage(pDrinkBeverage p);//保存饮品信息
     
120. pStapleFood readStapleFoodFile();//从主食文件中读取用户信息，返回一个表头地址  
     
121. pNon_stapleFood readNonStapleFoodFile();//从副食文件中读取用户信息，返回一个表头地址
     
122. pDrinkBeverage readDrinkBeverageFile();//从饮品文件中读取用户信息，返回一个表头地址
     
123. void Table();//餐桌管理
     
124. void Add_Table();//添加餐桌
     
125. void save_Table(pTable p);//保存餐桌信息
     
126. pTable readTableFile(); //从餐桌文件中读取用户信息，返回一个表头地址
     
127. void Clear_Table();//清理餐桌
     
128. void Clear_oneTable();//清理指定餐桌
     
129. void Clear_allTable();//清理所有餐桌
     
130. void Updata_Table(pTable head);//更新餐桌文件
     
131. void Administrator_List_Table();//餐桌列表
     
132. 
     
133. 
     
134.         //公共函数
     
135. void toxy(int x,int y);//将光标移动到x，y坐标处
     
136. void HideCursor(int x);//隐藏光标
     
137. char *HidePassword();//隐藏密码
     
138. void Exit();//退出系统  
     
139. void Change();//切换账号
     
140. void Amend_passWord();//修改密码
     
141. void List_Food();//菜单列表
     
142. 
     
143. //全局变量区
     
144. char _userName[10];
     
145. char _passWord[18];//记录当前用户
     
146. pOrder orderHead=NULL,p2=NULL;//记录当前用户的订单
     
147. int num=0;
     
148. 
     
149. //函数实现区
     
150. 
     
151. void toxy(int x,int y)//将光标移动到x，y坐标处
     
152. {
     
153.         COORD pos={x,y};
     
154.         HANDLE Out = GetStdHandle(STD_OUTPUT_HANDLE);
     
155.         SetConsoleCursorPosition(Out,pos);
     
156. }
     
157. 
     
158. void HideCursor(int x)//隐藏光标 ,当x为0时，隐藏，为1时，显示
     
159. {
     
160.         CONSOLE_CURSOR_INFO cursor_info ={1,x};
     
161.         SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),&cursor_info);
     
162. }
     
163. 
     
164. void Default()//欢迎界面
     
165. {
     
166.         char t;//用于选择
     
167.         do
     
168.         {
     
169.                 HideCursor(0); //隐藏光标
     
170.                 system("color 72");
     
171.                 toxy(28,8);
     
172.                 printf("     欢迎来到南航餐饮！    ");
     
173.                 toxy(26,9);
     
174.                 printf("-----------------------------");
     
175.                 toxy(27,11);
     
176.                 printf("1.登录  2.注册  3.管理员登录");
     
177.                 while(1)    //死循环为防止其他按键干扰
     
178.                 {
     
179.                         t=getch();//不回显函数
     
180.                         if(t=='1')//如果按1，则进入登录界面
     
181.                                 User_Login();
     
182.                         else if(t=='2')//如果按2，则进入注册界面
     
183.                                 Logon();
     
184.                         else if(t=='3')
     
185.                                 Administrator_Login();
     
186.                 }//如果既不是1也不是2和3，则循环输入
     
187.         }while(1);//永远为真
     
188.        
     
189. }
     
190. 
     
191. void User_Menu()//用户菜单
     
192. {
     
193.        
     
194.         char t;//用于选择菜单选项
     
195.         do
     
196.         {       
     
197.                 system("cls");
     
198.                 HideCursor(0); //隐藏光标
     
199.                 system("color 74");
     
200.                 toxy(32,3);
     
201.                 printf("南航餐饮点餐系统！");
     
202.                 toxy(32,4);
     
203.                 printf("当前用户：%s",_userName);
     
204.                 toxy(30,5);
     
205.                 printf("*********************");
     
206.                 toxy(32,7);
     
207.                 printf("|  1.菜单列表  |");
     
208.                 toxy(32,9);
     
209.                 printf("|  2.餐桌列表  |");
     
210.                 toxy(32,11);
     
211.                 printf("|  3.会员办理  |");
     
212.                 toxy(32,13);
     
213.                 printf("|  4.修改密码  |");
     
214.                 toxy(32,15);
     
215.                 printf("|  5.我的钱包  |");
     
216.                 toxy(32,17);
     
217.                 printf("|  6.切换账号  |");
     
218.                 toxy(32,19);
     
219.                 printf("|  7.退出系统  |");
     
220.                 t=getch();//不回显函数，输入一个值
     
221.                 switch(t)
     
222.                 {
     
223.                         case '1':User_Order();break;
     
224.                         case '2':User_List_Table();break;
     
225.                         case '3':Apply_VIP_Menu();break;
     
226.                         case '4':Amend_passWord();break;
     
227.                         case '5':User_Wallet();break;
     
228.                         case '6':Change();break;
     
229.                         case '7':Exit();break;
     
230.                         default :break;
     
231.                 }
     
232.         }while(1);//永远 为真
     
233. }
     
234. 
     
235. char *HidePassword()//隐藏密码
     
236. {
     
237.         char password[18];//密码
     
238.         char *p;//指向密码的指针
     
239.         int i=0;//记录密码位数
     
240.         char t;//输入密码
     
241.         for(;;)              //此处为输入密码不回显操作
     
242.                 {
     
243.                         t=getch();       //输入k
     
244.                         if(t=='\r')      //如果输入k为回车，则跳出循环
     
245.                         {
     
246.                                 break;
     
247.                         }
     
248.                         else if(t=='\b')  //如果输入k为删除键
     
249.                         {
     
250.                                 if(i>0)       //如若密码还没完全删除
     
251.                                 {
     
252.                                         printf("\b");
     
253.                                         printf(" ");
     
254.                                         printf("\b");
     
255.                                         i--;
     
256.                                 }
     
257.                         }
     
258.                         else              //如果输入的k既不是删除键，也不是回车键
     
259.                         {
     
260.                                 password[i]=t;   //把k的值赋给_password[i];
     
261.                                 printf("*");      //输出*号，保护用户隐私
     
262.                                 i++;              //密码位数加1
     
263.                         }
     
264.                 }
     
265.                 password[i]='\0';//在数组末端加一个结束符
     
266.                 p=password;//让p指向该数组
     
267.                 return p; //返回一个指向密码的指针
     
268. }
     
269. 
     
270. pUser readUserFile()//从文件中读取用户信息，返回一个表头地址
     
271. {
     
272.         FILE *fp;       //文件指针
     
273.         int n=0;//记录链表 的结点数
     
274.         pUser head=NULL;//定义头指针
     
275.         pUser p2,p,pre;
     
276.         fp=fopen("User.txt","a+");     //以只读的方式打开文件
     
277.         if(fp==NULL)
     
278.         {
     
279.                 printf("cannot open file\n");
     
280.         }
     
281.         else
     
282.         {
     
283.                 while(!feof(fp))        //判断文件位置标志是否移动到文件末尾
     
284.                 {
     
285.                     n++;
     
286.                         p=(pUser)malloc(M); //向内存申请一段空间
     
287.                    fread(p,M,1,fp);     //将fp所指向的文件中的内容赋给p
     
288.                    if(n==1)
     
289.                    {
     
290.                       head=p;
     
291.                       p2=p;
     
292.                     }
     
293.                     else             //创建链表
     
294.                     {
     
295.                             pre=p2;
     
296.                             p2->next=p;
     
297.                             p2=p;
     
298.                         }
     
299.             }
     
300.             p2->next=NULL;
     
301.         }
     
302.         if(n<=2)
     
303.                 head->next=NULL;
     
304.         else
     
305.                 pre->next=NULL;
     
306.     fclose(fp);    //关闭文件
     
307.     return head;   //返回头指针
     
308. }
     
309. 
     
310. void save_User(pUser p1)     //将p1所指向的内容存储到文件中
     
311. {
     
312.         FILE *fp;       //文件指针
     
313.         fp=fopen("User.txt","a+");    //以追加的方式打开文件
     
314.         if(fp==NULL)
     
315.         {
     
316.                 printf("cannot open file\n");
     
317.         }
     
318.         if(fwrite(p1,M,1,fp)!=1)    //将p1所指向的1个大小为N的数据结构写入fp所指向的文件中
     
319.         {
     
320.                 printf("file write error\n");
     
321.         }
     
322.         fclose(fp);        //关闭文件
     
323. }
     
324. 
     
325. void User_Login()//登录页面
     
326. {
     
327.         char *q,t,c;//q指针用于接收 *HidePassword()函数返回的指向密码的指针，t和c均用于选择
     
328.         pUser p=readUserFile();//从文件中读取用户信息，返回一个表头地址
     
329.         do
     
330.         {
     
331.                 HideCursor(1);//显示管光标
     
332.                 system("cls");//清屏
     
333.                 system("color 73");//设置颜色
     
334.                 toxy(28,8);
     
335.                 printf("南航餐饮管理系统登录界面");
     
336.                 toxy(26,9);
     
337.                 printf("-----------------------------");
     
338.                 toxy(32,11);
     
339.                 printf("用户名:");
     
340.                 toxy(32,13);
     
341.                 printf("密  码:");
     
342.                 toxy(40,11);
     
343.                 scanf("%s",_userName);
     
344.                 toxy(40,13);
     
345.                 q=HidePassword();//输入密码
     
346.                 strcpy(_passWord,q);//将获得的密码复制给_passWord[]数组
     
347.                 while(p!=NULL&&strcmp(p->userName,_userName)!=0)   //遍历链表，寻找当前输入的账户的账号
     
348.                 {
     
349.                         p=p->next;
     
350.                 }
     
351.                 if(p!=NULL)   //如果p不为空
     
352.                 {
     
353.                     if(strcmp(p->passWord,_passWord)==0)     //如果输入的密码正确
     
354.                         {
     
355.                                 toxy(32,16);
     
356.                                 printf("正在登陆....");
     
357.                                 Sleep(500);      //暂停0.5秒
     
358.                                 system("cls");
     
359.                                 toxy(32,10);
     
360.                                 printf("登陆成功！");
     
361.                                 break;    //跳出循环
     
362.                         }
     
363.                         else      //如果输入的密码错误
     
364.                         {
     
365.                                 toxy(32,16);
     
366.                                 printf("正在登陆....");
     
367.                                 Sleep(500);
     
368.                                 system("cls");
     
369.                                 toxy(30,8);
     
370.                                 printf("-------------------------");
     
371.                                 toxy(30,9);
     
372.                                 printf("|                       |");
     
373.                                 toxy(30,10);
     
374.                                 printf("| 密码错误！是否继续？  |");
     
375.                                 toxy(30,12);
     
376.                                 printf("| 1.是             2.否 |");
     
377.                                 toxy(30,13);
     
378.                                 printf("|                       |");
     
379.                                 toxy(30,14);
     
380.                                 printf("-------------------------");
     
381.                                 while(1)//无限循环为防止其他按键干扰
     
382.                                 {
     
383.                                         t=getch();  //输入t   
     
384.                                         if(t=='1')         
     
385.                                         {
     
386.                                                 system("cls");  //清屏
     
387.                                                 break;
     
388.                                         }
     
389.                                         else if(t=='2')     //如果输入t为n，进入开始界面
     
390.                                         {
     
391.                                                 system("cls");  //清屏
     
392.                                                 Default();break;
     
393.                                         }
     
394.                                 }
     
395.                         }
     
396.            }
     
397.            else              //如果p为空，即输入的账号不正确
     
398.            {
     
399.                        toxy(32,16);
     
400.                        printf("正在登陆....");
     
401.                        Sleep(500);
     
402.                        system("cls");
     
403.                        toxy(30,8);
     
404.                        printf("-------------------------");
     
405.                        toxy(30,9);
     
406.                        printf("|                       |");
     
407.                            toxy(30,10);
     
408.                         printf("|  账号错误！是否继续？ |");
     
409.                         toxy(30,11);
     
410.                         printf("|                       |");
     
411.                         toxy(30,12);
     
412.                         printf("|  1.是            2.否 |");
     
413.                         toxy(30,13);
     
414.                         printf("|                       |");
     
415.                         toxy(30,14);
     
416.                         printf("-------------------------");
     
417.                         while(1)      //死循环防止其他按键干扰
     
418.                         {
     
419.                                 c=getch();
     
420.                                 if(c=='1')
     
421.                                 {  
     
422.                                         system("cls");
     
423.                                         break;
     
424.                                 }
     
425.                                 else if(c=='2')
     
426.                                 {
     
427.                                         system("cls");  //清屏
     
428.                                         Default();
     
429.                                 }
     
430.                         }
     
431.            }
     
432.         }while(1);
     
433.         Sleep(500);      //暂停0.5秒
     
434.     User_Menu();         //账号密码均正确，进入用户主菜单
     
435. }
     
436. 
     
437. void Logon()//注册界面
     
438. {
     
439.         pUser p1;
     
440.         pUser p=readUserFile();//从文件中读取用户信息，返回一个表头地址
     
441.         p1=(pUser)malloc(M);     //向内存申请一段空间
     
442.         char *q1,*q2;//q1，q2分别用于接收 *HidePassword()函数返回的值
     
443.         char userName[10],passWord[18],againPassword[18],c,k,t;//c，k，t均用于选择
     
444.         do{       
     
445.                 system("cls");
     
446.                 system("color 73");
     
447.                 HideCursor(1);//显示光标
     
448.                 int flag=0;//标记信息库中是否存在要注册用户名
     
449.                 toxy(28,8);
     
450.                 printf("南航餐饮管理系统注册界面");
     
451.                 toxy(26,9);
     
452.                 printf("-----------------------------");
     
453.                 toxy(32,11);
     
454.                 printf("用 户 名:");
     
455.                 toxy(32,13);
     
456.                 printf("密    码:");
     
457.                 toxy(32,15);
     
458.                 printf("确认密码:");
     
459.                 toxy(42,11);
     
460.                 scanf("%s",userName);//输入用户名
     
461.                 toxy(42,13);
     
462.                 q1=HidePassword();//输入密码
     
463.                 strcpy(passWord,q1);
     
464.                 toxy(42,15);
     
465.                 q2=HidePassword();//输入确认密码
     
466.                 strcpy(againPassword,q2);
     
467.                 while(p!=NULL)   //遍历链表，寻找当前输入的账户的账号
     
468.                 {
     
469.                         if(strcmp(p->userName,userName)==0)//如果信息库中存在该用户名
     
470.                         {
     
471.                                 toxy(32,17);
     
472.                                 printf("用户名已存在，请重新注册！");
     
473.                                 flag=1;//flag为1时表示用户名已存在
     
474.                                 break;//跳出循环
     
475.                         }
     
476.                         p=p->next;
     
477.                 }
     
478.                 if(flag)//如果用户名已存在
     
479.                 {
     
480.                         HideCursor(0);//隐藏光标
     
481.                         toxy(32,19);
     
482.                         printf("是否继续？");//询问是否继续
     
483.                         toxy(32,21);
     
484.                         printf("1.是\t2.否");
     
485.                         while(1)
     
486.                         {
     
487.                                 t=getch();
     
488.                                 if(t=='1')
     
489.                                         break;
     
490.                                 else if(t=='2')
     
491.                                         break;
     
492.                         }
     
493.                         if(t=='1')//如果继续，则重新注册
     
494.                                 continue;
     
495.                         else if(t=='2')//如果不继续，则回到首页
     
496.                         {
     
497.                                 system("cls");//清屏
     
498.                                 Default();//回到首页
     
499.                         }        
     
500.                 }
     
501.                        
     
502.                 if(strcmp(passWord,againPassword)==0)        //如果输入的两次密码均正确
     
503.                 {
     
504.                         strcpy(p1->userName,userName);
     
505.                         strcpy(p1->passWord,passWord);
     
506.                         strcpy(_userName,userName);
     
507.                         strcpy(_passWord,passWord);
     
508.                         p1->isVIP=0;
     
509.                         p1->money=0;
     
510.                         if(strcmp(userName,"root")==0&&strcmp(passWord,"root")==0)
     
511.                                 p1->isAdministrator=1;
     
512.                         else
     
513.                                 p1->isAdministrator=0;
     
514.                         toxy(32,16);
     
515.                         printf("正在注册....");
     
516.                         Sleep(500);
     
517.                         break;              //跳出循环
     
518.                 }
     
519.                 else    //如果输入的两次密码不同
     
520.                 {
     
521.                         toxy(32,16);
     
522.                         printf("正在注册....");
     
523.                         Sleep(500);
     
524.                         system("cls");
     
525.                         toxy(30,8);
     
526.                         printf("------------------------------");
     
527.                         toxy(30,9);
     
528.                         printf("|                            |");
     
529.                         toxy(30,10);
     
530.                         printf("|两次密码不一致!是否继续注册?|");
     
531.                         toxy(30,11);
     
532.                         printf("|                            |");
     
533.                         toxy(30,12);
     
534.                         printf("|  1.是                2.否  |");
     
535.                         toxy(30,13);
     
536.                         printf("|                            |");
     
537.                         toxy(30,14);
     
538.                         printf("------------------------------");
     
539.                         while(1)
     
540.                         {
     
541.                                 c=getch();
     
542.                                 if(c=='1')
     
543.                                 {
     
544.                                         system("cls");
     
545.                                         break;
     
546.                                 }
     
547.                                 else if(c=='2')
     
548.                                 {
     
549.                                         system("cls");
     
550.                                         Default();
     
551.                                         break;
     
552.                                 }
     
553.                         }
     
554.                 }
     
555.         }while(1);
     
556.         save_User(p1);     //调用函数，将p1所指向的内容存储到文件中
     
557.         system("cls");
     
558.         toxy(32,10);
     
559.         printf("注册成功！");
     
560.         Sleep(500);         //暂停0.5秒
     
561.         toxy(32,12);
     
562.         printf("正在自动为您登陆....");
     
563.         Sleep(500);
     
564.         User_Menu();    //注册成功后进入主菜单
     
565. }
     
566. 
     
567. void User_Order()//点餐
     
568. {
     
569.         char ch='0';
     
570.         char t='0';
     
571.         int ID;
     
572.         int number;
     
573.         do
     
574.         {
     
575.                 while(1)
     
576.                 {       
     
577.                         system("cls");
     
578.                         HideCursor(1);
     
579.                         int flag=0;
     
580.                         pTable T,Thead;
     
581.                         Thead=readTableFile();
     
582.                         T=Thead;
     
583.                         int j=11;
     
584.                         toxy(12,6);
     
585.                         printf("餐桌列表(按任意键继续)");
     
586.                         toxy(2,8);
     
587.                         printf("餐桌编号 | 可坐人数 | 已坐人数");
     
588.                         toxy(0,9);
     
589.                         printf("--------------------------------------");
     
590.                         while(T!=NULL)
     
591.                         {
     
592.                                 toxy(6,j);
     
593.                                 printf("%-10d%-10d%d",T->ID,T->count,T->People);
     
594.                                 j++;
     
595.                                 T=T->next;
     
596.                         }
     
597.                         toxy(38,12);
     
598.                         printf("请选择餐桌号：");
     
599.                         scanf("%d",&ID);
     
600.                         toxy(40,14);
     
601.                         printf("请选择人数：");
     
602.                         scanf("%d",&number);
     
603.                         T=Thead;
     
604.                         while(T!=NULL)
     
605.                         {
     
606.                                 if(T->ID==ID)
     
607.                                 {
     
608.                                         if((T->count)-(T->People)>=number)
     
609.                                         {
     
610.                                                 toxy(38,16);
     
611.                                                 printf("占座成功！按任意键继续点餐");
     
612.                                                 flag=1;
     
613.                                                 break;
     
614.                                         }
     
615.                                         else
     
616.                                         {
     
617.                                                 toxy(38,16);
     
618.                                                 printf("占座失败！该餐桌座位不够");
     
619.                                                 flag=0;
     
620.                                                 break;
     
621.                                         }
     
622.                                 }
     
623.                                 T=T->next;
     
624.                         }
     
625.                         if(T==NULL&&flag==0)
     
626.                         {
     
627.                                 toxy(38,16);
     
628.                                 printf("该餐桌编号不存在，请重新输入");
     
629.                                 Sleep(1000);
     
630.                                 continue;
     
631.                         }
     
632.                         else if(T!=NULL&&flag==0)
     
633.                         {
     
634.                                 toxy(38,17);
     
635.                                 printf("是否继续  1.是   2.否");
     
636.                                 while(1)
     
637.                                 {
     
638.                                         ch=getch();
     
639.                                         if(ch=='1'||ch=='2')
     
640.                                                 break;
     
641.                                 }
     
642.                                 if(ch=='1')
     
643.                                         continue;
     
644.                                 else if(ch=='2')
     
645.                                         break;
     
646.                         }
     
647.                         else if(flag)
     
648.                                 break;
     
649.                 }
     
650.                 if(ch=='2')
     
651.                         break;
     
652.                 getch();
     
653.                 do
     
654.                 {
     
655.                        
     
656.                         system("cls");
     
657.                         toxy(32,6);
     
658.                         printf("点餐");
     
659.                         toxy(24,8);
     
660.                         printf("-----------------");
     
661.                         toxy(28,10);
     
662.                         printf("1) 主  食");
     
663.                         toxy(28,12);
     
664.                         printf("2) 副  食");
     
665.                         toxy(28,14);
     
666.                         printf("3) 饮  品");
     
667.                         toxy(28,16);
     
668.                         printf("4）订  单");
     
669.                         toxy(28,18);
     
670.                         printf("5）返  回");
     
671.                         t=getch();
     
672.                         switch(t)
     
673.                         {
     
674.                                 case '1':Order_StapleFood();break;
     
675.                                 case '2':Order_nonStapleFood();break;
     
676.                                 case '3':Order_DrinkBeverage();break;
     
677.                                 case '4':Order_Form(ID,number);break;
     
678.                                 case '5':break;
     
679.                                 default :break;
     
680.                          }
     
681.                          if(t=='5')
     
682.                                  break;
     
683.                 }while(1);
     
684.                 if(t=='5')
     
685.                         break;
     
686.         }while(1);
     
687. }
     
688. 
     
689. 
     
690. void Order_StapleFood()//主食
     
691. {
     
692.         char t;
     
693.         do
     
694.         {
     
695.                 system("cls");
     
696.                 pStapleFood p,head=readStapleFoodFile();
     
697.                 pOrder p1;
     
698.                 p=head;
     
699.                 char foodName[20];
     
700.                 int i=8;
     
701.                 toxy(10,4);
     
702.                 printf("主食菜单");
     
703.                 toxy(6,6);
     
704.                 printf("菜名\t\t\t价格");
     
705.                 toxy(0,7);
     
706.                 printf("-----------------------------------");
     
707.                 while(p!=NULL)
     
708.                 {
     
709.                         toxy(6,i);
     
710.                         printf("%-22s%.2f",p->name,p->price);
     
711.                         i++;
     
712.                         p=p->next;
     
713.                 }
     
714.                 toxy(40,8);
     
715.                 printf("请输入您要点的菜名:");
     
716.                 scanf("%s",foodName);
     
717.                 p=head;
     
718.                 while(p!=NULL&&strcmp(p->name,foodName)!=0)
     
719.                 {
     
720.                         p=p->next;
     
721.                 }
     
722.                 if(p)
     
723.                 {
     
724.                         p1=(pOrder)malloc(Y);
     
725.                         strcpy(p1->name,foodName);
     
726.                         p1->price=p->price;
     
727.                         num++;
     
728.                         if(num==1)
     
729.                         {
     
730.                                 orderHead=p1;
     
731.                                 p2=p1;
     
732.                         }
     
733.                         else
     
734.                         {
     
735.                                 p2->next=p1;
     
736.                                 p2=p1;
     
737.                         }
     
738.                         p2->next=NULL;
     
739.                         toxy(40,10);
     
740.                         printf("点餐成功！是否继续？1.是   2.否");
     
741.                         while(1)
     
742.                         {
     
743.                                 t=getch();
     
744.                                 if(t=='1')
     
745.                                         break;
     
746.                                 else if(t=='2')
     
747.                                         break;
     
748.                         }
     
749.                         if(t=='2')
     
750.                                 break;
     
751.                 }
     
752.                 else
     
753.                 {
     
754.                         toxy(36,10);
     
755.                         printf("没有找到这道菜，请检查您输入的菜名是否正确！");
     
756.                         Sleep(1500);
     
757.                 }
     
758.         }while(1);
     
759.        
     
760. }
     
761. 
     
762. void Order_nonStapleFood()//副食
     
763. {
     
764.         char t;
     
765.         do
     
766.         {
     
767.                 system("cls");
     
768.                 pNon_stapleFood p,head=readNonStapleFoodFile();
     
769.                 pOrder p1;
     
770.                 p=head;
     
771.                 char foodName[20];
     
772.                 int i=8;
     
773.                 toxy(10,4);
     
774.                 printf("副食菜单");
     
775.                 toxy(6,6);
     
776.                 printf("菜名\t\t\t价格");
     
777.                 toxy(0,7);
     
778.                 printf("-----------------------------------");
     
779.                 while(p!=NULL)
     
780.                 {
     
781.                         toxy(6,i);
     
782.                         printf("%-22s%.2f",p->name,p->price);
     
783.                         i++;
     
784.                         p=p->next;
     
785.                 }
     
786.                 toxy(40,8);
     
787.                 printf("请输入您要点的菜名:");
     
788.                 scanf("%s",foodName);
     
789.                 p=head;
     
790.                 while(p!=NULL&&strcmp(p->name,foodName)!=0)
     
791.                 {
     
792.                         p=p->next;
     
793.                 }
     
794.                 if(p)
     
795.                 {
     
796.                         p1=(pOrder)malloc(Y);
     
797.                         strcpy(p1->name,foodName);
     
798.                         p1->price=p->price;
     
799.                         num++;
     
800.                         if(num==1)
     
801.                         {
     
802.                                 orderHead=p1;
     
803.                                 p2=p1;
     
804.                         }
     
805.                         else
     
806.                         {
     
807.                                 p2->next=p1;
     
808.                                 p2=p1;
     
809.                         }
     
810.                         p2->next=NULL;
     
811.                         toxy(36,10);
     
812.                         printf("点餐成功！是否继续？1.是   2.否");
     
813.                         while(1)
     
814.                         {
     
815.                                 t=getch();
     
816.                                 if(t=='1')
     
817.                                         break;
     
818.                                 else if(t=='2')
     
819.                                         break;
     
820.                         }
     
821.                         if(t=='2')
     
822.                                 break;
     
823.                 }
     
824.                 else
     
825.                 {
     
826.                         toxy(36,10);
     
827.                         printf("没有找到这道菜，请检查您输入的菜名是否正确！");
     
828.                         Sleep(1500);
     
829.                 }
     
830.         }while(1);
     
831. }
     
832. 
     
833. void Order_DrinkBeverage()//饮品
     
834. {
     
835.                 char t;
     
836.         do
     
837.         {
     
838.                 system("cls");
     
839.                 pDrinkBeverage p,head=readDrinkBeverageFile();
     
840.                 pOrder p1;
     
841.                 p=head;
     
842.                 char foodName[20];
     
843.                 int i=8;
     
844.                 toxy(10,4);
     
845.                 printf("饮品菜单");
     
846.                 toxy(6,6);
     
847.                 printf("菜名\t\t\t价格");
     
848.                 toxy(0,7);
     
849.                 printf("-----------------------------------");
     
850.                 while(p!=NULL)
     
851.                 {
     
852.                         toxy(6,i);
     
853.                         printf("%-22s%.2f",p->name,p->price);
     
854.                         i++;
     
855.                         p=p->next;
     
856.                 }
     
857.                 toxy(40,8);
     
858.                 printf("请输入您要点的菜名:");
     
859.                 scanf("%s",foodName);
     
860.                 p=head;
     
861.                 while(p!=NULL&&strcmp(p->name,foodName)!=0)
     
862.                 {
     
863.                         p=p->next;
     
864.                 }
     
865.                 if(p)
     
866.                 {
     
867.                         p1=(pOrder)malloc(Y);
     
868.                         strcpy(p1->name,foodName);
     
869.                         p1->price=p->price;
     
870.                         num++;
     
871.                         if(num==1)
     
872.                         {
     
873.                                 orderHead=p1;
     
874.                                 p2=p1;
     
875.                         }
     
876.                         else
     
877.                         {
     
878.                                 p2->next=p1;
     
879.                                 p2=p1;
     
880.                         }
     
881.                         p2->next=NULL;
     
882.                         toxy(36,10);
     
883.                         printf("点餐成功！是否继续？1.是   2.否");
     
884.                         while(1)
     
885.                         {
     
886.                                 t=getch();
     
887.                                 if(t=='1')
     
888.                                         break;
     
889.                                 else if(t=='2')
     
890.                                         break;
     
891.                         }
     
892.                         if(t=='2')
     
893.                                 break;
     
894.                 }
     
895.                 else
     
896.                 {
     
897.                         toxy(36,10);
     
898.                         printf("没有找到这道菜，请检查您输入的菜名是否正确！");
     
899.                         Sleep(1500);
     
900.                 }
     
901.         }while(1);
     
902. }
     
903. 
     
904. void Order_Form(int ID,int number)//订单
     
905. {
     
906.         do
     
907.         {
     
908.                 system("cls");
     
909.                 int i=10;
     
910.                 char t;
     
911.                 float totalPrice=0;
     
912.                 float actualPayment=0;
     
913.                 pOrder p=orderHead;
     
914.                 pUser q,head;
     
915.                 pTable T,Thead;
     
916.                 q=head;
     
917.                 if(orderHead==NULL)
     
918.                 {
     
919.                         toxy(26,8);
     
920.                         printf("您还没有点任何东西，赶紧去点吧！(按任意键返回)");
     
921.                         getch();
     
922.                         break;
     
923.                 }
     
924.                 else
     
925.                 {
     
926.                         toxy(26,6);
     
927.                         printf("我的订单");
     
928.                         toxy(22,8);
     
929.                         printf("菜品名称\t\t价格");
     
930.                         toxy(20,9);
     
931.                         printf("***************************");
     
932.                         while(p!=NULL)
     
933.                         {
     
934.                                 toxy(22,i);
     
935.                                 printf("%-18s%.2f",p->name,p->price);
     
936.                                 i++;
     
937.                                 totalPrice+=p->price;
     
938.                                 p=p->next;
     
939.                         }
     
940.                         head=readUserFile();
     
941.                         q=head;
     
942.                         toxy(20,i);
     
943.                         printf("***************************");
     
944.                         while(q!=NULL&&strcmp(q->userName,_userName)!=0)
     
945.                         {
     
946.                                 q=q->next;
     
947.                         }
     
948.                         if(q)
     
949.                         {
     
950.                                 toxy(24,++i);
     
951.                                 printf("总价：  %.2f",totalPrice);
     
952.                                 if(q->isVIP)
     
953.                                         actualPayment=totalPrice*0.85;
     
954.                                 else
     
955.                                         actualPayment=totalPrice;
     
956.                                 toxy(24,++i);
     
957.                                 printf("实付：  %.2f",actualPayment);
     
958.                         }
     
959.                         toxy(22,++i);
     
960.                         printf("1.确认支付   2.取消订单   3.返回");
     
961.                         while(1)
     
962.                         {
     
963.                                 t=getch();
     
964.                                 if(t=='1'||t=='2'||t=='3')
     
965.                                         break;
     
966.                         }
     
967.                         if(t=='1')
     
968.                         {
     
969.                                 Thead=readTableFile();
     
970.                                 T=Thead;
     
971.                                 while(T!=NULL&&T->ID!=ID)
     
972.                                 {
     
973.                                         T=T->next;
     
974.                                 }
     
975.                                 toxy(24,++i);
     
976.                                 printf("正在支付....");
     
977.                                 if(q->money>=actualPayment)
     
978.                                 {
     
979.                                         q->money-=actualPayment;
     
980.                                         T->People+=number;
     
981.                                         Updata_User(head);
     
982.                                         Updata_Table(Thead);
     
983.                                         Sleep(1500);
     
984.                                         system("cls");
     
985.                                         toxy(24,10);
     
986.                                         printf("支付成功！按任意键返回");
     
987.                                         orderHead=NULL;
     
988.                                         getch();
     
989.                                         break;
     
990.                                 }
     
991.                                 else
     
992.                                 {
     
993.                                         Sleep(1500);
     
994.                                         system("cls");
     
995.                                         toxy(24,10);
     
996.                                         printf("余额不足！按任意键返回");
     
997.                                         getch();
     
998.                                         break;
     
999.                                 }
     
1000.                         }
      
1001.                         else if(t=='2')
      
1002.                         {
      
1003.                                 orderHead=NULL;
      
1004.                                 break;
      
1005.                         }
      
1006.                         else if(t=='3')
      
1007.                                 break;
      
1008.                 }
      
1009.         }while(1);
      
1010. }
      
1011. 
      
1012. void User_List_Table()//餐桌列表
      
1013. {
      
1014.         system("cls");
      
1015.         pTable p,head;
      
1016.         head=readTableFile();
      
1017.         p=head;
      
1018.         int i=11;
      
1019.         toxy(32,6);
      
1020.         printf("餐桌列表(按任意键继续)");
      
1021.         toxy(22,8);
      
1022.         printf("餐桌编号 | 可坐人数 | 已坐人数");
      
1023.         toxy(20,9);
      
1024.         printf("--------------------------------------");
      
1025.         while(p!=NULL)
      
1026.         {
      
1027.                 toxy(26,i);
      
1028.                 printf("%-10d%-10d%d",p->ID,p->count,p->People);
      
1029.                 i++;
      
1030.                 p=p->next;
      
1031.         }
      
1032.         getch();
      
1033. }
      
1034. 
      
1035. void Apply_VIP_Menu()//办理会员
      
1036. {
      
1037.         char t; //t用于选择
      
1038.         do
      
1039.         {
      
1040.                 system("cls");
      
1041.                 system("color 75");
      
1042.                 HideCursor(0);
      
1043.                 pUser head=readUserFile();//从文件中读取用户信息，返回一个表头地址
      
1044.                 toxy(32,6);
      
1045.                 printf("会员办理");
      
1046.                 toxy(30,8);
      
1047.                 printf("1)  充值 ");
      
1048.                 toxy(30,10);
      
1049.                 printf("2)  办理会员");
      
1050.                 toxy(30,12);
      
1051.                 printf("3)  返回");
      
1052.                 t=getch();
      
1053.                 switch(t)
      
1054.                 {
      
1055.                         case '1':Add_money(head);break;
      
1056.                         case '2':Apply_VIP(head);break;
      
1057.                         case '3':break;
      
1058.                         default :break;
      
1059.                 }
      
1060.                 if(t=='3')//如果输入3，则跳出循环，该函数生命周期结束，回到上一级菜单
      
1061.                         break;
      
1062.         }while(1);
      
1063. }
      
1064. 
      
1065. void Add_money(pUser head)//充值
      
1066. {
      
1067.         float money;//输入要充值的钱
      
1068.         pUser p;
      
1069.         p=head;//head为从 上一级菜单传过来的参数，为用户信息链表的头结点
      
1070.         while(p!=NULL&&strcmp(p->userName,_userName)!=0)//遍历链表，寻找当前登录账户的信息
      
1071.         {
      
1072.                 p=p->next;
      
1073.         }
      
1074.         while(1)
      
1075.         {
      
1076.                 system("cls");
      
1077.                 system("color 76");
      
1078.                 toxy(32,6);
      
1079.                 printf("南航餐饮充值中心");
      
1080.                 if(p!=NULL)
      
1081.                 {
      
1082.                         if(p->isVIP==0)//如果不是会员
      
1083.                         {
      
1084.                                 toxy(20,8);
      
1085.                                 printf("对不起，您还不是会员，请先办理会员后再来充值！");
      
1086.                                 toxy(32,10);
      
1087.                                 printf("请按任意键返回!");
      
1088.                                 break;
      
1089.                         }
      
1090.                         else if(p->isVIP==1)//如果是会员
      
1091.                         {
      
1092.                                 HideCursor(1);
      
1093.                                 toxy(32,8);
      
1094.                                 printf("请输入充值金额（一次不少于200）：");
      
1095.                                 scanf("%f",&money);
      
1096.                                 if(money>=200)//如果充值金额大于200
      
1097.                                 {
      
1098.                                         p->money+=money;
      
1099.                                         toxy(32,10);
      
1100.                                         printf("正在充值....");
      
1101.                                         Updata_User(head);//更新用户表
      
1102.                                         toxy(32,10);
      
1103.                                         printf("充值成功    ");
      
1104.                                         toxy(32,12);
      
1105.                                         printf("请按任意键返回!");
      
1106.                                         break;
      
1107.                                 }
      
1108.                                 else//如果充值金额小于200
      
1109.                                 {
      
1110.                                         toxy(32,10);
      
1111.                                         printf("一次至少充值200元！");
      
1112.                                         Sleep(1500);
      
1113.                                         continue;
      
1114.                                 }
      
1115.                         }
      
1116.                 }
      
1117.         }
      
1118.         getch();
      
1119. }
      
1120. 
      
1121. void Apply_VIP(pUser head)//办理会员
      
1122. {
      
1123.         system("cls");
      
1124.         system("color 76");
      
1125.         pUser p=head;//head为从 上一级菜单传过来的参数，为用户信息链表的头结点
      
1126.         char t;
      
1127.         float money;
      
1128.         toxy(32,6);
      
1129.         printf("南航餐饮会员办理中心");
      
1130.         while(p!=NULL&&strcmp(p->userName,_userName)!=0)//遍历链表，寻找当前登录账户的信息
      
1131.         {
      
1132.                 p=p->next;
      
1133.         }
      
1134.         do
      
1135.         {
      
1136.                 if(p!=NULL)
      
1137.                 {
      
1138.                         if(p->isVIP==1)//如果已经是会员
      
1139.                         {
      
1140.                                 toxy(20,8);
      
1141.                                 printf("您已是本店尊贵会员，无需再次办理！");
      
1142.                                 toxy(32,10);
      
1143.                                 printf("请按任意键返回!");
      
1144.                                 getch();
      
1145.                                 break;
      
1146.                         }
      
1147.                         else if(p->isVIP==0)//如果还没办理会员
      
1148.                         {
      
1149.                                 toxy(30,8);
      
1150.                                 printf("提示：");
      
1151.                                 toxy(30,9);
      
1152.                                 printf("1.办理会员至少充值500");
      
1153.                                 toxy(30,10);
      
1154.                                 printf("2.冲500送200，冲1000送500");
      
1155.                                 toxy(32,12);
      
1156.                                 printf("是否确认办理会员？");
      
1157.                                 toxy(32,13);
      
1158.                                 printf("1.是\t2.否");
      
1159.                                 while(1)
      
1160.                                 {
      
1161.                                         t=getch();
      
1162.                                         if(t=='1')
      
1163.                                                 break;
      
1164.                                         else if(t=='2')
      
1165.                                                 break;
      
1166.                                 }
      
1167.                                 if(t=='1')
      
1168.                                 {
      
1169.                                         while(1)
      
1170.                                         {
      
1171.                                                 system("cls");
      
1172.                                                 HideCursor(1);
      
1173.                                                 toxy(32,10);
      
1174.                                                 printf("请输入充值金额：");
      
1175.                                                 scanf("%f",&money);
      
1176.                                                 if(money>=500&&money<1000)
      
1177.                                                 {
      
1178.                                                         money+=200;
      
1179.                                                         p->money+=money;
      
1180.                                                         p->isVIP=1;
      
1181.                                                         Updata_User(head);
      
1182.                                                         toxy(32,12);
      
1183.                                                         printf("恭喜，您已成为本店尊贵会员！");
      
1184.                                                         toxy(32,14);
      
1185.                                                         printf("请按任意键返回主菜单");
      
1186.                                                         getch();
      
1187.                                                         User_Menu();
      
1188.                                                 }
      
1189.                                                 else if(money>=1000)
      
1190.                                                 {
      
1191.                                                         money+=500;
      
1192.                                                         p->money+=money;
      
1193.                                                         p->isVIP=1;
      
1194.                                                         Updata_User(head);
      
1195.                                                         toxy(32,12);
      
1196.                                                         printf("恭喜，您已成为本店尊贵会员！");
      
1197.                                                         toxy(32,14);
      
1198.                                                         printf("请按任意键返回主菜单");
      
1199.                                                         getch();
      
1200.                                                         User_Menu();
      
1201.                                                 }
      
1202.                                                 else
      
1203.                                                 {
      
1204.                                                         toxy(32,12);
      
1205.                                                         printf("办理会员至少充值500");
      
1206.                                                         Sleep(2000);
      
1207.                                                 }
      
1208.                                         }
      
1209.                                 }
      
1210.                                 else if(t=='2')
      
1211.                                         break;
      
1212.                         }
      
1213.                 }
      
1214.         }while(1);
      
1215. }
      
1216. 
      
1217. void Updata_User(pUser head)//更新文件
      
1218. {
      
1219.         FILE *fp;
      
1220.         pUser p=head->next;                           //使p指向第二个结点
      
1221.         fp=fopen("User.txt","w");                  //先清空原文件内容再将修改后的信息写入文件
      
1222.         if(fp==NULL)
      
1223.         {
      
1224.                 printf("cannot open file\n");
      
1225.         }
      
1226.         if(fwrite(head,M,1,fp)!=1)                 //将head所指向的数据写入fp所指向的文件
      
1227.         {
      
1228.                 printf("file write error\n");
      
1229.         }
      
1230.         fclose(fp);                         //关闭文件
      
1231.         fp=fopen("User.txt","a");          // 打开User.txt文件，方式为追加
      
1232.         while(p!=NULL)                    //p不为空就执行循环体
      
1233.         {
      
1234.                 if(fwrite(p,M,1,fp)!=1)            //将p所指向的1个大小为N的数据结构写入fp所指向的文件
      
1235.             {
      
1236.                         printf("file write error\n");
      
1237.             }
      
1238.             p=p->next;                     //使p指向下一个结点
      
1239.         }
      
1240.         fclose(fp);              //关闭文件
      
1241. }
      
1242. 
      
1243. void Amend_passWord()//修改密码
      
1244. {
      
1245.         system("cls");         //清屏
      
1246.         HideCursor(0);  //隐藏光标，看着更舒服
      
1247.         pUser p,head;      
      
1248.         head=readUserFile();
      
1249.     do
      
1250.     {
      
1251.             p=head;
      
1252.             char password[18],newpassword[18],t,k,*q1,*q2;
      
1253.             int i=0;
      
1254.             toxy(34,5);          //将光标移动到坐标为（50，5）的位置
      
1255.                 printf("南航餐饮点餐系统");
      
1256.                 toxy(34,8);
      
1257.                 printf("修改密码");
      
1258.                 toxy(32,10);
      
1259.                 printf("请输入旧密码：");
      
1260.                 q1=HidePassword();
      
1261.                 strcpy(password,q1);
      
1262.                 toxy(32,12);
      
1263.                 printf("请输入新密码：");
      
1264.                 q2=HidePassword();
      
1265.                 strcpy(newpassword,q2);
      
1266.                 while(p!=NULL&&strcmp(p->userName,_userName)!=0)//遍历链表，寻找当前登陆账户的账号
      
1267.                 {
      
1268.                         p=p->next;
      
1269.                 }
      
1270.                 if(p!=NULL)                   //如果p不为空
      
1271.                 {
      
1272.                         if(strcmp(p->passWord,password)==0)          //如果旧密码输入正确
      
1273.                         {
      
1274.                                 strcpy(p->passWord,newpassword);         //将旧密码改为新密码
      
1275.                                 break;                                   //跳出循环
      
1276.                         }
      
1277.                         else                                         //如果旧密码输入错误
      
1278.                         {
      
1279.                                 system("cls");
      
1280.                                 toxy(30,8);
      
1281.                                 printf("--------------------------");
      
1282.                                 toxy(30,9);
      
1283.                                 printf("|                        |");
      
1284.                                 toxy(30,10);
      
1285.                                 printf("|  密码错误！是否继续？  |");
      
1286.                                 toxy(30,11);
      
1287.                                 printf("|                        |");
      
1288.                                 toxy(30,12);
      
1289.                                 printf("|  1.是           2.否   |");
      
1290.                                 toxy(30,13);
      
1291.                                 printf("|                        |");
      
1292.                                 toxy(30,14);
      
1293.                                 printf("--------------------------");
      
1294.                                 while(1)
      
1295.                                 {
      
1296.                                         t=getch();                              //输入t
      
1297.                                         if(t=='1')
      
1298.                                         {
      
1299.                                                 system("cls");
      
1300.                                                 break;
      
1301.                                         }
      
1302.                                         else if(t=='2')
      
1303.                                           User_Menu();
      
1304.                                 }
      
1305.                         }
      
1306.                 }
      
1307.         }while(1);                                //永远为真
      
1308.         Updata_User(head);//修改密码
      
1309.         toxy(32,14);
      
1310.         printf("修改成功！正在跳转...");
      
1311.         Sleep(500);       //暂停0.5秒
      
1312. }
      
1313. 
      
1314. void User_Wallet()//我的钱包
      
1315. {
      
1316.         system("cls");
      
1317.         system("color 78");
      
1318.         pUser p,head;
      
1319.         head=readUserFile();
      
1320.         p=head;
      
1321.         while(p!=NULL&&strcmp(p->userName,_userName)!=0)
      
1322.         {
      
1323.                 p=p->next;
      
1324.         }
      
1325.         if(p!=NULL)
      
1326.         {
      
1327.                 toxy(32,10);
      
1328.                 printf("账户余额为：%.2f",p->money);
      
1329.                 toxy(32,12);
      
1330.                 printf("请按任意键返回");
      
1331.         }
      
1332.         getch();
      
1333. }
      
1334. 
      
1335. void Change()//切换账号
      
1336. {
      
1337.         system("cls");
      
1338.         Default();
      
1339. }
      
1340. 
      
1341. void Exit()//退出点餐系统
      
1342. {
      
1343.         char t;
      
1344.         toxy(30,10);
      
1345.         printf("-----------------------");
      
1346.         toxy(30,11);
      
1347.         printf("|   您确定要退出吗？  |");
      
1348.         toxy(30,13);
      
1349.         printf("| 1.确定     2.取消   |");
      
1350.         toxy(30,14);
      
1351.         printf("-----------------------");
      
1352.         while(1)
      
1353.         {
      
1354.                 t=getch();         //输入t
      
1355.                 switch(t)
      
1356.                 {
      
1357.                         case '1':
      
1358.                         system("cls");
      
1359.                         toxy(32,10);
      
1360.                         printf("正在安全退出....");
      
1361.                         Sleep(1000);     //暂停1秒
      
1362.                         system("cls");
      
1363.                         toxy(32,10);
      
1364.                         printf("已安全退出软件");
      
1365.                         toxy(32,12);
      
1366.                         printf("谢谢使用！");
      
1367.                         toxy(32,14);
      
1368.                         printf("by-by^_^");
      
1369.                         exit(0);  break; //终止程序
      
1370.                         case '2':
      
1371.                          break;   //调用函数，进入菜单
      
1372.                         default :break;
      
1373.                 }
      
1374.                 if(t=='2')
      
1375.                         break;
      
1376.         }
      
1377. }
      
1378. 
      
1379. void Administrator_Menu()//管理员菜单
      
1380. {
      
1381.         char t;//用于选择菜单选项
      
1382.         do
      
1383.         {       
      
1384.                 system("cls");
      
1385.                 HideCursor(0); //隐藏光标
      
1386.                 system("color 74");
      
1387.                 toxy(32,3);
      
1388.                 printf("南航餐饮管理系统！");
      
1389.                 toxy(32,4);
      
1390.                 printf("当前管理员：%s",_userName);
      
1391.                 toxy(30,5);
      
1392.                 printf("*********************");
      
1393.                 toxy(32,7);
      
1394.                 printf("|  1.菜品  信息  |");
      
1395.                 toxy(32,9);
      
1396.                 printf("|  2.餐桌  管理  |");
      
1397.                 toxy(32,11);
      
1398.                 printf("|  3.查看  用户  |");
      
1399.                 toxy(32,13);
      
1400.                 printf("|  4.本店  会员  |");
      
1401.                 toxy(32,15);
      
1402.                 printf("|  5.设置管理员  |");
      
1403.                 toxy(32,17);
      
1404.                 printf("|  6.修改  密码  |");
      
1405.                 toxy(32,19);
      
1406.                 printf("|  7.切换  账号  |");
      
1407.                 toxy(32,21);
      
1408.                 printf("|  8.退出  系统  |");
      
1409.                 t=getch();//不回显函数，输入一个值
      
1410.                 switch(t)
      
1411.                 {
      
1412.                         case '1':Food();break;
      
1413.                         case '2':Table();break;
      
1414.                         case '3':Check_User();break;
      
1415.                         case '4':All_VIP();break;
      
1416.                         case '5':Setup_administrator();break;
      
1417.                         case '6':Amend_passWord();break;
      
1418.                         case '7':Change();break;
      
1419.                         case '8':Exit();break;
      
1420.                         default :break;
      
1421.                 }
      
1422.         }while(1);//永远 为真
      
1423. }
      
1424. 
      
1425. void Administrator_Login()//管理员登录
      
1426. {
      
1427.         char *q,t,c;//q指针用于接收 *HidePassword()函数返回的指向密码的指针，t和c均用于选择
      
1428.         pUser p=readUserFile();//从文件中读取用户信息，返回一个表头地址
      
1429.         do
      
1430.         {
      
1431.                 HideCursor(1);//显示管光标
      
1432.                 system("cls");//清屏
      
1433.                 system("color 73");//设置颜色
      
1434.                 toxy(28,8);
      
1435.                 printf("南航餐饮管理员登录界面");
      
1436.                 toxy(26,9);
      
1437.                 printf("-----------------------------");
      
1438.                 toxy(32,11);
      
1439.                 printf("用户名:");
      
1440.                 toxy(32,13);
      
1441.                 printf("密  码:");
      
1442.                 toxy(40,11);
      
1443.                 scanf("%s",_userName);
      
1444.                 toxy(40,13);
      
1445.                 q=HidePassword();//输入密码
      
1446.                 strcpy(_passWord,q);//将获得的密码复制给_passWord[]数组
      
1447.                 while(p!=NULL&&strcmp(p->userName,_userName)!=0)   //遍历链表，寻找当前输入的账户的账号
      
1448.                 {
      
1449.                         p=p->next;
      
1450.                 }
      
1451.                 if(p!=NULL)   //如果p不为空
      
1452.                 {
      
1453.                     if(strcmp(p->passWord,_passWord)==0&&p->isAdministrator==1)     //如果输入的密码正确
      
1454.                         {
      
1455.                                 toxy(32,16);
      
1456.                                 printf("正在登陆....");
      
1457.                                 Sleep(500);      //暂停0.5秒
      
1458.                                 system("cls");
      
1459.                                 toxy(32,10);
      
1460.                                 printf("登陆成功！");
      
1461.                                 break;    //跳出循环
      
1462.                         }
      
1463.                         else      //如果输入的密码错误
      
1464.                         {
      
1465.                                 toxy(32,16);
      
1466.                                 printf("正在登陆....");
      
1467.                                 Sleep(500);
      
1468.                                 system("cls");
      
1469.                                 toxy(30,8);
      
1470.                                 printf("-------------------------");
      
1471.                                 toxy(30,9);
      
1472.                                 printf("|                       |");
      
1473.                                 toxy(30,10);
      
1474.                                 printf("| 密码错误！是否继续？  |");
      
1475.                                 toxy(30,12);
      
1476.                                 printf("| 1.是             2.否 |");
      
1477.                                 toxy(30,13);
      
1478.                                 printf("|                       |");
      
1479.                                 toxy(30,14);
      
1480.                                 printf("-------------------------");
      
1481.                                 while(1)//无限循环为防止其他按键干扰
      
1482.                                 {
      
1483.                                         t=getch();  //输入t   
      
1484.                                         if(t=='1')         
      
1485.                                         {
      
1486.                                                 system("cls");  //清屏
      
1487.                                                 break;
      
1488.                                         }
      
1489.                                         else if(t=='2')     //如果输入t为n，进入开始界面
      
1490.                                         {
      
1491.                                                 system("cls");  //清屏
      
1492.                                                 Default();break;
      
1493.                                         }
      
1494.                                 }
      
1495.                         }
      
1496.            }
      
1497.            else              //如果p为空，即输入的账号不正确
      
1498.            {
      
1499.                        toxy(32,16);
      
1500.                        printf("正在登陆....");
      
1501.                        Sleep(500);
      
1502.                        system("cls");
      
1503.                        toxy(30,8);
      
1504.                        printf("-------------------------");
      
1505.                        toxy(30,9);
      
1506.                        printf("|                       |");
      
1507.                            toxy(30,10);
      
1508.                         printf("|  账号错误！是否继续？ |");
      
1509.                         toxy(30,11);
      
1510.                         printf("|                       |");
      
1511.                         toxy(30,12);
      
1512.                         printf("|  1.是            2.否 |");
      
1513.                         toxy(30,13);
      
1514.                         printf("|                       |");
      
1515.                         toxy(30,14);
      
1516.                         printf("-------------------------");
      
1517.                         while(1)      //死循环防止其他按键干扰
      
1518.                         {
      
1519.                                 c=getch();
      
1520.                                 if(c=='1')
      
1521.                                 {  
      
1522.                                         system("cls");
      
1523.                                         break;
      
1524.                                 }
      
1525.                                 else if(c=='2')
      
1526.                                 {
      
1527.                                         system("cls");  //清屏
      
1528.                                         Default();
      
1529.                                 }
      
1530.                         }
      
1531.            }
      
1532.         }while(1);
      
1533.         Sleep(500);      //暂停0.5秒
      
1534.     Administrator_Menu();         //账号密码均正确，进入管理员主菜单
      
1535. }
      
1536. 
      
1537. void Food()//菜品信息
      
1538. {
      
1539.         system("color 74");
      
1540.         char t;
      
1541.         do
      
1542.         {
      
1543.                 system("cls");
      
1544.                 toxy(32,6);
      
1545.                 printf("菜品信息");
      
1546.                 toxy(28,7);
      
1547.                 printf("-----------------");
      
1548.                 toxy(30,9);
      
1549.                 printf(" 1) 添加菜单");
      
1550.                 toxy(30,11);
      
1551.                 printf(" 2) 菜单列表");
      
1552.                 toxy(30,13);
      
1553.                 printf(" 3) 返回上一级");
      
1554.                 t=getch();
      
1555.                 switch(t)
      
1556.                 {
      
1557.                         case '1':Add_Food();break;
      
1558.                         case '2':List_Food();break;
      
1559.                         case '3':break;
      
1560.                         default :break;
      
1561.                 }
      
1562.                 if(t=='3')
      
1563.                         break;
      
1564.         }while(1);
      
1565. }
      
1566. 
      
1567. void save_stapleFood(pStapleFood p)//保存主食信息
      
1568. {
      
1569.         FILE *fp;       //文件指针
      
1570.         fp=fopen("StapleFood.txt","a+");    //以追加的方式打开文件
      
1571.         if(fp==NULL)
      
1572.         {
      
1573.                 printf("cannot open file\n");
      
1574.         }
      
1575.         if(fwrite(p,N,1,fp)!=1)    //将p1所指向的1个大小为N的数据结构写入fp所指向的文件中
      
1576.         {
      
1577.                 printf("file write error\n");
      
1578.         }
      
1579.         fclose(fp);        //关闭文件
      
1580. }
      
1581. 
      
1582. void save_non_stapleFood(pNon_stapleFood p)//保存副食信息
      
1583. {
      
1584.         FILE *fp;       //文件指针
      
1585.         fp=fopen("non_StapleFood.txt","a+");    //以追加的方式打开文件
      
1586.         if(fp==NULL)
      
1587.         {
      
1588.                 printf("cannot open file\n");
      
1589.         }
      
1590.         if(fwrite(p,P,1,fp)!=1)    //将p1所指向的1个大小为N的数据结构写入fp所指向的文件中
      
1591.         {
      
1592.                 printf("file write error\n");
      
1593.         }
      
1594.         fclose(fp);        //关闭文件
      
1595. }
      
1596. 
      
1597. void save_drinkBeverage(pDrinkBeverage p)//保存饮品信息
      
1598. {
      
1599.         FILE *fp;       //文件指针
      
1600.         fp=fopen("DrinkBeverage.txt","a+");    //以追加的方式打开文件
      
1601.         if(fp==NULL)
      
1602.         {
      
1603.                 printf("cannot open file\n");
      
1604.         }
      
1605.         if(fwrite(p,Q,1,fp)!=1)    //将p1所指向的1个大小为N的数据结构写入fp所指向的文件中
      
1606.         {
      
1607.                 printf("file write error\n");
      
1608.         }
      
1609.         fclose(fp);        //关闭文件
      
1610. }
      
1611. 
      
1612. pStapleFood readStapleFoodFile()//从主食文件中读取用户信息，返回一个表头地址
      
1613. {
      
1614.         FILE *fp;       //文件指针
      
1615.         int n=0;//记录链表 的结点数
      
1616.         pStapleFood head=NULL;//定义头指针
      
1617.         pStapleFood p2,p,pre;
      
1618.         fp=fopen("StapleFood.txt","a+");     //以只读的方式打开文件
      
1619.         if(fp==NULL)
      
1620.         {
      
1621.                 printf("cannot open file\n");
      
1622.         }
      
1623.         else
      
1624.         {
      
1625.                 while(!feof(fp))        //判断文件位置标志是否移动到文件末尾
      
1626.                 {
      
1627.                     n++;
      
1628.                         p=(pStapleFood)malloc(N); //向内存申请一段空间
      
1629.                    fread(p,N,1,fp);     //将fp所指向的文件中的内容赋给p
      
1630.                    if(n==1)
      
1631.                    {
      
1632.                       head=p;
      
1633.                       p2=p;
      
1634.                     }
      
1635.                     else             //创建链表
      
1636.                     {
      
1637.                             pre=p2;
      
1638.                             p2->next=p;
      
1639.                             p2=p;
      
1640.                         }
      
1641.             }
      
1642.             p2->next=NULL;
      
1643.         }
      
1644.         if(n<=2)
      
1645.                 head->next=NULL;
      
1646.         else
      
1647.                 pre->next=NULL;
      
1648.     fclose(fp);    //关闭文件
      
1649.     return head;   //返回头指针
      
1650. }
      
1651. 
      
1652. pNon_stapleFood readNonStapleFoodFile()//从副食文件中读取用户信息，返回一个表头地址
      
1653. {
      
1654.         FILE *fp;       //文件指针
      
1655.         int n=0;//记录链表 的结点数
      
1656.         pNon_stapleFood head=NULL;//定义头指针
      
1657.         pNon_stapleFood p2,p,pre;
      
1658.         fp=fopen("non_StapleFood.txt","a+");     //以只读的方式打开文件
      
1659.         if(fp==NULL)
      
1660.         {
      
1661.                 printf("cannot open file\n");
      
1662.         }
      
1663.         else
      
1664.         {
      
1665.                 while(!feof(fp))        //判断文件位置标志是否移动到文件末尾
      
1666.                 {
      
1667.                     n++;
      
1668.                         p=(pNon_stapleFood)malloc(P); //向内存申请一段空间
      
1669.                    fread(p,P,1,fp);     //将fp所指向的文件中的内容赋给p
      
1670.                    if(n==1)
      
1671.                    {
      
1672.                       head=p;
      
1673.                       p2=p;
      
1674.                     }
      
1675.                     else             //创建链表
      
1676.                     {
      
1677.                             pre=p2;
      
1678.                             p2->next=p;
      
1679.                             p2=p;
      
1680.                         }
      
1681.             }
      
1682.             p2->next=NULL;
      
1683.         }
      
1684.         if(n<=2)
      
1685.                 head->next=NULL;
      
1686.         else
      
1687.                 pre->next=NULL;
      
1688.     fclose(fp);    //关闭文件
      
1689.     return head;   //返回头指针
      
1690. }
      
1691. 
      
1692. pDrinkBeverage readDrinkBeverageFile()//从饮品文件中读取用户信息，返回一个表头地址
      
1693. {
      
1694.         FILE *fp;       //文件指针
      
1695.         int n=0;//记录链表 的结点数
      
1696.         pDrinkBeverage head=NULL;//定义头指针
      
1697.         pDrinkBeverage p2,p,pre;
      
1698.         fp=fopen("DrinkBeverage.txt","a+");     //以只读的方式打开文件
      
1699.         if(fp==NULL)
      
1700.         {
      
1701.                 printf("cannot open file\n");
      
1702.         }
      
1703.         else
      
1704.         {
      
1705.                 while(!feof(fp))        //判断文件位置标志是否移动到文件末尾
      
1706.                 {
      
1707.                     n++;
      
1708.                         p=(pDrinkBeverage)malloc(Q); //向内存申请一段空间
      
1709.                    fread(p,Q,1,fp);     //将fp所指向的文件中的内容赋给p
      
1710.                    if(n==1)
      
1711.                    {
      
1712.                       head=p;
      
1713.                       p2=p;
      
1714.                     }
      
1715.                     else             //创建链表
      
1716.                     {
      
1717.                             pre=p2;
      
1718.                             p2->next=p;
      
1719.                             p2=p;
      
1720.                         }
      
1721.             }
      
1722.             p2->next=NULL;
      
1723.         }
      
1724.         if(n<=2)
      
1725.                 head->next=NULL;
      
1726.         else
      
1727.                 pre->next=NULL;
      
1728.     fclose(fp);    //关闭文件
      
1729.     return head;   //返回头指针
      
1730. }
      
1731. 
      
1732. void Add_Food()  //添加菜单
      
1733. {
      
1734.         HideCursor(1);//显示光标
      
1735.         pStapleFood p1;//主食
      
1736.         pNon_stapleFood p2;//副食
      
1737.         pDrinkBeverage p3;//饮品
      
1738.         char name[20];
      
1739.         float price=0;
      
1740.         int type=1;
      
1741.         char t;
      
1742.         do
      
1743.         {
      
1744.                 system("cls");
      
1745.                 p1=(pStapleFood)malloc(N);
      
1746.                 p2=(pNon_stapleFood)malloc(P);
      
1747.                 p3=(pDrinkBeverage)malloc(Q);
      
1748.                 toxy(30,6);
      
1749.                 printf("请输入菜名:");
      
1750.                 toxy(30,8);
      
1751.                 printf("请输入价格:");
      
1752.                 toxy(30,10);
      
1753.                 printf("请输入类型:");
      
1754.                 toxy(30,12);
      
1755.                 printf("(1:主食  2.副食  3.饮品)");
      
1756.                 toxy(42,6);
      
1757.                 scanf("%s",name);
      
1758.                 toxy(42,8);
      
1759.                 scanf("%f",&price);
      
1760.                 toxy(42,10);
      
1761.                 scanf("%d",&type);
      
1762.                 if(type==1)
      
1763.                 {
      
1764.                         strcpy(p1->name,name);
      
1765.                         p1->price=price;
      
1766.                         save_stapleFood(p1);
      
1767.                 }
      
1768.                 else if(type==2)
      
1769.                 {
      
1770.                         strcpy(p2->name,name);
      
1771.                         p2->price=price;
      
1772.                         save_non_stapleFood(p2);
      
1773.                 }
      
1774.                 else if(type==3)
      
1775.                 {
      
1776.                         strcpy(p3->name,name);
      
1777.                         p3->price=price;
      
1778.                         save_drinkBeverage(p3);
      
1779.                 }
      
1780.                 toxy(28,14);
      
1781.                 printf("添加成功！是否继续？(1.是  2.否)");
      
1782.                 while(1)
      
1783.                 {
      
1784.                         t=getch();
      
1785.                         if(t=='1')
      
1786.                                 break;
      
1787.                         else if(t=='2')
      
1788.                                 break;
      
1789.                 }
      
1790.                 if(t=='2')
      
1791.                         break;
      
1792.         }while(1);
      
1793.        
      
1794. }
      
1795. 
      
1796. void List_Food()  //菜单列表
      
1797. {
      
1798.         system("cls");
      
1799.         int i=8;
      
1800.         toxy(30,4);
      
1801.         printf("菜单列表(按任意键继续)");
      
1802.         pStapleFood p1;//主食
      
1803.         pNon_stapleFood p2;//副食
      
1804.         pDrinkBeverage p3;//饮品
      
1805.         p1=readStapleFoodFile();//从主食文件中读取用户信息，返回一个表头地址
      
1806.         p2=readNonStapleFoodFile();//从副食文件中读取用户信息，返回一个表头地址
      
1807.         p3=readDrinkBeverageFile();//从饮品文件中读取用户信息，返回一个表头地址
      
1808.         toxy(26,6);
      
1809.         printf("菜名\t\t\t价格");
      
1810.         toxy(20,7);
      
1811.         printf("-----------------------------------");
      
1812.         toxy(24,i);
      
1813.         printf("主食：");
      
1814.         i++;
      
1815.         while(p1!=NULL)
      
1816.         {
      
1817.                 toxy(26,i);
      
1818.                 printf("%-22s%.2f",p1->name,p1->price);
      
1819.                 i++;
      
1820.                 p1=p1->next;
      
1821.         }
      
1822.         toxy(24,i);
      
1823.         printf("副食：");
      
1824.         i++;
      
1825.         while(p2!=NULL)
      
1826.         {
      
1827.                 toxy(26,i);
      
1828.                 printf("%-22s%.2f",p2->name,p2->price);
      
1829.                 i++;
      
1830.                 p2=p2->next;
      
1831.         }
      
1832.         toxy(24,i);
      
1833.         printf("饮品：");
      
1834.         i++;
      
1835.         while(p3!=NULL)
      
1836.         {
      
1837.                 toxy(26,i);
      
1838.                 printf("%-22s%.2f",p3->name,p3->price);
      
1839.                 i++;
      
1840.                 p3=p3->next;
      
1841.         }
      
1842.         getch();
      
1843. }
      
1844. 
      
1845. void Table()//餐桌管理
      
1846. {
      
1847.         char t;
      
1848.         do
      
1849.         {
      
1850.                 system("cls");
      
1851.                 HideCursor(0);
      
1852.                 toxy(32,4);
      
1853.                 printf("餐桌管理");
      
1854.                 toxy(26,5);
      
1855.                 printf("-------------------");
      
1856.                 toxy(30,7);
      
1857.                 printf("1) 添加餐桌");
      
1858.                 toxy(30,9);
      
1859.                 printf("2) 餐桌列表");
      
1860.                 toxy(30,11);
      
1861.                 printf("3) 清理餐桌");
      
1862.                 toxy(30,13);
      
1863.                 printf("4) 返回上一级");
      
1864.                 t=getch();
      
1865.                 switch(t)
      
1866.                 {
      
1867.                         case '1':Add_Table();break;
      
1868.                         case '2':Administrator_List_Table();break;
      
1869.                         case '3':Clear_Table();break;
      
1870.                         case '4':break;
      
1871.                         default :break;
      
1872.                 }
      
1873.                 if(t=='4')
      
1874.                         break;
      
1875.         }while(1);
      
1876. }
      
1877. 
      
1878. void save_Table(pTable p)//保存餐桌信息
      
1879. {
      
1880.         FILE *fp;       //文件指针
      
1881.         fp=fopen("Table.txt","a+");    //以追加的方式打开文件
      
1882.         if(fp==NULL)
      
1883.         {
      
1884.                 printf("cannot open file\n");
      
1885.         }
      
1886.         if(fwrite(p,X,1,fp)!=1)    //将p1所指向的1个大小为N的数据结构写入fp所指向的文件中
      
1887.         {
      
1888.                 printf("file write error\n");
      
1889.         }
      
1890.         fclose(fp);        //关闭文件
      
1891. }
      
1892. 
      
1893. pTable readTableFile()//从餐桌文件中读取用户信息，返回一个表头地址
      
1894. {
      
1895.         FILE *fp;       //文件指针
      
1896.         int n=0;//记录链表 的结点数
      
1897.         pTable head=NULL;//定义头指针
      
1898.         pTable p2,p,pre;
      
1899.         fp=fopen("Table.txt","a+");     //以只读的方式打开文件
      
1900.         if(fp==NULL)
      
1901.         {
      
1902.                 printf("cannot open file\n");
      
1903.         }
      
1904.         else
      
1905.         {
      
1906.                 while(!feof(fp))        //判断文件位置标志是否移动到文件末尾
      
1907.                 {
      
1908.                     n++;
      
1909.                         p=(pTable)malloc(X); //向内存申请一段空间
      
1910.                    fread(p,X,1,fp);     //将fp所指向的文件中的内容赋给p
      
1911.                    if(n==1)
      
1912.                    {
      
1913.                       head=p;
      
1914.                       p2=p;
      
1915.                     }
      
1916.                     else             //创建链表
      
1917.                     {
      
1918.                             pre=p2;
      
1919.                             p2->next=p;
      
1920.                             p2=p;
      
1921.                         }
      
1922.             }
      
1923.             p2->next=NULL;
      
1924.         }
      
1925.         if(n<=2)
      
1926.                 head->next=NULL;
      
1927.         else
      
1928.                 pre->next=NULL;
      
1929.     fclose(fp);    //关闭文件
      
1930.     return head;   //返回头指针
      
1931. }
      
1932. 
      
1933. void Add_Table()//添加餐桌
      
1934. {
      
1935.         HideCursor(1);//显示光标
      
1936.         pTable p,p1;
      
1937.         p1=readTableFile();
      
1938.         char t;
      
1939.         int ID;
      
1940.         int count;
      
1941.         do
      
1942.         {
      
1943.                 system("cls");
      
1944.                 p=(pTable)malloc(X);
      
1945.                 toxy(26,6);
      
1946.                 printf("请输入餐桌编号:");
      
1947.                 toxy(26,8);
      
1948.                 printf("请输入可坐人数:");
      
1949.                 toxy(42,6);
      
1950.                 scanf("%d",&ID);
      
1951.                 toxy(42,8);
      
1952.                 scanf("%d",&count);
      
1953.                 while(p1!=NULL&&p1->ID!=ID)
      
1954.                 {
      
1955.                         p1=p1->next;
      
1956.                 }
      
1957.                 if(p1!=NULL)
      
1958.                 {
      
1959.                         toxy(30,10);
      
1960.                         printf("该餐桌编号已存在，请重新输入！");
      
1961.                         Sleep(2000);
      
1962.                         continue;
      
1963.                 }
      
1964.                 p->ID=ID;
      
1965.                 p->People=0;
      
1966.                 p->count=count;
      
1967.                 strcpy(p->Username,"无");
      
1968.                 save_Table(p);
      
1969.                 toxy(24,10);
      
1970.                 printf("添加成功！是否继续？(1.是   2.否)");
      
1971.                 while(1)
      
1972.                 {
      
1973.                         t=getch();
      
1974.                         if(t=='1')
      
1975.                                 break;
      
1976.                         else if(t=='2')
      
1977.                                 break;
      
1978.                 }
      
1979.                 if(t=='2')
      
1980.                         break;
      
1981.         }while(1);
      
1982. }
      
1983. 
      
1984. void Administrator_List_Table()//餐桌列表
      
1985. {
      
1986.         system("cls");
      
1987.         pTable p,head;
      
1988.         head=readTableFile();
      
1989.         p=head;
      
1990.         int i=11;
      
1991.         toxy(32,6);
      
1992.         printf("餐桌列表(按任意键继续)");
      
1993.         toxy(22,8);
      
1994.         printf("餐桌编号 | 可坐人数 | 已坐人数 | 订餐人");
      
1995.         toxy(20,9);
      
1996.         printf("--------------------------------------------");
      
1997.         while(p!=NULL)
      
1998.         {
      
1999.                 toxy(26,i);
      
2000.                 printf("%-10d%-10d%-10d%s",p->ID,p->count,p->People,p->Username);
      
2001.                 i++;
      
2002.                 p=p->next;
      
2003.         }
      
2004.         getch();
      
2005. }
      
2006. 
      
2007. void Clear_Table()//清理餐桌
      
2008. {
      
2009.         char t;
      
2010.         do
      
2011.         {
      
2012.                 system("cls");
      
2013.                 toxy(32,4);
      
2014.                 printf("清理餐桌");
      
2015.                 toxy(26,5);
      
2016.                 printf("-------------------");
      
2017.                 toxy(30,7);
      
2018.                 printf("1) 清理指定餐桌");
      
2019.                 toxy(30,9);
      
2020.                 printf("2) 清理所有餐桌");
      
2021.                 toxy(30,11);
      
2022.                 printf("3) 返回上一级");
      
2023.                 t=getch();
      
2024.                 switch(t)
      
2025.                 {
      
2026.                         case '1':Clear_oneTable();break;
      
2027.                         case '2':Clear_allTable();break;
      
2028.                         case '3':break;
      
2029.                         default :break;
      
2030.                 }
      
2031.                 if(t=='3')
      
2032.                         break;
      
2033.         }while(1);
      
2034. }
      
2035. 
      
2036. void Updata_Table(pTable head)//更新餐桌文件
      
2037. {
      
2038.         FILE *fp;
      
2039.         pTable p=head->next;                           //使p指向第二个结点
      
2040.         fp=fopen("Table.txt","w");                  //先清空原文件内容再将修改后的信息写入文件
      
2041.         if(fp==NULL)
      
2042.         {
      
2043.                 printf("cannot open file\n");
      
2044.         }
      
2045.         if(fwrite(head,X,1,fp)!=1)                 //将head所指向的数据写入fp所指向的文件
      
2046.         {
      
2047.                 printf("file write error\n");
      
2048.         }
      
2049.         fclose(fp);                         //关闭文件
      
2050.         fp=fopen("Table.txt","a");          // 打开User.txt文件，方式为追加
      
2051.         while(p!=NULL)                    //p不为空就执行循环体
      
2052.         {
      
2053.                 if(fwrite(p,X,1,fp)!=1)            //将p所指向的1个大小为N的数据结构写入fp所指向的文件
      
2054.             {
      
2055.                         printf("file write error\n");
      
2056.             }
      
2057.             p=p->next;                     //使p指向下一个结点
      
2058.         }
      
2059.         fclose(fp);              //关闭文件
      
2060. }
      
2061. 
      
2062. void Clear_oneTable()//清理指定餐桌
      
2063. {
      
2064.         int ID;
      
2065.         pTable p,head;
      
2066.         char t;
      
2067.         do
      
2068.         {
      
2069.                 system("cls");
      
2070.                 head=readTableFile();
      
2071.                 p=head;
      
2072.                 toxy(28,8);
      
2073.                 printf("请输入您要清理的餐桌编号:");
      
2074.                 scanf("%d",&ID);
      
2075.                 while(p!=NULL&&p->ID!=ID)
      
2076.                 {
      
2077.                         p=p->next;
      
2078.                 }
      
2079.                 if(p)
      
2080.                 {
      
2081.                         toxy(32,10);
      
2082.                         printf("正在清理....");
      
2083.                         p->People=0;
      
2084.                         strcpy(p->Username,"无");
      
2085.                         Updata_Table(head);
      
2086.                         Sleep(2000);
      
2087.                         toxy(24,10);
      
2088.                         printf("清理成功！是否继续？1.是   2.否");
      
2089.                         while(1)
      
2090.                         {
      
2091.                                 t=getch();
      
2092.                                 if(t=='1')
      
2093.                                         break;
      
2094.                                 else if(t=='2')
      
2095.                                         break;
      
2096.                         }
      
2097.                         if(t=='2')
      
2098.                                 break;
      
2099.                 }
      
2100.                 else
      
2101.                 {
      
2102.                         toxy(32,10);
      
2103.                         printf("该餐桌不存在！请重新输入");
      
2104.                         Sleep(1500);
      
2105.                 }
      
2106.         }while(1);
      
2107. }
      
2108. 
      
2109. void Clear_allTable()//清理所有餐桌
      
2110. {
      
2111.         system("cls");
      
2112.         toxy(32,10);
      
2113.         printf("正在清理....");
      
2114.         pTable p,head;
      
2115.         head=readTableFile();
      
2116.         p=head;
      
2117.         while(p!=NULL)
      
2118.         {
      
2119.                 p->People=0;
      
2120.                 strcpy(p->Username,"无");
      
2121.                 p=p->next;
      
2122.         }
      
2123.         Updata_Table(head);
      
2124.         Sleep(2000);
      
2125.         toxy(32,10);
      
2126.         printf("清理成功！按任意键继续");
      
2127.         getch();
      
2128. }
      
2129. 
      
2130. void Check_User()//查看用户
      
2131. {
      
2132.         char t;
      
2133.         do
      
2134.         {
      
2135.                 system("cls");
      
2136.                 system("color 79");
      
2137.                 toxy(32,6);
      
2138.                 printf("  查看用户  ");
      
2139.                 toxy(32,7);
      
2140.                 printf("----------------");
      
2141.                 toxy(32,9);
      
2142.                 printf(" 1) 查找用户 ");
      
2143.                 toxy(32,11);
      
2144.                 printf(" 2) 所有用户 ");
      
2145.                 toxy(32,13);
      
2146.                 printf(" 3）返回上一级");
      
2147.                 t=getch();
      
2148.                 switch(t)
      
2149.                 {
      
2150.                         case '1':Find_User();break;
      
2151.                         case '2':All_User();break;
      
2152.                         case '3':break;
      
2153.                         default :break;
      
2154.                 }
      
2155.                 if(t=='3')
      
2156.                         break;
      
2157.         }while(1);
      
2158. }
      
2159. 
      
2160. void Find_User()//查找用户
      
2161. {
      
2162.         system("cls");
      
2163.         char username[10];
      
2164.         pUser p, head=readUserFile();
      
2165.         p=head;
      
2166.         toxy(32,10);
      
2167.         printf("请输入您要查找的用户名：");
      
2168.         scanf("%s",username);
      
2169.         toxy(24,12);
      
2170.         printf("用户名\t\t余额\t\t会员状态");
      
2171.         while(p!=NULL&&strcmp(p->userName,username)!=0)
      
2172.                 p=p->next;
      
2173.         if(p!=NULL)
      
2174.         {
      
2175.                 toxy(24,14);
      
2176.                 printf("%s\t\t%.2f\t\t%d",p->userName,p->money,p->isVIP);
      
2177.         }
      
2178.         else
      
2179.         {
      
2180.                 toxy(28,14);
      
2181.                 printf("没有找到相关信息");
      
2182.         }
      
2183.         toxy(30,16);
      
2184.         printf("请按任意键返回");
      
2185.         getch();
      
2186. }
      
2187. 
      
2188. void All_User()//打印所有用户信息
      
2189. {
      
2190.         system("cls");
      
2191.         pUser p,head;
      
2192.         head=readUserFile();
      
2193.         p=head;
      
2194.         int i=9;
      
2195.         toxy(32,4);
      
2196.         printf("所有用户");
      
2197.         toxy(20,5);
      
2198.         printf("--------------------------------------------------");
      
2199.         toxy(30,6);
      
2200.         printf("按任意键返回");
      
2201.         toxy(24,7);
      
2202.         printf("用户名\t\t余额\t\t会员状态");
      
2203.         while(p!=NULL)
      
2204.         {
      
2205.                 toxy(24,i);
      
2206.                 printf("%s\t\t%.2f\t\t%d",p->userName,p->money,p->isVIP);
      
2207.                 p=p->next;
      
2208.                 i+=2;
      
2209.         }
      
2210.         getch();
      
2211. }
      
2212. 
      
2213. void All_VIP()//查看所有VIP
      
2214. {
      
2215.         system("cls");
      
2216.         system("color 79");
      
2217.         pUser p,head;
      
2218.         head=readUserFile();
      
2219.         p=head;
      
2220.         int i=11;
      
2221.         toxy(32,6);
      
2222.         printf("本店会员");
      
2223.         toxy(26,8);
      
2224.         printf("用户名\t\t余额");
      
2225.         toxy(24,9);
      
2226.         printf("--------------------------------");
      
2227.         while(p!=NULL)
      
2228.         {
      
2229.                 if(p->isVIP)
      
2230.                 {
      
2231.                         toxy(26,i);
      
2232.                         printf("%s\t\t\t%.2f",p->userName,p->money);
      
2233.                         i+=2;
      
2234.                 }
      
2235.                 p=p->next;
      
2236.         }
      
2237.         toxy(30,i);
      
2238.         printf("按任意键返回");
      
2239.         getch();
      
2240. }
      
2241. 
      
2242. void Setup_administrator()//设置管理员
      
2243. {
      
2244.        
      
2245.         system("color 80");
      
2246.         char t;
      
2247.         char username[10];
      
2248.         pUser p,head;
      
2249.         head=readUserFile();
      
2250.         do
      
2251.         {
      
2252.                 system("cls");
      
2253.                 p=head;
      
2254.                 toxy(26,8);
      
2255.                 printf("请输入您要设置为管理员的用户名：");
      
2256.                 scanf("%s",username);
      
2257.                 while(p!=NULL&&strcmp(p->userName,username)!=0)
      
2258.                 {
      
2259.                         p=p->next;
      
2260.                 }
      
2261.                 if(p!=NULL)
      
2262.                 {
      
2263.                         p->isAdministrator=1;
      
2264.                         Updata_User(head);
      
2265.                         toxy(32,10);
      
2266.                         printf("设置成功!请按任意键返回");
      
2267.                         getch();
      
2268.                         break;
      
2269.                 }
      
2270.                 else
      
2271.                 {
      
2272.                         toxy(24,10);
      
2273.                         printf("您所输入的用户名不存在！是否继续？(1.是   2.否)");
      
2274.                         while(1)
      
2275.                         {
      
2276.                                 t=getch();
      
2277.                                 if(t=='1')
      
2278.                                         break;
      
2279.                                 else if(t=='2')
      
2280.                                         break;
      
2281.                         }
      
2282.                         if(t=='2')
      
2283.                                 break;
      
2284.                 }
      
2285.         }while(1);       
      
2286. }
      
2287. 
      
2288. 
      
2289. int main()
      
2290. {       
      
2291.         Default();//进入欢迎界面
      
2292.         return 0;
      
2293. }

复制代码

ccczd666

782353676 发表于 2020-12-22 20:16

大佬，您这代码太复杂了这就是个小问题ヽ（＿；)ノ

hhp_3533

#include <stdio.h>

void main()
{
        int m,n;//m为餐桌号，n为菜编号
        printf("请输入你所在的餐桌号：");
        scanf("%d",&m);
        printf("\n请点菜：\n");
        printf("宫保鸡丁--1\n");
        printf("清炒油菜--2\n");
        printf("可口可乐--3\n");
        printf("请输入你要点菜的编号：");
        scanf("%d",&n);
        switch(n)
        {
        case 1:
                printf("餐桌号：%d,已点菜：宫保鸡丁\n",m);
                break;
        case 2:
                printf("餐桌号：%d,已点菜：清炒油菜\n",m);
                break;
        case 3:
                printf("餐桌号：%d,已点菜：可口可乐\n",m);
                break;
        default:
                printf("你输入的菜编号错误\n");
        }

}

lzq9825

782353676 发表于 2020-12-22 20:16

牛逼啊

Yvonne!

ccczd666 发表于 2020-12-22 20:28
大佬，您这代码太复杂了这就是个小问题ヽ（＿；)ノ

大佬这是帮你把整个系统给搞出来了，你自己挖一下需要的内容就好了嘛O(∩_∩)O哈哈~

Yvonne!

782353676 发表于 2020-12-22 20:16

我想知道你这段码是即兴还是认真的

782353676

Yvonne! 发表于 2020-12-26 11:18
我想知道你这段码是即兴还是认真的

我们期末作业....

流光千仞

782353676 发表于 2020-12-22 20:16

膜拜大佬
这太牛批了！！！