自定义类型：结构体，枚举，联合结构体

一、结构体

1.结构体的基础知识

结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。

和数组相比较，数组是一些值的集合，这些值的类型是相同的。

2.结构体类型的声明

结构体的声明
struct tag
{
member - list;
}variable - list;

例如

​
struct book//定义一本书类型
{
	char name[100];//书名
	double price;//价格
	char chubanshijian[100];//出版时间
	char writer[10];//作者

};//分号不能丢

我们可以使用typedef来重命名结构体

typedef struct book//定义一本书类型
{
	char name[100];//书名
	double price;//价格
	char chubanshijian[100];//出版时间
	char writer[10];//作者

}book;//分号不能丢

3.特殊的声明（匿名结构体）

有时候我们会遇见这样的结构体

struct
{
	char name[20];
	int age;
}s1;
int main()
{
	return 0;
}

像这种没有结构体标签的定义结构体，我们称为匿名结构体，匿名结构体只能在声明结构体时定义好结构体变量，否则之后无法在进行定义
关于匿名结构体，我们还需注意

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

在上面的代码中我们需注意的是x和&x的结构体看上去好像是一样的，但是事实上并不相同，当我们进行编译时，就会报警告。
编译器会把上面的两个声明当成完全不同的两个类型。 所以是非法的。

4.结构的自引用

我们可以思考一个问题，在结构中包含一个类型为该结构本身的成员是否可以呢？是否可以用下面这段代码来实现呢？

struct Node
{
 int data;
 struct Node next;
};
//可行否？
如果可以，那sizeof(struct Node)是多少？

仔细分析一下，我们不难发现，这样是不行的。因为如果成立的话，假设我们要去计算这个结构体的大小，我们会发现它的大小是无穷大的，这是肯定不行的。

那我们该如何正确的自引用呢？我们知道我们可以通过地址也就是指针去访问一个数，那么在这里我们可以通过指针在一个结构体中来访问另一个结构体中的成员

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

那么对于一个匿名结构体，我们是否可以自引用呢？我们来看看下面这段代码。

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

其实这样做也是不合理的。这里有两处错误，首先是我们是使用了typedef，但是我们在结构体里面使用Node是在我们typedef之前进行的。我们编译器此时还不认识Node，所以这里错了，而且对于一个匿名结构体，他是无法自引用的。所以我们正确的代码应该是这样的

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

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

//定义变量
struct book
{
	char name[100];
	double price;
}b1,b2;//全局变量//生命结构体类型同时定义变量b1
struct book b3 = 0;//全局变量，定义结构体变量b2
int main()
{
	struct book b4;
	struct book b5;//局部变量，
	return 0;
}

由于结构体是一些值的集合，而数组是一些数的集合，那么结构体的初始化与数组的初始化应当一致，都是使用{}来初始化的。
如果一个结构体里面嵌套一个结构体进行初始化的话，我们也采用相同的方法来初始化
当然如果你不想按照顺序来初始化，这也是可以的，我们需要使用"."这个操作符，然后再输入我们想初始化的变量名即可，同样如果想要乱序打印也是使用这个操作符的。

struct s
{
	char a;
	int b;
	char c[20];
	float d;
};
struct s s5 = { 'c',4,"wonwoo",2.18 };//初始化，定义变量同时赋初值
struct B
{
	char ba;
	struct s s1;
	float f;
};
int main()
{
	struct s s2 = { 'a',2,"joshua",1.12 };
	struct B b1 = { 'b',{'q',12,"s.coups",2.3},1.23 };//结构体嵌套初始化
	struct B b2 = { .f = 3.2f,.ba = 'v',.s1.b = 2,.s1.d = 5.0f,.s1.c = "woozi",.s1.a = 'r' };//乱序赋值
	printf("%c %d %s %f \n", s2.a, s2.b, s2.c, s2.d);
	printf("%c %c %s %d %f %f\n", b1.ba, b1.s1.a, b1.s1.c, b1.s1.b, b1.f, b1.s1.d);
	return 0;
}

6.结构体内存对齐

当我们了解结构体后，还有一件事需明白：那就是结构体的大小是多少，又是如何计算的。
我们先来看这段代码，来猜测一下结果

#include<stddef.h>
struct S1
{
	char c1;
	int i;
	char c2;
};
struct S2
{
	char c1;
	char c2;
	int i;
};
int main()
{
	printf("%d\n", sizeof(struct S1));
	printf("%d\n", sizeof(struct S2));
	return 0;
}

我们肯定会想当然地认为是两个6，但答案是12和8

要想知道如何计算结构体的大小，首先得掌握结构体的对齐规则：

1. 第一个成员在与结构体变量偏移量为0的地址处。

2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。 VS中默认的值为8

3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。

4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整 体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍

我们也可以来验证一下这些宏的偏移量

我们可以使用offsetof这个宏来计算，这个宏是用来计算偏移量的，它需要一个头文件stddef.h

计算可知结果是正确的
我们可以来看下下面这些结构体的大小

struct S1
{
	int a;
	char c;
};
struct S1
{
	char c; 
	int a;
};

struct S3
{
	double d;
	char c;
	int i;
};
//printf("%d\n", sizeof(struct S3));

struct S4
{
	char c1;
	struct S3 s3;
	double d;
};
//printf("%d\n", sizeof(struct S4));

那为什么要进行对齐呢？

1. 平台原因(移植原因)： 不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特 定类型的数据，否则抛出硬件异常。

2. 性能原因： 数据结构(尤其是栈)应该尽可能地在自然边界上对齐。 原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访 问。

总体来说： 结构体的内存对齐是拿空间来换取时间的做法。

那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到： 让占用空间小的成员尽量集中在一起

struct S1
{
 char c1;
 int i;
 char c2;
};
struct S2
{
 char c1;
 char c2;
 int i;
};

S1和S2类型的成员一模一样，但是S1和S2所占空间的大小有了一些区别。

7. 修改默认对齐数

我们知道vs下的默认对齐数是8，但是8有时并不是最适合的，这时我们可以自己修改这个默认对齐数。
之前我们见过了 #pragma 这个预处理指令，这里我们再次使用，可以改变我们的默认对齐数

#pragma pack(1)//设置默认对齐数为1
struct S2
{
    char c1;
    int i;
    char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
int main()
{
    printf("%d\n", sizeof(struct S2));
    return 0;
}

8.结构体传参

struct S
{
 int data[1000];
 int num;
};
struct S s = {{1,2,3,4}, 1000};
//结构体传参
void print1(struct S s)
{
 printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps)
{
 printf("%d\n", ps->num);
}
int main()
{
 print1(s);  //传结构体
 print2(&s); //传地址
 return 0;
}

我们知道结构体传参有两种方式：一是直接传结构体，二是传地址

上面的 print1 和 print2 函数哪个好些？ 答案是：首选print2函数。

原因： 函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。``

结论：
结构体传参的时候，要传结构体的地址。

二、位段

1.什么是位段

位段的声明和结构是类似的，有两个不同：
1.位段的成员必须是 int、unsigned int 或signed int 。
2.位段的成员名后边有一个冒号和一个数字。

这里的大小是为什么会是8个字节呢？4个整形不应该是16个字节吗？

其实这里的位段，这个位是指二进制位 也就是说a占2个二进制位，b占5个二进制位，c占10个二进制位，d占30个二进制位

这样做是为了节省空间。应为我们实际应用结构体时，可能不需要那么多二进制位，有点浪费空间，我们应用位段对它进行更精细的划分，可以更加节省空间

2.位段的内存分配

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

所以上面那个位段，内存分配是这样的。

我们可以在vs2019验证一下下面这段代码

struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};
int main()
{
	struct S s = { 0 };
	s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;
	return 0;
}

最后的十六进制位是62 03 04，struct s 的大小是3 。事实就是如此

3.位段的跨平台问题

1. int 位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机 器会出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是 舍弃剩余的位还是利用，这是不确定的。

三、枚举

1.枚举类型的定义和使用

枚举顾名思义就是一一列举。
把可能的取值一一列举。
枚举类型的定义与结构体非常类似，只是它的关键词是enum

enum Season
{
	SPRING,
	SUMMER, 
	AUTHOM,
	WINTER,
};
enum Option
{
	EXIT,
	PLAY,
	ADD,
	DEL,
};
enum Sex
{
	MALE,
	FEMALE,
	SECRET,
};

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

我们可以打印这些值

enum Option
{
	EXIT,
	PLAY,
	ADD,
	DEL,
};
int main()
{
	printf("%d\n", EXIT);
	printf("%d\n", PLAY);
	printf("%d\n", ADD);
	printf("%d\n", DEL);
	return 0;
}

这些值都是默认值，我们可以修改这些默认值

这些枚举常量，我们可以定义一个枚举类型的常量来接受这些枚举常量。只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。

如下图，我们可以直接赋值1，这也是可以的，但是这是由于c语言检查不够仔细造成的，这样写其实不好，在c++中会直接报错了。

还有需注意，一个枚举的大小是4个字节

2.枚举的优点

我们可以使用 #define 定义常量，为什么非要使用枚举？ 枚举的优点：

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

四、联合

1.联合类型的定义

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

#include<stdio.h>
union U
{
	char i;
	int a;
};
int main()
{
	union U u;
	return 0;
}

2.联合的特点

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

#include<stdio.h>
union U
{
	char i;
	int a;
};
int main()
{
	union U u;
	printf("%d\n", sizeof(u));
	printf("%p\n", &u);
	printf("%p\n", &(u.i));
	printf("%p\n", &(u.a));
	return 0;
}

由此可知：a和i共用这4个字节的空间，我们平时使用时只是单独使用其中的一个变量，因为我们修改一个变量，其他的变量也会随之改变，不可同时使用。
我们可以来看一下下面这段代码
在小端机器上测试

union U
{
	char i;
	int a;
};
int main()
{
	union U u;
	u.a = 0x11223344;
	printf("%x\n", u.a);
	u.i = 0x00;
	printf("%x\n", u.a);
	
	return 0;
}

这个联合体的大小4个字节，我们将一个十六进制的数赋值给a，此时内存为

然后我们存放0x00给i，内存就变为了

事实上结果就是如此

3.联合大小的计算

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

union U1
{
	char i[5] ;
	int a;
};
union U2
{
	short i[7];
	int a;
};
int main()
{
	printf("%d\n", sizeof(union U1));
	printf("%d\n", sizeof(union U2));
	return 0;
}

在U1中，最大的大小是5个字节 i数组的大小是5个字节，i的大小是4个字节，所以最大成员的大小是5个字节
i的大小是1，与默认对齐数8取得最小值还是1
a的大小是4，与默认对齐数8取得最小值还是4 最大对齐数就是1和4的最大值，就是4
5不是4的倍数，所以应该是8个字节的大小 在U2中，最大的大小是14个字节

i数组的大小是14个字节，i的大小是4个字节，所以最大成员的大小是14个字节
i的大小是2，与默认对齐数8取得最小值还是2
a的大小是4，与默认对齐数8取得最小值还是4 最大对齐数就是1和4的最大值，就是4
14不是4的倍数，所以应该是16个字节的大小

4.利用联合判断大小端

union U
{
	char i;
	int a;
};
int main()
{
	union U u;
	u.a = 1;
	if (u.i == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}

总结

本节是关于结构体，位段，枚举，联合的知识点。
希望对你有所帮助。