C语言结构体联合体 | 嵌套使用

最新推荐文章于 2024-08-19 16:27:52 发布

嵌入式_Chen

最新推荐文章于 2024-08-19 16:27:52 发布

阅读量1.3w

点赞数 30

分类专栏： C语言文章标签：嵌入式 c语言结构体联合体

原文链接：https://blog.csdn.net/zhengnianli/article/details/111503438

版权

C语言专栏收录该内容

19 篇文章 1 订阅

订阅专栏

本文详细讲解了如何使用C语言的结构体和联合体来获取和操作0x12345678的各个字节，包括大小端影响、位操作技巧、联合体在数据管理、寄存器操作和数据拆分/组合中的应用。同时介绍了如何通过联合体处理不同类型数据和浮点数的传输。

摘要由CSDN通过智能技术生成

一、简单的实例分析

题目：获取0x12345678各个字节。
答案：

//方法一:
#include <stdio.h>

typedef unsigned int  uint32_t;
typedef unsigned char uint8_t;

union bit32_data
{
    uint32_t data;
    struct 
    {
        uint8_t byte0;
        uint8_t byte1;
        uint8_t byte2;
        uint8_t byte3;
    }byte;
};

int main(void)
{
    union bit32_data num;
    
    num.data = 0x12345678;

    printf("byte0 = 0x%x\n", num.byte.byte0);
    printf("byte1 = 0x%x\n", num.byte.byte1);
    printf("byte2 = 0x%x\n", num.byte.byte2);
    printf("byte3 = 0x%x\n", num.byte.byte3);

    return 0;
}

这种方法的缺点是：会受到大小端的影响。只有在明确大小端的情况下可稍微用一用。以上是小端模式下的运行结果。

// 方法二：
#include <stdio.h>

#define GET_LOW_BYTE0(x) ((x >>  0) & 0x000000ff) /* 获取第0个字节 */
#define GET_LOW_BYTE1(x) ((x >>  8) & 0x000000ff) /* 获取第1个字节 */
#define GET_LOW_BYTE2(x) ((x >> 16) & 0x000000ff) /* 获取第2个字节 */
#define GET_LOW_BYTE3(x) ((x >> 24) & 0x000000ff) /* 获取第3个字节 */

int main(void)
{
 unsigned int a = 0x12345678;
 
 printf("byte0 = 0x%x\n", GET_LOW_BYTE0(a));
 printf("byte1 = 0x%x\n", GET_LOW_BYTE1(a));
 printf("byte2 = 0x%x\n", GET_LOW_BYTE2(a));
 printf("byte3 = 0x%x\n", GET_LOW_BYTE3(a));
 return 0;
}

这也是获取数据各个字节的最常用也最有效的方法。这种类似的位操作在嵌入式方面应用得很多，比如在LCD操作中表示像素颜色值、FLASH的操作等方面都有用到。
当然还有其他方式来解答此题！

二、结构体、联合体的嵌套使用介绍

实例分析，方法一就是使用结构体和联合体嵌套的一个实例场景应用。
结构体、联合体是C语言中的构造类型，结构体我们平时应该都用得很多。但是，对于联合体，一些初学的朋友可能用得并不多，甚至感到陌生。我们先简单看一下联合体：
在C语言中定义联合体的关键字是union。
定义一个联合类型的一般形式为：

union 联合名
{
成员表
};

成员表中含有若干成员，成员的一般形式为：类型说明符成员名。其占用的字节数与成员中最大数据类型占用的字节数。

下面我们一起看一下结构体、联合体结合使用在C语言、嵌入式中的一些其他实用技巧。

1、应用于管理不同的数据

示例代码：

enum DATA_PKG_TYPE
{
    DATA_PKG1 = 1,
    DATA_PKG2,
    DATA_PKG3    
};

struct data_pkg1
{
    // ...
};

struct data_pkg2
{
    // ...
};

struct data_pkg3
{
    // ...
};

struct data_pkg
{
    enum DATA_PKG_TYPE data_pkg_type;
    union 
    {
       struct data_pkg1 data_pkg1_info;
       struct data_pkg2 data_pkg2_info;
       struct data_pkg3 data_pkg3_info;
    }data_pkg_info;
};

这里把struct data_pkg1、struct data_pkg2、struct data_pkg3三个结构体放到了struct data_pkg这个结构体里进行管理，把data_pkg_type与union里的三个结构体建立一一对应关系，我们需要用哪一结构体数据就通过data_pkg_type来进行选中。

在进行数据组包的时候，先给data_pkg_type进行赋值，确定数据包的类型，再给对应的union里的结构体进行赋值；在进行数据解析的时候，通过data_pkg_type来选择解析哪一组数据。

思考一下，如果在union里面再嵌套一层union会怎么样？会变得更复杂？以前的话，我会觉得越嵌套会越复杂，我也很抵制这种不断嵌套的做法。但后来看来在实际的应用场景中我们的模块很多，数据很多，嵌套这样的设计中显得很清晰、很容易维护。

2、寄存器、状态变量封装

我们看一看TI的寄存器封装是怎么做的：

所有的寄存器被封装成联合体类型的，联合体里边的成员是一个32bit的整数及一个结构体，该结构体以位域的形式体现。这样就可以达到直接操控寄存器的某些位了。比如，我们要设置PA0引脚的GPAQSEL1寄存器的[1:0]两位都为1，则我们只操控两个bit就可以很方便的这么设置：

GpioCtrlRegs.GPAQSEL1.bit.GPIO0 = 3
或者直接操控整个寄存器：

GpioCtrlRegs.GPAQSEL1.all |=0x03

如果不是工作于芯片原厂，寄存器的封装应该离我们很远。但我们可以学习使用这种方法，然后用于我们的实际应用开发中。
下面就看一种实际应用：管理一些状态变量。

示例代码：

union sys_status
{
   uint32 all_status;
   struct 
   {
      bool status1:  1; // FALSE / TRUE
      bool status2:  1; // 
      bool status3:  1; // 
      bool status4:  1; // 
      bool status5:  1; // 
      bool status6:  1; // 
      bool status7:  1; // 
      bool status8:  1; // 
      bool status9:  1; // 
      bool status10: 1; // 
   // ...
  }bit;
};

之前记得群里有一位小伙伴问系统有几十个状态变量需要管理，怎么做比较好。如上例子就是比较好的一种管理方法。

3、数据组合/拆分、大小端

（1）验证大小端

#include <stdio.h>

typedef unsigned int  uint32_t;
typedef unsigned char uint8_t;

union bit32_data
{
    uint32_t data;
    struct 
    {
        uint8_t byte0;
        uint8_t byte1;
        uint8_t byte2;
        uint8_t byte3;
    }byte;
};

int main(void)
{
    union bit32_data num;
    
    num.data = 0x12345678;
 
    if (0x78 == num.byte.byte0)
    {
      printf("Little endian\n");
    }
    else if (0x78 == num.byte.byte3)
    {
      printf("Big endian\n");
    }else{}

    return 0;
}

（2）数据组合、拆分
在数据组合与拆分之前首先需要确实当前平台的大小端。比如小编使用的平台是小端模式。
① 把0x12345678拆分成0x78、0x56、0x34、0x12：

#include <stdio.h>

typedef unsigned int  uint32_t;
typedef unsigned char uint8_t;

union bit32_data
{
    uint32_t data;
    struct 
    {
        uint8_t byte0;
        uint8_t byte1;
        uint8_t byte2;
        uint8_t byte3;
    }byte;
};

int main(void)
{
    union bit32_data num;
    
    num.data = 0x12345678;

    printf("byte0 = 0x%x\n", num.byte.byte0);
    printf("byte1 = 0x%x\n", num.byte.byte1);
    printf("byte2 = 0x%x\n", num.byte.byte2);
    printf("byte3 = 0x%x\n", num.byte.byte3);

    return 0;
}

② 把0x78、0x56、0x34、0x12组合成0x12345678：

#include <stdio.h>

typedef unsigned int  uint32_t;
typedef unsigned char uint8_t;

union bit32_data
{
    uint32_t data;
    struct 
    {
        uint8_t byte0;
        uint8_t byte1;
        uint8_t byte2;
        uint8_t byte3;
    }byte;
};

int main(void)
{
    union bit32_data num;
    
    num.byte.byte0 = 0x78;
 num.byte.byte1 = 0x56;
 num.byte.byte2 = 0x34;
 num.byte.byte3 = 0x12;

    printf("num.data = 0x%x\n", num.data);

    return 0;
}

但是数据组合与拆分有更好的方法：移位操作。

4、结构体 & 缓冲区

#define BUF_SIZE 16
union protocol_data
{
 uint8_t data_buffer[BUF_SIZE];
 struct 
 {
  uint8_t data1;
  uint8_t data2;
  uint8_t data3;
  uint8_t data4;
  // ...
 }data_info;
};

这种应用得很广泛，用于自定义通信协议。struct里面的内容可以设计得很简单，比如全是有用的数据，或是设计得很复杂，包含一些协议头尾、包长、有效数据、校验等内容。
但无论如何，我们组包发送的过程是填充结构体->发送data_buffer；反之接收数据解析的过程就是接收数据存于data_buffer->使用结构体数据。我们之前分享的《干货 | protobuf-c之嵌入式平台使用》也是这个思路。

5、传输浮点数据

union f_data 
{
 float f;
 struct
 {
  unsigned char byte[4];
 };
}

类似的，使用这样子的方法可以用于传输浮点数，更具体地不再展开，网络上有很多这一块的资料。感兴趣的朋友可以自己操作验证验证。