c++ - 迭代多个模板参数的递归模板函数

Question

我写了一个执行仿函数 F 的可变参数模板 恰好 N 次并累加结果。现在我想知道如何使这个模板能够处理可变数量的索引(模板)参数，当前名为 id 并且在所需的仿函数 x, y, z 中。

我想到的是一个像下面这样的仿函数，它的执行就像你称之为三个 for 循环一样。我也想知道是否可以通过参数列表来解决。

struct 3DFunctor {
    template <int x, int y, int z>
    static int run() {
        return x*y*z;
    }
};

期望的行为应该是这样的:

accum_for<3,3,3>::get<3DFunctor>();

3DFunctor::run<0,0,0>(/*args ...*/) +
3DFunctor::run<0,0,1>(/*args ...*/) +
3DFunctor::run<0,0,2>(/*args ...*/) +
3DFunctor::run<0,1,0>(/*args ...*/) +
3DFunctor::run<0,1,1>(/*args ...*/) +
3DFunctor::run<0,1,2>(/*args ...*/) +
// ..

例子:

#include <iostream>
#include <string>

struct F {
    template <int id>
    static int run(int val) {
        return id * val;
    }
};

template<unsigned int n>
struct accum1d_for {
    template <class Funct, class ... ArgTypes>
    static auto get(ArgTypes ... args) -> decltype(Funct::template run<0>(args ...)) {
        return (
            accum1d_for<n-1>::template get<Funct>(args ...) + 
            Funct::template run<n>(args ...)
        );
    }
};

template<>
struct accum1d_for<0> {
    template <class Funct, class ... ArgTypes>
    static auto get(ArgTypes ... args) -> decltype(Funct::template run<0>(args ...)) {
        return static_cast<decltype(Funct::template run<0>(args ...))>(0);
    }
};

int main()
{
    std::cout << accum1d_for<10>::get<F>(2.f) << std::endl; 
}

Answer 1

使用 std::index_sequence，你可以这样做

template <std::size_t N1, std::size_t N2, std::size_t N3>
struct accum_for
{
private:
    template <class Funct, std::size_t ... Is>
    static int get(std::index_sequence<Is...>) {
        int res = 0;
        using int_array = int[];
        static_cast<void>(int_array{0, (res += Funct::template run<Is / N3 / N2,
                                                                   (Is / N3) % N2,
                                                                   Is % N3>())...});
        return res;
    }


public:
    template <class Funct>
    static int get() {
        return get<Funct>(std::make_index_sequence<N1 * N2 * N3>());
    }
};

Demo