C语言·自定义类型之结构体与位段

彧..

已于 2023-03-28 15:12:47 修改

阅读量346

点赞数 3

分类专栏： C 文章标签： c语言开发语言

于 2023-03-24 15:23:37 首次发布

本文链接：https://blog.csdn.net/czy02/article/details/129680654

版权

C 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章目录

1.结构体类型的声明

1.1 结构的基础知识

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

1.2 结构的声明

struct tag//struct结构体关键字，tag结构体名字
{
 member-list;//成员变量
}variable-list;//对此结构体类型创造的全局变量

例如描述一个学生：

struct Stu
{
 char name[20];//名字
 int age;//年龄
 char sex[5];//性别
 char id[20];//学号
}s1; //分号不能丢，创建一个s1变量
struct Stu s2；//创建一个s2变量
int main()
{
 sturct Stu s3;//运用结构体创建一个s3变量
 return 0;
}

那么s1，s2，s3变量有什么区别呢？

s3变量是在main函数中定义的这里的s3为局部变量而s1与s2都是全局变量。

1.3 特殊的声明

在声明结构的时候，可以不完全的声明，即匿名结构体类型。
比如：

//匿名结构体类型
struct
{
 int a;
 char b;
 float c;
}x;
struct
{
 int a;
 char b;
 float c;
}a[20], *p;

1.4 结构的自引用

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

//代码1
struct Node
{
 int data;
 struct Node next;
};
//可行否？

是否可以呢？如果可以，那sizeof(struct Node)是多少？
结果是不可以的，这是为什么呢？

试问，在结构体还未完全定义时，怎么能使用呢？

正确的自引用方式：

//代码2
struct Node
{
 int data;
 struct Node* next;
};

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

当会声明结构体变量就，结构体变量的定义和初始化就非常简单。

struct stu
{
	char name[20];
	char sex;
	int age;
}s1;//声明类型的同时定义变量s1
struct stu s2;//定义变量s2
int main()
{
	struct stu s3;//定义一个结构体变量s3
	struct stu s[10];//定义一个结构体数组s
	return 0;
}

在结构体变量的定义时有可能会因为结构体名称过长而导致十分麻烦，此时可以使用typedef

#include<stdio.h>
typedef struct stu
{
	char name[20];
	char sex;
	int age;
}S;//声明类型
//此处S可以替换struct stu
S s1;//定义变量s1
int main()
{
	S s3;//定义一个结构体变量s3
	S s[10];//定义一个结构体数组s
	return 0;
}

结构体初始化与嵌套初始化

struct Stu        //类型声明
{
 char name[15];//名字
 int age;      //年龄
};
struct Stu s = {"zhangsan", 20};//初始化
struct Node
{
 int data;
 struct Point p;
 struct Node* next; 
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

1.6 结构体内存对齐

结构体的声明、定义、初始化都已经说完了，那么接下来来到了结构体最有意思的知识点，结构体的内存对齐。
内存对齐顾名思义这是关于结构体内存的知识点。我们先来看一个题

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

这里会输出什么呢？
在不了解结构体内存对齐，之前我想答案会是6

但是既然在这里出现了，又这样问出来了那么铁定会有猫腻。那么就来介绍一下结构体内存对齐的规则。
1.第一个成员在结构体变量偏移量为0 的地址处。
2.其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。对齐数 = 编译器默认的一个对齐数与该成员大小中的较小值。vs中默认值是8 Linux默认值为4.
3.结构体总大小为最大对齐数的整数倍。（每个成员变量都有自己的对齐数）
4.如果嵌套结构体，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（包含嵌套结构体的对齐数）的整数倍。

那么我们接着看上面那段代码，char类型与int类型的大小分别是一个字节和四个字节，所以char类型与int类型的偏移值分别为1、4（假设此处使用VS，则默认偏移值的大小为8，因为char类型与int类型的大小都小于默认偏移值，所以此处的偏移值为1、4）

由于int类型的偏移值为4所以当储存c1、c2后不能紧接储存i，而是浪费了两个字节，从偏移值4的整数倍处继续储存。所以该结构体的大小为8个字节。

为什么会存在内存对齐？

大部分的参考资料都是如是说的：

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

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

那么在设计结构体的时候，我们既要满足对齐，又要节省空间，做到让占用空间小的成员尽量集中在一起。

//例如：
struct S1
{
 char c1;
 int i;
 char c2;
};
struct S2
{
 char c1;
 char c2;
 int i;
};

可以看到S1、S2中的成员类型是一样的，但是S1、S2两个结构体的大小却是不一样的。S1的大小是12个字节，S2的大小是8个字节。可以明显地看出排列顺序不同的成员方式，结构体的大小可能有很大的差别，所以在设计结构体的时候要对结构体内部成员的顺序进行恰当的排列，当然在特殊要求的情况下除外。

1.7 修改默认对齐数

这里我们使用#pragma，可以改变我们的默认对齐数。

#include <stdio.h>
#pragma pack(8)//设置默认对齐数为8
struct S1
{
 char c1;
 int i;
 char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
#pragma pack(1)//设置默认对齐数为1
struct S2
{
 char c1;
 int i;
 char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
int main()
{
    //输出的结果是什么？
    printf("%d\n", sizeof(struct S1));//12
    printf("%d\n", sizeof(struct S2));//6
   	return 0;
}

经过上面关于结构体内存对齐的定义我们可以知道，分别输出12、6。同样的成员类型，不同样的默认对齐数，结构体的大小也会不同，所以当对齐结果不理想时，我们直接修改默认对齐数。

1.8 结构体传参

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

那么这里使用print1的传参方式还是print2的传参方式呢。
答案是，print2的传参方式，传地址。
原因：

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

所以在结构体传参的时候，要传结构体的地址。

2. 位段

2.1 什么是位段

结构体说完就不得不说一下结构体实现位段的能力。
位段的声明和结构是类似的，但是也是有不同的：

1.位段的成员必须是 int、char、unsigned int 或signed int
2.位段的成员名后跟冒号加数字(数字表示该变量所占bit位数)。

比如：

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

A就是一个位段类型。
那位段A的大小是多少？

在VS2022 X86环境下 printf("%d\n", sizeof(struct A));
输出的是 8（单位字节，1byte=8bit）

2.2 位段的内存分配

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

由于位段的存在很多不确定因素，因此我们只在VS2022 X86环境下做出以下假设
1.当该字节空间不足以存放时，使用下一个字节，该字节剩余空间闲置（并没有明确标准规定，空余空间如何处理，取决于编译器）
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;
	return 0;
}

在上文假设的基础上，我们对此代码进行分析。
储存分析图
则在内存中的实际储存为
内部实际储存图
为了验证所提出的假设是否正确，在VS2022 X86环境下进行调试
得到：
假设确认
由于在内存中展示的是数据的十六进制的大小，所以我们先将二进制转换成十六进制
十六进制转换
在这里插入图片描述
可以看到在VS2022 X86环境下,符合上面所做的假设。对此可以提出，在VS2022 X86环境下位段的储存符合以下条件

1.当该字节空间不足以存放时，使用下一个字节，该字节剩余空间闲置。
2.位段的储存是由低地址到高地址。

2.3 位段的跨平台问题

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

2.4位段的实际应用

位段到底有什么用呢？我们看上文的代码，通过位段可以实现将原本需要四个字节储存的数据，控制到了三个字节，我们定义一个int类型的变量asize_t a;(unsigned int)在这个变量a中，我们仅储存0或1(在使用位段时如果数据大小超过所设定的大小会发生截断)，则在32位bit位中仅使用了1位，剩余的31位则不会被使用，此时则会造成内存浪费，所以在此时使用位段，可以极大的省略空间。