Welcome to Software Development on Codidact!
Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.
How to declare variable-length arrays correctly?
This is meant as a FAQ Q&A regarding variable-length arrays (VLA). The two bugs described below are surprisingly common.
I'm trying to use the variable-length arrays feature of C99 (and newer) but I'm facing problems with it.
-
Whenever I write a program like this, I get strange crashes and unexpected behavior:
int size; int array[size]; scanf("%d", &size); -
Similarly, I also get crashes and strange behavior when I do this:
int size = 1000000; ... int array[size];
1 answer
C programs are executed from top to bottom. You can't declare a VLA with an uninitialized variable as its size parameter. For the same reason at you can't do this:
int x;
printf("%d\n",x);
scanf("%d",&x);
If I type 5 as input to this program, then it doesn't magically go back and change the printf to print 5. Because it is already too late - I took input after I printed.
Similarly, int array[size]; doesn't create some magic bond between array and size. The array gets created to be as large as the value that size had at the point when that source code line was encountered. If size is uninitialized, then you get undefined behavior. Changing size afterwards does not change the size of the VLA. And you can't resize a VLA either.
In the second example where a very large VLA is created, the reason for unexpected crashes is simply stack overflow. VLA are to be regarded as local arrays and as such they are typically allocated on the stack. But the stack space is limited and it is therefore bad practice to declare large arrays on the stack.
The recommended practice in such cases is to use dynamic allocation on the heap with malloc instead.
Other things to be aware of:
You can't initialize a VLA because it is created in run-time (and well, because the C standard says that you can't). If you attempt to give an initializer list to a VLA int array[size] = {0};, you will get errors such as "error: variable-sized object may not be initialized".
For the same reason, you can't declare VLA at file scope either, because (...the C standard says so, and...) file scope variables get static storage duration, but VLA need automatic storage duration. Declaring a VLA at file scope would create an initialization order problem where it matters if the VLA or its size variable gets initialized first.
You can't have VLA inside struct or union either. You can have a flexible array member as the last item of a struct, but that's a different feature of its own, not to be confused with VLA.
Note that the sizeof operator has a special meaning for VLA. It is normally evaluated at compile-time, but in case of VLA it is evaluated in run-time. This means that in case of VLA, the sizeof operand is evaluated for side effects.
0 comment threads
1 comment thread