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

结构体

结构体的语法结构

没有写变量列表也不会报错

写法一：

struct Stu
{
int age;
char name[20];
};

写法二：

struct Stu
{
int age；
char name[20];
}s1,s2;//s1,s1是全局变量（结构体变量）

匿名结构体类型：（不写结构体标签）

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

但是只能用一次

结构体的自引用

结构体内是不能包含同类型的结构体的

结构体内包含一个同类型的结构体指针才是正确的

正确的自引用方式：

struct Node
{
int date;
struct Node* next;

}

以及重命名写法：

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

重命名后struct Node n1和Node n2是一样的

在今后我们常会遇见以下的写法：

写法一：

这是对struct Node{}*重命名为linklist，这时的linklist是一个指针类型。

写法二：

这里的linklist和上面的Node都是重命名，只不过上面是struct Node{}类型，下面是struct Node{}*。

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

初始化的写法一：

struct Point
{
int x;inty;
}p1={1,2};

写法二：

struct point
{
int x;int y;
};
struct point p2={3,4};

结构体的嵌套写法：

struct score
{
int point;
char ch;
};

struct Stu
{
int age;
char name[20];
struct score s;
};
int main()
{
struct Stu s1={13,"shaoyu",{59,'A'}};
printf("%d %s %d %c",s1.age,s1.name,s1.s.point,s1.s.ch);
return 0;
}

结构体内存对齐

如何计算结构体的大小？

结构体内存对齐规则：

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

偏移量：结构体成员的内存地址，相对于结构体变量起始地址的「差值」（字节数）。（结构体第一个字节在起始位置中的偏移量就是0）

实例：

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

图中的×是指浪费的字节

offsetof()的使用

补充知识：offsetof()是一个宏，用于计算结构体成员相对于结构体起始地址的偏移量（单位：字节）,其头文件为<stddef.h>

offsetof()使用模板：offsetof(struct S1,c1)

printf("d\n",offsetof(struct S1,c1));//0
printf("d\n",offsetof(struct S1,i));//4
printf("d\n",offsetof(struct S1,c2));//8

修改默认对齐数

用预处理指令#pragme

#pragma pack(4)//将默认对齐数设置为4
struct S
{
int i;
double d;
};
#pragma pack()//将默认对齐数恢复成8

拓展：#pragma once//在头文件中使用，功能是：防止头文件被多次引用。

 结构体传参

使用实例：

struct S 
{
    int data[3];  
    int num;     
};

 1. 函数 print1：传值调用（结构体对象）
void print1(struct S ss) 
{
    int i = 0;
    for (i = 0; i < 3; i++)
{
        printf("%d ", ss.data[i]);  // 访问成员用 .
    }
    printf("%d\n", ss.num);
}

 2. 函数 print2：传址调用（结构体指针）
void print2(struct S* ps) {
    int i = 0;
    for (i = 0; i < 3; i++) {
        printf("%d ", ps->data[i]); // 访问指针成员用 ->
    }
    printf("%d\n", ps->num);
}

int main() 
{
   
    struct S s = {{1, 2, 3}, 100};
    
    print1(s);   // 传值
    print2(&s);  // 传址
    return 0;
}

优先选择传址调用（print2(&s)）的原因:

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

位段

位段的结构

与结构体的差异：

1. 位段的成员必须是整形家族的（int、char、unsigned int等）。
2. 位段的成员后面有一个冒号和一个数字。

例：

struct A
{
int a:1;//a只需要1个比特位
int b:2;//b只需要2个比特位
int c:3;//c只需要3个比特位
};

A就是一个位段类型，这样做可以节省空间 （在嵌入式开发中，内存非常宝贵）       

位段的内存分配

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

struct S
{
//先开辟4byte-32bit
int a:2;
int b:5;
int c:10;
//32个bit位已经用了17个,剩下的不足以存放d的30个bit位，所以再开辟4byte（之前剩余的15个bit位浪费了）
int d:30;
};

一般情况下，位段的成员是一个类型的，因为位段本身不稳定，所以不要搞复杂

实例：

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;
}

关于s.a   s.b   s.c  s.d 的存放方法：

s.a=10换成二进制：1010但是只存放3个bit位，所以去掉最高位，即010

s.b=12-->1100：存放4个bit位，全部存储，即1100

s.c=3-->11:存放5个bit位，不够的部分补0，即00011

s.d同s.c

地址转化为16进制即为：620304

因为开辟的数据只有1个字节，所以不用考虑大小端。

枚举

枚举类型的结构

图一：

enum Day
{
Mon,（是逗号不是分号）
Tues,
Wed,
Thur,
Fri,
Sat,
Sun,
};

使用实例：

图二：

int main()
{
enum Day d=Fri;
return 0;
}

编译器默认第一个变量的值为0，依次递增1（枚举相当于一个图纸，并不会占空间，只有创建变量才会申请空间，如图二），即：

但也可以设置Mon的值，即：

enum Day
{
//这些是枚举常量，不能修改，而Mon=1只是给Mon赋了一个初始值
Mon=1,
Tues,
Wed,
Thur,
Fri,
Sat,
Sun,
};

那么Tues的值就为2，Wed为3，依次类推

枚举的优点：

1. 增加代码的可读性和可维护性
2. 和 #define 定义的标识符比较枚举有类型检查，更加严谨。（在C语言中体现的不明显，但是在C++中体现的明显）                                                                                                               

   #define Mon 1    //这个Mon是没有类型的

   而枚举常量有类型，其类型就是Day             
3. 防止了命名污染（封装）
4. 便于调试                                                                                                                                    对于一个文件test.c的运行过程：                                                                                              test.c-->(预处理) -->编译-->链接-->.exe                                                                                     

   #define M 100
   
   int main()
   {
       enum Day d = Fri;
       int m = M;
   }

    上图代码在预处理过程中将M的值全部转化为100了，导致不能很好的观察M的值，而枚举变量不会发生变换。                                                                                                            
5. 使用方便，一次可以定义多个常量

联合

联合体的结构

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

联合体的特点

int main()
{
union Un u;
printf("%p",&u);
printf("%p",&(u.a));
printf("%p",&(u.c));
}

结果：三者地址相同

原因：联合体是共用体，变量共用同一块空间

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

union Un
{
    char arr[5];//5,5个char类型,对齐数为1
    int i;//4,对齐数为4
};

int main()
{
    printf("%d\n", sizeof(union Un));//8,最大对齐数为4,所以应该为4的倍数)
    return 0;
}