Best practice for allocating a continuous 2d array on the heap using c++14

Question

I am having a hard time finding the answer to the following:

What is the best practice way of allocating a 2d array of ints that is contiguous in memory on the heap in c++14.

Conditions:

The width and height is known at compile time but I would still like to put the 2d array on the heap for various reasons.
I would like to access memory locations using the 2d syntax arr[x][y]
I do not want to implement my own wrapper if possible

Sub questions:

Do I have to use std::array or is the native int[][dim] syntax usable?
Is it possible to have a unique_ptr to the 2d array?

Thanks in advance for answers.

`std::vector> vec(n, std::vector(m));` If the size is known at compile-time, please do not use dynamic memory. — DeiDei, Nov 01 '17 at 16:36
@DeiDei That will not be contiguous and will be quite inefficient. As for your second sentence, that's just wrong. — , Nov 01 '17 at 16:44
`auto &arr = *new std::array, width>`? Or `std::vector> arr(width);`? — geza, Nov 01 '17 at 16:45
@DeiDei you suggest to use `std::vector` and you suggest not to use `std::vector`? — 463035818_is_not_an_ai, Nov 01 '17 at 16:45
Use a `std::vector` and calculate the offset for every access. Remove requirement three and adapt requirement two so that the syntax of your wrapper class becomes `arr(x, y)`. — Christian Hackl, Nov 01 '17 at 17:29
"on the heap for various reasons." Which reasons? Known size in compile time and using heap sounds opposite to me. — Klaus, Nov 02 '17 at 07:58
@Klaus known big size is as good reason as any to place an array to dynamic memory — Sergey.quixoticaxis.Ivanov, Nov 02 '17 at 16:06

score 3 · Answer 1 · answered Nov 01 '17 at 16:49

You could use a unique_ptr that holds a raw array:

std::unique_ptr<int[][Y]> p(new int[X][Y]);

However, this doesn't give you meaningful bounds checking on the first axis, nor does it let you iterate using range-based for.

You could use a unique_ptr that holds a std::array

std::unique_ptr<std::array<std::array<int, Y>, X>> p;

However, this doesn't let you index, since operator[] is only defined for raw arrays.

I would just write my own wrapper that gives me the best of both. Something like:

template <typename T, size_t X, size_t Y>
struct Array {
    Array() {
        p.reset(new T[X][Y]);
    }   

    using row = T[Y];

    row* begin() { return p.get(); }
    row* end() { return p.get() + X; }

    row& operator[](size_t y) { return p[y]; }

    std::unique_ptr<int[][Y]> p;
};

Note that data in nested `std::array`'s are _not_ guaranteed to be contiguous (https://stackoverflow.com/q/9762662/873025). — Felix Glas, Nov 01 '17 at 16:58

Best practice for allocating a continuous 2d array on the heap using c++14

1 Answers1