可变参数模板
可变参数模板的概念和语法
📊 如果一个函数需要的参数个数以及参数类型不确定时，我们急需一种能够让参数可变的方法！
- 在参数类型一致，参数个数不同时可以使用
initializer_list - 在参数类型不一致时，需要使用C++提供的可变参数模板
🎃 来个代码：
#include <iostream>
template<typename ...Args>
void print(Args ...args)
{
std::cout << __FUNCTION__ << " " << sizeof...(args) << std::endl;
}
int main()
{
print(1, 2, "Hello", "World", 18, 20);
print("aaa", 2);
print(11111);
return 0;
}
⛑ 结果：
print 6
print 2
print 1
💱 解释
- 在上面的代码中
class ...Args是类型模板形参包，他可以接受零个或者多个类型的模板实参； Args ...args叫做函数形参包，它出现在函数的形参列表中，可以接受零个或者多个函数实参；sizeof...(args)其中sizeof...是C++的运算符，专门用来获取形参包的参数个数。
以上这些语法概念看起来可能会有点复杂。但是这样写应该就明了了：
int main()
{
print(1, 2, "Hello", "World", 18, 20); // print<int, int, string, string, int, int>
print("aaa", 2); // print<string, int>
print(11111); // print<int>
return 0;
}
上面，我们可以看出，其实就是省去了定义类型步骤，这个步骤编译器是自动帮我们实现的，对于可变参数模板来说，它可以接收任意多个参数，这些参数都交由编译器自动帮我们推导，最总生成对于的实例化函数。
可变参注意点
如果可变参数和其他模板变量相结合，那一定要注意顺序问题，必须将含餐变量放到最后，如下代码所示。
#include <iostream>
template<typename T, typename U, typename ...Args>
void foo(T t, U u, Args ...args)
{
std::cout << "first: " << t << " second: " << u << " other size: " << sizeof...(args) << std::endl;
}
int main()
{
foo<int, double>(10, 66.0, "wy", 28);
return 0;
}
形参包展开
含参变量，如果可以存储任意个数，任意类型，那必有一个核心功能，就是含参展开 ，也叫形参包展开，简称包展开。只有结合了包展开，才能发挥变参模板的能力。但是注意的是，包展开并不是在所有情况下都能够进行的，允许包展开的场景包括以下几种。
- 表达式列表。
- 初始化列表。
- 基类描述。
- 成员初始化列表。
- 函数参数列表。
- 模板参数列表。
- 动态异常列表（C++17已经不再使用）。
- lambda表达式捕获列表。
- Sizeof…运算符。
- 对其运算符。
- 属性列表。
借助辅助函数实现包展开
#include <iostream>
template<typename T>
T print(T t)
{
std::cout << t << std::endl;
return t;
}
// 解包辅助函数
template<typename ...Args>
void unpack(Args ...args)
{
}
template<typename ...Args>
void foo(Args ...args)
{
unpack(print(args)...);
}
int main()
{
foo(1, 2, "y", "x", "z");
return 0;
}
在上面的代码中，print是一个普通的函数模板，它将实参通过std::cout输出到控制台上。unpack是一个可变参数的函数模板，不过这个函数什么也不做。在main函数中调用了foo函数模板，并传递了参数，在它的函数体里面对形参包进行了展开，其中print(args)...是包展开，而print(args)就是模式，也可以理解为包展开的方法。所以这段代码相当于：
void foo(int a1, int a2, string a3, string a4, string a5)
{
unpack(print(a1), print(a2), print(a3), print(a4), print(a5));
}
对于这个代码来说，就非常清晰了，其实unpack这个空函数，就是用来容纳包展开的内容的。
可变参数模板的递归
递归输出所有参数
在上面的形参包展开中也能输出所有参数，但是比较麻烦，接下来看一下递归方式输出，比如下面的案例：
#include <iostream>
template<typename T, typename ...Args>
void foo(T t, Args ...args)
{
std::cout << t << " ";
foo(args...);
}
int main()
{
foo(1, 2, 3, "y", "x", "z");
return 0;
}
但是一运行，结果会报错
这是因当可变惨args为空的时候，这个时候调用foo的时候，会出现参数不匹配的情况
🌌 解决方法
- 方法一：传入一个结束数据，如下：
template<typename T,typename ...Args>
void foo(T t,Args ...args)
{
if(t == 0)
return;
cout << t << endl;
foo(args...,0);
}
在这里仅仅是加了一个判断，当t == 0，也是就是 foo(args...,0);这个调用的最后一个参数时，退出递归！
当然这个有个坏处，就是当调用者的参数中出现了0时，递归会提前结束，所以这样就需要额外定义一个结束标志。
- 方法二：使用函数重载
在上面可变参数模板的递归的时候，报错的原因是当可变惨没有数据的时候，函数foo找不到，那我们可以利用函数重载，当只剩下最后一个数据的时候，让编译器调用函数模板即可。
#include <iostream>
template<typename T>
void foo(T t)
{
std::cout << t << std::endl;
}
template<typename T, typename ...Args>
void foo(T t, Args ...args)
{
std::cout << t << " ";
foo(args...);
}
int main()
{
foo(1, 2, 3, "y", "x", "z");
return 0;
}折叠表达式
折叠表达式求和
如果想实现可变参数中参数求和，递归计算的方式过于烦琐，数组和括号表达式的方法技巧性太强也不是很容易想到。为了用更加正规的方法完成包展开，C++委员会在C++17标准中引入了折叠表达式的新特性，下面是用新特性修改的例子：
template<typename ...Args>
auto sum(Args ...args)
{
return (args + ...);
}
int main()
{
std::cout << sum(1, 5.0, 11.7) << std::endl;
}
C++17这一次对这个功能的更新，极大的简化了操作，对于上面，(args + …)会被折叠为arg0 + (arg1 + arg2)，即1 + (5.0 + 11.7)。
在C++17的标准中有4种折叠规则，分别是一元向左折叠、一元向右折叠、二元向左折叠和二元向右折叠。上面的例子就是一个典型的一元向右折叠(公式看着简单，但是运用起来挺难，我如果用会结合AI辅助)：
(args op ...)折叠为(arg0 op (arg1 op ... (argN-1 op argN)))
对于一元向左折叠而言，折叠方向正好相反：
(... op args )折叠为((((arg0 op arg1) op arg2) op ...) op argN)
二元折叠总体上和一元相同，唯一的区别是多了一个初始值，比如二元向右折叠：
(args op ... op init )折叠为(arg0 op (arg1 op ...(argN-1 op (argN op
init)))
二元向左折叠也是只有方向上正好相反：
(init op ... op args )折叠为(((((init op arg0) op arg1) op arg2) op
...) op argN)
虽然没有提前声明以上各部分元素的含义，但是看懂不难。
- args表示的是形参包的名称
- init表示的是初始化值
- 而op则代表任意一个二元运算符。值得注意的是，在二元折叠中，两个运算符必须相同。 (且折叠初始值和末尾值不属于折叠展开式子)
其他情况
- 情况一，用折叠参数展开，
OP左右之间必须是能正常运算的，如下代码：
#include <iostream>
template<typename ...Args>
auto sum(Args ...args)
{
return (args + ...);
}
int main()
{
std::cout << sum(1, 2, 3, "y", "x", "z") << std::endl;
return 0;
}
这个时候，运行会报错，因为这个时候展开情况1 + (2 + 3 + "w" + "y" + "z") 的情况，所以报错。
- 情况二，string类型和原生字符串类型
在折叠规则中最重要的一点就是操作数之间的结合顺序，如下：
template<typename ...Args>
auto sum(Args ...args)
{
return (args + ...);
}
int main()
{
cout << sum(std::string("hello "), "C++", "Maye") << endl;
}
上面的代码会编译失败，因为折叠表达式(args +…)向右折叠，所以翻译出来的实际代码是(std::string("hello ") + ("c++ " + "Maye"))，但是两个原生的字符串类型是无法相加的，所以编译一定会报错。要使这段代码通过编译，只需要修改一下折叠表达式即可：
template<typename ...Args>
auto sum(Args ...args)
{
return (... + args);
}
这样翻译出来的代码将是((std::string("hello ") +"c++ ") + "world")，而std::string类型的字符串可以使用+将两个字符串连接起来，于是可以顺利地通过编译。
折叠表达式输出
最后让我们来看一个有初始化值的例子：
#include <iostream>
template<typename ...Args>
void foo(Args ...args)
{
(std::cout << ... << args) << std::endl;
}
int main()
{
foo(1, 2, 3, "y", "x", "z");
return 0;
}
在上面的代码中，foo是一个输出函数，它会将传入的实参输出到控制台上。该函数运用了二元向左折叠(std::cout <<…<<args)，其中std::cout是初始化值，编译器会将代码翻译为()(((((std::cout << 1) << 2) << 3) << "y") << "x") << "z") << std::endl;
小结
💌 核心：明白是几元运算符，是左叠还是右叠。
一元折叠表达式中空参数包的特殊处理
一元折叠表达式对空参数包展开有一些特殊规则，这是因为编译器很难确定折叠表达式最终的求值类型，比如：
template<typename ...Args>
auto sum(Args ...args)
{
return (args + ...);
}
在上面的代码中，如果函数模板sum的实参为空，那么表达式args +…是无法确定求值类型的。当然，二元折叠表达式不会有这种情况，因为它可以指定一个初始化值：
template<typename ...Args>
auto sum(Args ...args)
{
return (args + ... + 0);
}
这样即使参数包为空，表达式的求值结果类型依然可以确定，编译器可以顺利地执行编译。
为了解决一元折叠表达式中参数包为空的问题，下面的规则是必须遵守的，注意是为空的情况：
-
只有 &&、|| 和 , 运算符能够在空参数包的一元折叠表达式中使用;
- 这些运算符在参数包为空时有明确的求值结果，编译器可以正确处理。
-
&& 的求值结果一定为 true;
- 例如，(true && …) 在参数包为空时求值为 true。
-
|| 的求值结果一定为 false；
- 例如，(false || …) 在参数包为空时求值为 false。
-
, 的求值结果为 void();
- 例如，(void(), …) 在参数包为空时求值为 void()。
-
其他运算符都是非法的;
- 例如，+、-、*、/ 等运算符在参数包为空时会导致编译错误，因为编译器无法推导出返回类型。
template<typename ...Args>
auto andop(Args ...args)
{
return (args && ...);
}
int main()
{
std::cout<< std::boolalpha << andop()<<std::endl;
}
在上面的代码中，虽然函数模板andop的参数包为空，但是依然能成功地编译运行并且输出计算结果true。
