巧用联合与枚举:解锁自定义类型的无限潜力

夜雨声烦1413

发布于 2026-01-12 16:02:52

850

嘿嘿,家人们,今天咱们来详细剖析C语言中的联合与枚举,好啦,废话不多讲,开干!

1.:联合体

1.1:联合体类型的声明

联合体像结构体一样,联合体也是由一个或多个成员构成,这些成员可以是不同的类型.但是编译器只能为最大的成员分配足够的内存空间.联合体的特点是所有成员共用一块内存空间,所以联合体也叫:共同体.

1.1.1:代码1

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

union Un
{
	char _c;
	int _i;
};

int main()
{
	//联合变量的定义
	union Un  u1 = {'c'};
	return 0;
}

1.1.2:代码2(计算机联合体的大小)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

union Un
{
	char _c;
	int _i;
};

int main()
{
	//联合变量的定义
	union Un  u1 = {'c'};

	printf("%d\n", sizeof(u1));
	return 0;
}

在结构体那一章节,博主讲到了,结构体的大小要遵循内存对齐的规则,那么联合体要不要遵从内存对齐的规则,如果遵从的话,上面的代码计算出来的结果是8(原因博主不过多解释哈,忘了滴uu可以去去博主那篇结构体的博客).

1.1.3:代码3

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

union Un
{
	char _c;
	double _i;
};

int main()
{
	//联合变量的定义
	union Un  u1 = {'c'};

	printf("%d\n", sizeof(u1));
	return 0;
}

上面的两段代码输出结果是4与8,那么为什么是4与8呢?这里就要讲到联合体的特点了

1.2:联合体的特点

联合体的成员是共用一块内存空间的,这样一个联合体变量的大小,至少是最大成员的大小(因为联合体至少得有能力保存最大的那个成员),而上面的代码中最大成员int类型,因此结果为4

1.2.1:代码1

#include <stdio.h>
int main()

union Un
{
    char _c;
    int _i;
};
{
    union Un u1 = {0};
    printf("&u1._c == %p\n",&u1._c);
    printf("&u1._i == %p\n",&u1._i);
    printf("&u1 == %p\n",&u1);
    return 0;    
}

上面的代码输出的三个均是一模一样,那么我们仔细便可以画图u1的内存分布图.

1.2.2:代码2

#include <stdio.h>
int main()

union Un
{
    char _c;
    int _i;
};
{
    union Un u1 = { 0 };
    u1._i = 0x11223344;
    u1._c = 0x55;
    printf("%x\n", u1._i);
    return 0;
}

通过上面的代码我们可以分析出,将变量i的第4个字节改成了55,那么因此我们可以画出其对应的内存分布图.

1.3:相同成员的结构体与联合体进行对比

我们再来对比一下,相同成员的结构体与联合体的内存布局情况.

1.3.1:代码1(结构体)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

struct S
{
	char _c;
	int _i;
};

int main()
{
	struct S s1 ={'c'};
	return 0;
}

1.3.2:代码2(联合体)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

union Un
{
	char _c;
	int _i;
};

int main()
{
	union Un u = {0};
	return 0;
}

1.4:联合体大小的计算

联合体的大小至少为最大成员的大小.
当最大成员不是最大对齐数的整数倍的时候,就要对齐到最大对齐数的整数倍.

1.4.1:代码1

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

union Un1
{
	char c[5];
	int _i;
};

int main()
{
	printf("Un1的大小为:> %zd\n", sizeof(union Un1));
	return 0;
}

1.4.2:代码2

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

union Un2
{
	short s[5];
	int _i;
};

int main()
{
	printf("Un2的大小为:> %zd\n", sizeof(union Un2));
	return 0;
}

1.4.3:联合体的优点

使用联合体是可以节省空间的,例如: 我们要搞一个活动,要上线一个礼品兑换单,礼品兑换单中有三种商品： 图书、杯子、衬衫 . 每一种商品都有: 库存量、价格、商品类型和商品类型相关的其他信息.

图书:设计、书名、作者、页数.
杯子:设计、品牌.
衬衫:设计、颜色、尺寸、品牌

如果我们使用结构体来描述的话,将会是如下代码

1.4.3.1:结构体描述

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
struct Gift_List
{
	//库存量
	int _Inventory;
	//价格
	double _Price;
	//商品类型
	int Type_Of_Merchandise;

	//书的特殊属性
	char _Name[20];
	//书的作者
	char _Author[20];
	//书的页数
	int _Pages;

	//衬衫的颜色
	char _Color[20];
	//衬衫的尺寸
	int _Sizes;

	//三者的设计
	char _Desigin[20];
	//三者的品牌
	char _Brand[20];
};

int main()
{
	printf("%zd\n", sizeof(struct Gift_List));
	return 0;
}

上面的结构其实设计的很简单，用起来也方便，但是结构的设计中包含了所有礼品的各种属性，这样使得结构体的大小就会偏大,比较浪费内存.因为对于礼品兑换单中的商品来说，只有部分属性信息是常用的.
比如:商品是图书,就不需要_Design、_Color、_Sizes.
所以可以把公共属性单独写出来，剩余属于各种商品本身的属性使用联合体保存起来，这样就可以节省所需的内存空间,一定程度上节省了内存。

1.4.3.2:使用联合体描述

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
struct Gift_List
{
	//库存量
	int _Inventory;
	//价格
	double _Price;
	//商品类型
	int Type_Of_Merchandise;
	//三者的设计
	char _Desigin[20];
	//三者的品牌
	char _Brand[20];
	union
	{
		struct Book
		{
			//书的特殊属性
			char _Name[20];
			//书的作者
			char _Author[20];
			//书的页数
			int _Pages;
		};
		struct Shirt
		{
			//衬衫的颜色
			char _Color[20];
			//衬衫的尺寸
			int _Sizes;
		};
	};
};

int main()
{
	printf("Gift_List(嵌套联合体):>%zd\n", sizeof(struct Gift_List));
	return 0;
}

通过对比二者,我们可以清晰地发现,使用联合体可以大大地减少内存空间的占用.

1.5:联合的一个练习

在数据类型在内存的存储方式那篇博客中,我们讲到了大小端的概念.

大端:地址低位存放着数值高位,地址高位存放着数值低位.
小端:地址低位存放着数值低位,地址高位存放着数值高位.

在那里我们通过拿到数值1的最低位并且按位与1来判断来判断程序的大小端

1.5.1:(通过拿数值1的最低位并且按位与1)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
int check_sys()
{
	int value = 1;
	return (*(char*)&value & 1);
}
int main()
{
	int result = check_sys();
	if(result == 0)
	{
		printf("大端存储\n");
	}
	else
	{
		printf("小端存储\n");
	}
 
}

1.5.2:代码2(通过联合体)

除了上面的方式,我们也可以通过联合体的方式来进行求解,联合体的特点是

联合体的成员是共用一块内存空间的,这样一个联合体变量的大小,至少是最大成员的大小(因为联合体至少得有能力保存最大的那个成员).

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int Check_sys()
{
	union
	{
		int _i;
		char _c;
	}un;
	un._i = 1;
	return un._c;
}

int main()
{
	int result = Check_sys();
	if (result == 0)
	{
		printf("大端存储\n");
	}
	else
	{
		printf("小端存储\n");
	}

}

2:枚举类型

2.1:枚举类型的声明

枚举顾名思义就是⼀⼀列举, 把可能的取值⼀⼀列举, 比如我们现实生活中:

⼀周的星期一到星期日是有限的7天，可以⼀⼀列举.
性别有:男、女、保密，也可以⼀⼀列举.
月份有12个月，也可以一一列举.
三原色，也是可以意义列举.

2.1.1:代码1

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>


//星期
enum Day
{
	Monday,
	Tuesday,
	Wednesday,
	Thursday,
	Friday,
	Saturday,
	Sunday
};

//性别
enum Sex
{
	Boy,
	Girl,
	Other
};

//颜色
enum Color
{
	Red,
	Green,
	Blue
};

int main()
{
	printf("Day:Monday> %d\n", Monday);
	printf("Sex:Girl> %d\n", Girl);
	printf("Color:Blue> %d\n", Blue);
	return 0;
}

以上定义的 enum Day,enum Sex,enum Color 都是枚举类型.
{}中的内容以,为分隔符,枚举类型的可以取值,也叫枚举常量.
这些可能取值都是有值的，默认从0开始，依次递增1，当然在声明枚举类型的时候也可以赋初值.

2.1.2:代码2(给枚举类型赋初值)

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>


//星期
enum Day
{
	Monday = 1,
	Tuesday,
	Wednesday,
	Thursday,
	Friday,
	Saturday,
	Sunday
};

//性别
enum Sex
{
	Boy = 5,
	Girl,
	Other
};

//颜色
enum Color
{
	Red,
	Green,
	Blue = 2
};

int main()
{
	printf("Day:Monday> %d\n", Monday);
	printf("Sex:Girl> %d\n", Girl);
	printf("Color:Blue> %d\n", Blue);
	return 0;
}

2.2:枚举类型的优点

我们可以使用#define定义常量,但是为什么非要使用枚举呢

枚举可以增加代码的可读性与可维护性.
和#define定义的标识符比较枚举有类型检查,更加严谨.
便于调试,预处理阶段会删除#define定义的符号.
使用方便,一次可以定义多个变量.
枚举常量是遵循作用域规则的,枚举声明在函数内,只能在函数内部使用.

2.3:枚举类型的使用

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>



//性别
enum Sex
{
	Boy = 5,
	Girl,
	Other
};


int main()
{
	enum Sex Tom = Boy;
	printf("%d\n", Tom);
	return 0;
}

那是否可以拿整数给枚举变量赋值呢？在C语言中是可以的，但是在C++是不行的，C++的类型检查比较较严格。

3:柔性数组

也许大部分uu没有听说柔性数组的概念,但是她确实是存在滴,在C99中,结构中的最后一个元素允许是未知大小的数组,这就叫做柔性数组成员.

3.1:代码1

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

typedef struct Flexible_Array
{
	int _i;
	//柔性数组成员,最后一个元素时未知大小的数组,在[]中填0表示数组的大小是未知的
	int a[0];
}type_a;

3.2:代码2

对于代码1,有些编译器可能会报错导致无法编译,因此将a[0]中的0去掉.

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

typedef struct Flexible_Array
{
	int _i;
	//柔性数组成员,最后一个元素时未知大小的数组
	int a[];
}type_a;

3.3:柔性数组的特点

结构中的柔性数组成员前面必须至少一个其他成员.
sizeof返回包含柔性数组的结构体不包括柔性数组的内容.
包含柔性数组成员的结构用malloc()函数进行内存的动态分配,并且分配的内存应该大于结构的大小,以适应柔性数组的预期大小.

3.3.1:代码1

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

typedef struct Flexible_Array
{
	double _i;
	//柔性数组成员,最后一个元素时未知大小的数组,在[]中填0表示数组的大小是未知的
	int a[];
}type_a;

int main()
{

	printf("%zd\n",sizeof(type_a));
	return 0;
}

3.4:柔性数组的使用

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

typedef struct Flexible_Array
{
	int _i;
	//柔性数组成员,最后一个元素时未知大小的数组,在[]中填0表示数组的大小是未知的
	int a[];
}type_a;

int main()
{
	int i = 0;
	type_a* p = (type_a*)malloc(sizeof(type_a) + 100 * sizeof(int));

	for (i = 0; i < 100; i++)
	{
		p->a[i] = i;
	}
	free(p);
	return 0;
}

柔性数组a[]虽然在编译的时候没有固定大小,但是在运行时通过malloc分配了额外的内存,这部分内存与结构体的其他成员是在一起连续分配的,由于malloc分配了这部分内存，并且在结构体中按需访问这些元素是安全的因此柔性数组成员a[]能够通过动态分配获得 100 个整型元素的连续空间.

3.5:柔性数组的特点

3.5.1:代码1

上述的type_a结构也可以设计为下面的结构,也能完成同样的效果.

#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

typedef struct Flexible_Array
{
	int _i;

	int * pa;
}type_a;

int main()
{
	int i = 0;
	type_a * p = (type_a *)malloc(sizeof(type_a) + 100 * sizeof(int));
	p->_i = 100;
	p->pa = (int *)malloc(sizeof(int) * p->_i);

	//进行赋值
	for(i=0; i<100; i++)
	{
		p->pa[i] = i;
	}
	//先释放内部
	free(p->pa);
	p->pa = NULL;
	//再释放外部
	free(p);
	p = NULL;
	return 0; 
}