自定义类型详解（结构体，位段，枚举，联合）

一、结构体

• 定义：结构体是不同类型值的集合，这些值称为成员变量。但结构中的每个成员可以是不同类型的变量

结构体声明

语法：
声明方法一：

struct student
{
   char name[20]; 
   int number;
};
int main()
{
    struct student t; 
    
}

• struct book 就是结构体类型
  t 就是用结构体类型创建的变量

声明方法二：

struct book
{
   char name[20];
   char id[15];  成员列表
   int price;
}s1,s2,s3;

• 在声明的同时创建结构体变量s1,s2,s3
  注意：方法一创建的是局部变量，方法二是全局变量

---

特殊声明方式（匿名结构类型）

struct    
{
   int a;
   char b;
   float c; 
}s;

• 声明结构体时，可以不完全的声明，类似于数组的不完全初始化，即省略掉结构体的名称（标签）
• 这种结构体声明方式叫匿名结构类型，但只能用一次
• 特别注意：如果二种匿名结构类型的成员完全相同，编译器却会认为是两种不同类型，所以避免这样使用

---

结构体自引用

错误方式：

struct G
{
   int f;
   struct G;
};

• 显然会死循环，而且如果要计算结构体的大小，那大小是多少呢？不能这样引用
  正确方式是：

struct Node
 {  
     struct Node* next;
 };

• 正确的自引用方法是包含同类型的结构体指针，通过这个指针指向另一个同类型的结构体。一般用来实现链表、二叉树等链式结构。

• Q：是否可以用匿名结构体进行结构体自引用？
  A：不行。结构体类型是无法通过结构体自身变量进行自引用，只能通过自身类型进行引用，因为匿名结构体只能用一次。

• Q：如何使用typedef进行类型重命名后，进行结构体自引用？
  A：

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

---

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

struct K
{
	int a;
	char b;
}; 
struct H
{
	int a;
	char b;
}pd;  
int main()
{   // 定义变量的同时，赋初始值
	struct K b = { 6,'G'};
	struct H pd = { 66,'A'};
	printf("%d %c\n", b.a, b.b); 
	printf("%d %c\n", pd.a, pd.b); 

	return 0;
}

• 第一种定义的是局部变量，赋值后打印
• 第二种定义的是全局变量，也是赋值后打印

---

结构体嵌套初始化

struct KG
{
	int a;
	char b;
};
struct H
{
	int a;
	char b;
	struct KG q;  // 结构体嵌套
};
int main()
{
	struct H pd = { 66,'A',4,'J'};//初始化

	printf("%d %c %d %c\n", pd.a, pd.b,pd.q.a,pd.q.b); //打印

	return 0;
}

• 结构体 H 中包含了 结构体 KG，这种叫结构体嵌套
  初始化是通过结构体成员找到结构体的方式

---

结构体内存对齐（计算结构体大小）

struct S
{
	char a;
	int b;
	char c;
};
int main()
{
	struct S pd = { 0 };
	printf("%d\n", sizeof(s));
	return 0;
}

问：结果是多少？
正常思维下，应该是6个字节：char a 1字节 int b 4 字节 char c 1 字节，加起来=6
但是，结果如下：
首先要知道结构体的对齐规则：
1.第一个成员在与结构体变量偏移量为0的地址处。
2.其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
对齐数 = 编译器默认对齐数 与 该成员大小的 较小值。 （VS中默认的值为8）
3.结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4.如果嵌套了结构体的情况，嵌套的结构体对齐到 自己 的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍

本题具体步骤如下：

练习一：

struct S
{
   double c1;
   char c2;
   int i;
};
printf("%d\n",sizeof(struct S));   //16

图解：

练习二：（结构体的嵌套的计算方式）

struct S
{
	double c1;
	char c2;
	int i;
};
struct S3
{
	char c1;
	struct S s1;
	double d;
};
int main()
{
	struct S3 s3 = { 0 };
	printf("%d\n", sizeof(s3));   //32
	return 0;
}

图解：

注意：结构体嵌套的最大数并不是16。16是结构体嵌套成员的大小，S里的最大对齐数是 8。这里用来对比的是所有的对齐数，而不是所占的空间。

内存对齐看上去总会浪费空间，那为什么存在内存对齐呢？
原因有二：

• 1.平台原因(移植原因)：
  不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则容易导致硬件异常。
• 2.性能原因：
  数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
  原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
• 总结：结构体的内存对齐是拿空间来换取时间的做法
• 因此，在设计结构体的时候，我们既要满足对齐，又要节省空间，做到：
  让占用空间小的成员尽量集中在一起。
  例如：

struct S1
{
 char c1;
 int i;
 char c2;
};       s1 的大小是 12 个字节
------------------------------------
struct S2
{
 char c1;
 char c2;
 int i;
};       s2 的大小是 8 个字节

修改默认对齐数

计算结构体大小用到的的默认对齐数是可以修改的
#pragma 这个预处理指令，可以修改默认对齐数

#pragma pack(2)//设置默认对齐数为2
struct S1
{
 char c1;
 int i;
 char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认

修改默认对齐数的意义：当结构体的对齐方式不合适的时候，可以自己更改默认对齐数。

offsetof 宏计算偏移量

offsetof 用来计算某个结构体成员离最开始的地址 0 的偏差是多少
offsetof 头文件：<stddef.h>
使用：

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

结构体传参

法一：传形参

struct peo
{
	char name[20];
	char srx[10];
	int tele[12];
};
print(struct peo str)
{
	printf("%s %s %d\n", str.name, str.srx, str.tele);
}
int main()
{
	struct peo s = { "小明","男","15846092751" };
	print1(s);
}

打印时用的是.操作符
如果是是传值的方式，传的是整个数结构体的大小，这样会比较占空间

法二：传地址
打印时用的是->操作符。这种方式传的是地址，最大也就是4个或8个字节

struct peo
{
	char name[20];
	char srx[10];
	int tele[12];
};
print1(struct peo* str)
{
	printf("%s %s %d\n", str->name, str->srx, str->tele);
}
int main()
{
	struct peo s = { "小明","男","15846092751" };
	print2(&s);
}

因此，选择结构体传参时首选传指针的方式。
因为如果选择以形参的函数传参的时候，参数是需要压栈的。
如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。

---

二、位段

1.定义：位段的声明和结构是类似的，有两个不同：

• 位段的成员必须是 int、unsigned int 或signed int 。
• 位段的成员名后边有一个冒号和一个数字。

struct A
{
 int _a:2;
 int _b:5;
 int _c:10;
 int _d:30;
};

2.位段的内存分配

• 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型
• 位段的空间上是按照需要以4个字节（ int ）或1个字节（ char ）的方式开辟的。
• 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。
  
  3.位段的跨平台问题
• int 位段被当成有符号数还是无符号数是不确定的。
• 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机 器会出问题。
• 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
• 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是 舍弃剩余的位还是利用，这是不确定的。
  总结：跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。

---

三、枚举

1.定义：

enum Day//星期
{
 Mon,
 Tues,
 Wed,
 Thur,
 Fri,
 Sat,
 Sun
};

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

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

2.使用枚举的优点：
既然可以用 #define 定义常量，为什么非要使用枚举？
枚举的优点：

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

---

四、联合

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

//联合类型的声明
union Un
{
 char c;
 int i;
};
//联合变量的定义
union Un un;
//计算连个变量的大小
printf("%d\n", sizeof(un));

2.特点：联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。
例：编写一个程序判断当前机器的大小端存储
3.联合体大小的计算
联合的大小至少是最大成员的大小。
当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。