【c语言】详解结构体

目录

• 什么是结构体？
• 结构体的声明
• 结构体变量的创建和初始化
• • 匿名结构体类型
  • 结构体的自引用
  • 结构体的初始化
  • • 普通初始化
    • 指定初始化
    • 结构体内存对齐
    • • 对齐规则
      • 默认对齐数的修改
      • ���构体传参

        什么是结构体？

        在学习每个类型之前我们需要了解其存在的意义，即什么是结构体？为什么要引入结构体这个类型呢？

        我们可以想象现实中我们是如何处理一个人信息的？假设现在要汇总每个同学的个人信息，这时我们会对每个人的姓名，年龄等信息单独建表吗？显然不会，通常会给每个人发一张信息采集表，在表上可以填写每个人的姓名，年龄，体重等信息。

        在c语言中像这种信息采集表形式的数据结构是通过结构体来实现的。其中姓名，年龄等信息就是结构体的成员变量，显然这些结构体的成员变量可以是不同的数据类型。

        在引入结构体这个类型后，我们想表示类似学生信息这样的工作时，就会大大减少变量的创建，也减少了我们的工作量，提高了代码的可读性。

        结构体的声明

        上面解释了什么是结构体，为什么要引入结构体这个类型。接下来具体介绍结构体，首先是结构体的声明：

        struct tag{     member-list;//成员名}variable-list;

        我们以学生信息为例：

        struct Stu{     char[20] name;//姓名     int age;//年龄     double height;//身高};//分号不能丢

        这里每个结构体变量有三个不同类型的成员：name（学生姓名），age（学生年龄），height（学生身高）。其中，结构体的名字Stu称为结构名(struct tag)，{}声明的name,age等称为结构体成员(member-list)。

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

        匿名结构体类型

        在声明结构体的时候，可以不完全声明，比如：

        struct{     int a;     char b;     float c;}x;

        上⾯的结构体在声明的时候省略掉了结构体标签（tag）。但有一点需要注意：匿名的结构体类型，如果没有对结构体类型重命名的话，基本上只能使⽤⼀次。

        结构体的自引用

        我们思考这样一个问题：在结构中包含⼀个类型为该结构本⾝的成员是否可以呢？

        比如，定义⼀个链表的节点：

        struct Node{     int data;//保存的数据     struct Node next;//下一个结构体};

        上述代码正确吗？如果正确，那 sizeof(struct Node) 是多少？

        仔细分析，其实是不行的，因为⼀个结构体中再包含⼀个同类型的结构体变量，可以类比一下没有限制条件的递归函数，这样结构体变量的大小就会无穷的大，是不合理的。

        正确的代码：

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

        其中struct Node* next是指向下一个结构体的指针，这样也可以将两个结构体链起来。

        ---

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

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

        答案是不行的，因为Node是对前面的匿名结构体类型的重命名产⽣的，但是在匿名结构体内部提前使⽤Node类型来创建成员变量，这是不⾏的。

        解决方案如下：定义结构体不要使用匿名结构体了

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

        结构体的初始化

        普通初始化

        其实为结构体赋初始值的形式与数组相同。各个结构体成员的初始值依次排列在{}里面，并用逗号进行分割。如果未赋初始值的成员则被初始化为0。

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

        初始化式中的值必须按结构体成员的顺序显示。在此例中，结构体Stu,的成员name则为"zhangsan"，成员age则为20。与数组类似，用于结构初始化式的表达式必须式常量。

        ---

        指定初始化

        指示初始化方式(C99)，这种方式允许不是按照成员顺序初始化。

        如下：

        struct Stu{     int age;     char name[15];     float weight;};struct Stu s = {.weight=75.5f, .age=20, .name="zhangsan"};//初始化

        指定初始化式的优点：

        1. 易读且容易进行验证，因为读者可以清楚地看出结构中的成员和初始化式中的值之间的对应关系；
        2. 初始化式中的值的顺序不需要与结构中成员的顺序一致，不会影响指定初始化式。

        指定初始化式中列出来的值的前面不一定要有提示符，下面这个例子：

        struct Stu s = {.weight=75.5f, .age=20, "zhangsan"}；

        值"zhangsan"的前面并没有指示符，所以编译器会认为它用于初始化结构中位于age之后的成员。初始化式中没有涉及的成员都设为0。

        结构体内存对齐

        对齐规则

        我们已经掌握了结构体的基本使用了。现在我们深⼊讨论⼀个问题：计算结构体的大小。

        具体对齐规则如下：

        1. 结构体的第⼀个成员对齐到相对结构体变量起始位置偏移量为0的地址处
        2. 其他成员变量要对齐到某个数字（对⻬数）的整数倍的地址处。

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

        • VS中默认的值为8
        • Linux中没有默认对齐数，对齐数就是成员自身的大小
          1. 结构体总大小为最大对齐数（结构体中每个成员变量都有⼀个对齐数，所有对齐数中最大的）的整数倍。
          2. 如果嵌套了结构体的情况，嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体中成员的对齐数）的整数倍。

          看如下几个例子：

          //练习1struct S1{     char c1;     int i;     char c2;};printf("%d\n", sizeof(struct S1));//---12

          练习1的分析：

          变量	变量大小	默认对齐数	对齐数
          c1	1	8	1
          i	4	8	4
          c2	1	8	1

          通过上面表格，我们可以想象到其在内存中存储的大概：

          ---

          //练习2struct S2{     char c1;     char c2;     int i;};printf("%d\n", sizeof(struct S2));//---8

          内存中存储：

          ---

          默认对齐数的修改

          #pragma 这个预处理指令，可以改变编译器的默认对齐数。

          #pragma pack(4);//设置默认对齐数为4

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

          结构体传参

          结构成员访问操作符有两个⼀个是.，⼀个是->.

          形式如下：

          结构体变量.成员变量名结构体指针—>成员变量名

          比较一下下面的Print1和Print2函数，哪一个更好？

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

          事实上，Print2更好一些，原因如下：

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

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

          ---