可变参数模板与折叠
当函数需要接受「任意数量、任意类型」的参数时,C++11 的可变参数模板(Variadic Templates)提供了类型安全的解决方案;而 C++17 的折叠表达式(Fold Expressions)则让参数包的处理从递归走向了一行搞定。本节将带你从基础语法到实用模式,全面掌握这两项关键技术。
1. 可变参数模板 (Variadic Templates)
可变参数模板允许模板接受零个或多个参数。语法核心是省略号 ...,它出现在不同位置有不同含义:
// 类型参数包:零个或多个类型
template<typename... Ts>
void foo(Ts... args); // args 是函数参数包
// 非类型参数包 (C++17):零个或多个值
template<auto... Vs>
struct ValueList {};
// 混合使用
template<typename T, typename... Rest>
void bar(T first, Rest... rest);
命名惯例:
Ts(或 Args)表示类型参数包,args(或 values)表示函数参数包。省略号在声明侧紧跟类型名,在使用侧紧跟参数名。
一个最简单的可变参数函数模板:
#include <iostream>
// 接受任意数量、任意类型的参数
template<typename... Args>
void ignore_all(Args... args) {
// 目前什么都不做——我们稍后学习如何展开 args
std::cout << "收到 " << sizeof...(args) << " 个参数\n";
}
int main() {
ignore_all(); // 收到 0 个参数
ignore_all(1, 2.5, "hi"); // 收到 3 个参数
}
2. 参数包展开
2.1 sizeof... 运算符
sizeof...(pack) 在编译期返回参数包中的元素个数,结果类型为 std::size_t:
template<typename... Ts>
constexpr std::size_t count() {
return sizeof...(Ts); // 对类型包求大小
}
template<typename... Ts>
void f(Ts... args) {
constexpr auto n = sizeof...(args); // 对函数参数包求大小
static_assert(n >= 1, "至少需要一个参数");
}
static_assert(count<int, double, char>() == 3);
2.2 递归展开模式(C++11 风格)
在 C++17 折叠表达式出现之前,展开参数包的经典方式是递归:一个基准情况(base case)处理零或一个参数,递归情况剥离第一个参数并继续处理剩余部分。
#include <iostream>
// 基准情况:无参数时结束递归
void print() {
std::cout << '\n';
}
// 递归情况:处理第一个参数,递归剩余
template<typename T, typename... Rest>
void print(T first, Rest... rest) {
std::cout << first;
if constexpr (sizeof...(rest) > 0) {
std::cout << ", ";
}
print(rest...); // 包展开:rest... 展开为剩余参数列表
}
int main() {
print(1, 2.5, "hello", 'X');
// 输出:1, 2.5, hello, X
}
注意:递归模式中,每次递归都会实例化一个新的函数模板。
print(1, 2.5, "hello", 'X') 会生成 4 个不同的 print 实例加上一个基准重载,共 5 个函数。参数越多,编译时间越长。
2.3 展开上下文
参数包可以在多种上下文中展开,不仅限于函数调用:
template<typename... Ts>
void expand_demo(Ts... args) {
// 1) 函数调用参数列表
auto t = std::make_tuple(args...);
// 2) 初始化列表(利用逗号展开技巧,C++11)
int dummy[] = { (std::cout << args << ' ', 0)... };
(void)dummy;
// 3) 对每个参数施加变换后展开
auto t2 = std::make_tuple((args * 2)...); // 每个 arg 乘以 2
}
// 4) 基类列表展开
template<typename... Bases>
struct Derived : Bases... {
using Bases::operator()...; // C++17: using 声明展开
};
3. 折叠表达式 (Fold Expressions, C++17)
折叠表达式让我们对参数包直接执行二元运算符归约,无需递归。有四种形式:
| 形式 | 语法 | 展开结果 |
|---|---|---|
| 一元左折叠 | (... op args) |
((a op b) op c) |
| 一元右折叠 | (args op ...) |
(a op (b op c)) |
| 二元左折叠 | (init op ... op args) |
((init op a) op b) op c |
| 二元右折叠 | (args op ... op init) |
a op (b op (c op init)) |
助记:省略号靠左 → 左折叠(从左往右结合);省略号靠右 → 右折叠(从右往左结合)。有初始值 → 二元折叠。
3.1 求和示例
// 一元左折叠:(... + args) → ((a + b) + c)
template<typename... Args>
auto sum(Args... args) {
return (... + args);
}
// 二元左折叠:带初始值,空包安全
template<typename... Args>
auto safe_sum(Args... args) {
return (0 + ... + args); // 空包时返回 0
}
int main() {
auto s1 = sum(1, 2, 3, 4, 5); // 15
auto s2 = safe_sum(); // 0(空包)
auto s3 = sum(1.5, 2.5, 3.0); // 7.0
}
3.2 打印所有参数
#include <iostream>
// 用逗号运算符 + 左折叠,一行搞定!
template<typename... Args>
void print(Args... args) {
((std::cout << args << ' '), ...);
std::cout << '\n';
}
// 等价展开:(std::cout << a << ' '), (std::cout << b << ' '), ...
int main() {
print(1, 2.5, "hello", 'X');
// 输出:1 2.5 hello X
}
3.3 逻辑折叠
// 所有条件都为真?
template<typename... Bools>
constexpr bool all_of(Bools... bs) {
return (... && bs); // 空包时返回 true(&& 的单位元)
}
// 任一条件为真?
template<typename... Bools>
constexpr bool any_of(Bools... bs) {
return (... || bs); // 空包时返回 false(|| 的单位元)
}
static_assert(all_of(true, true, true));
static_assert(!all_of(true, false, true));
static_assert(any_of(false, false, true));
static_assert(!any_of()); // 空包:false
空包规则:对于一元折叠,当参数包为空时,只有
&&(→true)、||(→false)和逗号运算符(→void())有合法的默认值。其他运算符的空包折叠是编译错误,请使用二元折叠提供初始值。
4. 实用折叠模式
4.1 求和与求积
template<typename... Args>
auto sum(Args... args) { return (... + args); }
template<typename... Args>
auto product(Args... args) { return (... * args); }
auto s = sum(1, 2, 3, 4, 5); // 15
auto p = product(1, 2, 3, 4, 5); // 120
4.2 带分隔符打印
#include <iostream>
template<typename T, typename... Rest>
void print_sep(T first, Rest... rest) {
std::cout << first;
// 逗号折叠:先输出分隔符,再输出参数
((std::cout << ", " << rest), ...);
std::cout << '\n';
}
int main() {
print_sep("apple", "banana", "cherry");
// 输出:apple, banana, cherry
}
4.3 Push all — 批量插入容器
#include <vector>
template<typename T, typename... Args>
void push_all(std::vector<T>& vec, Args&&... args) {
(vec.push_back(std::forward<Args>(args)), ...);
}
int main() {
std::vector<int> v;
push_all(v, 1, 2, 3, 4, 5);
// v = {1, 2, 3, 4, 5}
}
4.4 类型检查 — 所有参数是否为同一类型
#include <type_traits>
template<typename T, typename... Rest>
constexpr bool all_same = (std::is_same_v<T, Rest> && ...);
static_assert(all_same<int, int, int>);
static_assert(!all_same<int, int, double>);
5. sizeof... 运算符详解
sizeof... 是在编译期求值的运算符,可用于 static_assert、if constexpr 和模板参数等场景:
#include <type_traits>
// 限制参数个数
template<typename... Args>
void at_least_two(Args... args) {
static_assert(sizeof...(Args) >= 2, "需要至少两个参数");
// ...
}
// 用于 if constexpr 分支
template<typename T, typename... Rest>
auto first_or_default(T val, Rest... rest) {
if constexpr (sizeof...(rest) == 0) {
return val; // 只有一个参数时直接返回
} else {
return val; // 有多个参数时也返回第一个
}
}
// 用于数组大小
template<typename... Args>
void store(Args... args) {
// 创建与参数包等大的数组
int results[sizeof...(args)] = { static_cast<int>(args)... };
}
6. if constexpr 与参数包
C++17 的 if constexpr 允许在编译期丢弃无关分支,与可变参数模板结合时,可以替代传统的递归终止重载:
#include <iostream>
// 传统方式需要两个重载(基准 + 递归)
// C++17 方式:只需一个函数模板
template<typename T, typename... Rest>
void print(T first, Rest... rest) {
std::cout << first;
if constexpr (sizeof...(rest) > 0) {
std::cout << ", ";
print(rest...); // 仅在包非空时实例化
} else {
std::cout << '\n';
}
}
int main() {
print(42, 3.14, "hello");
// 输出:42, 3.14, hello
}
if constexpr 的优势:不需要额外的基准情况重载函数,代码更集中、更易读。丢弃的分支中即使有语法错误(只要不依赖于模板参数),也不会引发编译错误。
更复杂的例子——根据参数类型执行不同操作:
#include <iostream>
#include <string>
#include <type_traits>
template<typename T, typename... Rest>
void describe(T val, Rest... rest) {
if constexpr (std::is_integral_v<T>) {
std::cout << val << " (整数)";
} else if constexpr (std::is_floating_point_v<T>) {
std::cout << val << " (浮点数)";
} else {
std::cout << val << " (其他)";
}
if constexpr (sizeof...(rest) > 0) {
std::cout << ", ";
describe(rest...);
} else {
std::cout << '\n';
}
}
int main() {
describe(42, 3.14, std::string("hello"));
// 输出:42 (整数), 3.14 (浮点数), hello (其他)
}
7. 综合实例
7.1 类型安全的 print 函数
实现类似 Python 的 print("name: {}, age: {}", name, age),使用折叠+递归替换占位符:
#include <iostream>
#include <string_view>
#include <sstream>
#include <stdexcept>
// 在格式串中找到第一个 {} 并替换为 val
template<typename T>
std::string replace_first(std::string_view fmt, T const& val) {
auto pos = fmt.find("{}");
if (pos == std::string_view::npos) {
throw std::runtime_error("多余的参数,没有对应的 {} 占位符");
}
std::ostringstream oss;
oss << fmt.substr(0, pos) << val << fmt.substr(pos + 2);
return oss.str();
}
// 无参数版本:直接输出格式串
void print(std::string_view fmt) {
std::cout << fmt << '\n';
}
// 可变参数版本:逐个替换 {}
template<typename T, typename... Rest>
void print(std::string_view fmt, T const& first, Rest const&... rest) {
auto result = replace_first(fmt, first);
print(std::string_view(result), rest...);
}
int main() {
std::string name = "张三";
int age = 25;
double score = 95.5;
print("姓名: {}, 年龄: {}, 分数: {}", name, age, score);
// 输出:姓名: 张三, 年龄: 25, 分数: 95.5
}
7.2 Tuple-like make 函数
#include <tuple>
#include <utility>
#include <iostream>
// 完美转发所有参数到 tuple
template<typename... Args>
auto make_stuff(Args&&... args) {
return std::tuple{std::forward<Args>(args)...};
}
// 使用 C++17 结构化绑定解包
int main() {
auto [name, age, score] = make_stuff("Alice", 30, 99.5);
std::cout << name << " is " << age
<< " years old, score: " << score << '\n';
}
7.3 可变参数 max/min
#include <type_traits>
// 两个参数的基础版本
template<typename T>
constexpr T max_of(T a, T b) {
return a > b ? a : b;
}
// 可变参数版本:折叠无法直接用于自定义二元函数
// 使用 if constexpr + 递归
template<typename T, typename... Rest>
constexpr auto max_of(T first, Rest... rest) {
if constexpr (sizeof...(rest) == 0) {
return first;
} else {
auto rest_max = max_of(rest...);
using Common = std::common_type_t<T, decltype(rest_max)>;
return static_cast<Common>(first) > static_cast<Common>(rest_max)
? static_cast<Common>(first)
: static_cast<Common>(rest_max);
}
}
// 编译期求值
static_assert(max_of(3, 1, 4, 1, 5, 9, 2, 6) == 9);
static_assert(max_of(1.5, 2.7, 0.3) == 2.7);
7.4 事件分发器(多继承 + 折叠)
#include <iostream>
// 多个 handler 的聚合
template<typename... Handlers>
struct Dispatcher : Handlers... {
using Handlers::operator()...; // C++17 using 展开
};
// CTAD 推导指引
template<typename... Handlers>
Dispatcher(Handlers...) -> Dispatcher<Handlers...>;
int main() {
auto dispatch = Dispatcher{
[](int i) { std::cout << "int: " << i << '\n'; },
[](double d) { std::cout << "double: " << d << '\n'; },
[](auto s) { std::cout << "other: " << s << '\n'; }
};
dispatch(42); // int: 42
dispatch(3.14); // double: 3.14
dispatch("hello"); // other: hello
}
常见错误:
- 忘记省略号位置:
args...(展开)vs...args(声明)是不同的。 - 一元折叠空包:除
&&、||、逗号外,空包折叠是编译错误。务必使用二元折叠或static_assert保证非空。 - 递归无终止:忘记写基准情况会导致无限递归实例化。
- 展开位置错误:
f(args)...表示展开为多个f(arg)调用,而f(args...)是将所有参数传入一次调用。
本章小结
template<typename... Ts>声明类型参数包,template<auto... Vs>声明非类型参数包。sizeof...(pack)在编译期获取包大小,可用于static_assert和if constexpr。- C++11 风格:递归 + 基准情况展开参数包。C++17 风格:折叠表达式一行搞定。
- 四种折叠形式:一元左/右折叠、二元左/右折叠。省略号方向决定结合方向。
- 实用模式:求和、逻辑判断、批量操作(push_back)、带分隔符输出。
if constexpr+sizeof...取代基准重载,让递归代码更简洁。- 多继承 +
using...展开实现 overloaded lambda 分发器。