c++ - 元组到参数包

Question

以下代码来自用户 Faheem Mitha，基于用户 Johannes Schaub - litb 在此 SO 中的回答.这段代码完美地完成了我所寻求的，即 tuple 的转换。进入参数包，但我不太了解这段代码，因此我想我会创建一个新的讨论，这可能有助于像我这样的模板元编程新手。因此，请原谅重复发帖。

现在进入代码

#include <tuple>
#include <iostream>
using std::cout;
using std::endl;

template<int ...> struct seq {};

template<int N, int ...S> struct gens : gens<N - 1, N - 1, S...> { };

template<int ...S> struct gens<0, S...>{ typedef seq<S...> type; };

double foo(int x, float y, double z)
{
    return x + y + z;
}

template <typename ...Args>
struct save_it_for_later
{
    std::tuple<Args...> params;
    double(*func)(Args...);

    double delayed_dispatch()
    {
        return callFunc(typename gens<sizeof...(Args)>::type()); // Item #1
    }

    template<int ...S>
    double callFunc(seq<S...>)
    {
        return func(std::get<S>(params) ...);
    }
};

int main(void)
{
    std::tuple<int, float, double> t = std::make_tuple(1, (float)1.2, 5);
    save_it_for_later<int, float, double> saved = { t, foo };
    cout << saved.delayed_dispatch() << endl;
    return 0;
}

我完全被上面的项目 #1 搞糊涂了:

• typename 的用途是什么？在那条线上服务？
• 我明白 gens<sizeof...(Args)>::type()将扩展为 gens<3>::type() ，但这似乎与 template<int N, int ...S> struct gens : gens<N - 1, N - 1, S...> { }; 都不匹配也不template<int ...S> struct gens<0, S...> .我显然没有捕获要点，如果有人能解释这里发生的事情，我会很高兴。

我明白 callFunc以这种形式被调用 callFunc(seq<0,1,2>)并且此方法本身的返回语句扩展为 return func(std::get<0>(params), std::get<1>(params), std::get<2>(params)这就是使该方案起作用的原因，但我无法解决这个 seq<0,1,2>生成类型。

注意:使用 std::index_sequence_for不是一个选项，我的编译器不支持 C++14 功能。

PS:这种技术可以归类为模板元编程吗？

Answer 1

让我们看看这里发生了什么:

template<int N, int ...S> struct gens : gens<N - 1, N - 1, S...> { };

template<int ...S> struct gens<0, S...>{ typedef seq<S...> type; };

第一个是通用模板，第二个是当第一个模板参数为 0 时应用的特殊化。

现在，拿一张纸和一支铅笔，写下怎么做

 gens<3>

由上述模板定义。如果你的回答是:

 struct gens<3> : public gens<2, 2>

那你是对的。这就是第一个模板在 N 时展开的方式。是“3”，...S是空的。 gens<N - 1, N - 1, S...> ，因此，变为 gens<2, 2> .

现在，让我们继续，看看如何gens<2, 2>得到定义:

 struct gens<2, 2> : public gens<1, 1, 2>

在这里，在模板扩展中，N是 2，...S是“2”。现在，让我们进行下一步，看看如何 gens<1, 1, 2>定义:

 struct gens<1, 1, 2> : public gens<0, 0, 1, 2>

好的，现在如何 gens<0, 0, 1, 2>得到定义？它现在可以由特化定义:

 template<int ...S> struct gens<0, S...>{ typedef seq<S...> type; };

那么，struct gens<0, 0, 1, 2> 会发生什么？这里？那么，在特化中，“S...”变成了“0、1、2”，所以从某种意义上说，这变成了:

 struct gens<0, 0, 1, 2> {

   typedef seq<0, 1, 2> type;

 }

现在，请记住，所有这些都公开地相互继承，“大象式”，所以:

 gens<3>::type

最终成为 typedef 声明

 struct seq<0, 1, 2>

接下来的代码使用另一个模板将元组转换为参数包:

double delayed_dispatch()
{
    return callFunc(typename gens<sizeof...(Args)>::type()); // Item #1
}

...Args是元组参数。所以，如果元组中有三个元素，sizeof(...Args)是 3，正如我上面解释的那样，gens<sizeof...(Args)>::type()变成 gens<3>::type() ，又名 seq<0, 1, 2>() .

那么，现在:

template<int ...S>
double callFunc(seq<S...>)
{
    return func(std::get<S>(params) ...);
}

S...部分变为“0、1、2”，所以

std::get<S>(params)...

成为一个扩展到的参数包:

std::get<0>(params), std::get<1>(params), std::get<2>(params),

这就是元组成为参数包的方式。