【C进阶】自定义类型（结构体，枚举，联合）

本文链接：https://blog.csdn.net/weixin_61543874/article/details/122275807

结构体

结构体的概念

结构体是由一批数据组合而成的结构型数据。组成结构型数据的每个数据称为结构型数据的“成员”，其描述了一块内存区间的大小及解释意义.

结构体的声明

struct tag
{
	member-list;//成员列表
}variable-list; //变量列表

例如我们描述一个学生

struct Stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//性别
	char id[20];//学号
}; //分号不能丢

特殊的声明

匿名结构体类型，没有名字的函数，随着定义的时候直接调用

struct
{
	int a;
	char b;
	float c;
}x;
struct
{
	int a;
	char b;
	float c;
}a[20], *p;

我们在声明时省略掉了结构体标签
注：p = &x，这个时非法的，编译器会把上面的两个声明当成完全不同的两个类型

结构体的自引用

在结构中包含一个类型为该结构本身的成员

struct Node
{
	int data;
	struct Node* next;
};

typedef结构体后，不可以用重命名后的名字初始化next

typedef struct Node
{
	int data;
	struct Node* next;
}Node;

结构体变量的定义和初始化

struct Point
{
	int x;
	int y;
}p1; //声明类型的同时定义变量p1
struct Point p2; //定义结构体变量p2
//初始化：定义变量的同时赋初值。
struct Point p3 = {x, y};

struct Stu //类型声明
{
	char name[15];//名字
	int age; //年龄
};
struct Stu s = {"zhangsan", 20};//初始化
struct Node
{
	int data;
	struct Point p;
	struct Node* next;
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

结构体内存对齐

结构体的对齐规则：

第一个成员在与结构体变量偏移量为0的地址处。
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。
VS中默认的值为8
结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

根据结构体对齐规则我们来计算下面结构体的大小(注:本人编译器为VS2019)

struct S1
{
	char c1;//1
	int i;//4
	char c2;//1
};//12

struct S2
{
	char c1;//1
	char c2;//1
	int i;//4
};//8

struct S3
{
	double d;//8
	char c;//1
	int i;//4
};//16

struct S4
{
	char c1;//1
	struct S3 s3;//16
	double d;//8
};//32

int main()
{
	printf("%d\n", sizeof(struct S1));//12
	printf("%d\n", sizeof(struct S2));//8
	printf("%d\n", sizeof(struct S3));//16
	printf("%d\n", sizeof(struct S4));//32
	//offsetof可以计算结构体中某变量相对于首地址的偏移，头文件是#include <stddef.h>
	printf("%d\n", offsetof(struct S1, c1));
	printf("%d\n", offsetof(struct S1, i));
	printf("%d\n", offsetof(struct S1, c2));

	return 0;
}

在这里插入图片描述

为什么存在内存对齐?

平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问

结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到->让占用空间小的成员尽量集中在一起。

修改默认对齐数

#pragma 这个预处理指令,可以改变我们的默认对齐数

#include <stdio.h>
#pragma pack(8)//设置默认对齐数为8
struct S1
{
	char c1;
	int i;
	char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认

位段

位段的概念

C语言允许在一个结构体中以位为单位来指定其成员所占内存长度，这种以位为单位的成员称为“位段”或称“位域”( bit field) 。利用位段能够用较少的位数存储数据。

位段的使用

位段成员的类型必须指定为unsigned或int类型。
.位段的成员名后边有一个冒号和一个数字。

struct S
{
	//char类型，先给1byte
	char a : 3;//用了3bit，剩余5bit
	char b : 4;//剩1bit
	char c : 5;//重新分配1byte，剩3bit
	char d : 4;//重新分配1byte，剩4bit
};
int main()
{
	struct S s = { 0 };
	s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;
	return 0;
}

那么sizeof(struct A)的大小为多少呢？这里我们就要知道位段的内存分配

位段的成员可以是 int unsigned int signed int 或者是 char (属于整形家族）类型
位段的空间上是按照需要以4个字节(int )或者1个字节(char)的方式来开辟的。
位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段

若某一位段要从另一个字开始存放，可用以下形式定义：

struct
{
	unsigned a：1；
	unsigned　b：2；一个存储单元
	unsigned：0；
	unsigned　c：3；另一存储单元
};

a、b、c应连续存放在一个存储单元中，由于用了长度为0的位段，其作用是使下一个位段从下一个存储单元开始存放。因此，只将a、b存储在一个存储单元中，c另存在下一个单元(“存储单元”可能是一个字节，也可能是2个字节，视不同的编译系统而异）

枚举

枚举的概念

在数学和计算机科学理论中，一个集的枚举是列出某些有穷序列集的所有成员的程序，或者是一种特定类型对象的计数。

比如：
一周的星期一到星期日是有限的7天，可以一一列举
性别有：男、女、保密，也可以一一列举
月份有12个月，也可以一一列举

枚举类型的定义

enum Day//星期
{
	Mon,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun
};
enum Sex//性别
{
	MALE,
	FEMALE,
	SECRET
}；
enum Color//颜色
{
	RED,
	GREEN,
	BLUE
};

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

enum Color//颜色
{
	RED=1,
	GREEN=2,
	BLUE=4
};

枚举的优点

增加代码的可读性和可维护性
和#define定义的标识符比较枚举有类型检查，更加严谨。
防止了命名污染（封装）
便于调试
使用方便，一次可以定义多个常量

枚举的使用

enum Color//颜色
{
	RED=1,
	GREEN=2,
	BLUE=4
};
	enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
	clr = 5; //不能直接把int类型直接赋值，因为类型不同

联合（共用体）

联合类型的定义

联合也是一种特殊的自定义类型
这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以联合也叫共用体）。

union Un
{
	char c;//1
	int i;//4
};

int main()
{
	union Un u = {0};
	u.c = 'w';
	u.i = 0x11223344;
	printf("%d\n", sizeof(u));//4
	printf("%p\n", &u);//010FF7D8
	printf("%p\n", &(u.c));//010FF7D8
	printf("%p\n", &(u.i));//010FF7D8

	return 0;
}

这里如果我们对u.c和u.i的赋值顺序不同，相关内存变化如下
在这里插入图片描述
总结： 赋值顺序的不同对内存中存放的数据有影响，所以我们要避免多个赋值

联合的特点

联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）

联合大小的计算

联合的大小至少是最大成员的大小。
当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

union Un1
{
	char c[5];//5
	int i;//4
};//8
union Un2
{
	short c[7];//14
	int i;//4
};//16

int main()
{
	printf("%d\n", sizeof(union Un1));
	printf("%d\n", sizeof(union Un2));
	return 0;
}