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

结构体

1 结构体的声明

1.1 结构的基础知识

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

1.2 结构的声明

struct tag

{

member-list;

}variable-list;

例如描述一个学生：

struct student
{
    char name[20];
    int age;
    double score;
}s1,s2,s3;
int main()
{
    return 0;
}

1.3 特殊的声明

在声明结构的时候，可以不完全的声明。

比如：

//匿名结构体类型
struct
{
    int a;
    char b;
    float c;
}x;
struct
{
    int a;
    char b;
    float c;
}a[20], * p;
只能用一次，匿名结构体的成员如果一样，在编译器看来也是不同类型的结构体

1.4 结构的自引用

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

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

struct book
{
	char name[20];
	float price;
	char id[20];
}s1 = {"p",20.5f,"0001"};
struct Node
{
	struct book b;
	struct Node* next;
};
int main()
{
	struct book s2 = { "h",34.56f,"001" };
	struct Node n = { {"t",56.555f,"001"},NULL };
	return 0;
}

1.6 结构体内存对齐

 首先得掌握结构体的对齐规则：

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

2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。 对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。 VS中默认的值为8，Linux环境下没有默认对其数的，它自身大小就是它的对齐数

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

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

1~3包括9~12空间被申请但是被浪费了。

上面分析完之后，我们可以用offsetof这个函数检查一下，它的调用是传入结构体和成员，会返回一个无符号的整数表示离0（也就是相对起始位置的偏移量）的大小

 这个函数的头文件是stddef.h

经过打印验证了我们的分析

为什么存在内存对齐?

1. 平台原因(移植原因)：

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

2. 性能原因：

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

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

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

1.7 修改默认对齐数

之前我们见过了 #pragma 这个预处理指令，这里我们再次使用，可以改变我们的默认对齐数。

改为1也就是不对称存，就是按我们正常字节大小存 。

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

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

2. 位段

结构体讲完就得讲讲结构体实现 位段 的能力。

2.1 什么是位段

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

1.位段的成员必须是 int、unsigned int 或signed int 。

2.位段的成员名后边有一个冒号和一个数字。

位段的设计是为了省空间，这里不存在对齐的。

以下仅是vs平台下，位段是不跨平台的

2.2 位段的内存分配

1. 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型

2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。

3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

struct A
{
    int _a : 2;//开辟一个int，4个byte，32个bit，这里用2个
    int _b : 5;//这里用5个
    int _c : 10;//这里用10个
    int _d : 30;//余15但是这里要30个就产生了二义性，有的编译器再开一个int不用前面的这15个有的编译器就用就造成了可移植性差
};

2.3 位段的跨平台问题

1. int 位段被当成有符号数还是无符号数是不确定的。

2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机 器会出问题。

3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。（vs是从右向左）

4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是 舍弃剩余的位还是利用，这是不确定的。

总结： 跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。 

3. 枚举

枚举顾名思义就是一一列举。 把可能的取值一一列举。

一周的星期一到星期日是有限的7天，可以一一列举。

月份有12个月，也可以一一列举

enum sex
{
	male=5,
    female=8,
	secret
};
enum day
{
	mon,
	tues,
	wed,
	thur,
	fri,
	sat,
	sun
};
int main()
{
	enum sex s1 = male;
	enum sex s2 = female;
	enum day d = fri;
	//用枚举的可能取值给他们赋值。
	//并且枚举的这些值再创造的时候就被赋予了值从0开始
	//也可以刚开始给它们赋初值(是初始化并非给值它是常量），赋的就从下一个开始+1。
	return 0;
}

为什么使用枚举？

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

枚举的优点：

1. 增加代码的可读性和可维护性

2. 和#define定义的标识符比较枚举有类型检查，更加严谨。

3. 防止了命名污染（封装）

4. 便于调试

//程序再开始指向之前由test.c到test.exe要执行预编译，编译，汇编，链接才编程了可执行程序。

//但是预编译阶段就把#define定义的宏全部替换到代码里面，在调试的过程肯定是已经编译完过程，我们看见的代码没有被替换但是底层已经被替换了，就导致调试不太准确方便，但是用enum枚举就没有这个问题。

5. 使用方便，一次可以定义多个常量

4. 联合（共用体）

4.1 联合类型的定义

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

比如：

 

对于联合体成员，公用的空间，不会同时使用，因为一个改变另外一个也发生改变

4.2 联合的特点

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

它的应用

//这是判断字符在内存中是大端存储还是小端存储
//int main()
//{
//	int m = 1;
//	if (*(char*)&m == 1)
//	{
//		printf("小端\n");
//	}
//	else
//	{
//		printf("大端\n");
//	}
//	return 0;
//}

int  check_sys()
{
	union un
	{
		char c;
		int i;
	}u;
	u.i = 1;
	return u.c;
}
int main()
{
	int ret=check_sys();
	if (ret == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
}

联合体也是存在对齐的