【C语言】自定义类型：结构体（内存对齐），枚举，联合

r囧r小猫 2024-04-06 10:03 98阅读 0赞

#### 文章目录 ####

*   *  结构体
     *   *  结构体的声明
         *   *  结构体的基础知识
             *  结构体的声明
             *  特殊的声明
             *  结构体的自引用
             *  结构体变量的定义和初始化
             *  结构体的内存对齐
             *  修改默认对齐数
             *  结构体传参
         *  位段
         *   *  什么是位段
             *  位段的内存分配
             *  位段的跨平台问题
             *  位段的应用
         *  枚举
         *   *  枚举类型的定义
             *  枚举的优点
         *  联合（共用体）
         *   *  联合类型的定义
             *  联合体的特点
             *  联合体大小的计算

**本章重点**

*  结构体
    
     *  结构体类型的声明
     *  结构体的自引用
     *  结构体变量的定义和初始化
     *  结构体内存对齐
     *  结构体实现位段（位段的填充&可移植性）
 *  枚举
    
     *  枚举类型的定义
     *  枚举的优点
     *  枚举的使用
 *  联合
    
     *  联合类型的定义
     *  联合的特点
     *  联合大小的计算

### 结构体 ###

#### 结构体的声明 ####

##### 结构体的基础知识 #####

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

##### 结构体的声明 #####

struct Book {
        
    	char book_name[20];
    	char author[20];
    	int price;
    	char id[20];
    };

> 分号前面可以加结构体变量，是全局变量

##### 特殊的声明 #####

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

struct {
        
    	char book_name[20];
    	char author[20];
    	int price;
    	char id[20];
    }sb1, sb2;

这个在声明的时候省略了结构体的标签，也叫作匿名结构体类型只能使用一次

那么问题来了？

struct {
        
    	char book_name[20];
    	char author[20];
    	int price;
    	char id[20];
    }sb1;
    
    
    struct {
        
    	char book_name[20];
    	char author[20];
    	int price;
    	char id[20];
    }* ps;
    
    
    int main() {
        
    	ps = &sb1;
    	return 0;
    }

**警告**：编译器会把上面的两个声明当成完全不相同的类型。所以是非法的

##### 结构体的自引用 #####

使用场景，就是链表当中

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

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

有了结构体那么如何定义变量，

struct Node {
        
    	int data;
    	struct Node* next;
    };
    
    
    struct Point {
        
    	int x;
    	int y;
    }p1;	//声明类型的同时定义变量p1
    
    struct Point p2;//定义结构体变量p2
    
    
    //初始化：定义变量的同时赋值
    
    struct Point p3 = {
         x, y };

##### 结构体的内存对齐 #####

struct S1 {
        
    	char c1;
    	int i;
    	char c2;
    };
    
    struct S2 {
        
    	char c1;
    	char c2;
    	int i;
    };
    
    #include <stdio.h> 
    
    int main()  {
        
    	printf("%d\n", sizeof(struct S1));
    	printf("%d\n", sizeof(struct S2));
    }

结果是什么？

![image-20220917104233614][]

这是因为什么那？

> 就是结构体内存对齐，这里在介绍一个函数

`offsetof`,

`offsetof (type,member)`,这个函数的功能就是计算结构体成员相对于起始位置的偏移量

![image-20220917110204070][]

这是对应的偏移量，所以怎么画图那（这是根据偏移量计算的）

![image-20220917110451177][]

如何结算？

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

> 1.  第一个成员在与结构体变量偏移量为0的地址处
> 2.  第二个成员开始，要对齐到某个【对齐数】的整数倍到的偏移处，对齐数：结构体成员自身大小和默认对齐数的较小值
> 
> VS： 8
> 
> Linux： 默认不设对齐数（对齐数是结构体成员的自身大小）
> 
> 1.  结构体的总大小，必须是最大对齐数的整数倍。每个结构体成员都有一个对齐数，其中最大的对齐数就是最大对齐数。
> 2.  如果嵌套了结构体的情况，潜逃的结构体对齐到自己的最大对齐数的整数倍，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

**为什么存在内存对齐的规则？**

> 1.  平台原因（移植原因）：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定的数据类型，否则抛出硬件异常
> 2.  性能原因：数据结构（尤其是栈）应该尽可能的在自然边界上对齐，原因在于，为了访问未对齐的内存，处理器需要操作两次内存访问；而对齐的内存仅需要一次访问

总体来说：

**结构体的内存对齐是拿空间来换取时间的做法**

##### 修改默认对齐数 #####

设置默认对齐数：

`#pragma pack(8)`//设置默认对齐数为8

`#pragma pack()`//恢复默认对齐数

![image-20220917221557040][]

##### 结构体传参 #####

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

首选print2函数原因：

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

**结论**

结构体传参的时候，是要传结构体的地址的

#### 位段 ####

> 结构体说完就得说说结构体实现`位段`的能力

##### 什么是位段 #####

> 1.  位段的成员必须是`int,unsigned int, signed int`
> 2.  位段的成员后边有一个冒号和一个数字

比如：

struct A {
        
    	int a : 2;
    	int b : 5;
    	int c : 10;
    	int d : 30;
    };

位段中的位其实是二进制位，后面的2就是表示2个比特位，后面也是如此

##### 位段的内存分配 #####

![image-20220920194747587][]

#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;
    
    }
    
    //空间是如何开辟的？

![image-20220920200311072][]

最后在内存中的结果应该是：

![image-20220920200850540][]

我们在编译器上来看看，到底是什么？

![image-20220920200823120][]

![image-20220920200926884][]

##### 位段的跨平台问题 #####

> 1.  int位段被当成有符号数还是无符号数是不确定的
> 2.  位段中最大的数目不能确定（16位机器最大16,32位机器最大32，写成27，在16位机器会出现问题）
> 3.  位段中的成员的内存从左到右分配还是从右到左分配标准尚未定义
> 4.  当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位是时，是舍弃剩余的位还是利用，这是不确定的

**总结**

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

##### 位段的应用 #####

![image-20220920205335068][]

#### 枚举 ####

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

##### 枚举类型的定义 #####

#include <stdio.h>
    
    enum Color {
        
        //枚举的可能取值
        //每一个可能的取值是常量
    	RED,
    	GREEN,
    	BLUE
    };
    
    int main() {
        
    	enum Color color = RED;
    	return 0;
    }

这些可能取值是都是有值的默认是从0开始，一次递增1，当然在定义的时候也可以赋初始值

##### 枚举的优点 #####

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

#### 联合（共用体） ####

##### 联合类型的定义 #####

联合也是一种特殊的自定义类型

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

#include <stdio.h>
    
    union Un {
        
    	char c;
    	int i;
    };
    
    int main() {
        
    	union Un un;
    	printf("%d\n", sizeof(union Un));
    }

##### 联合体的特点 #####

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

![image-20220922150638939][]

之前写的大端小端判断在这里用共用体同样可以解决：

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

##### 联合体大小的计算 #####

*  联合体大小至少是最大成员的大小
 *  当最大成员大小不是最大对齐数的整数倍的时候，就要对齐最大对齐数的整数倍

![image-20220922152808427][]

[image-20220917104233614]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/388b3159dda2492cb5cf228872c6875e.png
[image-20220917110204070]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/aa9d92f9f49a4e28862ac043539d739d.png
[image-20220917110451177]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/fd8fa91de0534a69b88897f67469435b.png
[image-20220917221557040]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/b5f9e165280546fba87f572835562fc3.png
[image-20220920194747587]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/68b62ccb33e5447c8504889af737bcaa.png
[image-20220920200311072]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/7cf766d676244b338bb691499baa09c6.png
[image-20220920200850540]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/e773fa13aff649e0bea1e24ce2775e1e.png
[image-20220920200823120]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/596fca1ace134392b67219e8ac6c76d0.png
[image-20220920200926884]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/babcd80039f34123a91cd511f4abdcd6.png
[image-20220920205335068]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/bbc6cbfbdee34b379924925dfcc91a47.png
[image-20220922150638939]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/c6ee18cb878d4e6fa38be76c7d0ff1d6.png
[image-20220922152808427]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/0b768320b86043928fef8b54d7cb5a78.png