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
tag:snake search within a tag
answers:0 unanswered questions
user:xxxx search by author id
score:0.5 posts with 0.5+ score
"snake oil" exact phrase
votes:4 posts with 4+ votes
created:<1w created < 1 week ago
post_type:xxxx type of post
Search help
Notifications
Mark all as read See all your notifications »
Q&A

Post History

83%
+8 −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 1y ago by Lundin‭  ·  edited 9mo ago by Lundin‭

Answer
#5: Post edited by user avatar Lundin‭ · 2022-04-26T10:48:23Z (9 months ago)
  • 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 user avatar Lundin‭ · 2021-08-18T09:00:51Z (over 1 year ago)
  • 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 user avatar Lundin‭ · 2021-08-16T08:57:16Z (over 1 year ago)
  • 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 user avatar Lundin‭ · 2021-08-16T08:54:36Z (over 1 year ago)
  • 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 user avatar Lundin‭ · 2021-08-16T08:53:12Z (over 1 year ago)
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.