模板参数包如何展开 折叠表达式与参数包处理技巧

...

template<typename T>
void print_one(T arg) {
    std::cout << arg << " ";
}

template<typename... Args>
void print_all(Args... args) {
    // 这里的 args... 就是展开操作，它会把参数包里的每个元素逐一传递给 print_one
    (print_one(args), ...); // C++17 折叠表达式简化了这步，否则需要递归或初始化列表
    std::cout << std::endl;
}

// 实际调用时：print_all(1, 2.0, "hello");
// 编译器会展开成：print_one(1); print_one(2.0); print_one("hello");

#include <iostream>

// 递归终止函数：当参数包为空时调用
void print_pack_old_style() {
    // std::cout << "End of pack." << std::endl; // 可以加个标记
}

// 递归处理函数：处理第一个参数，然后递归调用自身处理剩余参数
template<typename T, typename... Args>
void print_pack_old_style(T first_arg, Args... rest_args) {
    std::cout << first_arg << " ";
    print_pack_old_style(rest_args...); // 递归调用，展开剩余参数
}

// 使用示例：
// print_pack_old_style(1, 2.5, "hello", 'X');
// 输出: 1 2.5 hello X

std::initializer_list

#include <iostream>
#include <vector> // 仅为示例，实际不一定需要

template<typename T>
void process_item(T item) {
    std::cout << "Processing: " << item << std::endl;
}

template<typename... Args>
void process_pack_initializer_list(Args... args) {
    // 这里的 (process_item(args), 0)... 会为每个args生成一个表达式，
    // 表达式的值是0，然后这些0被用来初始化一个 std::initializer_list<int>。
    // 重点是 process_item(args) 会被执行。
    int dummy[] = { (process_item(args), 0)... };
    (void)dummy; // 避免未使用变量警告
}

// 使用示例：
// process_pack_initializer_list(10, "test", 3.14);
// 输出:
// Processing: 10
// Processing: test
// Processing: 3.14

+

*

<<

op

template<typename... Args>
auto sum_all(Args... args) {
    return (args + ...); // 一元右折叠，等价于 arg1 + arg2 + ...
}
// std::cout << sum_all(1, 2, 3, 4); // 输出 10

#include <iostream>

template<typename... Args>
void print_pack_fold(Args... args) {
    // 逗号运算符折叠，执行每个表达式的副作用
    // (std::cout << args << " ", ...); // 这样写会多一个空格，但更通用
    // 更常见的写法，利用 << 运算符
    ((std::cout << args << " "), ...); // 注意这里的括号，确保逗号运算符的优先级
    std::cout << std::endl;
}
// print_pack_fold(1, "hello", 3.14); // 输出: 1 hello 3.14

template<typename... Args>
bool all_true(Args... args) {
    return (true && ... && args); // 检查所有参数是否都为真
}
// all_true(true, false, true); // 返回 false

std::forward

#include <utility> // For std::forward

template<typename Func, typename... Args>
decltype(auto) call_and_log(Func&& f, Args&&... args) {
    // 假设我们想在调用前打印所有参数
    ((std::cout << "Arg: " << args << " "), ...);
    std::cout << std::endl;
    // 完美转发参数
    return std::forward<Func>(f)(std::forward<Args>(args)...);
}

// 示例：
// auto result = call_and_log([](int a, double b){ return a + b; }, 10, 20.5);
// 输出:
// Arg: 10 Arg: 20.5
// result = 30.5

std::apply

std::apply

std::apply

constexpr

#include <string>
#include <functional> // For std::hash

template<typename... Args>
constexpr size_t calculate_hash_sum(const Args&... args) {
    // 假设我们有一个可以对所有类型进行哈希的函数
    // 实际应用中，你需要确保 std::hash 对所有 Args 类型都有特化
    return (0ULL + ... + std::hash<Args>{}(args));
}

// 示例：
// constexpr size_t h = calculate_hash_sum(10, "hello", 3.14);
// 这是一个编译期计算