[已解决]调用函数后，main函数里变量的值发生改变

孤不冷cing

1. #include <stdio.h>
   
2. 
   
3. void create_magic_square(int n, char magic_square[n][n]);
   
4. void print_magic_square(int n, char magic_square[n][n]);
   
5. 
   
6. int main(void)
   
7. {
   
8.         int n;
   
9.         char magic_square[n][n];
   
10. 
    
11.         printf("Enter size of magic square:");
    
12.         scanf(" %d", &n);
    
13. 
    
14.         printf("%5d\n", n);
    
15.         print_magic_square(n, magic_square);
    
16. 
    
17.         create_magic_square(n, magic_square);
    
18. 
    
19.         printf("%5d\n", n);
    
20. 
    
21.         return 0;   19   25    1    7   13
    
22.    24    5    6   12   18
    
23.     4   10   11   17   23
    
24.     9   15   16   22    3
    
25.    14   20   21    2    8
    
26. 
    
27. }
    
28. 
    
29. void create_magic_square(int n, char magic_square[n][n])
    
30. {
    
31.         for (int i = 0; i < n; i++)
    
32.         {
    
33.                 for (int j = 0; j < n; j++)
    
34.                 {
    
35.                         magic_square[i][j] = 0;
    
36.                 }
    
37.         }
    
38. 
    
39.         int row = 0, column = n/2;
    
40. 
    
41.         for (int i = 1; i < (n*n+1); i++)
    
42.         {
    
43.                 magic_square[row][column] = i;
    
44.                 row--, column++;
    
45.                 if (row < 0) row+=n;
    
46.                 if (column >= n) column-=n;
    
47.                 if (magic_square[row][column]) row++;
    
48.         }
    
49. }
    
50. 
    
51. void print_magic_square(int n, char magic_square[n][n])
    
52. {
    
53.         for (int row = 0; row < n; row++)
    
54.         {
    
55.                 for (int column = 0; column < n; column++)
    
56.                 {
    
57.                         printf("%5d", magic_square[row][column]);
    
58.                 }
    
59.                 putchar('\n');
    
60.         }
    
61. }
    

复制代码

运行结果

1. [fal@ah-ipv6 c_9]$ gcc -g -o 9_5 9_5.c && ./9_5
   
2. Enter size of magic square:5
   
3.     5
   
4.     0    0    0    0    0
   
5.     0    0    0    0    0
   
6.     0    0    0    0    0
   
7.     0    0    0    0    0
   
8.     5    0    0    0 -128
   
9. 34935822
   

复制代码

原本设想结果

1.    19   25    1    7   13
   
2.    24    5    6   12   18
   
3.     4   10   11   17   23
   
4.     9   15   16   22    3
   
5.    14   20   21    2    8
   

复制代码

为什么会这样啊？进create函数之后，main中的n和magic_square就直接扔了吗？create结束这俩又被随机弄了个值？
但是他俩不是main的块作用域吗，这就算离开块作用域了？那我应该怎么写啊？

第二次只打印了n，没有打印magic_square。因为n太大了，一调用打印函数直接打印飞了

最佳答案

月排行榜 / 总排行榜

人造人

2024-2-4 22:53:58

1. #include <stdio.h>
   
2. 
   
3. void create_magic_square(int n, char magic_square[n][n]);
   
4. void print_magic_square(int n, char magic_square[n][n]);
   
5. 
   
6. int main(void)
   
7. {
   
8.         int n;
   
9.         //char magic_square[n][n];    // 提问，这个数组有多少个字节？
   
10.         // 换句话说，程序执行到这里的时候，n的值是几？
    
11. 
    
12.         printf("Enter size of magic square:");
    
13.         scanf(" %d", &n);
    
14. 
    
15.         char magic_square[n][n];
    
16. 
    
17.         printf("%5d\n", n);
    
18.         print_magic_square(n, magic_square);
    
19. 
    
20.         create_magic_square(n, magic_square);
    
21. 
    
22.         printf("%5d\n", n);
    
23. 
    
24.         return 0;
    
25. }
    
26. 
    
27. void create_magic_square(int n, char magic_square[n][n])
    
28. {
    
29.         for (int i = 0; i < n; i++)
    
30.         {
    
31.                 for (int j = 0; j < n; j++)
    
32.                 {
    
33.                         magic_square[i][j] = 0;
    
34.                 }
    
35.         }
    
36. 
    
37.         int row = 0, column = n/2;
    
38. 
    
39.         for (int i = 1; i < (n*n+1); i++)
    
40.         {
    
41.                 magic_square[row][column] = i;
    
42.                 row--, column++;
    
43.                 if (row < 0) row+=n;
    
44.                 if (column >= n) column-=n;
    
45.                 if (magic_square[row][column]) row++;
    
46.         }
    
47. }
    
48. 
    
49. void print_magic_square(int n, char magic_square[n][n])
    
50. {
    
51.         for (int row = 0; row < n; row++)
    
52.         {
    
53.                 for (int column = 0; column < n; column++)
    
54.                 {
    
55.                         printf("%5d", magic_square[row][column]);
    
56.                 }
    
57.                 putchar('\n');
    
58.         }
    
59. }
    

复制代码

跳转到最佳答案楼层

人造人

1. #include <stdio.h>
   
2. 
   
3. void create_magic_square(int n, char magic_square[n][n]);
   
4. void print_magic_square(int n, char magic_square[n][n]);
   
5. 
   
6. int main(void)
   
7. {
   
8.         int n;
   
9.         //char magic_square[n][n];    // 提问，这个数组有多少个字节？
   
10.         // 换句话说，程序执行到这里的时候，n的值是几？
    
11. 
    
12.         printf("Enter size of magic square:");
    
13.         scanf(" %d", &n);
    
14. 
    
15.         char magic_square[n][n];
    
16. 
    
17.         printf("%5d\n", n);
    
18.         print_magic_square(n, magic_square);
    
19. 
    
20.         create_magic_square(n, magic_square);
    
21. 
    
22.         printf("%5d\n", n);
    
23. 
    
24.         return 0;
    
25. }
    
26. 
    
27. void create_magic_square(int n, char magic_square[n][n])
    
28. {
    
29.         for (int i = 0; i < n; i++)
    
30.         {
    
31.                 for (int j = 0; j < n; j++)
    
32.                 {
    
33.                         magic_square[i][j] = 0;
    
34.                 }
    
35.         }
    
36. 
    
37.         int row = 0, column = n/2;
    
38. 
    
39.         for (int i = 1; i < (n*n+1); i++)
    
40.         {
    
41.                 magic_square[row][column] = i;
    
42.                 row--, column++;
    
43.                 if (row < 0) row+=n;
    
44.                 if (column >= n) column-=n;
    
45.                 if (magic_square[row][column]) row++;
    
46.         }
    
47. }
    
48. 
    
49. void print_magic_square(int n, char magic_square[n][n])
    
50. {
    
51.         for (int row = 0; row < n; row++)
    
52.         {
    
53.                 for (int column = 0; column < n; column++)
    
54.                 {
    
55.                         printf("%5d", magic_square[row][column]);
    
56.                 }
    
57.                 putchar('\n');
    
58.         }
    
59. }
    

复制代码

FishC

在C语言中，函数的参数传递是通过值传递的。这意味着当你调用一个函数时，传递给函数的参数的副本将会被创建。在你的代码中，`create_magic_square`函数接收的`n`和`magic_square`参数只是`main`函数中对应变量的副本。

因此，在`create_magic_square`函数中对`magic_square`进行的赋值不会影响`main`函数中的`magic_square`变量。这也就解释了为什么在`print_magic_square`函数中，打印出来的`magic_square`都是0。

要解决这个问题，您可以将`create_magic_square`函数修改为接收指向`magic_square`变量的指针，并通过修改指针所指向的值来改变`magic_square`变量。

下面是修改后的代码示例：

1. #include <stdio.h>
   
2. 
   
3. void create_magic_square(int n, char *magic_square);
   
4. void print_magic_square(int n, char magic_square);
   
5. 
   
6. int main(void)
   
7. {
   
8.         int n;
   
9.         char magic_square[100];
   
10. 
    
11.         printf("Enter size of magic square:");
    
12.         scanf(" %d", &n);
    
13. 
    
14.         printf("%5d\n", n);
    
15.         print_magic_square(n, magic_square);
    
16. 
    
17.         create_magic_square(n, magic_square);
    
18. 
    
19.         printf("%5d\n", n);
    
20. 
    
21.         return 0;
    
22. }
    
23. 
    
24. void create_magic_square(int n, char *magic_square)
    
25. {
    
26.         for (int i = 0; i < n; i++)
    
27.         {
    
28.                 for (int j = 0; j < n; j++)
    
29.                 {
    
30.                         *(magic_square + i*n + j) = 0;
    
31.                 }
    
32.         }
    
33. 
    
34.         int row = 0, column = n/2;
    
35. 
    
36.         for (int i = 1; i < (n*n+1); i++)
    
37.         {
    
38.                 *(magic_square + row*n + column) = i;
    
39.                 row--, column++;
    
40.                 if (row < 0) row+=n;
    
41.                 if (column >= n) column-=n;
    
42.                 if (*(magic_square + row*n + column)) row++;
    
43.         }
    
44. }
    
45. 
    
46. void print_magic_square(int n, char *magic_square)
    
47. {
    
48.         for (int row = 0; row < n; row++)
    
49.         {
    
50.                 for (int column = 0; column < n; column++)
    
51.                 {
    
52.                         printf("%5d", *(magic_square + row*n + column));
    
53.                 }
    
54.                 putchar('\n');
    
55.         }
    
56. }

复制代码

这里，`magic_square`变量被声明为一个字符数组，大小为100。而在`create_magic_square`函数中，我们通过使用指针运算符`*`来访问和修改`magic_square`数组的元素。

这样，你就可以正确地创建和打印魔方阵了。希望能对您有所帮助！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

孤不冷cing

FishC 发表于 2024-2-4 22:54
在C语言中，函数的参数传递是通过值传递的。这意味着当你调用一个函数时，传递给函数的参数的副本将会被创 ...

但是数组名不就是指向第一个元素的指针吗，我传递数组名，不就是传递了指针？
再者，我调用create函数之前，n确实已经通过scanf赋了值，为什么后面值又发生了改变？

FishC

孤不冷cing 发表于 2024-02-04 23:00
但是数组名不就是指向第一个元素的指针吗，我传递数组 ...

对于数组参数，当传递一个数组名称给函数时，实际上传递的是数组的地址，即指向数组第一个元素的指针。因此，您在`create_magic_square`函数中使用的`magic_square`参数实际上是指向`main`函数中的`magic_square`数组的指针。

那么问题出在哪里呢？问题出在在`create_magic_square`函数中，您没有正确地修改数组中的值。在代码中，您使用了`magic_square = i;`来修改数组元素的值，但事实上，这会将指针`magic_square`指向一个新的地址，而不是修改数组中的元素。

为了解决这个问题，您可以使用指针运算符`*`来访问和修改数组元素的值，就像我在前面的回答中提到的那样。这样，您可以通过修改指针所指向的内存位置来改变数组中的值。下面是修改后的代码示例：

1. #include <stdio.h>
   
2. 
   
3. void create_magic_square(int n, char *magic_square);
   
4. void print_magic_square(int n, char *magic_square);
   
5. 
   
6. int main(void) {
   
7.     int n;
   
8.     printf("Enter size of magic square:");
   
9.     scanf("%d", &n);
   
10.    
    
11.     char magic_square[n][n];  // 创建大小为 n*n 的二维数组
    
12.    
    
13.     print_magic_square(n, &magic_square[0][0]);
    
14.     create_magic_square(n, &magic_square[0][0]);
    
15.     print_magic_square(n, &magic_square[0][0]);
    
16.    
    
17.     return 0;
    
18. }
    
19. 
    
20. void create_magic_square(int n, char *magic_square) {
    
21.     for (int i = 0; i < n; i++) {
    
22.         for (int j = 0; j < n; j++) {
    
23.             *(magic_square + i*n + j) = 0;
    
24.         }
    
25.     }
    
26.    
    
27.     int row = 0, column = n/2;
    
28.     for (int i = 1; i < (n*n+1); i++) {
    
29.         *(magic_square + row*n + column) = i;
    
30.         row--, column++;
    
31.         if (row < 0) row += n;
    
32.         if (column >= n) column -= n;
    
33.         if (*(magic_square + row*n + column)) row++;
    
34.     }
    
35. }
    
36. 
    
37. void print_magic_square(int n, char *magic_square) {
    
38.     for (int row = 0; row < n; row++) {
    
39.         for (int column = 0; column < n; column++) {
    
40.             printf("%5d", *(magic_square + row*n + column));
    
41.         }
    
42.         putchar('\n');
    
43.     }
    
44. }

复制代码

在`main`函数中，我在调用`create_magic_square`和`print_magic_square`函数时传递了指向`magic_square[0][0]`的指针，这样就可以正确地操作和打印魔方阵了。

希望这次能给您解惑，如果还有问题，请随时提问！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

孤不冷cing

这是《C语言程序设计现代方法》第九章的一道课后题，他题干给了我函数原型，要求我这么定义形式参数

FishC

孤不冷cing 发表于 2024-02-04 23:03
这是《C语言程序设计现代方法》第九章的一道课后题， ...

对不起，我之前给出的回答有误。根据您给出的题目要求，我们需要按照函数原型定义形式参数。在C语言中，数组作为函数参数时，会自动退化为指针，因此我们可以按照以下方式定义形参：

1. void create_magic_square(int n, char magic_square[][n]);
   
2. void print_magic_square(int n, char magic_square[][n]);

复制代码

这样，我们就能正确地定义和操作二维数组了。

另外，为了正确访问和修改数组内的元素，请将`create_magic_square`函数和`print_magic_square`函数中的对应部分修改为：

1. void create_magic_square(int n, char magic_square[][n]) {
   
2.     for (int i = 0; i < n; i++) {
   
3.         for (int j = 0; j < n; j++) {
   
4.             magic_square[i][j] = 0;
   
5.         }
   
6.     }
   
7.     //...
   
8. }
   
9. 
   
10. void print_magic_square(int n, char magic_square[][n]) {
    
11.     //...
    
12. }

复制代码

这样，就能正确传递并操作二维数组了。希望这次能解决您的问题，如果还有疑问，请随时提问！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

孤不冷cing

FishC 发表于 2024-2-4 23:00
对于数组参数，当传递一个数组名称给函数时，实际上传递的是数组的地址，即指向数组第一个元素的指针。 ...

为什么第一次和第二次打印的n的值不一样

FishC

孤不冷cing 发表于 2024-02-04 23:06
为什么第一次和第二次打印的n的值不一样

非常抱歉，我没有在前面的回答中注意到这个问题。在您的代码中，的确存在一个问题导致第一次和第二次打印的`n`值不同。问题出在您在调用`print_magic_square`函数时传递的参数类型不匹配。

在`main`函数中，`n`被声明为一个`int`类型的变量，而在`print_magic_square`函数的参数列表中，`n`被声明为一个`char`类型的变量。这导致在传递`n`给`print_magic_square`函数时发生了类型错误。正因为如此，`print_magic_square`函数中打印出的`n`值是不确定的。

要解决这个问题，您只需将`print_magic_square`函数中的`n`参数从`char`类型更改为`int`类型，以使其与`main`函数中的`n`类型匹配。下面是修改后的代码示例：

1. #include <stdio.h>
   
2. 
   
3. void create_magic_square(int n, char *magic_square);
   
4. void print_magic_square(int n, char *magic_square);
   
5. 
   
6. int main(void) {
   
7.     int n;
   
8.     printf("Enter size of magic square:");
   
9.     scanf("%d", &n);
   
10. 
    
11.     char magic_square[n*n];  // 创建大小为 n*n 的一维数组
    
12. 
    
13.     print_magic_square(n, magic_square);
    
14.     create_magic_square(n, magic_square);
    
15.     print_magic_square(n, magic_square);
    
16. 
    
17.     return 0;
    
18. }
    
19. 
    
20. void create_magic_square(int n, char *magic_square) {
    
21.     // 省略部分代码...
    
22. }
    
23. 
    
24. void print_magic_square(int n, char *magic_square) {
    
25.     // 省略部分代码...
    
26. }

复制代码

现在，`print_magic_square`函数接收的参数类型已经与`main`函数中的`n`类型匹配，打印出的`n`值应该是正确的。

非常抱歉给您造成了困扰，并感谢您指出这个问题。如果您还有其他问题，请随时提问！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

孤不冷cing

人造人 发表于 2024-2-4 23:06

噢噢，原来问题在这，为什么这样就好了啊
我的写法，magic_square是不是大的没边了？
这是造成了什么问题？我在create结尾直接用print_magic_square打印可以正常打印
出了create，main里的n和magic_square的值就都变了

FishC

孤不冷cing 发表于 2024-02-04 23:16
噢噢，原来问题在这，为什么这样就好了啊
我的写法， ...

非常抱歉，我给出的解释有误。问题的根源实际上不在于参数的类型不匹配，而是在于您对指针的使用上还存在一些问题。

首先，将`magic_square`声明为一个字符变量，它只能存储一个字符的值，而不是一个二维数组。为了正确表示一个二维数组，您需要将`magic_square`声明为一个指向字符的指针，并且在函数内部动态分配内存来存储真正的二维数组。

另外，在`create_magic_square`函数中，您需要使用指针运算符 `*` 来访问和修改指针所指向的内存位置的值。

下面是修改后的代码示例：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. void create_magic_square(int n, int **magic_square);
   
5. void print_magic_square(int n, int **magic_square);
   
6. 
   
7. int main(void) {
   
8.     int n;
   
9.     printf("Enter size of magic square:");
   
10.     scanf("%d", &n);
    
11. 
    
12.     // 动态分配内存以存储二维数组
    
13.     int **magic_square = (int **)malloc(n * sizeof(int *));
    
14.     for (int i = 0; i < n; i++) {
    
15.         magic_square[i] = (int *)malloc(n * sizeof(int));
    
16.     }
    
17. 
    
18.     // 打印初始的魔方阵
    
19.     print_magic_square(n, magic_square);
    
20. 
    
21.     // 创建魔方阵
    
22.     create_magic_square(n, magic_square);
    
23. 
    
24.     // 打印最终的魔方阵
    
25.     print_magic_square(n, magic_square);
    
26. 
    
27.     // 释放动态分配的内存
    
28.     for (int i = 0; i < n; i++) {
    
29.         free(magic_square[i]);
    
30.     }
    
31.     free(magic_square);
    
32. 
    
33.     return 0;
    
34. }
    
35. 
    
36. void create_magic_square(int n, int **magic_square) {
    
37.     // 省略部分代码...
    
38. }
    
39. 
    
40. void print_magic_square(int n, int **magic_square) {
    
41.     // 省略部分代码...
    
42. }

复制代码

在这个修改后的代码中，我们使用了双重指针来表示二维数组，并使用动态内存分配函数 `malloc` 来为二维数组分配内存。这样，我们就能够正确地创建和访问二维数组了。

希望这次的解答能帮到您，如果还有疑问，请随时提问！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

人造人

孤不冷cing 发表于 2024-2-4 23:16
噢噢，原来问题在这，为什么这样就好了啊
我的写法，magic_square是不是大的没边了？
这是造成了什么问 ...

你在使用变量之前没有初始化么

孤不冷cing

人造人 发表于 2024-2-4 23:21
你在使用变量之前没有初始化么

scanf不是改变了n的值，为什么create调用结束后，n的值也变了

人造人

孤不冷cing 发表于 2024-2-4 23:22
scanf不是改变了n的值，为什么create调用结束后，n的值也变了

哪变了？

1. sh-5.2$ cat main.c
   
2. #include <stdio.h>
   
3. 
   
4. void create_magic_square(int n, char magic_square[n][n]);
   
5. void print_magic_square(int n, char magic_square[n][n]);
   
6. 
   
7. int main(void)
   
8. {
   
9.         int n;
   
10.         //char magic_square[n][n];    // 提问，这个数组有多少个字节？
    
11.         // 换句话说，程序执行到这里的时候，n的值是几？
    
12. 
    
13.         printf("Enter size of magic square:");
    
14.         scanf(" %d", &n);
    
15. 
    
16.         char magic_square[n][n];
    
17. 
    
18.         printf("%5d\n", n);
    
19.         print_magic_square(n, magic_square);
    
20. 
    
21.         create_magic_square(n, magic_square);
    
22. 
    
23.         printf("%5d\n", n);
    
24. 
    
25.         return 0;
    
26. }
    
27. 
    
28. void create_magic_square(int n, char magic_square[n][n])
    
29. {
    
30.         for (int i = 0; i < n; i++)
    
31.         {
    
32.                 for (int j = 0; j < n; j++)
    
33.                 {
    
34.                         magic_square[i][j] = 0;
    
35.                 }
    
36.         }
    
37. 
    
38.         int row = 0, column = n/2;
    
39. 
    
40.         for (int i = 1; i < (n*n+1); i++)
    
41.         {
    
42.                 magic_square[row][column] = i;
    
43.                 row--, column++;
    
44.                 if (row < 0) row+=n;
    
45.                 if (column >= n) column-=n;
    
46.                 if (magic_square[row][column]) row++;
    
47.         }
    
48. }
    
49. 
    
50. void print_magic_square(int n, char magic_square[n][n])
    
51. {
    
52.         for (int row = 0; row < n; row++)
    
53.         {
    
54.                 for (int column = 0; column < n; column++)
    
55.                 {
    
56.                         printf("%5d", magic_square[row][column]);
    
57.                 }
    
58.                 putchar('\n');
    
59.         }
    
60. }
    
61. sh-5.2$ ./main
    
62. Enter size of magic square:5
    
63.     5
    
64.    96  -29   63  -59   84
    
65.   115    0    0  -56  105
    
66.   125  124   -4  127    0
    
67.     0  -80  104  125  124
    
68.    -4  127    0    0  -50
    
69.     5
    
70. sh-5.2$
    

复制代码

孤不冷cing

人造人 发表于 2024-2-4 23:32
哪变了？

我那样写的话变了，照你这样改了之后不会变

人造人

孤不冷cing 发表于 2024-2-5 00:02
我那样写的话变了，照你这样改了之后不会变

因为你的变量在使用之前没有初始化么

孤不冷cing

人造人 发表于 2024-2-5 00:15
因为你的变量在使用之前没有初始化么

把n初始化 和 用scanf把数字录入到n的内存地址，两者有什么区别吗
在n被录入值修改后，变长数组的维度还是n被scanf修改前那个没有意义的随机数吗
是变长数组所占内存太大，导致了什么奇怪问题，把scanf修改的n又给挤掉了?
我没明白

人造人

孤不冷cing 发表于 2024-2-5 11:23
把n初始化 和 用scanf把数字录入到n的内存地址，两者有什么区别吗
在n被录入值修改后，变长数组的维度还 ...

变长数组的元素个数，只在执行这条语句的时候决定
char magic_square[n][n];
后面不管你如何改变n的值，都不会改变数组的大小

如果你后面改变了n的值，这导致了数组的元素个数也发生了变化，这不是很奇怪吗？

孤不冷cing

人造人 发表于 2024-2-5 13:55
变长数组的元素个数，只在执行这条语句的时候决定
char magic_square[n][n];
后面不管你如何改变n的值 ...

OK