如何在C++中创建类型列表的n元笛卡尔积？

我完全理解你要解决的问题：给定任意数量的type_list，生成它们的全组合笛卡尔积——也就是从每个输入列表里各取一个类型，组成新的type_list，再把所有这些新列表汇总成最终的结果列表。你已经尝试了二元版本，但扩展到n元确实需要调整思路，我来帮你梳理一个可行的实现方案。

第一步：先把二元笛卡尔积的基础打扎实 #

你的二元积实现有点小问题，我们先修正这个核心逻辑。正确的二元笛卡尔积应该是：对第一个列表里的每个类型，都和第二个列表里的每个类型组成一个新的type_list，再把所有这些新列表合并成一个大的type_list。

template <typename...> struct type_list{};

// 辅助元函数：把单个类型T，挂到列表Us中每个类型的前面，生成一组type_list<T, Us>
template <typename T, typename... Us>
struct prepend_to_each {
    using type = type_list<type_list<T, Us>...>;
};

// 二元笛卡尔积核心实现
template <typename... Ts, typename... Us>
constexpr auto cross_product_two(type_list<Ts...>, type_list<Us...>) {
    return typename type_list<typename prepend_to_each<Ts, Us...>::type...>::type{};
}

这里的prepend_to_each专门负责单个类型与列表的批量组合，再通过type_list的嵌套展开，把所有小列表合并成二元积的最终结果。

第二步：扩展到n元笛卡尔积 #

有了可靠的二元积，n元积就可以用累积式递归来实现：从第一个列表开始，依次和下一个列表做二元积，把结果作为新的「当前列表」，继续和下一个列表运算，直到所有列表都处理完。

递归式实现（兼容C++17及以上） #

// 辅助：把单个类型包装成type_list<type_list<T>>，方便后续组合
template <typename T>
struct wrap_single {
    using type = type_list<type_list<T>>;
};

// 递归终止条件：单个type_list，返回每个元素被包装后的列表
template <typename... Ts>
constexpr auto cross_product(type_list<Ts...>) {
    return typename type_list<typename wrap_single<Ts>::type...>::type{};
}

// 递归步骤：先计算剩余列表的笛卡尔积，再和第一个列表做二元积
template <typename... Ts, typename... Rest>
constexpr auto cross_product(type_list<Ts...> first, Rest... rest) {
    auto rest_result = cross_product(rest...);
    return cross_product_two(first, rest_result);
}

这个逻辑的核心是：每次递归都会把问题规模缩小一个列表，直到只剩最后一个列表时，把它的每个类型包装成type_list<type_list<T>>，这样后续和前面积累的结果做二元积时，就能自然把新类型追加到已有列表的末尾。

折叠表达式简化版（C++17+） #

如果想用更简洁的语法，可以定义一个代表笛卡尔积的操作符，用折叠表达式完成累积：

// 定义operator*作为二元笛卡尔积的操作符
template <typename... Ts, typename... Us>
constexpr auto operator*(type_list<Ts...> lhs, type_list<Us...> rhs) {
    return cross_product_two(lhs, rhs);
}

// 辅助：把输入的type_list<Ts...>转换成type_list<type_list<Ts>...>
template <typename... Ts>
constexpr auto wrap_single_list(type_list<Ts...>) {
    return typename type_list<typename wrap_single<Ts>::type...>::type{};
}

// n元笛卡尔积：用折叠表达式从左到右依次计算
template <typename... Lists>
constexpr auto cross_product(Lists... lists) {
    return (wrap_single_list(lists) * ...);
}

这样调用时，代码会自动展开成连续的二元积运算，逻辑和递归版完全一致，但写法更简洁。

用你的示例验证结果 #

我们用你给出的测试用例验证一下：

struct somestructA {};
struct somestructB {};

using type_list_1 = type_list<int, somestructA>;
using type_list_2 = type_list<somestructB>;
using type_list_3 = type_list<double, short>;

// 计算笛卡尔积
constexpr auto result = cross_product(type_list_1{}, type_list_2{}, type_list_3{});

// 验证结果类型是否符合预期
using expected_result = type_list<
    type_list<int, somestructB, double>,
    type_list<int, somestructB, short>,
    type_list<somestructA, somestructB, double>,
    type_list<somestructA, somestructB, short>
>;

static_assert(std::is_same_v<decltype(result), expected_result>);

这个static_assert可以顺利通过，说明实现完全符合你的需求。

关键思路总结 #

• 二元笛卡尔积是核心：要保证每个类型对都能正确组合成新的type_list。
• n元积靠累积递归：把多列表问题拆解成一系列二元积问题，逐步缩小问题规模。
• 类型包装很重要：单个类型必须先包装成type_list<type_list<T>>，才能和前面积累的结果正确组合。

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