共用体的用法

已于 2024-09-11 09:44:53 修改
阅读量280 收藏 4
点赞数 5
文章标签： arm开发 stm32 单片机 mcu
于 2024-09-11 09:29:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lcl113480/article/details/142126874
版权

共用体（union）在 C 语言中有多种用途，除了用于实现互斥量之外，还可以用于以下几种常见场景：

  1. 硬件访问：

    • 共用体常用于硬件驱动程序开发中，特别是当需要处理硬件寄存器时。硬件寄存器可能需要以不同的方式访问，比如既可以当作一组位来操作，也可以当作一个整数来读写。

    • 例如，一个 32 位的寄存器，可以将其视为一个整数或者拆分成几个位字段进行操作。

  2. 类型转换：

    • 共用体可以用来在不同数据类型之间进行转换，这在某些情况下非常有用，尤其是在低级编程中。

    • 例如，可以使用共用体将浮点数转换成整数，以便检查其内部表示。

  3. 高效内存利用：

    • 当需要在不同的阶段使用同一段内存存储不同类型的数据时，共用体可以用来减少内存消耗。

    • 例如，在一个数据包解析过程中，可能需要暂时存储多种不同类型的数据，但这些数据不会同时存在于内存中。

  4. 数据打包与解包：

    • 在网络编程或者文件格式解析中，共用体可以帮助解析或构建复杂的数据结构，特别是当数据结构包含多种类型的字段时。

    • 例如，一个网络协议包可能包含多种类型的字段，共用体可以用来方便地处理这些字段。

  5. 调试工具：

    • 在调试工具中，共用体可以用来查看同一内存地址上的不同数据类型表示，这对于分析内存内容非常有用。

  6. 复合数据类型：

    • 共用体可以用来创建复合数据类型，这些类型可以在不同情况下表现出不同的特性。

    • 例如，一个复合数据类型可能在一种情况下表现为一个结构体，在另一种情况下表现为一个数组。

  7. 动态类型选择：

    • 在某些算法中，根据运行时条件选择使用不同的数据类型。共用体可以用来实现这样的动态类型选择，使得程序可以根据需要选择最合适的类型。

  8. 互斥量的用法

    • 互斥量（mutex）通常用于保护共享资源，确保在同一时间只有一个线程能够访问这些资源。在 C 语言中，可以通过共用体来实现互斥量的功能。

1. 硬件访问

假设我们需要处理一个 32 位的硬件寄存器，该寄存器既可以作为一个整数来读写，也可以拆分成多个位字段来操作。

#include <stdio.h>
​
union HardwareRegister {
    uint32_t reg;
    struct {
        uint32_t bit0 : 1;
        uint32_t bit1 : 1;
        uint32_t bit2 : 1;
        uint32_t bit3 : 1;
        uint32_t bit4 : 1;
        uint32_t bit5 : 1;
        uint32_t bit6 : 1;
        uint32_t bit7 : 1;
        uint32_t reserved : 24;
    } bits;
};
​
int main() {
    union HardwareRegister reg;
​
    // 设置寄存器的各个位
    reg.reg = 0;
    reg.bits.bit0 = 1;
    reg.bits.bit1 = 1;
    reg.bits.bit2 = 1;
​
    // 打印寄存器的整数值
    printf("Register value: 0x%08X\n", reg.reg);
​
    // 打印寄存器的位字段值
    printf("Bit 0: %d\n", reg.bits.bit0);
    printf("Bit 1: %d\n", reg.bits.bit1);
    printf("Bit 2: %d\n", reg.bits.bit2);
​
    return 0;
}

2. 类型转换

假设我们需要将一个浮点数转换成整数，以便检查其内部表示。

#include <stdio.h>
#include <string.h>
​
union FloatToInt {
    float f;
    int i;
};
​
int main() {
    union FloatToInt data;
​
    // 设置浮点数
    data.f = 123.45;
​
    // 打印浮点数
    printf("Float value: %.2f\n", data.f);
​
    // 打印整数表示
    printf("Int value: 0x%08X\n", data.i);
​
    return 0;
}

3. 高效内存利用

假设我们需要在不同的阶段使用同一段内存存储不同类型的数据。

#include <stdio.h>
​
union EfficientMemory {
    int i;
    float f;
    char str[20];
};
​
int main() {
    union EfficientMemory data;
​
    // 使用整型
    data.i = 12345;
    printf("Integer value: %d\n", data.i);
​
    // 使用浮点型
    data.f = 123.45;
    printf("Float value: %.2f\n", data.f);
​
    // 使用字符串
    strcpy(data.str, "Hello, Union!");
    printf("String value: %s\n", data.str);
​
    return 0;
}

4. 数据打包与解包

假设我们需要在网络编程中打包和解包数据。

#include <stdio.h>
#include <string.h>
​
union DataPacket {
    struct {
        int id;
        float value;
        char name[20];
    } fields;
    char raw[20];
};
​
int main() {
    union DataPacket packet;
​
    // 打包数据
    packet.fields.id = 1;
    packet.fields.value = 123.45;
    strcpy(packet.fields.name, "John Doe");
​
    // 解包数据
    memcpy(packet.raw, &packet.fields, sizeof(packet.fields));
​
    // 打印原始数据
    printf("Raw data: ");
    for (int i = 0; i < sizeof(packet.fields); ++i) {
        printf("%02X ", (unsigned char)packet.raw[i]);
    }
    printf("\n");
​
    // 打印解包后的数据
    printf("ID: %d\n", packet.fields.id);
    printf("Value: %.2f\n", packet.fields.value);
    printf("Name: %s\n", packet.fields.name);
​
    return 0;
}

5. 调试工具

假设我们需要查看同一内存地址上的不同数据类型表示。

#include <stdio.h>
​
union DebugData {
    int i;
    float f;
    char str[20];
};
​
int main() {
    union DebugData data;
​
    // 设置整型
    data.i = 12345;
    printf("Integer value: %d\n", data.i);
​
    // 设置浮点型
    data.f = 123.45;
    printf("Float value: %.2f\n", data.f);
​
    // 设置字符串
    strcpy(data.str, "Hello, Union!");
    printf("String value: %s\n", data.str);
​
    return 0;
}

6. 复合数据类型

假设我们需要创建一个复合数据类型，该类型可以在不同情况下表现出不同的特性。

#include <stdio.h>
​
union CompositeData {
    struct {
        int id;
        float value;
    } structData;
    char array[20];
};
​
int main() {
    union CompositeData data;
​
    // 使用结构体形式
    data.structData.id = 1;
    data.structData.value = 123.45;
    printf("Struct ID: %d\n", data.structData.id);
    printf("Struct Value: %.2f\n", data.structData.value);
​
    // 使用数组形式
    strcpy(data.array, "Hello, Union!");
    printf("Array value: %s\n", data.array);
​
    return 0;
}

7. 动态类型选择

假设我们需要根据运行时条件选择使用不同的数据类型。

#include <stdio.h>
​
union DynamicData {
    int i;
    float f;
    char str[20];
};
​
int main() {
    union DynamicData data;
    int choice;
​
    printf("Enter your choice (1 for int, 2 for float, 3 for string): ");
    scanf("%d", &choice);
​
    switch (choice) {
        case 1:
            data.i = 12345;
            printf("Integer value: %d\n", data.i);
            break;
        case 2:
            data.f = 123.45;
            printf("Float value: %.2f\n", data.f);
            break;
        case 3:
            strcpy(data.str, "Hello, Union!");
            printf("String value: %s\n", data.str);
            break;
        default:
            printf("Invalid choice.\n");
    }
​
    return 0;
}

8.互斥量的用法

假设我们有一个简单的队列结构，其中包含一个互斥量来保护队列的操作。我们将使用共用体来实现互斥量的功能。通过这种方式，共用体实现了互斥量的功能，确保队列操作的安全性。

  1. 队列结构定义：

    • Queue 结构体包含队列的基本信息和互斥量的共用体。

    • 共用体 u 包含两种成员：pcReadFrom 和 uxRecursiveCallCount。

    • uxRecursiveCallCount 用于记录互斥量的递归调用次数。

  2. 互斥量操作：

    • acquireMutex：获取互斥量，递增递归调用计数。

    • releaseMutex：释放互斥量，递减递归调用计数。

  3. 队列操作：

    • enqueue：入队操作，先获取互斥量，然后插入新节点，最后释放互斥量。

    • dequeue：出队操作，先获取互斥量，然后删除队头节点，最后释放互斥量。

  4. 打印队列：

    • printQueue：遍历队列并打印所有元素。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义队列节点
typedef struct QueueNode {
    int data;
    struct QueueNode *next;
} QueueNode;

// 定义队列结构
typedef struct Queue {
    QueueNode *head;
    QueueNode *tail;
    int count;

    // 互斥量的共用体
    union {
        int8_t *pcReadFrom;            // 指向最后一次读取数据的位置
        int uxRecursiveCallCount;      // 记录递归获取互斥锁的次数
    } u;
} Queue;

// 初始化队列
void initQueue(Queue *queue) {
    queue->head = NULL;
    queue->tail = NULL;
    queue->count = 0;
    queue->u.uxRecursiveCallCount = 0; // 初始化互斥量状态
}

// 获取互斥量
void acquireMutex(Queue *queue) {
    queue->u.uxRecursiveCallCount++;
    printf("Acquired mutex (count: %d)\n", queue->u.uxRecursiveCallCount);
}

// 释放互斥量
void releaseMutex(Queue *queue) {
    if (queue->u.uxRecursiveCallCount > 0) {
        queue->u.uxRecursiveCallCount--;
        printf("Released mutex (count: %d)\n", queue->u.uxRecursiveCallCount);
    }
}

// 入队操作
void enqueue(Queue *queue, int data) {
    acquireMutex(queue); // 获取互斥量

    QueueNode *newNode = (QueueNode *)malloc(sizeof(QueueNode));
    newNode->data = data;
    newNode->next = NULL;

    if (queue->tail == NULL) {
        queue->head = newNode;
        queue->tail = newNode;
    } else {
        queue->tail->next = newNode;
        queue->tail = newNode;
    }

    queue->count++;

    releaseMutex(queue); // 释放互斥量
}

// 出队操作
int dequeue(Queue *queue) {
    acquireMutex(queue); // 获取互斥量

    if (queue->head == NULL) {
        releaseMutex(queue); // 释放互斥量
        return -1; // 队列为空
    }

    QueueNode *temp = queue->head;
    int data = temp->data;

    queue->head = queue->head->next;
    if (queue->head == NULL) {
        queue->tail = NULL;
    }

    free(temp);
    queue->count--;

    releaseMutex(queue); // 释放互斥量

    return data;
}

// 打印队列
void printQueue(Queue *queue) {
    QueueNode *current = queue->head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

int main() {
    Queue queue;
    initQueue(&queue);

    // 入队操作
    enqueue(&queue, 10);
    enqueue(&queue, 20);
    enqueue(&queue, 30);

    printf("Queue after enqueuing: ");
    printQueue(&queue);

    // 出队操作
    int data = dequeue(&queue);
    printf("Dequeued data: %d\n", data);

    printf("Queue after dequeuing: ");
    printQueue(&queue);

    return 0;
}

 

 

傲雪飞龍
关注
【C 高阶】共用体（联合体）
Kong
10-29 1403
C 高阶系列导航 1. 共用体简介 共用体又称联合体，为一种 C 语言的复合数据类型。共用体与结构体类似的是，同为多种数据类型的集合；不同的是，共用体在同一时刻只能表现出其中一种数据类型，而结构体本身包含着多种数据类型。 如何理解“共用体在同一时刻只能表现出其中一种数据类型”这一句话呢？ 可以从数据类型的角度解答。数据类型为对某段内存以特定方式进行解析的方法，比如整型就是对 4 字节大小的内存以...
共用体的定义和使用
Lijueqi001的博客
08-04 3412
共用体的定义和使用
共用体
str999_cn的专栏
11-22 4980
共用体把几种不同数据类型的变量存放在同一块内存里。共用体中的变量共享同一块内存。     定义共用体类型变量的一般形式：         union 共用体名         {                 成员列表         }变量列表;     与结构体类似，变量列表是可选的。如果没有变量列表，只是定义了一种共用体类型。
C语言——共用体
刘鑫磊
02-06 1168
目录： 一：定义 实例 二：访问共用体成员 实例 三：共用体作用 四：共用体应用场景 五：结构体与共用体的区别 1.结构体变量 2.共用体变量 六：补充 一：定义 允许您在相同的内存位置存储不同的数据类型 可以定义一个带有多成员的共用体 但是任何时候只能有一个成员带有值 共用体提供了一种使用相同的内存位置的有效方式 必须使用union语句 union 语句...
【C语言】共用体
熠熠L的博客
03-25 1389
共用体是一种特殊的数据类型，允许您在相同的内存位置存储不同的数据类型。您可以定义一个带有多成员的共用体，但是任何时候只能有一个成员带有值。共用体提供了一种使用相同的内存位置的有效方式。 定义一个共用体 union u1 { char c; int i; float f; }; 在同一时间只使用一个变量。 #include <stdio.h> union u1 { int i; float f; }; int main() { unio.
什么是共用体？如何定义和使用共用体？
weixin_68551689的博客
06-09 2968
可以看到，共用体的大小为最大成员的大小，即在这个例子中为 `20` 字节（`stringValue` 的大小）。在上述示例中，定义了一个名为 `Data` 的共用体，包含了三个成员变量：`intValue`、`floatValue` 和 `stringValue`，它们分别表示整数、浮点数和字符串类型的数据。由于共用体的不同成员共享同一块内存，因此共用体的内存对齐将按照其最宽的成员进行，以确保成员的访问不会跨越边界。需要注意的是，同一时间只能使用一个成员，并且共用体的不同成员共享相同的内存空间。
C语言学习之共用体union
01-06
这是实际工作中接触到的一种共用体的用法，晓得的大佬就别看了，有点丑，感兴趣的可以先看看代码再看下文： #include #include char flash[200]; typedef struct str_test { int len; int size; int width; int...
c 语言 结构体 共用体 大小,结构体与共用体内存大小计算
weixin_36047538的博客
05-17 2740
结构体和共用体的内存分配是C语言的一个难点，也是面试题中的热点。示例1：点击(此处)折叠或打开Union data1{double d;int i;char c1;char c2[9];};sizeof(uniondata1)的值为16.在编译器默认设置的情况下，该共用体最大基本类型为double,它占8字节，所以此共用体以8来对齐。字符数组c2占9个字节，那么整个共用体应该占9个字节，但按照对齐...
c语言共用体变量赋值,（C语言）共用体union的用法举例
weixin_26821003的博客
05-18 2883
以前在学校学习C语言的时候一直搞不懂那个共用体union有什么用的。工作之后才发现它的一些妙用，现举例如下：1. 为了方便看懂代码。比如说想写一个3 * 3的矩阵，可以这样写：[ 注：下面用红色部分标记的地方是后来添加上去的，谢谢yrqing718的提醒！]struct Matrix{union{struct{float _f11,_f12,_f13,_f21,_f22,_f23,...
结构体和共用体小结.doc
09-29
定义共用体变量的方法与结构体类似，例如：`union Data d;`。 4. **效率和用途**： 共用体主要用于节省内存，当只需要在不同时刻存储不同类型数据中的一个时，它可以提供高效的空间利用。 5. **与结构体的区别**...
703-轻松理解C语言的共用体
LINZEYU666的博客
10-18 569
C语言的共用体 共用体：也称为联合体，所有的成员共用内存，也就是意味着所有成员都是从相同的低地址开始。 我们先来看看结构体的内存布局： 我们现在来看看共用体的内存布局： 成员是共用低地址开始的内存。 因为成员的大小有可能是不一样的，如果b是char类型的，那么b只占从低地址开始的1个字节大小的内存。 但是b还是和a共用低地址开始的内存。 对于所有的成员来说，内存都是相同的，从低地址开始。 在宿舍，每个成员都有自己的床位，类似于结构体，每个人都有自己独立的内存空间。 但是，餐厅是每个成员共用的，就餐座位
union的常见使用场景
HFUTWXY的博客
10-15 3323
概念： 1.联合体union类似于结构体struct 2.联合体用同一段内存单元存放不同数据类型的成员，在使用时，一次只能使用其中的一个成员 3.它的所有成员相对于基地址的偏移量都为0 4.union的大小取决于它所有的成员中，占用空间最大的一个成员的大小，并且union的大小要能被其他成员的大小所整除 应用： 1.用来节省内存空间 这个就很容易理解了，多个变量使用同一处内存。 2...
共用体变量的定义与运用实例
韶言大雅
04-06 1628
设计一个共用体模板，存储3个不同的圆的半径，并通过运算获取对应的圆面积。 #include<stdio.h> #define pi 3.14 union cycleinfo { short r; float cyclearea; }; int main() { int i=0; union cycleinfo cycle[3]; //定义有三个元素的cycleinfo共用体类...
联合体union适用场景
现从事游戏开发领域 | 团队项目be_with开发进行中 web方向感兴趣者私 ——We can do all things.
11-21 1566
         Union的内存是照着里边占地儿最大的那个变量分的。也就可以大胆的推测一下，这种union的使用场合，是各数据类型各变量占用空间差不多并且对各变量同时使用要求不高的场合（单从内存使用上，我觉得没错）。        一个数组（或者更...
共用体的使用实例
Yi_bunny的专栏
02-19 3010
转自http://home.eeworld.com.cn/my/space.php?uid=139222&do=blog&id=28244 1、共用体的概念 在编程过程中，有时需要使几种不同类型的变量存放到同一段内存单元中。例如，可以把一个整型变量，一个字符型变量，一个实型变量放在同一个地址开始的内存单元中。 这样的话，不同类型的变量在内存中占据的字节数不同，但是都从
【ARM 嵌入式 编译系列 10.5 -- ARM toolchain naming convention】
CodingCos的博客
09-26 702
ARM 工具链的命名规范指示了 GCC 工具链的构建目的和所针对的环境。
OpenHarmony（鸿蒙南向）——平台驱动指南【I2C】
鸿蒙开发知识记录
09-26 1158
I2C（Inter Integrated Circuit）总线是由Philips公司开发的一种简单、双向二线制同步串行总线。由于其硬件连接简单、成本低廉，因此被广泛应用于各种短距离通信的场景。I2C通常用于与各类支持I2C协议的传感器、执行器或输入输出设备进行通信。
ARM 服务器上安装 OpenEuler (欧拉)
最新发布
明弟有理想的博客
09-26 1326
在 2019 年 7 月 19 日，华为宣布要在年底正式开源 openEuler 操作系统；在半年后的 12 月 31 日，华为正式开源了 openEuler 操作系统，邀请社区开发者共同来贡献。一年后，截止到 2020 年12 月 25日，openEuler 已经拥有了 3 万社区用户，2 万多个合入的 拉取请求(Pull Request)，2000 多名社区贡献者，7032 款社区软件，75 个特别兴趣组（SIG）以及 7 个商业发行版。
C语言结构体与共用体详解
"C语言结构体与共用体的使用方法" 在C语言中，结构体（struct）和共用体（union）是两种重要的构造数据类型，它们允许我们将不同类型的数据组合到一起，形成一个复合的数据结构。下面将详细介绍这两种类型以及它们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值