C++11: std::get<> equivalent for n-dimensional arrays

Question

I was wondering whether there is something like std::get for accessing any n-dimensional array at compile time. E.g. get_value(arr, 1,2,3) shall return the value arr[1][2][3]. I tried to use a recursive template constexpr. However, the type deduction seems to be problematic.

#include <iostream>
#include <string>
#include <array>

template <class T, class FIRST, class ... REST>
constexpr auto get_value(T arr, FIRST first, REST... rest) {
    auto sub = arr[first];
    using sub_t = decltype(sub);
    return get_value<sub_t, REST...>(sub, rest...);
}

// works for 1D
template<class T>
constexpr auto get_value(T arr, auto first) {
    return arr[first];
}

int main()
{
    using arr1_t = std::array<int, 5>;
    using arr2_t = std::array<arr1_t, 5>;

    arr1_t arr1 = {1,2,3,4,5};
    arr2_t arr2 = {arr1, arr1, arr1, arr1, arr1};

    std::cout <<  get_value(arr1, 1) << std::endl;
    std::cout <<  get_value(arr2, 1,1) << std::endl;
}

What does your array look like? Is it really multidimensional arr[0][1][2] or is it an 1-D array used as multidimensional? — Vittorio Romeo
I think there is need to generalize the [] operator to the needs of parameter packs :/ — dgrat

Vittorio Romeo Vittorio Romeo · Accepted Answer · 2017-09-04T10:15:53

template <std::size_t I, std::size_t... Is, typename T>
auto get(const T& x)
{
    if constexpr(sizeof...(Is) == 0) { return x[I]; } 
    else { return get<Is...>(x[I]); }
}

Usage:

using array4d = std::array<std::array<std::array<std::array<int, 6>, 6>, 6>, 6>;

int main()
{
    array4d a;
    a[1][2][3][4] = 42;
    assert((get<1, 2, 3, 4>(a)) == 42);
}

live wandbox example

If you want a runtime version:

template <typename T, typename... Is>
auto get(const T& x, std::size_t i, Is... is)
{
    if constexpr(sizeof...(Is) == 0) { return x[i]; } 
    else { return get(x[i], is...); }
}

Usage:

int main()
{
    array4d a;
    a[1][2][3][4] = 42;
    assert(get(a, 1, 2, 3, 4) == 42);
}

live wandbox example

Note that I'm using C++17's if constexpr to define a base case for the recursion. In C++11 you can provide an overload instead:

template <typename T>
int get(const T& x, std::size_t i)
{
    return x[i]; 
}


template <typename T, typename... Is>
int get(const T& x, std::size_t i, Is... is)
{
    return get(x[i], is...);
}

live example on wandbox

C++11: std::get<> equivalent for n-dimensional arrays

1 Answers