Is there any overhead for using variable-length arrays?

by

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, since VLAs can only be declared as automatic objects, this memory overhead is not something anyone would ever notice. It is just like declaring an extra local variable of integral type.

Secondly, VLA is normally allocated on stack, but because of its variable size, in general case its exact location in memory is not known at compile time. For this reason the underlying implementation usually has to implement it as a pointer to a memory block. This introduces some additional memory overhead (for the pointer), which is again completely insignificant for the reasons described above. This also introduces slight performance overhead, since we have to read the pointer value in order to find the actual array. This is the same overhead you get when accessing malloc-ed arrays (and don’t get with the named compile-time-sized arrays).

Since the size of the VLA is a run-time integer value, it can, of course, be passed as a command-line argument. VLA doesn’t care where its size comes from.

VLA were introduced as run-time-sized arrays with low allocation/deallocation cost. They fit between “ordinary” named compile-time-sized arrays (which have virtually zero allocation-deallocation cost, but fixed size) and malloc-ed arrays (which have run-time size, but relatively high allocation-deallocation cost).

VLA obey [almost] the same scope-dependent lifetime rules as automatic (i.e local) objects, which means that in general case they can’t replace malloc-ed arrays. They applicability is limited to situations when you need a quick run-time sized array with a typical automatic lifetime.

More Related Contents:

  1. Correctly allocating multi-dimensional arrays
  2. Difference between array type and array allocated with malloc
  3. How does GCC implement variable-length arrays?
  4. Which compiler should I trust?
  5. Array of variable length in a structure
  6. Is it possible to use notation [] with pointers in C?
  7. C array pointer increment
  8. I need help understanding this code in C [closed]
  9. C | Static array: why does writing out-of-bounds not result in exception? [duplicate]
  10. C-programming board game [duplicate]
  11. Is an array name a pointer?
  12. Returning an array using C
  13. Getting a stack overflow exception when declaring a large array
  14. How do I work with dynamic multi-dimensional arrays in C?
  15. Using malloc for allocation of multi-dimensional arrays with different row lengths
  16. Why do arrays in C decay to pointers?
  17. What is the maximum size of an array in C?
  18. Pointer address in a C multidimensional array
  19. No compiler error when fixed size char array is initialized without enough room for null terminator
  20. Performance of 2-dimensional array vs 1-dimensional array
  21. initializing an array of ints
  22. Changing array inside function in C
  23. Miscalculation of array size inside a function
  24. C char array initialization: what happens if there are less characters in the string literal than the array size?
  25. Resizing an array with C
  26. Why does scanf() need & operator (address-of) in some cases, and not others? [duplicate]
  27. Array of structs replacing values over itself
  28. Is it required that a C Variable Length Array is allocated from the stack?
  29. Dynamic array allocation on stack in C
  30. 2D Array indexing – undefined behavior?

Leave a Comment