C/C++ union联合体介绍

文章参考：https://blog.csdn.net/mooneve/article/details/92703036

C/C++ union联合体介绍

1. 联合体union简介

union是在某种程序上类似结构体struct的一种数据结构，union也可以包含很多种数据类型和变量，区别在于：

结构体中所有变量是共存的，内存空间的分配是粗放的，不管用不用，都会分配；
union中个变量是互斥的，任何两个成员不会同时有效，内存使用更精细灵活，节省内存空间。

当多个数据需要共享内存或者多个数据每次只取其一时，可以利用联合体。

在《C Programming Language》中对联合体union的描述：

联合体是一个结构体；
它的所有成员相对于基地址的偏移量是0；
此结构空间要大到足够容纳最宽的成员；
其内存对齐方式要适合其中所有的成员；

联合体union定义形式如下：

union 名称{

   public:  // 默认为public，可不写

   	公有成员

   protected:

   	保护成员

   privated:

   	私有成员

};

示例，无名联合体声明和使用

union{

   int i;

   float f;

}

i=1;

f=1.2;

示例：使用联合体管理成绩信息

/**

 * @file 1unioc.cpp

 * @author zoya (2314902703@qq.com)

 * @brief 联合体使用：使用联合体保存信息并数据

 * @version 0.1

 * @@date: 2022-10-08

 *

 * @copyright Copyright (c) 2022

 *

 */

#include <iostream>

#include <string>

using namespace std;

class ExamGradeInfo

{

private:

    string name; // 课程名

    enum

    {

        LEVEL,

        PASS,

        GRADE,

    } mode; // 计分方式

    union

    {

        char level; // 等级表示成绩 A/B/C等

        bool pass;  // 只计算是否通过

        int grade;  // 具体的分数

    };

public:

    ExamGradeInfo();

    ExamGradeInfo(string name, char level) : name(name),

                                             mode(ExamGradeInfo::LEVEL),

                                             level(level)

    {

    }

    ExamGradeInfo(string name, bool pass) : name(name),

                                            mode(ExamGradeInfo::PASS),

                                            pass(pass)

    {

    }

    ExamGradeInfo(string name, int grade) : name(name),

                                            mode(ExamGradeInfo::GRADE),

                                            grade(grade)

    {

    }

    void show()

    {

        cout << name << ":";

        switch (mode)

        {

        case ExamGradeInfo::LEVEL:

            cout << level << endl;

            break;

        case ExamGradeInfo::PASS:

            cout << (pass?"PASS":"FAILE") << endl;

            break;

        case ExamGradeInfo::GRADE:

            cout << grade << endl;

            break;

        default:

            break;

        }

    }

};

int main()

{

    ExamGradeInfo course1("english", 'B');

    ExamGradeInfo course2("math", true);

    ExamGradeInfo course3("C", 60);

    course1.show();

    course2.show();

    course3.show();

    return 0;

}

运行显示结果：

english:B

math:PASS

C:60

2. 联合体union内存分配与所占空间

联合体所占的空间不仅取决于最宽成员，还跟所有成员有关系，其大小必须满足两个条件：

大小足够容纳最宽的成员；
大小能被其包含的所有的基本数据类型的大小整除。

示例：测试如下联合体所占的大小：

/**

 * @file 2union.c

 * @author zoya (2314902703@qq.com)

 * @brief 测试联合体所占内存大小

 * @version 0.1

 * @@date: 2022-10-08

 *

 * @copyright Copyright (c) 2022

 *

 */

#include <stdio.h>

int main()

{

    union u1

    {

        int n;

        char s[5];

        double f;

    };

    union u2

    {

        int n;

        char s[9];

        double f;

    };

    u1 tmp1;

    u2 tmp2;

    printf("sizeof(int) = %ld, sizeof(char) = %ld, sizoef(douvle) = %ld\n", sizeof(int), sizeof(char), sizeof(double));

    printf("sizeof(u1) = %ld, sizeof(u2) = %ld\n", sizeof(tmp1), sizeof(tmp2));

    printf("u1各个变量的地址, &u1 : 0x%x, &u1.n : 0x%x, &u1.s : 0x%x, &u1.f : 0x%x\n",

           &tmp1, &tmp1.n, tmp1.s, &tmp1.f);

    printf("u2各个变量的地址, &u2 : 0x%x, &u2.n : 0x%x, &u2.s : 0x%x, &u2.f : 0x%x\n",

           &tmp2, &tmp2.n, tmp2.s, &tmp2.f);

    return 0;

}

运行结果：

sizeof(int) = 4, sizeof(char) = 1, sizoef(douvle) = 8

sizeof(u1) = 8, sizeof(u2) = 16

u1各个变量的地址, &u1 : 0x5ec19748, &u1.n : 0x5ec19748, &u1.s : 0x5ec19748, &u1.f : 0x5ec19748

u2各个变量的地址, &u2 : 0x5ec19750, &u2.n : 0x5ec19750, &u2.s : 0x5ec19750, &u2.f : 0x5ec19750

对联合体u1，n占4字节，f占8字节，s占5字节，u1最多占用8个字节，所以sizoef(u1)=8；

对联合体u2，n占4字节，f占8字节，s占9字节，最多占用了9字节，但是9字节不能被double所占的8字节整除，所以就会扩充到16字节，所以sizeof(u2) = 16；

另外，还可以发现联合体中各个变量的地址都是相同的。

3. 联合体union的优缺点

联合体的优点：多种访问内存的手段可以灵活读取任意部分的数据，也可整体进行赋值。在某些寄存器或通道大小有限制的情况下，可以分多次搬运；

联合体的缺点，由于所有变量都能使用，容易使用错误的变量造成逻辑错误。

示例：通过改变联合体中其中一个变量的值，操作共享到其它变量：

/**

 * @file 3union.c

 * @author zoya (2314902703@qq.com)

 * @brief 通过改变union中某一个变量的值来操作其它变量的改变

 * @version 0.1

 * @@date: 2022-10-09

 *

 * @copyright Copyright (c) 2022

 *

 */

#include <stdio.h>

int main()

{

    union

    {

        short nval;

        char bval[2];

    };

    nval = 0x0102;

    printf("联合体内存地址：0x%x\n", &nval);

    printf("nval(0x%x) = 0x%04x, bval[0](0x%x) = 0x%02x, bval[1](0x%x) = 0x%02x\n", &nval, nval, &bval[0], bval[0], &bval[1], bval[1]);

    bval[0] = 0x03;

    printf("nval(0x%x) = 0x%04x, bval[0](0x%x) = 0x%02x, bval[1](0x%x) = 0x%02x\n", &nval, nval, &bval[0], bval[0], &bval[1], bval[1]);

    return 0;

}

运行结果：

联合体内存地址：0x6427da16

nval(0x6427da16) = 0x0102, bval[0](0x6427da16) = 0x02, bval[1](0x6427da17) = 0x01

nval(0x6427da16) = 0x0103, bval[0](0x6427da16) = 0x03, bval[1](0x6427da17) = 0x01

因为测试机电脑是小段字节序的(高位数据存储在高位内存地址，低位数据存储在低位内存地址)，bval[0]所在的地址是低位内存地址(0x6427da16)，bval[1]所在地址是高位内存地址(0x6427da17)，所以分别存储的是0x02、0x01。

根据运行结果可以看出来，改变其中一个变量，那么另一个变量也会对应改变。

4. 联合体union的应用

判断电脑字节序

根据联合体的这一特点，还可以判断电脑是小端字节序还是大端字节序，如下：

/**

 * @file byteorder.c

 * @author your name (you@domain.com)

 * @brief 通过代码检测当前主机的字节序

 * @version 0.1

 * @date 2022-10-08

 *

 * @copyright Copyright (c) 2022

 *

 */

#include <stdio.h>

int main()

{

    union

    {

        short value;               // 2字节

        char bytes[sizeof(short)]; // 2字节数组

    } test;

    test.value = 0x0102;

    if (0x01 == test.bytes[0] && 0x02 == test.bytes[1])

    {

        printf("大端字节序\n");

    }

    else if (0x02 == test.bytes[0] && 0x01 == test.bytes[1])

    {

        printf("小端字节序\n");

    }

    else

    {

        printf("未知\n");

    }

}

寄存器读取

假设有一个I2C的温度控制寄存器，该寄存器是10位有效，需要读取该寄存器的值。但是I2C的数据传输是按照8bit的，每个时序只能接收8bit数据，只有使用char或unsigned char型接收数据，并且要接收2次。

传统的做法是声明一个char数组，包含2个元素，接收到数据后再通过计算给到一个short或int整数。

通过使用联合体也可以实现，使用联合体不用考虑各种转换问题，并且如果寄存器的有效位改变，也不用更改太多代码。

如下示例：

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

int main()

{

    // 传统的做法

    char bval[2] = {0};

    // 通过读取获取到寄存器的值,假设bval[0] = 02,bval[0] = 0x01

    bval[0] = 0x02;

    bval[1] = 0x07;

    // 转换为整型

    int nval = bval[0] | ((bval[1] & 0x03) << 8); // &0x03是因为10位有效

    printf("nval = 0x%x\n", nval);

    // 使用联合体

    union u1

    {

        int val;

        char cval[sizeof(int)];

    };

    u1 tmp;

    memset(&tmp, 0, sizeof(tmp));

    tmp.cval[0] = 0x02;

    tmp.cval[1] = 0x07;

    printf("val = 0x%x\n", tmp.val & 0x3ff); // &0x3ff是因为10位有效

    // 寄存器的有效位改变，17位有效

    tmp.cval[0] = 0x02;

    tmp.cval[1] = 0x07;

    tmp.cval[2] = 0x1f;

    printf("val = 0x%x\n", tmp.val & 0x1ffff); // 0x1ffff是因为17位有效

}

程序运行：

nval = 0x302

val = 0x302

val = 0x10702