function return value array

First look at a subclass of the return value array: #include<stdio. h>

2. #define N 5
4. int *print()
   
6. {
   
8. int a[N];
   
10. int i;
    
12. for(i=0; I<n; I )
    
14. A[i]=i;
    
18. return a;
    
20. }
    
22. int main()
    
24. {
    
26. int *b, I;
    
28. b=print();
    
32. for(i=0; I<n; I )
    
34. printf("%d\n", b[i]);
    
38. return 0;
    
40. }

This class is a function that returns an array, and the result is incorrect. The reason is that in the function print (), the array a[n] is a local variable, and when your function is finished, it will automatically release its space, so return a is simply returning a pointer to the array a[n] Value. In the main function, B should receive the address of the array a[n] (i.e. the address of the array itself), and the space occupied by it will be released with the completion of the function call, so the answer is incorrect. The return value of the function is an array, and the following two modifications will give the correct answer, the code is as follows:

2. #include<stdio. h>
   
4. #include<stdlib. h>
   
6. #define N 5
8. int *print()
   
10. {
    
12. static int a[N];
    
14. int i;
    
16. for(i=0; I<n; I )
    
18. A[i]=i;
    
22. return a;
    
24. }
    
26. int *print1()
    
28. {
    
30. int *a;
    
32. int i;
    
34. A=(int *) malloc(N);
    
36. for(i=0; I<n; I )
    
38. {
    
40. A[i]=i;
    
42. }
    
46. return a;
    
48. }
    
50. int main()
    
52. {
    
54. int *b;
    
56. // int b[N];
    
58. int i;
    
60. b=print1();
    
64. for(i=0; I<n; I )
    
66. printf("%d\n", b[i]);
    
70. return 0;
    
72. }

Whether you call the print () function or call the Print1 () function, you get the correct result. The reason for calling the print () function is to add the static keyword before the array a[n], which causes a[n] to be stored in the static storage area in memory. The occupied storage unit is not released until the entire program runs to the end. So when the main function calls the print () function, the space still exists. Therefore, the B pointer in the main () function receives the first value of the array and can access the elements in the array. Call Print1 () function: Put array a[n] Change to the pointer *a, and then give the pointer to apply for space, also can run normally. Because when you apply space to pointer A, the space allocated to the pointer is on the heap, and the space on the heap is allocated and released automatically by the programmer. If the programmer does not release,      It may be released by the OS at the end of the program. So the B pointer in the main function can also receive the first value of the space and get the correct answer. Error test.c:30:warning:assignment makes integer from pointer without a cast or test.c:30 when the int *b annotation in the main function is changed to int b[n]: Error:incompatible types when the assigning to type ' int[5] ' from type ' int * ' does not get the correct result for the following reasons: The return value of B in the main function is the first value of the array, and if it is *b, it is  Pointer b points to the first value of the array, so that the pointer variable moves backwards to access all the elements in the array. And if it is b[n], the equivalent of the compiler on the stack to the array b[n] allocated N int space, so B points to the first value of a, cannot pass this address, modify the value of its own application. You can access the source data by moving the pointer backwards through the first value through a pointer. And because B is not initialized , so the result is a random value.PostScript:The purpose of writing this is simply to understand this knowledge through the return value, and of course, the parameter is the best choice.

function return value array