如何合并两个std::variant？C++变体类型合并方法问询

C++标准库本身并没有提供直接合并std::variant类型的工具，但可以通过模板元编程实现你想要的功能，把多个std::variant的所有类型合并成一个新的std::variant。

实现步骤 #

我们可以拆解为三个核心步骤：提取单个std::variant的类型列表、合并多个类型列表、将合并后的列表转换回std::variant。

1. 提取std::variant的类型参数包

首先定义一个辅助模板，用来获取任意std::variant内部的类型集合（以std::tuple形式存储）：

#include <variant>
#include <tuple>
#include <type_traits>

template <typename Variant>
struct variant_types;

// 特化处理std::variant，提取其类型参数到tuple
template <typename... Ts>
struct variant_types<std::variant<Ts...>> {
    using type = std::tuple<Ts...>;
};

// 简化类型别名
template <typename Variant>
using variant_types_t = typename variant_types<Variant>::type;

2. 合并多个类型列表（tuple）

接下来实现合并多个std::tuple的模板，把它们的类型参数合并成一个大的tuple：

template <typename... Tuples>
struct merge_tuples;

// 递归合并多个tuple
template <typename... Ts, typename... Us, typename... Rest>
struct merge_tuples<std::tuple<Ts...>, std::tuple<Us...>, Rest...> {
    using type = typename merge_tuples<std::tuple<Ts..., Us...>, Rest...>::type;
};

// 递归终止条件：单个tuple
template <typename... Ts>
struct merge_tuples<std::tuple<Ts...>> {
    using type = std::tuple<Ts...>;
};

// 简化类型别名
template <typename... Tuples>
using merge_tuples_t = typename merge_tuples<Tuples...>::type;

3. 将合并后的tuple转换为std::variant

最后把合并后的tuple类型转换回std::variant：

template <typename Tuple>
struct tuple_to_variant;

// 特化处理tuple，将其类型参数转为std::variant
template <typename... Ts>
struct tuple_to_variant<std::tuple<Ts...>> {
    using type = std::variant<Ts...>;
};

// 简化类型别名
template <typename Tuple>
using tuple_to_variant_t = typename tuple_to_variant<Tuple>::type;

4. 组合所有模板，实现合并功能

把上面的模板组合起来，定义一个merge_variants别名，直接实现多个std::variant的合并：

template <typename... Variants>
using merge_variants = tuple_to_variant_t<merge_tuples_t<variant_types_t<Variants>...>>;

测试示例 #

用你提供的代码测试：

using Var1 = std::variant<int, bool>;
using Var2 = std::variant<float, double>;

// 合并两个variant
using MergedVariant = merge_variants<Var1, Var2>;
// 等价于 std::variant<int, bool, float, double>

可选：合并时自动去重 #

如果你的多个std::variant存在重复类型，可以额外添加类型去重的逻辑，确保合并后的variant中每种类型只出现一次：

// 类型去重的辅助模板
template <typename... Ts>
struct unique_types;

template <typename T, typename... Ts>
struct unique_types<T, Ts...> {
    using type = std::conditional_t<
        // 检查T是否在Ts中存在
        (std::is_same_v<T, Ts> || ...),
        // 存在则跳过，继续处理剩余类型
        typename unique_types<Ts...>::type,
        // 不存在则将T加入结果
        decltype(std::tuple_cat(std::tuple<T>(), typename unique_types<Ts...>::type()))
    >;
};

// 递归终止条件：空类型列表
template <>
struct unique_types<> {
    using type = std::tuple<>;
};

template <typename... Ts>
using unique_types_t = typename unique_types<Ts...>::type;

// 带去重的合并版本
template <typename... Variants>
using merge_variants_unique = tuple_to_variant_t<unique_types_t<merge_tuples_t<variant_types_t<Variants>...>>>;

比如如果有重复类型：

using Var1 = std::variant<int, bool>;
using Var2 = std::variant<int, double>;

// 合并后只保留一个int
using MergedUnique = merge_variants_unique<Var1, Var2>;
// 等价于 std::variant<int, bool, double>

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