C语言第38课作业 第46，47行我看不懂怎么判断是否已经创建过

superswagy2002

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. #define MAX_LIMIT_MATRIX 100
   
5. 
   
6. void welcome(void);
   
7. int get_ins(void);
   
8. int *create_matrix(void);
   
9. void init_matrix(int *ptr);
   
10. void print_matrix(int *ptr);
    
11. void write_matrix(int *ptr);
    
12. void read_matrix(int *ptr);
    
13. 
    
14. void welcome(void)
    
15. {
    
16.         printf("\n============================\n");
    
17.         printf("* 欢迎使用该程序，指令如下 *\n");
    
18.         printf("* 1.生成一个 M*N 的矩阵    *\n");
    
19.         printf("* 2.初始化矩阵             *\n");
    
20.         printf("* 3.给矩阵中某个元素赋值   *\n");
    
21.         printf("* 4.读取矩阵中某个元素     *\n");
    
22.         printf("* 5.打印整个矩阵           *\n");
    
23.         printf("* 6.结束程序               *\n");
    
24.         printf("============================\n");
    
25. }
    
26. 
    
27. int get_ins(void)
    
28. {
    
29.         int ins;
    
30. 
    
31.         printf("\n请输入指令：");
    
32.         scanf("%d", &ins);
    
33. 
    
34.         while (ins < 1 || ins > 6)
    
35.         {
    
36.                 printf("\n指令错误，请重新输入：");
    
37.                 scanf("%d", &ins);
    
38.         }
    
39. 
    
40.         return ins;
    
41. }
    
42. 
    
43. int *create_matrix(void)
    
44. {
    
45.         int m, n;
    
46.         static int created = 0; // 用于判断是否已经创建过矩阵
    
47.         static int *ptr = NULL;
    
48. 
    
49.         if (created)
    
50.         {
    
51.                 printf("矩阵已存在，是否需要重新创建？（Y/N）-> ");
    
52.                 getchar(); // 清除缓冲区残留的换行符
    
53.                 while (getchar() == 'N')
    
54.                 {
    
55.                         return ptr;
    
56.                 }
    
57.         }
    
58. 
    
59.         printf("请输入新矩阵的规模（M*N）-> ");
    
60.         scanf("%d*%d", &m, &n);
    
61. 
    
62.         while (m < 1 || n < 1)
    
63.         {
    
64.                 printf("规模太小，请重新输入：");
    
65.                 scanf("%d*%d", &m, &n);
    
66.         }
    
67. 
    
68.         while (m > MAX_LIMIT_MATRIX || n > MAX_LIMIT_MATRIX)
    
69.         {
    
70.                 printf("规模太大，请重新输入：");
    
71.                 scanf("%d*%d", &m, &n);
    
72.         }
    
73. 
    
74.         // 虽然说是矩阵是二维数组，但在C语言中它的存放形式是“平铺”的
    
75.         // 这里用realloc，支持重新创建二维数组
    
76.         // 这里多申请了两个整形空间，用于存放矩阵的长和宽
    
77.         ptr = (int *)realloc(ptr, (m * n + 2)* sizeof(int));
    
78.         if (ptr == NULL)
    
79.         {
    
80.                 printf("内存申请失败！\n");
    
81.                 exit(1);
    
82.         }
    
83. 
    
84.         printf("%d*%d 的矩阵创建成功！\n", m, n);
    
85.         created = 1;
    
86. 
    
87.         // 将长和宽放在前两个元素中
    
88.         ptr[0] = m;
    
89.         ptr[1] = n;
    
90. 
    
91.         return ptr;
    
92. }
    
93. 
    
94. void init_matrix(int *ptr)
    
95. {
    
96.         int m = ptr[0];
    
97.         int n = ptr[1];
    
98.         int *matrix = ptr + 2;
    
99.         int num, i, j;
    
100. 
     
101.         if (ptr == NULL)
     
102.         {
     
103.                 printf("未检测到矩阵，请先生成矩阵！\n");
     
104.                 return ;
     
105.         }
     
106. 
     
107.         printf("请输入一个数字：");
     
108.         scanf("%d", &num);
     
109. 
     
110.         for (i = 0; i < m; i++)
     
111.         {
     
112.                 for (j = 0; j < n; j++)
     
113.                 {
     
114.                         matrix[i * n + j] = num;
     
115.                 }
     
116.         }
     
117. }
     
118. 
     
119. void print_matrix(int *ptr)
     
120. {
     
121.         int m = ptr[0];
     
122.         int n = ptr[1];
     
123.         int *matrix = ptr + 2;
     
124.         int i, j;
     
125. 
     
126.         if (ptr == NULL)
     
127.         {
     
128.                 printf("未检测到矩阵，请先生成矩阵！\n");
     
129.                 return ;
     
130.         }
     
131. 
     
132.         for (i = 0; i < m; i++)
     
133.         {
     
134.                 for (j = 0; j < n; j++)
     
135.                 {
     
136.                         printf("%d  ", matrix[i * n + j]);
     
137.                 }
     
138.                 putchar('\n');
     
139.         }
     
140. }
     
141. 
     
142. void write_matrix(int *ptr)
     
143. {
     
144.         int m = ptr[0];
     
145.         int n = ptr[1];
     
146.         int *matrix = ptr + 2;
     
147.         int num, x, y;
     
148. 
     
149.         if (ptr == NULL)
     
150.         {
     
151.                 printf("未检测到矩阵，请先生成矩阵！\n");
     
152.                 return ;
     
153.         }
     
154. 
     
155.         printf("请输入要修改的位置（行,列）-> ");
     
156.         scanf("%d,%d", &x, &y);
     
157. 
     
158.         if (x > m || y > n || x < 1 || y < 1)
     
159.         {
     
160.                 printf("坐标输入有误！\n");
     
161.                 return ;
     
162.         }
     
163. 
     
164.         printf("请输入一个数字：");
     
165.         scanf("%d", &num);
     
166. 
     
167.         matrix[(x - 1) * n + (y - 1)] = num;
     
168. }
     
169. 
     
170. void read_matrix(int *ptr)
     
171. {
     
172.         int m = ptr[0];
     
173.         int n = ptr[1];
     
174.         int *matrix = ptr + 2;
     
175.         int num, x, y;
     
176. 
     
177.         if (ptr == NULL)
     
178.         {
     
179.                 printf("未检测到矩阵，请先生成矩阵！\n");
     
180.                 return ;
     
181.         }
     
182. 
     
183.         printf("请输入要读取的位置（行,列）-> ");
     
184.         scanf("%d,%d", &x, &y);
     
185. 
     
186.         if (x > m || y > n || x < 1 || y < 1)
     
187.         {
     
188.                 printf("坐标输入有误！\n");
     
189.                 return ;
     
190.         }
     
191. 
     
192.         printf("第%d行，第%d列的数字是：%d\n", x, y, matrix[(x - 1) * n + (y - 1)]);
     
193. }
     
194. 
     
195. int main(void)
     
196. {
     
197.         int ins;
     
198.         int *ptr = NULL;
     
199. 
     
200.         welcome();
     
201. 
     
202.         while((ins = get_ins()) != 6)
     
203.         {
     
204.                 switch(ins)
     
205.                 {
     
206.                         case 1: ptr = create_matrix(); break;
     
207.                         case 2: init_matrix(ptr); break;
     
208.                         case 3: write_matrix(ptr); break;
     
209.                         case 4: read_matrix(ptr); break;
     
210.                         case 5: print_matrix(ptr); break;
     
211.                 }
     
212.         }
     
213. 
     
214.         printf("\n感谢使用本程序^_^\n\n");
     
215. 
     
216.         free(ptr);
     
217. 
     
218.         return 0;
     
219. }

复制代码

jackz007

         static 定义静态变量，静态变量与一般局部变量有所区别，局部变量的生命周期只是在函数被调用期间，也就是说，局部变量只是存在于函数被调用期间，函数调用结束后，局部变量就不复存在。静态变量就不同了，静态变量的生命周期是程序运行的全过程，静态变量会在程序编译时被赋值初始化，其值在后续的函数调用过程中，将始终被保持。
         考察一下下面的代码可以帮助加深理解：

1. #include <stdio.h>
   
2. 
   
3. void foo()
   
4. {
   
5.         static int a = 0                    ; // 静态变量只在程序编译时被初始化一次，不会在函数被调用时初始化
   
6.         int b = 0                           ; // 局部变量在函数每次被调用的时候都要被初始化一次。
   
7.         a ++                                ;
   
8.         b ++                                ;
   
9.         printf("a = %d , b = %d\n" , a , b) ;
   
10. }
    
11. 
    
12. int main(void)
    
13. {
    
14.         int i , m = 10                      ;
    
15.         for(i = 0 ; i < m ; i ++) foo()     ;
    
16. }

复制代码

        编译、运行实况：

1. D:\00.Excise\C>g++ -o x x.c
   
2. 
   
3. D:\00.Excise\C>x
   
4. a = 1 , b = 1
   
5. a = 2 , b = 1
   
6. a = 3 , b = 1
   
7. a = 4 , b = 1
   
8. a = 5 , b = 1
   
9. a = 6 , b = 1
   
10. a = 7 , b = 1
    
11. a = 8 , b = 1
    
12. a = 9 , b = 1
    
13. a = 10 , b = 1
    
14. 
    
15. D:\00.Excise\C>

复制代码