Is there a more idiomatic way than this to use template-generic C++23 multidimensional array subscripts?

Question

C++23 is going to add multidimensional array subscript operators to the language, yippee!

Alas, I have not yet come across a way to adapt them to types where the number of dimensions is templated, so I came up with this, using variadic templates, fold expression and concepts:

#include <cstddef>
#include <concepts>

// version with static bounds on the dimensions
template <typename T, std::size_t... DIMS>
struct vec {
    template <std::convertible_to<std::size_t>... Is>
    requires (sizeof...(Is) == sizeof...(DIMS))
    T operator[](Is... indices) { return {}; }
};

// version with only the number of dimensions specified (unbounded)
template <typename T, std::size_t D>
struct nvec {
    template <std::convertible_to<std::size_t>... Is>
    requires (sizeof...(Is) == D)
    T operator[](Is... indices) { return {}; }
};

int main() {
    vec<int, 3, 2, 4> foo;
    vec<int, 1, 1> bar;
    vec<int, 91'000> baz;
    vec<int> bung;
    nvec<int, 4> bogget;
    return foo[2, 3, 1] + bar[0, 1] + baz[120] + bung[] + bogget[1, 2, 3, 4];
}

Note that the actual implementation in both cases is stubbed out (I suppose in practice, I will probably use fold expressions to resolve the indices to the correct location in the 1-D array that actually backs the storage for the things, probably with some bounds-checking for the case of vec<> which has static bounds for all dimensions).

I dunno, this feels slightly unwieldy, but this is the most succinct thing I could come up with that allows template-variadic dimensions. There isn't a more concise way now, is there?

Answer 1

Yes, this is a perfectly fine way to do it, and it is very concise. It might be instructive to compare this to std::mdspan: its operator[] has a similar overload that takes a parameter pack of indices. However, your code is not doing anything useful. The real question is: how do you convert from multi-dimensional indices into a single offset into the underlying buffer? This should look something like:

template <typename T, std::size_t... DIMS>
struct vec {
    template <std::convertible_to<std::size_t>... Is>
    requires (sizeof...(Is) == sizeof...(DIMS))
    T operator[](Is... indices) {
        // Cheat to be able to use a regular for-loop.
        static constexpr std::array dims_array{DIMS...};
        std::array index_array{indices...};

        std::size_t offset = 0;

        // The compiler should unroll this.
        for (std::size_t i = 0; i < sizeof...(DIMS); ++i) {
             offset *= dims_array[i];
             offset += index_array[i];
        }

        return data[offset];
    }

private:
    static constexpr std::size_t size = (DIMS * ...);
    std::vector<T> data{size};
};

It becomes even more complex if you allow for different strides and/or layouts, like std::mdspan does. This complexity is alledgedly one of the reasons why they decided to postpone the proposed std::mdarray to C++26.