Do multi-dimensional arrays cause any problems in C and/or C++?

Question

I know that this question seems a little bit hilarious at the first sight. But as I came across this question I´ve found a comment, of @BasileStarynkevitch, a C and C++ high-level user, in which he claimed that multidimensional arrays shall not be preferable to use, neither in C nor in C++:

Don't use multi-dimensional arrays in C++ (or in C).

Why? Why shouldn´t I use multi-dimensional arrays in C++ nor in C?

What does he meant with this statement?

---

Thereafter, another user replied on this comment:

Basile is right. It's possible to declare a 3D array in C/C++ but causes too many problems.

Which problems?

I use multi-dimensional arrays a lot and see no disadvantages in using them. In opposite, I think it has only advantages.

• Are there any issues about using mulit-dimensional arrays I do not know about?

• Can anyone explain me what they meant?

Answer 1

This is quite a broad (and interesting) performance related topic. We could discuss cache misses, cost of initialization of multi-dimensional arrays, vectorization, allocation of multidimensional std::array on the stack, allocation of multidimensional std::vector on the heap, access to the latter two, and so on... .

That said, if your program works fine with your multidimensional arrays, leave it the way it is, especially if your multidimensional arrays allow for more readability.

A performance related example:

Consider a std::vector which holds many std::vector<double>:

std::vector<std::vector<double>> v;

We know that each std::vector object inside v is allocated contiguously. Also, all the elements in a std::vector<double> in v are allocated contiguously. However, not all the double's present in v are in contiguous memory. So, depending on how you access those elements (how many times, in what order, ...), a std::vector of std::vector's can be very slow compared to a single std::vector<double> containing all the double's in contiguous memory.

Matrix libraries will typically store a 5x5 matrix in a plain array of size 25.

Answer 2

You cannot answer this question for C and C++ at once, because there is a fundamental difference between these two languages and their handling of multidimensional arrays. So this answer contains two parts:

---

C++

Multidimensional arrays are pretty useless in C++ because you cannot allocate them with dynamic sizes. The sizes of all dimensions except the outermost one must be compile time constants. In virtually all the usecases for multidimensional arrays I have encountered, the size parameters are simply not known at compile time. Because they come from the dimensions of an image file, or some simulation parameter, etc.

There might be some special cases where the dimensions are actually known at compile time, and in these cases, there is no issue with using multidimensional arrays in C++. In all the other cases, you'll need to either use pointer arrays (tedious to set up), nested std::vector<std::vector<std::vector<...>>>, or a 1D array with manual index computation (error prone).

---

C

C allows for true multidimensional arrays with dynamic sizes since C99. This is called VLA, and it allows you to create fully dynamically sized multidimensional arrays both on the stack and the heap.

However, there are two catches:

• You can pass a multidimensional VLA to a function, but you can't return it. If you want to pass multidimensional data out of a function, you must return it by reference.

  void foo(int width, int height, int (*data)[width]);  //works
  //int (*bar(int width, int height))[width];  //does not work
  

• You can have pointers to multidimensional arrays in variables, and you can pass them to functions, but you cannot store them in structs.

  struct foo {
      int width, height;
      //int (*data)[width];  //does not work
  };
  

Both problems can be worked around (pass by reference to return a multidimensional array, and storing the pointer as a void* in the struct), but it's not trivial. And since its not a heavily used feature, only very few people know how to do it right.

---

Compile time array sizes

Both C and C++ allow you to use multidimensional arrays with dimensions known at compile time. These do not have the drawbacks listed above.

But their usefulness is reduced greatly: There are just so many cases where you would want to use a multidimensional array, and where you do not have the ghost of a chance to know the involved sizes at compile time. An example is image processing: You don't know the dimensions of the image before you have opened the image file. Likewise with any physics simulation: You do not know how large your working domain is until your program has loaded its configuration files. Etc.

So, in order to be useful, multidimensional arrays must support dynamic sizes imho.