Implementing subscript operator that accepts an array of indices - c++

Question

This is a continuation of my question Implement STL functions in variadic template:
How can I implement a subscript operator for an N-dimensional array that accepts an array of length N, given that a already have defined "single-layer" subscript operators to be used as array[indx0][indx1]…[indxN]. I feel like there should be a simple fold expression for this?

Answer 1

So, [] is not one of the foldable operators. Bummer. But we just have to cheat a bit and piggyback on another one :)
namespace indexer_detail {
template <class T>
struct ArrayWrapper {
T obj;
};
template <class T>
ArrayWrapper(T&&) -> ArrayWrapper<T&&>;
template <class T>
auto operator & (ArrayWrapper<T> const &aw, std::size_t N) {
return ArrayWrapper{aw.obj[N]};
}
}
template <std::size_t Size, class Array, std::size_t... Idx>
decltype(auto) index(
Array &&array,
std::array<std::size_t, Size> const &indices,
std::index_sequence<Idx...>
) {
return (
indexer_detail::ArrayWrapper{std::forward<Array>(array)} & ... & indices[Idx]
).obj;
}
template <std::size_t Size, class Array>
decltype(auto) index(Array &&array, std::array<std::size_t, Size> const &indices) {
return index(std::forward<Array>(array), indices, std::make_index_sequence<Size>{});
}
See it live on Coliru

Answer 2

Because it's C++17, we can use constexpr if to make more it simple :
template<size_t Idx0, size_t... IdxRest, typename V>
decltype(auto) getval(const V& v)
{
if constexpr (sizeof...(IdxRest) == 0)
{
return v[Idx0];
}
else
{
return getval<IdxRest...>(v[Idx0]);
}
}
int main()
{
int arr[10][10] = { 1,2,3 };
std::vector<int> arr2 = { 1,2,3 };
auto v1 = getval<0, 2>(arr);
auto v2 = getval<1>(arr2);
return 0;
}