【C进阶】之联合体与共用体和枚举

联合体/共用体 —> union

1. 声明联合体的语法格式
   typedef union 联合体名 {
   数据类型 成员名1;
   数据类型 成员名2;
   …
   } 联合体别名_t;

   此时可以使用“union 联合体名”或者“联合体别名_t”定义联合体类型的变量。

2. 什么是联合体
   联合体属于构造类型，联合体中可以包含不同的数据类型的成员，联合体中的所有的成员共用同一块内存空间，
   联合体类型的大小和联合体中最大的成员的大小一致。

3. 定义联合体类型的变量
   联合体别名_t 普通联合体变量名;
   联合体别名_t * 联合体指针变量名;

4. 联合体中的成员的初始化(一般只对某个成员初始化，并使用)
   普通联合体变量名.成员变量名 = 初始值;

   联合体指针变量名->成员变量名 = 初始值;

5. 访问联合体中的成员
   普通联合体变量名.成员变量名; // 普通的联合体类型的变量使用“.”访问联合体中的成员
   联合体指针变量名->成员变量名; // 联合体指针类型的变量使用“->”访问联合体中的成员

#include <stdio.h>
#include <stdlib.h>
// 1. 声明联合体类型
typedef union  Integer
{
    unsigned int a;
    unsigned short b;
    unsigned char c;
}Integer_t;



int main(int argc, const char *argv[])
{
    /*your code*/
    // 1. 定义普通联合体类型的变量
    Integer_t i1;
    // 2. 对联合体中的成员a进行初始化
    i1.a = 0x12345678;

    // 3. 打印联合体中成员的地址以及成员中对应的值，验证成员是否共用同一块内存空间
    printf("i1 address = %p\n", &i1);
    printf("i1.a address = %p i1.a value = %#x\n", &i1.a, i1.a);
    printf("i1.b address = %p i1.b value = %#x\n", &i1.b, i1.b);
    printf("i1.c address = %p i1.c value = %#x\n", &i1.c, i1.c);

    // 4. 联合体类型的大小
    printf("i1 union type size = %ld\n", sizeof(Integer_t));

    

    // 1. 定义联合体类型的指针变量
    Integer_t *i2_p = (Integer_t *)malloc(sizeof(Integer_t));
    if (i2_p == NULL)
    {
        printf("malloc failed\n");
        return -1;
    }
    // 2. 初始化联合体指针变量指向的堆区空间
    i2_p->a = 0x12345679;

    // 3. 打印联合体中成员的地址以及成员中对应的值，验证成员是否共用同一块内存空间
    printf("i2_p address = %p\n", &i2_p);
    printf("i2_p->a address = %p i2_p->a value = %#x\n", &i2_p->a, i2_p->a);
    printf("i2_p->b address = %p i2_p->b value = %#x\n", &i2_p->b, i2_p->b);
    printf("i2_p->c address = %p i2_p->c value = %#x\n", &i2_p->c, i2_p->c);

    free(i2_p);
    i2_p = NULL;

    return 0;
}

练习题：使用联合体验证大小端

typedef union little{
 unsigned int x;
 unsigned char y[4];
}little_t;

定义联合体类型的变量，并对x成员进行初始化为0x12345678，
打印y这个字符数组的每个元素的值及元素对应的地址。
    
#include <stdio.h>
// 1. 声明联合体类型
typedef union little{
 unsigned int x;
 unsigned char y[4];
}little_t;

int main(int argc, const char *argv[])
{
    /*your code*/
    int i;
    // 2. 定义联合体类型的变量
    little_t l;
    // 3. 对联合体类型中的成员进行初始化
    l.x = 0x12345678;
    // 4. 访问联合体中的成员
    for (i = 0; i < 4; i++)
    {
        printf("&l.y[%d] = %p l.y[%d] = %#x\n", i, &l.y[i], i, l.y[i]);
    }

    return 0;
}

枚举 —> enum

1. 声明枚举类型的格式
   typedef enum 枚举类型名{
   成员名0,
   成员名1,
   成员名2,
   …
   } 枚举类型的别名_t;

2. 什么是枚举类型？
   枚举类型是一个基本类型，不属于构造类型，枚举中的成员是一个常量，默认第一个成员的对应的常量值为0.

3. 枚举中的成员的使用
   1> 枚举类型中的成员可以直接使用，不需要定义枚举类型的变量，就当成一个常量使用。
   2> 定义枚举类型的变量，必须使用枚举类型中的成员对枚举类型的变量进行初始化
   枚举类型的别名_t 变量名 = 枚举类型中的成员名;

4. 枚举类型作为函数的参数或者返回值

5. 枚举类型的成员是一个常量，如果使用的是宏定义定义的常量，可以使用枚举替换。

#include <stdio.h>
// 1. 声明枚举类型
typedef enum number{
    ZERO,   // 0   // 默认枚举中的成员对应的值从0开始
    ONE,    // 1
    TWO,    // 2
    THREE,  // 3
    FORE,   // 4
    FIVE,   // 5
} number_t;

// 对枚举中的成员进行初始化为一个常量
typedef enum number1{
    ZERO0,   // 0   // 默认枚举中的成员对应的值从0开始
    ONE1,    // 1
    TWO2,    // 2
    FIVE5 = 5,   // 5
    SIX6,    // 6    // 后边成员的值是在前一个成员的值的基础之上加1
    SEVEN7,  // 7
    EIGHT8,  // 8
    NINE9,   // 9
    TEN10,    // 10
} number1_t;

number_t getValue(number_t num)
{
    switch (num) 
    {
        case ZERO:
            printf("ZERO\n");
            break;
        case ONE:
            printf("ONE\n");
            break;
        case TWO:
            printf("TWO\n");
            break;
        case THREE:
            printf("THREE\n");
            break;
        case FORE:
            printf("FORE\n");
            break;
        case FIVE:
            printf("FIVE\n");
            break;
    }

    return num;
}


int main(int argc, const char *argv[])
{
    /*your code*/
    // 2. 枚举中的成员可以直接使用，当成一个常量使用即可
    printf("ONE = %d\n", ONE);

    // 3. 定义枚举类型的变量，使用枚举中的成员进行初始化
    number_t num = THREE;
    printf("num = %d\n", num);


    printf("FIVE5 = %d\n", FIVE5);
    printf("TEN10 = %d\n", TEN10);

    number_t num1 = getValue(ONE);
    printf("num1 = %d\n", num1);
    return 0;
}