引言

在 C++ 中,我们有时需要让同一块内存在不同时间存储不同类型的数据(例如一个变量既可以是 int 也可以是 float),或者希望精确控制数据的位宽度以节省内存(例如只用一个字节中的几个位表示状态)。共用体(union) 和位域(bit-field) 正是为此而生的低级特性。共用体允许多个成员共享同一块内存,但同一时刻只能有一个成员有效;位域则允许我们指定结构体或共用体成员所占的位数,常用于硬件编程、协议解析或内存受限的场景。
本文将详细介绍共用体的定义、使用场景、注意事项,以及位域的声明和典型应用,并通过内存模型解释它们的底层布局。


1. 共用体(union)

1.1 定义与基本用法

共用体是一种特殊的数据类型,它的所有成员共享同一段内存,大小等于最大成员的大小。同一时刻只能存储其中一个成员的值。

#include <iostream>

union Data {
    int i;
    float f;
    char c;
};

int main() {
    Data d;
    d.i = 42;
    std::cout << "作为 int: " << d.i << std::endl;
    std::cout << "作为 float: " << d.f << std::endl;  // 未定义行为(内存被解释为 float)
    std::cout << "作为 char: " << d.c << std::endl;   // 未定义行为

    d.f = 3.14f;
    std::cout << "现在作为 float: " << d.f << std::endl;

    // 注意:同一时间只能有效使用一个成员
    return 0;
}

关键点:

  • 共用体的大小为最大成员的大小(可能因对齐而更大)。
  • 写入一个成员会覆盖其他成员的数据。
  • 从非活动成员读取是未定义行为(除非是某种类型的重新解释,如 int 和 unsigned int)。

1.2 使用场景

场景1:节省内存(多选一的变量)

例如在网络包解析中,一个字段可能是不同类型,但同一时刻只有一种类型有效。

enum Type { INT, FLOAT, STRING };

struct Variant {
    Type type;
    union {
        int intVal;
        float floatVal;
        char* strVal;
    };
};

void print(const Variant& v) {
    switch (v.type) {
        case INT:    std::cout << v.intVal; break;
        case FLOAT:  std::cout << v.floatVal; break;
        case STRING: std::cout << v.strVal; break;
    }
}
场景2:类型双关(Type Punning)—— 但需谨慎

有时需要将同一块内存以不同类型解释(例如将 float 的二进制表示作为 int 查看)。虽然可以用 reinterpret_cast,但 union 也是一种传统方式(C++ 标准中从非活动成员读取是未定义行为,但许多编译器支持作为扩展)。

union FloatInt {
    float f;
    int i;
};

float f = 3.14f;
FloatInt fi;
fi.f = f;
std::cout << std::hex << fi.i << std::endl;  // 输出浮点数的十六进制表示

注意:现代 C++ 中推荐使用 memcpy 或 std::bit_cast(C++20)来进行类型双关,避免未定义行为。

场景3:访问特定字节

可以使用 union 来拆分一个多字节变量的各个字节(但注意大小端问题)。

union IntBytes {
    int value;
    unsigned char bytes[sizeof(int)];
};

int main() {
    IntBytes ib;
    ib.value = 0x12345678;
    for (int i = 0; i < 4; ++i) {
        std::cout << std::hex << (int)ib.bytes[i] << " ";
    }
    // 输出取决于大小端:小端序输出 78 56 34 12
    return 0;
}

1.3 匿名共用体

在结构体或类中,可以定义没有名称的共用体,其成员被视为外层作用域的成员。

struct Node {
    int type;
    union {
        int intData;
        double doubleData;
        char* stringData;
    };  // 匿名共用体
};

Node n;
n.type = 0;
n.intData = 100;   // 直接访问成员

2. 位域(bit-field)

位域允许在结构体或共用体中指定成员占用的位数,用于紧凑存储多个标志或小范围整数,节省内存。

2.1 定义与基本用法

位域的语法:类型 成员名 : 位数; 其中类型通常是 unsigned int 或 int(也可以是 unsigned char 等,但标准要求整数类型)。

#include <iostream>

struct Flags {
    unsigned int flag1 : 1;   // 1 位,取值 0 或 1
    unsigned int flag2 : 1;
    unsigned int flag3 : 1;
    unsigned int reserved : 5; // 保留 5 位(可能不用)
};

int main() {
    Flags f;
    f.flag1 = 1;
    f.flag2 = 0;
    f.flag3 = 1;
    std::cout << "flag1: " << f.flag1 << std::endl;
    std::cout << "size of Flags: " << sizeof(Flags) << std::endl; // 通常为 4 字节(unsigned int)
    return 0;
}

2.2 使用场景

场景1:硬件寄存器映射

在嵌入式或驱动程序开发中,寄存器通常由多个位字段组成。

struct ControlRegister {
    unsigned int enable : 1;    // bit0
    unsigned int mode   : 2;    // bit1-2
    unsigned int speed  : 2;    // bit3-4
    unsigned int reserved : 3;  // bit5-7
};

volatile ControlRegister* reg = reinterpret_cast<ControlRegister*>(0x40021000);
reg->enable = 1;
reg->mode = 2;
场景2:网络协议头解析

例如 IP 头中的很多字段只有几位。

struct IPHeader {
    unsigned int version : 4;
    unsigned int ihl : 4;
    unsigned int tos : 8;
    unsigned int total_len : 16;
    // ...
};
场景3:状态标志压缩

当需要存储多个布尔标志时,使用位域可以大大减少内存占用。

struct State {
    bool isReady : 1;   // 注意:bool 作为位域类型可能不可移植,建议用 unsigned int
    bool isRunning : 1;
    bool isFinished : 1;
    // 否则每个 bool 原本占 1 字节,现在总共只占 1 字节(如果编译器打包)
};

2.3 位域的注意事项

  • 位域的地址不能取(不能有指向位域的指针)。
  • 位域的对齐和布局是编译器相关的(不同编译器可能产生不同的内存布局,不适合跨平台通信)。
  • 位域成员可以混合普通成员,但通常建议将位域放在一起以提高空间利用率。
  • 使用 unsigned int 或 int 作为位域类型,避免使用 signed int 的位域(符号位行为复杂)。
  • 如果连续位域的总位数超过底层类型的位数,编译器可能会分配新的存储单元。

3. 内存模型讲解

3.1 共用体的内存布局

假设我们定义了以下共用体:

union Mixed {
    char c;    // 1 字节
    int i;     // 4 字节
    double d;  // 8 字节
};

sizeof(Mixed) 等于 sizeof(double) = 8(可能加上对齐,但这里是 8)。内存布局如下:

地址 0x1000 开始的 8 个字节:
+----+----+----+----+----+----+----+----+
| 共享内存(同一时刻存储 c 或 i 或 d 的内容)|
+----+----+----+----+----+----+----+----+
  • 如果存储 c,只有第一个字节有意义,其他字节未定义。
  • 如果存储 i,前 4 个字节有意义。
  • 如果存储 d,全部 8 个字节有意义。

重要:写入一个成员会覆盖其他成员的数据。读取非活动成员会将内存内容按该成员的类型解释,可能导致意外值。

3.2 位域的内存布局(以典型编译器为例)

考虑以下结构体:

struct BitFieldExample {
    unsigned int a : 3;   // 3 位
    unsigned int b : 5;   // 5 位
    unsigned int c : 7;   // 7 位
};

假设 unsigned int 为 4 字节(32 位)。编译器可能会将 a、b、c 打包到一个 32 位单元中,布局如下(小端序,从低位到高位):

bit 0-2: a
bit 3-7: b
bit 8-14: c
bit 15-31: 未使用(填充)

sizeof(BitFieldExample) 通常为 4 字节。

如果位域总位数超过 32,则会分配第二个 unsigned int 单元。

注意:不同编译器对位域的顺序(从低到高或从高到低)和是否跨越字节边界可能有不同行为,因此位域不适合用于跨平台数据交换。

3.3 共用体与位域结合

可以将位域放在共用体中,以灵活访问同一内存的不同解释方式。

union Register {
    unsigned int value;
    struct {
        unsigned int low : 16;
        unsigned int high : 16;
    } parts;
};

这样既可以整体读写寄存器,也可以分别访问高 16 位和低 16 位。


4. 常见错误与避坑

错误说明正确做法
从共用体的非活动成员读取未定义行为(除非是某些允许类型双关的编译器扩展)确保读取的是最后写入的成员
忘记共用体成员共享内存,以为可以同时存储多个值写入一个会破坏其他明确使用一个成员,或使用 std::variant
位域使用有符号类型符号扩展可能产生意外结果使用 unsigned int
假设位域跨平台布局一致不同编译器、不同平台布局不同避免用于序列化,或使用固定位操作
取位域的地址编译错误不能取地址,可以通过整体结构体地址间接操作

5. 练习题

题目:编写一个 C++ 程序,完成以下任务:

  1. 定义一个共用体 Value,可以存储 int、float 或 char[20](字符串)。同时使用一个枚举类型来指示当前存储的类型。
  2. 在 main 中,创建一个 Value 变量,先存储一个整数 100,然后输出(根据类型)。再改为存储浮点数 3.1415,输出。再改为存储字符串 "Hello",输出。
  3. 定义一个位域结构体 Status,包含以下字段:
    • isReady (1 bit)
    • errorCode (3 bits, 范围 0-7)
    • priority (2 bits, 范围 0-3)
    • reserved (2 bits, 填充)
      要求总大小不超过 1 字节。使用 unsigned char 作为底层类型(如果编译器支持,否则用 unsigned int 并检查大小)。
  4. 创建一个 Status 变量,设置 isReady = 1, errorCode = 5, priority = 2,然后输出整个结构体的大小(以字节为单位),并尝试使用 union 或 reinterpret_cast 输出其底层字节的值(十六进制),观察位域如何打包。
  5. 解释为什么共用体不适合同时存储多个信息,并指出 C++17 中更安全的替代方案。

期望输出(示例):

存储整数: 100
存储浮点数: 3.1415
存储字符串: Hello
Status 大小: 1 字节
Status 原始字节: 0x65 (二进制 01100101,根据位域布局可能不同)
更安全的替代方案: std::variant

上期参考答案

#include <iostream>
#include <string>

// 1. 定义结构体
struct Employee {
    std::string name;
    int id;
    double salary;
};

// 3. 涨薪函数(通过指针)
void giveRaise(Employee* emp, double percent) {
    if (emp != nullptr) {
        emp->salary *= (1.0 + percent / 100.0);
    }
}

int main() {
    // 2. 结构体数组初始化
    Employee employees[3] = {
        {"Alice", 101, 50000.0},
        {"Bob", 102, 60000.0},
        {"Charlie", 103, 55000.0}
    };

    std::cout << "原始信息:" << std::endl;
    for (int i = 0; i < 3; ++i) {
        std::cout << employees[i].name << ", " 
                  << employees[i].id << ", " 
                  << employees[i].salary << std::endl;
    }

    // 4. 给所有员工涨薪 10%
    for (int i = 0; i < 3; ++i) {
        giveRaise(&employees[i], 10.0);
    }

    std::cout << "\n涨薪10%后:" << std::endl;
    for (int i = 0; i < 3; ++i) {
        std::cout << employees[i].name << ", " 
                  << employees[i].id << ", " 
                  << employees[i].salary << std::endl;
    }

    // 5. 指向第二个元素的指针并修改 ID
    Employee* ptr = &employees[1];  // 指向 Bob
    ptr->id = 999;
    std::cout << "\n通过指针修改后 Bob 的新 ID: " << employees[1].id << std::endl;

    // 6. 输出结构体大小
    std::cout << "结构体大小: " << sizeof(Employee) << " 字节" << std::endl;
    std::cout << "解释: 由于内存对齐,结构体实际大小可能大于成员大小之和。" << std::endl;

    return 0;
}

总结:共用体(union)通过共享内存节省空间,适用于多选一的场景,但需小心未定义行为。位域(bit-field)允许精确控制位数,用于压缩存储标志或硬件映射。两者都是底层特性,使用时要注意平台差异和内存布局。在现代 C++ 中,类型安全的 std::variant 和位操作(如 std::bitset)可以替代许多传统用法,但理解 union 和位域对于系统编程仍然重要。通过练习题,你应能掌握它们的基本用法和内存模型。

Logo

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念,把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起,为开发者提供从开发、训练到部署的一站式体验。

更多推荐