作者:旧梦拾遗186
每日励志:
不敢奢求有锦鲤般的运气,但求一切顺利,不忘初心,砥砺前行,长路漫漫,未来可期。
前言:今天小编带大家对结构体进行整理,帮大家深入理解结构体。
目录
1.结构体:
1.1 结构的基础知识:
结构是一些值的集合,这些值称为成员变量。结构的每个成员可以是不同类型的变量。
1.2 结构的声明:
基本框架:
struct tag { member-list; }variable-list;
举个例子:
例如描述一个学生:
struct Stu { char name[20];//名字 int age;//年龄 char sex[5];//性别 char id[20];//学号 }; //分号不能丢
1.3特殊声明:
在声明结构的时候,可以不完全的声明,我们称之为 匿名结构体类型 。比如://匿名结构体类型 struct { int a; char b; float c; }x; struct { int a; char b; float c; }a[20], *p;
上面的两个结构在声明的时候省略掉了结构体标签(tag)。
这里存在一个问题?
我们主观上会认为这两个结构体是一样的,但是在编译器看来,两个结构体就是两个不同的自定义类型,即使他们的成员变量都一样。所以变量 x 的地址不能存放在另一种类型的结构体指针变量 p 当中。
//在上面代码的基础上,下面的代码合法吗? p = &x;
另一个错误使用的案例:匿名结构体的变量只能定义一次,并且只能是在结构体声明的时候定义。
如果我们非要定义第二次变量,或者是不在结构体声明时定义变量,那么编译器就会报错。
#include<stdio.h> //匿名结构体类型 struct//省略了结构体标签 { int data[100]; int age; }s1; int main() { struct s = { {1,2,3},100 }; return 0; }
1.4 结构体的自引用
下边我们来判断一下以下自引用方式是否可行?
//代码1 struct Node { int data; struct Node next; }; //可行否? 如果可以,那sizeof(struct Node)是多少?
很明显是不合法的,就比如要使用 sizeof 计算结构体的大小,那么这个大小能计算的出来吗?这就类似陷入了死递归。
改进方式:
#include<stdio.h> struct Node { int data; struct Node* next; }; int main() { printf("%d", sizeof(struct Node)); return 0; }
这种写法就是链表的写法,一个结点包含数据域和指针域,这个大小是可算的,因为指针的大小很明确。
至于这里为什么是16而不是其他数我们下边讲到结构体对齐数是会详细讲解。
我们再来结合 typedef 关键字来分析一段代码是否正确:
#include<stdio.h> typedef struct { int data; Node* next; }Node; int main() { return 0; }
这个问题就类似于是先有鸡还是先有蛋了。这里要说的是,成员变量的声明是先于类型重命名的。也就是说,我们使用类型重定义后的类型名来声明指针,那么在编译器看来是非法的。
解决方法:
#include<stdio.h> typedef struct Node { int data; struct Node* next; }Node; int main() { return 0; }
给struct Node结构体类型重命名叫做Node
结构体声明中不能引用自己,但是可以引用其他的结构体:
struct Person { char name[20]; char sex[10]; int age; }; struct Count { struct Person data[100];//struct Person 类型的数组 int count; }; int main() { return 0; }
1.5 结构体变量的定义和初始化
先说一下定义:定义就非常简单了,只需要一个类型+变量名即可struct Point { int x; int y; }p1; //声明类型的同时定义变量p1 struct Point p2; //定义结构体变量p2 struct Stu //类型声明 { char name[15];//名字 int age; //年龄 }; struct Node { int data; struct Point p; struct Node* next; }n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
初始化:初始化就是在定义变量的时候顺带赋值。//初始化:定义变量的同时赋初值。 struct Point p3 = {x, y}; struct Stu s = {"zhangsan", 20};//初始化 struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化
赋值的方法与数组是一样的,只需要注意顺序、成员变量的类型即可。
1.6 结构体变量的数据输出:
有了定义初始化我们来学习下怎么利用printf进行输出?
#include<stdio.h> typedef struct Node { int age; char name[100]; }student; int main() { student a = { 18,"zhangsan" }; student b = { 19,"lisi" }; printf("%d,%s\n", a.age, a.name); printf("%d,%s\n", b.age, b.name); return 0; }
可以看到一个全新的字符 '.' 。这就跟数组的原理是一样的,想要输出数组的某个元素,只需要引用这个元素的下标即可。只不过在结构体中,需要用 结构体变量.成员变量。
1.7 结构体内存对齐
我们已经掌握了结构体的基本使用了。现在我们深入讨论一个问题: 计算结构体的大小。这也是一个特别热门的考点: 结构体内存对齐
先看一段代码:#include <stdio.h> struct S1 { char c1; int i; char c2; }s1; int main() { printf("%d\n", sizeof(s1)); return 0; }
这里的结果按理来说应该是6啊两个char类型2个字节一个int类型四个字节,但为什么结果是12呢?这就涉及到了结构体内存对齐。
首先得掌握结构体的对齐规则:1. 第一个成员在与结构体变量偏移量为0的地址处。2. 其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。VS中默认的值为83. 结构体总大小为最大对齐数(每个成员变量都有一个对齐数)的整数倍。4. 如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。就例如我们现在分析这个例题为什么是 12 :
我们再看一个例题,也是求结构体的大小:
#include <stdio.h> //练习2 struct S2 { char c1; char c2; int i; }; int main() { printf("%d\n", sizeof(struct S2)); return 0; }
接下来我们来学会计算结构体嵌套的问题:
#include <stdio.h> //练习4-结构体嵌套问题 struct S3 { double d; char c; int i; }; struct S4 { char c1; struct S3 s3; double d; }; int main() { printf("%d\n", sizeof(struct S4)); return 0; }
至于为什么存在结构体内存对齐,大部分的参考资料给出两个原因:
平台原因(移植原因):不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特定类型的数据,否则抛出硬件异常。
性能原因:数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于,为了访问未对齐的内存,处理器需要作两次内存访问;而对齐的内存访问仅需要一次访问。
总体来说:结构体的内存对齐是拿空间换时间的做法。
不过我们需要注意,并不是所有的开发环境都有默认对齐数的。 例如在 gcc 平台下就没有默认对齐数这一说法。
让占用空间小的成员尽量集中在一起。struct S1 { char c1; int i; char c2; }; struct S2 { char c1; char c2; int i; };
S1 和 S2 类型的成员一模一样,但是 S1 和 S2 所占空间的大小有了一些区别。
1.8 修改默认对齐数
我们可以使用 #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)); printf("%d\n", sizeof(struct S2)); return 0; }
1.9 结构体传参
这就跟我们普通数据传参一样的道理。如果我们想要在某个函数内改变外部变量的内容,就必须要传地址(使用指针)。
比如说,我们的结构体已经初始化好了,只需要封装一个打印函数打印结构体的内容,不涉及到改变内容,那我们可以不使用地址传参:
#include <stdio.h> typedef struct Person { char name[20]; char sex[10]; int age; }Person; void print(Person person) { printf("%s %s %d\n", person.name, person.sex, person.age); } int main() { Person person = { "lisi","男",20 };//结构体已经初始化 print(person); return 0; }
现在我们想封装一个函数来专门初始化结构体的内容,那么这时候就需要传址调用:
#include <stdio.h> #include <string.h> typedef struct Person { char name[20]; char sex[10]; int age; }Person; void Init(Person* per) { strcpy(per->name, "张三");//per->name 相当于 (*per).name ,找到的是数组的地址, strcpy(per->sex, "男");//如果 per->name = "张三"; 这样赋值的话是相当于在修改数组的地址 per->age = 20; printf("%s %s %d\n", per->name, per->sex, per->age); } int main() { Person person; Init(&person); return 0; }
再看一个案例:
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 、 unsigned int 或 signed int 。2. 位段的成员名后边有一个冒号和一个数字。
2.2 位段的声明
struct A { char a : 2; char b : 3; char c : 4; };
2.3 位段的内存分配
我们应该如何计算位段的大小呢?
#include <stdio.h> struct A { char a : 2; char b : 3; char c : 4; }; int main() { printf("%d", sizeof(struct A)); return 0; }
首先,位段,就是控制位。就比如上面这段代码,我们定义了一个 char 类型变量 a 。这个 a 本来是有 8 个比特位的。但是我使用位段使 a 的比特位只有 2 个了,b 修改成只有 3 个了,c 修改成只有 4 个了。
在定义 a 时就会开辟一个字节的空间大小,即 8 个比特位。但是 a 现在只有 2 个比特位,放进这一个字节当中还剩 6 个比特位,b 只有 3 个比特位还可以往里放,这时空间大小还剩 3 个比特位,这就不够 c 放了,因为 c 有 4 个比特位,那么此时又会单独开辟一块空间一字节的空间大小。所以位段 A 的大小是 2 字节。
1. 位段的成员可以是 int unsigned int signed int 或者是 char (属于整形家族)类型2. 位段的空间上是按照需要以 4 个字节( int )或者 1 个字节( char )的方式来开辟的。3. 位段涉及很多不确定因素,位段是不跨平台的,注重可移植的程序应该避免使用位段。例子:#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; }
在开辟空间的时候我们从地址向高地址开辟,存储的时候我们都假设,内存从低位想高位使用。
说明我们的假设是正确的
这里在提一嘴,如果我们定义的数据的二进制位超过了我们定义的位段,那么就会发生截断。这与 整形数据放在字符类型空间里的道理一样。
当所要讨论的变量大于1字节是才考虑大小端存储
2.4存在的问题:
位段的跨平台问题
1. int 位段被当成有符号数还是无符号数是不确定的。2. 位段中最大位的数目不能确定。( 16 位机器最大 16 , 32 位机器最大 32 ,写成 27 ,在 16 位机器会出问题。3. 位段中的成员在内存中从左向右分配,还是从右向左分配标准尚未定义。4. 当一个结构包含两个位段,第二个位段成员比较大,无法容纳于第一个位段剩余的位时,是舍弃剩余的位还是利用,这是不确定的
总结:跟结构相比,位段可以达到同样的效果,但是可以很好的节省空间,但是有跨平台的问题存在