C++联合体使用注意事项与最佳实践

std::string

std::variant

union

struct

// 使用结构体，占用 sizeof(Point3D) 内存
struct Point2D { float x, y; };
struct Point3D { float x, y, z; };

struct DataWithStruct {
    Point2D p2d;
    Point3D p3d; // 即使不使用，也占着内存
    bool is3D;
};

// 使用联合体，占用 sizeof(Point3D) 内存
union DataWithUnion {
    Point2D p2d;
    Point3D p3d;
};

struct MyPoint {
    DataWithUnion data;
    bool is3D; // 判别式
};

// 内存占用对比
// sizeof(DataWithStruct) 通常是 2*sizeof(float) + 3*sizeof(float) + sizeof(bool)
// sizeof(MyPoint) 则是 max(sizeof(Point2D), sizeof(Point3D)) + sizeof(bool)

MyPoint

std::string

std::vector

#include <string>
#include <iostream>
#include <new> // For placement new

enum class DataType {
    None,
    Int,
    String
};

class MyVariant {
private:
    DataType type_ = DataType::None;
    union {
        int i_val;
        std::string s_val; // 非POD类型
    };

public:
    MyVariant() : type_(DataType::None) {}

    // 构造函数，支持int
    MyVariant(int val) : type_(DataType::Int), i_val(val) {}

    // 构造函数，支持string
    MyVariant(const std::string& val) : type_(DataType::String) {
        // 使用placement new在s_val的内存位置构造std::string
        new (&s_val) std::string(val);
    }

    // 拷贝构造函数
    MyVariant(const MyVariant& other) : type_(other.type_) {
        switch (type_) {
            case DataType::Int:
                i_val = other.i_val;
                break;
            case DataType::String:
                new (&s_val) std::string(other.s_val);
                break;
            default:
                break;
        }
    }

    // 析构函数：必须手动析构活跃的非POD成员
    ~MyVariant() {
        if (type_ == DataType::String) {
            s_val.~basic_string(); // 显式调用std::string的析构函数
        }
    }

    // 赋值运算符重载（简化版，仅作示例）
    MyVariant& operator=(const MyVariant& other) {
        if (this == &other) return *this;

        // 1. 析构当前活跃成员（如果是非POD）
        if (type_ == DataType::String) {
            s_val.~basic_string();
        }

        // 2. 拷贝新的类型和值
        type_ = other.type_;
        switch (type_) {
            case DataType::Int:
                i_val = other.i_val;
                break;
            case DataType::String:
                new (&s_val) std::string(other.s_val); // 构造新的非POD成员
                break;
            default:
                break;
        }
        return *this;
    }

    // Getter方法
    int get_int() const {
        if (type_ == DataType::Int) return i_val;
        throw std::bad_cast();
    }

    const std::string& get_string() const {
        if (type_ == DataType::String) return s_val;
        throw std::bad_cast();
    }
};

// 使用示例
// MyVariant v_int(10);
// MyVariant v_str("hello union");
// MyVariant v_copy = v_str;

std::variant

std::variant

std::variant

std::variant

std::variant

MyVariant

#include <string>
#include <iostream>
#include <variant> // C++17

// 使用std::variant，不再需要手动管理判别式和生命周期
using MySafeVariant = std::variant<int, std::string>;

// 使用示例
void process_variant(const MySafeVariant& v) {
    // 方式一：使用std::get_if安全访问
    if (const int* p_int = std::get_if<int>(&v)) {
        std::cout << "It's an int: " << *p_int << std::endl;
    } else if (const std::string* p_str = std::get_if<std::string>(&v)) {
        std::cout << "It's a string: " << *p_str << std::endl;
    } else {
        std::cout << "Unknown type." << std::endl;
    }

    // 方式二：使用std::visit访问者模式
    std::visit([](auto&& arg){
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, int>) {
            std::cout << "Visited int: " << arg << std::endl;
        } else if constexpr (std::is_same_v<T, std::string>) {
            std::cout << "Visited string: " << arg << std::endl;
        }
    }, v);
}

// int main() {
//     MySafeVariant v1 = 100;
//     process_variant(v1); // 输出：It's an int: 100, Visited int: 100

//     v1 = "Hello, std::variant!"; // 自动析构旧的int，构造新的string
//     process_variant(v1); // 输出：It's a string: Hello, std::variant!, Visited string: Hello, std::variant!

//     try {
//         std::string s = std::get<int>(v1); // 尝试获取错误的类型，会抛出异常
//     } catch (const std::bad_variant_access& e) {
//         std::cerr << "Error: " << e.what() << std::endl; // 输出错误信息
//     }
//     return 0;
// }

std::variant

std::variant