variable-length-array

I just did a experiment yesterday, and find something confusing: #include <stdio.h> int main() { int j; scanf("%d",&j); const int i = j; int arr[i]; return 0; } The number j is read from keyboard and it’s used to allocate the array arr on the stack. The compiler does not even know the size of the array at compile time (initializes j to 0?), but there is no compilation error. How is it possible? Variable length arrays were added to C99. It's described in the C99 rationale: 6.7.5.2 Array declarators C99 adds a new array type called a variable length array type. The inability to declare arrays

An argument in the comments section of this answer prompted me to ask this question. In the following code, bar points to a variable length array, so the sizeof is determined at runtime instead of compile time. int foo = 100; double (*bar)[foo]; The argument was about whether or not using sizeof evaluates its operand when the operand is a variable length array, making sizeof(*bar) undefined behavior when bar is not initialized. Is it undefined behavior to use sizeof(*bar) because I'm dereferencing an uninitialized pointer? Is the operand of sizeof actually evaluated when the type is a variable

Possible Duplicate: Variably modified array at file scope I have some concepts about the VLA and its behavior that I need to clarify. AFIK since C99 it's possible to declare VLA into local scopes: int main(int argc, char **argv) { // function 'main' scope int size = 100; int array[size]; return 0; } But it is forbidden in global scopes: const int global_size = 100; int global_array[global_size]; // forbidden in C99, allowed in C++ int main(int argc, char **argv) { int local_size = 100; int local_array[local_size]; return 0; } The code above declares a VLA in C99 because the const modifier

This question already has an answer here: What's the difference between a VLA and dynamic memory allocation via malloc? 4 answers There are two ways to allocate memory to an array, of which the size is unknown at the beginning. The most common way is using malloc like this int * array; ... // when we know the size array = malloc(size*sizeof(int)); But it's valid too in C99 to define the array after we know the size. ... // when we know the size int array[size]; Are they absolutely the same? No they're not absolutely the same. While both let you store the same number and type of objects, keep

Is there some overhead of using variable-length arrays? Could the size of array be passed via command line argument at run time? Why is it introduced, compared to automatic and dynamically allocating an array? VLA does have some overhead (compared to "ordinary" named compile-time-sized array). Firstly, it has run-time length and yet the language provides you with means to obtain the actual size of the array at run-time (using sizeof ). This immediately means that the actual size of the array has to be stored somewhere. This results in some insignificant per-array memory overhead. However,