21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › 【转】嵌入式 C | 结构体完全笔记，收藏！ ...
123下一页
返回列表 发新帖我要提问

[应用相关] 【转】嵌入式 C | 结构体完全笔记，收藏！

[复制链接]
5745|52
 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:38 | 显示全部楼层 |阅读模式
https://mp.weixin.qq.com/s/hDMFhRurdWjnTiwbhcuS-Q


本次分享一篇关于结构体的入门、提高的笔记，**比较长，前面部分是结构体基础，已经掌握的童鞋可以跳过，直接看看后半部分的提高实例。

有的时候，我们所遇到的数据结构，不仅仅是一群数字或者是字符串那么简单。比如我们每一个人的学籍信息，学号是一个长整数，名字却是字符；甚至有更复杂的情况，这种问题在现实生活中并不少见。我们之前学过一种叫数组的数据结构，它可以允许我们把很多同类型的数据集中在一起处理。相对于之前，这已经是一次极大的进步。但是，新的问题，往往又会出现，这个时候，我们就得上更高端的装备——结构体。

相比于数组，结构体有以下的更强大的优势：

  • 批量存储数据
  • 存储不同类型的数据
  • 支持嵌套



回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:40 | 显示全部楼层
结构体的声明与定义声明

结构体的声明使用struct关键字，如果我们想要把我们的学籍信息组织一下的话，可以这样表示：

复制
  1. struct Info
    

  2. {
    

  3.     unsigned long identifier;//学号，用无符号长整数表示
    

  4.     char name[20];//名字，用字符数组表示
    

  5.     unsigned int year;//入学年份，用无符号整数表示
    

  6.     unsigned int years;//学制，用无符号整数表示
    

  7. }

这样，我们就相当于描绘好了一个框架，以后要用的话直接定义一个这种类型的变量就好了。




回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:41 | 显示全部楼层
定义

我们刚刚申请了一个名叫Info的结构体类型，那么理论上我们可以像声明其他变量的操作一样，去声明我们的结构体操作，但是C语言中规定，声明结构体变量的时候，struct关键字是不可少的。

struct 结构体类型名 结构体变量名

不过，你可以在某个函数里面定义：

复制
  1. #include <stdio.h>
    


  2. 

  3. struct Info
    

  4. {
    

  5.     unsigned long identifier;//学号，用无符号长整数表示
    

  6.     char name[20];//名字，用字符数组表示
    

  7.     unsigned int year;//入学年份，用无符号整数表示
    

  8.     unsigned int years;//学制，用无符号整数表示
    

  9. };
    


  10. 

  11. int main(void)
    

  12. {
    

  13.     /**
    

  14.      *在main函数中声明结构体变量
    

  15.      *结构体变量名叫info
    

  16.      *struct关键字不能丢
    

  17.      */
    

  18.     struct Info info;
    

  19.     ...
    

  20. }
也可以在声明的时候就把变量名定义下来（此时这个变量是全局变量）：
复制
  1. #include <stdio.h>
    


  2. 

  3. struct Info
    

  4. {
    

  5.     unsigned long identifier;//学号，用无符号长整数表示
    

  6.     char name[20];//名字，用字符数组表示
    

  7.     unsigned int year;//入学年份，用无符号整数表示
    

  8.     unsigned int years;//学制，用无符号整数表示
    

  9. } info;
    

  10. /**
    

  11.  *此时直接定义了变量
    

  12.  *该变量是全局变量
    

  13.  *变量名叫info
    

  14.  */
    


  15. 

  16. int main(void)
    

  17. {
    

  18.     ...
    

  19. }


回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:42 | 显示全部楼层
访问结构体成员

结构体成员的访问有点不同于以往的任何变量，它是采用点号运算符.来访问成员的。比如，info.name就是引用info结构体的name成员，是一个字符数组，而info.year则可以查到入学年份，是个无符号整型。

比如，下面开始录入学生的信息：

复制
  1. //Example 01
    

  2. #include <stdio.h>
    


  3. 

  4. struct Info
    

  5. {
    

  6.     unsigned long identifier;//学号，用无符号长整数表示
    

  7.     char name[20];//名字，用字符数组表示
    

  8.     unsigned int year;//入学年份，用无符号整数表示
    

  9.     unsigned int years;//学制，用无符号整数表示
    

  10. };
    


  11. 

  12. int main(void)
    

  13. {
    

  14.     struct Info info;
    


  15. 

  16.     printf("请输入学生的学号：");
    

  17.     scanf("%d", &info.identifier);
    

  18.     printf("请输入学生的姓名：");
    

  19.     scanf("%s", info.name);
    

  20.     printf("请输入学生的入学年份：");
    

  21.     scanf("%d", &info.year);
    

  22.     printf("请输入学生的学制：");
    

  23.     scanf("%d", &info.years);
    


  24. 

  25.     printf("\n数据录入完毕\n\n");
    


  26. 

  27.     printf("学号：%d\n姓名：%s\n入学年份：%d\n学制：%d\n毕业时间：%d\n", \
    

  28.         info.identifier, info.name, info.year, info.years, info.year + info.years);
    

  29.     return 0;
    

  30. }

运行结果如下：

复制
  1. //Consequence 01
    

  2. 请输入学生的学号：20191101
    

  3. 请输入学生的姓名：Harris
    

  4. 请输入学生的入学年份：2019
    

  5. 请输入学生的学制：4
    


  6. 

  7. 数据录入完毕
    


  8. 

  9. 学号：20191101
    

  10. 姓名：Harris
    

  11. 入学年份：2019
    

  12. 学制：4
    

  13. 毕业时间：2023


回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:43 | 显示全部楼层
初始化结构体

像数组一样，结构体也可以在定义的时候初始化，方法也几乎一样：

复制
  1. struct Info info = {
    

  2.     20191101,
    

  3.     "Harris",
    

  4.     2019,
    

  5.     4
    

  6. };

在C99标准中，还支持给指定元素赋值（就像数组一样）：

复制
  1. struct Info info = {
    

  2.     .name = "Harris",
    

  3.     .year = 2019
    

  4. };

对于没有被初始化的成员，则「数值型」成员初始化为0，「字符型」成员初始化为‘\0’。


回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:44 | 显示全部楼层
对齐

下面这个代码，大家来看看会发生什么：

复制
  1. //EXample 02 V1
    

  2. #include <stdio.h>
    


  3. 

  4. int main(void)
    

  5. {
    

  6.     struct A
    

  7.     {
    

  8.         char a;
    

  9.         int b;
    

  10.         char c;
    

  11.     } a = {'a', 10, 'o'};
    

  12.     
    

  13.     printf("size of a = %d\n", sizeof(a));
    

  14.     
    

  15.     return 0;
    

  16. }

我们之前学过，char类型的变量占1字节，int类型的变量占4字节，那么这么一算，一个结构体A型的变量应该就是6字节了。别急，我们看运行结果：

复制
  1. //COnsequence 02 V1
    

  2. size of a = 12

怎么变成12了呢？标准更新了？老师教错了？都不是。我们把代码改一下：

复制
  1. //EXample 02 V2
    

  2. #include <stdio.h>
    


  3. 

  4. int main(void)
    

  5. {
    

  6.     struct A
    

  7.     {
    

  8.         char a;
    

  9.         char c;
    

  10.         int b;
    

  11.     } a = {'a', 'o', 10};
    

  12.     
    

  13.     printf("size of a = %d\n", sizeof(a));
    

  14.     
    

  15.     return 0;
    

  16. }

结果：

复制
  1. //Consequence 02 V2
    

  2. size of a = 8

实际上，这是编译器对我们程序的一种优化——内存对齐。在第一个例子中，第一个和第三个成员是char类型是1个字节，而中间的int却有4个字节，为了对齐，两个char也占用了4个字节，于是就是12个字节。

而在第二个例子里面，前两个都是char，最后一个是int，那么前两个可以一起占用4个字节（实际只用2个，第一个例子也同理，只是为了访问速度更快，而不是为了扩展），最后的int占用4字节，合起来就是8个字节。

关于如何声明结构体来节省内存容量，可以阅读下面的这篇**，作者是艾瑞克·雷蒙，时尚最具争议性的黑客之一，被公认为开源运动的主要领导者之一：

英文原版，中文版



回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:46 | 显示全部楼层
结构体嵌套

在学籍里面，如果我们的日期想要更加详细一些，精确到day，这时候就可以使用结构体嵌套来完成：

复制
  1. #include <stdio.h>
    


  2. 

  3. struct Date
    

  4. {
    

  5.     unsigned int year;
    

  6.     unsigned int month;
    

  7.     unsigned int day;
    

  8. };
    


  9. 

  10. struct Info
    

  11. {
    

  12.     unsigned long identifier;//学号，用无符号长整数表示
    

  13.     char name[20];//名字，用字符数组表示
    

  14.     struct Date date;/*---入学日期，用结构体Date表示---*/
    

  15.     unsigned int years;//学制，用无符号整数表示
    

  16. };
    


  17. 

  18. int main(void)
    

  19. {
    

  20.     ...
    

  21. }

如此一来，比我们单独声明普通变量快多了。

不过，这样访问变量，就必须用点号一层层往下访问。比如要访问day这个成员，那就只能info.date.day而不能直接info.date或者info,day。

复制
  1. //Example 03
    

  2. #include <stdio.h>
    


  3. 

  4. struct Date
    

  5. {
    

  6.     unsigned int year;
    

  7.     unsigned int month;
    

  8.     unsigned int day;
    

  9. };
    


  10. 

  11. struct Info
    

  12. {
    

  13.     unsigned long identifier;//学号，用无符号长整数表示
    

  14.     char name[20];//名字，用字符数组表示
    

  15.     struct Date date;/*---入学日期，用结构体Date表示---*/
    

  16.     unsigned int years;//学制，用无符号整数表示
    

  17. };
    


  18. 

  19. int main(void)
    

  20. {
    

  21.     struct Info info;
    

  22.     printf("请输入学生的学号：");
    

  23.     scanf("%d", &info.identifier);
    

  24.     printf("请输入学生的姓名：");
    

  25.     scanf("%s", info.name);
    

  26.     printf("请输入学生的入学年份：");
    

  27.     scanf("%d", &info.date.year);
    

  28.     printf("请输入学生的入学月份：");
    

  29.     scanf("%d", &info.date.month);
    

  30.     printf("请输入学生的入学日期：");
    

  31.     scanf("%d", &info.date.day);
    

  32.     printf("请输入学生的学制：");
    

  33.     scanf("%d", &info.years);
    


  34. 

  35.     printf("\n数据录入完毕\n\n");
    


  36. 

  37.     printf("学号：%d\n姓名：%s\n入学时间：%d/%d/%d\n学制：%d\n毕业时间：%d\n",\
    

  38.            info.identifier, info.name,\
    

  39.            info.date.year, info.date.month, info.date.day,\
    

  40.            info.years, info.date.year + info.years);
    

  41.     return 0;
    

  42. }
    

  43. 运行结果如下：
    


  44. 

  45. //Consequence 03
    

  46. 请输入学生的学号：20191101
    

  47. 请输入学生的姓名：Harris
    

  48. 请输入学生的入学年份：2019
    

  49. 请输入学生的入学月份：9
    

  50. 请输入学生的入学日期：7
    

  51. 请输入学生的学制：4
    


  52. 

  53. 数据录入完毕
    


  54. 

  55. 学号：20191101
    

  56. 姓名：Harris
    

  57. 入学时间：2019/9/7
    

  58. 学制：4
    

  59. 毕业时间：2023



回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:47 | 显示全部楼层
结构体数组

刚刚我们演示了存储一个学生的学籍信息的时候，使用结构体的例子。那么，如果要录入一批学生，这时候我们就可以沿用之前的思路，使用结构体数组。

我们知道，数组的定义，就是存放一堆相同类型的数据的容器。而结构体一旦被我们声明，那么你就可以把它看作一个类型，只不过是你自己定义的罢了。

定义结构体数组也很简单：

复制
  1. struct 结构体类型
    

  2. {
    

  3.     成员;
    

  4. } 数组名[长度];
    


  5. 

  6. /****或者这样****/
    


  7. 

  8. struct 结构体类型
    

  9. {
    

  10.     成员;
    

  11. };
    

  12. struct 结构体类型 数组名[长度];


回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:48 | 显示全部楼层
结构体指针

既然我们可以把结构体看作一个类型，那么也就必然有对应的指针变量。

复制
  1. struct Info* pinfo;

但是在指针这里，结构体和数组就不一样了。我们知道，数组名实际上就是指向这个数组第一个元素的地址，所以可以将数组名直接赋值给指针。而结构体的变量名并不是指向该结构体的地址，所以要使用取地址运算符&才能获取地址：

复制
  1. pinfo = &info;

通过结构体指针来访问结构体有以下两种方法：

  • (*结构体指针).成员名
  • 结构体指针->成员名

第一个方法由于点号运算符比指针的取值运算符优先级更高，因此需要加一个小括号来确定优先级，让指针先解引用变成结构体变量，在使用点号的方法去访问。

相比之下，第二种方法就直观许多。

这两种方法在实现上是完全等价的，但是点号只能用于结构体变量，而箭头只能够用于指针。

第一种方法：

复制
  1. #include <stdio.h>
    

  2. ...
    

  3. int main(void)
    

  4. {
    

  5.     struct Info *p;
    

  6.     p = &info;
    

  7.     
    

  8.     printf("学号：\n", (*p).identifier);
    

  9.     printf("姓名：\n", (*p).name);
    

  10.     printf("入学时间：%d/%d/%d\n", (*p).date.year, (*p).date.month, (*p).date.day);
    

  11.     printf("学制：\n", (*p).years);
    

  12.     return 0;
    

  13. }

第二种方法：

复制
  1. #include <stdio.h>
    

  2. ...
    

  3. int main(void)
    

  4. {
    

  5.     struct Info *p;
    

  6.     p = &info;
    

  7.     
    

  8.     printf("学号：\n", p -> identifier);
    

  9.     printf("姓名：\n", p -> name);
    

  10.     printf("入学时间：%d/%d/%d\n", p -> date.year, p -> date.month, p -> date.day);
    

  11.     printf("学制：\n", p -> years);
    

  12.     return 0;
    

  13. }


回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:49 | 显示全部楼层
传递结构体信息传递结构体变量

我们先来看看下面的代码：

复制
  1. //Example 04
    

  2. #include <stdio.h>
    


  3. 

  4. int main(void)
    

  5. {
    

  6.     struct Test
    

  7.     {
    

  8.         int x;
    

  9.         int y;
    

  10.     }t1, t2;
    


  11. 

  12.     t1.x = 3;
    

  13.     t1.y = 4;
    

  14.     t2 = t1;
    


  15. 

  16.     printf("t2.x = %d, t2.y = %d\n", t2.x, t2.y);
    

  17.     return 0;
    

  18. }
运行结果如下：
复制
  1. //Consequence 04
    

  2. t2.x = 3, t2.y = 4

这么看来，结构体是可以直接赋值的。那么既然这样，作为函数的参数和返回值也自然是没问题的了。

先来试试作为参数:

复制
  1. //Example 05
    

  2. #include <stdio.h>
    

  3. struct Date
    

  4. {
    

  5.     unsigned int year;
    

  6.     unsigned int month;
    

  7.     unsigned int day;
    

  8. };
    


  9. 

  10. struct Info
    

  11. {
    

  12.     unsigned long identifier;
    

  13.     char name[20];
    

  14.     struct Date date;
    

  15.     unsigned int years;
    

  16. };
    


  17. 

  18. struct Info getInput(struct Info info);
    

  19. void printInfo(struct Info info);
    


  20. 

  21. struct Info getInput(struct Info info)
    

  22. {
    

  23.     printf("请输入学号：");
    

  24.     scanf("%d", &info.identifier);
    

  25.     printf("请输入姓名：");
    

  26.     scanf("%s", info.name);
    

  27.     printf("请输入入学年份：");
    

  28.     scanf("%d", &info.date.year);
    

  29.     printf("请输入月份：");
    

  30.     scanf("%d", &info.date.month);
    

  31.     printf("请输入日期：");
    

  32.     scanf("%d", &info.date.day);
    

  33.     printf("请输入学制：");
    

  34.     scanf("%d", &info.years);
    


  35. 

  36.     return info;
    

  37. }
    


  38. 

  39. void printInfo(struct Info info)
    

  40. {
    

  41.     printf("学号：%d\n姓名：%s\n入学时间：%d/%d/%d\n学制：%d\n毕业时间：%d\n", \
    

  42.         info.identifier, info.name, \
    

  43.         info.date.year, info.date.month, info.date.day, \
    

  44.         info.years, info.date.year + info.years);
    

  45. }
    


  46. 

  47. int main(void)
    

  48. {
    

  49.     struct Info i1 = {};
    

  50.     struct Info i2 = {};
    

  51.     printf("请录入第一个同学的信息...\n");
    

  52.     i1 = getInput(i1);
    

  53.     putchar('\n');
    

  54.     printf("请录入第二个学生的信息...\n");
    

  55.     i2 = getInput(i2);
    


  56. 

  57.     printf("\n录入完毕，现在开始打印...\n\n");
    

  58.     printf("打印第一个学生的信息...\n");
    

  59.     printInfo(i1);
    

  60.     putchar('\n');
    

  61.     printf("打印第二个学生的信息...\n");
    

  62.     printInfo(i2);
    


  63. 

  64.     return 0;
    

  65. }

运行结果如下：

复制
  1. //Consequence 05
    

  2. 请录入第一个同学的信息...
    

  3. 请输入学号：20191101
    

  4. 请输入姓名：Harris
    

  5. 请输入入学年份：2019
    

  6. 请输入月份：9
    

  7. 请输入日期：7
    

  8. 请输入学制：4
    


  9. 

  10. 请录入第二个学生的信息...
    

  11. 请输入学号：20191102
    

  12. 请输入姓名：Joy
    

  13. 请输入入学年份：2019
    

  14. 请输入月份：9
    

  15. 请输入日期：8
    

  16. 请输入学制：5
    


  17. 

  18. 录入完毕，现在开始打印...
    


  19. 

  20. 打印第一个学生的信息...
    

  21. 学号：20191101
    

  22. 姓名：Harris
    

  23. 入学时间：2019/9/7
    

  24. 学制：4
    

  25. 毕业时间：2023
    


  26. 

  27. 打印第二个学生的信息...
    

  28. 学号：20191102
    

  29. 姓名：Joy
    

  30. 入学时间：2019/9/8
    

  31. 学制：5
    

  32. 毕业时间：2024


回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:50 | 显示全部楼层
传递指向结构体变量的指针

早期的C语言是不允许直接将结构体作为参数直接传递进去的。主要是考虑到如果结构体的内存占用太大，那么整个程序的内存开销就会爆炸。不过现在的C语言已经放开了这方面的限制。

不过，作为一名合格的开发者，我们应该要去珍惜硬件资源。那么，传递指针就是一个很好的办法。

将刚才的代码修改一下：

复制
  1. //Example 06
    

  2. #include <stdio.h>
    

  3. struct Date
    

  4. {
    

  5.     unsigned int year;
    

  6.     unsigned int month;
    

  7.     unsigned int day;
    

  8. };
    


  9. 

  10. struct Info
    

  11. {
    

  12.     unsigned long identifier;
    

  13.     char name[20];
    

  14.     struct Date date;
    

  15.     unsigned int years;
    

  16. };
    


  17. 

  18. void getInput(struct Info *info);
    

  19. void printInfo(struct Info *info);
    


  20. 

  21. void getInput(struct Info *info)
    

  22. {
    

  23.     printf("请输入学号：");
    

  24.     scanf("%d", &info->identifier);
    

  25.     printf("请输入姓名：");
    

  26.     scanf("%s", info->name);
    

  27.     printf("请输入入学年份：");
    

  28.     scanf("%d", &info->date.year);
    

  29.     printf("请输入月份：");
    

  30.     scanf("%d", &info->date.month);
    

  31.     printf("请输入日期：");
    

  32.     scanf("%d", &info->date.day);
    

  33.     printf("请输入学制：");
    

  34.     scanf("%d", &info->years);
    

  35. }
    


  36. 

  37. void printInfo(struct Info *info)
    

  38. {
    

  39.     printf("学号：%d\n姓名：%s\n入学时间：%d/%d/%d\n学制：%d\n毕业时间：%d\n", \
    

  40.         info->identifier, info->name, \
    

  41.         info->date.year, info->date.month, info->date.day, \
    

  42.         info->years, info->date.year + info->years);
    

  43. }
    


  44. 

  45. int main(void)
    

  46. {
    

  47.     struct Info i1 = {};
    

  48.     struct Info i2 = {};
    

  49.     printf("请录入第一个同学的信息...\n");
    

  50.     getInput(&i1);
    

  51.     putchar('\n');
    

  52.     printf("请录入第二个学生的信息...\n");
    

  53.     getInput(&i2);
    


  54. 

  55.     printf("\n录入完毕，现在开始打印...\n\n");
    

  56.     printf("打印第一个学生的信息...\n");
    

  57.     printInfo(&i1);
    

  58.     putchar('\n');
    

  59.     printf("打印第二个学生的信息...\n");
    

  60.     printInfo(&i2);
    


  61. 

  62.     return 0;
    

  63. }

此时传递的就是一个指针，而不是一个庞大的结构体。


回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:51 | 显示全部楼层
动态申请结构体

结构体也可以在堆里面动态申请：

复制
  1. //Example 01
    

  2. #include <stdio.h>
    

  3. ...
    

  4. int main(void)
    

  5. {
    

  6.     struct Info *i1;
    

  7.     struct Info *i2;
    

  8.     
    

  9.     i1 = (struct Info *)malloc(sizeof(struct Info));
    

  10.     i2 = (struct Info *)malloc(sizeof(struct Info));
    

  11.     if (i1 == NULL || i2 == NULL)
    

  12.     {
    

  13.         printf("内存分配失败！\n");
    

  14.         exit(1);
    

  15.     }
    

  16.     
    

  17.     printf("请录入第一个同学的信息...\n");
    

  18.     getInput(i1);
    

  19.     putchar('\n');
    

  20.     printf("请录入第二个学生的信息...\n");
    

  21.     getInput(i2);
    


  22. 

  23.     printf("\n录入完毕，现在开始打印...\n\n");
    

  24.     printf("打印第一个学生的信息...\n");
    

  25.     printInfo(i1);
    

  26.     putchar('\n');
    

  27.     printf("打印第二个学生的信息...\n");
    

  28.     printInfo(i2);
    

  29.     
    

  30.     free(i1);
    

  31.     free(i2);
    

  32.     
    

  33.     return 0;
    

  34. }


回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:53 | 显示全部楼层
实战：建立一个图书馆数据库

实际上，我们建立的数组可以是指向结构体指针的数组。

代码实现如下：

复制
  1. //Example 02
    

  2. #include <stdio.h>
    

  3. #include <stdlib.h>
    


  4. 

  5. #define MAX_SIZE 100
    


  6. 

  7. struct Date
    

  8. {
    

  9.     int year;
    

  10.     int month;
    

  11.     int day;
    

  12. };
    


  13. 

  14. struct Book
    

  15. {
    

  16.     char title[128];
    

  17.     char author[48];
    

  18.     float price;
    

  19.     struct Date date;
    

  20.     char publisher[48];
    

  21. };
    


  22. 

  23. void getInput(struct Book* book);//录入数据
    

  24. void printBook(struct Book* book);//打印数据
    

  25. void initLibrary(struct Book* lib[]);//初始化结构体
    

  26. void printLibrary(struct Book* lib[]);//打印单本书数据
    

  27. void releaseLibrary(struct Book* lib[]);//释放内存
    


  28. 

  29. void getInput(struct Book* book)
    

  30. {
    

  31.     printf("请输入书名：");
    

  32.     scanf("%s", book->title);
    

  33.     printf("请输入作者：");
    

  34.     scanf("%s", book->author);
    

  35.     printf("请输入售价：");
    

  36.     scanf("%f", &book->price);
    

  37.     printf("请输入出版日期：");
    

  38.     scanf("%d-%d-%d", &book->date.year, &book->date.month, &book->date.day);
    

  39.     printf("请输入出版社：");
    

  40.     scanf("%s", book->publisher);
    

  41. }
    


  42. 

  43. void printBook(struct Book* book)
    

  44. {
    

  45.     printf("书名：%s\n", book->title);
    

  46.     printf("作者：%s\n", book->author);
    

  47.     printf("售价：%.2f\n", book->price);
    

  48.     printf("出版日期：%d-%d-%d\n", book->date.year, book->date.month, book->date.day);
    

  49.     printf("出版社：%s\n", book->publisher);
    

  50. }
    


  51. 

  52. void initLibrary(struct Book* lib[])
    

  53. {
    

  54.     for (int i = 0; i < MAX_SIZE; i++)
    

  55.     {
    

  56.         lib[i] = NULL;
    

  57.     }
    

  58. }
    


  59. 

  60. void printLibrary(struct Book* lib[])
    

  61. {
    

  62.     for (int i = 0; i < MAX_SIZE; i++)
    

  63.     {
    

  64.         if (lib[i] != NULL)
    

  65.         {
    

  66.             printBook(lib[i]);
    

  67.             putchar('\n');
    

  68.         }
    

  69.     }
    

  70. }
    


  71. 

  72. void releaseLibrary(struct Book* lib[])
    

  73. {
    

  74.     for (int i = 0; i < MAX_SIZE; i++)
    

  75.     {
    

  76.         if (lib[i] != NULL)
    

  77.         {
    

  78.             free(lib[i]);
    

  79.         }
    

  80.     }
    

  81. }
    


  82. 

  83. int main(void)
    

  84. {
    

  85.     struct Book* lib[MAX_SIZE];
    

  86.     struct Book* p = NULL;
    

  87.     int ch, index = 0;
    


  88. 

  89.     initLibrary(lib);
    


  90. 

  91.     while (1)
    

  92.     {
    

  93.         printf("请问是否要录入图书信息(Y/N):");
    

  94.         do
    

  95.         {
    

  96.             ch = getchar();
    

  97.         } while (ch != 'Y' && ch != 'N');
    


  98. 

  99.         if (ch == 'Y')
    

  100.         {
    

  101.             if (index < MAX_SIZE)
    

  102.             {
    

  103.                 p = (struct Book*)malloc(sizeof(struct Book));
    

  104.                 getInput(p);
    

  105.                 lib[index] = p;
    

  106.                 index++;
    

  107.                 putchar('\n');
    

  108.             }
    

  109.             else
    

  110.             {
    

  111.                 printf("数据库已满！\n");
    

  112.                 break;
    

  113.             }
    

  114.         }
    

  115.         else
    

  116.         {
    

  117.             break;
    

  118.         }
    

  119.     }
    


  120. 

  121.     printf("\n数据录入完毕，开始打印验证...\n\n");
    

  122.     printLibrary(lib);
    

  123.     releaseLibrary(lib);
    


  124. 

  125.     return 0;
    

  126. }
运行结果如下：
复制
  1. //Consequence 02
    

  2. 请问是否要录入图书信息(Y/N):Y
    

  3. 请输入书名：人类简史
    

  4. 请输入作者：尤瓦尔·赫拉利
    

  5. 请输入售价：32.25
    

  6. 请输入出版日期：2016-3-4
    

  7. 请输入出版社：中信出版集团
    


  8. 

  9. 请问是否要录入图书信息(Y/N):N
    


  10. 

  11. 数据录入完毕，开始打印验证...
    


  12. 

  13. 书名：人类简史
    

  14. 作者：尤瓦尔·赫拉利
    

  15. 售价：32.25
    

  16. 出版日期：2016-3-4
    

  17. 出版社：中信出版集团


回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:54 | 显示全部楼层
单链表

我们知道，数组变量在内存中，是连续的，而且不可拓展。显然在一些情况下，这种数据结构拥有很大的局限性。比如移动数据的时候，会牵一发而动全身，尤其是反转这种操作更加令人窒息。那么，需要需要一种数据结构来弄出一种更加灵活的“数组”，那么这，就是「链表」。

本节我们只讲讲单链表。

所谓链表，就是由一个个「结点」组成的一个数据结构。每个结点都有「数据域」和「指针域」组成。其中数据域用来存储你想要存储的信息，而指针域用来存储下一个结点的地址。如图：

924206274e219e48e2.png
单链表

当然，链表最前面还有一个头指针，用来存储头结点的地址。

这样一来，链表中的每一个结点都可以不用挨个存放，因为有了指针把他们串起来。因此结点放在哪都无所谓，反正指针总是能够指向下一个元素。我们只需要知道头指针，就能够顺藤摸瓜地找到整个链表。

因此对于学籍数据库来说，我们只需要在Info结构体中加上一个指向自身类型的成员即可：

复制
  1. struct Info
    

  2. {
    

  3.     unsigned long identifier;
    

  4.     char name[20];
    

  5.     struct Date date;
    

  6.     unsigned int years;
    

  7.     struct Info* next;
    

  8. };





回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:56 | 显示全部楼层
在单链表中插入元素头插法

这种每次都将数据插入单链表的头部（头指针后面）的插入法就叫头插法。

如果要把学生信息加入到单链表，可以这么写：

复制
  1. void addInfo(struct Info** students)//students是头指针
    

  2. {
    

  3.     struct Info* info, *temp;
    

  4.     info = (struct Info*)malloc(sizeof(struct Info));
    

  5.     if (info == NULL)
    

  6.     {
    

  7.         printf("内存分配失败！\n");
    

  8.         exit(1);
    

  9.     }
    

  10.     
    

  11.     getInput(info);
    

  12.     
    

  13.     if (*students != NULL)
    

  14.     {
    

  15.         temp = *students;
    

  16.         *students = info;
    

  17.         info->next = temp;
    

  18.     }
    

  19.     else
    

  20.     {
    

  21.         *students = info;
    

  22.         info->next = NULL;
    

  23.     }
    

  24. }
[color=rgba(127, 194, 194, 0.498)]❝

由于students存放的是头指针，因此我们需要传入它的地址传递给函数，才能够改变它本身的值。而students本身又是一个指向Info结构体的指针，所以参数的类型应该就是struct Info**。

[color=rgba(127, 194, 194, 0.498)]❞

往单链表里面添加一个结点，也就是先申请一个结点，然后判断链表是否为空。如果为空，那么直接将头指针指向它，然后next成员指向NULL。若不为空，那么先将next指向头指针原本指向的结点，然后将头指针指向新结点即可。

那么，打印链表也变得很简单：

复制
  1. void printStu(struct Info* students)
    

  2. {
    

  3.     struct Info* info;
    

  4.     int count = 1;
    

  5.     
    

  6.     info = students;
    

  7.     while (book != NULL)
    

  8.     {
    

  9.         printf("Student%d:\n", count);
    

  10.         printf("姓名：%s\n", info->name);
    

  11.         printf("学号：%d\n", info->identifier);
    

  12.         info = info->next;
    

  13.         count++;
    

  14.     }
    

  15. }

想要读取单链表里面的数据，只需要迭代单链表中的每一个结点，直到next成员为NULL，即表示单链表的结束。

最后，当然还是别忘了释放空间：

复制
  1. void releaseStu(struct Info** students)
    

  2. {
    

  3.     struct Info* temp;
    

  4.     
    

  5.     while (*students != NULL)
    

  6.     {
    

  7.         temp = *students;
    

  8.         *students = (*students)->next;
    

  9.         free(temp);
    

  10.     }
    

  11. }
尾插法

与头插法类似，尾插法就是把每一个数据都插入到链表的末尾。

复制
  1. void addInfo(struct Info** students)
    

  2. {
    

  3.     struct Info* info, *temp;
    

  4.     info = (struct Info*)malloc(sizeof(struct Info));
    

  5.     if (info == NULL)
    

  6.     {
    

  7.         printf("内存分配失败！\n");
    

  8.         exit(1);
    

  9.     }
    

  10.     
    

  11.     getInput(info);
    

  12.     
    

  13.     if (*students != NULL)
    

  14.     {
    

  15.         temp = *students;
    

  16.         *students = info;
    

  17.         //定位到链表的末尾的位置
    

  18.         while (temp->next != NULL)
    

  19.         {
    

  20.             temp = temp->next;
    

  21.         }
    

  22.         //插入数据
    

  23.         temp->next = info;
    

  24.         info->next = temp;
    

  25.     }
    

  26.     else
    

  27.     {
    

  28.         *students = info;
    

  29.         info->next = NULL;
    

  30.     }
    

  31. }

这么一来，程序执行的效率难免要降低很多，因为每次插入数据，都要先遍历一次链表。如果链表很长，那么对于插入数据来说就是一次灾难。不过，我们可以给程序添加一个指针，让它永远都指向链表的尾部，这样一来，就可以用很少的空间换取很高的程序执行效率。

代码更改如下：

复制
  1. void addInfo(struct Info** students)
    

  2. {
    

  3.     struct Info* info, *temp;
    

  4.     static struct Info* tail;//设置静态指针
    

  5.     info = (struct Info*)malloc(sizeof(struct Info));
    

  6.     if (info == NULL)
    

  7.     {
    

  8.         printf("内存分配失败！\n");
    

  9.         exit(1);
    

  10.     }
    

  11.     
    

  12.     getInput(info);
    

  13.     
    

  14.     if (*students != NULL)
    

  15.     {
    

  16.         tail->next = info;
    

  17.         info->next = NULL;
    

  18.     }
    

  19.     else
    

  20.     {
    

  21.         *students = info;
    

  22.         info->next = NULL;
    

  23.     }
    

  24. }


回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:57 | 显示全部楼层
搜索单链表

单链表是我们用来存储数据的一个容器，那么有时候需要快速查找信息就需要开发相关搜索的功能。比如说输入学号，查找同学的所有信息。

复制
  1. struct Info *searchInfo(struct Info* students, long* target)
    

  2. {
    

  3.     struct Info* info;
    

  4.     info = students;
    

  5.     while (info != NULL)
    

  6.     {
    

  7.         if (info->identifier == target)
    

  8.         {
    

  9.             break;
    

  10.         }
    

  11.         info = info->next;
    

  12.     }
    

  13.     
    

  14.     return book;
    

  15. };
    


  16. 

  17. void printInfo(struct Info* info)
    

  18. {
    

  19.     ...
    

  20. }
    

  21. ...
    


  22. 

  23. int main(void)
    

  24. {
    

  25.     ...
    

  26.     printf("\n请输入学生学号：");
    

  27.     scanf("%d", input);
    

  28.     info = searchInfo(students, input);
    

  29.     if (info == NULL)
    

  30.     {
    

  31.         printf("抱歉，未找到相关结果！\n");
    

  32.     }
    

  33.     else
    

  34.     {
    

  35.         do
    

  36.         {
    

  37.             printf("相关结果如下：\n");
    

  38.             printInfo(book);
    

  39.         } while ((info = searchInfo(info->next, input)) != NULL);
    

  40.     }
    

  41.     
    

  42.     releaseInfo(...);
    

  43.     return 0;
    

  44. }


回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:58 | 显示全部楼层
插入结点到指定位置

到了这里，才体现出链表真正的优势。

设想一下，如果有一个有序数组，现在要求你去插入一个数字，插入完成之后，数组依然保持有序。你会怎么做？

没错，你应该会挨个去比较，然后找到合适的位置（当然这里也可以使用二分法，比较节省算力），把这个位置后面的所有数都往后移动一个位置，然后将我们要插入的数字放入刚刚我们腾出来的空间里面。

你会发现，这样的处理方法，经常需要移动大量的数据，对于程序的执行效率来说，是一个不利因素。那么链表，就无所谓。反正在内存中，链表的存储毫无逻辑，我们只需要改变指针的值就可以实现链表的中间插入。


复制
  1. //Example 03
    

  2. #include <stdio.h>
    

  3. #include <stdlib.h>
    


  4. 

  5. struct Node
    

  6. {
    

  7.     int value;
    

  8.     struct Node* next;
    

  9. };
    


  10. 

  11. void insNode(struct Node** head, int value)
    

  12. {
    

  13.     struct Node* pre;
    

  14.     struct Node* cur;
    

  15.     struct Node* New;
    


  16. 

  17.     cur = *head;
    

  18.     pre = NULL;
    


  19. 

  20.     while (cur != NULL && cur->value < value)
    

  21.     {
    

  22.         pre = cur;
    

  23.         cur = cur->next;
    

  24.     }
    


  25. 

  26.     New = (struct Node*)malloc(sizeof(struct Node));
    

  27.     if (New == NULL)
    

  28.     {
    

  29.         printf("内存分配失败！\n");
    

  30.         exit(1);
    

  31.     }
    

  32.     New->value = value;
    

  33.     New->next = cur;
    


  34. 

  35.     if (pre == NULL)
    

  36.     {
    

  37.         *head = New;
    

  38.     }
    

  39.     else
    

  40.     {
    

  41.         pre->next = New;
    

  42.     }
    

  43. }
    


  44. 

  45. void printNode(struct Node* head)
    

  46. {
    

  47.     struct Node* cur;
    


  48. 

  49.     cur = head;
    

  50.     while (cur != NULL)
    

  51.     {
    

  52.         printf("%d ", cur->value);
    

  53.         cur = cur->next;
    

  54.     }
    

  55.     putchar('\n');
    

  56. }
    


  57. 

  58. int main(void)
    

  59. {
    

  60.     struct Node* head = NULL;
    

  61.     int input;
    


  62. 

  63.     printf("开始插入整数...\n");
    

  64.     while (1)
    

  65.     {
    

  66.         printf("请输入一个整数，输入-1表示结束：");
    

  67.         scanf("%d", &input);
    

  68.         if (input == -1)
    

  69.         {
    

  70.             break;
    

  71.         }
    

  72.         insNode(&head, input);
    

  73.         printNode(head);
    

  74.     }
    


  75. 

  76.     return 0;
    

  77. }
运行结果如下：
复制
  1. //Consequence 03
    

  2. 开始插入整数...
    

  3. 请输入一个整数，输入-1表示结束：4
    

  4. 4
    

  5. 请输入一个整数，输入-1表示结束：5
    

  6. 4 5
    

  7. 请输入一个整数，输入-1表示结束：3
    

  8. 3 4 5
    

  9. 请输入一个整数，输入-1表示结束：6
    

  10. 3 4 5 6
    

  11. 请输入一个整数，输入-1表示结束：2
    

  12. 2 3 4 5 6
    

  13. 请输入一个整数，输入-1表示结束：5
    

  14. 2 3 4 5 5 6
    

  15. 请输入一个整数，输入-1表示结束：1
    

  16. 1 2 3 4 5 5 6
    

  17. 请输入一个整数，输入-1表示结束：7
    

  18. 1 2 3 4 5 5 6 7
    

  19. 请输入一个整数，输入-1表示结束：-1



回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 16:59 | 显示全部楼层
删除结点

删除结点的思路也差不多，首先修改待删除的结点的上一个结点的指针，将其指向待删除结点的下一个结点。然后释放待删除结点的空间。

复制
  1. ...
    

  2. void delNode(struct Node** head, int value)
    

  3. {
    

  4.     struct Node* pre;
    

  5.     struct Node* cur;
    

  6.     
    

  7.     cur = *head;
    

  8.     pre = NULL;
    

  9.     while (cur != NULL && cur->value != value)
    

  10.     {
    

  11.         pre = cur;
    

  12.         cur = cur->next;
    

  13.     }
    

  14.     if (cur == NULL)
    

  15.     {
    

  16.         printf("未找到匹配项!\n");
    

  17.         return ;
    

  18.     }
    

  19.     else
    

  20.     {
    

  21.         if (pre == NULL)
    

  22.         {
    

  23.             *head = cur->next;
    

  24.         }
    

  25.         else
    

  26.         {
    

  27.             pre->next = cur->next;
    

  28.         }
    

  29.         free(cur);
    

  30.     }
    

  31. }



回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 17:01 | 显示全部楼层


内存池

C语言的内存管理，从来都是一个让人头秃的问题。要想更自由地管理内存，就必须去堆中申请，然后还需要考虑何时释放，万一释放不当，或者没有及时释放，造成的后果都是难以估量的。

当然如果就这些，那倒也还不算什么。问题就在于，如果大量地使用malloc和free函数来申请内存，首先使要经历一个从应用层切入系统内核层，调用完成之后，再返回应用层的一系列步骤，实际上使非常浪费时间的。更重要的是，还会产生大量的内存碎片。比如，先申请了一个1KB的空间，紧接着又申请了一个8KB的空间。而后，这个1KB使用完了，被释放，但是这个空间却只有等到下一次有刚好1KB的空间申请，才能够被重新调用。这么一来，极限情况下，整个堆有可能被弄得支离破碎，最终导致大量内存浪费。

那么这种情况下，我们解决这类问题的思路，就是创建一个内存池。

内存池，实际上就是我们让程序创建出来的一块额外的缓存区域，如果有需要释放内存，先不必使用free函数，如果内存池有空，那么直接放入内存池。同样的道理，下一次程序申请空间的时候，先检查下内存池里面有没有合适的内存，如果有，则直接拿出来调用，如果没有，那么再使用malloc。

其实内存池我们就可以使用单链表来进行维护，下面通过一个通讯录的程序来说明内存池的运用。

普通的版本：

复制
  1. //Example 04 V1
    

  2. #include <stdio.h>
    

  3. #include <stdlib.h>
    

  4. #include <string.h>
    


  5. 

  6. struct Person
    

  7. {
    

  8.  char name[40];
    

  9.  char phone[20];
    

  10.  struct Person* next;
    

  11. };
    


  12. 

  13. void getInput(struct Person* person);
    

  14. void printPerson(struct Person* person);
    

  15. void addPerson(struct Person** contects);
    

  16. void changePerson(struct Person* contacts);
    

  17. void delPerson(struct Person** contacts);
    

  18. struct Person* findPerson(struct Person* contacts);
    

  19. void displayContacts(struct Person* contacts);
    

  20. void releaseContacts(struct Person** contacts);
    


  21. 

  22. void getInput(struct Person* person)
    

  23. {
    

  24.  printf("请输入姓名：");
    

  25.  scanf("%s", person->name);
    

  26.  printf("请输入电话：");
    

  27.  scanf("%s", person->phone);
    

  28. }
    


  29. 

  30. void addPerson(struct Person** contacts)
    

  31. {
    

  32.  struct Person* person;
    

  33.  struct Person* temp;
    


  34. 

  35.  person = (struct Person*)malloc(sizeof(struct Person));
    

  36.  if (person == NULL)
    

  37.  {
    

  38.   printf("内存分配失败！\n");
    

  39.   exit(1);
    

  40.  }
    


  41. 

  42.  getInput(person);
    


  43. 

  44.  //将person添加到通讯录中
    

  45.  if (*contacts != NULL)
    

  46.  {
    

  47.   temp = *contacts;
    

  48.   *contacts = person;
    

  49.   person->next = temp;
    

  50.  }
    

  51.  else
    

  52.  {
    

  53.   *contacts = person;
    

  54.   person->next = NULL;
    

  55.  }
    

  56. }
    


  57. 

  58. void printPerson(struct Person* person)
    

  59. {
    

  60.  printf("联系人：%s\n", person->name);
    

  61.  printf("电话：%s\n", person->phone);
    

  62. }
    


  63. 

  64. struct Person* findPerson(struct Person* contacts)
    

  65. {
    

  66.  struct Person* current;
    

  67.  char input[40];
    


  68. 

  69.  printf("请输入联系人：");
    

  70.  scanf("%s", input);
    


  71. 

  72.  current = contacts;
    

  73.  while (current != NULL && strcmp(current->name, input))
    

  74.  {
    

  75.   current = current->next;
    

  76.  }
    


  77. 

  78.  return current;
    

  79. }
    


  80. 

  81. void changePerson(struct Person* contacts)
    

  82. {
    

  83.  struct Person* person;
    


  84. 

  85.  person = findPerson(contacts);
    

  86.  if (person == NULL)
    

  87.  {
    

  88.   printf("找不到联系人！\n");
    

  89.  }
    

  90.  else
    

  91.  {
    

  92.   printf("请输入联系电话：");
    

  93.   scanf("%s", person->phone);
    

  94.  }
    

  95. }
    


  96. 

  97. void delPerson(struct Person** contacts)
    

  98. {
    

  99.  struct Person* person;
    

  100.  struct Person* current;
    

  101.  struct Person* previous;
    


  102. 

  103.  //先找到待删除的节点的指针
    

  104.  person = findPerson(*contacts);
    

  105.  if (person == NULL)
    

  106.  {
    

  107.   printf("找不到该联系人！\n");
    

  108.  }
    

  109.  else
    

  110.  {
    

  111.   current = *contacts;
    

  112.   previous = NULL;
    


  113. 

  114.   //将current定位到待删除的节点
    

  115.   while (current != NULL && current != person)
    

  116.   {
    

  117.    previous = current;
    

  118.    current = current->next;
    

  119.   }
    


  120. 

  121.   if (previous == NULL)
    

  122.   {
    

  123.    //若待删除的是第一个节点
    

  124.    *contacts = current->next;
    

  125.   }
    

  126.   else
    

  127.   {
    

  128.    //若待删除的不是第一个节点
    

  129.    previous->next = current->next;
    

  130.   }
    


  131. 

  132.   free(person);//将内存空间释放
    

  133.  }
    

  134. }
    


  135. 

  136. void displayContacts(struct Person* contacts)
    

  137. {
    

  138.  struct Person* current;
    


  139. 

  140.  current = contacts;
    

  141.  while (current != NULL)
    

  142.  {
    

  143.   printPerson(current);
    

  144.   current = current->next;
    

  145.  }
    

  146. }
    


  147. 

  148. void releaseContacts(struct Person** contacts)
    

  149. {
    

  150.  struct Person* temp;
    


  151. 

  152.  while (*contacts != NULL)
    

  153.  {
    

  154.   temp = *contacts;
    

  155.   *contacts = (*contacts)->next;
    

  156.   free(temp);
    

  157.  }
    

  158. }
    


  159. 

  160. int main(void)
    

  161. {
    

  162.  int code;
    

  163.  struct Person* contacts = NULL;
    

  164.  struct Person* person;
    


  165. 

  166.  printf("| 欢迎使用通讯录管理程序 |\n");
    

  167.  printf("|--- 1:插入新的联系人 ---|\n");
    

  168.  printf("|--- 2:查找现有联系人 ---|\n");
    

  169.  printf("|--- 3:更改现有联系人 ---|\n");
    

  170.  printf("|--- 4:删除现有联系人 ---|\n");
    

  171.  printf("|--- 5:显示当前通讯录 ---|\n");
    

  172.  printf("|--- 6:退出通讯录程序 ---|\n");
    


  173. 

  174.  while (1)
    

  175.  {
    

  176.   printf("\n请输入指令代码：");
    

  177.   scanf("%d", &code);
    

  178.   switch (code)
    

  179.   {
    

  180.   case 1:addPerson(&contacts); break;
    

  181.   case 2:person = findPerson(contacts);
    

  182.    if (person == NULL)
    

  183.    {
    

  184.     printf("找不到该联系人！\n");
    

  185.    }
    

  186.    else
    

  187.    {
    

  188.     printPerson(person);
    

  189.    }
    

  190.    break;
    

  191.   case 3:changePerson(contacts); break;
    

  192.   case 4:delPerson(&contacts); break;
    

  193.   case 5:displayContacts(contacts); break;
    

  194.   case 6:goto END;
    

  195.   }
    

  196.  }
    


  197. 

  198. END://此处直接跳出恒循环
    

  199.  releaseContacts(&contacts);
    


  200. 

  201.  return 0;
    


  202. 

  203. }

运行结果如下：

复制
  1. //Consequence 04 V1
    

  2. | 欢迎使用通讯录管理程序 |
    

  3. |--- 1:插入新的联系人 ---|
    

  4. |--- 2:查找现有联系人 ---|
    

  5. |--- 3:更改现有联系人 ---|
    

  6. |--- 4:删除现有联系人 ---|
    

  7. |--- 5:显示当前通讯录 ---|
    

  8. |--- 6:退出通讯录程序 ---|
    


  9. 

  10. 请输入指令代码：1
    

  11. 请输入姓名：HarrisWilde
    

  12. 请输入电话：0101111
    


  13. 

  14. 请输入指令代码：1
    

  15. 请输入姓名：Jack
    

  16. 请输入电话：0101112
    


  17. 

  18. 请输入指令代码：1
    

  19. 请输入姓名：Rose
    

  20. 请输入电话：0101113
    


  21. 

  22. 请输入指令代码：2
    

  23. 请输入联系人：HarrisWilde
    

  24. 联系人：HarrisWilde
    

  25. 电话：0101111
    


  26. 

  27. 请输入指令代码：2
    

  28. 请输入联系人：Mike
    

  29. 找不到该联系人！
    


  30. 

  31. 请输入指令代码：5
    

  32. 联系人：Rose
    

  33. 电话：0101113
    

  34. 联系人：Jack
    

  35. 电话：0101112
    

  36. 联系人：HarrisWilde
    

  37. 电话：0101111
    


  38. 

  39. 请输入指令代码：3
    

  40. 请输入联系人：HarrisWilde
    

  41. 请输入联系电话：0101234
    


  42. 

  43. 请输入指令代码：5
    

  44. 联系人：Rose
    

  45. 电话：0101113
    

  46. 联系人：Jack
    

  47. 电话：0101112
    

  48. 联系人：HarrisWilde
    

  49. 电话：0101234
    


  50. 

  51. 请输入指令代码：6
下面加入内存池：
复制
  1. //Example 04 V2
    

  2. #include <stdio.h>
    

  3. #include <stdlib.h>
    

  4. #include <string.h>
    


  5. 

  6. #define MAX 1024
    


  7. 

  8. struct Person
    

  9. {
    

  10.  char name[40];
    

  11.  char phone[20];
    

  12.  struct Person* next;
    

  13. };
    


  14. 

  15. struct Person* pool = NULL;
    

  16. int count;
    


  17. 

  18. void getInput(struct Person* person);
    

  19. void printPerson(struct Person* person);
    

  20. void addPerson(struct Person** contects);
    

  21. void changePerson(struct Person* contacts);
    

  22. void delPerson(struct Person** contacts);
    

  23. struct Person* findPerson(struct Person* contacts);
    

  24. void displayContacts(struct Person* contacts);
    

  25. void releaseContacts(struct Person** contacts);
    

  26. void releasePool(void);
    


  27. 

  28. void getInput(struct Person* person)
    

  29. {
    

  30.  printf("请输入姓名：");
    

  31.  scanf("%s", person->name);
    

  32.  printf("请输入电话：");
    

  33.  scanf("%s", person->phone);
    

  34. }
    


  35. 

  36. void addPerson(struct Person** contacts)
    

  37. {
    

  38.  struct Person* person;
    

  39.  struct Person* temp;
    


  40. 

  41.  //如果内存池不是空的，那么首先从里面获取空间
    

  42.  if (pool != NULL)
    

  43.  {
    

  44.   person = pool;
    

  45.   pool = pool->next;
    

  46.   count--;
    

  47.  }
    

  48.  //内存池为空，则直接申请
    

  49.  else
    

  50.  {
    

  51.   person = (struct Person*)malloc(sizeof(struct Person));
    

  52.   if (person == NULL)
    

  53.   {
    

  54.    printf("内存分配失败！\n");
    

  55.    exit(1);
    

  56.   }
    

  57.  }
    


  58. 


  59. 

  60.  getInput(person);
    


  61. 

  62.  //将person添加到通讯录中
    

  63.  if (*contacts != NULL)
    

  64.  {
    

  65.   temp = *contacts;
    

  66.   *contacts = person;
    

  67.   person->next = temp;
    

  68.  }
    

  69.  else
    

  70.  {
    

  71.   *contacts = person;
    

  72.   person->next = NULL;
    

  73.  }
    

  74. }
    


  75. 

  76. void printPerson(struct Person* person)
    

  77. {
    

  78.  printf("联系人：%s\n", person->name);
    

  79.  printf("电话：%s\n", person->phone);
    

  80. }
    


  81. 

  82. struct Person* findPerson(struct Person* contacts)
    

  83. {
    

  84.  struct Person* current;
    

  85.  char input[40];
    


  86. 

  87.  printf("请输入联系人：");
    

  88.  scanf("%s", input);
    


  89. 

  90.  current = contacts;
    

  91.  while (current != NULL && strcmp(current->name, input))
    

  92.  {
    

  93.   current = current->next;
    

  94.  }
    


  95. 

  96.  return current;
    

  97. }
    


  98. 

  99. void changePerson(struct Person* contacts)
    

  100. {
    

  101.  struct Person* person;
    


  102. 

  103.  person = findPerson(contacts);
    

  104.  if (person == NULL)
    

  105.  {
    

  106.   printf("找不到联系人！\n");
    

  107.  }
    

  108.  else
    

  109.  {
    

  110.   printf("请输入联系电话：");
    

  111.   scanf("%s", person->phone);
    

  112.  }
    

  113. }
    


  114. 

  115. void delPerson(struct Person** contacts)
    

  116. {
    

  117.  struct Person* person;
    

  118.  struct Person* current;
    

  119.  struct Person* previous;
    

  120.  struct Person* temp;
    

  121.  {
    


  122. 

  123.  };
    


  124. 

  125.  //先找到待删除的节点的指针
    

  126.  person = findPerson(*contacts);
    

  127.  if (person == NULL)
    

  128.  {
    

  129.   printf("找不到该联系人！\n");
    

  130.  }
    

  131.  else
    

  132.  {
    

  133.   current = *contacts;
    

  134.   previous = NULL;
    


  135. 

  136.   //将current定位到待删除的节点
    

  137.   while (current != NULL && current != person)
    

  138.   {
    

  139.    previous = current;
    

  140.    current = current->next;
    

  141.   }
    


  142. 

  143.   if (previous == NULL)
    

  144.   {
    

  145.    //若待删除的是第一个节点
    

  146.    *contacts = current->next;
    

  147.   }
    

  148.   else
    

  149.   {
    

  150.    //若待删除的不是第一个节点
    

  151.    previous->next = current->next;
    

  152.   }
    


  153. 

  154.   //判断内存池中有没有空位
    

  155.   if (count < MAX)
    

  156.   {
    

  157.    //使用头插法将person指向的空间插入内存池中
    

  158.    if (pool != NULL)
    

  159.    {
    

  160.     temp = pool;
    

  161.     pool = person;
    

  162.     person->next = temp;
    

  163.    }
    

  164.    else
    

  165.    {
    

  166.     pool = person;
    

  167.     person->next = NULL;
    

  168.    }
    

  169.    count++;
    

  170.   }
    

  171.   //没有空位，直接释放
    

  172.   else
    

  173.   {
    

  174.    free(person);//将内存空间释放
    

  175.   }
    

  176.  }
    

  177. }
    


  178. 

  179. void displayContacts(struct Person* contacts)
    

  180. {
    

  181.  struct Person* current;
    


  182. 

  183.  current = contacts;
    

  184.  while (current != NULL)
    

  185.  {
    

  186.   printPerson(current);
    

  187.   current = current->next;
    

  188.  }
    

  189. }
    


  190. 

  191. void releaseContacts(struct Person** contacts)
    

  192. {
    

  193.  struct Person* temp;
    


  194. 

  195.  while (*contacts != NULL)
    

  196.  {
    

  197.   temp = *contacts;
    

  198.   *contacts = (*contacts)->next;
    

  199.   free(temp);
    

  200.  }
    

  201. }
    


  202. 

  203. void releasePool(void)
    

  204. {
    

  205.  struct Person* temp;
    

  206.  while (pool != NULL)
    

  207.  {
    

  208.   temp = pool;
    

  209.   pool = pool->next;
    

  210.   free(temp);
    

  211.  }
    

  212. }
    


  213. 

  214. int main(void)
    

  215. {
    

  216.  int code;
    

  217.  struct Person* contacts = NULL;
    

  218.  struct Person* person;
    


  219. 

  220.  printf("| 欢迎使用通讯录管理程序 |\n");
    

  221.  printf("|--- 1:插入新的联系人 ---|\n");
    

  222.  printf("|--- 2:查找现有联系人 ---|\n");
    

  223.  printf("|--- 3:更改现有联系人 ---|\n");
    

  224.  printf("|--- 4:删除现有联系人 ---|\n");
    

  225.  printf("|--- 5:显示当前通讯录 ---|\n");
    

  226.  printf("|--- 6:退出通讯录程序 ---|\n");
    


  227. 

  228.  while (1)
    

  229.  {
    

  230.   printf("\n请输入指令代码：");
    

  231.   scanf("%d", &code);
    

  232.   switch (code)
    

  233.   {
    

  234.   case 1:addPerson(&contacts); break;
    

  235.   case 2:person = findPerson(contacts);
    

  236.    if (person == NULL)
    

  237.    {
    

  238.     printf("找不到该联系人！\n");
    

  239.    }
    

  240.    else
    

  241.    {
    

  242.     printPerson(person);
    

  243.    }
    

  244.    break;
    

  245.   case 3:changePerson(contacts); break;
    

  246.   case 4:delPerson(&contacts); break;
    

  247.   case 5:displayContacts(contacts); break;
    

  248.   case 6:goto END;
    

  249.   }
    

  250.  }
    


  251. 

  252. END://此处直接跳出恒循环
    

  253.  releaseContacts(&contacts);
    

  254.  releasePool();
    


  255. 

  256.  return 0;
    


  257. 

  258. }



回复

收藏1 举报

 楼主| 盗铃何须掩耳 发表于 2022-5-6 17:02 | 显示全部楼层


typedef给数据类型起别名

C语言是一门古老的语言，它是在1969至1973年间，由两位天才丹尼斯·里奇和肯·汤普逊在贝尔实验室以B语言为基础开发出来的，用于他们的重写UNIX计划（这也为后来UNIX系统的可移植性打下了基础，之前的UNIX是使用汇编语言编写的，当然也是这两位为了玩一个自己设计的游戏而编写的）。天才就是和咱常人不一样，不过他俩的故事，在这篇里面不多啰嗦，我们回到话题。

虽然C语言诞生的很早，但是却依旧不是最早的高级编程语言。目前公认的最早的高级编程语言，是IBM公司于1957年开发的FORTRAN语言。C语言诞生之时，FORTRAN已经统领行业数十年之久。因此，C语言要想快速吸纳FORTRAN中的潜在用户，就必须做出一些妥协。

我们知道，不同的语言的语法，一般来说是不同的，甚至还有较大的差距。比如：

C:

复制
  1. int a, b, c;
    

  2. float i, j, k;

而FORTRAN语言是这样的：

复制
  1. integer :: a, b, c;
    

  2. real :: i, j, k;

如果让FORTRAN用户使用原来的变量名称进行使用，那么就能够快速迁移到C语言上面来，这就是typedef的用处之一。

我们使用FORTRAN语言的类型名，那就这么办：

复制
  1. typedef int integer;
    

  2. typedef float real;
    


  3. 

  4. integer a, b, c;
    

  5. real i, j, k;


回复

收藏1 举报

下一页 »
123下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

盗铃何须掩耳

50

主题

385

帖子

0

粉丝
快速回复 在线客服 返回列表 返回顶部