An earlier version of my Pitfalls of VLA in C article contained an example of useful case of VLA, but since there are actually two of them (and I'd be overjoyed being presented with more), they deserve a dedicated, if low effort, post of their own. After all, those use-cases are the only reason why I compile with -Wvla-larger-than=0 rather than more strict and reliable -Wvla.

Size check when passing to function #

"Only" a bit over two decades after the introduction of VLA to C language, GCC started giving warnings about passing to functions bigger than declared size of arrays when we actually decide to utilize VLA syntax in parameters.

#include <stdio.h>

void f(const size_t size, const int buf[static size]);

int main(void)
{
    int arr[50] = { 0 };
    f(10, arr);  // acceptable
    f(50, arr);  // correct
    f(100, arr); // *WARNING*
    return 0;
}

Added bonus: explicit size annotation

Multidimensional arrays #

Dynamically allocating multi-dimensional arrays where the inner dimensions are not known until runtime is really simplified using VM types. It isn't even as unsafe as aVLA since there's no arbitrary stack allocation.

int (*arr)[n][m] = malloc(sizeof *arr); // `n` and `m` are variables with dimensions
if (arr) {
    // (*arr)[i][j] = ...;
    free(arr);
}

The VLA-free alternatives aren't as sexy:

• piecemeal allocation

  int** arr = malloc(n * (sizeof *arr));
  if (arr) {
      for (int i = 0; i < n; ++i) {
          arr[i] = malloc(m * (sizeof *arr[i]));
      }
      // arr[i][j] = ...
      for (int i = 0; i < n; ++i) {
          free(arr[i]);
      }
      free(arr);
  }
  

• 1D array with offsets

  int* arr = malloc(n * m * (sizeof *arr));
  if (arr) {
      // arr[i*n + j] = ...
      free(arr);
  }
  

• big fixed array

  int arr[SAFE_SIZE][SAFE_SIZE]; // SAFE_SIZE must be safe for SAFE_SIZE*SAFE_SIZE
  // arr[i][j] = ...;