I would like to extend the solution i found to return an array from a function, so that i have a function that creates an array with a length that's provided to this function.
But now if i call the function like this i get a warning, that ‘length’ is undeclared.
double * my_function(int length)
{
static double arr[length] = {0};
return arr;
}
How can this behavior be avoided?
If you are going to allocate variable length array, why not use calloc?
double * my_function(size_t length)
{
double *arr;
arr = calloc(length, sizeof *arr);
return arr;
}
free() the arr once you are done and check if it's NULL before using it.
Static arrays must have a length that is known at compile-time. With ordinary automatic arrays you can specify a variable length, but that is a special C99 feature called "variable-length arrays", or VLA's for short.
Variable-length static arrays are not possible because the storage for them has to be allocated even before your program is allowed to run by the operating system.
Automatic (local) variable-length arrays are possible because it just implies incrementing/decrementing the stack pointer by a variable rather than a constant. It is still a dangerous thing to do, though, because you can easily exceed the available stack space in case of having a larger value as the length.
Look into malloc. The *alloc functions are used to dynamically create arrays. They're created on something called the heap, and when you're programming, you need to make sure that things that are allocated on the heap are cared for properly, or you can start having memory leaks. In your case, you have somewhat taken care of it by making it static. The other major way to do things is to have the caller of the function free the memory when it's done with it.
Your usage should be something like this:
double * my_function(int length)
{
static double * arr = NULL;
if (arr == NULL) {
arr = malloc(length * sizeof(double));
}
return arr;
}
Note, by having the static and putting the wrapper around it as I did, this is setting arr up to fit a singleton design.
The non-singleton alternative is:
double * my_function(int length)
{
static double * arr = NULL;
if (arr != NULL) {
free(arr);
}
arr = malloc(length * sizeof(double));
return arr;
}
This one reallocates each time it is called. Any function that saved the return value from my_function would then find it to be out of date.
malloc doesn't "create arrays", but instead returns a pointer to an unoccupied contiguous area of memory. In the terms of the C language, the latter is not an array.
malloc() is never called and NULL is returned always.NULL is waste of time, as free() is defined to accept NULL, at least from C99 on.
static double * arr = NULL; free (arr);First of all, this is not ANSI C (as far as I remember). You cannot declare arrays of size that is not a compile-time constant.
Secondly, this approach is in general considered extremely bad as it implements a function that is not thread-safe. Multiple threads using this function will corrupt each-other's data in this array.
A proper general way is to allocate an array using malloc()/calloc() inside the function. Depending on the problem you are trying to solve and performance requirements, you might consider doing various optimizations to avoid repeated/frequent allocations.
Just out of curiosity, Why didn't you use malloc?
and as mentioned above, since you are declaring a static array so the program will need to know the length of the array at compile time
