C语言15--联合体与枚举

最新推荐文章于 2024-10-12 18:23:31 发布

ZARD996

最新推荐文章于 2024-10-12 18:23:31 发布

阅读量817

点赞数 16

分类专栏： C语言文章标签： c语言

本文链接：https://blog.csdn.net/weixin_69902486/article/details/142165669

版权

C语言专栏收录该内容

27 篇文章 2 订阅

订阅专栏

联合体（共同体）基本概念

联合体的外在形式跟结构体非常类似，但它们有一个本质的区别：结构体中的各个成员是各自独立的内存空间，而联合体中的各个成员却共用同一块内存，因此联合体也称为共用体。

联合体各成员的堆叠效果

联合体内部成员的这种特殊的“堆叠”效果，使得联合体有如下基本特征：

整个联合体变量的尺寸，取决于联合体中尺寸最大的成员。
给联合体的某个成员赋值，会覆盖其他的成员，使它们失效。
联合体各成员之间形成一种“互斥”的逻辑，在某个时刻只有一个成员有效。

联合体的定义：

union 联合体标签
{
    成员1;
    成员2;
    ...
};

语法：
- 联合体标签，用来区分各个不同的联合体。
- 成员，是包含在联合体内部的数据，可以是任意的数据类型。

// 定义了一种称为 union attr 的联合体类型
union attr
{
    int x;
    char y;
    double z;  
};

int main()
{
    // 定义联合体变量
    union attr n;
}

联合体操作

联合体的操作跟结构体形式上别无二致，但由于联合体特殊的存储特性，不管怎么初始化和赋值，最终都有且仅有一个成员是有效的。

初始化：

// 普通初始化：第一个成员有效（与数组类似，后面的值会被编译器直接优化）
union attr at = {100, 'k', 3.14};

// 指定成员初始化：最后一个成员有效（即只有3.14是有效的，其余成员会被覆盖）
union attr at = {
                .x  = 100,
                .y = 'k',
                .z = 3.14,
};

成员引用：

at.x = 100;
at.y = 'k';
at.z = 3.14; // 只有最后一个赋值的成员有效

printf("%d\n", at.x);
printf("%c\n", at.y);
printf("%lf\n", at.z);

联合体指针：

union attr *p = &at;
p->x = 100;
p->y = 'k';
p->z = 3.14;  // 只有最后一个赋值的成员有效

printf("%d\n", p->x);
printf("%c\n", p->y);
printf("%lf\n", p->z);

联合体的使用

联合体一般很少单独使用，而经常以结构体的成员形式存在（联合体被嵌套在结构体内部作为一个成员），用来表达某种互斥的属性。

示例：

struct node
{
    int a;
    char b;
    double c;
    union attr at; // at内有三种互斥的属性，非此即彼
};

int main()
{
    struct node n;
    n.at.x = 100; // 使用连续的成员引用符来索引结构体中的联合体成员
}

示例：

#include <stdio.h>

typedef struct Personnel
{
    char Name [32];
    int Num ;

    char  Role ; // S 学生  T 教师  A 饭堂阿姨  B 保安

    union 
    {
        char Profession[32] ; // 用于描述学生的专业
        char Grade ; // 用于描述老师的等级
        float Jitter ; // 用于描述阿姨的手抖系数
        int Defense ; // 用于描述保安的防御力
    }Attr;
    
}DataType_t;


int main(int argc, char const *argv[])
{
    
    DataType_t Even = {
        .Name = "Even",
        .Num = 96 ,
        .Role = 'T',
        .Attr.Grade = 'S'
    };

    DataType_t ErDaYe = {
        .Name = "ErDaYe",
        .Num = 3 ,
        .Role = 'B' ,
        .Attr.Defense = 0 
    };

    DataType_t DaShiXiong = {
        .Name = "DaShiXiong",
        .Num = 147 ,
        .Role = 'S' ,
        .Attr.Profession = "水道清理专业" 
    };


    DataType_t  arr [3] = 
    {
        {
        .Name = "Even",
        .Num = 96 ,
        .Role = 'T',
        .Attr.Grade = 'S'
        },

        {
        .Name = "ErDaYe",
        .Num = 3 ,
        .Role = 'B' ,
        .Attr.Defense = 0 
        },

        {
        .Name = "DaShiXiong",
        .Num = 147 ,
        .Role = 'S' ,
        .Attr.Profession = "水道清理专业" 
        }
    };

    for (int i = 0; i < 3; i++)
    {
       printf("Name:%s Num:%d Role:%c " , arr[i].Name , arr[i].Num , arr[i].Role);

       switch (arr[i].Role)
       {
        case 'T':
            printf("Grade:%c\n" , arr[i].Attr.Grade);
            break;
        
        case 'A':
            printf("Jitter:%f\n" , arr[i].Attr.Jitter);

            break;
        
        case 'S':
            printf("Profession:%s\n" , arr[i].Attr.Profession);
            break;
        
         case 'B':
            printf("Defense:%d\n" , arr[i].Attr.Defense);
            break;

        default:
            break;
       }

    }
    



    
    return 0;
}

补充知识点：

字节序

如何检测机器的字节序：

#include <stdio.h>

typedef union data
{
    int Num ;
    char c ;
}DataType_t;


int main(int argc, char const *argv[])
{
    // 方法一使用联合体
    DataType_t Data = {
        .Num = 0x12345678
    };

    printf("Data.c : %x\n" , Data.c );

    if (Data.c == 0x78)
    {
        printf("当前为小端序设别...\n");
    }
    else{
        printf("当前为大端序设别...\n");
    }
    
    // 方法二 使用指针直接访问判断字节序
    int Num = 0x12345678;
    char *p = &Num ;
    printf("*p: %x\n" , *p);
    
    return 0;
}

枚举

枚举是 C 语言中的一种基本数据类型，用于定义一组具有离散值的常量，它可以让数据更简洁，更易读。

定义一个枚举类型，需要使用 enum 关键字，后面跟着枚举类型的名称，以及用大括号括起来的一组枚举常。

每个枚举常量可以用一个标识符来表示，也可以为它们指定一个整数值，如果没有指定，那么默认从0开始递增。

枚举类型的本质是提供一种范围受限的整型（使用一个单词替代整型），比如用0-6表示七种颜色，用0-3表示四种状态等，但枚举在C语言中并未实现其本来应有的效果，直到C++环境下枚举才拥有原本该有的属性。

枚举常量列表
- enum是关键字
- spectrum是枚举常量列表标签，可以省略。省略的情况下无法定义枚举变量

枚举常量列表声明语句：
enum   标签   { 常量1 , 常量2 , 常量3 , ....... , 常量N };//枚举常量后加逗号，大括号后;
enum spectrum{ red, orange, yellow , green, blue, cyan, purple};
enum         { reset, running, sleep, stop};

枚举变量

enum spectrum color = orange; // 等价于 color = 1

语法要点：
- 枚举常量实质上就是整型常量，首个枚举常量默认为0。
- 枚举常量在定义时可以赋值，若不赋值，则取其前面的枚举常量的值加1。
- C语言中，枚举等价于整型，支持整型常量数据的一切操作。

使用举例：

switch(color)
{
    case red:
        // 处理红色...
    case orange:
        // 处理橙色...
    case yellow:
        // 处理黄色...   
}

枚举数据最重要的作用，是使用有意义的单词，来替代无意义的数字，提高程序的可读性

#include <stdio.h>


// 枚举列表声明
enum Stat { Running , Stop , Close , Sleep };


int getStat()
{
    // 假设访问设备进行获取当前的工作状态

    // 返回实际状态
    return Stop ;
}


int main(int argc, char const *argv[])
{
    

    int stat_Ele = getStat();

    switch (stat_Ele)
    {
        case Running:
            printf("电机正在疯狂运转....\n");
            break;
        
        case Stop:
            printf("电机正在停止运转....\n");
            break;
        
        case Sleep:
            printf("电机正在睡眠....\n");
            break;
        
        case Close:
            printf("电机正在疯狂关闭....\n");
            break;
        
        default:
            break;
    }
    

    return 0;
}