C++模板包展开 多重参数包处理技巧

...

std::index_sequence

func(pack1..., pack2...)

func(arg1s + arg2s...)

...

std::cout << args << ...

args

std::cout << arg

std::cout << args1 << args2 << ...

...

args1

args2

args1

args2

std::index_sequence

std::make_index_sequence

std::get<Index>(std::forward<PackType>(pack))

#include <iostream>
#include <utility> // for std::index_sequence, std::make_index_sequence

// 辅助函数，实际处理每个索引对应的元素
template<typename T1, typename T2, std::size_t Index>
void process_elements(T1&& val1, T2&& val2) {
    std::cout << "Index " << Index << ": (" << val1 << ", " << val2 << ")\n";
}

// 主函数，利用index_sequence展开
template<typename... Args1, typename... Args2, std::size_t... Is>
void print_paired_packs_impl(const std::tuple<Args1...>& t1, const std::tuple<Args2...>& t2, std::index_sequence<Is...>) {
    // 这里的 (void) 是为了避免未使用的变量警告，同时触发展开
    (process_elements<Args1, Args2, Is>(std::get<Is>(t1), std::get<Is>(t2)), ...);
}

template<typename... Args1, typename... Args2>
void print_paired_packs(Args1&&... args1, Args2&&... args2) {
    // 先把参数包转换成tuple，方便通过索引访问
    auto t1 = std::make_tuple(std::forward<Args1>(args1)...);
    auto t2 = std::make_tuple(std::forward<Args2>(args2)...);

    // 确保两个包的长度一致，或者根据最短的包来生成索引序列
    constexpr std::size_t common_size = (sizeof...(Args1) < sizeof...(Args2)) ? sizeof...(Args1) : sizeof...(Args2);

    print_paired_packs_impl(t1, t2, std::make_index_sequence<common_size>{});
}

// 调用示例
// int main() {
//     print_paired_packs(1, 2, 3, "hello", 5.0);
//     print_paired_packs(10, "world", 30.0); // 编译错误，这里需要两个包
//     print_paired_packs(1, 2, 3, "hello", 5.0, 6);
//     print_paired_packs(10, "world", 30.0, 'c', true, 100);
//     return 0;
// }

print_paired_packs

(args + ...)

(std::cout << args << ...)

(args1 + args2 + ...)

args1

args2

args1

args2

std::pair

std::tuple

#include <iostream>
#include <utility> // For std::pair

// 假设我们有一个辅助函数，可以创建一对参数
template<typename T1, typename T2>
auto make_pair_from_args(T1&& arg1, T2&& arg2) {
    return std::make_pair(std::forward<T1>(arg1), std::forward<T2>(arg2));
}

// 利用index_sequence和折叠表达式组合两个包
template<typename... Args1, typename... Args2, std::size_t... Is>
void process_paired_packs_with_fold_impl(std::index_sequence<Is...>, Args1&&... args1, Args2&&... args2) {
    // 创建一个包含pair的临时包，然后对这个包进行折叠
    // 这里我们假设可以从参数包中通过索引获取元素，但这需要更复杂的辅助结构
    // 更实际的做法是，先将参数包转换为tuple，再用index_sequence访问
    // 为了演示折叠表达式，我们简化一下，假设已经有了pair的序列

    // 这种直接展开是错误的：
    // (std::cout << make_pair_from_args(args1, args2) << ...); // 错误，args1和args2不能直接同步展开

    // 正确的做法是结合index_sequence，但折叠表达式在这里的作用是辅助性的，而不是直接同步
    // 比如，如果先将所有配对好的pair放入一个tuple，再对tuple进行折叠（这也不是折叠表达式的典型用法）

    // 让我们换一个更直接的，能体现折叠表达式的例子
    // 假设我们已经通过某种方式，将两个包的对应元素配对成一个`pairs`参数包
    // 比如：`std::pair<T1, T2> p0, std::pair<T1, T2> p1, ...`
    // 然后对这个`pairs`包进行折叠：
    // (std::cout << "Pair:(" << pairs.first << ", " << pairs.second << ")\n", ...); // 这是一个合法的折叠表达式

    // 回到多重参数包的原始问题，折叠表达式的局限在于，它不能直接处理多个独立的参数包。
    // 你仍然需要像`std::index_sequence`那样，通过索引来“同步”地构建一个临时的、可折叠的序列。
    // 例如，我们可以用逗号运算符和折叠表达式来执行一系列操作，但每个操作的参数仍然需要通过索引获取：
    auto printer = [&](auto index_val) {
        // 这里的index_val是索引，通过它来访问原始参数包的元素
        // 这需要一个能捕获原始参数包的lambda，或者一个辅助类
        // 比如，如果我们在一个lambda里捕获了原始的tuple，就可以这样：
        // std::cout << "Index " << index_val << ": (" << std::get<index_val>(t1) << ", " << std::get<index_val>(t2) << ")\n";
    };
    // (printer(Is), ...); // 这种形式的折叠表达式是可行的，但它仍然依赖于index_sequence来提供索引
}

// 总结：折叠表达式本身不能直接同步多个参数包。
// 它可以在你已经通过其他机制（如std::index_sequence）将多重参数包转化为一个可折叠的序列（例如，一个由std::pair组成的参数包，或者一个由函数调用组成的参数包）之后，发挥其简洁性优势。
// 换句话说，折叠表达式是“结果”的处理器，而不是“同步”的协调器。

std::index_sequence

std::index_sequence