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

1.结构体

1. 1结构体的声明

struct tag
{
    member_list;//成员列表，可以有多种类型
}variable_list;//结构体变量列表
struct Point
{
    int x;
    int y;
}p1;//声明结构体的同时定义了结构体变量

匿名结构体

struct
{
    int a;
    char b;
}x;
struct
{
    int a;
}a[20], *p;
//此时：*p=&x;//非法，无法判断结构体的类型

1.2结构体的自引用

结构体内部包含指向自身的结构体指针

struct Node
{
    int date;
    struct Node next;//编译错误，会造成自递归，一个包含一个，没有尽头
    struct Node* next;
}

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

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

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 = {10,{5,6},NULL};//结构体嵌套初始化

1.4结构体内存对齐

//计算结构体大小
struct S3
{
    int d;
    char c;
    int i;
};
printf("%d\n", sizeof(struct S3));//结果：12
struct S4
{
    char c1;//默认大小1  默认对齐数8  对齐数1
    struct S3 s3;//默认大小12  结构体中成员的最大对齐数4  对齐数4
    double d;//默认大小8  默认对齐数8  对齐数8
};
printf("%d\n", sizeof(struct S4));//结果：24

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

• 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

对齐数 = 编译器默认的一个对齐数 与 该结构体最大成员大小的较小值。
VS中默认的值为8
Linux中的默认值为4

3.结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
修改默认对齐数

#pragma pack(8)//设置默认对齐数为8
struct S1
{
    char c1;//偏移量0
    char c2;//1
    double c3;//8
};
#pragma pack()//取消设置的对齐数，还原为默认值
结果：16

计算结构体成员对于结构体起始位置的偏移量offsetof
实现：

struct S3
{
    int d;
    char c;
    int i;
};
int main()
{
    printf("%d\n",&(((struct *)0)->d);//从0号位置下访问变量，变量的地址就是偏移量
}

1.5结构体传参

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 printf2(struct S* ps)//结构体地址传参
{
    printf("%d\n",ps->num);
}
int main()
{
    printf1(s);//传结构体
    printf2(&s);//传地址
    return 0;
}

结论：一般选择printf2.
函数传参的时候，参数是需要压栈的，如果传入一个结构体，参数压栈是的开销比较大，导致性能下降。
结构体传参的时候，传结构体地址。

1.6位段

1.位段的成员必须是 int、unsigned int 或signed int,char 。
2.位段的成员名后面有一个冒号和一个数字

struct A
{
    int _a:2;
    int _b:5;
    int _:10;
    int _d:30;
};
//此结构体大小为：8

位段的内存分配

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

struct S
{
    char a:3;//char类型8位,成员a只占3bit
    char b:4;
    char c:5;
    char d:4;
};//大小为3字节
int main()
{
    struct S s = {0};
    s.a = 10;//1001,成员a只占3bit,初始化后放不下，只能截取
    s.b = 12;//1100
    s.c = 3;//0011
    s.d = 4;//0100
    return 0；
}

2.枚举

2.1枚举类型的定义

一一列举

//枚举常量的值默认从0开始，一次递增1，也可以赋值
enum Day//星期
{
    //枚举常量
    Mon,
    Tues,
    Wed,
    Thur,
    Fri,
    Sat,
    Sun
};
enum Sex//性别
{
    MALE,
    FEMALE,
    SECRET
};

2.2枚举的优点

#define也可以定义常量，那么枚举为什么会存在？
1. 增加代码的可读性和可维护性
2. 和#defifine定义的标识符比较枚举有类型检查，更加严谨。
3. 防止了命名污染（封装）（define是全局的，enum是局部的，不易冲突）
4. 便于调试（define不可以调试）
5. 使用方便，一次可以定义多个常量

2.3枚举的使用

enum Color//颜色
{
    RED=1,
    GREEN=2,
    BLUE=4
};
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
clr=5;//非法，5是整形字面常量,clr是一个枚举变量，类型不一样，不能匹配

3.联合体

3.1联合类型的声明和定义

联合成员共用同一块内存空间

//联合类型的声明
union Un
{
    char c;
    int i;
}u;
//联合变量的定义
union Un un;
u.i=0x12345678;
printf("%x\n", un.c);//结果：78（小端存储，共同一块内存空间，联合变量c占一个字节）
//计算联合变量的大小
printf("%d\n", sizeof(un));//4至少是最大成员的大小

3.2联合体的特点

联合变量公共使用同一块内存空间

union Un
{
    int i;
    char c;
};
union Un un;
printf("%d\n", &(un.i));
printf("%d\n", &(un.c));//结果一样
un.i = 0x11223344;
un.c = 0x55;
printf("%x\n",un.i);//结果：0x11223355

在任意一时刻，联合中只存放一个成员，并且对于联合成员进行赋值会对其成员重写，原来的成员的值不存在了。

3.3联合体大小的计算

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

union Un1
{
    char c[5];
    int i;
};
union Un2
{
    short c[7];
    int i;
};
//联合体大小：8,  16

4.练一练

1.在VS2013下，这个结构体所占的空间大小是（ 12）字节

typedef struct
{
 	 int a;
 	 char b;
	 short c;
	 short d;
}AA_t;

2.下面代码的结果是：（ 16）

#include <stdio.h>
union Un
{
	short s[7];
	int n;
};
int main()
{
  	printf("%d\n", sizeof(union Un));
  	return 0;
}

解析：联合体共用一段空间，因此看最大的成员所占的空间，其次还要看内存是否对齐，用联合体内类型最大的成员大小和系统默认对齐数取最小，得到对齐数，然后看最大成员所占空间是否是为对齐数的整数倍
类型最大的int与默认对齐树8取最小 4 14不是4的整数倍 则要对齐到4的整数倍因此该联合体的大小是16
3.下面代码的结果是：（1 257 ）

enum ENUM_A
{
	X1,
	Y1,
	Z1 = 255,
	A1,
	B1,
};
enum ENUM_A enumA = Y1;
enum ENUM_A enumB = B1;
printf("%d %d\n", enumA, enumB);

解析：哈哈是不是忘记了枚举类型第一个元素从1还是0开始。
枚举中元素的默认值是从0开始的 往后一次递增
如果中途赋值了 从该值往后递增因此Y1位1 B1位257