自定义类型详解

àì夳堔傛蜴生んèń 2023-10-03 19:38 5阅读 0赞

**目录**

一 结构体

1.1 结构的基础知识

1.2 结构的声明

1.3 特殊的声明

1.4 结构的自引用

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

1.6 结构体内存对齐

1.7 修改默认对齐数

1.8 结构体传参

二 位段

2.1 什么是位段

2.2 位段的内存分配

2.3 位段的跨平台问题

三 枚举

3.1 枚举类型的定义

3.2 枚举的优点

四 联合（共同体）

4.1 联合类型的定义

4.2 联合大小的实现

--------------------

励志环节

一个人使劲踮起脚尖靠近太阳的时候，全世界都挡不住他的阳光。

--------------------

**本章重点**

C语言中除了有char,short,int,long,long long,double,foat这些内置类型，还有结构体，枚举，联合等这些自定义类型。

**结构体：**结构体类型的声明 结构的自引用 结构体变量的定义和初始化 结构体内存对齐 结构体传参 结构体实现位段（位段的填充&可移植性）

**枚举：**枚举类型的定义 枚举的优点 枚举的使用

**联合：**联合类型的定义 联合的特点 联合大小的计算

--------------------

## 一 结构体 ##

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

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

### 1.2 结构的声明 ###

#include <stdio.h>
    
    struct stu//struct是结构体关键字，stu是结构体标签
    {
    	//这里面放成员列表
    	char name[10];
    	char sex[5];
    	int age;
    	int height;
    }s2,s3,s4;//这里的s2,s3,s4也是结构体变量，是一个全局变量
    
    struct stu s5;//这里的s5是结构体变量，是一个全局变量
    
    int main()
    {
    	struct stu s1 = { "xianming", "nan", 18, 43 };//这里的s1就是结构体变量，是一个局部变量
    	return 0;
    }

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

**匿名结构体类型**

#include <stdio.h>
    
    struct
    {
    	char c;
    	int a;
    	double d;
    }e;//结构体变量必须在这里命名，而且只能使用一次
    
    struct
    {
    	char c;
    	int a;
    	double d;
    }* ps;
    
    int main()
    {
    	ps = &e;//在这里是不能这样用的，会出现错误，即使结构体成员一模一样也不可以
        //编译器认为等号两边是不同的结构体类型，所以这种写法是错误的
    	return 0;
    }

编译器会把上面的两个结构体声明当成完全不同的两个类型。所以是非法的

省略结构体标签，编译器也会认为这两个结构体是不同的。（虽然省略结构体标签后，这两个结构体成员是一样的）

### 1.4 结构的自引用 ###

下面为正确的自引用的方式：

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

#include <stdio.h>
    
    typedef struct Node//重命名这个结构体为Node
    {
    	int data;
    	struct Node* next;
    }Node;
    //这种方法尽量不要使用，不建议
    int main()
    {
    	struct Node s2 = { 0 };//这种写法是可以的
    	Node s1 = { 0 };//这种写法也是可以的
    	return 0;
    }

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

定义：

struct stu    
    {
    	char name[20];
    	int age;
    	float score;
    };
    int main()
    {
    	struct stu s;
    	return 0;
    }

struct stu    
    {
    	char name[20];
    	int age;
        float score;
    }s1, s2;//这里的s1 s2 和s一样，也是结构体变量，（全局的）
    struct stu s3;//定义一个初始化变量 全局变量
    int main()
    {
    	struct stu s;//s就是结构体变量，struct stu 就是和int char float 一样的类型,但是却是局部的
    	return 0;
    }

初始化：

struct stu    
    {
    	char name[20];
    	int age;
    	float score;
    };
    
    struct stu s2 = { "xiaohong", 20, 97.5f };
    
    int main()
    {
    	struct stu s = { "xiaoming", 20, 97.5f };//97.5 后面加f说明是float类型，不加的话，会默认为为double类型
    	printf("%s %d %f", s.name, s.age, s.score);
    	return 0;
    }

结构体嵌套初始化
    struct Node
    {
    int data;
    struct Point p;
    struct Node* next;
    }n1 = {10, {4,5}, NULL}; 
    
    struct Node n2 = {10, {4,5}, NULL};

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

这个知识点比较重要

计算结构体的大小，这也是一个特别热门的考点： 结构体内存对齐

**代码1展示：**

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

运行的结果是：12

#include <stdio.h>
    #include <stddef.h>
    
    struct S1
    {
        char c1;
        int i;
        char c2;
    };
    //offsetof(a,b)计算的是返回的是size_t,a代表结构体类型名，b代表结构体成员名,头文件是<stddef.h>
    //偏移量，第一个位置的偏移量是0.
    int main()
    {
    	printf("%d\n", sizeof(struct S1));
    	printf("%d\n", offsetof(struct S1, c1));
    	printf("%d\n", offsetof(struct S1, i));
    	printf("%d\n", offsetof(struct S1, c2));
    	return 0;
    }

打印结果：12 0 4 8

![6fb1ee701007493f95e81a4a415ed93f.png][]

> c1是第一个成员，所以是0，第二个成员的对齐数是4，所以从4开始，因为int是4个字节，所以占了4个位置，然后c2的对齐数是1，然后8是1的倍数，所以是8.此时的大小是9（因为还有一个0处位置的大小），因为最终大小是最大对齐数的整数倍，所以是12个字节

**对齐规则**

1. 第一个成员在与结构体变量偏移量为0的地址处。  
2. 其他成员变量要对齐到**某个数字（对齐数）**的整数倍的地址处。  
**对齐数** = 编译器默认的一个对齐数 与 该成员大小的**较小值。**（比如该成员是int 4，与8相比，选择4，然后因为） VS中默认对齐数的值为8，linux没有默认对齐数，所以对齐数就是成员自身本身的大小  
3. 结构体**总大小**为最大对齐数（每个成员变量都有一个对齐数）的**整数倍。**  
4. 如果嵌套了结构体的情况，嵌套的结构体**对齐到自己的最大对齐数**的整数倍处，然后根据嵌套结构体的大小，占据相应的字节数， 结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

**注意：** 为了可以既要对齐，又要省空间 。可以让占用空间小的成员尽量集中在一起，以防浪费空间

（每一个成员都要确认一个对齐数，从0开始，总大小（注意加上0的大小）为最大对齐数的倍数）

**为什么存在内存对齐?**  
大部分的参考资料都是如是说的：  
1. 平台原因(移植原因)：  
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特  
定类型的数据，否则抛出硬件异常。  
2. 性能原因：（32位平台，4个字节4个字节的读）  
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。  
原因在于，为了访问未对齐的内存，处理器需**要作两次内存访问；**而对齐的内存访问仅需要一次访  
问。

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

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

\#pragma 这个预处理指令，可以改变我们的默认对齐数

#include <stdio.h>
    #pragma pack(2)  //设置默认对齐数为2
    struct S1
    {
    	char c1;
    	int i;
    	char c2;
    };
    #pragma pack()   //取消设置的默认对齐数，还原为默认
    
    int main()
    {
    	printf("%d\n", sizeof(struct S1));
    	return 0;
    }

打印结果：8

在不改变的情况下为，12.

> 结构在对齐方式不合适的时候，我么可以自己更改默认对齐数

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

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

#include <stdio.h>
    struct S
    {
    	int data[1000];
    	int num;
    };
    struct S s = { {1,2,3,4}, 1000 };
    void print2(struct S* ps)
    {
    	printf("%d\n", ps->num);
    }
    int main()
    {
    	print2(&s); //传地址
    	return 0;
    }

函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。

如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的

下降。

## 二 位段 ##

结构体实现位段的能力

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

> （1）位段的成员必须是 int、unsigned int 或signed int 。（还可以是char类型）  
> （2）位段的成员名后边有一个冒号和一个数字

#include <stdio.h>
    struct A
    {
    	int _a : 2;//_a需要2个比特位
    	int _b : 5;//_b需要5个比特位
    	int _c : 10;//_c需要10个比特位
    	int _d : 30;//_d需要30个比特位
    };  //这就是一个位段
    int main()
    {
        printf("%d\n", sizeof(struct A);
        return 0;
    }

运行结果为：8

> 上述代码位段，首先因为是int类型，所以开辟了4个字节（byte）（32个比特位）的空间，第一行用了2个比特位，第二行用了5个比特位，第三行用了10个比特位，此时还剩下15个比特位，但是第四行需要30个比特位，因为是int类型所以有开辟了4个字节。所以一共是8个字节。
> 
> 对于是先用第一次开辟的剩下15个字节再用第二次开辟的32位中的15个比特位，还是直接用第二次开辟的空间的30个字节，这是C语言中没有定义的。

include <stdio.h>
    
    struct S
    {
    	char a : 3;
    	char b : 4;
    	char c : 5;
    	char d : 4;
    };
    
    int main()
    {
    	printf("%d\n", sizeof(struct S));
    	return 0;
    }

代码运行结果：3

在这里我们可以猜测VS2019，上一次开辟的空间剩下的不够用时，是被抛弃了，并没有用，直接用新开辟的空间。

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

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

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

![474cfadf570e406c8674eaa446befe46.png][]

关于位段成员，怎么在内存中分配，C语言中没有明确的规定，要看编译器，VS2019就是上图所示。

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

> 1. int  位段被当成有符号数还是无符号数是不确定的。 
> 
> 2.  位段中最大位的数目不能确定。（ 16 位机器最大 16 ， 32 位机器最大 32 ，写成 27 ，在 16 位机器会出问题。（在早期16位平台上，sizeof（int）的大小是16bit，在当前32位平台和64位平台是32bit，当写的数字大于16，放在32位或者是64位平台上是有问题的）
> 
> 3.  位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。 
> 
> 4.  当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是 舍弃剩余的位还是利用，这是不确定的。

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

位段本身是不跨平台的。

## 三 枚举 ##

枚举顾名思义就是列举，把可能的取值列举。（枚举是一个常量）

> 一周是从星期一到星期日，是有限的，可以一一列举出来。

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

#include <stdio.h>
    enum Day
    {
    	//枚举的可能取值
    	Mon,
    	Tues,
    	Wed,
    	Thir,
    	Fri,
    	Sta,
    	Sun
    };
    int main()
    {
    	enum Day d = Sun;
    	printf("%d\n", Mon);
    	printf("%d\n", Tues);
    	printf("%d\n", Wed);
    	return 0;
    }

打印的结构为：0 1 2；

以上 定义的的enum Day 就是一个枚举类型，\{\}中的内容是枚举类型的可能取值，叫做枚举常量。

这些可能取值都是有值的，默认从0开始，依次加一，也可以在定义的时候赋初值。

#include <stdio.h>
    
    enum Day
    {
    	//枚举的可能取值
    	Mon = 2,
    	Tues = 3,
    	Wed,
    	Thir,
    	Fri,
    	Sta,
    	Sun
    };
    
    int main()
    {
    	enum Day d = Sun;
    	printf("%d\n", Mon);
    	printf("%d\n", Tues);
    	printf("%d\n", Wed);
    	return 0;
    }

打印的结果为：2 3 4

#include <stdio.h>
    
    enum Day
    {
    	//枚举的可能取值
    	Mon = 2,
    	Tues,
    	Wed = 3,
    	Thir,
    	Fri,
    	Sta,
    	Sun
    };
    
    int main()
    {
    	enum Day d = Sun;
    	printf("%d\n", Mon);
    	printf("%d\n", Tues);
    	printf("%d\n", Wed);
    	return 0;
    }

打印结果：2 3 3

枚举是一个常量，在定义枚举的时候**后**（无论有没有赋值），不可以对可能取值的值进行改变。例如：Mon= 3；（如果想让值发生改变，只能在定义枚举的时候进行赋值）

#include <stdio.h>
    
    enum Day
    {
    	//枚举的可能取值
    	Mon,
    	Tues,
    	Wed,
    	Thir,
    	Fri,
    	Sta,
    	Sun
    };
    
    int main()
    {
    	enum Day s = Mon;// 定义的变量只能是，枚举里面的元素，不能是数字
    //只能用枚举常量给枚举变量赋值
    	printf("%d\n", Mon);
    	printf("%d\n", Tues);
    	printf("%d\n", Wed);
    	printf("%d\n", s);//0
    	printf("%d\n", sizeof(s));//因为是int类型，所以是4
    	return 0;
    }

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

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

## 四 联合（共同体） ##

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

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

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

打印结果： 4 007D9BC 007D9BC 007D9BC

起始地址是一样的，共用一块地址，所以是4个字节。（但是i和c不能一起用这块地址）

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

**习题:判断当前计算机的大小端存储**

> 知识点：低位放在低地址是小端，低位放在高地址是大端

常规写法：

#include <stdio.h>
    
    int cheak_sys()
    {
    	int a = 1;//00 00 00 01(16进制)
    	return *((char*)&a);
    }
    
    int main()
    {
    	int ret = 0;
    	ret = cheak_sys();
    	if (ret == 1)
    		printf("小端\n");
    	else
    		printf("大端\n");
    	return 0;
    }

用联合的方法写：

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

打印结果：小端

### 4.2 联合大小的实现 ###

> 联合的大小至少是最大成员的大小。 
> 
> 当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。 
> 
> （和结构体一样）但是注意起始地址是一样的

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

自定义类型到这里就结束了！！！

[6fb1ee701007493f95e81a4a415ed93f.png]: https://img-blog.csdnimg.cn/6fb1ee701007493f95e81a4a415ed93f.png
[474cfadf570e406c8674eaa446befe46.png]: https://img-blog.csdnimg.cn/474cfadf570e406c8674eaa446befe46.png