C语言中联合体与共用体和枚举使用语法示例

目录

• 联合体/共用体-union
• 枚举-enum

联合体/共用体-union

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

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

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

typedef union Integer{
int a;
short b;
char c;
} lnteger_t;

定义联合体类型的变量

联合体别名_t 普通联合体变量名;

联合体别名_t * 联合体指针变量名;

联合体中的成员的初始化(一般只对某个成员初始化，并使用)

普通联合体变量名.成员变量名 = 初始值;

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

访问联合体中的成员

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

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

#include 
#include 
// 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 
// 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

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

什么是枚举类型？
枚举类型是一个基本类型，不属于构造类型，枚举中的成员是一个常量，默认第一个成员的

对应的常量值为0.

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

枚举类型的别名_t 变量名 = 枚举类型中的成员名;

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

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

#include 
// 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;
}

到此这篇关于C语言中联合体与共用体和枚举使用语法示例的文章就介绍到这了,更多相关C语言联合体与共用体和枚举内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！