C++联合体(union)深度解析与使用指南-CSDN博客

C++联合体(union)深度解析与使用指南

什么是联合体(union)

联合体(union)是C++中一种特殊的数据结构，它允许在相同的内存位置存储不同的数据类型。联合体的所有成员共享同一块内存空间，这意味着在任何时候，联合体只能存储其中一个成员的值。联合体的大小由其最大成员决定。

联合体的基本语法

联合体的声明语法如下：

union 联合体名称 {
    成员类型1 成员名1;
    成员类型2 成员名2;
    // 更多成员...
};

例如，我们可以定义一个简单的联合体：

union Data {
    int i;
    float f;
    char str[20];
};

联合体的内存布局

联合体的所有成员共享同一块内存空间。假设我们有以下联合体：

union NumericType {
    short iValue;
    long lValue;
    double dValue;
};

其内存布局可以这样理解：

整个联合体占用8字节空间（由最大的double类型决定）
short类型的iValue占用前2字节
long类型的lValue占用前4字节
double类型的dValue占用全部8字节

联合体的初始化

联合体可以在声明时直接初始化：

union NumericType values = {10};  // 初始化第一个成员iValue

注意：只能初始化第一个成员，后续如果需要使用其他成员，需要单独赋值。

联合体的使用场景

联合体主要用于以下场景：

内存优化：当需要存储多种类型数据但不会同时使用时，可以节省内存空间
类型转换：通过联合体可以实现不同类型数据的二进制层面转换
硬件寄存器访问：在嵌入式开发中，常用于访问同一寄存器的不同位域

匿名联合体

C++支持匿名联合体，它没有名称，成员可以直接访问：

struct Variant {
    enum Type { INT, FLOAT, STRING } type;
    union {
        int i;
        float f;
        char str[20];
    };  // 匿名联合体
};

// 使用
Variant v;
v.type = Variant::INT;
v.i = 10;  // 直接访问匿名联合体成员

C++11中的无限制联合体

在C++11之前，联合体成员不能有非平凡的构造函数、析构函数或赋值运算符。C++11放宽了这一限制：

union ComplexUnion {
    std::string str;  // C++11允许，因为string有非平凡构造函数
    int i;
};

但需要注意，使用这种联合体时需要手动管理对象的构造和析构。

联合体的注意事项

类型安全：访问联合体时需要确保当前存储的是正确的成员类型
生命周期管理：对于有非平凡构造函数的成员，需要显式构造和析构
替代方案：C++17引入的std::variant是更安全的替代方案

联合体与结构体的区别

| 特性 | 联合体(union) | 结构体(struct) | |------------|--------------|---------------| | 内存使用 | 成员共享内存 | 成员独立内存 | | 同时存储 | 只能存一个成员 | 可存所有成员 | | 大小 | 等于最大成员 | 大于等于各成员和 |

实际应用示例：鉴别联合体

一种常见的联合体使用模式是"鉴别联合体"，它结合枚举类型来跟踪当前存储的类型：

struct TaggedUnion {
    enum { INT, FLOAT, CHAR } tag;
    union {
        int i;
        float f;
        char c;
    };
};

void process(TaggedUnion tu) {
    switch(tu.tag) {
        case TaggedUnion::INT:
            cout << "Integer: " << tu.i << endl;
            break;
        case TaggedUnion::FLOAT:
            cout << "Float: " << tu.f << endl;
            break;
        case TaggedUnion::CHAR:
            cout << "Char: " << tu.c << endl;
            break;
    }
}

联合体的高级用法

对于复杂的联合体使用，可以封装成类来提供更好的安全性：

class SafeUnion {
public:
    enum Type { INT, DOUBLE };
    
    SafeUnion(int val) : type_(INT) { data_.i = val; }
    SafeUnion(double val) : type_(DOUBLE) { data_.d = val; }
    
    int getInt() const {
        if(type_ != INT) throw std::runtime_error("Not an int");
        return data_.i;
    }
    
    double getDouble() const {
        if(type_ != DOUBLE) throw std::runtime_error("Not a double");
        return data_.d;
    }

private:
    Type type_;
    union {
        int i;
        double d;
    } data_;
};