联合体实现变体类型怎么做 替代C++17的std variant方案

#include <iostream>
#include <string>
#include <cassert> // 用于运行时断言

enum class MyVariantType {
    Int,
    Double,
    String,
    None // 初始状态或无效状态
};

struct MyVariant {
    MyVariantType type;
    union {
        int i_val;
        double d_val;
        std::string s_val; // 非POD类型
    };

    // 默认构造函数
    MyVariant() : type(MyVariantType::None) {}

    // 构造函数重载，用于不同类型
    MyVariant(int val) : type(MyVariantType::Int), i_val(val) {}
    MyVariant(double val) : type(MyVariantType::Double), d_val(val) {}
    MyVariant(const std::string& val) : type(MyVariantType::String) {
        new (&s_val) std::string(val); // placement new 构造字符串
    }
    MyVariant(std::string&& val) : type(MyVariantType::String) {
        new (&s_val) std::string(std::move(val)); // placement new 移动构造字符串
    }

    // 析构函数：手动清理非POD类型
    ~MyVariant() {
        if (type == MyVariantType::String) {
            s_val.~basic_string(); // 手动调用字符串析构函数
        }
    }

    // 拷贝构造函数：深拷贝非POD类型
    MyVariant(const MyVariant& other) : type(other.type) {
        switch (type) {
            case MyVariantType::Int: i_val = other.i_val; break;
            case MyVariantType::Double: d_val = other.d_val; break;
            case MyVariantType::String: new (&s_val) std::string(other.s_val); break;
            case MyVariantType::None: break;
        }
    }

    // 拷贝赋值运算符：处理自我赋值和资源清理
    MyVariant& operator=(const MyVariant& other) {
        if (this == &other) return *this; // 自我赋值检查

        // 先清理当前资源
        if (type == MyVariantType::String) {
            s_val.~basic_string();
        }

        // 再拷贝新资源
        type = other.type;
        switch (type) {
            case MyVariantType::Int: i_val = other.i_val; break;
            case MyVariantType::Double: d_val = other.d_val; break;
            case MyVariantType::String: new (&s_val) std::string(other.s_val); break;
            case MyVariantType::None: break;
        }
        return *this;
    }

    // 移动构造函数
    MyVariant(MyVariant&& other) noexcept : type(other.type) {
        switch (type) {
            case MyVariantType::Int: i_val = other.i_val; break;
            case MyVariantType::Double: d_val = other.d_val; break;
            case MyVariantType::String: new (&s_val) std::string(std::move(other.s_val)); break;
            case MyVariantType::None: break;
        }
        other.type = MyVariantType::None; // 移动后源对象置空
    }

    // 移动赋值运算符
    MyVariant& operator=(MyVariant&& other) noexcept {
        if (this == &other) return *this;

        if (type == MyVariantType::String) { // 清理当前资源
            s_val.~basic_string();
        }

        type = other.type; // 移动新资源
        switch (type) {
            case MyVariantType::Int: i_val = other.i_val; break;
            case MyVariantType::Double: d_val = other.d_val; break;
            case MyVariantType::String: new (&s_val) std::string(std::move(other.s_val)); break;
            case MyVariantType::None: break;
        }
        other.type = MyVariantType::None;
        return *this;
    }

    // 获取值的方法（需要运行时检查）
    int& get_int() { assert(type == MyVariantType::Int); return i_val; }
    double& get_double() { assert(type == MyVariantType::Double); return d_val; }
    std::string& get_string() { assert(type == MyVariantType::String); return s_val; }

    const int& get_int() const { assert(type == MyVariantType::Int); return i_val; }
    const double& get_double() const { assert(type == MyVariantType::Double); return d_val; }
    const std::string& get_string() const { assert(type == MyVariantType::String); return s_val; }

    MyVariantType get_type() const { return type; }
};

// 示例用法
// int main() {
//     MyVariant v1(10);
//     std::cout << "v1 (int): " << v1.get_int() << std::endl;
//
//     MyVariant v2("hello manual variant");
//     std::cout << "v2 (string): " << v2.get_string() << std::endl;
//
//     MyVariant v3 = v2; // 拷贝构造
//     std::cout << "v3 (string, copy of v2): " << v3.get_string() << std::endl;
//
//     MyVariant v4(std::move(v1)); // 移动构造
//     std::cout << "v4 (int, moved from v1): " << v4.get_int() << std::endl;
//     // std::cout << "v1 after move: " << v1.get_int() << std::endl; // v1现在状态不确定，不应访问
//
//     v1 = MyVariant(3.14); // 赋值，原v1如果是非POD会被清理
//     std::cout << "v1 (double after assignment): " << v1.get_double() << std::endl;
//
//     return 0;
// }