[已解决]C语言输出值问题求教

foxiangzun

今天在网上看到一段分解质因数的代码，想自己试试，于是抄了过来，自己玩了一下，果然，玩脱了。。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <malloc.h>
   
4. 
   
5. int main() {
   
6.     int inputNum = 0, j = 0;
   
7.     printf("Please input a NUMBER to decomposed prime factor: ");
   
8.     scanf("%d", &inputNum);
   
9.     printf("The prime factors are: ");
   
10.     const int leng = 1;
    
11.     int *result = (int *)malloc(leng * sizeof(int));
    
12.     int i = 2;
    
13.     int result_idx = 0;
    
14.     while (i * i <= inputNum) {
    
15.         while (inputNum % i == 0) {
    
16.             result[result_idx] = i;
    
17.             inputNum /= i;
    
18.             result_idx++;
    
19.         }
    
20.         i++;
    
21.     }
    
22.     if (inputNum > 1) {
    
23.         result[result_idx] = inputNum;
    
24.     }
    
25.     while (j <= result_idx) {
    
26.         printf("%d\t", result[j]);
    
27.         j++;
    
28.     }
    
29. 
    
30.     return 0;
    
31. }

复制代码

最后一个 while，括号里如果是 “j <= result_idx”，那么在 scanf 的地方输入 1024，就会多出一个未分配的地址。。但是如果改成 “j < result_idx”，输入 74 或者 82 这样的数，质因数又不会完全显示。。如下图。。





求各位大佬帮忙掌掌眼，看看我这是哪里弄错了。。

最佳答案

月排行榜 / 总排行榜

jackz007

2022-7-24 23:54:25

1.     const int leng = 1 ;
   
2.     int * result = (int *)malloc(leng * sizeof(int)) ; // result 只分配了 1 个元素空间，就是说，只有 result[0] 可以存入 1 个整型数。
   
3. . . . . . .
   
4.             result[result_idx] = i ; // result 只有保存一个整数的能力，却被当成一维整型数组，用于保存多个元素，必然导致下标越界。

复制代码

        下面是我写的代码，可以不用一维数组

1. #include <stdio.h>
   
2. 
   
3. int main(void)
   
4. {
   
5.         int c , k , n                                                 ;
   
6.         printf("Please input a NUMBER to decomposed prime factor : ") ;
   
7.         scanf("%d" , & n)                                             ;
   
8.         printf("The prime factors are : ")                            ;
   
9.         for(c = 0 , k = 2 ; k * k < n + 1 ; k ++) {
   
10.                 for(; ! (n % k) && (k * k < n + 1) ; n /= k , c ++) {
    
11.                         if(c) printf("\t")                            ;
    
12.                         printf("%d" , k)                              ;
    
13.                 }                                                     ;
    
14.         }
    
15.         if(c) printf("\t")                                            ;
    
16.         printf("%d\n" , n)                                            ;
    
17. }

复制代码

        编译、运行实况：

1. D:\[00.Exerciese.2022]\C>g++ -o x x.c
   
2. 
   
3. D:\[00.Exerciese.2022]\C>x
   
4. Please input a NUMBER to decomposed prime factor : 1024
   
5. The prime factors are : 2       2       2       2       2       2       2
   
6. 2       2       2
   
7. 
   
8. D:\[00.Exerciese.2022]\C>

复制代码

跳转到最佳答案楼层

jackz007

1.     const int leng = 1 ;
   
2.     int * result = (int *)malloc(leng * sizeof(int)) ; // result 只分配了 1 个元素空间，就是说，只有 result[0] 可以存入 1 个整型数。
   
3. . . . . . .
   
4.             result[result_idx] = i ; // result 只有保存一个整数的能力，却被当成一维整型数组，用于保存多个元素，必然导致下标越界。

复制代码

        下面是我写的代码，可以不用一维数组

1. #include <stdio.h>
   
2. 
   
3. int main(void)
   
4. {
   
5.         int c , k , n                                                 ;
   
6.         printf("Please input a NUMBER to decomposed prime factor : ") ;
   
7.         scanf("%d" , & n)                                             ;
   
8.         printf("The prime factors are : ")                            ;
   
9.         for(c = 0 , k = 2 ; k * k < n + 1 ; k ++) {
   
10.                 for(; ! (n % k) && (k * k < n + 1) ; n /= k , c ++) {
    
11.                         if(c) printf("\t")                            ;
    
12.                         printf("%d" , k)                              ;
    
13.                 }                                                     ;
    
14.         }
    
15.         if(c) printf("\t")                                            ;
    
16.         printf("%d\n" , n)                                            ;
    
17. }

复制代码

        编译、运行实况：

1. D:\[00.Exerciese.2022]\C>g++ -o x x.c
   
2. 
   
3. D:\[00.Exerciese.2022]\C>x
   
4. Please input a NUMBER to decomposed prime factor : 1024
   
5. The prime factors are : 2       2       2       2       2       2       2
   
6. 2       2       2
   
7. 
   
8. D:\[00.Exerciese.2022]\C>

复制代码

foxiangzun

jackz007 发表于 2022-7-24 23:54
下面是我写的代码，可以不用一维数组

        编译、运行实况：

感谢大佬的解答


不过这段代码，我旨在希望把指针和内存分配，以及对应的取值给弄懂。。

顺着阁下提到下标越界的问题，我又在这里加了一个变量，然后在函数体中用了 realloc，但是还是有那个问题。。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <malloc.h>
   
4. 
   
5. int main() {
   
6.     int inputNum = 0, j = 0;
   
7.     printf("Please input a NUMBER to decomposed prime factor: ");
   
8.     scanf("%d", &inputNum);
   
9.     printf("The prime factors are: ");
   
10.     const int leng = 1;
    
11.     int localLen = leng;
    
12.     int *result = (int *)malloc(localLen * sizeof(int));
    
13.     int i = 2;
    
14.     int result_idx = 0;
    
15.     while (i * i <= inputNum) {
    
16.         while (inputNum % i == 0) {
    
17.             result[result_idx] = i;
    
18.             inputNum /= i;
    
19.             result_idx++;
    
20.             if (result_idx >= localLen)
    
21.             {
    
22.                 localLen += leng;
    
23.                 result = (int *)realloc(result, localLen * sizeof(int));
    
24.             }
    
25.         }
    
26.         i++;
    
27.     }
    
28.     if (inputNum > 1) {
    
29.         result[result_idx] = inputNum;
    
30.     }
    
31.     while (j <= result_idx) {
    
32.         printf("%d\t", result[j]);
    
33.         j++;
    
34.     }
    
35. 
    
36.     return 0;
    
37. }

复制代码

foxiangzun

问题找到了。。在上面的嵌套 while 中，里面的 while 一直都有一个 result_idx++ 的动作，如果是某一个质数的幂数，那么在这里会先把 result_idx 加一，然后直接跳出整个循环，这样在 result 的最后一个下标，是一个未被赋值的野指针，所以如果输入 1024、59049、8、64 等这些数后，显示的结果里，最后一个质数其实就是一个野指针。找到问题后，改进的代码就知道怎么调了，加个判断就行了，同时将内存重新分配的代码，拿到上面来，避免未经分配跳出循环。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <malloc.h>
   
4. 
   
5. int main() {
   
6.     int inputNum = 0, j = 0;
   
7.     printf("Please input a NUMBER to decomposed prime factor: ");
   
8.     scanf("%d", &inputNum);
   
9.     printf("The prime factors are: ");
   
10.     const int leng = 1;
    
11.     int localLen = leng;
    
12.     int *result = (int *)malloc(localLen * sizeof(int));
    
13.     int i = 2;
    
14.     int result_idx = 0;
    
15.     while (i * i <= inputNum) {
    
16.         while (inputNum % i == 0) {
    
17.             if (result_idx >= localLen) {
    
18.                 localLen += leng;
    
19.                 result = (int *)realloc(result, localLen * sizeof(int));
    
20.             }
    
21.             if (inputNum != i) {
    
22.                 result[result_idx] = i;
    
23.                 inputNum /= i;
    
24.                 result_idx++;
    
25.             } else {
    
26.                 result[result_idx] = i;
    
27.                 inputNum /= i;
    
28.             }
    
29.         }
    
30.         i++;
    
31.     }
    
32.     if (inputNum > 1) {
    
33.         result[result_idx] = inputNum;
    
34.     }
    
35.     while (j <= result_idx) {
    
36.         printf("%d\t", result[j]);
    
37.         j++;
    
38.     }
    
39. 
    
40.     return 0;
    
41. }

复制代码