如何将N个类型的参数包折叠为N-1个std::pair构成的std::tuple？

我明白你想要实现的是把一个包含N个不同类型的参数包，转换成一个由N-1个连续相邻类型组成的std::pair的std::tuple——也就是从T0, T1, T2, ..., Tn-1得到std::tuple<std::pair<T0,T1>, std::pair<T1,T2>, ..., std::pair<Tn-2,Tn-1>>对吧？你的当前实现可能是把每个元素和自己配对了，这确实不是你要的效果。下面给你两个C++17风格的解决方案，都能满足你的需求：

方法1：利用折叠表达式和std::tuple索引特性 #

这种方法先把参数包转成临时tuple，再通过编译期索引取相邻元素构造pair，最后组合成目标tuple，代码简洁且符合C++17的现代化风格。

#include <tuple>
#include <utility>

// 辅助模板：生成编译期索引并构造配对tuple
template <typename... Ts>
struct ResolveToTupleOfPairsHelper {
    static constexpr auto param_count = sizeof...(Ts);
    // 生成0到param_count-2的索引序列（对应N-1个配对）
    using index_seq = std::make_index_sequence<param_count - 1>;

    template <std::size_t... Is>
    static auto build_tuple(std::index_sequence<Is...>) {
        return std::make_tuple(
            std::pair<
                std::tuple_element_t<Is, std::tuple<Ts...>>,
                std::tuple_element_t<Is + 1, std::tuple<Ts...>>
            >{}...
        );
    }

    // 推导最终的tuple类型
    using type = decltype(build_tuple(index_seq{}));
};

// 对外暴露的别名模板，简化使用
template <typename... Ts>
using ResolveToTupleOfPairs = typename ResolveToTupleOfPairsHelper<Ts...>::type;

代码说明 #

• param_count计算参数包的总类型数，我们需要生成param_count-1个相邻配对；
• index_seq生成编译期索引序列，覆盖所有需要配对的相邻位置；
• build_tuple用折叠表达式遍历索引，为每个索引Is构造<Ts[Is], Ts[Is+1]>的pair，最终组合成tuple；
• ResolveToTupleOfPairs作为对外的简洁接口，直接引用辅助模板推导的类型。

方法2：递归模板拼接tuple #

如果不想依赖tuple的索引特性，也可以用递归的方式逐步传递前一个类型，拼接相邻pair的tuple：

#include <tuple>
#include <utility>

// 递归终止条件：参数包只剩1个类型时，返回空tuple（无配对可生成）
template <typename T>
struct ResolveToTupleOfPairsHelper {
    using type = std::tuple<>;
};

// 递归逻辑：取前两个类型构造pair，再和剩余类型的配对结果拼接
template <typename T, typename U, typename... Ts>
struct ResolveToTupleOfPairsHelper<T, U, Ts...> {
    using type = decltype(
        std::tuple_cat(
            std::make_tuple(std::pair<T, U>{}),
            std::declval<typename ResolveToTupleOfPairsHelper<U, Ts...>::type>()
        )
    );
};

// 对外暴露的别名模板
template <typename... Ts>
using ResolveToTupleOfPairs = typename ResolveToTupleOfPairsHelper<Ts...>::type;

代码说明 #

• 终止条件：当参数包只有单个类型时，返回空tuple，因为没有相邻元素可以配对；
• 递归步骤：对于T, U, Ts...，先构造<T,U>的tuple，再和递归处理U, Ts...得到的配对tuple拼接，逐步生成完整的结果。

验证测试 #

可以写一段编译期断言来验证类型转换是否符合预期：

#include <type_traits>

int main() {
    // 测试：int, double, std::string 三个类型的参数包
    using TargetType = ResolveToTupleOfPairs<int, double, std::string>;
    // 期望得到的类型是两个相邻pair组成的tuple
    static_assert(std::is_same_v<
        TargetType,
        std::tuple<std::pair<int, double>, std::pair<double, std::string>>
    >);
    return 0;
}

这段代码会正常编译通过，说明类型转换完全符合需求。

注意事项 #

• 如果参数包的类型数小于2（0个或1个类型），ResolveToTupleOfPairs会返回空tuple，这是合理的边界处理；
• 两种方法都完全基于C++17标准，不需要依赖更高版本的特性。

内容的提问来源于stack exchange，提问作者nyronium