C语言笔记（十五）——结构体、联合体、枚举与typedef

朴灿烈づ我的快乐病毒、 2022-05-21 01:06 373阅读 0赞

# 一、结构体 #

由不同类型的数据组合成一个整体，以便引用，这些组合在一个整体中的数据是互相联系的，这样的数据结构称为结构体。

#include <stdio.h>
    struct student//student是结构体名字
    {
        char name[100];
        int age;
        int sex;
    }; //说明了结构体的数据成员类型.不能直接用student，需要在主函数中定义变量
    
    int main()
    {
        /**********定义结构体的方法1**************/ /*struct student st;//定义了一个结构体变量，名字叫st,在栈里 st.age = 20; st.sex = 1; strcpy(st.name, "BoBo");*/ /**********定义结构体的方法2**************/
        struct student st = {"BoBo", 25, 0}; //定义了一个结构体变量，名字叫st
           /**********初始化结构体**************/ // struct student st = { 0 }; //定义了一个结构体变量，名字叫st,同时将所有成员值初始化为0
    
        printf("name = %s\n", st.name);
        printf("age = %d\n", st.age);
        if(st.sex == 0)
        {
            printf("sex = 男\n");
        }
        else
        {
            printf("sex = 女\n");
        }
        return 0;
    }

## 1.1 定义结构体struct与成员初始化的几种方法 ##

<table style="width:602px;"> 
 <tbody> 
  <tr> 
   <td style="width:599px;">法1：<br><span style="color:#006600;">&nbsp;struct student</span><span style="color:#3333ff;"> <strong>st</strong></span><span style="color:#006600;">;//定义了一个</span><strong><span style="color:#cc0000;">结构体变量</span></strong><span style="color:#006600;">，名字叫st,在栈里.</span><span style="color:#990000;">注：定义时各变量顺序要跟声明顺序一致。</span><strong><span style="color:#6600cc;">st是结构体变量名称</span></strong><br><span style="color:#006600;">&nbsp; &nbsp; st.age = 20;</span><br><span style="color:#006600;">&nbsp; &nbsp; st.sex = 1;</span><br><span style="color:#006600;">&nbsp; &nbsp; strcpy(st.name, "BoBo");</span></td> 
  </tr> 
  <tr> 
   <td style="width:599px;">法2：定义并初始化<br><span style="color:#009900;">&nbsp;struct student st = {"BoBo", 25, 0}; //定义了一个结构体变量，名字叫st。<span style="color:#990000;">注：定义时各变量顺序要跟声明顺序一致</span></span></td> 
  </tr> 
  <tr> 
   <td style="width:599px;">法3：定义并初始化<br><span style="color:#009900;">struct student st = { </span><span style="color:#cc0000;">.name</span><span style="color:#009900;"> = "BoBo", </span><span style="color:#cc0000;">.age</span><span style="color:#009900;"> = 25,</span><span style="color:#ff0000;"> .sex</span><span style="color:#009900;"> = 0}; //</span><span style="color:#990000;">“.成员变量名”的形式可以不用按声明顺序赋值。</span></td> 
  </tr> 
 </tbody> 
</table>

初始化为0的方法

<table style="width:599px;"> 
 <tbody> 
  <tr> 
   <td style="width:596px;"> <p>法4：</p> <p><span style="color:#009900;">&nbsp;struct student st = { 0 };&nbsp;</span></p> <p><span style="color:#333333;">法5：</span></p> <p><span style="color:#006600;">memset(&amp;st, 0, sizeof(st));</span></p> </td> 
  </tr> 
 </tbody> 
</table>

## 1.2 结构体的访问 ##

**.操作符**

**结构体变量名字.成员变量名字**

<table style="width:530px;"> 
 <tbody> 
  <tr> 
   <td style="width:527px;"> <p>eg:&nbsp;</p> <p>&nbsp;&nbsp;&nbsp;&nbsp;printf("name = %s\n",<span style="color:#cc0000;"> st.name</span>);</p> </td> 
  </tr> 
 </tbody> 
</table>

## 1.3 结构体的内存对其方式 ##

编译器在编译一个结构的时候采用内存对齐模式。

比如结构声明有一个int，一个char，则有8个字节。

![70][]

![70 1][]

## 1.4 指定结构体元素的位字段 ##

定义一个结构体的时候可以指定具体元素的位长。1字节 = 8bit

<table> 
 <tbody> 
  <tr> 
   <td> <p>struct text</p> <p>{ </p> <p>&nbsp; &nbsp; char a :<span style="color:#cc0000;"> 2</span>; <span style="color:#009900;">//定义一个成员类型为char，但这个成员只使用</span><span style="color:#cc0000;">2个<strong><em>bit</em></strong></span><span style="color:#009900;">。指定元素为2</span><span style="color:#009900;">位长</span><span style="color:#009900;">，不是2个字节长</span></p> <p>};</p> </td> 
  </tr> 
 </tbody> 
</table>

<table style="width:677px;"> 
 <tbody> 
  <tr> 
   <td style="width:674px;"> <p>struct A</p> <p>{ </p> <p>&nbsp; &nbsp; int x : 4;</p> <p>&nbsp; &nbsp; char a : 2;</p> <p>&nbsp; &nbsp; char b : 1;</p> <p>}</p> </td> 
  </tr> 
 </tbody> 
</table>

则A的长度为8个字节。因为int型有4个字节，char a，b只能在下一行，尽管它俩只用了3bit，但根据内存对齐方式，结构A共占了8字节

**注：指定位长不能超过该变量类型的位数范围。比如int a ： 32 最大只能使用32位，不能多用。**

**1.5 结构数组**

给结构数组赋值

<table> 
 <tbody> 
  <tr> 
   <td> <p>struct man{ </p> &nbsp; &nbsp; char name[20];<br> &nbsp; &nbsp; char score;<br> };<br><br> int main()<br> { <p>&nbsp;<em><strong> &nbsp; <span style="color:#ff0000;">struct man m[10] </span>= { {"tom", 12}, {"marry", 10}, {"jack", 9} }; //在栈中定义数组，有10个成员，m【0】-m【9】</strong></em></p> <p><em><strong>&nbsp; <span style="color:#009900;">&nbsp;// struct student *p = malloc(sizeof(struct student) * 3);//在堆中定义了3个成员的数组</span></strong></em></p> &nbsp; &nbsp; int i;<br> &nbsp; &nbsp; for(i = 0; i &lt; 3; i++)<br> &nbsp; &nbsp; &nbsp; &nbsp; { <br> &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; printf("名字 = %s, 分数 = %d\n", m[i].name, m[i].score);<br> &nbsp; &nbsp; &nbsp; &nbsp; }<br> return 0;<br> }</td> 
  </tr> 
 </tbody> 
</table>

## \*在堆、栈中分别定义数组及访问数组成员 ##

<table> 
 <tbody> 
  <tr> 
   <td> <p>在栈中</p> <p>定义数组：</p> <p>&nbsp;&nbsp;&nbsp;&nbsp;<em>&nbsp;<span style="color:#009900;">struct man m[10]&nbsp;= { {"tom", 12}, {"marry", 10}, {"jack", 9} }; //在栈中定义数组，有10个成员，m【0】-m【9】</span></em></p> <p>访问数组：</p> <p>&nbsp; &nbsp; <span style="color:#006600;">m[2].age = 5; //将j结构体变量m中第三个成员的age项赋值5.</span></p> </td> 
  </tr> 
  <tr> 
   <td> <p>在堆中</p> <p>定义数组：</p> <p>&nbsp;&nbsp;&nbsp;&nbsp;<em><span style="color:#009900;">struct student *p = malloc(sizeof(struct student) * 3);//在堆中定义了3个成员的数组</span></em></p> <p><span style="color:#333333;">访问数组：</span></p> <p><span style="color:#333333;">&nbsp; </span><span style="color:#009900;">&nbsp;p[0].age = 100;//将结构体变量p的第一个成员的age项赋值为100</span></p> <p><span style="color:#333333;">或者</span></p> <p><span style="color:#333333;">&nbsp; &nbsp; </span><span style="color:#009900;">p -&gt; age = 100;&nbsp;//此方法只适用于指针</span></p> </td> 
  </tr> 
 </tbody> 
</table>

## 结构赋值：将数组中某一元素跟另一元素交换位置。比如将下面的程序放到上面结构体定义的下面，可以将结构体中* \{"tom", 12\}, \{"marry", 10\}这两元素换位显示。* ##

<table style="width:200px;"> 
 <tbody> 
  <tr> 
   <td> <p>struct student tmp = m[0];</p> <p>m[0] = m[1];</p> <p>m[1] = tmp;</p> </td> 
  </tr> 
 </tbody> 
</table>

结构体数组排序：采用冒泡算法将数组成员按年龄从小到大排序，年龄一样的，按成绩由小到大排

struct man{
        char name[20];
        char age;
        char score;
    }; //结构体说明
    void swap(struct man *p, struct man *a) //函数定义
    {
        struct man tmp = *p;
        *p = *a;
        *a = tmp;
    }
    int main()
    {
        struct man m[10] = { {"tom", 36, 12}, {"marry", 15, 10}, {"jack", 100, 9}, {"jj", 20, 12} };
        int i, j;
        for(j = 0; j < 4; j++)
        {
            for(i = 1; i < 4 - j; i++)
                {
                    if(m[i].age > m[i - 1].age)
                    {
                        swap(&m[i], &m[i - 1]);
                    }
                    else
                        if((m[i].age == m[i - 1].age) && (m[i].score > m[i - 1].score))
                        {
                            swap(&m[i], &m[i - 1]);
                        }
                }
        }
        for(i = 0; i < 4; i++)
        {
            printf("名字 = %s, 年龄 = %d, 分数 = %d\n", m[i].name, m[i].age, m[i].score);
        }
    return 0;
    }

## 1.6 嵌套结构 ##

一个结构的成员还可以是另一个结构类型

struct A
    {
        int a;
        char b;
    };
    struct B
    {
        struct A a;
        char c;
    };
    int main()
    {
        printf("%d\n", sizeof(struct B));
        return 0;
    }

![70 2][]

![70 3][]

## 1.7 结构体的赋值 ##

struct name a = b;

## 结构赋值：将数组中某一元素跟另一元素交换位置。比如将下面的程序放到上面1.5例子中结构体定义的下面，可以将结构体中* \{"tom", 12\}, \{"marry", 10\}这两元素换位显示。* ##

<table style="width:490px;"> 
 <tbody> 
  <tr> 
   <td style="width:487px;"> <p>struct A a1, a2;</p> <p>a1.a = 10;</p> <p>a2.b = 20;</p> <p>a2 = a1;//结构体赋值，其实就是结构体之间内存的拷贝</p> </td> 
  </tr> 
 </tbody> 
</table>

## 1.8 指向结构体的指针 ##

“**->**”操作符：表示指针访问一个结构体的成员

struct A
    {
      int a;
      int b;
    };
    int main()
    {
        struct A a;
        struct A *p = &a;
        p ->a = 2;
        p ->b = 6;
        printf("a = %d, b = %d\n", a.a, a.b);
    }

## 1.9 指向结构体数组的指针 ##

struct A
    {
        int a;
        int b;
    };
    int main()
    {
        struct A array[10] = { 0 };//栈里创建数组
        struct A *p = &array; //定义一个指针指向结构体地址
        p -> a = 1; //数组的第0个元素分别设置为1和2.指针访问一个结构体的成员
        p -> b = 2;
        p++;//设置数组的下一个元素
        p -> a = 3;
        p -> b = 4;
        int i;
        for(i = 0; i < 10; i++)
        {
            printf("a = %d, b = %d\n", array[i].a, array[i].b);
        }
        return 0;
    }

## ![70 4][] ##

## 1.10 结构中的数组成员和指针成员 ##

一个结构中可以有数组成员，也可以有指针成员。若是指针成员，结构体成员在初始化和赋值时就需要提前为指针成员分配内存

结构中的数组成员例子：

struct child
    {
        char name[30];
        int age;
    };
    struct child_a
    {
        char *name;
        int age;
    };
    int main()
    {
        struct child st;
        st.age = 30;
        strcpy(st.name, "liudehua");
       
        printf("%d, %s\n", st.age, st.name);
        free(st.name);
        return 0;
    }

结构中的指针成员例子：

struct child
    {
        char name[30];
        int age;
    };
    struct child_a
    {
        char *name;
        int age;
    };
    int main()
    {
        struct child_a st = {NULL, 0};//因为child_a中name是指针，所以结构体定义这要对结构成员初始化
        st.age = 30;
        //因为*name的地址为NULL，所以下面要给name重新分配内存
        st.name = malloc(100);
        strcpy(st.name, "liudehua");
    
        printf("%d, %s\n", st.age, st.name);
        free(st.name);
        return 0;
    }

## 1.11 结构作为函数的参数 ##

将**结构**作为函数参数，将**结构指针**作为函数参数

#include <stdio.h>
    struct student
    {
        char name[10];
        int age;
    };
    //不建议用结构体作为函数的参数使用
    void print_student(const struct student s) //为防止内容被修改，所以加const
    {
        printf("name = %s, age = %d\n", s.name, s.age);
    }
    void set_student(struct student s, const char *name, int age)//指针作为参数，只需要传递一个地址，所以代码效率高。因此当一个结构作为函数的参数时，尽量使用指针，而不是使用结构变量
    {
        strcpy(s.name, name);
        s.age = age;
    }
    
    int main(void)
    {
        struct student st = {"tom", 20};
        set_student(st, "mike", 100); //加上set_student以及这一句后，运行的结果仍然是name = tom, age = 20.
        print_student(st);
        return 0;
    }

<table> 
 <tbody> 
  <tr> 
   <td>set_student(st, "mike", 100);//这个函数的作用是将它的值复制到s.name中输出，但它忽略了set_student的参数是指针形式的，其内存关系如下：</td> 
  </tr> 
 </tbody> 
</table>

## ![70 5][] ##

## 所以要采用指针的形式 ##

#include <stdio.h>
    struct student
    {
        char name[1000];//栈中数量很大时，函数入栈时要消耗很多资源，采用指针的话，由于只需要传一个地址，所以效率会很高
        int age;
    };
    void print_student(const struct student *s) //为防止值在传递过程过程被修改，所以要加const
    {
        printf("name = %s, age = %d\n", s->name, s->age);
    }
    void set_student(struct student *s, const char *name, int age)
    {
        strcpy(s->name, name);
        s->age = age;
    }
    int main(void)
    {
        struct student st = {"tom", 20};
        set_student(&st, "mike", 100);
        print_student(&st);
        return 0;
    }

## 1.12 结构，还是指向结构的指针 ##

在定义一个和结构有关的函数时，是使用结构还是结构的指针？

指针作为参数，只需要传递一个地址，所以代码效率高。因此**当一个结构作为函数的参数时，尽量使用指针，而不是使用结构变量**，这样代码效率很高。

[70]: /images/20220521/2d028b3a46054e21aedcd2f99f4cf752.png
[70 1]: /images/20220521/cb260d6a8fe34584b1e80ba0133673c6.png
[70 2]: /images/20220521/3242ba5704364e2197daaecf7584fd07.png
[70 3]: /images/20220521/cd946c2cdb0346149056a141fba80451.png
[70 4]: /images/20220521/aa417493bce4427c8f68de950627d711.png
[70 5]: /images/20220521/c4196c8a4940477b852a4a61870a9b8b.png