当std::variant所有模板类型均继承自同一基类时的多态实现与类型转换问题

首先得明确你现在遇到的几个核心痛点：手动强制转换的未定义行为（UB）、想绕过std::visit的静态基类访问，还有怎么基于基类成员实现std::set的排序。我来一步步给你拆解：

一、手动reinterpret_cast的UB风险 #

你当前代码里用reinterpret_cast直接把std::get<A>(v)的地址转成Base*，这绝对是未定义行为，主要有两个原因：

• C++标准完全没规定std::variant的内部存储布局，你不能想当然认为派生类对象的起始地址和variant的存储区域完全对齐——不同编译器、不同优化级别下，内存安排可能天差地别。
• 就算当前variant确实持有A类型，这种强制转换也违反了C++的类型别名规则，编译器可能因此生成逻辑错误的代码，后续排查起来会非常头疼。

而且这种方式根本没法处理variant持有其他类型（比如B）的情况，一旦类型不匹配要么抛异常要么直接崩溃，完全不可靠。

二、不依赖std::visit的静态基类访问？其实很难绕开 #

你提到不想用std::visit，觉得它是动态分发，但实际上在处理有限数量的variant类型时，编译器通常会把std::visit优化成编译期的分支判断，而非真正的动态虚函数调用，性能开销几乎可以忽略不计。

如果真的铁了心要完全避免运行时的类型判断，其实没有标准合规的办法——因为std::variant的实际类型是在运行时确定的，你总得有某种方式匹配当前持有的类型，才能安全转换到基类。不过我们可以用一些编译期技巧封装这个过程，让代码看起来更干净：

方法1：用辅助函数封装类型安全的基类转换 #

我们可以写个模板函数，利用std::holds_alternative和std::get来安全获取基类引用，把繁琐的判断逻辑藏起来：

#include <variant>
#include <string>
#include <stdexcept>

struct Base { int i; };
struct A : public Base { int j; };
struct B : public Base { std::string k; };

template <typename... Ts>
Base& get_base(std::variant<Ts...>& var) {
    auto visitor = [](auto& obj) -> Base& { return obj; };
    return std::visit(visitor, var);
}

template <typename... Ts>
const Base& get_base(const std::variant<Ts...>& var) {
    auto visitor = [](const auto& obj) -> const Base& { return obj; };
    return std::visit(visitor, var);
}

int main() {
    std::variant<A, B> v(A{{1}, 2});
    Base& b = get_base(v); // 安全拿到基类引用
    v = B{{3}, "hello"};
    Base& b2 = get_base(v); // 换类型也一样安全
}

这个方法本质还是用了std::visit，但封装后代码简洁很多，而且编译器会帮你优化掉不必要的开销。

方法2：用编译期折叠表达式生成转换逻辑 #

如果你真的想手动实现编译期分支，可以用C++17的折叠表达式遍历所有可能的类型：

template <typename... Ts>
Base& get_base(std::variant<Ts...>& var) {
    bool found = false;
    Base* result = nullptr;
    // 折叠表达式遍历variant的所有类型，逐一判断
    (void)(std::holds_alternative<Ts>(var) && 
           (result = &std::get<Ts>(var), found = true, true) || ...);
    if (!found) {
        throw std::bad_variant_access{};
    }
    return *result;
}

这个方法没用到std::visit，而是手动生成了所有类型的判断逻辑，但它和std::visit的性能几乎没区别，而且代码更冗长，其实不如直接用std::visit省心。

三、实现std::set的排序逻辑 #

要让std::set<std::variant<A,B>>基于Base::i排序，只需要给std::set传一个自定义比较器，用上我们刚才写的get_base函数就行：

struct VariantBaseComparator {
    bool operator()(const std::variant<A,B>& lhs, const std::variant<A,B>& rhs) const {
        return get_base(lhs).i < get_base(rhs).i;
    }
};

int main() {
    std::set<std::variant<A,B>, VariantBaseComparator> my_set;
    my_set.insert(A{{5}, 10});
    my_set.insert(B{{3}, "test"});
    my_set.insert(A{{7}, 20});
    // 此时set会按Base::i从小到大排序：3、5、7
}

这个比较器能安全地从每个variant中拿到Base引用，然后比较i的值，完全符合你的需求。

总结 #

• 绝对不要用手动强制转换来获取variant中的基类引用，这是UB，而且后期维护风险极大。
• std::visit并没有你想象的那么“动态”，编译器会做大量优化，是处理variant类型转换的标准、安全方式。
• 基于基类成员实现std::set排序的核心就是安全获取基类引用，再在比较器中用这个引用的成员做判断。

内容来源于stack exchange