C语言自定义类型讲解 — 结构体

悠悠 2023-10-05 23:03 4阅读 0赞

枚举：[http://t.csdn.cn/GNP51][http_t.csdn.cn_GNP51]

联合体：[http://t.csdn.cn/xPGVu][http_t.csdn.cn_xPGVu]

前面学到了C语言中的内置类型：char,int…

C语言中还有一种类型是自定义类型，其中包括了**结构体**，联合体和枚举。  
那么今天来学习自定义类型中的结构体类型。

![9779ad6b07eb43eaa1bb0d24f5d889bb.jpeg][]

**本章重点**

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

**目录**

结构体

1.结构体的声明

1.1 结构基础知识

1.2 结构的声明

1.3 特殊的声明

1.4 结构的自引用

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

1.6 结构体内存对齐

结构体的对齐规则

为什么存在内存对齐

1.7 修改默认对齐数

1.8 结构体传参

2.位段

1.什么是位段

2.位段的内存分配

位段是如何分配空间的

3.位段的跨平台问题

4.位段的应用

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

## 结构体 ##

## 1.结构体的声明 ##

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

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

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

![c1c35f6fba0d452b83d7a714c8bbb1bd.png][]

下里面来定义一个描述学生的类型：

struct stu
    {
    	//学生的相关属性
    	char name[20];//成员name
    	int age;//成员age
    } s1,s2;

**结构体**标签一般是关于结构体是用来干什么的，s1和s2是 struct stu 类型的变量。

注意：结构体只是创造出来的一中类型，不用初始化。

上面的代码也可以这样写，省去变量列表，也是没问题的。

struct stu
    {
    	//学生的相关属性
    	char name[20];//成员name
    	int age;//成员age
    };

若此时结构体在main函数里面，s1和s2是**局部变量**；若在main外面是**全局变量**。

#include<stdio.h>
    
    int main()
    {
    	struct stu
    	{
    		//学生的相关属性
    		char name[20];//成员name
    		int age;//成员age
    	} s1, s2;//局部变量
    	return 0;
    }

#include<stdio.h>
    
    struct stu
    {
    	//学生的相关属性
    	char name[20];//成员name
    	int age;//成员age
    } s1, s2;//全局变量
    
    int main()
    {
    	
    	return 0;
    }

**struct stu** 是声明的一个结构体类型，我们还可以拿他创建一个s3变量。所创建出来的s3是局部变量。

#include<stdio.h>
    
    struct stu
    {
    	//学生的相关属性
    	char name[20];//成员name
    	int age;//成员age
    } s1, s2;//全局变量
    
    int main()
    {
    	struct stu s3;//局部变量
    
    	return 0;
    }

外面可以在创建结构体的同时创建变量。也可以在main里利用结构体创建变量。但是一定要注意的是结构体的**分号不能丢**。

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

在声明的时候，可以**不完全声明**

结构体的名字可以省略，变成 **匿名结构体类型**

//匿名结构体类型
    struct
    {
    	//学生的相关属性
    	char name[20];//成员name
    	int age;//成员age
    } s1, s2;

####  ####

匿名结构体的使用

//匿名结构体类型
    struct
    {
    	//学生的相关属性
    	char name[20];//成员name
    	int age;//成员age
    } s1;
    
    int main()
    {
    
    	return 0;
    }

s1是用匿名结构体创建的变量。

注意：这个变量只能使用一次 - 声明类型的时候所创建的变量s1以后就用不了。

struct
    {
    	int a;
    	char b;
    	float c;
    } x;
    
    struct
    {
    	int a;
    	char b;
    	float c;
    } a[20], *p;

上面的两个结构体在声明的时候省略掉了结构体标签

那么问题来了？

在上面代码的基础上，下面的代码合法吗？

p = &x;

代码演示：

struct
    {
    	int a;
    	char b;
    	float c;
    } x;
    
    struct
    {
    	int a;
    	char b;
    	float c;
    } a[20], *p;
    
    int main()
    {
    	p = &x;
    	return 0;
    }

代码虽然跑过了，但是会报警告。

![399dd337d4bc4093a6d5ca64303953aa.png][]

原因：因为编译器会把上面的两个声明当做是两个完全不同的类型。

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

在结构中包含是一个类型为该结构本身的成员

数据结构是数据在内存中的存储结构，有线性，和树形（二叉树）。  
其中线性又分为顺序表和链表。  
其中顺序表是数据在内存中连续存放的，通过找到第一个数据就可以找到后面的数据。  
但是链表的数据不是连续存放的，那么就需要通过上一个数据能找到下一个数据，那么这是后可以通过结构体的自引用

但是，下列结构体的自引用是错误的

错误写法：

struct Dode
    {
    	int data;
    	struct Dode next;//自引用
    };
    
    int main()
    {
    	sizeof(struct Dode);
    	return 0;
    }

未来定义一个结点的时候，这个结点既可以放一个数值，又可以放下一个结点。这样就可以做到1结点找到2结点，2结点找到3结点，直到找到5结点，但是这样写**存在问题**。

结构体里面有一个date，还有一个next；而next又是struct Dode类型的，所以next也有有个next，在这里会一直套下去，sizeof无法计算大小，程序会报错。

![b93f4d3b4c6243c990e432633d39c1e6.png][]

正确写法：

可以在一个结点中存放**数据**和下一个结点的**地址**

struct Dode
    {
    	int data;
    	struct Dode* next;
    };
    
    int main()
    {
    	sizeof(struct Dode);
    	return 0;
    }

这个时候结点中存放的是一个数据和下一个结点的地址，用来存放数据的叫数据域，存放下一个结点的地址的叫指针域。

![f4adc7be28224569a8e6afe7afd5b467.png][]

这个时候我们就可以把一个一个的数据串联起来，形成一个链表了。

总结：

> 结构体里面包含一个同类型的结构体是不行的，要包含一个的结构体指针。

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

有了结构体类型，那该如何定义变量呢？

struct point
    {
    	int x;
    	int y;
    }p1 = { 2, 3 };

![cf86d0600c0249138ddcc64203f59dac.png][]

用结构体定义变量就像是用图纸盖房子，即使是有了图纸也不能直接盖房子，还需要有砖头、水泥等材料和工具才行。结构体就相当于是图纸，所创建的成员变量就相当于是砖头和水泥。利用这几样定义了一个p1变量，这叫定义；在定义变量的时候赋值，这叫初始化。上面2，3就是给p1赋的值，可以把p1看成一座房子，而2，3则是房子里的家具。

**定义：**

struct point
    {
    	int x;
    	int y;
    }p1;//声明结构体的同时定义p1变量
    
    int main()
    {
    	struct point p2;//定义结构体变量p2
    }

可以在声明结构体类型的时候定义变量，也可以用所声明的类型定义变量。

**初始化：**

struct stu
    {
    	char name[20];
    	int age;
    } p3 = { 1,2,3 };
    
    int main()
    {
    	struct stu s = { "lisi", 20 };
    	return 0;
    }

在定义变量之后紧跟着赋值。

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

结构体的大小如何计算？

代码结果：

![c26f1151bc814b2eb4bf11d8bffc65a3.png][]

这两段代码只是成员变量的顺序变了其他的都一样，那为什么**结果不一样**呢？

#### 结构体的**对齐规则** ####

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

**代码1：**

struct S1
    {
    	char c1;
    	int i;
    	char c2;
    };
    
    int main()
    {
    	printf("%d\n", sizeof(struct S1));
    	return 0;
    }

代码结果：

![e62531692296467daa0d8ee90355edfb.png][]

> 1.  根据对起规则知S1中的c1存放在偏移量为0处。占用一个字节即0.
> 2.  因为int类型为4个字节小于8，那么该成员S1中的 i 的对齐数是4，即 i 要存放在4的倍数的偏移量处，即存放在偏移量为4处。占用了四个字节即4~7
> 3.  因为char类型为1个字节小于8，那么该成员i的对齐数是1，即i要存放在1的倍数的偏移量处，即存放在偏移量为8处。占用一个字节即8。
> 4.  计算上面的字节数为9，不是该结构体总大小为最大对齐数4的倍数，那么要继续增加到12，那么结构体的大小就是12。

![ff6b3a24f9d3407ea945a43289b04501.png][]

对齐规则很重要！很重要！很重要！

**代码2：**

struct S2
    {
    	char c1;
    	char c2;
    	int i;
    };
    
    int main()
    {
    	printf("%d\n", sizeof(struct S2));
    	return 0;
    }

代码结果：

![40f7856ec5774ffeb991de6d2a20160e.png][]

> 1.  根据对起规则知c1存放在偏移量为0处。占用一个字节即0.
> 2.  因为char类型为1个字节小于8，那么该成员i的对齐数是1，即i要存放在1的倍数的偏移量处，即存放在偏移量1处。占用一个字节即1。
> 3.  因为int类型为4个字节小于8，那么该成员i的对齐数是4，即i要存放在4的倍数的偏移量处，即存放在偏移量为4处。占用了四个字节即4~7
> 4.  计算上面的字节数为8，是该结构体总大小为最大对齐数4的倍数，结构体的大小就是8。

![5a12022a324844e399e9743b11be108e.png][]

下面给出两个练习题，来练习巩固前面讲的对齐规则。要注意的是练习2中的S4有一个成员是结构体（S3），S4的大小就包括了S3的大小。

练习1：

struct S3
    {
    	double d;
    	char c;
    	int i;
    };
    
    int main()
    {
    	printf("%d\n", sizeof(struct S3));
    	return 0;
    }

代码结果是，**16**

练习2：

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));
    	printf("%d\n", sizeof(struct S4));
    	return 0;
    }

代码结果是，**32**

#### 为什么存在内存对齐 ####

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

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

在设计结构体的时候，尽量让占用空间小的成员尽量集中在一起，因为这样既可以满足对齐，又可以节省空间。

在使用的时候，尽量用S2来代替S1的写法，因为可以节省更多的空间。

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

\#pragma 这个预处理指令，这里我们再次使用，可以改变我们的默认对齐数。

一般修改默认对齐数都为2的倍数。

struct S
    {
    	int i;
    	double d;
    };
    
    int main()
    {
    	printf("%d\n", sizeof(struct S));
    	return 0;
    }

代码结果：

![29434e5730c047d5a72e6538b626b786.png][]

默认对齐数是8，所以代码结果是16

#pragma pack(4)//将对齐数改为4
    
    struct S
    {
    	int i;
    	double d;
    };
    #pragma pack()//将对齐数改为默认值8
    
    int main()
    {
    	printf("%d\n", sizeof(struct S));
    	return 0;
    }

代码结果：

![37e60e52d3fb4dd49b17c2f37660ef9b.png][]

修改对齐数后，代码输出12.

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

struct S
    {
    	int date[1000];
    	int num;
    };
    
    void print1(struct S ss)
    {
    	int i = 0;
    	for (i = 0; i < 3; i++)
    	{
    		printf("%d ", ss.date[i]);
    	}
    	printf("%d\n", ss.num);
    }
    
    void print2(struct S* ps)
    {
    	int i = 0;
    	for (i = 0; i < 3; i++)
    	{
    		printf("%d ", ps -> date[i]);
    	}
    	printf("%d\n", ps -> num);
    }
    
    int main()
    {
    	struct S s = { {1,2,3}, 100 };
    	print1(s);
    	print2(&s);
    	return 0;
    }

代码结果：

![81b3b8e5d8e24380be54829efbcc2956.png][]

print1 和 print2 哪个函数的效果更好呢？

答案是：print1

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

结论：**结构体传参的时候，要传结构体的地址。**

参数具体是怎样压栈的，我在其它的文章中有做详细讲解，下面是链接。

函数的栈帧的开辟与销毁：[http://t.csdn.cn/2HSWx][http_t.csdn.cn_2HSWx]

## 2.位段 ##

位段是有结构体实现的

### 1.什么是位段 ###

位段的声明和结构是类似的，有两个不同：

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

注意：成员后面的数字不能超过类型的大小。若a是 int 类型，数字最大是32。

实际上 char 也可以是位段的成员，因为字符在底层存储的是 ASCII 码，并且只要是整形家族就都可以。

例1：

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

位段的位其实是比特位的意思。

> a后面的数字表示，a只需要2个比特位。
> 
> a后面的数字表示，b只需要5个比特位。
> 
> a后面的数字表示，c只需要10比特位。
> 
> a后面的数字表示，d只需要30个比特位。

4个成员明明是 int 类型，应该是32比特位，那2、5、10、30又是什么意思呢？

比如说\_a不需要那么多的空间，所以只分配了2个比特位的空间，也就是用多少取多少。

这里也就可以看出，位段其实是用来节省空间的。

例2：

#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));
    	return 0;
    }

代码结果：

![57fee75ee99c4f97a3485748c1be7b05.png][]

1个整形4个字节，4个整形应该是16个字节，那结果为什么会是8呢？4个成员一共是47个比特位，那给6个字节，就够用了，应该输出的是6，但是结果也不对。

注意：所谓的节省空间并不是极致的节省空间，而是适当的节省空间。如果不使用位段的话，那将会开辟16个字节的空间。

具体是什么原因。在下面的位段的内存分配有做详细介绍。

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

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

前面例2的解释：因为先开辟4个字节的空间，一共是32个比特位。4个成员一共有47个比特位，分配完之后还剩下15个比特位没有空间存放了，所以在开辟4个字节给剩下的15个比特位使用，所以才是8个字节。

一般都是位段的类型都会是同一种类型，要不然的话，这个位段会非常复杂。

#### 位段是如何分配空间的 ####

例3：

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

情况1：

1.  看见是char，所以先**开辟1个字节**，a占3个比特位，还剩下5个比特位。
2.  b有4个比特位，给b分配后还剩1个比特位，不够c分配了，所以把剩下的1个比特位舍弃。
3.  再**开辟1个字节**，给c分配完之后还剩下3个，不够d分配了，还要再**开辟1个字节**给d。

如果输出3则说明是情况1，空间不够的话会直接开辟新的空间，多余出来的比特位会直接浪费掉。

情况2：

1.  先**开辟1个字节**，给a分配完以后，还剩5个比特位。
2.  给b分配完后，还剩1个比特位，再**开辟1个字节**，加上前面剩下的就还有9个比特位。
3.  给c用完后还剩4个比特位，这个时候可以正好给d分配。

如果输出2则说明是情况2，空间不够的话会直接再开辟1个字节的空间，之前剩下的空间也会继续参与分配。

代码结果：

![e2fbd5e74a234c0aa193910aa90e5d2d.png][]

例4：

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

存储前的内存：

![0adbbfe7daa6456bbc16ea89182a86fe.png][]

存储后的内存：

![68b110a488484b259c0fb90e564d2ed2.png][]

1.  a的二进制序列是1010，但是a只有3个比特位的空间，所以只会存放010。
2.  这个字节还剩下5个比特位，而b二进制序列是1100，剩下的空间可以放得下。
3.  这个时候不够存c了，需要再开辟一个空间。
4.  c的二进制是011,但是不够5个比特位所以要补0,变成00011。
5.  因为只剩下3个比特位的空间，不够d使用了，所以要再开辟1个空间
6.  4的二级制序列是0100，空间正好够用。

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

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

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

### 4.位段的应用 ###

![4f085e68107940fb825ea3ddd49461d9.png][]

[http_t.csdn.cn_GNP51]: http://t.csdn.cn/GNP51
[http_t.csdn.cn_xPGVu]: http://t.csdn.cn/xPGVu
[9779ad6b07eb43eaa1bb0d24f5d889bb.jpeg]: https://img-blog.csdnimg.cn/9779ad6b07eb43eaa1bb0d24f5d889bb.jpeg
[c1c35f6fba0d452b83d7a714c8bbb1bd.png]: https://img-blog.csdnimg.cn/c1c35f6fba0d452b83d7a714c8bbb1bd.png
[399dd337d4bc4093a6d5ca64303953aa.png]: https://img-blog.csdnimg.cn/399dd337d4bc4093a6d5ca64303953aa.png
[b93f4d3b4c6243c990e432633d39c1e6.png]: https://img-blog.csdnimg.cn/b93f4d3b4c6243c990e432633d39c1e6.png
[f4adc7be28224569a8e6afe7afd5b467.png]: https://img-blog.csdnimg.cn/f4adc7be28224569a8e6afe7afd5b467.png
[cf86d0600c0249138ddcc64203f59dac.png]: https://img-blog.csdnimg.cn/cf86d0600c0249138ddcc64203f59dac.png
[c26f1151bc814b2eb4bf11d8bffc65a3.png]: https://img-blog.csdnimg.cn/c26f1151bc814b2eb4bf11d8bffc65a3.png
[e62531692296467daa0d8ee90355edfb.png]: https://img-blog.csdnimg.cn/e62531692296467daa0d8ee90355edfb.png
[ff6b3a24f9d3407ea945a43289b04501.png]: https://img-blog.csdnimg.cn/ff6b3a24f9d3407ea945a43289b04501.png
[40f7856ec5774ffeb991de6d2a20160e.png]: https://img-blog.csdnimg.cn/40f7856ec5774ffeb991de6d2a20160e.png
[5a12022a324844e399e9743b11be108e.png]: https://img-blog.csdnimg.cn/5a12022a324844e399e9743b11be108e.png
[29434e5730c047d5a72e6538b626b786.png]: https://img-blog.csdnimg.cn/29434e5730c047d5a72e6538b626b786.png
[37e60e52d3fb4dd49b17c2f37660ef9b.png]: https://img-blog.csdnimg.cn/37e60e52d3fb4dd49b17c2f37660ef9b.png
[81b3b8e5d8e24380be54829efbcc2956.png]: https://img-blog.csdnimg.cn/81b3b8e5d8e24380be54829efbcc2956.png
[http_t.csdn.cn_2HSWx]: http://t.csdn.cn/2HSWx
[57fee75ee99c4f97a3485748c1be7b05.png]: https://img-blog.csdnimg.cn/57fee75ee99c4f97a3485748c1be7b05.png
[e2fbd5e74a234c0aa193910aa90e5d2d.png]: https://img-blog.csdnimg.cn/e2fbd5e74a234c0aa193910aa90e5d2d.png
[0adbbfe7daa6456bbc16ea89182a86fe.png]: https://img-blog.csdnimg.cn/0adbbfe7daa6456bbc16ea89182a86fe.png
[68b110a488484b259c0fb90e564d2ed2.png]: https://img-blog.csdnimg.cn/68b110a488484b259c0fb90e564d2ed2.png
[4f085e68107940fb825ea3ddd49461d9.png]: https://img-blog.csdnimg.cn/4f085e68107940fb825ea3ddd49461d9.png