c++ - 模板参数包扩展语法的基本原理

Question

给定以下辅助函数

template <typename ... Ts>
auto f(Ts&& ... args) {}

template <typename T>
auto g(T x) { return x; }

1)我们像往常一样扩展一个模板参数包。

template <typename ... Ts>
void test1(Ts&& ... args)
{
    f(args...);
}

---

2) 这里展开...发生在g()函数调用之后。这也是合理的，因为每个 args 都会调用 g():

template <typename ... Ts>
void test2(Ts&& ... args)
{
    f(g(args)...);
}

---

3) 使用相同的逻辑，我希望 test3(Is, args...)...，但没有。你必须写 test3(Is..., args...):

template <typename ... Ts>
void test3(size_t i, Ts&& ... args)
{
    f(args...);
}

template <typename ... Ts>
void test3(std::index_sequence<Is...>, Ts&& ... args)
{
    // would expect test3(Is, args...)...;
    test3(Is..., args...);
}

我知道，我使用它，但是，我不明白。模板扩展的整个概念是一种表达式折叠的形式。不是以 C++17 的方式，而是在 ... 之前的子表达式相对于可变参数被折叠(或重复)的意义上。在 test3 的情况下，我们“折叠”表达式 test3(Is, args...) 关于 Is。然而，我们必须编写 test3(Is..., args...) 而不是 test3(Is, args...)...。

使用标准的这种奇怪逻辑，您还可以编写 f(g(args...)) 而不是 f(g(args)...) - 然而那是无效的。看起来该语言在不同的上下文中使用不同的逻辑。

不同语法背后的基本原理是什么？

Answer 1

In the test3 case we are "folding" the expression test3(Is, args...) in respect to Is. Yet we have to write test3(Is..., args...) instead of test3(Is, args...)....

这实际上是不正确的。 test3(Is..., args...)将展开Is到位然后args到位。所以打电话test3(index_sequence<0,1,2>, x, y, z)最终会调用 test3(0, 1, 2, x, y, z) ，这不是你想要发生的。你要test3(0, x, y, z); test3(1, x, y, z); test3(2, x, y, z); .

调用它的 C++17 方式是:

(test3(Is, args...), ...);

这并不是真正不同的语法。您有两个要以不同方式扩展的参数包:args在函数调用和 Is 中在它周围，所以这意味着你有两个 ...秒。逗号只是表示这些是单独语句的一种方式。

... 中的自由放置意味着您可以根据需要折叠它:

(test3(Is, args), ...);    // test3(0,x); test3(1,y); test3(2,z);
(test3(Is..., args), ...); // test3(0,1,2,x); test3(0,1,2,y); test3(0,1,2,z);
test3(Is..., args...);     // test3(0,1,2,x,y,z);

---

With this weird logic of the standard you could also write f(g(args...)) instead of f(g(args)...) - however that's invalid

这不是奇怪的逻辑。这些意味着不同的东西。第一个扩展为 f(g(a0, a1, a2, ..., aN))第二个扩展为 f(g(a0), g(a1), g(a2), ..., g(aN)) .有时你需要前者，有时你需要后者。拥有允许两者的语法非常重要。