C++11中张量的递归索引

Question

我有一个等级为 N 的张量类，它包装存储在数组中的数据。例如，秩为 3 的张量将具有维度 (d0,d1,d2)，并且将使用长度为 d0*d1*d2 的基础数组的多索引 (i0,i1,i2) 访问唯一元素。如果 d0=d1=d2=10, i0=1, i1=2, i2=3，则将访问数组的元素 123。

我已经实现了一个递归定义的类，它从多索引计算单个数组索引，如下所示：

template<size_t N>
class TensorIndex : TensorIndex<N-1> {
private:
  size_t d;
public:
template<typename...Ds>
TensorIndex( size_t d0, Ds...ds ) : TensorIndex<N-1>( ds... ), d(d0) {}
  template<typename...Is>
  size_t index( size_t i0, Is...is ) {
    return i0+d*TensorIndex<N-1>::index(is...);
  }
};

template<>
struct TensorIndex<1> {
TensorIndex( size_t ) {}
  size_t index( size_t i ) { return i; }
};

这与所需的顺序相反。

TensorIndex<3> g(10,10,10);
std::cout << g.index(1,2,3) << std::endl;

输出 321。什么是反转构造函数和索引函数的参数顺序的简单方法？

编辑： 我尝试使用建议的反转可变参数的方法来实现，但这不是最理想的，因为它需要反转索引和构造函数的参数，并且这两种情况下必要的辅助函数看起来会略有不同。初始化列表的答案看起来更直接。

Answer 1

不需要递归也不需要反转，你可以使用initializer-list来调用一个从左到右累加索引的求值函数。在 initalizer-list 中调用的函数对象应该有一个非 void 返回类型：

#include <cstddef>
#include <iostream>

using namespace std;

template<size_t N>
class TensorIndex {
public:
    template<typename... Args>
    TensorIndex(Args... args) : dims{static_cast<size_t>(args)...}
    {
        static_assert(sizeof...(Args) == N,
                      "incorrect number of arguments for TensorIndex constructor");
    }

    template<typename... Args>
    size_t index(Args... args) {
        static_assert(sizeof...(Args) == N,
                      "incorrect number of arguments for TensorIndex::index()");
        IndexEval eval{dims};
        Pass pass{eval(args)...}; // evaluate from left to right : initializer-list                                                                           
        return eval.get_res();
    }

private:
    const size_t dims[N];

    class IndexEval {
        size_t k = 0;
        size_t res = 0;
        const size_t* dims;
    public:
        IndexEval(const size_t* dims) : dims{dims} {}
        size_t operator()(size_t i) {
            return res = res * dims[k++] + i;
        }
        size_t get_res() const { return res; }
    };

    struct Pass {
        template<typename... Args> Pass(Args...) {}
    };
};

int main()
{
    TensorIndex<3> g(10, 10, 10);
    cout << g.index(1, 2, 3) << endl;
}