Communities

Writing
Writing
Codidact Meta
Codidact Meta
The Great Outdoors
The Great Outdoors
Photography & Video
Photography & Video
Scientific Speculation
Scientific Speculation
Cooking
Cooking
Electrical Engineering
Electrical Engineering
Judaism
Judaism
Languages & Linguistics
Languages & Linguistics
Software Development
Software Development
Mathematics
Mathematics
Christianity
Christianity
Code Golf
Code Golf
Music
Music
Physics
Physics
Linux Systems
Linux Systems
Power Users
Power Users
Tabletop RPGs
Tabletop RPGs

Dashboard
Notifications
Mark all as read
Q&A

How to declare variable-length arrays correctly?

+5
−0

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]; 
    
Why does this post require moderator attention?
You might want to add some details to your flag.
Why should this post be closed?

0 comment threads

1 answer

+7
−0

C programs are executed from top to bottom. You can't declare a VLA with an uninitialized variable as its parameter. For the same reason at you can't do this:

int x;
printf("%d",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 where 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.

Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

Sign up to answer this question »