重温c语言之，7天开整，就是随便的写写，第六天

一：字符串相比较

　　题目:编写代码实现，模仿用户登录景象，而且只能登录3次。（只允许输入3次暗码，暗码正确则提示输入乐成，如果三次都输入错误，则退出程序）
　　这里就是用到了strcmp这个函数，其实这个函数是让两个字符串同时从左到右转换成ASCLL码，之后两个字符，前面的减去背面的，如果全部减完为0，
　　那么证明这两个字符串是雷同的。

1. 1 #include <stdio.h>
2. 2 #include <string.h>
3. 3 int main()
4. 4 {
5. 5     char password[100];
6. 6     int i = 0;
7. 7     for (i = 0; i < 3; i++)
8. 8     {
9. 9         printf("请输入密码：>");
10. 10         scanf("%s", password);
11. 11         // 假设密码是:abcd
12. 12         if ((strcmp(password, "abcd")) == 0) // 这里是字符串的函数，用来比较两个函数，如果比较的两个字符串相等，就返回0
13. 13         {
14. 14             printf("密码输入正确。");
15. 15             break;
16. 16         }
17. 17         else
18. 18         {
19. 19             printf("密码输入错误，请再次输入。");
20. 20         }
21. 21     }
22. 22     if (i == 3)
23. 23     {
24. 24         printf("三次密码均输入错误，退出程序");
25. 25     }
26. 26
27. 27     return 0;
28. 28 }

复制代码

二：指针变量的大小

指针变量的大小是根据操作系统多少位决定的！！！
直接看代码

1. 1 #include <stdio.h>
2. 2
3. 3 void fun(int *a)
4. 4 {
5. 5     printf("%zu\n", sizeof(a)); // 这里计算的是指针变量，指针变量是根据系统来分配的
6. 6                                 // X86是4-----32位，8位一个字节，所以32/8=4
7. 7                                 // X64是8-----64位，8位一个字节，所以64/8=8，我的电脑是64位的，所以，就是8
8. 8 }
9. 9
10. 10 int main()
11. 11 {
12. 12     int a[10] = {0};
13. 13     printf("%zu\n", sizeof(a));
14. 14     printf("%zu\n", sizeof(a[0]));
15. 15     fun(a);
16. 16     return 0;
17. 17 }

复制代码

结果就是:
40
4
8
三：rand函数

　　rand()函数是c语言内里产生随机变量的函数，但是不停只使用这个的话，产生的随机数的结果都是一样的
　　所以怎么解决这个问题呢？
　　这里变用到了srand()函数，设置随机数生成器种子的函数srand()，会随机生成种子，用这个函数会产生不同的rand()函数序列，但是就是跟二维矩阵差不多的意思，这个函数也有问题，就是生成的种子也会一样，所以怎么解决生成随机数种子一样的问题呢？
　　便用到了这个答案来解决：时间戳----time()函数，这个函数就是会随着时间不断地变化，很好的解决了srand()随机产生种子的问题
　　下面就是一个例子：
　　题目：做一个小游戏--猜大小。电脑随机出一个随机数（0-100），选择猜大小

1. 1 #include <stdio.h>
2. 2 #include <stdlib.h>
3. 3 #include <time.h>
4. 4
5. 5 void menu()
6. 6 {
7. 7     printf("***********************************\n");
8. 8     printf("*******    1.play game     ********\n");
9. 9     printf("*******    0.exit          ********\n");
10. 10     printf("***********************************\n");
11. 11     printf("请选择输入的数字：");
12. 12 }
13. 13
14. 14 void game()
15. 15 {
16. 16     // 生成1~100的随机数
17. 17     // 这里用到了时间戳----配上头文件：time.h
18. 18
19. 19     int num = 0;
20. 20     int ret = rand() % 100 + 1;//这里
21. 21     printf("这次的随机数是：%d\n", ret);
22. 22     printf("请输入1~100之前的数字.\n");
23. 23
24. 24     while (1)
25. 25     {
26. 26         scanf("%d", &num);
27. 27         if (num > ret)
28. 28         {
29. 29             printf("猜大了！\n");
30. 30         }
31. 31         else if (num < ret)
32. 32         {
33. 33             printf("猜小了！\n");
34. 34         }
35. 35         else
36. 36         {
37. 37             printf("恭喜你才对了！\n");
38. 38             break;
39. 39         }
40. 40     }
41. 41 }
42. 42
43. 43 int main()
44. 44 {
45. 45
46. 46     int num = 0;
47. 47     srand((unsigned int)time(NULL));
48. 48     /*
49. 49     srand()函数的返回值是：unsigend int 类型，而time()时间戳函数的返回类型是time_t类型，所以需要进行强制转换
50. 50     time()这里面的指针变量是获取的时间，但是也可以设置没有，而指针变量的没有------NULL
51. 51      */
52. 52     do
53. 53     {
54. 54         menu();
55. 55         scanf("%d", &num);
56. 56         switch (num)
57. 57         {
58. 58         case 0:
59. 59             printf("退出游戏！\n");
60. 60             break;
61. 61         case 1:
62. 62             game(); // 猜数字的逻辑
63. 63             break;
64. 64         default:
65. 65             printf("输入错误，请重新选择。\n");
66. 66             break;
67. 67         }
68. 68     } while (num != 0);
69. 69
70. 70     return 0;
71. 71 }

复制代码

 　　还有就是为什么不把这串代码放到game函数内里，srand((unsigned int)time(NULL));
　　原因有两点：一：如果你将这行代码放在game()函数内里，意味着每次调用game()函数时，都会重新调用srand()函数来初始化种子，那么生成的随机数种子可能会重复，由于时　　　　　　间戳可能会是一样的
　　　　　　　　二：浪费资源，让系统运行变慢
四：goto函数

　　这个函数不能跨越函数进行使用，比如在main内里使用goto()函数，如果其外部有一个自己命名的函数，之后运行goto()函数，就跳不外去
　　这个函数主要运用场景：多层循环嵌套，跳不出来，便可以用goto()函数来进行break，从而直接免除死循环的危险
　　比方：
　　　　

1. 1 #include <stdio.h>
2. 2
3. 3 int main() {
4. 4     int i, j;
5. 5     int found = 0; // 用于标记是否找到特定条件，以便退出循环
6. 6
7. 7     // 外层循环
8. 8     for (i = 0; i < 5; ++i) {
9. 9         // 内层循环
10. 10         for (j = 0; j < 5; ++j) {
11. 11             if (i * j > 10) {
12. 12                 found = 1; // 找到特定条件
13. 13                 goto end_loops; // 使用goto退出循环
14. 14             }
15. 15         }
16. 16     }
17. 17
18. 18 end_loops:
19. 19     if (found) {
20. 20         printf("特定条件满足，退出循环。\n");
21. 21     } else {
22. 22         printf("循环正常结束。\n");
23. 23     }
24. 24
25. 25     return 0;
26. 26 }

复制代码

五： 函数

　　形参---实参

　　　　先看代码

1. 1 #include <stdio.h>
2. 2
3. 3 void swap(int num1, int num2)
4. 4 {
5. 5     int mid = 0;
6. 6     mid = num1;
7. 7     num1 = num2;
8. 8     num2 = mid;
9. 9 }
10. 10
11. 11 // 当实参传递给形参时，形参是实参的一份临时拷贝
12. 12 // 对形参的修改不会影响到实参
13. 13
14. 14 int main()
15. 15 {
16. 16     // 交换两个整数
17. 17     int num1 = 0;
18. 18     int num2 = 0;
19. 19     scanf("%d %d", &num1, &num2);
20. 20     printf("%d %d\n", num1, num2);
21. 21     swap(num1, num2);
22. 22     printf("%d %d\n", num1, num2);
23. 23     return 0;
24. 24 }

复制代码

结果：（假设输入：20 45）
　　20 45
　　20 45--------值传递
　　为什么都一样呢，由于，在main函数内里，变量num1和num2创建了属于他们两个单独的地址，当程序运行到swap函数()的时间，程序给这个swap()函数内部的num1和num2变量重新整了一份新的空间来存放数据，所以这个swap()函数内部空间再怎么变化，都与主函数main()函数无关，就像我在代码内里所说的一样，实参传递给形参的时间，形参是实参的一份临时拷贝，形参的改变不会影响到实参
　　那怎么改变使其影响到呢？

　　这里便运用到了指针变量，利用指针变量传递地址，来改变原本值的变化，直接看代码

1. 1 #include<stdio.h>
2. 14 void swap(int *pn1, int *pn2)
3. 15 {
4. 16     int mid = *pn1;
5. 17     *pn1 = *pn2;
6. 18     *pn2 = mid;
7. 19 }
8. 20
9. 21 int main()
10. 22 {
11. 23     int num1 = 0;
12. 24     int num2 = 0;
13. 25     scanf("%d %d", &num1, &num2);
14. 26     printf("%d %d\n", num1, num2);
15. 27     swap(&num1, &num2);
16. 28     printf("%d %d\n", num1, num2);
17. 29     return 0;
18. 30 }

复制代码

这里的结果就是：（输与上面一样：20 45）
　　20 45
　　45 20------地址传递
六：素数

　　题目：打印100~200之间的素数
　　（先讲一下什么是素数：除了1与其本身，不能被其他数整除的整数叫素数，比方：2,3,5,7,11等等）
　　直接上代码：

1. 1 #include <stdio.h>
2. 2 int main()
3. 3 {
4. 4     int count = 0;
5. 5     for (int i = 100; i < 200; i++)
6. 6     {
7. 7         int flag = 0;
8. 8         for (int j = 2; j < i; j++)
9. 9         {
10. 10             if (i % j == 0)
11. 11             {
12. 12                 flag = 1;
13. 13                 break;
14. 14             }
15. 15              else
16. 16             {
17. 17                 printf("%d ", i);
18. 18                 count++;
19. 19                 break;
20. 20             }
21. 21            
22. 22     }
23. 23     printf("count=%d\n", count);
24. 24
25. 25     return 0;
26. 26 }

复制代码

　　我这里就是出现了一个明显的错误，我当时没有想到，后来才明白的，这个是内部循环每次都会除，当一开始的时间，不能被整除的话，可能直接就退出循环了，就比如105，这个就不是素数，由于一开始不能被2整除，但是一眼就可以看出来，105%5=0，这个是我一开始没有想到的，后来借鉴了csdn，知道了整一个标志位，直接看标志位来确认这一整个循环是否全部完成，最终的结果来看是否是素数，直接上代码

1. 1 // 题目：打印100~200之间的素数(素数，除了1和它本身不能被其他数整除的数字，例如2、3、5、7等等)
2. 2 #include <stdio.h>
3. 3 int main()
4. 4 {
5. 5     int count = 0;
6. 6     for (int i = 100; i < 200; i++)
7. 7     {
8. 8         int flag = 0;
9. 9         for (int j = 2; j < i; j++)
10. 10         {
11. 11             if (i % j == 0)
12. 12             {
13. 13                 flag = 1;
14. 14                 break;
15. 15             }
16. 16         }
17. 17         if (flag == 0)
18. 18         {
19. 19             printf("%d ", i);
20. 20             count++;
21. 21         }
22. 22     }
23. 23     printf("count=%d\n", count);
24. 24
25. 25     return 0;
26. 26 }

复制代码

　　这里我才知道如许，内循环全部完整的运行以便才气算是，计算出是否完满是素数
 
 
 
注：现在已老实，求放过，随心所感条记，就是随便写写
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。