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

目录

结构体

结构体类型的声明

匿名结构体

结构的自引用

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

结构体成员变量的访问

结构体内存对齐

结构体传参

位段

位段类型的声明

位段的内存分配

位段的跨平台问题

位段的应用

枚举

枚举类型的定义

枚举的优点

联合体(共用体)

联合类型的定义

联合体的特点

联合体的大小

联合体的应用

---

结构体

结构体类型的声明

之前学习到的数据类型我们称之为内置类型，如int, double, char, float等，后续还学习了数组，数组是一组相同类型元素的集合，但描述一个事物通常需要用到不同的类型，比如要描述一个学生，有年龄，姓名，学号等，就会出现各种类型的字段，这些叫做结构体的成员，结构体的每个成员额可以是不同的变量类型！

struct Stu是一个自定义的结构体类型， struct是结构体关键字，Stu是结构体标签(tag)

struct Stu
{char name[20];//名字int age;//年龄char sex[5];//性别char id[20];//学号
};

在使用时我们感觉结构体类型太长了，可以typedef进行类型重定义

typedef struct Stu
{char name[20];//名字int age;//年龄char sex[5];//性别char id[20];//学号
}stu;

匿名结构体

在声明结构体类型的时候，可以不完全的声明，也就是省略掉结构体标签, 称之为匿名结构体

struct
{char name[20];//名字int age;//年龄char sex[5];//性别char id[20];//学号
};

建议不要使用匿名结构体，可读性不是很好，就按照最标准的 struct + 结构体标签 来创建结构体

结构的自引用

在结构中包含一个类型为该结构本身的成员是否可以呢？

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

这样写是不可以的，因为sizeof(struct Node)是无法计算的，用该结构体类型创建变量时开辟的空间大小也就是未知的，因此是错误的写法

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

这样写就是可以的，第二个成员变量是一个结构体指针，固定大小是4/8个字节, 这也是数据结构中链表的每个节点的结构体定义方式

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

这样写是不可以的，因为定义结构体类型时第二个成员变量用到了typedef后的类型，而此时结构体还没有创建完成，而结构体要创建完成，第二个成员变量就应该定义完成了，这就是先有鸡还是先有蛋的问题了!

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

这样写就是可以的，第二个成员变量定义时使用的是 struct Node, 已经有该类型了!

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

●定义全局变量并初始化

#include <stdio.h>//声明结构体类型的同时初始化变量(定义+赋初值)
struct Stu
{char name[20];//名字int age;//年龄char sex[5];//性别char id[20];//学号
}s1 = { "zhangsan", 18, "mail", "20221931" };   //全局变量struct Stu s2; //全局变量int main()
{s2 = { "lisi", 20, "femail", "31931313"};return 0;
}

●定义局部变量并初始化

#include <stdio.h>
struct Stu
{char name[20];//名字int age;//年龄char sex[5];//性别char id[20];//学号
};
int main()
{struct Stu s = { "wangmazi", 23, "mail", "39133113" };return 0;
}

● 结构体的嵌套定义

#include <stdio.h>
struct score
{int x;char ch;
};
struct Stu
{char name[20];//名字int age;//年龄char sex[5];//性别char id[20];//学号struct score s; //嵌套结构体
};
int main()
{struct Stu s = { "wangmazi", 23, "mail", "39133113", {10, 'q'}};return 0;
}

结构体成员变量的访问

● 结构体变量.成员变量

● 结构体指针变量->成员变量

● (*结构体指针变量).成员变量

#include <stdio.h>
struct score
{int x;char ch;
};
struct Stu
{char name[20];//名字int age;//年龄char sex[5];//性别char id[20];//学号struct score sc; //嵌套结构体
};
int main()
{struct Stu s = { "wangmazi", 23, "mail", "39133113", {10, 'q'}};//1.结构体变量.成员变量printf("%s %d %s %s %d %c\n", s.name, s.age, s.sex, s.id, s.sc.x, s.sc.ch);//2.结构体指针变量->成员变量struct Stu* p = &s;printf("%s %d %s %s %d %c\n", p->name, p->age, p->sex, p->id, p->sc.x, p->sc.ch);//3.*(结构体指针变量).成员变量printf("%s %d %s %s %d %c\n", (*p).name, (*p).age, (*p).sex, (*p).id, (*p).sc.x, (*p).sc.ch);return 0;
}

结构体内存对齐

现在我们来讨论一下结构体的大小，结构体中包含了若干个成员变量，结构体的大小是所有成员变量大小相加吗???

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

显然不是，结构体中的成员变量并不是挨着连续存放的，而是要遵守一定的对齐规则!

结构体内存对齐规则

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

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

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

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

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

画图解释上面结构体的大小是12:

结构体嵌套计算大小:

#include <stdio.h>
struct S3
{double d;char c;int i;
};
struct S4
{char c1;struct S3 s3;double d;
};
int main()
{printf("%d\n", sizeof(struct S3)); //16printf("%d\n", sizeof(struct S4)); //32return 0;
}

计算出 struct S3 的所有成员的最大对齐数是8，因此struct S3 的起始位置就是8的整数倍，然后strcut s3 内部的成员变量存放规则依旧遵守前三条规则，最后检查整体结构体的大小是所有成员(包括嵌套结构体成员)大小的整数倍，也就是32个字节

为啥存在结构体内存对齐?

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

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

2. 性能原因：

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

举个例子: 对于下列结构体:

struct S
{char c; int i;
};

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

那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：

让占用空间小的成员尽量集中在一起

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

s1结构体和s2结构体的成员变量是完全一样的，但是s2结构体的两个char类型变量在一起，所以同样遵守结构体内存对齐规则前提下，s2是更加节省空间的!

修改默认对齐数

● 使用 #pragma pack() 预处理指令修改默认对齐数

#include <stdio.h>
#pragma pack(1) //修改默认对齐数
struct S1
{char c1;int i;char c2;
};
#pragma pack() //恢复默认对齐数int main()
{printf("%d\n", sizeof(struct S1)); //6return 0;
}

结构体传参

#include <stdio.h>
#include <stddef.h>
struct S
{int data[1000];int num;
};void print1(struct S ss)
{for (int i = 0; i < 3; i++){printf("%d ", ss.data[i]);}printf("%d\n", ss.num);
}void print2(const struct S* ps)
{for (int 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;
}

代码中有两种传参方式，可以采用代码一(传值传参)，也可以采用代码二(传址传参)，那么使用哪一个好呢???

建议使用传址传参，理由如下:

1. 传值传参，参数需要压栈，会有时间和空间上的系统开销

2. 如果结构体对象过大，参数压栈的系统开销比较大，导致性能下降

3. 如果要修改外部的结构体，就只能传址传参了; 如果不想修改，传址传参的形参加上const即可

位段

位段类型的声明

1.位段的成员必须是 int、unsigned int 、signed int 、char 等等,  总之，必须属于整形家族

2.位段的成员名后边有一个冒号和一个数字(表示成员占几个比特位)

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

可以看到，位段是一种节省空间的方式，int是占据4个字节，32个比特位，但是比如int flag 变量，用来标识真假，我们只需要两种状态，01 / 10, 只需要两个比特位就够了，也有很多其他类似的场景，因此使用位段可以节省空间

位段的内存分配

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

#include <stdio.h>
//位段
struct A
{int _a : 2;int _b : 5;int _c : 10;int _d : 30;
};
int main()
{printf("%d\n", sizeof(struct A)); //8return 0;
}

上述代码中，struct A中的成员都是 int 类型的，因此先开辟4个字节，先把前三个成员(17个比特位)存下来，还剩余了15个比特位，不够存储_d，于是再开辟4个字节，_d就能存下了! 于是最终结构体的大小就是8个字节, 32个比特位

问题是_d的空间如何分配，是先使用剩余的15个比特位，再使用15个比特位呢? 还是直接使用新开辟的4个字节(32个比特位)中的30个比特位呢?? 答案是 不确定！

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

#include <stdio.h>
//位段
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;printf("%d\n", sizeof(s)); //3return 0;
}

假设:

1.每一个字节的空间存放时从右向左存放

2.当这1个字节不够下一个位段成员存储时就从下一个字节开始存

根据上面两点假设，得到如下结果:

 经过vs2022调试观察，发现vs2022的位段存储就是基于上面两点假设

位段的跨平台问题

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

2. 位段中最大位的数目不能确定。

(比如 int 整数, 16位机器最大16，32位机器最大32，写成27，在16位机器会出问题)

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

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

总结：

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

位段的应用

网络中常用到，后期网络部分的博客会有介绍

枚举

枚举类型的定义

enum Day//星期
{Mon,Tues,Wed,Thur,Fri,Sat,Sun
};enum Sex//性别
{MALE,FEMALE,SECRET
};enum Color//颜色
{RED,GREEN,BLUE
};

枚举类型中包含的成员就是一个个常量，叫做枚举常量，枚举常量是有取值的，默认从0开始，依次递增一

#include <stdio.h>
enum Day//星期
{Mon,Tues,Wed,Thur,Fri,Sat,Sun
};
int main()
{printf("%d\n", Mon); //0printf("%d\n", Tues); //1printf("%d\n", Wed); //2 printf("%d\n", Thur); //3printf("%d\n", Fri); //4printf("%d\n", Sat); //5printf("%d\n", Sun); //6return 0;
}

当然我们在定义枚举变量的时候可以赋初值，从被赋初值的枚举常量开始往后的值都是递增1

#include <stdio.h>
enum Day//星期
{Mon,Tues,Wed = 3,Thur,Fri,Sat,Sun
};
int main()
{enum Day d = Fri;printf("%d\n", Mon); //0printf("%d\n", Tues); //1printf("%d\n", Wed); //3printf("%d\n", Thur); //4printf("%d\n", Fri); //5printf("%d\n", Sat); //6printf("%d\n", Sun); //7return 0;
}

枚举的优点

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

比如switch - case 进行分支判定时，可以用枚举常量代替0,1, 2等数字，可以很直观的看出某个分支的含义!
2. 和#define定义的标识符比较枚举有类型检查，更加严谨。

C语言对类型的检查不是很严格，但是C++对类型的检查更加严格，

#include <stdio.h>
enum Day//星期
{Mon,Tues,Wed = 3,Thur,Fri,Sat,Sun
};
int main()
{enum Day d = 5; //errreturn 0;
}

3. 防止了命名污染（封装）
4. 便于调试

#define定义的标识符和宏都是在编译阶段就完成替换的，而调试是将代码已经编译成了二进制程序，此时都完成了替换，调试起来的代码和最开始的就不一样了!
5. 使用方便，一次可以定义多个常量

联合体(共用体)

联合类型的定义

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

#include <stdio.h>
//定义一个联合体类型
union Un
{char c;int i;
};
int main()
{union Un u; //定义一个联合体变量printf("%d\n", sizeof(u)); //4printf("%p\n", &u);  //00AFFB78printf("%p\n", &u.c); //00AFFB78printf("%p\n", &u.i); //00AFFB78return 0;
}

注：取地址永远取出的是最低一个字节的地址

联合体的特点

● 由于联合成员公用一块空间，因此同一时刻只能使用其中一个联合成员

● 对一个联合成员的修改可能会影响另一个联合成员

联合体的大小

● 联合的大小至少是最大成员的大小

● 当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍

● 对齐数 = 编译器的默认对齐数 和 联合体成员大小 的较小值

#include <stdio.h>
union Un1
{char arr[5];int i;
};
int main()
{printf("%d\n", sizeof(union Un1)); //8return 0;
}

联合体的大小至少是最大成员的大小，也就是数组大小是5，arr虽然是数组，但其实被看成一个一个的char,  所以对齐数是1，i 的对齐数是4，所以最大对齐数就是4，因此最终联合体的大小不是5，应该是8

联合体的应用

判断机器大小端

●大端: 数据的高字节保存在内存的低地址中， 数据的低字节保存在内存的高地址中

●小端: 数据的低字节保存在内存的低地址中， 数据的高字节保存在内存的高地址中

#include <stdio.h>
int check_sys()
{union Un{char c;int i;}u;u.i = 1;//小端: 01 00 00 00//大端: 00 00 00 01return u.c;
}
int main()
{int ret = check_sys();if (ret == 1)printf("小端\n");elseprintf("大端\n");return 0;
}