可变参数模板(C++11)
这篇文章解说的是C++11的特性之一——可变参数模板，适合有一定根本的同学学习，如果是刚入门的同学可以看我过往的文章：C++根本入门可变参数模板（Variadic Templates）是C++的一种高级特性，它允许你编写接受任意数量模板参数的模板。可变参数模板在函数、类和其他模板中都可以利用。
1. 可变参数模板的根本语法
template<typename... Args>
void func(Args... args) {
// 在这里可以使用 args...
}
[*]typename... Args：这里的 Args... 表示这是一个模板参数包，它可以包罗任意数量的模板参数，类型也可以不同。
[*]args...：这是一个函数参数包，对应于模板参数包 Args...。它可以包罗任意数量的参数。
2. 递归展开
作用
可变参数模板的主要作用是简化处理不确定数量参数的场景。比如，你可以利用它来创建一个函数，可以接受任意数量的参数，而无需为每种参数数量环境写不同的函数重载。
在C++11之前，可变参数也仅仅限于函数参数，比如最常见的是我们的老朋侪printf函数，而今天提到的是模板的可变参数。
示例
假设你要写一个打印多个参数的函数，可以这样做：
#include <iostream>
// 基本模板：递归终止条件，无参的递归终止函数
void print() {
std::cout << "End of recursion\n";
}
// 可变参数模板
template<typename T, typename... Args>
void print(T first, Args... args) {
std::cout << first << std::endl;// 打印第一个参数
print(args...);// 递归调用自身，继续打印剩余的参数
}
int main() {
print(1, 2.5, "Hello", 'A');
return 0;
}
在这个例子中，print 函数接受了任意数量的参数，并依次打印它们。递归的停止条件是函数没有参数时调用的 void print() 重载。留意参数包是不支持args来获取参数的。
如果想在没有传参数的时候也是走函数模板的代码，可以改成这样：
#include <iostream>
// 可变参数模板：处理任意数量的参数，包括没有参数的情况
template<class T, class... Args>
void ShowListArg(T value, Args... args) {
std::cout << value << " ";
ShowListArg(args...);// 递归调用，继续处理剩余的参数
}
// 空参数包的情况
template<class... Args>
void ShowListArg() {
std::cout << std::endl;// 当没有参数时，直接打印换行符
}
// 包装函数
template<class... Args>
void ShowList(Args... args) {
ShowListArg(args...);// 调用处理函数
}
int main() {
ShowList(1, 2.5, "Hello", 'A');// 正常的参数调用
ShowList();// 没有参数的调用
return 0;
}
带参的递归停止函数
如果你渴望递归停止条件的函数也带有一个参数，可以通过限定参数的数量，使其只处理一个参数而不再递归调用。这就是递归的“根本条件”，在这种环境下，函数只需要处理末了一个参数。以下是一个带有参数的递归停止函数的例子：
#include <iostream>
// 递归终止函数：处理最后一个参数
template<class T>
void ShowListArg(T value) {
std::cout << value << std::endl;// 打印最后一个参数，并换行
}
// 可变参数模板：处理多个参数的情况
template<class T, class... Args>
void ShowListArg(T value, Args... args) {
std::cout << value << " ";
ShowListArg(args...);// 递归调用，继续处理剩余的参数
}
// 包装函数
template<class... Args>
void ShowList(Args... args) {
ShowListArg(args...);// 调用处理函数
}
也就是说这个函数至少要传一个参数，如果不传参数的话就会报错。
能不能把参数包放到数组里？
不能直接将不同类型的参数放入原生数组中，可以利用 std::initializer_list 大概 std::array 来处理参数包中的参数。
下面是一个示例，利用 std::initializer_list 将参数包中的参数放入数组并进行处理：
#include <iostream>
#include <initializer_list>
// 包装函数，用于将参数包转为 std::initializer_list
template<typename... Args>
void ShowList(Args... args) {
std::initializer_list<int> list{ args... };
for (auto value : list) {
std::cout << value << " ";
}
std::cout << std::endl;
}
int main() {
ShowList(1, 2, 3, 4);// 只支持同一类型的参数
return 0;
}
限定
利用 std::initializer_list 时，全部参数必须是同一类型（如上例中的 int）。如果你渴望处理不同类型的参数，则需要利用其他方法，如 std::tuple 大概变体类（例如 std::variant）。以下是一个利用 std::tuple 的示例：（这段代码有点难，但不是这篇文章的重点，可以暂时忽略，感爱好可以借助ai来学习）
#include <iostream>
#include <tuple>
// 辅助函数，用于递归地打印 std::tuple 中的元素
template<std::size_t Index = 0, typename... Args>
void printTuple(const std::tuple<Args...>& t) {
if constexpr (Index < sizeof...(Args)) {
std::cout << std::get<Index>(t) << " ";
printTuple<Index + 1>(t);
}
else {
std::cout << std::endl;
}
}
// 包装函数，将参数包放入 std::tuple
template<typename... Args>
void ShowList(Args... args) {
auto t = std::make_tuple(args...);// 创建 std::tuple
printTuple(t);// 打印 tuple 中的所有元素
}
int main() {
ShowList(1, 2.5, "Hello", 'A');// 支持不同类型的参数
return 0;
}
[*] std::tuple：std::tuple 是一个可以包罗多个不同类型元素的容器。我们将参数包 args... 放入 std::tuple 中，以便处理不同类型的参数。
[*] printTuple 函数：
[*]这个函数利用递归方式来打印 std::tuple 中的每个元素。
[*]if constexpr 是一种在编译时进行条件判断的方式，当递归到达 tuple 的末端时，停止递归并打印换行符。
这个示例支持将不同类型的参数放入数组并进行处理。你可以根据你的需求选择适合的方式。
2. 折叠表达式展开
利用折叠表达式来展开参数包是一种高级技巧，它可以在处理可变参数模板时简化代码。
下面是一个示例：
#include <iostream>
// 使用逗号表达式展开参数包
template<typename... Args>
void ShowList(Args... args) {
(std::cout << ... << args) << std::endl;
}
int main() {
ShowList(1, 2.5, "Hello", 'A');// 调用示例
return 0;
}
[*](std::cout << ... << args)：这是一个利用折叠表达式（fold expression）的语法，它可以对参数包进行操作。
[*]...：表示参数包的展开位置。
[*]std::cout << args：表示将参数包中的每个元素依次输出到 std::cout。
逗号表达式与折叠表达式的结合
在更传统的环境下，逗号表达式通常与初始化列表一起利用来展开参数包：
#include <iostream>
// 使用逗号表达式和初始化列表展开参数包
template<typename... Args>
void ShowList(Args... args) {
(void)std::initializer_list<int>{(std::cout << args << " ", 0)...};
std::cout << std::endl;
}
int main() {
ShowList(1, 2.5, "Hello", 'A');// 调用示例
return 0;
}
表明
[*]std::initializer_list{(std::cout << args << " ", 0)…}：
[*]{(std::cout << args << " ", 0)...}：这是逗号表达式在初始化列表中的应用。这里的 std::cout << args << " " 负责输出每个参数，逗号后的 0 是为了满足 std::initializer_list 的类型要求。
[*]... 负责展开参数包 args...，将每个 args 依次通报给表达式 (std::cout << args << " ", 0)，然后将结果（即 0）放入 std::initializer_list<int> 中。
[*]利用 (void) 是为了忽略 std::initializer_list 的结果，因为我们只关心输出操作。
总结
[*]利用折叠表达式 (std::cout << ... << args) 是现代 C++（C++17 及以后）的简洁做法，它直接对参数包进行展开，并将结果输出。
[*]利用传统的逗号表达式和初始化列表是一种更通用的方法，适用于更早版本的 C++，但是不是很推荐。
这两种方法都可以有效地展开参数包，并实行所需的操作。根据你的编译器支持环境，你可以选择此中一种方式来利用。
3. emplace_back
https://i-blog.csdnimg.cn/direct/3c285fb9464c443aa6941640760fdb53.png
在C++11中，STL的容器加入了emplace系列的接口，支持模板的可变参数
https://i-blog.csdnimg.cn/direct/7ee85109af53433db6626730ac209099.png
留意：此处的"&&"表示的是万能引用，详细可见上一篇文章（链接）
在 C++ 中，std::list 中的 push_back 和 emplace_back 是用于向列表的末端添加元素的两个函数，但它们在利用方式和效率上有一些紧张的区别。
1. push_back
[*] 用法: push_back 接受一个已存在的对象或对象的副本作为参数，并将其添加到列表的末端。
[*] 过程:
[*]传入的对象首先会被复制（大概移动，如果支持移动语义）。
[*]然后，std::list 会调用该对象的拷贝构造函数（或移动构造函数），将对象放入列表中。
[*] 示例:
std::list<std::string> myList;
std::string str = "Hello";
myList.push_back(str);// 传入的是对象的副本
[*] 性能影响: 由于需要复制（或移动）对象，push_back 在某些环境下可能会有额外的性能开销，特殊是在处理大型对象时。
2. emplace_back
[*] 用法: emplace_back 直接在列表末端构造一个对象。它接受构造函数的参数，然后在列表末端调用构造函数来创建对象。
[*] 过程:
[*]emplace_back 不需要先创建对象并再进行复制或移动，而是直接在目标位置调用构造函数进行对象构造。
[*]它可以避免不必要的复制或移动，从而提高性能。
[*] 示例:
std::list<std::string> myList;
myList.emplace_back("Hello");// 直接在列表中构造对象
[*] 性能优势: emplace_back 直接构造对象，避免了对象的拷贝或移动，这在处理复杂对象或大对象时尤其高效。
当你需要向列表中添加对象，而且该对象的构造过程较为复杂或你渴望避免不必要的拷贝时，emplace_back 是更好的选择。如果你已经有一个现成的对象，而且只是需要将它添加到列表中，那么利用 push_back 也是完全可以的。
传参数包
当你利用参数包通报给 push_back 和 emplace_back 时，两者的活动仍然有所不同，特殊是当你处理参数包中的多个参数时。
1. push_back 和参数包
push_back 不能直接接受参数包，因为 push_back 只接受一个已经构造好的对象。如果你通报参数包给 push_back，首先你需要将参数包展开并用于构造对象，然后将这个构造好的对象通报给 push_back。
示例：
#include <list>
#include <string>
template <typename T, typename... Args>
void addToList(std::list<T>& lst, Args&&... args) {
lst.push_back(T(std::forward<Args>(args)...));
}
int main() {
std::list<std::string> myList;
addToList(myList, "Hello", 5, 'a'); // 传递给std::string的构造函数
return 0;
}
2. emplace_back 和参数包
emplace_back 可以直接接受参数包并将其转发给对象的构造函数。因此，当你通报参数包给 emplace_back 时，它会将这些参数直接用于在容器中构造对象，而不会进行多余的拷贝或移动操作。
示例：
#include <list>
#include <string>
template <typename T, typename... Args>
void emplaceToList(std::list<T>& lst, Args&&... args) {
lst.emplace_back(std::forward<Args>(args)...);
}
int main() {
std::list<std::string> myList;
emplaceToList(myList, "Hello", 5, 'a'); // 在容器中直接构造std::string
return 0;
}
3. 区别总结
[*] push_back 和参数包：
[*]你需要手动展开参数包，构造对象，然后将该对象通报给 push_back。
[*]这种方式可能会导致额外的对象拷贝或移动操作。
[*] emplace_back 和参数包：
[*]可以直接将参数包通报给 emplace_back，由它在容器中直接构造对象。
[*]更加高效，避免了不必要的拷贝和移动操作。
4. 实际应用
[*]当你需要在容器中直接构造对象，而且通报了多个参数时，emplace_back 是更好的选择，因为它更高效且代码更简洁。
[*]如果你需要通报已经构造好的对象，大概你不能直接利用构造函数参数，则只能利用 push_back。
这样做的好处在于利用 emplace_back 时，你可以省去中央对象的创建，直接在容器中进行对象的构造，尤其是在处理参数包时，emplace_back 能够让代码更具表现力和效率。
可变参数模板非常强盛，但也可能让代码变得复杂，以是在利用时需要小心。如果学会了就会对代码的理解有进了一步，恭喜你~ 如果文章对你有帮助的话不妨点个赞。
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]