C++联合体类型转换 安全类型转换方法

#include <iostream>
#include <string>
#include <variant> // 提前引入，后面会用到

// 1. 传统C风格的安全联合体封装
struct MyVariantOldSchool {
    enum Type {
        INT,
        FLOAT,
        STRING
    } activeType; // 标记当前活跃的类型

    union Data {
        int i;
        float f;
        std::string s; // 注意：联合体成员不能有非平凡的构造函数/析构函数/赋值运算符
                       // 所以这里用std::string会引发问题，需要手动管理内存和生命周期
                       // 为了演示，暂时假设我们处理POD类型或手动管理
        Data() {} // 联合体需要一个默认构造函数
        ~Data() {} // 联合体需要一个默认析构函数
    } data;

    // 构造函数，初始化为某种类型
    MyVariantOldSchool() : activeType(INT) { data.i = 0; } // 默认初始化
    ~MyVariantOldSchool() {
        // 如果data.s是活跃的，需要手动调用析构函数
        if (activeType == STRING) {
            data.s.~basic_string();
        }
    }

    // 设置值的方法
    void setInt(int val) {
        if (activeType == STRING) data.s.~basic_string(); // 如果之前是string，先析构
        data.i = val;
        activeType = INT;
    }

    void setFloat(float val) {
        if (activeType == STRING) data.s.~basic_string(); // 如果之前是string，先析构
        data.f = val;
        activeType = FLOAT;
    }

    void setString(const std::string& val) {
        if (activeType == STRING) {
            data.s = val; // 如果之前是string，直接赋值
        } else {
            new (&data.s) std::string(val); // 否则，在联合体内存中构造新的string
        }
        activeType = STRING;
    }

    // 获取值的方法（需要类型检查）
    int getInt() const {
        if (activeType == INT) return data.i;
        throw std::bad_cast(); // 类型不匹配时抛出异常
    }

    float getFloat() const {
        if (activeType == FLOAT) return data.f;
        throw std::bad_cast();
    }

    const std::string& getString() const {
        if (activeType == STRING) return data.s;
        throw std::bad_cast();
    }
};

// 2. C++17 std::variant 的解决方案 (推荐)
// std::variant 是一个类型安全的联合体，它会自动管理内存和类型追踪
using MyVariantModern = std::variant<int, float, std::string>;

// 3. 辅助函数 for std::variant 访问
struct Visitor {
    void operator()(int i) const {
        std::cout << "It's an int: " << i << std::endl;
    }
    void operator()(float f) const {
        std::cout << "It's a float: " << f << std::endl;
    }
    void operator()(const std::string& s) const {
        std::cout << "It's a string: " << s << std::endl;
    }
};

// 实际使用示例
int main() {
    std::cout << "--- Old School Union ---" << std::endl;
    MyVariantOldSchool oldVar;
    oldVar.setInt(10);
    std::cout << "Current type: " << oldVar.activeType << ", Value: " << oldVar.getInt() << std::endl;

    oldVar.setFloat(3.14f);
    std::cout << "Current type: " << oldVar.activeType << ", Value: " << oldVar.getFloat() << std::endl;

    oldVar.setString("Hello Union!");
    std::cout << "Current type: " << oldVar.activeType << ", Value: " << oldVar.getString() << std::endl;

    try {
        // 尝试获取错误类型
        std::cout << "Trying to get int: " << oldVar.getInt() << std::endl;
    } catch (const std::bad_cast& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }


    std::cout << "\n--- Modern std::variant ---" << std::endl;
    MyVariantModern modernVar; // 默认初始化为第一个类型 (int)
    std::cout << "Index: " << modernVar.index() << ", Value: " << std::get<int>(modernVar) << std::endl;

    modernVar = 20.5f;
    std::cout << "Index: " << modernVar.index() << ", Value: " << std::get<float>(modernVar) << std::endl;

    modernVar = std::string("Hello std::variant!");
    std::cout << "Index: " << modernVar.index() << ", Value: " << std::get<std::string>(modernVar) << std::endl;

    // 使用 std::visit 访问
    std::visit(Visitor{}, modernVar);

    try {
        // 尝试获取错误类型
        std::cout << "Trying to get int: " << std::get<int>(modernVar) << std::endl;
    } catch (const std::bad_variant_access& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}

union Data { int i; float f; }

i

10

10

f

std::variant

std::variant

activeType

std::get<T>(myVariant)

T

std::bad_variant_access

std::variant

std::string

std::variant

std::variant

std::variant

std::variant

std::visit

std::variant

if-else if

switch

std::variant

std::variant

std::variant

std::variant

std::visit

union

enum

std::string