C++实现状态机时如何将基类对象赋值给子类组成的std::variant？

当前实现存在两个核心错误：

• 返回base类型值时发生了对象切片：派生类对象赋值给基类值对象时，会裁剪掉所有派生类专属的内容，最终base_obj只是一个纯基类实例，没有任何派生类的类型信息，自然无法转换为存储派生类的std::variant。
• 继承体系和std::variant的使用场景冲突：std::variant是静态多态的实现工具，本身就可以承载多种无继承关系的类型，不需要额外定义公共基类，你对“返回具体类型违背设计初衷”的理解存在偏差。

最优方案是直接将状态更新方法的返回值类型改为std::variant<event_x, event_y>，不需要公共基类，也不会暴露具体返回的事件类型，完全符合状态机的设计逻辑。修改后的示例代码如下：

#include <iostream>
#include <variant>

// 不需要公共基类
class derived_a {};
class derived_b {};

struct Visitor {
    void operator()(const derived_a& a) {
        std::cout << "a here\n";
    }
    void operator()(const derived_b& b) {
        std::cout << "b here\n";
    }
};

// 直接返回variant类型
std::variant<derived_a, derived_b> some_fn() {
    return derived_b{};
}

int main() {
    Visitor visitor{};

    std::variant<derived_a, derived_b> variant = some_fn();
    std::visit(visitor, variant);

    std::cout << "Hello, World!" << std::endl;
    return 0;
}

如果你必须保留公共基类的设计，则需要返回基类的指针（而非值），同时给基类添加虚函数保证运行时类型识别可用，再通过类型判断给variant赋值：

#include <iostream>
#include <variant>
#include <memory>

class base {
public:
    virtual ~base() = default; // 必须有虚函数才能启用RTTI
};
class derived_a : public base {};
class derived_b : public base {};

struct Visitor {
    void operator()(const derived_a& a) {
        std::cout << "a here\n";
    }
    void operator()(const derived_b& b) {
        std::cout << "b here\n";
    }
};

// 返回基类智能指针，避免对象切片
std::unique_ptr<base> some_fn() {
    return std::make_unique<derived_b>();
}

int main() {
    Visitor visitor{};
    std::variant<derived_a, derived_b> variant;

    auto base_ptr = some_fn();
    // 运行时判断实际类型
    if (auto* a = dynamic_cast<derived_a*>(base_ptr.get())) {
        variant = *a;
    } else if (auto* b = dynamic_cast<derived_b*>(base_ptr.get())) {
        variant = *b;
    }

    std::visit(visitor, variant);
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

该方案需要额外的运行时类型判断，性能和安全性都不如直接返回variant的方案，不推荐使用。

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