Passing a multidimensional variable length array to a function

by

Passing arrays to functions is a bit funny in C and C++. There are no rvalues of array types, so you’re actually passing a pointer.

To address a 2D array (a real one, not array of arrays), you’ll need to pass 2 chunks of data:

  • the pointer to where it starts
  • how wide one row is

And these are two separate values, be it C or C++ or with VLA or without or whatnot.

Some ways to write that:

Simplest, works everywhere but needs more manual work

void foo(int width, int* arr) {
    arr[x + y*width] = 5;
}

VLA, standard C99

void foo(int width, int arr[][width]) {
    arr[x][y] = 5;
}

VLA w/ reversed arguments, forward parameter declaration (GNU C extension)

void foo(int width; int arr[][width], int width) {
    arr[x][y]=5;
}

C++ w/ VLA (GNU C++ extension, terribly ugly)

void foo(int width, int* ptr) {
    typedef int arrtype[][width];
    arrtype& arr = *reinterpret_cast<arrtype*>(ptr);
    arr[x][y]=5;
}

Big remark:

The [x][y] notation with a 2D array works because the array’s type contains the width. No VLA = array types must be fixed at compile-time.

Hence: If you can’t use VLA, then…

  • there’s no way to handle it in C,
  • there’s no way to handle it without a proxy class w/ overloaded operator overloading in C++.

If you can use VLA (C99 or GNU C++ extensions), then…

  • you’re in the green in C,
  • you still need a mess in C++, use classes instead.

For C++, boost::multi_array is a solid choice.

A workaround

For 2D arrays, you can make two separate allocations:

  • a 1D array of pointers to T (A)
  • a 2D array of T (B)

Then set the pointers in (A) to point into respective rows of (B).

With this setup, you can just pass (A) around as a simple T** and it will behave well with [x][y] indexing.

This solution is nice for 2D, but needs more and more boilerplate for higher dimensions. It’s also slower than the VLA solution because of the extra layer of indirection.

You may also run into a similar solution with a separate allocation for every B‘s row. In C this looks like a malloc-in-a-loop, and is analogous of C++’s vector-of-vectors. However this takes away the benefit of having the whole array in one block.

More Related Contents:

  1. Does C99 guarantee that arrays are contiguous?
  2. Literal string initializer for a character array
  3. Declaring an array of negative length
  4. Access element of array of pointer of structure
  5. Explanation of output of this C code
  6. whats the difference between dynamic memory allocation and normal memory allocation?
  7. Getting an error while running following code
  8. Finding target sum of two numbers in array
  9. Correctly allocating multi-dimensional arrays
  10. C sizeof a passed array [duplicate]
  11. How to pass a 2D array by pointer in C?
  12. Passing an array by reference in C?
  13. What is the correct type for array indexes in C?
  14. Realistic usage of the C99 ‘restrict’ keyword?
  15. C char array initialization
  16. Convert Bytes to Int / uint in C
  17. Find the Size of integer array received as an argument to a function in c [duplicate]
  18. Can I omit return from main in C? [duplicate]
  19. state machines tutorials [closed]
  20. How to include a dynamic array INSIDE a struct in C?
  21. How can I return a character array from a function in C?
  22. variably modified array at file scope in C
  23. Is there any overhead for using variable-length arrays?
  24. C difference between *[] and **
  25. Finding out the duplicate element in an array
  26. Exceeding array bound in C — Why does this NOT crash?
  27. Find size of array without using sizeof
  28. ftell at a position past 2GB
  29. How can I malloc a struct array inside a function? Code works otherwise
  30. C pointer notation compared to array notation: When passing to function

Leave a Comment