&引用；“折叠”；在C++；17：惯用方法 C++11和C++14中的折叠ish表达式：惯用方法？

Q&A的设计使用了一种常见的C++17之前（在折叠表达式之前）的方法来“折叠”未展开的模板参数包

我见过这种技术的几种不同的变体；以上述问答为例：

#include <initializer_list>
#include <iostream>
#include <utility>

template <typename T> static void bar(T) {}

template <typename... Args> static void foo1(Args &&... args) {
  using expander = int[];
  // Left-most void to avoid `expression result unused [-Wunused-value]`
  (void)expander{0, ((void)bar(std::forward<Args>(args)), 0)...};
}

template <typename... Args> static void foo2(Args &&... args) {
  int dummy[] = {0, ((void)bar(std::forward<Args>(args)), 0)...};
  // To avoid `unused variable 'dummy' [-Wunused-variable]`
  (void)dummy;
}

template <typename... Args> static void foo3(Args &&... args) {
  // Left-most void to avoid `expression result unused [-Wunused-value]`
  (void)std::initializer_list<int>{((void)bar(std::forward<Args>(args)), 0)...};
}

template <typename... Args> static void foo4(Args &&... args) {
  auto l = {0, ((void)bar(std::forward<Args>(args)), 0)...};
  // To avoid `unused variable 'l' [-Wunused-variable]`
  (void)l;
}

int main() {
  foo1(1, 2, 3, "3");
  foo1();
  foo2(1, 2, 3, "3");
  foo2();
  foo3(1, 2, 3, "3");
  foo3();
  foo4(1, 2, 3, "3");
  foo4();
  return 0;
}

#包括
#包括
#包括
模板静态空心条（T）{}
模板静态void foo1（Args&&…Args）{
使用expander=int[]；
//最左侧为空，以避免`表达式结果未使用[-Wunused值]`
（void）扩展器{0，（（void）条（std:：forward（args）），0）…}；
}
模板静态void foo2（Args&&…Args）{
int-dummy[]={0，（（void）条（std:：forward（args）），0）；
//避免“未使用的变量”伪“[-Wunused变量]`
（无效）假人；
}
模板静态void foo3（Args&&…Args）{
//最左侧为空，以避免`表达式结果未使用[-Wunused值]`
（void）std:：initializer_list{（（void）bar（std:：forward（args）），0）；
}
模板静态void foo4（Args&&…Args）{
自动l={0，（（void）条（std:：forward（args）），0）；
//避免“未使用的变量”l'[-Wunused变量]`
（无效）l；
}
int main（）{
foo1（1,2,3,3”）；
foo1（）；
foo2（1,2,3,3”）；
foo2（）；
foo3（1,2,3,3”）；
foo3（）；
foo4（1,2,3,3”）；
foo4（）；
返回0；
}

这些变体（或其他变体）中是否有一种被视为“惯用变体”？它们之间是否有需要注意的微妙之处/差异

std:：initializer\u list

方法不需要括号内init list中最左边的

0

，因为initializer list可能是空的，而数组的大小可能不是零（/负）。这可能是

foo3

的一个论据（可以说，以额外的

#include

为代价，复杂性略低一些）

这些变体（或其他变体）中是否有一种被视为“惯用变体”

我会说是的

它们之间是否有需要注意的微妙之处/差异

大多数情况下是等效的，但是

foo3

和

foo4

要求

#包括


而
foo1
和
foo2
则没有。执行顺序是否保证所有变化？（我认为这是针对foo3的，必须搜索我的信仰来源。）@generic_opto_guy所有变体都使用带括号的init列表，其中的条目由逗号运算符分隔；前者保证按照出现的顺序（[dcl.init.list]）进行计算，而后者从左到右（[expr.comma]）进行计算，因此我相信所有变体的执行顺序都是有保证的（也是相同的）。谢谢您的回答。另一方面，
std:：initializer_list
方法不需要括号内init list中最左边的
0
值。