联合体和枚举

news2024/11/17 22:31:43

联合体：

联合体是什么？

联合体也是一种自定义类型，这种类型定义的变量也包含一系列类型，特征是这些类型公用一块内存空间(所以叫联合体也叫公用体)可以理解为结构体公用一块内存。

//联合-联合体-共用体
//联合也是一种特殊的自定义类型,这种类型定义的变量包含一系列的成员
union Un
{
    char c;
    int i;
};
//
int main()
{
    union Un u;
    printf("%d\n", sizeof(u));

    printf("%p\n", &u);

    printf("%p\n", &(u.c));
    printf("%p\n", &(u.i));
    
    return 0;
}

联合的成员是共用同一块内存空间的，这样一个联合变量的大小至少是最大成员的大小(因为联合至少得有能力保存最大的那个成员)。联合体最好不要改动其中成员的值，因为改动一个另外也会跟着改，因为它们共用一块内存一块空间。

联合体的大小：

联合体至少也是最大类型的整数倍。

union Un
{
    int a;//4
    char arr[5];//5  1相当于你写了5个char
    //5不是4的整数倍,对齐后是8
};//联合体大小的计算
//联合体的大小至少是成员的大小
//当最大成员大小不是最大对齐数的整数倍时,就要对齐到最大对齐数的整数倍
int main()
{
    union Un u;
    printf("%d\n", sizeof(u));
    return 0;
}

char arr[5];相当于5个char类型，之后又追加了int，已经超过了4个字节，目前最宽字节为4，加起来一共是9字节，因为这是联合体类型，它们会共用内存。可是联合体有自己的对齐规则，如果超过了里面最大数据类型，就会对齐最大类型的的整数倍。所以这个结果是8。

我们再来看一个例子：

union Un
{
    char a[5];
    char b[2];
}u;
int main()
{
    printf("%d\n", sizeof(u));
    return 0;
}

联合体的应用：

我们用联合体判断当前系统是小端存储还是大端存储。


//int check_sys()
//{
//    int a = 1;
//    return *(char*)&a;
//}
int check_sys()
{
    union
    {
        char c;
        int i;
    }u;//匿名联合体类型,用一次以后不再用
    u.i = 1;
    //返回1 小端
    //返回0 大端
    return u.c;
}
int main()
{

    //int a = 1;
    int ret = check_sys();
    //if (1 == *(char*)&a)
    //{
    //    printf("小端\n");
    //}
    //else
    //{
    //    printf("大端\n");
    //}
    if (ret == 1)
    {
        printf("小端\n");
    }
    else
    {
        printf("大端\n");
    }
    //int a = 0x11223344;
    //低地址------------->高地址
    //...[][11][22][33][44][][]...大端字节序存储模式
    //...[][44][33][22][11][][]...小端字节序存储模式
    //讨论一个数据放在内存中存放的字节顺序
    //大小端字节序问题
    return 0;
}

我们来看另外一种用法：

union U
{
	int n;//4
	struct S
	{
		char c1;
		char c2;
		char c3;
		char c4;
	}s;//4
};

int main()
{
	//int n = 0x11223344;
	//4个字节
	//用联合体实现
	union U u = { 0 };
	u.n = 0x11223344;
	printf("%x %x %x %x\n", u.s.c1, u.s.c2, u.s.c3, u.s.c4);
	return 0;
}

其实还用一种实际的用途，比如一个公司搞活动，上线一个礼品兑换单，礼品兑换单中有三种商品：图书、被子、衬衫。

每一种商品都有：库存量、价格、商品类型和商品类型的相关信息。

图书：书名、作者、页数
杯子：设计
衬衫：设计、可选颜色、可选尺寸

如果我们直接使用结构体写出一下形式：

struct gift_list
{
	//这是每一个商品的共同属性
	int stock_number;//库存量
	double price;//定价
	int item_type;//商品类型

	//特殊属性
	char title[20];//书名
	char author[20];//作者
	int num_pages;//页数

	char design[30];//设计
	int colors;//颜色
	int sizes;//尺寸
};

这样创建一个结构体但是一个礼品单只能兑换一个商品，只用一个商品有一些属性就会空闲着，这样势必会造成空间的浪费。此时就可以使用联合体：

struct gift_list
{
	//这是每一个商品的共同属性
	int stock_number;//库存量
	double price;//定价
	int item_type;//商品类型

	//之后就是指定一个商品
	union un 
	{
		struct
		{
			char title[20];//书名
			char author[20];//作者
			int num_pages;//页数
		}book;
		struct
		{
			char design[30];//设计
		}mug;
		struct
		{
			char design[30];//设计
			int colors;//颜色
			int sizes;//尺寸
		}shirt;
	}item;
};

此时兑换一个礼品，就开辟对应的空间，即可对空间进行合理的使用。

枚举：

什么是枚举：

枚举和define很像。顾名思义就是列举。因为现实生活中，总有一些东西是可以被一一列举的，比如星期，月份等。

//枚举的关键字
enum Sex
{
	//这里列举枚举enum Sex的可能取值
	MALE,
	FEMALE,
	SECRET
};

int main()
{
	printf("%d\n", MALE);
	printf("%d\n", FEMALE);
	printf("%d\n", SECRET);
	return 0;
}

{}中的内容是枚举类型中可能取的值，也叫枚举常量。打印出出的是常数，这些可能取值都是有值的，默认从0开始，依次增加1，当然定义的时候也可以赋初值。

枚举的使用：

我们也可以对其进行赋值：

//枚举类型
enum Sex
{
    //枚举的可能取值-常量
    MALE=9,
    FEMALE,
    SECRET
};
enum Color
{
    RED,
    GREEN=3,
    BLUE
};
int main()
{
    enum Sex s = MALE;
    enum Color c = BLUE;
    //只能拿枚举的变量来对这个变量进行赋值
    printf("%d %d %d\n", MALE, FEMALE, SECRET);
    printf("%d %d %d\n", RED, GREEN, BLUE);
    return 0;
}

我们也可以对其逐个赋值：

//枚举的关键字
enum Sex
{
	//这里列举枚举enum Sex的可能取值
	MALE = 5,
	FEMALE = 8,
	SECRET = 10
};

int main()
{
	printf("%d\n", MALE);
	printf("%d\n", FEMALE);
	printf("%d\n", SECRET);
	return 0;
}