C语言——结构体详解

目录

一、结构体类型

1.1结构体

1.1.1 结构体声明

1.1.2 结构体特殊声明

1.3 结构体变量的创建和初始化

1.4 结构体自引用

二、结构体内存对齐

2.1 为什么要结构体对齐

2.2 结构体的对齐规则

2.3 结构体对齐练习

2.3.1代码练习

2.3.2 内存对齐的原因

2.4修改默认对齐数

三、结构体传参

四、结构体实现位段

4.1 什么是位段

4.2 位段的内存分配

4.3位段的跨平台问题

4.4 位段的应用

4.5位段使用的注意事项

---

一、结构体类型

1.1结构体

结构体是由不同类型的数据组合成一个整体，这些组合在一个整体中的数据是互相联系的，结构体中的数据成员可以是基本数据类型（如int、float、char等），也可以是其他结构体类型、指针类型等。

1.1.1 结构体声明

声明只是表示结构体的类型，并不占内存的空间，只有结构体变量初始化或者进行改变的时候，才会占用内存空间。

//声明一个结构休类型的一般形式如下：
struct 结构体名
{成员列表};
 
 
//下面写一个例子，这个student就是一个结构体
struct student
{
	//成员列表，可以有一个或多个
	char name[20];
	int age;
	char sex[5];
	char id[20];
}s1,s2,s3;//变量列表,也可以不设置

1.1.2 结构体特殊声明

在进行结构体声明时，也可以不完全声明。如下：

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

上⾯的两个结构在声明的时候省略掉了结构体名字，那么如在在上面代码的基础上，使用这段代码是否合理呢？ p = &x; 

答案是肯定不合理的，①  编译器会把上⾯的两个声明当成完全不同的两个类型，所以是⾮法的。② 匿名的结构体类型，如果没有对结构体类型重命名的话，基本上只能使⽤⼀次。

1.3 结构体变量的创建和初始化

struct stu
{
	//成员列表，可以有一个或多个
	char name[20];
	int age;
	char sex[10];
	char id[10];
	float grade;
}s1,s2,s3;//变量列表,也可以不设置
 
int main()
{
	//按照默认顺序初始化
	struct stu s1 = { "张三",21,"man","20240001",99.0 };
	printf("%s %d %s %s %f\n", s1.name, s1.age, s1.sex, s1.id, s1.grade);
 
	//指定顺序初始化
	struct stu s2 = { .name = "李四",.grade = 98.0,.age = 20,.id = "20240002",.sex = "woman" };
	printf("%s %d %s %s %f\n", s2.name, s2.age, s2.sex, s2.id, s2.grade);
 
	return 0;
}

1.4 结构体自引用

结构体自引用是指结构体中的一个字段包含了指向自身的指针或引用。这种情况下，结构体实例的某个字段指向了另一个结构体实例，该实例又指向了其他结构体实例，最终又回到了原始结构体实例。这种自引用的结构体可以用来表示复杂的数据结构，如链表、树等。简单来说就是在结构中包含⼀个类型为该结构本⾝的成员。

我们知道数据在内存中有许多存储的方式，如：顺序表、链表等等。其中顺序表在内存中是连续存放的，链表是打乱存放不连续的。而结构体的自引用与链表相似，如下图所示：

因为顺序表在内存中是连续存放的，所以我们只需要知道起始位置 1 就可以依次找到后面的数据；但是链表是不连续的，其存放的每一个数据都保存着下一个数据的地址，所以是知1便能找到2，找到2就能找到3，以此类推，数据就如同被一个链条串起来了一样，故称为：链表结构存储

下面看一段代码，定义⼀个链表的节点：

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

上述代码正确吗？如果正确，那 sizeof(struct Node) 是多少？ 仔细分析，其实是不⾏的，因为⼀个结构体中再包含⼀个同类型的结构体变量，这样结构体变量的大小就会无穷大，是不合理的。下面是正确的自引用方式：

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

在结构体⾃引⽤使⽤的过程中，夹杂了 typedef 对匿名结构体类型重命名，也容易引⼊问题，看看 下⾯的代码，可行吗？

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

答案是不⾏的，因为Node是对前⾯的匿名结构体类型的重命名产⽣的，但是在匿名结构体内部提前使 ⽤Node类型来创建成员变量，这是不⾏的。 解决⽅案如下：定义结构体不要使⽤匿名结构体了

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

二、结构体内存对齐

2.1 为什么要结构体对齐

主要有以下两点原因：

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

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

2. 性能原因：

数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要 作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地 址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对⻬成8的倍数，那么就可以 ⽤⼀个内存操作来读或者写值了。否则，我们可能需要执⾏两次内存访问，因为对象可能被分放在两 个8字节内存块中。

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

2.2 结构体的对齐规则

1.结构体的第⼀个成员对齐到和结构体变量起始位置偏移量为0的地址处

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

     ①对齐数= 编译器默认的⼀个对齐数 与 该成员变量大小的大小值

     ②VS 中默认的值为 8

     ③Linux中 gcc 没有默认对齐数，对齐数就是成员自身的大小

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

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

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

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

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

2.3 结构体对齐练习

2.3.1代码练习

//宏  offsetof-------->  头文件-<stddef.h>
//可以计算结构体成员相较于起始位置的偏移量
//使用方法   offsetof(type,member)
 
struct S1   //6--8
{ 
	// 0  1  2  3  4 5 6 7 8 9 10 … …
	//c1 c2        i-----i  
	//       所占内存   偏移量            
	char c1;//1----------0
	char c2;//1----------1
	int i;  //4----------3-7
};
struct S2    //6--12
{
	// 0  1  2  3  4 5 6 7   8  9  10  11  12  13  14 … …
	//c1           i-----i  c2 第三条，空 
	char c1; //1-- 0
	int i;   //4-- 4-7 
	char c2; //1-- 8
};
struct S3    //13--16
{
	// 0 1 2 3 4 5 6 7   8  9 10 11 12 13 14 15 16  17… …
	// d-------------d   c          i--------i                                   
	double d; //8--  0-7
	char c;   //1--  8
	int i;    //4--  12-15
};
struct S4    //13--32
{
	// 0 …… 8…23  24…31 …
	//c1    s3      d             
	char c1;      //1-- 0
    //在结构体中引用S3,整体占16字节，开始存放依据对齐数
	struct S3 s3; //16- 8-23
	double d;     //4-- 24-31
};
//总结：
// ① S1(8)和S2(12)相同内容，所占空间却不同--------尽量让占用空间小的成员集中在一起，既满足对齐，又节省空间
 
int main()
{
	printf("S1:%zd\n", sizeof(struct S1));//8
	printf("S2:%zd\n", sizeof(struct S2));//12
	printf("S3:%zd\n", sizeof(struct S3));//16
	printf("S4:%zd\n", sizeof(struct S4));//32
	printf("S1中i的偏移量：%zd\n", offsetof(struct S1, i));//4
	printf("S4中d的偏移量：%zd\n", offsetof(struct S4,d));//24
	return 0;
}

上述代码中的四个结构体各个成员在内存中存储如下图所示：

2.3.2 内存对齐的原因

struct S
{
	char c;
	int i;
};

以上述代码为例，在内存中的存储我们分别用对齐和不对齐的方式实现，如下图：

上面是一段不使用内存对齐的模式，下面是一段使用内存对齐的模式。这两者看似对齐浪费内存，但实际上这是一种拿空间来换取时间的操作。

这其实是和编译器的读取有关，vs编译器是32位机器，所以读取字节是一次读四个，而后当你的结构体第一个成员是char类型，第二个成员是int类型时，且不进行对齐那么要读两次内存。甚至不是所有的硬件平台都能访问任意地址上的任意数据的，某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

2.4修改默认对齐数

VS编译器中的默认对齐数是8，这个数值是可以进行编译修改的，我们通过#pragma预处理指令来进行修改

#include<stdio.h>
#pragma pack(1)//设置对齐数为1
 
struct S
{
	char a;
	char b;
	int i;
};
#pragma pack()//对齐数还原为默认
 
int main()
{
	printf("%zd\n", sizeof(struct S));
	return 0;
}

这段代码在上面的练习中，最后的结果为8字节，但是当我们修改对齐数之后，存储就是紧挨着的，此时结果为6字节。

三、结构体传参

结构体传参也有两种方式，分别是直接传参和地址传参，和函数的形参实参类型是一样的，一种传的是值，一种传的是地址，那么说到这里，相信大家已经知道了这两种方式哪个更好。是的就是地址传参，这是因为函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。所以结构体传参的时候，要传结构体的地址。

struct S
{
	int data[1000];
	int num;
};
 
//结构体传参(直接传参)
void print1(struct S s)
{
	printf("%d %d\n", s.data[1],s.num);
}
//结构体地址传参
void print2(struct S* ps)
{
	printf("%d %d\n", ps->data[1], ps->num);
}
 
int main()
{
	struct S s = { {1,2,3,4}, 1000 };
	print1(s); //传结构体
	print2(&s); //传地址
	return 0;
}

四、结构体实现位段

4.1 什么是位段

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

1. 位段的成员必须是 int、unsigned int 或signed int ，在C99中位段成员的类型也可以 选择其他类型。
2. 位段的成员名后边有⼀个冒号和⼀个数字。这个数字最大不可超过当前类型的比特数

struct A
{                //47比特位------8字节（1字节==8比特）
	int _a : 2;  //2比特位
	int _b : 5;  //5比特位
	int _c : 10; //10比特位
	int _d : 30; //30比特位
	//16字节
};
 
printf("%d\n", sizeof(struct A));

这里的A就是⼀个位段类型。根据上面所讲的内存对齐，最后我们可以算出位段A所占内存大小为16字节。

4.2 位段的内存分配

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

struct S
{
	//①从右向左使用（VS环境中）
	//②如果剩余空间不够，就浪费
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};
 
int main()
{
	//printf("%d\n",sizeof(struct A));//一个整型不够，这里要两个整型，8个字节(64比特)
	struct S s = { 0 };
	s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;
	printf("%d\n", sizeof(struct S));
	printf("%d\n", sizeof(s));
 
	return 0;
}

4.3位段的跨平台问题

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

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

4.4 位段的应用

下图是网络协议中，IP数据报的格式，我们可以看到其中很多的属性只需要几个bit位就能描述，这里使用位段，能够实现想要的效果，也节省了空间，这样网络传输的数据报大小也会较小一些，对网络的畅通是有帮助的。

4.5位段使用的注意事项

位段的几个成员共有同一个字节，这样有些成员的起始位置并不是某个字节的起始位置，那么这些位置处是没有地址的。内存中每个字节分配一个地址，一个字节内部的bit位是没有地址的。所以不能对位段的成员使用&操作符，这样就不能使用scanf直接给位段的成员输入值，只能是先输入放在一个变量中，然后赋值给位段的成员。
 

struct A
{
	int _a : 2;
	int _b : 5;
	int _c : 10;
	int _d : 30;
};
 
int main()
{
	struct A sa = {0};
	//scanf("%d", &sa._b); //这是错误的
	//正确的示范
	int b = 0;
	scanf("%d", &b);
	sa._b = b;
	return 0;
}