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

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

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

联合体各成员的堆叠效果

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

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

联合体的定义：

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;
}

结语：

        在本篇博客中，我们详细探讨了 C 语言中的联合体和枚举这两个重要的数据结构。联合体作为一种灵活的数据类型，允许我们在同一内存位置存储不同类型的数据，从而有效地节省内存空间。同时，我们也讨论了如何通过联合体来实现更复杂的数据结构，如链表或树等。

        枚举类型则为我们提供了一种方便的方式来定义一组具有命名常数的整型值。通过使用枚举，可以提高代码的可读性和可维护性，避免魔法数字的使用。同时，使用枚举还可以增强代码的类型安全性，减少潜在的错误。

        掌握联合体和枚举的使用不仅能提升我们的编程技能，还能帮助我们在面对复杂数据时做出更合理的设计和实现。希望您能将这些知识应用于以后的编程实践中，创造出更高效、清晰的代码。