Parameter pack(形参包)
形参包分两种：
- 模板形参包
- 函数模板形参包
模板形参包
出现于别名模版、类模板、变量模板及函数模板形参列表中，简单说就是跟在template关键字后面尖括号<>里的东西
语法：
-
类型 ...Args(可选) （1） -
typename|class...Args(可选) （2） -
template<形参列表>typename(C++17)|class...Args(可选) （3）
（1）带可选名字的非类型模板形参包。如template
（2）带可选名字的类型模板形参包。如template
（3）带可选名字的模板模板形参包。如template
template struct Tuple {};
Tuple<> t0; // Types 不包含实参
Tuple t1; // Types 包含一个实参：int
Tuple t2; // Types 包含二个实参：int 与 float
Tuple<0> error; // 错误：0 不是类型
template struct Valid; // Ts必须时最后一个 函数模板形参包
出现于变参函数模板的函数形参列表中，简单说就是存在于函数参数里
语法：
-
Args ...args(可选) （1）
（1）带可选名字的函数形参包。
template void f(Types ... args);
f(); // OK：args 不包含实参
f(1); // OK：args 包含一个实参：int
f(2, 1.0); // OK：args 包含二个实参：int 与 double
template
void valid(U, Ts...); // 函数模板中 对Ts顺序无要求，只要实际能推导出即可 形参包展开
出现于变参模板体中
语法：
-
模式 ... （1）
（1）形参包展开：展开成零或更多 模式 的逗号分隔列表。模式必须包含至少一个形参包。如func( args...);
模式后随省略号，其中至少有一个形参包的名字至少出现一次，其被展开成零或更多个逗号分隔的模式实例，
其中形参包的名字按顺序被替换成包中的各个元素
template void f(Us... pargs) {}
template void g(Ts... args) {
f(&args...); // “&args...” 是包展开
// “&args” 是其模式
}
g(1, 0.2, "a"); // Ts... args 展开成 int E1, double E2, const char* E3
// &args... 展开成 &E1, &E2, &E3
// Us... 展开成 int* E1, double* E2, const char** E3 若两个形参包出现于同一模式中，则它们同时展开，而且它们必须有相同长度：
template struct Tuple {};
template struct Pair {};
template struct zip {
template struct with {
typedef Tuple...> type;
// Pair... 是包展开
// Pair 是模式
};
};
typedef zip::with::type T1;
// Pair... 展开成
// Pair, Pair
// T1 是 Tuple, Pair>
typedef zip::with::type T2;
// 错误：包展开中包含不同长度的形参包 若包展开内嵌于另一包展开中，则其所展开的是出现于最内层包展开的形参包，并且必须在外围（而非最内层）
的包展开中必须提及另一个包：
template
void g(Args... args) {
f(const_cast(&args)...);
// const_cast(&args) 是模式，它同时展开两个包（Args 与 args）
f(h(args...) + args...); // 嵌套包展开：
// 内层包展开是“args...”，它首先展开
// 外层包展开是 h(E1, E2, E3) + args 它被第二次展开
// （成为 h(E1,E2,E3) + E1, h(E1,E2,E3) + E2, h(E1,E2,E3) + E3）
} 展开场所
取决于发生展开的场所，其所产生的逗号分隔列表可以是不同种类的列表：函数形参列表，成员初始化器列表，属性列表，等等。以下列出了所有允许的语境。
函数实参列表
包展开可以出现在函数调用运算符的括号内，此情况下省略号左侧的最大表达式或花括号初始化器列表是被展开的模式。
f(&args...); // 展开成 f(&E1, &E2, &E3)
f(n, ++args...); // 展开成 f(n, ++E1, ++E2, ++E3);
f(++args..., n); // 展开成 f(++E1, ++E2, ++E3, n);
f(const_cast(&args)...);
// f(const_cast(&X1), const_cast(&X2), const_cast(&X3))
f(h(args...) + args...); // 展开成
// f(h(E1,E2,E3) + E1, h(E1,E2,E3) + E2, h(E1,E2,E3) + E3) 正式而言，函数调用表达式中的表达式列表被归类为初始化器列表，其模式是初始化器子句，它或是赋值表达式，或是花括号初始化器列表。
有括号初始化器
包展开可出现于直接初始化器，函数式转型及其他语境（成员初始化器，new 表达式等）的括号之内，这种情况下的规则与适用于上述函数调用表达式的规则相同：
Class c1(&args...); // 调用 Class::Class(&E1, &E2, &E3)
Class c2 = Class(n, ++args...); // 调用 Class::Class(n, ++E1, ++E2, ++E3);
::new((void *)p) U(std::forward(args)...) // std::allocator::allocate 花括号包围的初始化器
在花括号初始化器列表（花括号包围的初始化器和其他花括号初始化器列表的列表，用于列表初始化和其他一些语境中）中，也可以出现包展开：
template void func(Ts... args){
const int size = sizeof...(args) + 2;
int res[size] = {1,args...,2};
// 因为初始化器列表保证顺序，所以这可用于按顺序对包的每个元素调用函数：
int dummy[sizeof...(Ts)] = { (std::cout << args, 0)... };
} 模板实参列表
包展开可用于模板形参列表的任何位置，前提是模板拥有与该展开相匹配的形参。
template void func(A arg1, B arg2, C...arg3)
{
container t1; // 展开成 container
container t2; // 展开成 container
container t3; // 展开成 container
} 函数形参列表
在函数形参列表中，若省略号出现于某个形参声明中（无论它是否指名函数形参包（例如在 Args ... args中）），则该形参声明是模式：
template void f(Ts...) {}
f('a', 1); // Ts... 展开成 void f(char, int)
f(0.1); // Ts... 展开成 void f(double)
template void g(Ts (&...arr)[N]) {}
int n[1];
g("a", n); // Ts (&...arr)[N] 展开成
// const char (&)[2], int(&)[1] 注意：在模式 Ts (&...arr)[N] 中，省略号是最内层元素，而非如所有其他包展开中一样为其最后元素。
注意：Ts (&...)[N] 不被允许，因为 C++11 语法要求带括号的省略号形参拥有名字：CWG #1488。
模板形参列表
包展开可以出现于模板形参列表中：
template struct value_holder
{
template // 展开成非类型模板形参列表，
struct apply { }; // 例如
}; 基类说明符与成员初始化器列表
包展开可以用于指定类声明中的基类列表。典型情况下，这也意味着其构造函数也需要在成员初始化器列表中使用包展开，以调用这些基类的构造函数：
template
class X : public Mixins... {
public:
X(const Mixins&... mixins) : Mixins(mixins)... { }
}; Lambda 捕获
包展开可以出现于 lambda 表达式的捕获子句中
template
void f(Args... args) {
auto lm = [&, args...] { return g(args...); };
lm();
} sizeof... 运算符
sizeof... 也被归类为包展开
template
struct count {
static const std::size_t value = sizeof...(Types);
}; 动态异常说明
动态异常说明中的异常列表亦可为包展开
template void func(int arg) throw(X...)
{
// ... 在不同情形下抛出不同的 X
} 对齐说明符
包展开允许在关键词 alignas 所用的类型列表和表达式列表中使用
属性列表
包展开允许在属性列表中使用，如 [[attributes...]]。例如：void [[attributes...]] function()
| 折叠表达式 在折叠表达式中，模式是不包含未展开形参包的整个子表达式。 using 声明 在 using 声明中，省略号可以出现于声明器列表内，这对于从一个形参包进行派生时有用： |
(C++17 起) |
template
struct X : bases... {
using bases::g...;
};
X x; // OK：引入 B::g 与 D::g 折叠表达式(C++17 起)
< cpp | language
以二元运算符对形参包进行规约（折叠）。
语法
( 形参包 op ... ) |
(1) | ||||||||
( ... op 形参包 ) |
(2) | ||||||||
( 形参包 op ... op 初值 ) |
(3) | ||||||||
( 初值 op ... op 形参包 ) |
(4) | ||||||||
1) 一元右折叠
2) 一元左折叠
3) 二元右折叠
4) 二元左折叠
| op | - | 任何下列 32 个二元运算符之一：+ - * / % ^ & | = < > << >> += -= *= /= %= ^= &= |= <<= >>= == != <= >= && || , .* ->*。在二元折叠中，两个 op 必须相同。 |
| 形参包 | - | 含未展开的形参包且其顶层不含有优先级低于转型（正式而言，是 转型表达式）的运算符的表达式 |
| 初值 | - | 不含未展开的形参包且其顶层不含有优先级低于转型（正式而言，是 转型表达式）的运算符的表达式 |
注意开与闭括号是折叠表达式的一部分。
解释
折叠表达式的实例化按如下方式展开成表达式 e：
1) 一元右折叠 (E op ...) 成为 (E1 op (... op (EN-1 op EN)))
2) 一元左折叠 (... op E) 成为 (((E1 op E2) op ...) op EN)
3) 二元右折叠 (E op ... op I) 成为 (E1 op (... op (EN−1 op (EN op I))))
4) 二元左折叠 (I op ... op E) 成为 ((((I op E1) op E2) op ...) op EN)
（其中 N 是包展开中的元素数）
例如，
template
bool all(Args... args) { return (... && args); }
bool b = all(true, true, true, false);
// 在 all() 中，一元左折叠展开成
// return ((true && true) && true) && false;
// b 为 false 将一元折叠用于零长包展开时，仅允许下列运算符：
1) 逻辑与（&&）。空包的值为 true
2) 逻辑或（||）。空包的值为 false
3) 逗号运算符（,）。空包的值为 void()
注解
若用作 初值 或 形参包 的表达式在顶层具有优先级低于转型的运算符，则它可以加括号：
template
int sum(Args&&... args) {
// return (args + ... + 1 * 2); // 错误：优先级低于转型的运算符
return (args + ... + (1 * 2)); // OK
} 示例
#include
#include
#include
#include
#include
#include
template
void printer(Args&&... args) {
(std::cout << ... << args) << '\n';
}
template
void push_back_vec(std::vector& v, Args&&... args)
{
static_assert((std::is_constructible_v && ...));
(v.push_back(args), ...);
}
// 基于 http://stackoverflow.com/a/36937049 的编译时端序交换
template
constexpr T bswap_impl(T i, std::index_sequence) {
return (((i >> N*CHAR_BIT & std::uint8_t(-1)) << (sizeof(T)-1-N)*CHAR_BIT) | ...);
}
template>
constexpr U bswap(T i) {
return bswap_impl(i, std::make_index_sequence{});
}
int main()
{
printer(1, 2, 3, "abc");
std::vector v;
push_back_vec(v, 6, 2, 45, 12);
push_back_vec(v, 1, 2, 9);
for (int i : v) std::cout << i << ' ';
static_assert(bswap(0x1234u)==0x3412u);
static_assert(bswap(0x0123456789abcdefULL)==0xefcdab8967452301ULL);
}
/*
输出：
123abc
6 2 45 12 1 2 9
*/
简单示例
struct A {
void print() {
cout << "struct A" << endl;
}
};
struct B {
void print() {
cout << "struct B" << endl;
}
};
template
struct X : base... {
using base::print...;
};
void test_X()
{
X x;
x.A::print();
x.B::print();
}
template
bool all(Args...args) {
return (args && ...);
}
/* 折叠表达式 */
void test_Foldedexpression(){
/* all(true, false, true) 展开为 (true && (false && true)) */
cout << std::boolalpha << all(true, false, true) << endl;
}
template
void print_sequence(std::integer_sequence int_seq) {
cout << "The sequence size is " << int_seq.size() << ": ";
((cout << ints << ' '), ...);
cout << endl;
}
// std::integer_sequence 展开为0，1，2，3
template
auto arraytotuple_impl(const Array& a, std::integer_sequence) {
return std::make_tuple(a[index]...); // 展开为a[0],a[1],a[2],a[3]
}
template >
auto arraytotuple(const std::array& a) {
return arraytotuple_impl(a, Indics{});
}
// std::index_sequence 展开为0，1，2，3的下表序列
template
void print_tuple_impl(const Tuple& t, std::index_sequence)
{
((cout << std::get(t) << ' '), ...);
}
template
void print_tuple(const std::tuple& t) {
cout << sizeof...(Ty) << ':'; // 获取参数个数： 4
cout << sizeof(t) << ": "; // 获取t占用字节大小： 16
((cout<< typeid(Ty).name() << ' '), ...); // 输出类型：int int int int
print_tuple_impl(t, std::index_sequence_for{});
cout << endl;
}
void test_sequence() {
print_sequence(std::make_index_sequence<10>{});
// array，tuple都是编译器能确定size的类型
std::array a = { 0, 1, 4, 7 };
auto tuple = arraytotuple(a);
print_tuple(tuple);
}