What's the most idiomatic way to allocate a 3D array in C++?

Question

I have the following to code to allocate the 3d array:

int ***allocate3DArray(int y, int x, int r) {
    int ***array = (int ***) malloc(sizeof(int **) * y);
    for (int i = 0; i < y; i++) {
        array[i] = (int **) malloc(sizeof(int *) * x);
        for (int j = 0; j < x; j++) {
            array[i][j] = (int *) malloc(sizeof(int) * r);
            for (int k = 0; k < r; k++) {
                array[i][j][k] = 0;
            }
        }
    }
    return array;

}


void free3d(int ***arr, int y, int x, int r) {
    for (int i = 0; i < y; i++) {
        for (int j = 0; j < x; j++) {
            free(arr[i][j]);
        }
        free(arr[i]);

    }
    free(arr);

}

This seems a bit clunky and it's difficult to do error-handling if I malloc fails.

That said, it's quite ergonomic because I can simply access an element like so: int a = arr[x][y][z]

What would be the best way to initialize a 3d array that gives the same ergonomic flexibility while mitigating some of the above drawbacks?

I tried this:

    std::array < std::array < std::array < int, radius >, image.cols >, image.rows > houghSpace;

but I got an error:

 error: non-type template argument is not a constant expression
    std::array < std::array < std::array < int, radius >, image.cols >, image.rows > houghSpace;
                                                ^~~~~~
sobel.cpp:117:49: note: initializer of 'radius' is not a constant expression
sobel.cpp:116:15: note: declared here
    const int radius = image.rows / 2;
              ^
sobel.cpp:117:71: error: expected a type
    std::array < std::array < std::array < int, radius >, image.cols >, image.rows > houghSpace;
                                                                      ^
sobel.cpp:117:86: error: C++ requires a type specifier for all declarations
    std::array < std::array < std::array < int, radius >, image.cols >, image.rows > houghSpace;
                                                                                     ^

Answer 1

You want a 3-dimensional array with a cuboid shape. What you currently have is a jagged array. Every lane can have independent size, and is allocated separately. This creates 3(4) problems:

1. The number of allocations is x*y+1
2. Reading any elements requires 3 indirect memory loads.
3. Uses more storage than needed, since pointer to each allocated region needs to be kept.
4. Your code also requires manually handling the memory

For the same reasons the solution using vectors is also bad. It only solves one problem - manual allocation and deallocation. Otherwise it's even worse because it stores more redundant data.

What you want is to abstract a contiguous memory range such that it can be interpreted as a 3d array.

#include <iostream>
#include <memory>
#include <cstdint>

template <typename T>
struct Array3
{
    Array3(size_t w, size_t h, size_t d) :
        m_data(std::make_unique<T[]>(w*h*d)),
        m_width(w),
        m_height(h),
        m_depth(d)
    {
    }

    T& operator()(size_t x, size_t y, size_t z)
    {
        return m_data[(x * m_height + y) * m_depth + z];
    }

    const T& operator()(size_t x, size_t y, size_t z) const
    {
        return m_data[(x * m_height + y) * m_depth + z];
    }

    size_t width() const
    {
        return m_width;
    }

    size_t height() const
    {
        return m_height;
    }

    size_t depth() const
    {
        return m_depth;
    }

    T* data()
    {
        return m_data.get();
    }

    const T* data() const
    {
        return m_data.get();
    }

private:
    std::unique_ptr<T[]> m_data;
    std::size_t m_width;
    std::size_t m_height;
    std::size_t m_depth;
};


int main()
{
    Array3<int> a(10, 20, 30);
    a(5, 10, 15) = 123;
    std::cout << a(5, 10, 15);
}

Access is done with operator () instead of []. It can be done with [], but requires more boilerplate code and proxy objects.

Answer 2

Some strong recommendations for arrays in C++

• You must NOT use malloc and free in C++
• You should not even use NEW and DELETE any longer
• You should never use raw pointers for owned memory. Please use std::unique_ptr or std::shared_ptr instead.

So, never use the functions as shown above (allocate3DArray, free3d)

Ok. So, now we want to switch to std::array and you are wondering about the error messages. They are rather clear, as shown in your example. A std::array has a static size. It is not dynamic. So you need to give a compile time constant to define the size.

What you are looking for is a std::vector. It is dynamic, can grow in size and has also an index operator.

It can be used with the index operator [] without restrictions.

Please see the following example

#include <iostream>
#include <iterator>
#include <vector>

int main()
{
    // Dimensions for the 3 dimensional vector
    size_t xSize{3};
    size_t ySize{4};
    size_t zSize{5};
    int initialValue{0};

    // Define 3 dimensional vector and initialize it.
    std::vector<std::vector<std::vector<int>>> array3d(xSize, std::vector<std::vector<int>>(ySize, std::vector<int>(zSize,initialValue)));

    array3d[1][2][3] = 42;

    std::cout << "Result: " << array3d[1][2][3] << "\n";

    return 0;
}