C语言之结构体详解

[复制链接]

gaosmile 发布时间：2020-4-20 09:38

技术帖
文章封面:	-
文章简介:	-

「本文目录」

o 结构体的声明与定义

§ 声明

§ 定义

§ 访问结构体成员

§ 初始化结构体

§ 对齐

o 结构体嵌套

o 结构体数组

o 结构体指针

o 传递结构体信息

§ 传递结构体变量

§ 传递指向结构体变量的指针

o 动态申请结构体

o 实战：建立一个图书馆数据库

o 单链表

§ 在单链表中插入元素

§ 搜索单链表

§ 插入结点到指定位置

§ 删除结点

o 内存池

o typedef

§ 给数据类型起别名

§ 结构体的搭档

§ 进阶

o 共用体

§ 声明

§ 初始化

o 枚举

o 位域

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

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

o 批量存储数据

o 存储不同类型的数据

o 支持嵌套

结构体的声明与定义

声明

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

struct Info
{
unsigned long identifier;//学号，用无符号长整数表示
char name[20];//名字，用字符数组表示
unsigned int year;//入学年份，用无符号整数表示
unsigned int years;//学制，用无符号整数表示
}

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

定义

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

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

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

#include <stdio.h>

struct Info
{
unsigned long identifier;//学号，用无符号长整数表示
char name[20];//名字，用字符数组表示
unsigned int year;//入学年份，用无符号整数表示
unsigned int years;//学制，用无符号整数表示
};

int main(void)
{
/**
2 l9 ?+ v. P' X, `- P2 i( @" ]    *在main函数中声明结构体变量) X! j* ^% u2 @3 g. l1 Z- o* K
   *结构体变量名叫info
: z) e2 {" y: e: }. J$ W6 }1 s% L6 L    *struct关键字不能丢1 f6 d' @+ S) f% i% @1 R
   */
struct Info info;
...
}

也可以在声明的时候就把变量名定义下来（此时这个变量是全局变量）：

#include <stdio.h>

struct Info
{
unsigned long identifier;//学号，用无符号长整数表示
char name[20];//名字，用字符数组表示
unsigned int year;//入学年份，用无符号整数表示
unsigned int years;//学制，用无符号整数表示
} info;
/**' E# k& T% `8 u% {; A
*此时直接定义了变量! Y. k* v4 ^# A, u5 _6 y3 S" H1 O1 \
*该变量是全局变量
3 b' D( L) f& C& j+ M8 O# U7 J *变量名叫info7 R5 @+ {" x I) w" a( y, r z& A
*/

int main(void)
{
...
}

访问结构体成员

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

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

//Example 01
#include <stdio.h>

struct Info
{
unsigned long identifier;//学号，用无符号长整数表示
char name[20];//名字，用字符数组表示
unsigned int year;//入学年份，用无符号整数表示
unsigned int years;//学制，用无符号整数表示
};

int main(void)
{
struct Info info;

printf("请输入学生的学号：");
scanf("%d", &info.identifier);
printf("请输入学生的姓名：");
scanf("%s", info.name);
printf("请输入学生的入学年份：");
scanf("%d", &info.year);
printf("请输入学生的学制：");
scanf("%d", &info.years);

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

printf("学号：%d\n姓名：%s\n入学年份：%d\n学制：%d\n毕业时间：%d\n", \
info.identifier, info.name, info.year, info.years, info.year + info.years);
return 0;
}

运行结果如下：

//Consequence 01
请输入学生的学号：20191101
请输入学生的姓名：Harris
请输入学生的入学年份：2019
请输入学生的学制：4

数据录入完毕

学号：20191101
姓名：Harris
入学年份：2019
学制：4
毕业时间：2023

初始化结构体

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

struct Info info = {
20191101,
"Harris",
2019,
4
};

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

struct Info info = {
.name = "Harris",
.year = 2019
};

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

对齐

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

//EXample 02 V1
#include <stdio.h>

int main(void)
{
struct A
{
      char a;
      int b;
      char c;
} a = {'a', 10, 'o'};

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

return 0;
}

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

//COnsequence 02 V1
size of a = 12

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

//EXample 02 V2
#include <stdio.h>

int main(void)
{
struct A
{
      char a;
      char c;
      int b;
} a = {'a', 'o', 10};

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

return 0;
}

结果：

//Consequence 02 V2
size of a = 8

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

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

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

英文原版，中文版

结构体嵌套

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

#include <stdio.h>

struct Date
{
unsigned int year;
unsigned int month;
unsigned int day;
};

struct Info
{
unsigned long identifier;//学号，用无符号长整数表示
char name[20];//名字，用字符数组表示
struct Date date;/*---入学日期，用结构体Date表示---*/
unsigned int years;//学制，用无符号整数表示
};

int main(void)
{
...
}

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

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

//Example 03
#include <stdio.h>

struct Date
{
unsigned int year;
unsigned int month;
unsigned int day;
};

struct Info
{
unsigned long identifier;//学号，用无符号长整数表示
char name[20];//名字，用字符数组表示
struct Date date;/*---入学日期，用结构体Date表示---*/
unsigned int years;//学制，用无符号整数表示
};

int main(void)
{
struct Info info;
printf("请输入学生的学号：");
scanf("%d", &info.identifier);
printf("请输入学生的姓名：");
scanf("%s", info.name);
printf("请输入学生的入学年份：");
scanf("%d", &info.date.year);
printf("请输入学生的入学月份：");
scanf("%d", &info.date.month);
printf("请输入学生的入学日期：");
scanf("%d", &info.date.day);
printf("请输入学生的学制：");
scanf("%d", &info.years);

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

printf("学号：%d\n姓名：%s\n入学时间：%d/%d/%d\n学制：%d\n毕业时间：%d\n",\
         info.identifier, info.name,\
         info.date.year, info.date.month, info.date.day,\
         info.years, info.date.year + info.years);
return 0;
}

运行结果如下：

//Consequence 03
请输入学生的学号：20191101
请输入学生的姓名：Harris
请输入学生的入学年份：2019
请输入学生的入学月份：9
请输入学生的入学日期：7
请输入学生的学制：4

数据录入完毕

学号：20191101
姓名：Harris
入学时间：2019/9/7
学制：4
毕业时间：2023

结构体数组

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

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

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

struct 结构体类型
{
成员;
} 数组名[长度];

/****或者这样****/

struct 结构体类型
{
成员;
};
struct 结构体类型数组名[长度];

结构体指针

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

struct Info* pinfo;

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

pinfo = &info;

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

1.(*结构体指针).成员名

2.结构体指针->成员名

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

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

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

第一种方法：

#include <stdio.h>
...
int main(void)
{
struct Info *p;
p = &info;

printf("学号：\n", (*p).identifier);
printf("姓名：\n", (*p).name);
printf("入学时间：%d/%d/%d\n", (*p).date.year, (*p).date.month, (*p).date.day);
printf("学制：\n", (*p).years);
return 0;
}

第二种方法：

#include <stdio.h>
...
int main(void)
{
struct Info *p;
p = &info;

printf("学号：\n", p -> identifier);
printf("姓名：\n", p -> name);
printf("入学时间：%d/%d/%d\n", p -> date.year, p -> date.month, p -> date.day);
printf("学制：\n", p -> years);
return 0;
}

传递结构体信息

传递结构体变量

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

//Example 04
#include <stdio.h>

int main(void)
{
struct Test
{
int x;
int y;
}t1, t2;

t1.x = 3;
t1.y = 4;
t2 = t1;

printf("t2.x = %d, t2.y = %d\n", t2.x, t2.y);
return 0;
}

运行结果如下：

//Consequence 04
t2.x = 3, t2.y = 4

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

先来试试作为参数:

//Example 05
#include <stdio.h>
struct Date
{
unsigned int year;
unsigned int month;
unsigned int day;
};

struct Info
{
unsigned long identifier;
char name[20];
struct Date date;
unsigned int years;
};

struct Info getInput(struct Info info);
void printInfo(struct Info info);

struct Info getInput(struct Info info)
{
printf("请输入学号：");
scanf("%d", &info.identifier);
printf("请输入姓名：");
scanf("%s", info.name);
printf("请输入入学年份：");
scanf("%d", &info.date.year);
printf("请输入月份：");
scanf("%d", &info.date.month);
printf("请输入日期：");
scanf("%d", &info.date.day);
printf("请输入学制：");
scanf("%d", &info.years);

return info;
}

void printInfo(struct Info info)
{
printf("学号：%d\n姓名：%s\n入学时间：%d/%d/%d\n学制：%d\n毕业时间：%d\n", \
      info.identifier, info.name, \
      info.date.year, info.date.month, info.date.day, \
      info.years, info.date.year + info.years);
}

int main(void)
{
struct Info i1 = {};
struct Info i2 = {};
printf("请录入第一个同学的信息...\n");
i1 = getInput(i1);
putchar('\n');
printf("请录入第二个学生的信息...\n");
i2 = getInput(i2);

printf("\n录入完毕，现在开始打印...\n\n");
printf("打印第一个学生的信息...\n");
printInfo(i1);
putchar('\n');
printf("打印第二个学生的信息...\n");
printInfo(i2);

return 0;
}

运行结果如下：

//Consequence 05
请录入第一个同学的信息...
请输入学号：20191101
请输入姓名：Harris
请输入入学年份：2019
请输入月份：9
请输入日期：7
请输入学制：4

请录入第二个学生的信息...
请输入学号：20191102
请输入姓名：Joy
请输入入学年份：2019
请输入月份：9
请输入日期：8
请输入学制：5

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

打印第一个学生的信息...
学号：20191101
姓名：Harris
入学时间：2019/9/7
学制：4
毕业时间：2023

打印第二个学生的信息...
学号：20191102
姓名：Joy
入学时间：2019/9/8
学制：5
毕业时间：2024

传递指向结构体变量的指针

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

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

将刚才的代码修改一下：

//Example 06
#include <stdio.h>
struct Date
{
unsigned int year;
unsigned int month;
unsigned int day;
};

struct Info
{
unsigned long identifier;
char name[20];
struct Date date;
unsigned int years;
};

void getInput(struct Info *info);
void printInfo(struct Info *info);

void getInput(struct Info *info)
{
printf("请输入学号：");
scanf("%d", &info->identifier);
printf("请输入姓名：");
scanf("%s", info->name);
printf("请输入入学年份：");
scanf("%d", &info->date.year);
printf("请输入月份：");
scanf("%d", &info->date.month);
printf("请输入日期：");
scanf("%d", &info->date.day);
printf("请输入学制：");
scanf("%d", &info->years);
}

void printInfo(struct Info *info)
{
printf("学号：%d\n姓名：%s\n入学时间：%d/%d/%d\n学制：%d\n毕业时间：%d\n", \
      info->identifier, info->name, \
      info->date.year, info->date.month, info->date.day, \
      info->years, info->date.year + info->years);
}

int main(void)
{
struct Info i1 = {};
struct Info i2 = {};
printf("请录入第一个同学的信息...\n");
getInput(&i1);
putchar('\n');
printf("请录入第二个学生的信息...\n");
getInput(&i2);

printf("\n录入完毕，现在开始打印...\n\n");
printf("打印第一个学生的信息...\n");
printInfo(&i1);
putchar('\n');
printf("打印第二个学生的信息...\n");
printInfo(&i2);

return 0;
}

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

动态申请结构体

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

//Example 01
#include <stdio.h>
...
int main(void)
{
struct Info *i1;
struct Info *i2;

i1 = (struct Info *)malloc(sizeof(struct Info));
i2 = (struct Info *)malloc(sizeof(struct Info));
if (i1 == NULL || i2 == NULL)
{
printf("内存分配失败！\n");
exit(1);
}

printf("请录入第一个同学的信息...\n");
getInput(i1);
putchar('\n');
printf("请录入第二个学生的信息...\n");
getInput(i2);

printf("\n录入完毕，现在开始打印...\n\n");
printf("打印第一个学生的信息...\n");
printInfo(i1);
putchar('\n');
printf("打印第二个学生的信息...\n");
printInfo(i2);

free(i1);
free(i2);

return 0;
}

实战：建立一个图书馆数据库

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

代码实现如下：

//Example 02
#include <stdio.h>
#include <stdlib.h>

#define MAX_SIZE 100

struct Date
{
int year;
int month;
int day;
};

struct Book
{
char title[128];
char author[48];
float price;
struct Date date;
char publisher[48];
};

void getInput(struct Book* book);//录入数据
void printBook(struct Book* book);//打印数据
void initLibrary(struct Book* lib[]);//初始化结构体
void printLibrary(struct Book* lib[]);//打印单本书数据
void releaseLibrary(struct Book* lib[]);//释放内存

void getInput(struct Book* book)
{
printf("请输入书名：");
scanf("%s", book->title);
printf("请输入作者：");
scanf("%s", book->author);
printf("请输入售价：");
scanf("%f", &book->price);
printf("请输入出版日期：");
scanf("%d-%d-%d", &book->date.year, &book->date.month, &book->date.day);
printf("请输入出版社：");
scanf("%s", book->publisher);
}

void printBook(struct Book* book)
{
printf("书名：%s\n", book->title);
printf("作者：%s\n", book->author);
printf("售价：%.2f\n", book->price);
printf("出版日期：%d-%d-%d\n", book->date.year, book->date.month, book->date.day);
printf("出版社：%s\n", book->publisher);
}

void initLibrary(struct Book* lib[])
{
for (int i = 0; i < MAX_SIZE; i++)
{
      lib = NULL;9 N1 K- A! s2 H* c3 e" l
}
2 ^- U4 Z6 q0 K& i) }}
5 o# V& n! }& X2 P
. p# q" k5 G, p) Zvoid printLibrary(struct Book* lib[])7 ]  w* K- ^6 J, ]/ u  x
{
& w) d2 q$ u5 A8 r/ c" r0 h6 o& l% V for (int i = 0; i < MAX_SIZE; i++)
6 u) U( P! C' ^0 {9 } {
+ Y/ L: C$ ?0 e       if (lib != NULL)& d$ G* G3 O8 i- {4 _
      {9 A* X8 W9 x" D3 o  X5 t; O7 c; X+ M
         printBook(lib);
* {/ w. t$ _  a# P( O% j          putchar('\n');. Q" P! U1 |5 V  C1 Y/ O% l/ k
      }
# ]1 r+ Y3 p" n1 I$ X0 N }/ l5 E! p; v3 d+ K! \" C: B
}
$ a) j2 W, C0 E& A7 L/ b2 l$ X/ v0 N; k% N2 f. v+ h% _+ F  C
void releaseLibrary(struct Book* lib[])
) o, K+ A, w: l7 e{  B& k2 A! F' P( K& ~* ?3 d
for (int i = 0; i < MAX_SIZE; i++)
: r; J- ^" Z. o; p+ R3 x, M {
+ O# T" `, W7 [, A" e5 ^       if (lib != NULL). E1 K5 u4 d" Y9 R" ]+ A
      {
! }6 Y: N* W- _( {3 e          free(lib);& P# n: t9 f+ w8 D0 D+ \. o- X$ C
      }
2 ]% {: P" Q- C$ M1 E# K& R6 ~ }
3 h# K3 N+ @' F  v" m}
8 G4 O' T% {5 p& l+ e; C0 `- \1 K* A, ^+ I5 G& ~
int main(void)& M' }" `2 ~% N" n5 L; @$ F
{
* F1 u  e: J, }6 b& F! m* d) P struct Book* lib[MAX_SIZE];2 ]. q* z% J' I1 u& \/ [
struct Book* p = NULL;
+ I0 D1 c. n! e, Y( _1 l int ch, index = 0;) z# X3 m9 A: h* q

. l" \- r0 O0 g* m# a) {4 s5 p$ S initLibrary(lib);
9 y: t; j2 V$ Z& k
9 Q; l% J1 U, t while (1)
) B% T8 X5 u( ?  w$ b$ v; u {
* x% R* I! W% E6 K& j       printf("请问是否要录入图书信息(Y/N):");; f2 s4 c$ T+ x, h
      do0 [& l/ `8 X2 r8 I+ D5 D/ I
      {
& g, s9 f! g, k, x          ch = getchar();
6 B& _  f1 s& n9 ^       } while (ch != 'Y' && ch != 'N');2 `5 M/ I! Y1 ]

6 O7 u4 V6 O% B0 ~5 ]       if (ch == 'Y')9 d: i5 K  m3 X2 d
      {' g% @. g2 z' V: R  V- S
         if (index < MAX_SIZE)
0 E7 B9 S5 P, \4 u/ a          {
% j% A- G5 b9 d" c" O" [             p = (struct Book*)malloc(sizeof(struct Book));
3 p& s- H+ a# U, d' u             getInput(p);
1 ]7 q+ z( ]# h9 j+ m9 w             lib[index] = p;5 T' U+ r: Y7 [! e  r: R
            index++;% H/ Z8 O9 q4 D2 t/ x: l0 m
            putchar('\n');
4 l9 |7 J0 O: P3 v          }
, |' ^& m* J! ?! t; k& r$ {          else
8 f) g2 W. {5 N5 V" Q          {
" s9 l9 A. j, {/ j; \             printf("数据库已满！\n");
  V, w9 q1 \; H" G5 y             break;
/ A) p( `- r: V, |* D          }
7 }6 y7 k3 [/ V) E: A+ }! e       }
4 B( [% N+ C6 q8 M( U       else
4 v( J( g* ]: X; j+ z! w       {
" }! `8 G# A% }, j8 N: @6 ^          break;( D# C: s3 y6 B# l2 c3 D; \8 R- i
      }2 ]- L; @2 w9 Q6 u5 J& n1 {2 r
}" {4 T+ ?; @3 s( ^6 f/ y2 k' S, c

$ k! v- d( k7 } printf("\n数据录入完毕，开始打印验证...\n\n");8 N5 \, q2 P) _" k& V: `
printLibrary(lib);; }. R$ Y- o8 \) I8 s  ?' {  [
releaseLibrary(lib);
/ {0 I. Z& R" s; E+ r: J+ x8 t8 l) Y# W$ M$ i9 S2 X1 _8 g+ t6 e) `) {$ N
return 0;+ G5 R9 L7 d; N$ K6 j9 j
}

运行结果如下：

//Consequence 02( }) e5 P  l4 p7 L5 ^+ ~; r. g
请问是否要录入图书信息(Y/N):Y( j* R- ^+ X/ Q6 X( x4 R( J
请输入书名：人类简史
' u; }% j* B& ?请输入作者：尤瓦尔·赫拉利, Q2 b3 k1 i1 h$ o% _. ?
请输入售价：32.257 j( u6 G- ?1 g1 o
请输入出版日期：2016-3-4: u1 N1 |3 t4 M. A
请输入出版社：中信出版集团
8 G' y5 c/ M+ B9 g5 y7 V
+ G7 n; h  v  {请问是否要录入图书信息(Y/N):N
  O  x; r5 w( E0 Y$ t
8 Y6 S" O, c- @2 D数据录入完毕，开始打印验证...* \& p1 h" ^* F/ e7 r* o$ T3 J

1 R7 \& `7 c( l$ P书名：人类简史
8 m' Z) w; z4 `: d( [  y3 t9 l作者：尤瓦尔·赫拉利
) h7 W. H- q+ }: y0 g- `$ D  X售价：32.25+ l0 G* \4 J6 @- [% y  T
出版日期：2016-3-44 o7 f5 M- w! C; U( D3 ~
出版社：中信出版集团

单链表

* C  F1 i6 Y, I4 R" R; H. o
我们知道，数组变量在内存中，是连续的，而且不可拓展。显然在一些情况下，这种数据结构拥有很大的局限性。比如移动数据的时候，会牵一发而动全身，尤其是反转这种操作更加令人窒息。那么，需要需要一种数据结构来弄出一种更加灵活的“数组”，那么这，就是「链表」。
本节我们只讲讲单链表。
所谓链表，就是由一个个「结点」组成的一个数据结构。每个结点都有「数据域」和「指针域」组成。其中数据域用来存储你想要存储的信息，而指针域用来存储下一个结点的地址。如图：

% i: L; t4 s/ m6 w# _
单链表
当然，链表最前面还有一个头指针，用来存储头结点的地址。
这样一来，链表中的每一个结点都可以不用挨个存放，因为有了指针把他们串起来。因此结点放在哪都无所谓，反正指针总是能够指向下一个元素。我们只需要知道头指针，就能够顺藤摸瓜地找到整个链表。
因此对于学籍数据库来说，我们只需要在Info结构体中加上一个指向自身类型的成员即可：
struct Info
+ P4 y+ ]1 }& I, S{
1 }" H3 {$ E/ V2 ~0 D$ h% l unsigned long identifier;* B0 l0 _( j5 D# s9 x/ n# q
char name[20];, ^" J. ^, p! t5 m
struct Date date;3 A* q# t. O) h. @$ X0 D1 B4 V4 h
unsigned int years;
* Y+ c- ~- l5 b! x struct Info* next;
3 k' K' D; Z% m; l' i; {};
在单链表中插入元素
头插法
这种每次都将数据插入单链表的头部（头指针后面）的插入法就叫头插法。
如果要把学生信息加入到单链表，可以这么写：
void addInfo(struct Info** students)//students是头指针* t" u- b. n( _( U# a$ r0 X
{1 F, @' V5 j5 z. k
struct Info* info, *temp;
, J! O/ k4 u2 k/ h1 A info = (struct Info*)malloc(sizeof(struct Info));
5 f4 S% n* C4 Z6 w7 y$ c8 ~ if (info == NULL)/ v( j0 Q3 U5 h6 Z
{
$ L3 T  v( ]  A, I/ Q+ G       printf("内存分配失败！\n");
' O2 a& P5 z5 B* }0 _- ^" ~       exit(1);
/ Y2 [! T% v4 [ }
0 F* Y2 }* I; W3 d9 K- }$ q, p
5 _& {* e3 ?) s8 B) E/ f getInput(info);
- h2 J$ e2 c+ A
2 d( {$ K) I) e: Q: Z+ j if (*students != NULL)% L! _' ~& \" j! ^
{4 f! L# c$ S. i( g: v9 y7 u" E7 `
      temp = *students;
7 m. I5 w# y2 m0 Z$ {4 m; ?$ J0 t       *students = info;
/ e! F1 D' T7 F- r# U" u$ S+ C/ S       info->next = temp;' T# [3 ^' g8 d
}
8 @+ D' z: v/ r% Y9 s else
9 D9 T  \/ y& s: \$ q, b {
& z3 V; ]5 F1 r       *students = info;
7 _( V: o5 L7 G$ d/ a       info->next = NULL;
! P1 X& x4 m8 Z }! \0 b+ L- M7 k9 e; ?: S5 s) p5 g
}
❝
由于students存放的是头指针，因此我们需要传入它的地址传递给函数，才能够改变它本身的值。而students本身又是一个指向Info结构体的指针，所以参数的类型应该就是struct Info**。
❞
往单链表里面添加一个结点，也就是先申请一个结点，然后判断链表是否为空。如果为空，那么直接将头指针指向它，然后next成员指向NULL。若不为空，那么先将next指向头指针原本指向的结点，然后将头指针指向新结点即可。
那么，打印链表也变得很简单：
void printStu(struct Info* students)/ |$ u, ^2 \+ N' v
{
& {3 J2 P9 K5 O1 G2 w struct Info* info;
% N5 x1 K* v( C; T6 A int count = 1;
9 {! T. Z6 S( ]$ V+ {( O  `: P ( \& d6 l6 c4 q" i0 }
info = students;1 c" A( V4 L- M1 O
while (book != NULL)
* \6 V! f+ e6 U& s$ s: G3 b {
8 D* `" ?" `/ F* c  t, K       printf("Student%d:\n", count);
3 R; \8 Y# E6 J- z; |2 z& ]       printf("姓名：%s\n", info->name);
5 R. u4 s" j% [' M) m5 R# S5 }: A" _       printf("学号：%d\n", info->identifier);  k# E- m% k/ t/ G2 y7 L& T
      info = info->next;
0 H) d7 p: X5 i, ^  e/ {7 E1 b4 a       count++;7 l7 S* Z6 a0 R& }8 Y
}
: h( m' Y* L  V}
想要读取单链表里面的数据，只需要迭代单链表中的每一个结点，直到next成员为NULL，即表示单链表的结束。
最后，当然还是别忘了释放空间：
void releaseStu(struct Info** students)  k4 Q- u5 h( o5 Q6 {2 p: r
{; _7 c" ?! J, ?8 V: D( ^* T
struct Info* temp;2 F+ p# |' @9 C6 \( u6 N

6 L  j) [! }4 T/ u) ^; \! S while (*students != NULL)
: ^# s% ?# B. k% o. H% U( b {" s( \- q4 \8 V! ?' ?9 Y. F
      temp = *students;. z* R7 V! ~, `$ y
      *students = (*students)->next;! h8 ^) |! N: G7 V' l2 k* O
      free(temp);& o% ]! K3 Y. H( |: f) ]
}
; f. i8 D2 L% K9 q* L}
尾插法
与头插法类似，尾插法就是把每一个数据都插入到链表的末尾。
void addInfo(struct Info** students)
6 g9 m. }( U( J{- |/ J* E8 k7 A/ a& I
struct Info* info, *temp;4 V1 Z) l- t. |- g2 w
info = (struct Info*)malloc(sizeof(struct Info));
& p! o! j: [2 D, n if (info == NULL)
: `4 ^. \: H* j* X$ p' I {6 [& o3 i0 Q( g- V" O
      printf("内存分配失败！\n");
* T3 ~! i' A4 H+ M: A       exit(1);
+ h' A9 @. m( z8 B% g; o, W; S! B }  F2 C8 s4 c; r
" J7 ?% g; ~+ b* {$ `
getInput(info);
  t) W( [% w1 f/ K! B # D  `2 D& N. ^" A/ v7 D$ X& t
if (*students != NULL)
# T( ]7 w2 ], i, f9 `* p {9 o  z- c: w. ~2 Z. s* q
      temp = *students;  c% q3 N  q% @* h0 c3 `7 H
      *students = info;9 ]. k4 K' c- V8 T3 o, z; r
      //定位到链表的末尾的位置# _. Z: a( R0 x  X, X! ~
      while (temp->next != NULL)
, L3 k7 u& d0 a' J, Z/ g3 l       {
7 ^- }8 e6 Y# V2 Q+ ?  Z          temp = temp->next;) x9 n8 ~) M8 P
      }- ]  b4 \6 M2 o5 p: W
      //插入数据
  t7 m. y3 z# J+ Y5 K       temp->next = info;* u! O/ ?1 b+ ]9 x$ a0 B
      info->next = temp;$ M. v2 a5 ^/ ?3 ^' p
}& w( q* C9 s6 T' G, p; |
else
  ~6 W6 b; [; O; w  l& Q4 w {  ^" y, X: w/ {2 ~9 y
      *students = info;8 J4 U/ I1 L% W  p# v) m7 q; r
      info->next = NULL;. |% C, W9 I) _, V3 j6 S
}
5 f& j7 [8 A  g3 }( j9 F+ F( K}
这么一来，程序执行的效率难免要降低很多，因为每次插入数据，都要先遍历一次链表。如果链表很长，那么对于插入数据来说就是一次灾难。不过，我们可以给程序添加一个指针，让它永远都指向链表的尾部，这样一来，就可以用很少的空间换取很高的程序执行效率。
代码更改如下：
void addInfo(struct Info** students)
* h; i" s% w- U8 Z6 j" E1 }% ]( x{- G& C% k7 y+ @% m0 J, z' u$ E  f
struct Info* info, *temp;
- `5 Z& y" L; X9 n9 o: T static struct Info* tail;//设置静态指针
$ b0 f, }/ ~2 p8 v# s: t4 ^% Q info = (struct Info*)malloc(sizeof(struct Info));' b6 h; i/ o7 [  ^6 _$ b; t2 a
if (info == NULL)
, G( n: ]" p* V- H0 L- B  u {
6 r5 R& y8 P# Q- c, a       printf("内存分配失败！\n");
! B, ], [; L- o& H* x' H       exit(1);2 z2 ]4 ?+ P; @. P
}( x; Q! z* J  K( k: ]# A
. j# v2 b$ ^: G4 t7 m, S& h
getInput(info);
7 m2 S! i4 P$ Z: T# c
! l% }3 b! L% J if (*students != NULL)# `' x! E3 q/ I) \% T) p
{0 @7 P4 T. ?" w' E
      tail->next = info;
2 m" O; ^( P# f7 Q) R5 W9 {. [( G       info->next = NULL;
) n% m( n: N! ? }
4 O' V. n; w, h8 a9 u# ~5 m, h7 u else
# E) I* F  A. y. H: u {
6 U: T7 f0 E7 j* b       *students = info;' ^- ]( F' S+ Q3 m6 ^7 h/ \
      info->next = NULL;
2 u$ N# I  F; u+ D7 n }
0 V  k) `, T2 `1 q% y# }" S' r}
搜索单链表
单链表是我们用来存储数据的一个容器，那么有时候需要快速查找信息就需要开发相关搜索的功能。比如说输入学号，查找同学的所有信息。
struct Info *searchInfo(struct Info* students, long* target), u. _. ?4 e- H6 [+ m  f
{$ \2 b4 k7 x7 P) B# q5 F
struct Info* info;
0 }  g- E  y( c5 {* k info = students;
% X! l2 @7 r, L) E. @4 Y' }+ x while (info != NULL)3 C7 Z* j( ~" F5 _
{
- @2 _3 O4 G4 X3 e6 w$ }- l3 _       if (info->identifier == target)- i# Q0 k' Q4 N0 c: R$ n$ e4 u
      {
! ~6 C* B8 M3 U% Y          break;
8 s2 s4 ^- M2 j! ?% W+ ~+ u       }# N& y0 X* A+ \: y5 M
      info = info->next;
' t0 s2 B( y2 |3 ^1 L4 u }' f% t! }5 ~- ~& k0 u! {3 M1 {

0 S% j& }( S% O8 L return book;
8 m9 E5 V4 q3 i" N& `- x* _};
! u0 m8 k: X4 k+ c5 s( i+ k2 t3 w! s/ B- w( x8 D, j
void printInfo(struct Info* info)
5 U: F% A9 A. M' F{
+ J: i) x% ~0 C+ h5 o) E) z$ F ...
- h$ B6 h7 Z; \7 W}/ ^# k5 d; ]5 d( |& Z0 x3 s% R/ [
...
% a+ I$ }" h# Z$ c6 D5 ~" z/ }9 F* N* a
int main(void)
( ~& z6 S- H! U5 t7 I{
1 i$ m% A! F& U" X9 b( t ...! ~1 I6 B4 v6 W2 f
printf("\n请输入学生学号：");
4 U4 @; Z: ]: V1 _2 R/ R7 J  D scanf("%d", input);
. d+ ]: z( ^6 u' J4 H' l' H1 j info = searchInfo(students, input);0 i- C8 x3 j; z1 \% L+ S9 p" b
if (info == NULL): w/ V- \/ S7 X' ?4 o
{% d, S, i6 y0 {2 i8 S
      printf("抱歉，未找到相关结果！\n");7 \  \9 N% {9 ?7 G- t
}6 g  k+ O! C2 A
else
/ [. |. M  s6 V5 Y4 Q5 s& t {2 d: R1 e3 V  A0 C* p, w6 K( K' t: u
      do
, ?2 ^5 g0 L1 q+ |       {
, e7 b$ A' g* `" Y  t          printf("相关结果如下：\n");
; g. W/ k' \8 ?4 q' c4 S          printInfo(book);
( n* A! x' U  t9 O6 J6 \) P6 K       } while ((info = searchInfo(info->next, input)) != NULL);  F: t4 y3 F1 w/ I
}9 J. R# N$ d" i- T" N7 H( B# s

! n  x& N9 _0 a# ]' M9 h! L' k& k releaseInfo(...);
8 O. l2 S5 d" r1 X, U7 C2 v9 v& m return 0;
8 C/ L1 S* I: Q) Z8 b. ^* a( `. e}
插入结点到指定位置
到了这里，才体现出链表真正的优势。
设想一下，如果有一个有序数组，现在要求你去插入一个数字，插入完成之后，数组依然保持有序。你会怎么做？
没错，你应该会挨个去比较，然后找到合适的位置（当然这里也可以使用二分法，比较节省算力），把这个位置后面的所有数都往后移动一个位置，然后将我们要插入的数字放入刚刚我们腾出来的空间里面。
你会发现，这样的处理方法，经常需要移动大量的数据，对于程序的执行效率来说，是一个不利因素。那么链表，就无所谓。反正在内存中，链表的存储毫无逻辑，我们只需要改变指针的值就可以实现链表的中间插入。
//Example 03
) t+ d% a6 q7 ^/ v#include <stdio.h>
, [: \1 o# G' k/ H: V) P+ j; Q#include <stdlib.h>
' i' K) \( m) `0 u4 K1 N$ l0 a# q+ @  ~+ N; o) c  N: U
struct Node
* e! V# }. G1 L7 L/ I, K  Y/ B{5 w# `  F0 `0 p) p: i
int value;3 R& I/ V0 x6 y. V0 j# S3 w
struct Node* next;& b; s0 i5 G8 O- c( F1 J6 C
};
  Q5 k- m* L" C8 b! T# J3 j; l9 D; i  i! V
void insNode(struct Node** head, int value)
# p' I: w" z) G! M7 b: m6 |/ L/ A* D{
; e! U9 C: b  d: G struct Node* pre;
: p- N, f  B9 R& r; t+ S/ v struct Node* cur;4 T3 r" R! Q( l
struct Node* New;
0 I% }7 I3 Q3 p) O' W. V1 n. D8 i! C3 `1 A7 Q2 S
cur = *head;3 j7 l7 ^5 {. f- `% }5 q. `
pre = NULL;( ^. a( }9 \+ Y& F, t" n# q# Z

, L3 p  i; x+ M: G- ~" I6 s9 E while (cur != NULL && cur->value < value), N* {% L& F3 u* M6 F; p) D
{7 P( ]# _: w! p
      pre = cur;2 l8 l7 F6 b# n/ v
      cur = cur->next;
& q, j5 O, g& x0 s. ? }
! j; j; g- s6 _* O, q: K0 j, a, R  L" B! z2 V( U7 E
New = (struct Node*)malloc(sizeof(struct Node));
2 _7 K+ i7 B2 m8 F! E  z if (New == NULL): R) o' {; @6 d4 u$ c3 i/ ]+ F$ w
{' j9 p$ r9 ?7 m3 u/ k2 l* K- g
      printf("内存分配失败！\n");
' d% [: n. ]+ @0 v5 ~6 b6 D       exit(1);
6 Z8 A) I2 |) t3 W0 Z& A9 G }
4 R+ J9 t  d* ~8 m$ j# M4 x New->value = value;4 u/ B5 B+ z6 A2 q# \$ n
New->next = cur;: ~! L4 K# W0 [/ f

/ |7 E9 U8 Q3 X( ~' o if (pre == NULL)
+ \8 |# Z* v" M1 M, ^, s {2 {" _  m9 @3 f. X+ s2 `& C
      *head = New;
. U6 l2 x1 }# T2 S" I/ W2 { }
- f2 [% i7 f/ y8 i else
- X* b3 y4 y  S5 `6 `' w {
/ n/ J+ U/ T$ `, ]       pre->next = New;
# @5 i& |1 B, h: ]! ^ }/ q) ]: g  g* L1 _
}
  i9 t# g3 y# g6 h: k" o) A  O/ ^2 A- `5 p  K! o* Q2 V1 ?
void printNode(struct Node* head)( p  X, Q# G+ @( R
{$ r" c5 K% n, Y/ }7 N5 P
struct Node* cur;4 S, c( q2 W8 b1 @

4 h' ~% D1 o7 @: f4 p cur = head;$ l: N9 q# M, O- D7 G
while (cur != NULL): `; N% Z3 X1 l/ D
{. {8 o: r, e* c
      printf("%d ", cur->value);
" ?3 m3 c* A7 |/ q8 j; b" U9 {       cur = cur->next;  ^: d6 a# g! Y6 V3 O% `  @
}% F/ `- R4 ]! r$ _: v0 j4 C0 k9 O6 M& |
putchar('\n');
* B* X; Z6 S8 j) [8 c5 N5 i0 X}
, ^7 n& ^2 f- W' N/ J
$ D; g4 H. h0 ?4 v  Fint main(void)
  i8 |4 S9 C% H" j% {{6 W+ }0 U( u5 _1 [
struct Node* head = NULL;; ?$ L; i: H- w. {- X# G
int input;
, y9 ^7 v7 b1 }' }! }9 c
% B& H4 h# R/ Z, `! X7 X printf("开始插入整数...\n");
; B( \0 Y% L1 u# `; v- F1 | while (1)
8 d8 E9 s$ s* G* s3 ~& K' D {
! d4 i6 D% O& i       printf("请输入一个整数，输入-1表示结束：");
7 r; _9 G& s2 [       scanf("%d", &input);+ N3 d+ Q/ k9 w: x' V
      if (input == -1)
: d* s- f, r( n- A5 ]       {: H. g+ f& P; T; B  }) |: I% k9 P
         break;, Z$ W5 z5 ?) N2 N/ V# Y
      }
( @9 A. J$ D5 C: r7 s6 F! v       insNode(&head, input);* o0 a8 Z$ w* }9 i/ ]* U
      printNode(head);
' x5 _; N1 s: a+ K3 Q }
) _& y4 r2 R' Y2 Y; E: e+ V* ^! P7 Z: F/ Y" B! R0 ^0 g7 E
return 0;% b% n6 J, z" i
}
运行结果如下：
//Consequence 03
! u$ m: n# ]. ~% t+ w开始插入整数...
! ~  U. ^7 N3 d. X* g请输入一个整数，输入-1表示结束：4  f$ H1 f0 D9 `/ l
4  _: Y1 P- S: m9 P+ e9 [
请输入一个整数，输入-1表示结束：5
2 [8 t1 e0 C4 A) C4 5
1 M( b# O5 ^1 S5 g! `* m: G! M请输入一个整数，输入-1表示结束：3( Y. v4 w" W2 i  T6 N* u
3 4 58 @; D& S" x" I" L1 d$ E% G8 n
请输入一个整数，输入-1表示结束：6: x6 y: ^, }8 i5 J
3 4 5 6
* H# I) M" D8 w% u$ A* b) D4 g请输入一个整数，输入-1表示结束：26 O0 J2 W2 E8 T4 ?
2 3 4 5 6# i: z, x: O6 N; w& n6 I
请输入一个整数，输入-1表示结束：5) H# Z! ~5 c& N8 i% S/ q. i# _. o8 t
2 3 4 5 5 62 ?7 {" O/ |) A0 g, F2 f: ^
请输入一个整数，输入-1表示结束：1/ J! {1 v3 A6 [7 i( z2 N
1 2 3 4 5 5 6  \8 D) `6 w3 w, k  Q$ p
请输入一个整数，输入-1表示结束：7
' J0 b7 Q  `2 P1 2 3 4 5 5 6 7, @: f  a' P$ B! T
请输入一个整数，输入-1表示结束：-1
删除结点
删除结点的思路也差不多，首先修改待删除的结点的上一个结点的指针，将其指向待删除结点的下一个结点。然后释放待删除结点的空间。
...
9 }. z$ `( G) L! v& ^& G, L2 Wvoid delNode(struct Node** head, int value)
1 }, W/ h# b& z3 g) a* @9 }{
- @" @. L1 X( g- n) E struct Node* pre;
( C  C3 e$ f0 M- F2 T: u! @ struct Node* cur;. ^. j2 t* F( r  i% z1 |

& `! X1 A& U" X% R3 x. f, N- V cur = *head;' Z$ G1 L% Z% }. |& P
pre = NULL;# i! c8 k5 }  A. L9 o- q: I* `
while (cur != NULL && cur->value != value)0 L9 |+ Z: {! X9 l# L
{
% n8 R/ w5 Z( j4 i2 C. Z& ~7 \       pre = cur;
5 |/ \6 t* Q9 o) |       cur = cur->next;
3 B! ~7 Y+ B, u }8 r2 j6 b4 X1 ^
if (cur == NULL)
* r' l0 i0 i7 s' G$ u$ Y {
- g" A, E# [' w       printf("未找到匹配项!\n");
- f% U1 e4 B. s5 ?% }* P" U$ E6 P$ [       return ;
  T) Y9 ^# G' }7 P }9 @5 b3 U+ q3 V; J5 V( R
else
+ d! ?' Y$ d3 h {
, g; d; z& W0 f- T5 h       if (pre == NULL)% K! q( \0 _  D" U" W2 q
      {
: m  F: M2 N6 y/ y          *head = cur->next;, e9 w! O7 k+ Y- |8 y  n4 h  a
      }
' J: J8 y  C. M( ]- [1 ]% k- C$ @       else
* G0 H9 C2 x: y( e- g3 o+ v       {
, f" x, {: U$ I4 y          pre->next = cur->next;7 c" ~4 V0 i: V1 C
      }
  Q/ S- G  Q: E. H" H, o       free(cur);/ e8 p: I  T6 H8 t( w- D
}
$ z1 N0 N4 k* i; x  s3 @}
内存池
& @# Z. N- s: `: n  |3 N

C语言的内存管理，从来都是一个让人头秃的问题。要想更自由地管理内存，就必须去堆中申请，然后还需要考虑何时释放，万一释放不当，或者没有及时释放，造成的后果都是难以估量的。
当然如果就这些，那倒也还不算什么。问题就在于，如果大量地使用malloc和free函数来申请内存，首先使要经历一个从应用层切入系统内核层，调用完成之后，再返回应用层的一系列步骤，实际上使非常浪费时间的。更重要的是，还会产生大量的内存碎片。比如，先申请了一个1KB的空间，紧接着又申请了一个8KB的空间。而后，这个1KB使用完了，被释放，但是这个空间却只有等到下一次有刚好1KB的空间申请，才能够被重新调用。这么一来，极限情况下，整个堆有可能被弄得支离破碎，最终导致大量内存浪费。
那么这种情况下，我们解决这类问题的思路，就是创建一个内存池。
内存池，实际上就是我们让程序创建出来的一块额外的缓存区域，如果有需要释放内存，先不必使用free函数，如果内存池有空，那么直接放入内存池。同样的道理，下一次程序申请空间的时候，先检查下内存池里面有没有合适的内存，如果有，则直接拿出来调用，如果没有，那么再使用malloc。
其实内存池我们就可以使用单链表来进行维护，下面通过一个通讯录的程序来说明内存池的运用。
普通的版本：
//Example 04 V11 x' b7 ?* X7 B9 U
#include <stdio.h>
, G2 x* k8 n6 R* |( e3 U#include <stdlib.h>
, B: L* X  {% h- k  U$ [#include <string.h>
5 I/ L* Z% j, z% c/ i; J/ [! v' |
struct Person
/ h8 v, C# w! w3 z4 Q1 i{% j$ a4 r7 i1 @3 r5 o5 p
char name[40];) }% C% Y; u5 }+ T$ k4 j) e
char phone[20];) F7 N9 A% `% v7 q, t2 d- t
struct Person* next;' p8 Q8 S0 O0 a0 E; [
};% P' a* t- ~+ F0 s2 V

+ y3 R& P- q4 _4 q) p. f. v4 `" Kvoid getInput(struct Person* person);
! t2 t, V& C" Q$ xvoid printPerson(struct Person* person);
1 Q6 |$ F9 ~  w" b2 t3 Q, q! Xvoid addPerson(struct Person** contects);8 p; K$ v7 U# u% U0 `' {! T+ l$ O
void changePerson(struct Person* contacts);* i* |5 f+ |- G
void delPerson(struct Person** contacts);
9 t$ r4 u, p% g1 Estruct Person* findPerson(struct Person* contacts);* w$ Q% N8 w# N$ ^, k
void displayContacts(struct Person* contacts);
5 V/ ^* C/ Q( O7 p( ]2 cvoid releaseContacts(struct Person** contacts);* N2 z+ s" B; j
) y* [3 g0 d6 n# l7 P7 k0 a
void getInput(struct Person* person)
$ l; M; d) x. t9 g$ y8 I7 k! r{
& x6 R9 @4 G! d2 f7 B printf("请输入姓名：");
0 t( ?7 C2 h/ @7 o scanf("%s", person->name);% n' E% X  m! W- e" F* }' j* R. p
printf("请输入电话：");  D: V2 I+ s) r1 H
scanf("%s", person->phone);
) @  I5 z# _# d% C  \}
8 |. c, l' M( Y- i0 d4 q/ T- c4 \+ F8 @5 {& F% N7 k, n
void addPerson(struct Person** contacts)
9 y$ ~9 Y+ i( V4 y5 M{5 [) [* ?! G5 U
struct Person* person;
3 p! x: |: Q. g) L3 h4 ?7 \ struct Person* temp;4 u$ R; ?' Y; ^

0 h% o0 R. o' M) u9 {2 t person = (struct Person*)malloc(sizeof(struct Person));
- X0 R' s& G$ a( d# m8 p( E if (person == NULL)+ J9 H0 r6 {$ u; ?# G: T
{5 H7 e2 @9 p9 p: M8 ?# f4 ?
  printf("内存分配失败！\n");
2 x+ X& R1 e/ m+ N  exit(1);
4 ~( k) s+ Y( d0 V1 r: t# ` }; H) B' H8 O* K1 n+ n+ |4 h/ W
* p7 k8 d5 H4 k. S5 I% y
getInput(person);
7 k) ^' G% D5 }3 e# k6 m6 A4 ^4 l0 a2 }6 Y
//将person添加到通讯录中! j& v1 [+ o6 K3 d5 u" Z$ f3 @
if (*contacts != NULL)
1 o- c! T* `: ~2 W, b. t {
" `6 D; Q& }- M/ F  temp = *contacts;
, Z1 ^/ h: u$ u7 K: x  f  *contacts = person;9 ]9 h( D* z( i8 A  f# y: i
  person->next = temp;& |! U+ N/ h7 ?( I, b8 Z5 V
}
/ p0 C% ~  A) Z" D else% a" O: R0 A# S( e
{
0 y6 B" W1 _9 K  *contacts = person;
# O& A, C1 v( V1 D- T2 q  person->next = NULL;
; N4 F0 [5 S5 @+ T) h$ b. T }
6 ?% ]5 a$ Z0 K/ x, \* l5 K" N}
  E* H. a  x: k1 U3 {% ^0 C. h9 u* O( D* A0 R* R
void printPerson(struct Person* person)
+ y# t* `, i! D! n, o1 `{4 {" Q! T, V% g: d
printf("联系人：%s\n", person->name);
# D' Q# s# w4 [) I- R7 ?* ?1 D6 I printf("电话：%s\n", person->phone);
3 k; \; |9 h: T. n1 C2 z( R- F6 K}0 n9 [" A8 l! b2 ^

$ a3 p# m" @. Hstruct Person* findPerson(struct Person* contacts)- F' i0 c; `2 i* g6 l7 ~
{8 C- M. s9 J* T1 j# C/ Z! e
struct Person* current;( `6 j2 v$ K- l0 U
char input[40];" h) j4 e0 p' A5 [" j5 y
  u0 O' S6 b* U4 s* {; j1 D+ I
printf("请输入联系人：");
& \/ g( U) m6 G' x" S1 F4 F$ i scanf("%s", input);
7 J; ]0 \; U/ p5 ?# G
9 b& ?6 }3 L5 N# k% u current = contacts;
' g, V: G9 u1 v: y- o3 g while (current != NULL && strcmp(current->name, input))
& X5 X0 t  R- A' T, e) b' b {
; Y9 |- [% x9 x5 g, q( ~  current = current->next;; c# H  S4 d( L" {4 j0 E# T  e
}
8 s2 y" U* k# p$ K% {% U
4 q6 N3 _8 b: t& Q% N) R9 M return current;- f: [; d# I, h/ Y
}3 l& e( h+ ^, ?7 F  A; l7 b; P
6 ^! F7 \  w& }/ ]4 O6 z! N
void changePerson(struct Person* contacts)
5 q6 j" P% J  k! M; O2 O6 p  J{
  ]# ^) k. H8 V struct Person* person;
% B, j7 ~6 K, c% k: {& A( z9 A6 }$ @/ _
person = findPerson(contacts);
) B, W3 F6 \% t6 I/ I if (person == NULL)3 f; e7 _* j6 y, F) `! g
{$ S) y4 G7 Z/ F* o0 ^. H* r
  printf("找不到联系人！\n");- @; S* x6 ]" }
}
5 o$ q: o2 i* r0 q/ D" i else8 J0 f) i& O0 D# [; O) ?
{" T8 j8 t! K3 C- a& W! R
  printf("请输入联系电话：");
# s8 [6 E1 o" |6 d% _. `/ N: L  scanf("%s", person->phone);& ?9 b# d$ i: o
}
3 H- ^) ?! j. _7 n7 V% q}
# A# C5 l4 \% j6 O& X1 ^6 G7 M: m/ p
void delPerson(struct Person** contacts)
% b/ h3 i5 k9 ]( Q' i1 i% ?) ]3 K{
+ U3 Y; _' E7 \ struct Person* person;
' }8 L* ~. n: v* g6 r# q struct Person* current;
9 _3 D! y2 W& B3 o9 W: c struct Person* previous;& S" T2 D& E+ q' A& B) {9 y' Y
5 n9 T8 g& [# q" ^5 D" e( v
//先找到待删除的节点的指针9 Z( `; T. m& I2 r2 O0 f
person = findPerson(*contacts);8 R9 e- Y& C8 L  x
if (person == NULL), w% Y/ a0 A6 Y6 d" N8 [' ~3 S
{
2 |% G# t) _: F8 v/ n  printf("找不到该联系人！\n");
6 C- p' [# P% m! k4 y* D: { }
" p1 a6 V, f, E- h9 A6 ~6 s else# Z7 z7 {6 m- b+ q
{
  l3 b4 Y  C: @8 z" n6 c' w, k  current = *contacts;
* u% b* l7 s7 |* ^" }/ K* J- _, s  previous = NULL;! u# ^0 S9 d5 Z( I$ g" [1 E; ?

' w* @& Z: R! j9 z9 o' z( o8 M  //将current定位到待删除的节点
( z* Y$ l$ ^2 K0 Y6 K! t  while (current != NULL && current != person)
$ J3 n3 V' m, }7 E3 P3 P7 t9 W  {
# ~& [7 J1 Q7 {) M previous = current;- M( b' l- x; [- P/ Z, B+ C1 J
current = current->next;( u2 ]5 t" c2 G
  }* }; R6 F" `( r5 d0 S* }

6 h) m- v, G% B$ H  if (previous == NULL)
) Q# [, P6 t3 m" K5 D( |+ J  {
* V0 S% F3 S4 e  H: _( J //若待删除的是第一个节点( [3 ~6 ]/ Q, Z
*contacts = current->next;
8 m/ [: [6 h0 R3 K  }' E: ^( k: V  L' B
  else
" `4 y! ?0 [5 q. w6 C5 i  {
. d3 D6 G$ U8 H //若待删除的不是第一个节点+ E" E/ }& K" @/ d. C
previous->next = current->next;
" L1 I: v  q8 U% {# F3 R  }
; T- _$ O& g8 X" x& C
7 Q8 O+ d/ d8 j# \  free(person);//将内存空间释放$ |5 q1 F2 p: k& f1 k' H
}& N0 _9 u  t% l+ `3 y- ]
}
4 G  V# x. c7 @! G
8 b1 M; r+ t" h" O; a0 Lvoid displayContacts(struct Person* contacts); i- R; k$ F1 w+ I, E- w+ U
{3 M. y! S+ L6 C+ h3 w
struct Person* current;/ k# \7 L6 h' y* X+ P
  E7 w4 u4 E1 B3 b9 B
current = contacts;6 `3 ~; E# {( n9 p/ L
while (current != NULL)& i9 z& o+ ^, Q6 Q. n; \
{) K2 o# ^) `; \3 }) M% t( I: L
  printPerson(current);* V0 k! d) `) D
  current = current->next;
, @- L( o2 x- @0 y }
1 L, _' J3 \* _}
% x7 y1 a( C5 O  [' X# ^
2 {) U8 s; _7 b7 e) a1 ]1 [# _void releaseContacts(struct Person** contacts)' B5 }# `/ t' g7 q
{
5 ?6 v+ X! s/ |% a! P0 o& { struct Person* temp;
5 U* U4 h( C# c- R. I4 u( _" j4 \' m9 M! Z5 Y3 D0 ]+ i. O7 o
while (*contacts != NULL)
' k% y1 k" p# j- P. Z8 e0 u. s3 B {  u, s" V& G2 q
  temp = *contacts;# v0 u9 n' N" _# m% K  J
  *contacts = (*contacts)->next;" a1 L5 i; ], c; _* U+ `
  free(temp);3 E6 W; A/ }, R5 G
}+ m6 a2 p4 T; `2 L
}
# Q2 n3 [+ g- d. F# T* h( u# H
4 ?; ^5 c8 y; [" `, nint main(void)+ ?  ~% R1 o  r  {' x1 m. z
{9 O. o' R. V0 e
int code;, k( D, C' y* v- t
struct Person* contacts = NULL;* \" y9 H* t* X
struct Person* person;
; {4 \1 _) H, S% s* Q, \: D1 f2 ~/ X5 a! o0 H- h" ?
printf("| 欢迎使用通讯录管理程序 |\n");$ s: m# N: p* {; O" n
printf("|--- 1:插入新的联系人 ---|\n");- o' L9 ?! c* }+ {& \4 q+ D2 A# H
printf("|--- 2:查找现有联系人 ---|\n");
9 l5 `  r1 N* D$ o9 t) T printf("|--- 3:更改现有联系人 ---|\n");
# a0 R/ b' i. Y printf("|--- 4:删除现有联系人 ---|\n");
; Y) g; [# N  o" N& y/ W printf("|--- 5:显示当前通讯录 ---|\n");
4 A2 x9 Y9 n1 ~$ _- P printf("|--- 6:退出通讯录程序 ---|\n");/ _; |/ |) A, B- b

0 r, `2 f* S$ x) M& D& | while (1)0 o+ |8 n, K4 t9 S1 ?$ g6 p
{
# ~, j/ r3 B4 C7 U. h6 ^  printf("\n请输入指令代码：");
2 I' _# H2 M- P  scanf("%d", &code);; W0 r; c4 }6 }
  switch (code)% Y9 [# F, p2 Y& n5 b$ F
  {
( X/ J: P  P6 D5 T3 J3 Z  case 1:addPerson(&contacts); break;5 I2 P4 l. Y: Y  e1 m- m* P4 y6 n% k. h
  case 2:person = findPerson(contacts);1 x2 o+ S/ q( R) S
if (person == NULL)
; F/ v8 u" O, s. n {
, V6 c9 B( }& K% W% U$ U7 [ printf("找不到该联系人！\n");, c4 w& B& P  F$ h& Z# G1 N
}
0 V4 j5 ?" U1 d) \$ f) k* \ else
; y9 M$ t( D1 v  @# { {* h6 Q6 M% I* D. Y! u8 f* _8 Q& c
printPerson(person);
+ d4 w/ Z) m4 K5 W: p& t: K' Z& }( s, J }/ A; i6 r& Q8 {" a5 O) }/ Q
break;9 x! F8 M' a3 g* E7 H' q* `' D
  case 3:changePerson(contacts); break;" a( {& I0 Y7 N/ ]0 d
  case 4:delPerson(&contacts); break;
! c, {3 h9 D1 T; N. {5 [8 T/ c  case 5:displayContacts(contacts); break;( Z. _' C3 O6 h, Q
  case 6:goto END;
# t# y7 }7 v5 q  C! f; M8 r  }
2 E5 N1 U% q  g+ a$ Q, q }! ?" r1 ]/ D" [4 p
0 d2 m. g9 g, s5 b
END://此处直接跳出恒循环$ U8 i4 R  m, r- y3 m* t1 c( i
releaseContacts(&contacts);
6 B- H+ }* s! j4 `! a5 t' F3 [, Q" B* K1 S/ J
return 0;; ^" z# f+ m* q

- w  H* S# G5 N- k}
运行结果如下：
//Consequence 04 V1. P0 R% y& l7 k1 `+ \2 o9 G. k
| 欢迎使用通讯录管理程序 |
( i/ A. `3 n, A* c% V4 S|--- 1:插入新的联系人 ---|
- u) L, S0 z% @$ u! D( ?5 {5 U|--- 2:查找现有联系人 ---|9 ?: \: w. o; t( i! h
|--- 3:更改现有联系人 ---|
$ g  ]2 a* A8 N: d8 |# J: s6 F; v|--- 4:删除现有联系人 ---|
/ Z, A% G: C- V3 p# F  t|--- 5:显示当前通讯录 ---|
- V' ?3 k. H* U8 M. N5 ~|--- 6:退出通讯录程序 ---|- H* b# c. Q) u
+ q: t9 c: I! `
请输入指令代码：1
* }$ K2 t; B2 K8 k请输入姓名：HarrisWilde
0 X$ L( y( Q0 {2 n0 p7 S# S请输入电话：0101111
% R; v# ^% }, A  b4 p5 C; v- e7 n; f& k6 \3 |4 d
请输入指令代码：1
& U1 P6 m  O' @+ N请输入姓名：Jack/ B! A0 {  f% N- S7 R
请输入电话：0101112
0 X0 b# s( k& W& A9 L' f5 B
7 X* }! R( e! @0 C: r5 Z5 H) M请输入指令代码：1
) `8 N+ t7 {6 w& H8 p# G5 u请输入姓名：Rose+ e, Q6 I0 h3 ^" d. Q1 T$ F
请输入电话：0101113$ ?2 ?/ U2 f* E" U' \

7 ]. b, B( g4 d' w: h6 _$ ~& f请输入指令代码：2
" X3 @: U0 v" \% p' d, w请输入联系人：HarrisWilde4 s$ W  V) t8 H: ^' N
联系人：HarrisWilde3 \2 ^  g1 c) F
电话：01011118 r  j9 G0 B8 _

1 u/ J" e& A- V# G4 x请输入指令代码：21 E) Y/ v) T) v2 f" N6 y* W, \9 S- |
请输入联系人：Mike' z& U2 D% T  c% Z- \
找不到该联系人！
  K$ P6 i: @  R! ^4 x! P& ?. }+ F, G' L7 x! W6 E  x+ Y  y, S
请输入指令代码：57 M: j$ `2 q" N9 ]& z. M% b
联系人：Rose
' j" l- X4 g4 a1 @. y. N+ y6 G电话：0101113. R# F. N8 s' Q' J/ m2 \4 b
联系人：Jack
/ W3 |7 v6 O0 S% i0 P: A电话：0101112
; w: t9 T$ o) u+ F& c/ k, A+ _( @联系人：HarrisWilde5 X" ]& O9 Q2 h1 W
电话：0101111
5 [4 E9 \6 C5 e: G) ~
$ Q: a$ P# u5 X' I2 G! t8 s; @请输入指令代码：3
2 x+ y* H- h. `, T9 Y6 e* }4 A请输入联系人：HarrisWilde. _7 c2 W% a/ F0 k/ s
请输入联系电话：0101234
, h9 Y+ t+ P% X4 Y, g0 X
& Z9 v7 l6 q$ O$ K1 h* G& c. o$ l请输入指令代码：59 ?: i7 I* @* N/ O, c" z
联系人：Rose
- v! B3 N" v2 X* q' g3 s电话：0101113; H! H3 P$ @% v6 o+ k$ t+ J' m
联系人：Jack
  E6 P. @0 k& l/ s) q/ B" x& `0 ^3 |电话：0101112% m1 |& [. d% Z! g; ?
联系人：HarrisWilde
0 K4 v* H$ K. p) N+ y1 U* x% v电话：0101234
4 Z+ @! H6 |; x4 h6 u$ Z) x3 ]
  Z- A- t. J( Y- y- ^请输入指令代码：6
下面加入内存池：
//Example 04 V2
% h( ~: h3 {3 Z( _2 o- m% f/ F#include <stdio.h>6 V; r$ O6 p: t! f- F3 X2 r2 V# m4 N" d
#include <stdlib.h>
6 S" l9 d! `6 n2 [+ W6 d#include <string.h>" W) m* \! y/ A2 l: D

1 G+ k+ u5 H2 K; g/ E, `+ p6 p#define MAX 1024" d! R% n9 T/ o$ ]' |$ r
: F' A0 _/ g: i/ {) {
struct Person/ `0 u$ i) m+ _; ~! O* L6 `& w
{) G5 B8 s, m# j0 Y8 K0 V0 _
char name[40];% K( @9 R" i) L% X" y  E" s, e
char phone[20];
* Z! I$ Q$ D6 m" d7 J9 B$ T8 E- P struct Person* next;
8 }9 Z8 V  b9 o* m' `};# l2 C. v* T& X: u

; J) f. I3 X7 b" Nstruct Person* pool = NULL;  }- N4 y% X8 z! h9 F: @2 d/ c
int count;
- l& m; }( b* Q% o# V- Q) n& H; k( Q% B4 c; D3 P: Z  D
void getInput(struct Person* person);
2 O1 u! {8 y; ~( bvoid printPerson(struct Person* person);" k4 ?2 q* ~- t3 u0 b6 ]" C
void addPerson(struct Person** contects);# r( P; e1 U9 J, ~2 [( X% ?
void changePerson(struct Person* contacts);
# J2 h) V8 x' X- b- ]+ W7 [void delPerson(struct Person** contacts);
, _% h- L+ r: G: H- xstruct Person* findPerson(struct Person* contacts);
" E) p0 T6 _: E5 bvoid displayContacts(struct Person* contacts);- d3 f8 g5 ?( X9 B
void releaseContacts(struct Person** contacts);
6 O! H2 M, L4 {2 [+ E" bvoid releasePool(void);
7 [1 j" j0 {1 g) q) M
% o: Y7 v2 M* X2 Pvoid getInput(struct Person* person)
$ X, x- v# U" u: A9 `{! D8 U! W; j% q
printf("请输入姓名：");1 f6 b* Q2 ~) B# v* P& i
scanf("%s", person->name);& |+ Z5 K* \- `7 B
printf("请输入电话：");2 U1 m+ K) @$ d% `
scanf("%s", person->phone);( i# ^* q* d; P% M
}8 B1 g3 L. a) c' [1 c

7 l" Q5 u$ s& z1 w% q2 lvoid addPerson(struct Person** contacts)
: E+ T( e$ x1 [# |{, G  S9 K7 G: R
struct Person* person;
# g3 S2 k: b: r) \4 U1 X" U, I- |. N struct Person* temp;
' |% v+ M" X. r2 k3 [1 f. J
# S8 ~% ^! X. Q! ?; R$ A. C" E //如果内存池不是空的，那么首先从里面获取空间
! m, h& u0 y  w  ~ if (pool != NULL)4 L# V' b5 {$ @' ~$ O: D. C1 w
{
: @# s7 C5 w4 [" w- O  b  person = pool;
/ Y/ E+ z( f6 _: j  pool = pool->next;6 J1 d4 _/ r1 O6 l2 {6 o
  count--;, U( v' j3 v! |8 t
}
" X0 y- a' X* s5 o: v$ }5 N //内存池为空，则直接申请
* D% u3 ?: k5 k else& s& a+ R8 P6 ~2 g( M! E9 Y! Q2 }
{
  o. p5 g. \% L8 q# a  person = (struct Person*)malloc(sizeof(struct Person));
% I; @% q, P$ Z8 X  if (person == NULL)
' [: ?# P' J; [7 N$ q# E  {
2 \8 ^' r- U3 |" A, P9 |+ r printf("内存分配失败！\n");
# {8 g* ^. [) d5 h exit(1);
" z5 N6 v+ _& b0 ]9 r; m' t  }
' e3 z# T$ X6 W4 h" J! u, |! v }2 M  I, k# \' K/ e$ G
  F! O+ b* e) C  Y8 z/ v, d4 B
* d' M6 U+ e0 K- o
getInput(person);
8 V( [; B& }6 O) q) v% X1 }6 w' `8 _5 D* c1 u- V
//将person添加到通讯录中
5 S1 {8 L$ N, U, K- w# W: M if (*contacts != NULL)8 F) Z& I. \5 D5 o9 |% d$ ~  D2 K" c
{
  A9 t9 Q5 n3 G: o9 P- C0 F* N  temp = *contacts;2 D% w9 b7 j* ~( e. T
  *contacts = person;9 ^0 }9 d! O# Z1 c& g
  person->next = temp;
9 ~8 f! u. Z4 _1 j8 t0 p }( O( X/ ~8 H  z& ^2 Y) g
else8 e7 [! k4 r8 M2 G) o: V$ A1 n
{3 W8 _! i0 v2 G$ s. ?
  *contacts = person;
6 o2 W% z, A2 L0 P8 _2 ^  person->next = NULL;* y8 y4 \/ m7 n' `% S$ ?
}
% n4 D& p" U. x' b/ s7 @' e  `}
4 ?, K  f% s# q, Y- `) g4 S# a: s+ l: q8 J; X1 m& m
void printPerson(struct Person* person)# F2 S" J, o7 I' y* h* I
{
. ]; I# L1 f5 V printf("联系人：%s\n", person->name);
8 L& p3 h* @3 ^7 X! d) c printf("电话：%s\n", person->phone);1 ?/ v, h3 u: t* \
}3 Q, D% ^- v2 ?8 m

1 x6 Q- E' q2 i' H, `8 T; m) ustruct Person* findPerson(struct Person* contacts)
$ w8 C7 u! ~& X# f{
& p& Y, a' I! x( T6 ~8 b4 M' E struct Person* current;# J7 _. x( I5 h. g2 f
char input[40];
  c% w6 m, B) T) j" y% ?9 f1 o& p1 p& a6 n3 O$ k
printf("请输入联系人：");) r' u/ B- q0 x' P4 k5 f" u
scanf("%s", input);
5 D& P9 E, O) C5 R
: ]+ F+ I+ I# | current = contacts;3 A4 [$ ^9 B3 t* w+ P6 Z
while (current != NULL && strcmp(current->name, input))1 t) }3 Y- _: X- _7 u. l, P
{
7 F9 B+ W% _  [2 m( J1 b  current = current->next;& F! s, [0 b9 s) h
}
# v/ r0 t" q* V6 \( x' }
5 F- W- S! ]8 y2 Z2 v& g return current;% r5 {, Z7 \+ m0 K  t
}" w3 |# J3 J. G/ T6 Z) X

8 M* h3 N. P0 j9 k# Z$ F/ e0 wvoid changePerson(struct Person* contacts)
& Q8 g6 k3 j+ L% W{& I3 q  M$ e( B6 [/ {
struct Person* person;7 p! |6 o. I; C7 M. `( ?; `5 m

( t$ R, h' g5 C6 s; U person = findPerson(contacts);
5 Q9 y" u0 W/ j8 H+ b2 K& z/ V if (person == NULL)
) \2 c+ ^; d, p/ l: C! A {
2 F+ V1 O6 C7 f7 y2 _  printf("找不到联系人！\n");
4 N  K& C* l+ X }' L5 n1 _" C/ n# H# B, ?1 [: p
else! U# W. N" Z2 x+ F  t8 ]
{
" G5 c& M6 K* u  printf("请输入联系电话：");% H/ Z9 A* a3 ]. d% Y7 d
  scanf("%s", person->phone);
  H  @+ V) A0 l! u* `" ~ }
' z' a3 x) E$ W& A}* V+ ]4 k  \( V8 k; ^$ R* D

% f5 ]0 M* b/ A0 ]void delPerson(struct Person** contacts)6 v, E4 m. E5 W( `6 [  r; v
{
2 N( Q4 _3 g" Z# m0 N struct Person* person;
6 @8 o5 @! E+ T5 D9 U/ b struct Person* current;7 ^1 R$ K; j% A1 K6 r) U
struct Person* previous;
* E7 q: ^* m% u( F5 r& |" G4 l struct Person* temp;
# d4 J' ?3 R' Y; E) I7 G! r$ l {& U9 \# y: F4 [1 A

+ W9 G, J$ S$ l' S8 a };
, J1 y5 L7 _1 O5 X! w% V% b: z3 z5 n
//先找到待删除的节点的指针7 [) O- `! q+ ~2 C; d! d) J- j
person = findPerson(*contacts);
/ q+ }0 `) Q5 i9 _ if (person == NULL)
! I8 L+ l/ m# g3 o7 X {
7 Q5 E8 p, S- a  j# f, D  printf("找不到该联系人！\n");
4 p: p9 ]% p6 W, n6 [9 _ }, j8 Y2 y; A" @7 W
else% V: m- S7 P0 |, T( g) n/ ~
{! ?7 d, t' U, ^9 P$ u
  current = *contacts;
" ^# g+ }/ O9 O# W* p7 d5 [! L2 L  previous = NULL;
4 W7 C- I. O4 g7 H2 M3 _1 L
; R# J: E: x/ V1 B+ i; n  //将current定位到待删除的节点. r8 B% t4 C. j+ |9 H7 \; L
  while (current != NULL && current != person)
. }9 _4 f; \; [0 N% M. [7 [  h  {
& l  g2 b, g" I7 l9 V: v previous = current;
5 ^) [1 K% K5 B, M: J8 V% Y current = current->next;
) A7 L" I3 o1 }0 M- a  }, [) r& m4 r5 T; U/ a, b% o
* L) @2 M7 f  a1 Y4 @
  if (previous == NULL)* z- B7 U( Z3 f
  {
! `8 r* W. s) R- d //若待删除的是第一个节点/ X2 w4 S. G2 |; ?1 c3 \
*contacts = current->next;- V$ j+ q% g* `7 i6 l0 @3 H
  }
( A* Q- l/ L1 k  else8 {0 E: t5 E: d
  {
: B- q+ w$ c; ^/ `# Z //若待删除的不是第一个节点5 A7 G( e6 t7 _
previous->next = current->next;$ V% L* y. v/ |- g* h
  }
/ ?" Y+ u. M2 y0 h' h5 ^  R. Z1 {( ^( ~$ L0 Y2 o
  //判断内存池中有没有空位. u, `" f: }2 l' N7 t
  if (count < MAX)5 o; T# j$ D, n9 W& W- e& P+ M8 f
  {) p2 G& B* `! w$ C/ g: t& A* y
//使用头插法将person指向的空间插入内存池中  w) Z# S6 ]/ [2 v& h5 Z# _: G
if (pool != NULL)
. a4 M1 u: K; \ {* {9 |$ P+ z) h9 F8 L2 X/ \
temp = pool;- n, `% c$ `! O* |" ~+ Z! x
pool = person;  _+ j, a! z0 |- Q3 Z. O
person->next = temp;+ ~* b$ j+ p# {& m' [) i
}
4 D/ N- I* z& p6 m3 ~1 E, X else
, s1 F& R; U6 s( f6 B: o- u4 E0 c5 g' g {
! f7 ~/ r7 I4 `7 W3 q pool = person;
' l+ b. _7 k, h5 ^) h8 } person->next = NULL;
5 T7 W" [/ S2 K! F+ J* z }4 R. c! |% P6 v/ N, `+ @
count++;& @2 B  K2 B" M9 {8 j
  }! V& Z- X* T2 r$ _
  //没有空位，直接释放
# P9 j. V9 d# D  e  else/ }9 n9 n. h: H0 l) v5 n% [
  {
+ Y$ N. I+ B" z* }! E free(person);//将内存空间释放
$ ?) q2 I" z; g( J3 Q& m: ]9 m  }
* e& I1 g, F; v0 u6 T }
+ W" t4 O" z) U4 S1 u0 T' F$ N& s' `/ z}
. }% P: j( Y0 A% [
/ T) Y5 s9 w! `, t0 _4 vvoid displayContacts(struct Person* contacts)6 ?2 a& [( c  J
{9 b/ ]# i7 P3 Z/ [0 v1 l  H
struct Person* current;
2 A9 ^. i4 E) ?3 S. l4 p  f4 L9 Z
$ r8 l: [* d- E! @0 C, _7 C current = contacts;
0 ~; z. Z1 l6 W) R/ l! x while (current != NULL)- K/ E% J4 G4 w7 y) n2 ?, `
{
+ c% U# _1 Q' ?4 _  printPerson(current);# D5 C3 k: Y/ V3 i  B
  current = current->next;9 F( P' {6 b& ]0 |0 R! C
}7 ?6 b  ?# k  l8 H! {) N1 o( B, t
}9 D  }, g" o1 T" ~3 ]
2 z$ X) Q. ?% p& ?/ Y! [4 O
void releaseContacts(struct Person** contacts)3 T3 }) o" a: I: n/ g" K
{
# [# s* [- |" z- y+ Q struct Person* temp;, c. b* j% g1 H; O8 ^; V
/ t) ^% L% I3 R* y; I
while (*contacts != NULL)
, p5 A( O6 B$ ^/ R# `# k" V {5 K& I8 y0 x5 w+ J
  temp = *contacts;
$ C& Y3 n/ ?4 ~  *contacts = (*contacts)->next;) c. O' K  z) l
  free(temp);/ \$ d  R& O3 A8 M- d3 J! q
}8 A2 D* J9 {* ]# j6 W4 m2 R
}
1 l+ x8 O8 v1 h# {' [& w) h+ b$ D4 z# t% s
void releasePool(void)8 b# L  R7 r9 c
{
/ S) c% Y1 n% Z: s- N" O$ ^ struct Person* temp;
2 g. b% E, I. U; _8 @  e- L- U while (pool != NULL)- D4 k# `/ s# @# d. S
{2 e6 O* I( L4 \, O: o
  temp = pool;
7 z0 N- J' Q% Y/ m1 [' \  pool = pool->next;
" r! T& d. h1 W  free(temp);
}. r7 e. E- u/ D$ O, d$ \
}& T5 ~: ^' V, E  g

2 R4 r% V, K6 t1 jint main(void)5 {7 A, _) N" d  A8 R7 B2 m# k; b' d
{
0 j* Y( M/ \: d  T4 c  V7 ^ int code;
5 J: ]$ W, N+ }( @- ]% Q struct Person* contacts = NULL;8 Q& N* ~: M. i. ^0 t
struct Person* person;1 E; C  W: f' X3 s4 w# R- b
) N2 E8 u- R, S" E
printf("| 欢迎使用通讯录管理程序 |\n");
9 r6 Y3 I$ v  a/ r7 s printf("|--- 1:插入新的联系人 ---|\n");
" u( B( _: k: q9 d; O' P4 C- x5 n printf("|--- 2:查找现有联系人 ---|\n");
4 f& h8 \8 n1 V1 w) f7 Y" Q( } printf("|--- 3:更改现有联系人 ---|\n");6 |$ h7 ?4 _0 v9 ?0 C/ H
printf("|--- 4:删除现有联系人 ---|\n");! x/ S+ i9 N" |, P' T! X
printf("|--- 5:显示当前通讯录 ---|\n");3 b& P3 n0 r/ }9 n: |
printf("|--- 6:退出通讯录程序 ---|\n");$ C* ]' e- X, Q

9 d( _; h& d: L8 R$ b/ [$ ^9 S while (1)3 B0 ]7 C* O' Q9 g
{
5 E' q: x# F2 Q' W) k% L  printf("\n请输入指令代码：");
. P( \0 v( N! W0 t( x3 T  scanf("%d", &code);
' n: t( w6 _. y6 `  switch (code)4 E" p9 Y" i; \+ w
  {
/ m5 u/ R$ v& D" K! M/ m2 I  case 1:addPerson(&contacts); break;
  case 2:person = findPerson(contacts);
9 ^9 _3 q; N- Z6 x8 }2 ~( U- K* `2 ] if (person == NULL)2 ?6 d8 {) F  h: G5 |
{
- C( a, @  n$ ^5 [% g( m- D$ P3 Y printf("找不到该联系人！\n");2 ^7 Y3 V/ x, k$ {
}
0 p/ Q' a( r! b' N7 h+ |) v else1 t& k# e' D: ]
{
  s- D% }; W. P9 y9 }* L  W printPerson(person);
# V4 m5 G2 `3 h; K+ d7 H7 O }
  q% U+ }1 F$ C* F9 Q# ` break;
- m* t. \$ ^8 E: {9 o1 M: D+ u8 _4 U  case 3:changePerson(contacts); break;
2 r" U- K5 R- _% G1 V; |4 ~  case 4:delPerson(&contacts); break;/ Q& ^7 }, t( R8 q2 `
  case 5:displayContacts(contacts); break;$ A8 q- s1 f/ ^! Q+ I
  case 6:goto END;
3 F& t. r% f4 l5 T8 l3 V6 {8 L6 v( x  }2 n' h& e' O3 O2 a% W6 d3 m. z4 n8 t
}: W- @- U0 O. F. C
- d; h( w9 M( Q7 S( p
END://此处直接跳出恒循环/ f8 w5 B# g- n& u
releaseContacts(&contacts);7 S5 M, u# s- u1 l$ e/ l
releasePool();
: z8 t9 V% \  q( o
$ [+ S9 w) r$ S return 0;
: i: W, d* g5 x8 B
# Y' B/ G. N$ q4 b}
typedef
- ]+ ^. M- R8 K" X

给数据类型起别名
C语言是一门古老的语言，它是在1969至1973年间，由两位天才丹尼斯·里奇和肯·汤普逊在贝尔实验室以B语言为基础开发出来的，用于他们的重写UNIX计划（这也为后来UNIX系统的可移植性打下了基础，之前的UNIX是使用汇编语言编写的，当然也是这两位为了玩一个自己设计的游戏而编写的）。天才就是和咱常人不一样，不过他俩的故事，在这篇里面不多啰嗦，我们回到话题。
虽然C语言诞生的很早，但是却依旧不是最早的高级编程语言。目前公认的最早的高级编程语言，是IBM公司于1957年开发的FORTRAN语言。C语言诞生之时，FORTRAN已经统领行业数十年之久。因此，C语言要想快速吸纳FORTRAN中的潜在用户，就必须做出一些妥协。
我们知道，不同的语言的语法，一般来说是不同的，甚至还有较大的差距。比如：
C:
int a, b, c;/ O! U  H! ~6 f* `( p
float i, j, k;
而FORTRAN语言是这样的：
integer :: a, b, c;
/ V! s$ Q+ G* s2 |3 vreal :: i, j, k;
如果让FORTRAN用户使用原来的变量名称进行使用，那么就能够快速迁移到C语言上面来，这就是typedef的用处之一。
我们使用FORTRAN语言的类型名，那就这么办：
typedef int integer;
" w6 k& ]- B8 n8 n/ _/ E! _& vtypedef float real;, L. k6 l9 K/ f1 _! |6 W

8 t" u+ [- _) g3 uinteger a, b, c;2 H6 I0 a8 }- w) c- |4 b
real i, j, k;
结构体的搭档
虽然结构体的出现能够让我们有一个更科学的数据结构来管理数据，但是每次使用结构体都需要struct...，未免显得有些冗长和麻烦。有了typedef的助攻，我们就可以很轻松地给结构体类型起一个容易理解的名字：
typedef struct date2 C0 J% c) U$ W7 Q6 U1 D
{
  l; Z- R8 u' P+ m' y int year;
+ J' a( r6 g! ` int month;9 ~1 q9 S& w* A) x* R
int day;( u$ z2 N6 b& G  T) e
} DATE;//为了区分，一般用全大写/ p( ^. R* {1 F) @3 y/ a3 }5 T! m% k& @

- p, V3 `( k7 a' Jint main(void)
/ i) \- d$ s  d5 P0 t5 z5 [{& M% ]! G1 G$ k- F$ U
DATE* date;
$ M& b7 a& Q# R1 o ...
; q3 D' i4 }! U  ^$ l# Q}
甚至还可以顺便给它的指针也定义一个别名：
typedef struct date
# r7 I' X5 C3 y+ o{) k8 o7 c* f% R
int year;7 Z' z5 L" }; o" c" t+ W
int month;7 ?( p: k" Q& o% l+ b3 T2 s0 J
int day;
4 R4 o5 m3 T, g( x* \; s6 g} DATE, *PDATE;
进阶
我们还可以利用typedef来简化一些比较复杂的命令。
比如：
int (*ptr) [5];
我们知道这是一个数组指针，指向一个5元素的数组。那么我们可以改写成这样：
typedef int(*PTR_TO_ARRAY)[3];
这样就可以把很复杂的声明变得很简单：
PTR_TO_ARRAY a = &array;
取名的时候要尽量使用容易理解的名字，这样才能达到使用typedef的最终目的。
共用体
' q' Y( {' P9 c3 D0 D; T

共用体也称联合体。
声明
和结构体还是有点像：
union 共用体名称/ H! V1 a- S/ s
{, F8 u1 t% E/ H9 {
成员1;' A2 [+ {4 t& N6 l( \& _) L
成员2;
成员3;, _5 H* M' N* i* @
};
但是两者有本质的不同。共用体的每一个成员共用一段内存，那么这也就意味着它们不可能同时被正确地访问。如：
//Example 05' d1 i3 ~, u" @! G
#include <stdio.h>3 }4 K6 G* S7 f5 _; R( e  W4 n# c! k
#include <string.h>% a6 v  N& S+ b

6 v, ^; G- ^! R" }$ }union Test
+ E- p9 X3 p5 w* B% q{/ U( R0 |6 j0 j8 E( W: d% ?
int i;
, b: \2 z$ K( e* g double pi;
/ b1 ]7 S3 a5 J' M& } char str[9];
5 P( s8 B! D, t};
2 Y+ p! {+ N  V" K6 X
9 w2 w2 J8 h- X% iint main(void)
6 _9 C- o& N  {6 J  m% n{3 Q" B- [' P9 m& N: c8 A& {
union Test test;
4 ^) R! m" [* V: |& O% u: E+ H3 C2 Z9 b7 v7 O0 @5 h
test.i = 10;5 s9 D( q  M! Y/ `7 w- |  g
test.pi = 3.14;! y9 z) M9 J8 G, M( S6 {
strcpy(test.str, "TechZone");
$ o: W: H" Q" @3 \; h0 Q9 q8 E. ]+ l$ \9 ^- |8 c8 G8 ^' a% l
printf("test.i: %d\n", test.i);. j  o& w' V( K, p! Z& }
printf("test.pi: %.2f\n", test.pi);
, h6 L6 W' O( m/ J printf("test.str: %s\n", test.str);
7 Y/ k1 z& `- r* @) u+ G: t* z, T0 H& c: [6 p
return 0;, z) }: p. G' x2 p
}
执行结果如下：
//Consequence 056 w: }1 x1 f" T0 R) j$ S- E
test.i: 1751344468
" H$ O$ N* [) }8 H+ mtest.pi:3946574856045802736197446431383475413237648487838717723111623714247921409395495328582015991082102150186282825269379326297769425957893182570875995348588904500564659454087397032067072.00) x' N: o- T. K8 j. g( I" B0 B4 `
test.str: TechZone
可以看到，共用体只能正确地展示出最后一次被赋值的成员。共用体的内存应该要能够满足最大的成员能够正常存储。但是并不一定等于最大的成员的尺寸，因为还要考虑内存对齐的问题。
共用体可以类似结构体一样来定义和声明，但是共用体还可以允许不带名字：
union4 n7 @8 h7 w% e/ Z* Q2 {+ a
{
# u& E7 Z4 r3 D* K int i;
# C0 _$ n( \* K char ch;
. X2 C2 e& `5 z8 ^$ ^, b float f;
  V; [2 @; ], e2 v} a, b;
初始化
共用体不能在同一时间存放多个成员，所以不能批量初始化
union data" H7 c9 w: u: P$ H
{" u: H- E& X' |
int i;
) O$ h" q0 c2 b6 V char ch;. b- F1 }' O3 k0 k# s
float f;
% Z4 N9 z3 R* u9 Y; U+ i};
1 |: ^3 k: r- h! X3 i  \, b+ r4 A' G; N2 {5 H, V8 t
union data a = {520};       //初始化第一个成员6 t$ X5 D8 ~  S6 f8 ~- f$ l
union data b = a;          //直接使用一个共用体初始化另一个共用体
' y# m/ n2 K! @! G9 Munion data c = {.ch = 'C'};  //C99的特性，指定初始化成员
枚举

& @# Y5 r. X& t: C
枚举是一个基本的数据类型，它可以让数据更简洁。
如果写一个判断星期的文章，我们当然可以使用宏定义来使代码更加易懂，不过：
#define MON 16 G& v( r. v& @) b# ]  m
#define TUE 2
2 l3 _1 u1 \9 x" y! p6 }#define WED 3
$ F, y/ M% X. i) l0 J( Q#define THU 4
! t6 `3 ^  ?1 x3 _' O# z#define FRI 5
& F; ?$ b8 c8 B( e9 `: z5 _#define SAT 6
  x2 f/ G$ A! e, L8 |7 V5 l#define SUN 7
这样的写法有点费键盘。那么枚举就简单多了：
enum DAY' H& t5 C+ {% R7 E. p
{  H  P% L/ h% `
   MON=1, TUE, WED, THU, FRI, SAT, SUN; J  x7 V# p! _3 b+ Q
};
❝
**注意：**第一个枚举成员的默认值为整型的 0，后续枚举成员的值在前一个成员上加 1。我们在这个实例中把第一个枚举成员的值定义为 1，第二个就为 2，以此类推。
❞
枚举变量的定义和声明方法和共用体一样，也可以省略枚举名，直接声明变量名。
//Example 06; G+ F) k4 S5 t! m
#include <stdio.h>7 ^8 M( M) o1 t" a+ L# w
#include <stdlib.h>
5 E$ g& B* Q4 G; H2 ?
4 E+ R$ E% o8 ]' Y& nint main()- J( R$ w/ I, z$ I# _( a
{
2 b9 \% K! o/ T9 j  b% i6 `
enum color { red = 1, green, blue };
8 \' q! g+ w& F. P3 W' s1 C* D- m- i7 n! A
enum  color favorite_color;
3 K( H, }% n6 a7 Q0 C( R. o6 O& d9 _+ ~. \5 q* t9 {- i# j6 _5 Y1 V- E
printf("请输入你喜欢的颜色: (1. red, 2. green, 3. blue): ");
0 B% T8 `: H* h scanf("%d", &favorite_color);, v- [# F5 w5 b7 w. a
! `* u: t, p+ q$ J+ s; E+ R. `
//输出结果
6 g$ [4 q$ G  r- ?# `0 r( s. q" ~ switch (favorite_color)
; ]8 ], d* A  d1 V( j8 _" g9 @ {3 e5 q  {6 [8 K" A( u( @
case red:
  {) N) N) H  `  W) d       printf("你喜欢的颜色是红色");
4 U2 e7 S" n6 R9 E& e( T       break;& w/ J) {. f( j! u
case green:3 g9 J+ W4 S: [- W
      printf("你喜欢的颜色是绿色");" Q8 E0 e, y7 N5 S. _
      break;$ F4 e6 v& l4 |9 E" p
case blue:
+ P+ y$ Z8 G$ Y4 @2 ?3 a       printf("你喜欢的颜色是蓝色");
9 t, f* x2 @, f, h& v/ m; v; l3 s6 ~       break;) o+ K( Y+ y2 h  j, v3 f) s& ^; e
default:
3 M& ~# q6 ~4 p$ d& w1 i; c! ?       printf("你没有选择你喜欢的颜色");
4 c; z" P$ L3 n3 u. h }
) K" t5 a6 x7 T2 E! x( \7 S% }& b( C' j* T
return 0;+ d% Q- Q) O6 s# K
}
执行结果如下：
//Consequence 06  ]# r& C& ]1 C# B! x# M
请输入你喜欢的颜色: (1. red, 2. green, 3. blue): 3
% ?6 W" l9 l' \你喜欢的颜色是蓝色
也可以把整数转换为枚举类型：
//Example 07
& ^: n$ [+ J. X0 Y: s% z( |1 p# i) _6 _  k4 N/ i
#include <stdio.h>
& M+ Y( |2 ~  r# B#include <stdlib.h>
) q7 I$ e  S5 n; s( \+ [
: h, c& f- q& O& Cint main()+ e# i8 N; \) P% R+ `5 W" `* M
{
! Q" A  ?- A, E enum day
7 F2 `: t+ G4 @& `0 O; A {
! e) h5 t  f) w6 T/ z       saturday,1 O. F  B# j% ^4 U
      sunday,1 H& g. M( d/ t6 o- n! g' g
      monday,
5 W6 \2 B" D) J* L       tuesday,, ~  L2 b- t+ G# X4 H# ?
      wednesday,
- ]. N5 H3 e5 b- u5 i5 j       thursday,8 t, ^, k6 i, L  E
      friday5 t( h! E3 L* a' g/ y
} workday;" K3 |  |/ i  X$ Z; u

4 Y: [2 s, |% X$ g6 v7 j+ ` int a = 1;1 H  E& L6 A: Y% J% i) ?6 c' F: o
enum day weekend;, \# f6 l- [( g9 a/ M6 X6 f
weekend = (enum day) a;  //使用强制类型转换5 S8 w; E: X- D5 ?8 y
//weekend = a; //错误
6 V4 D$ |  |9 K; A- U1 j printf("weekend:%d", weekend);
: K) Z; o* F3 |. I8 Q return 0;
$ \+ u- p& X  Y% _& L6 w# S}
运行结果如下：
//Consequence 07
1 V; U, l8 H" gweekend:1
位域

$ k# H, u& V: L! _5 \2 n4 n
C语言除了开发桌面应用等，还有一个很重要的领域，那就是「单片机」开发。单片机上的硬件资源十分有限，容不得我们去肆意挥洒。单片机使一种集成电路芯片，使采用超大规模集成电路技术把具有数据处理能力的CPU、RAM、ROM、I/O、中断系统、定时器/计数器等功能（有的还包括显示驱动电路、脉宽调制电路、模拟多路转换器、A/D转换器等电路）集成到一块硅片上构成的一个小而完善的微型计算机系统，在工控领域使用广泛。
对于这样的设备，通常内存只有256B，那么能够给我们利用的资源就十分珍贵了。在这种情况下，如果我们只需要定义一个变量来存放布尔值，一般就申请一个整型变量，通过1和0来间接存储。但是，显然1和0只用1个bit就能够放完，而一个整型却是4个字节，也就是32bit。这就造成了内存的浪费。
好在，C语言为我们提供了一种数据结构，称为「位域」（也叫位端、位字段）。也就是把一个字节中的二进制位划分，并且你能够指定每个区域的位数。每个域有一个域名，并允许程序中按域名进行单独操作。
使用位域的做法是在结构体定义的时候，在结构体成员后面使用冒号（:）和数字来表示该成员所占的位数。
//Example 08
' M, B: G7 h% }8 Y: H#include <stdio.h>! l7 K2 e1 W' i: c8 S

1 v8 O, i7 P) O3 W$ M$ Sint main(void)9 s( k  m2 f' f; `) \: j' L
{
  t2 O6 J% X8 \4 z7 \# @ struct Test
. d; |0 h5 o2 g; B1 G/ E {
* D7 i1 S/ ^+ w( L6 c  unsigned int a : 1;8 o- X2 _0 w) _* y
  unsigned int b : 1;
% `- @$ o$ S) i. J  unsigned int c : 2;" E+ v+ D! H( F3 h5 W% {
} test;3 e' \4 s  c- U$ L0 ]

( V1 v* C9 `" a4 w8 N6 w& R( \) a: G test.a = 0;
0 J% j& E  B# k; n% `/ B test.b = 1;
' L/ K: ?/ t# k9 ]+ H5 G7 }& m test.c = 2;
' n! ^0 a8 G& [$ l) ^5 J" j
$ k& K5 H. u6 {6 u printf("a = %d, b = %d, c = %d\n", test.a, test.b, test.c);
* B; d% n. [' T, ?2 i printf("size of test = %d\n", sizeof(test));8 F) x1 @5 [; B, K* L) k: J$ e

+ G9 N+ w: X9 | return 0;
9 K" T! j$ z9 h2 B  J" S, s! K8 p}
运行结果如下：
//Consequence 083 w7 O. w2 z% w
a = 0, b = 1, c = 2
+ p5 c( E: ]4 ^% I2 u% m3 X$ jsize of test = 4
如此一来，结构体test只用了4bit，却存放下了0、1、2三个整数。但是由于2在二进制中是10，因此占了2个bit。如果把test.b赋值为2，那么：
//Consequence 08 V2
6 X: F4 R/ X# y2 d' n8 xa = 0, b = 0, c = 24 v* k" w& P0 p7 l/ `
size of test = 4
可以看到，b中的10溢出了，只剩下0。
当然，位域的宽度不能够超过本身类型的长度，比如：
unsigned int a : 100;
那么就会报错：
错误  C2034    “main::test::a”: 位域类型对位数太小
位域成员也可以没有名称，只要给出类型和宽度即可：
struct Test
: L% I, h! B' R{
7 M  R* [, I) ~/ e# B( ? unsigned int x : 1;
5 {# S( X# N5 r! K+ r unsigned int y : 2;9 S0 s2 E2 X; @% P1 W) Q2 a5 D/ k
unsigned int z : 3;
5 b" c" T; a, b3 l1 b unsigned int : 26;) }4 \3 B4 G& I1 L( R1 X& {
};
无名位域一般用来作为填充或者调整成员的位置，因为没有名称，所以无名位域并不能够拿来使用。
❝
C语言的标准只说明unsigned int和signed int支持位域，然后C99增加了_Bool类型也支持位域，其他数据类型理论上是不支持的。不过大多数编译器在具体实现时都进行了扩展，额外支持了signed char、unsigned char以及枚举类型，所以如果对char类型的结构体成员使用位域，基本上也没什么问题。但如果考虑到程序的可移植性，就需要谨慎对待了。另外，由于内存的基本单位是字节，而位域只是字节的一部分，所以并不能对位域进行取地址运算。
❞
虽然科技发展日新月异，但是秉承着节约成本这个放之四海而皆准的原则，还是要注意使用！毕竟5毛钱可能是小钱，但是乘以5000万呢？

4 M/ o5 B0 L6 W4 A