练习3-1

  1. /* 猜拳游戏（其四：分割函数/显示成绩）*/
  2.  
  3. #include <time.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6.  
  7. int human;        /* 玩家的手势 */
  8. int comp;        /* 计算机的手势 */
  9. int win_no;        /* 胜利次数 */
  10. int lose_no;    /* 失败次数 */
  11. int draw_no;    /* 平局次数 */
  12.  
  13. char* hd[] = { "石头", "剪刀", "布" };        /* 手势 */
  14.  
  15. /*--- 初始处理 ---*/
  16. void initialize(void)
  17. {
  18.     win_no = ;        /* 胜利次数 */
  19.     lose_no = ;        /* 失败次数 */
  20.     draw_no = ;        /* 平局次数 */
  21.  
  22.     srand(time(NULL));    /* 设定随机数种子 */
  23.  
  24.     printf("猜拳游戏开始!!\n");
  25. }
  26.  
  27. /*--- 运行猜拳游戏（读取/生成手势）---*/
  28. void jyanken(void)
  29. {
  30.     int i;
  31.  
  32.     comp = rand() % ;        /* 用随机数生成计算机的手势（0~2）*/
  33.  
  34.     do {
  35.         printf("\n\a石头剪刀布 ···");
  36.         for (i = ; i < ; i++)
  37.             printf(" (%d)%s", i, hd[i]);
  38.         printf(":");
  39.         scanf("%d", &human);        /* 读取玩家的手势 */
  40.     } while (human <  || human > );
  41. }
  42.  
  43. /*--- 更新胜利/失败/平局次数 ---*/
  44. void count_no(int result)
  45. {
  46.     switch (result) {
  47.     case : draw_no++; puts("平局。");     break;                        /* 平局 */
  48.     case : lose_no++; puts("你输了。");     break;                        /* 失败 */
  49.     case :  win_no++;  puts("你赢了。");   break;                    /* 胜利 */
  50.     }
  51. }
  52.  
  53. /*--- 确认是否再次挑战 ---*/
  54. int confirm_retry(void)
  55. {
  56.     int x;
  57.  
  58.     printf("再来一次吗···(0)否 (1)是：");
  59.     scanf("%d", &x);
  60.  
  61.     return x;
  62. }
  63.  
  64. int main(void)
  65. {
  66.     int judge;                /* 胜负 */
  67.     int retry;                /* 再来一次？*/
  68.  
  69.     initialize();                        /* 初始处理 */
  70.  
  71.     do {
  72.         jyanken();                        /* 运行猜拳游戏 */
  73.  
  74.         /* 显示计算机和玩家的手势 */
  75.         printf("我出%s，你出%s。\n", hd[comp], hd[human]);
  76.  
  77.         judge = (human - comp + ) % ;    /* 判断胜负 */
  78.  
  79.         count_no(judge);                /* 更新胜利/失败/平局次数 */
  80.  
  81.         retry = confirm_retry();        /* 确认是否再次挑战 */
  82.  
  83.     } while (retry == );
  84.  
  85.     printf("%d胜%d负%d平。\n", win_no, lose_no, draw_no);
  86.  
  87.     return ;
  88. }

练习3-2

  1. /* 猜拳游戏（其五：先赢满3局者胜）*/
  2.  
  3. #include <time.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6.  
  7. int human;        /* 玩家的手势 */
  8. int comp;        /* 计算机的手势 */
  9. int win_no;        /* 胜利次数 */
  10. int lose_no;    /* 失败次数 */
  11. int draw_no;    /* 平局次数 */
  12.  
  13. char* hd[] = { "石头", "剪刀", "布" };        /* 手势 */
  14.  
  15. /*--- 初始处理 ---*/
  16. void initialize(void)
  17. {
  18.     win_no = ;        /* 胜利次数 */
  19.     lose_no = ;        /* 失败次数 */
  20.     draw_no = ;        /* 平局次数 */
  21.  
  22.     srand(time(NULL));    /* 设定随机数种子 */
  23.  
  24.     printf("猜拳游戏开始!!\n");
  25. }
  26.  
  27. /*--- 运行猜拳游戏（读取/生成手势） ---*/
  28. void jyanken(void)
  29. {
  30.     int i;
  31.  
  32.     comp = rand() % ;        /* 用随机数生成计算机的手势（0~2）*/
  33.  
  34.     do {
  35.         printf("\n\a石头剪刀布 ···");
  36.         for (i = ; i < ; i++)
  37.             printf(" (%d)%s", i, hd[i]);
  38.         printf(":");
  39.         scanf("%d", &human);        /* 读取玩家的手势 */
  40.     } while (human <  || human > );
  41. }
  42.  
  43. /*--- 更新胜利/失败/平局次数 ---*/
  44. void count_no(int result)
  45. {
  46.     switch (result) {
  47.     case : draw_no++;     break;                        /* 平局 */
  48.     case : lose_no++;     break;                        /* 失败 */
  49.     case : win_no++;   break;                        /* 胜利 */
  50.     }
  51. }
  52.  
  53. /*--- 显示判断结果 ---*/
  54. void disp_result(int result)
  55. {
  56.     switch (result) {
  57.     case : puts("平局。");     break;     /* 平局 */
  58.     case : puts("你输了。");   break;     /* 失败 */
  59.     case : puts("你赢了。");   break;     /* 胜利 */
  60.     }
  61. }
  62.  
  63. int main(void)
  64. {
  65.     int judge;                /* 胜负 */
  66.     int cnt;
  67.     printf("要猜赢几次?");
  68.     scanf("%d", &cnt);
  69.  
  70.     initialize();                        /* 初始处理 */
  71.  
  72.     do {
  73.         jyanken();                        /* 运行猜拳游戏 */
  74.  
  75.         /* 显示计算机和玩家的手势 */
  76.         printf("我出%s，你出%s。\n", hd[comp], hd[human]);
  77.  
  78.         judge = (human - comp + ) % ;    /* 判断胜负 */
  79.  
  80.         count_no(judge);                /* 更新胜利/失败/平局次数 */
  81.  
  82.         disp_result(judge);                /* 显示判断结果 */
  83.  
  84.     } while (win_no < cnt && lose_no < cnt);
  85.  
  86.     printf(win_no == cnt?"\n□你赢了。\n" : "\n■我赢了。\n");
  87.  
  88.     printf("%d胜%d负%d平。\n", win_no, lose_no, draw_no);
  89.  
  90.     return ;
  91. }

练习3-3

  1. /* 猜拳游戏（其四：分割函数/显示成绩）*/
  2.  
  3. #include <time.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6.  
  7. int human;        /* 玩家的手势 */
  8. int comp;        /* 计算机的手势 */
  9. int win_no;        /* 胜利次数 */
  10. int lose_no;    /* 失败次数 */
  11. int draw_no;    /* 平局次数 */
  12. char* hd[] = { "石头", "剪刀", "布" };        /* 手势 */
  13.  
  14. /*--- 初始处理 ---*/
  15. void initialize(void)
  16. {
  17.     win_no = ;        /* 胜利次数 */
  18.     lose_no = ;        /* 失败次数 */
  19.     draw_no = ;        /* 平局次数 */
  20.  
  21.     srand(time(NULL));    /* 设定随机数种子 */
  22.  
  23.     printf("猜拳游戏开始!!\n");
  24. }
  25.  
  26. /*--- 运行猜拳游戏（读取/生成手势）---*/
  27. void jyanken(void)
  28. {
  29.     int i;
  30.     comp = rand() % ;        /* 用随机数生成计算机的手势（0~2）*/
  31.     do
  32.     {
  33.         comp = rand() % ;
  34.     } while (comp == );
  35.  
  36.     do {
  37.         printf("\n\a石头剪刀布 ···");
  38.         for (i = ; i < ; i++)
  39.             printf(" (%d)%s", i, hd[i]);
  40.         printf(":");
  41.         scanf("%d", &human);        /* 读取玩家的手势 */
  42.     } while (human <  || human > );
  43. }
  44.  
  45. /*--- 更新胜利/失败/平局次数 ---*/
  46. void count_no(int result)
  47. {
  48.     switch (result) {
  49.     case : draw_no++;     break;                        /* 平局 */
  50.     case : lose_no++;     break;                        /* 失败 */
  51.     case : win_no++;   break;                        /* 胜利 */
  52.     }
  53. }
  54.  
  55. /*--- 显示判断结果 ---*/
  56. void disp_result(int result)
  57. {
  58.     switch (result) {
  59.     case : puts("平局。");     break;     /* 平局 */
  60.     case : puts("你输了。");   break;     /* 失败 */
  61.     case : puts("你赢了。");   break;     /* 胜利 */
  62.     }
  63. }
  64.  
  65. /*--- 确认是否再次挑战 ---*/
  66. int confirm_retry(void)
  67. {
  68.     int x;
  69.  
  70.     printf("再来一次吗···(0)否 (1)是：");
  71.     scanf("%d", &x);
  72.  
  73.     return x;
  74. }
  75.  
  76. int main(void)
  77. {
  78.     int judge;                /* 胜负 */
  79.     int retry;                /* 再来一次？*/
  80.  
  81.     initialize();                        /* 初始处理 */
  82.  
  83.     do {
  84.         jyanken();                        /* 运行猜拳游戏 */
  85.  
  86.         /* 显示计算机和玩家的手势 */
  87.         printf("我出%s，你出%s。\n", hd[comp], hd[human]);
  88.  
  89.         judge = (human - comp + ) % ;    /* 判断胜负 */
  90.  
  91.         count_no(judge);                /* 更新胜利/失败/平局次数 */
  92.  
  93.         disp_result(judge);                /* 显示判断结果 */
  94.  
  95.         retry = confirm_retry();        /* 确认是否再次挑战 */
  96.  
  97.     } while (retry == );
  98.  
  99.     printf("%d胜%d负%d平。\n", win_no, lose_no, draw_no);
  100.  
  101.     return ;
  102. }

练习3-4

  1. /* 猜拳游戏（其四：分割函数/显示成绩）*/
  2.  
  3. #include <time.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6.  
  7. int human;        /* 玩家的手势 */
  8. int comp;        /* 计算机的手势 */
  9. int win_no;        /* 胜利次数 */
  10. int lose_no;    /* 失败次数 */
  11. int draw_no;    /* 平局次数 */
  12. char* hd[] = { "石头", "剪刀", "布" };        /* 手势 */
  13.  
  14. /*--- 初始处理 ---*/
  15. void initialize(void)
  16. {
  17.     win_no = ;        /* 胜利次数 */
  18.     lose_no = ;        /* 失败次数 */
  19.     draw_no = ;        /* 平局次数 */
  20.  
  21.     srand(time(NULL));    /* 设定随机数种子 */
  22.  
  23.     printf("猜拳游戏开始!!\n");
  24. }
  25.  
  26. /*--- 运行猜拳游戏（读取/生成手势）---*/
  27. void jyanken(void)
  28. {
  29.     int i;
  30.     static int cnt = ;
  31.     if (cnt == ) {
  32.         comp = ;
  33.         cnt++;
  34.     }
  35.     else
  36.     {
  37.         comp = rand() % ;
  38.     }        /* 用随机数生成计算机的手势（0~2）*/
  39.  
  40.     do {
  41.         printf("\n\a石头剪刀布 ···");
  42.         for (i = ; i < ; i++)
  43.             printf(" (%d)%s", i, hd[i]);
  44.         printf(":");
  45.         scanf("%d", &human);        /* 读取玩家的手势 */
  46.     } while (human <  || human > );
  47. }
  48.  
  49. /*--- 更新胜利/失败/平局次数 ---*/
  50. void count_no(int result)
  51. {
  52.     switch (result) {
  53.     case : draw_no++;     break;                        /* 平局 */
  54.     case : lose_no++;     break;                        /* 失败 */
  55.     case : win_no++;   break;                        /* 胜利 */
  56.     }
  57. }
  58.  
  59. /*--- 显示判断结果 ---*/
  60. void disp_result(int result)
  61. {
  62.     switch (result) {
  63.     case : puts("平局。");     break;     /* 平局 */
  64.     case : puts("你输了。");   break;     /* 失败 */
  65.     case : puts("你赢了。");   break;     /* 胜利 */
  66.     }
  67. }
  68.  
  69. /*--- 确认是否再次挑战 ---*/
  70. int confirm_retry(void)
  71. {
  72.     int x;
  73.  
  74.     printf("再来一次吗···(0)否 (1)是：");
  75.     scanf("%d", &x);
  76.  
  77.     return x;
  78. }
  79.  
  80. int main(void)
  81. {
  82.     int judge;                /* 胜负 */
  83.     int retry;                /* 再来一次？*/
  84.  
  85.     initialize();                        /* 初始处理 */
  86.  
  87.     do {
  88.         jyanken();                        /* 运行猜拳游戏 */
  89.  
  90.         /* 显示计算机和玩家的手势 */
  91.         printf("我出%s，你出%s。\n", hd[comp], hd[human]);
  92.  
  93.         judge = (human - comp + ) % ;    /* 判断胜负 */
  94.  
  95.         count_no(judge);                /* 更新胜利/失败/平局次数 */
  96.  
  97.         disp_result(judge);                /* 显示判断结果 */
  98.  
  99.         retry = confirm_retry();        /* 确认是否再次挑战 */
  100.  
  101.     } while (retry == );
  102.  
  103.     printf("%d胜%d负%d平。\n", win_no, lose_no, draw_no);
  104.  
  105.     return ;
  106. }

练习3-5

  1. /* 猜拳游戏（其四：分割函数/显示成绩）*/
  2.  
  3. #include <time.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6.  
  7. int human;        /* 玩家的手势 */
  8. int comp;        /* 计算机的手势 */
  9. int win_no;        /* 胜利次数 */
  10. int lose_no;    /* 失败次数 */
  11. int draw_no;    /* 平局次数 */
  12. char* hd[] = { "石头", "剪刀", "布" };        /* 手势 */
  13.  
  14. /*--- 初始处理 ---*/
  15. void initialize(void)
  16. {
  17.     win_no = ;        /* 胜利次数 */
  18.     lose_no = ;        /* 失败次数 */
  19.     draw_no = ;        /* 平局次数 */
  20.  
  21.     srand(time(NULL));    /* 设定随机数种子 */
  22.  
  23.     printf("猜拳游戏开始!!\n");
  24. }
  25.  
  26. /*--- 运行猜拳游戏（读取/生成手势）---*/
  27. void jyanken(void)
  28. {
  29.     static int cnt=;
  30.     int i;
  31.     comp = rand() % ;        /* 用随机数生成计算机的手势（0~2）*/
  32.     cnt++;
  33.     do {
  34.         printf("\n\a石头剪刀布 ···");
  35.         for (i = ; i < ; i++)
  36.             printf(" (%d)%s", i, hd[i]);
  37.         printf(":");
  38.         scanf("%d", &human);        /* 读取玩家的手势 */
  39.     } while (human <  || human > );
  40.     if (cnt %  == ) {
  41.         comp = (human + ) % ;
  42.     }
  43.  
  44. }
  45.  
  46. /*--- 更新胜利/失败/平局次数 ---*/
  47. void count_no(int result)
  48. {
  49.     switch (result) {
  50.     case : draw_no++;     break;                        /* 平局 */
  51.     case : lose_no++;     break;                        /* 失败 */
  52.     case : win_no++;   break;                        /* 胜利 */
  53.     }
  54. }
  55.  
  56. /*--- 显示判断结果 ---*/
  57. void disp_result(int result)
  58. {
  59.     switch (result) {
  60.     case : puts("平局。");     break;     /* 平局 */
  61.     case : puts("你输了。");   break;     /* 失败 */
  62.     case : puts("你赢了。");   break;     /* 胜利 */
  63.     }
  64. }
  65.  
  66. /*--- 确认是否再次挑战 ---*/
  67. int confirm_retry(void)
  68. {
  69.     int x;
  70.  
  71.     printf("再来一次吗···(0)否 (1)是：");
  72.     scanf("%d", &x);
  73.  
  74.     return x;
  75. }
  76.  
  77. int main(void)
  78. {
  79.     int judge;                /* 胜负 */
  80.     int retry;                /* 再来一次？*/
  81.  
  82.     initialize();                        /* 初始处理 */
  83.  
  84.     do {
  85.         jyanken();                        /* 运行猜拳游戏 */
  86.  
  87.         /* 显示计算机和玩家的手势 */
  88.         printf("我出%s，你出%s。\n", hd[comp], hd[human]);
  89.  
  90.         judge = (human - comp + ) % ;    /* 判断胜负 */
  91.  
  92.         count_no(judge);                /* 更新胜利/失败/平局次数 */
  93.  
  94.         disp_result(judge);                /* 显示判断结果 */
  95.  
  96.         retry = confirm_retry();        /* 确认是否再次挑战 */
  97.  
  98.     } while (retry == );
  99.  
  100.     printf("%d胜%d负%d平。\n", win_no, lose_no, draw_no);
  101.  
  102.     return ;
  103. }

练习3-6

  1. /* 猜拳游戏（其五：先赢满3局者胜）*/
  2.  
  3. #include <time.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6.  
  7. int human;        /* 玩家的手势 */
  8. int comp;        /* 计算机的手势 */
  9. int win_no;        /* 胜利次数 */
  10. int lose_no;    /* 失败次数 */
  11. int draw_no;    /* 平局次数 */
  12. int v[];
  13. int x[];
  14. int m[];
  15. int cnt = ;
  16. int i;
  17.  
  18. char* hd[] = { "石头", "剪刀", "布" };        /* 手势 */
  19. char* result[] = { "平局", "你输了", "你赢了" };        /* 手势 */
  20.  
  21. /*--- 初始处理 ---*/
  22. void initialize(void)
  23. {
  24.     win_no = ;        /* 胜利次数 */
  25.     lose_no = ;        /* 失败次数 */
  26.     draw_no = ;        /* 平局次数 */
  27.  
  28.     srand(time(NULL));    /* 设定随机数种子 */
  29.  
  30.     printf("猜拳游戏开始!!\n");
  31. }
  32.  
  33. /*--- 运行猜拳游戏（读取/生成手势） ---*/
  34. void jyanken(void)
  35. {
  36.     int i;
  37.     comp = rand() % ;        /* 用随机数生成计算机的手势（0~2）*/
  38.     v[cnt] = comp;
  39.     do {
  40.         printf("\n\a石头剪刀布 ···");
  41.         for (i = ; i < ; i++)
  42.             printf(" (%d)%s", i, hd[i]);
  43.         printf(":");
  44.         scanf("%d", &human);
  45.         x[cnt] = human;
  46.  
  47.     } while (human <  || human > );
  48.     cnt++;
  49.  
  50. }
  51.  
  52. /*--- 更新胜利/失败/平局次数 ---*/
  53. void count_no(int result)
  54. {
  55.     switch (result) {
  56.     case : draw_no++;     break;                        /* 平局 */
  57.     case : lose_no++;     break;                        /* 失败 */
  58.     case : win_no++;   break;                        /* 胜利 */
  59.     }
  60. }
  61.  
  62. /*--- 显示判断结果 ---*/
  63. void disp_result(int result)
  64. {
  65.     switch (result) {
  66.     case : puts("平局。");     break;     /* 平局 */
  67.     case : puts("你输了。");   break;     /* 失败 */
  68.     case : puts("你赢了。");   break;     /* 胜利 */
  69.     }
  70. }
  71.  
  72. int main(void)
  73. {
  74.     int judge;                /* 胜负 */
  75.     i = ;
  76.     initialize();                        /* 初始处理 */
  77.  
  78.     do {
  79.         jyanken();                        /* 运行猜拳游戏 */
  80.  
  81.         /* 显示计算机和玩家的手势 */
  82.         printf("我出%s，你出%s。\n", hd[comp], hd[human]);
  83.  
  84.         judge = (human - comp + ) % ;    /* 判断胜负 */
  85.         m[i] = judge;
  86.         count_no(judge);                /* 更新胜利/失败/平局次数 */
  87.  
  88.         disp_result(judge);                /* 显示判断结果 */
  89.         i++;
  90.     } while (win_no <  && lose_no < );
  91.     printf(win_no ==  ? "\n□你赢了。\n" : "\n■我赢了。\n");
  92.  
  93.     printf("%d胜%d负%d平。\n", win_no, lose_no, draw_no);
  94.     for (i = ; i <cnt; i++) {
  95.         printf("第%d次猜拳，玩家出%s,计算机出%s,结果是%s\n",i+,hd[x[i]],hd[v[i]],result[m[i]]);
  96.     }
  97.  
  98.     return ;
  99. }

明解C语言 中级篇 第三章答案的更多相关文章

  1. 明解C语言 入门篇 第三章答案

    练习3-1 #include <stdio.h> int main() { int x; int y; puts("请输入两个整数."); printf("整 ...

  2. 明解C语言 中级篇 第四章答案

    练习4-1 /* 珠玑妙算 */ #include <time.h> #include <ctype.h> #include <stdio.h> #include ...

  3. 明解C语言 入门篇 第五章答案

    练习5-1 /* 依次把1.2.3.4.5 赋值给数组的每个元素并显示(使用for语句) */ #include <stdio.h> int main(void) { int i; ]; ...

  4. 明解C语言 入门篇 第六章答案

    练习6-1 /* 求两个整数中的最小值 */ #include <stdio.h> /*--- 返回三个整数中的最小值 ---*/ int min2(int a, int b) { int ...

  5. 明解C语言 入门篇 第四章答案

    练习4-1 #include <stdio.h> int main(void) { int no; int x; do{ printf("请输入一个整数:"); sca ...

  6. 明解C语言 入门篇 第十三章答案

    练习13-1 /* 打开与关闭文件 */ #include <stdio.h> int main(void) { ]; FILE* fp; printf("请输入你要打开的文件& ...

  7. 明解C语言 入门篇 第十一章答案

    练习11-1 /* 用指针实现的字符串的改写 */ #include <stdio.h> int main(void) { "; printf("p = \" ...

  8. 明解C语言 入门篇 第七章答案

    练习7-1 #include <stdio.h> int main() { int n; printf(,, ); //此行显示结果为 4 3 6 因为1的字节就是为4,而-1的字节也是4 ...

  9. 明解C语言 中级篇 第二章答案

    练习2-1 /* 倒计时后显示程序运行时间 */ #include <time.h> #include <stdio.h> /*--- 等待x毫秒 ---*/ int slee ...

随机推荐

  1. 【shell脚本】点名器===randomName.sh

    随机点名,从name.txt文件中读取名字 [root@VM_0_10_centos shellScript]# cat randowName.sh #!/bin/bash # 随机点名器 # 需提前 ...

  2. linq根据两个时间求出天数

    对于在Linq To Entity里使用日期函数需要DbFunctions里的扩展方法,而不能使用.net里的日期函数,因为linq的代码会被翻译成SQL发到数据库端,如你的.net方法对于数据库是不 ...

  3. javascript split() 把一个字符串分割成字符串数组,类似于PHP的 explode()函数

    用法类似于框里的 例子:

  4. Spring Cloud中Hystrix 线程隔离导致ThreadLocal数据丢失问题分析

    最近spring boot项目中由于使用了spring cloud 的hystrix 导致了threadLocal中数据丢失,其实具体也没有使用hystrix,但是显示的把他打开了,导致了此问题. 导 ...

  5. 使用Java操作Elasticsearch(Elasticsearch的java api使用)

    1.Elasticsearch是基于Lucene开发的一个分布式全文检索框架,向Elasticsearch中存储和从Elasticsearch中查询,格式是json. 索引index,相当于数据库中的 ...

  6. Pycharm快捷键集合

    运行类:Alt + Shift + F10 运行模式配置Alt + Shift + F9 调试模式配置Shift + F10 运行Shift + F9 调试Ctrl + Shift + F10 运行编 ...

  7. SpringMVC学习笔记一（请求流程和配置，启动项目）

    springmvc请求流程: 1.用户发送请求至前端控制器DispatcherServlet 2.DispatcherServlet收到请求调用HandlerMapping处理器映射器. 3.处理器映 ...

  8. ES6变量的解构赋值（二）对象的解构赋值

    前面我们知道,数组的结构赋值需要按顺序进行赋值, let [a,,c] = [,,] console.log(a); console.log(c);//3 let [a,b] = [1];consol ...

  9. 干货，Wireshark使用技巧-过滤规则

    - 过滤规则使用 在抓取报文时使用的规则,称为过滤规则,Wireshark底层是基于Winpcap,因此过滤规则是Winpcap定义的规则,设置过滤规则后,抓到的报文仅包含符合规则的报文,其它报文则被 ...

  10. Web安全攻防笔记-SQL注入

    information_schema(MySQL5.0版本之后,MySQL数据库默认存放一个information_schema数据库) information_schema的三个表: SCHEMAT ...