qidao123.com ToB IT社区-企服评测·应用市场»论坛 › 物联网/工业互联网 › 物联网 › C语言菜鸟入门·关键字·union的用法

C语言菜鸟入门·关键字·union的用法

[复制链接]
发表于 2025-12-20 18:42:11 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

×

目次
1.  简介
2.  访问成员
2.1  声明
2.2  赋值
3.  共用体的巨细
4.  与typedef连合使用
5.  更多关键字

1.  简介

        共用体（union）是一种数据结构，它答应在同一内存位置存储差别的数据范例，但每次只能存储此中一种范例的数据。与结构体差别，结构体中的每个成员都有各自独立的内存空间，而共用体中的全部成员共享同一块内存地区。
表达情势：
  1. union union_name {
  2.     data_type1 member1;
  3.     data_type2 member2;
  4.     data_type3 member3;
  5.     // 其他成员
  6. };
复制代码
  

  • union_name 是共用体的名称。
  • member1, member2, member3 是共用体的成员。
  • data_type1, data_type2, data_type3 是成员的范例。
举例：
  1. union Data {
  2.     int i;
  3.     float f;
  4.     char str[20];
  5. };
复制代码
2.  访问成员

2.1  声明

        访问共用体的成员与结构体雷同，通过点操纵符 (.) 来访问共用体的各个成员。每次只能访问共用体中的一个成员。
        我们先声明一个共用体：
  1. union Data
  2. {
  3.         char data1;
  4.         int  data2;
  5.         float data3;
  6.         double data4;
  8.     char str[20];
  9. };
复制代码
        在界说一个共用体变量，通过改变了来访问共用体成员：
  1. union Data sum;
复制代码
        合起来就是：
  1. union Data
  2. {
  3.         char data1;
  4.         int  data2;
  5.         float data3;
  6.         double data4;
  8.     char str[20];
  9. };union Data sum;
复制代码
        简化情势：
  1. union Data
  2. {
  3.         char data1;
  4.         int  data2;
  5.         float data3;
  6.         double data4;
  8.     char str[20];
  9. }sum;
复制代码
        匿名结构：
  1. union
  2. {
  3.         char data1;
  4.         int  data2;
  5.         float data3;
  6.         double data4;
  8.     char str[20];
  9. }sum;
复制代码
2.2  赋值

        下面我们只对data1，举行赋值看看是什么结果：
  1. #include <stdio.h>
  3. union Data {
  4.     char data1;       // char 类型
  5.     int data2;        // int 类型
  6.     float data3;      // float 类型
  7.     double data4;     // double 类型
  8.     char str[20];     // 字符数组
  9. }sum;
  11. int main() {
  13.     // 1. 为 data1 赋值
  14.     sum.data1 = 'A';
  15.     printf("data1: %c\n", sum.data1);  
  16.     printf("data2: %d\n", sum.data2);  
  17.     printf("data3: %f\n", sum.data3);  
  18.     printf("data4: %lf\n", sum.data4);
  19.     printf("str: %s\n", sum.str);
  21.     return 0;
  22. }
复制代码
        可以看到全部共用体介能打印出data1的数据，分析他们共用一个内存空间： 

        下面我们对data2举行赋值，看看是什么结果：
  1. #include <stdio.h>
  3. union Data {
  4.     char data1;       // char 类型
  5.     int data2;        // int 类型
  6.     float data3;      // float 类型
  7.     double data4;     // double 类型
  8.     char str[20];     // 字符数组
  9. }sum;
  11. int main() {
  13.     // 1. 为 data1 赋值
  14.     sum.data1 = 'A';
  15.     printf("data1: %c\n", sum.data1);  
  16.     printf("data2: %d\n", sum.data2);  
  17.     printf("data3: %f\n", sum.data3);  
  18.     printf("data4: %lf\n", sum.data4);
  19.     printf("str: %s\n", sum.str);
  20.    
  21.     printf("------------------------------------\n");
  22.     printf("\n");
  23.     printf("\n");
  24.     printf("\n");
  25.                     
  26.     // 2. 为 data2 赋值，覆盖了 data1 的值
  27.     sum.data2 = 12345;
  28.     printf("data1: %c\n", sum.data1);  
  29.     printf("data2: %d\n", sum.data2);  
  30.     printf("data3: %f\n", sum.data3);  
  31.     printf("data4: %lf\n", sum.data4);
  32.     printf("str: %s\n", sum.str);
  33.    
  34.     return 0;
  35. }
复制代码
        可以看到值被覆盖掉了： 

        我们换一种表达方式：
  1. #include <stdio.h>
  3. union Data {
  4.     char str[4];   
  5.     int data1;      
  6. }sum;
  8. int main() {
  10.     sum.str[0] = 0x12;  
  11.     sum.str[1] = 0x34;  
  12.     sum.str[2] = 0x56;  
  13.     sum.str[3] = 0x78;
  14.    
  15.     printf("str: %x\n", sum.str[0]);
  16.     printf("str: %x\n", sum.str[1]);
  17.     printf("str: %x\n", sum.str[2]);
  18.     printf("str: %x\n", sum.str[3]);
  19.     printf("data1: %x\n", sum.data1);  
  20.             
  21.     printf("--------------------------------\n");
  22.     printf("\n");
  23.     printf("\n");
  24.     printf("\n");
  25.                     
  26.     sum.data1 = 0x12345678;
  27.    
  28.     printf("str: %x\n", sum.str[0]);
  29.     printf("str: %x\n", sum.str[1]);
  30.     printf("str: %x\n", sum.str[2]);
  31.     printf("str: %x\n", sum.str[3]);
  32.     printf("data1: %x\n", sum.data1);  
  33.    
  34.     return 0;
  35. }
复制代码
        会发现给数组赋值时，data1也会有数据表现，给data1赋值时，数组的数据会被覆盖掉：

        除此之外我们会发现，我们显着赋值赋的是12345678，但是为什么数组表现是str[0]=0x78，那是由于接纳的小端模式。
大端模式(高字节在前)小端模式(低字节在前)
data1str[0]str[1]str[2]str[3]str[0]str[1]str[2]str[3]
0x123456780x120x340x560x780x120x340x560x78
3.  共用体的巨细

        共用体的巨细是其最大成员的巨细，由于全部成员共享同一块内存空间。也就是说，只管共用体可以包罗多个成员，但内存只为此中最大的数据范例分配。
        比方，假如一个共用体包罗一个 int（4字节）和一个 double（8字节），那么这个共用体的巨细将是 8 字节，由于 double 占用的空间较大。
  1. #include <stdio.h>
  3. union Data
  4. {
  5.         char data1;
  6.         int  data2;
  7.         float data3;
  8.         double data4;
  10. };
  12. union Data sum;
  14. int main()
  15. {
  16.         printf("data1占用的%d字节\n",sizeof(sum.data1));
  17.         printf("data2占用的%d字节\n",sizeof(sum.data2));
  18.         printf("data3占用的%d字节\n",sizeof(sum.data3));
  19.         printf("data4占用的%d字节\n",sizeof(sum.data4));
  20.     printf("共用体占用的%d字节\n",sizeof(sum));
  22.   return 0;
  23. }
复制代码

4.  与typedef连合使用

        我们对共用体 union un 重界说为 u ，并通过 u 声明变量共用体变量 data2 并举行初始化。
  1. #include<stdio.h>
  3. union un
  4. {
  5.         char data1;
  6.         int data2;
  7. };
  9. typedef union un u;
  11. int main()
  12. {
  13.         u data2 = { 0 };
  14.         data2.data1 = 'a';
  16.         printf("%d", data2.data2);
  18.         return 0;
  19. }
复制代码
        也可以写作：
  1. #include<stdio.h>
  3. typedef union un
  4. {
  5.         char data1;
  6.         int data2;
  7. }u;
  9. int main()
  10. {
  11.         u data2 = { 0 };
  12.         data2.data1 = 'a';
  14.         printf("%d", data2.data2);
  16.         return 0;
  17. }
复制代码
        匿名情势：
  1. #include<stdio.h>
  3. typedef union
  4. {
  5.         char data1;
  6.         int data2;
  7. }u;
  9. int main()
  10. {
  11.         u data2 = { 0 };
  12.         data2.data1 = 'a';
  14.         printf("%d", data2.data2);
  16.         return 0;
  17. }
复制代码

5.  更多关键字

C语言32个关键字

跳转链接
第一类：数据范例关键字
 A根本数据范例（5个）
 void
声明函数无返回值或无参数，声明无范例指针，显式扬弃运算结果C语言菜鸟入门·关键字·void的用法-CSDN博客
char
 字符型范例数据，属于整型数据的一种。
C语言菜鸟入门·关键字·char关键字-CSDN博客
int
 整型数据，通常为编译器指定的呆板字长。
C语言菜鸟入门·关键字·int的用法-CSDN博客
float
 单精度浮点型数据，属于浮点数据的一种，小数点后生存6位。
C语言菜鸟入门·关键字·float以及double的用法-CSDN博客
double
 双精度浮点型数据，属于浮点数据的一种，比float生存的精度高，小数点后生存15/16位。
B范例修饰关键字（4个）
 short
 修饰int，短整型数据，可省略被修饰的int。
C语言菜鸟入门·关键字·修饰关键字short、long、signed、unsigne具体-CSDN博客
long
 修饰int，长整形数据，可省略被修饰的int。
signed
 修饰整型数据，有符号数据范例。
unsigne
 修饰整型数据，无符号数据范例。
C复杂范例关键字（5个）
 struct
 结构体声明。
C语言菜鸟入门·结构体·struct用法超具体分析_struct在c语言中用法-CSDN博客
union
 共用体声明。
C语言菜鸟入门·关键字·union的用法-CSDN博客
enum
 罗列声明。
C语言菜鸟入门·罗列范例·enum的使用详解-CSDN博客
typedef 声明范例别名。
C语言菜鸟入门·各种typedef用法超具体分析-CSDN博客
sizeof
 得到特定范例或特定范例变量的巨细。
C语言菜鸟入门·关键字·sizeof的用法-CSDN博客
D存储级别关键字（6个）
 auto
 指定为主动变量，由编译器主动分配及开释。通常在栈上分配。
C语言菜鸟入门·关键字·auto的用法、register的用法-CSDN博客
static
 指定为静态变量，分配在静态变量区，修饰函数时，指定函数作用域为文件内部。
register
 指定为寄存器变量，发起编译器将变量存储到寄存器中使用，也可以修饰函数形参，发起编译器通过寄存器而不是堆栈转达参数。
C语言菜鸟入门·关键字·auto的用法、register的用法-CSDN博客
extern
 指定对应变量为外部变量，即在别的的目的文件中界说，可以以为是约定由别的文件声明的。
const
 与volatile合称“cv特性”，指定变量不可被当火线程/进程改变
C语言菜鸟入门·关键字·const的用法、volatile的用法-CSDN博客
volatile
 与const合称“cv特性”，指定变量的值有大概会被体系或其他进程/线程改变，逼迫编译器每次从内存中取得该变量的值。
第二类：流程控制关键 字
 A跳转结构（4个）
 return
 用在函数体中，返回特定值（大概是void值，即不返回值）。
continu
 竣事当前循环，开始下一轮循环。
break
 跳出当前循环或switch结构。
goto
 无条件跳转语句。
分支结构（5个）
 if
 条件语句。
C语言菜鸟入门·判断语句（if语句、if...else语句、嵌套if语句）具体先容_c语言else if-CSDN博客
else
 条件语句否定分支（与if连用）。
switch
 开关语句（多重分支语句）。
case
 开关语句中的分支标记。
default
 开关语句中的“其他”分治，可选。
C循环结构（3个）
 for
 or循环结构，for(1;2;3)4;的实验序次为1->2->4->3->2...循环，此中2为循环条件。
do do循环结构，do 1 while(2);的实验序次是1->2->1...循环，2为循环条件。
while while循环结构，while(1) 2;的实验序次是1->2->1...循环，1为循环条件，以上循环语句，当循环条件
表达式为真则继续循环，为假则跳出循环。

   关键字_韶光の尘的博客-CSDN博客
  
回复

使用道具 举报

返回列表

宝塔山
+ 我要发帖

登录后关闭弹窗

登录参与点评抽奖  加入IT实名职场社区
去登录
快速回复 返回顶部 返回列表