Returning an array of variable size in c from a function

Question

So i want to return an array of a size n (variable) which my function has as input. I know that in order to return arrays in C I have to define them static, but the problem is that n is a variable and thus I get an error. I thought of actually using malloc/calloc but then I won't be able to free them after the function returns the array. Please take note that I'm not allowed to change anything on main(). Are there any other alternatives which I could use? Thanks in advance.

float *Arr( int *a , int n ){
    static float b[ n ];
    return b
}

Got to point out that the function will only be called Once,I saw the solution you posted but i noticed you aren't freeing the allocated memory,is it not of much importance when the malloc is called inside a function?

Answer 1

The important thing to notice here is that this syntax:

float arr[n];

Allocates an array on the stack of the current function. In other words, that array is a local variable. Any local variable becomes invalid after the function returns, and therefore returning the array directly is undefined behavior. It will most likely cause a crash when trying to access the array from outside the function, if not anything worse.

In addition to that, declaring a variable-length array as static is invalid in any case.

If you want to write a function which creates and returns any kind of array (dynamically sized or not), the only option you have is to use dynamic allocation through malloc() and then return a pointer to the array (technically there's also alloca() to make dynamic stack allocations, but that would not allow you to return the pointer, and I would also avoid it as it can easily break your program if the allocation is too large).

Here's an example of correct code:

float *create_array(size_t n_elements){
    float *arr = malloc(sizeof(float) * n_elements);
    if (arr == NULL) {
        // Memory could not be allocated, handle the error appropriately.
    }

    return arr;
}

In this case, malloc() is reserving memory outside of the local stack of the function, in the heap. The result is a pointer that can be freely returned and passed around without any problem, since that area of memory keeps being valid after the function returns (until it is released). When you're done working with the data, you can release the allocated memory by calling free():

float *arr = create_array(100);
// ...
free(arr);

If you don't have a way to release the memory through free() after using malloc(), that's a problem in the long run, but in general, it is not a strict requirement: if your array is always needed, from its creation until the exit of the program, then there's no need to explicitly free() it, since memory is automatically released when the program terminates.

If your function needs to be called more than once or needs to create significantly sized arrays that are only useful in part of the program and should therefore be discarded when no longer in use, then I'm afraid there's no good way of doing it. You should use free() in that case.

---

To answer your question precisely:

Please take note that I'm not allowed to change anything on main(). Are there any other alternatives which I could use?

No, there are no other better alternatives. The only correct approach here is to dynamically allocate the array through malloc(). The fact that you cannot free it afterwards is a different kind of problem.