可变参数模板包扩展

Question

在 Andrei 在 GoingNative 2012 上的演讲中，他谈到了 Variadic 模板，并且他在某一时刻通过下面的示例解释了参数包扩展的工作原理。作为这个主题的新手，我发现很难理解每种情况的工作原理，有人可以解释一下在 gun 的每个函数调用中扩展是如何工作的吗？

template<class... Ts> void fun(Ts... vs) {
    gun(A<Ts...>::hun(vs)...);
    gun(A<Ts...>::hun(vs...));
    gun(A<Ts>::hun(vs)...);
}

Answer 1

1.

   gun(A<Ts...>::hun(vs)...)
=> gun(A<T1, T2, …, Tn>::hun(vs)...)
=> gun(A<T1, T2, …, Tn>::hun(v1),
       A<T1, T2, …, Tn>::hun(v2),
       …,
       A<T1, T2, …, Tn>::hun(vm))

2.

   gun(A<Ts...>::hun(vs...))
=> gun(A<T1, T2, …, Tn>::hun(vs...))
=> gun(A<T1, T2, …, Tn>::hun(v1, v2, …, vm))

这应该是显而易见的。

3.

   gun(A<Ts>::hun(vs)...)
=> gun(A<T1>::hun(v1), A<T2>::hun(v2), …, A<Tn>::hun(vn))

（在这种情况下，如果 Ts 和 vs 的长度不同，程序将无法编译）

---

... 将扩展其前面的模式（包括任何参数包），这意味着，在foo(Ts, Us, Vs)...，列表中的每个成员 Ts、Us、Vs （在锁定步骤中枚举）将被替换为该模式，并且将形成一个逗号分隔的列表：

   foo(Ts, Us, Vs)...
=> foo(T1, U1, V1), foo(T2, U2, V2), …, foo(Tn, Un, Vn)

如果存在嵌套扩展，则最里面的模式将首先扩展。因此，在情况 1 中，模式 Ts 将首先扩展为 T1, T2, …, Tn。然后，外部 ... 之前的模式是 A::fun(vs) — 请注意 Ts< /code> 已扩展 - 因此它将扩展为 A::fun(v1), A::fun(v2), …, A::fun(vm) 通过替换 v1, v2等进入 vs。

Answer 2

KennyTM 的回答很完美。我也喜欢样品。但由于他的答案很抽象，我不认为在他的答案中添加演示是正确的事情。所以他的答案的演示就在这里。我假设他的答案是正确的，我自己一无所知。 （如果你支持这个，也支持他）

显然这都是伪代码，只是显示扩展状态。

void foo<void*,int,char,std::string>(nullptr, 32, '7', "BANANA") {
    //gun(A<Ts...>::hun(vs)...);
    gun(A<void*,int,char,std::string>::hun(nullptr)
       ,A<void*,int,char,std::string>::hun(32)
       ,A<void*,int,char,std::string>::hun('7')
       ,A<void*,int,char,std::string>::hun("BANANA")
       );
    //gun(A<Ts...>::hun(vs...));
    gun(A<void*,int,char,std::string>::hun(nullptr, 32, '7', "BANANA");
    //gun(A<Ts>::hun(vs)...);
    gun(A<void*>::hun(nullptr)
       ,A<int>::hun(32),
       ,A<char>::hun('7'),
       ,A<std::string>::hun("BANANA")
       );
}