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.

Post History

85%

+10 −0

Q&A How to declare variable-length arrays correctly?

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...

posted 2y ago by Lundin‭ · edited 8mo ago by Lundin‭

Answer

#6: Post edited by

Lundin‭ · 2023-08-25T12:55:11Z (8 months ago)

Copy Link

Raw

Markdown

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:
```C
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 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.

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:
```C
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.

#5: Post edited by

Lundin‭ · 2022-04-26T10:48:23Z (almost 2 years ago)

Copy Link

Raw

Markdown

~~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:~~
```C
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.

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:
```C
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 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.

#4: Post edited by

Lundin‭ · 2021-08-18T09:00:51Z (over 2 years ago)

Copy Link

Raw

Markdown

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:
```C
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 it's 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.

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:
```C
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.

#3: Post edited by

Lundin‭ · 2021-08-16T08:57:16Z (over 2 years ago)

Copy Link

Raw

Markdown

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:
```C
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 of `size` 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 it's 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.

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:
```C
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 it's 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.

#2: Post edited by

Lundin‭ · 2021-08-16T08:54:36Z (over 2 years ago)

Copy Link

Raw

Markdown

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:
```C
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 of `size` at the point where that source code line was encountered. Changing `size` afterwards does not change the size of the VLA. And you can't resize 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 it's 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.

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:
```C
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 of `size` 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 it's 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.

#1: Initial revision by

Lundin‭ · 2021-08-16T08:53:12Z (over 2 years ago)

Copy Link

Raw

Markdown

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:

```C
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 of `size` at the point where that source code line was encountered. Changing `size` afterwards does not change the size of the VLA. And you can't resize 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 it's 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.

Communities

Post History