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)
{
/**
0 n) l, B( @1 t' D' B    *在main函数中声明结构体变量
; t' R- K. Z1 j    *结构体变量名叫info, k5 a' l; ~3 q$ ?; m: x' Y
   *struct关键字不能丢
6 s3 f% w4 f8 q    */
struct Info info;
...
}

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

#include <stdio.h>

struct Info
{
unsigned long identifier;//学号，用无符号长整数表示
char name[20];//名字，用字符数组表示
unsigned int year;//入学年份，用无符号整数表示
unsigned int years;//学制，用无符号整数表示
} info;
/**
4 A' \: }8 V; H7 F) } *此时直接定义了变量
6 u9 i6 G' y6 `4 Q$ t0 u *该变量是全局变量
4 ]+ g9 `- u1 N$ V. ? *变量名叫info
! v. W; F1 J/ }+ E7 r9 L */

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;
$ Q+ W8 ^1 R9 i }0 [8 n! x' P, N& v4 A
}
' @& V# |" K, g2 }/ Y) R: G/ V+ V
void printLibrary(struct Book* lib[])
3 F  E. ~% P: T) H# u3 B) @{# a# a# x0 i# M. C
for (int i = 0; i < MAX_SIZE; i++)
% }% v7 j8 g6 g% G {# a+ f  K; d) P/ w0 [/ g$ a& ^2 W
      if (lib != NULL)
6 r: o2 l- i4 [3 Q* b       {
& k, F1 T$ q5 t6 K4 f) B" T1 d          printBook(lib);# a$ M. O7 I. g$ J
         putchar('\n');
) \) t) h# i" M" w       }
4 D$ t% D0 N& P' j) t }' f) c3 p! b+ t, S- W7 E9 i0 W
}
( C- J' q4 i! I; G8 P% O- \5 J
8 J+ C7 V4 `; ]9 Xvoid releaseLibrary(struct Book* lib[])% c) f0 {9 B5 C7 p( c4 g
{
  u$ C, G. q4 t: v for (int i = 0; i < MAX_SIZE; i++)
4 u7 i& }& L+ {* m0 F6 v {! w# v! \; h$ m' Q* p( n
      if (lib != NULL)! w' D9 h# X' u6 l; w3 G) }
      {
* g! ^# H, @1 r! a8 P: z) A          free(lib);
% `( ?) I1 O* \) C       }8 Q) b6 o# M+ Z" f2 Q
}" e" g; r$ d" b
}3 a( d) `, s* r% g& H( C  ~
0 b* B: t9 E6 Z$ ]% O$ l! Q' Q
int main(void)7 I1 b5 u+ Q6 N- V8 \% U$ g0 c
{& n* v8 v( g: t8 G7 V8 A" ~
struct Book* lib[MAX_SIZE];
; {6 @" K. p4 I) A1 G1 v! l struct Book* p = NULL;
, q' [" o# Z+ B* j4 E int ch, index = 0;
5 S4 [- E* s. A( h4 c% E" H3 u
% \- @  I% u. J5 g: w initLibrary(lib);/ A( e% X, c6 |

! C: L- v9 @/ x+ U( v+ R* y while (1)
4 s8 I7 _, j8 @# | {# P: ]# s" q* g# ^) _
      printf("请问是否要录入图书信息(Y/N):");
9 m1 t" I+ N& j5 L* r3 \. @" m. h       do5 f& H9 }2 ]6 K  Z3 v0 E: N
      {* o% m, ?/ `5 u* B
         ch = getchar();
2 k% p7 C, [0 T! [) `3 m* E( X- M9 w       } while (ch != 'Y' && ch != 'N');
7 b* v2 `& e$ X3 Z
; T& j! U2 A6 ^* ~       if (ch == 'Y')8 {) _7 V+ _$ l2 Q
      {
, H* u2 X8 |2 d( v          if (index < MAX_SIZE)5 t$ p' w$ O; k3 Y
         {
' b. c1 |6 Q& }+ k+ r) o# a             p = (struct Book*)malloc(sizeof(struct Book));% [, w+ u  x) g5 j
            getInput(p);& ~) o) O1 }+ z4 D" ?" L
            lib[index] = p;- R8 m( ~1 W6 d# {& x
            index++;
& T: n- }% b1 |; x# d8 N( |             putchar('\n');  x' A+ N2 }9 w$ N+ ]
         }- m/ i3 P5 }& m
         else
) Z, L/ `" y+ E9 P) G3 d4 I# f2 ~          {
4 v% s" G% z. y; e( W  C             printf("数据库已满！\n");
% F3 q9 ]$ x* v             break;' v7 F  X2 R* n( E: w) {* |9 E
         }4 y1 c1 s0 `) C
      }
; o2 W+ F( }. ]7 C6 F       else
3 [" f6 s/ T3 ^+ _% T( W/ H       {
, V' C" f, N6 m* ?- u          break;  R6 c7 e. X' z' o  e+ r: I1 _
      }5 L* N+ k7 u* U# a$ q' ]4 ~. x' S- F  G
}- i9 n5 J! M$ @6 \2 R

0 W: B% _6 a: b/ Z  j printf("\n数据录入完毕，开始打印验证...\n\n");) K, F$ p  E8 m; K) h' r, s
printLibrary(lib);  l2 Z7 o  P# m/ {' X5 A
releaseLibrary(lib);
9 R) `9 a/ ^& B9 d5 R( O# S. N2 t) T, s3 M
return 0;
' E7 b) R& c4 n5 L}

运行结果如下：

//Consequence 02/ p# v$ ^/ P& W) a6 e0 B
请问是否要录入图书信息(Y/N):Y2 l8 V7 |; }' P! X
请输入书名：人类简史4 |" \3 ~3 g6 _; n; D4 l0 x. {
请输入作者：尤瓦尔·赫拉利
2 e5 n* l) b, m- z7 z5 n请输入售价：32.25* W- o2 A$ ?: e9 J% r
请输入出版日期：2016-3-45 P6 M$ ^- O2 |' d7 @) x, [3 o
请输入出版社：中信出版集团6 K. f1 y* b5 o( ^/ U

& c8 t" Q/ q4 w, E" d请问是否要录入图书信息(Y/N):N
! b7 e4 u$ F7 R9 O. \# A& o7 g( a% ~0 U
数据录入完毕，开始打印验证...
7 S: P! d) u8 }! Z9 _2 d# R T- E1 W: I; ^; W) M
书名：人类简史
5 |6 v8 j5 e2 L) f( {" i( _ b, c# a作者：尤瓦尔·赫拉利$ O# p0 q- h6 _' C. J( [4 \" @! T+ S5 M
售价：32.25- }5 |9 `6 d# p5 B
出版日期：2016-3-4
# W6 \; f5 `* }3 Z( F8 m出版社：中信出版集团

单链表

) [) |; q6 \+ M: u, s

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

单链表
当然，链表最前面还有一个头指针，用来存储头结点的地址。
这样一来，链表中的每一个结点都可以不用挨个存放，因为有了指针把他们串起来。因此结点放在哪都无所谓，反正指针总是能够指向下一个元素。我们只需要知道头指针，就能够顺藤摸瓜地找到整个链表。
因此对于学籍数据库来说，我们只需要在Info结构体中加上一个指向自身类型的成员即可：
struct Info
( n% [/ r- }$ k{
/ l' _" A8 `7 } unsigned long identifier;  a2 w; O6 a. r3 Q
char name[20];/ _& A, R( c9 T) a0 [4 o1 a
struct Date date;5 R) b/ _+ n" c
unsigned int years;; k$ b& n7 P6 Y; Y3 y( k; K
struct Info* next;. u: k/ |. h' j  T% X
};
在单链表中插入元素
头插法
这种每次都将数据插入单链表的头部（头指针后面）的插入法就叫头插法。
如果要把学生信息加入到单链表，可以这么写：
void addInfo(struct Info** students)//students是头指针7 p9 n5 x3 c% i( x: N
{" W" Q0 D9 ?: w
struct Info* info, *temp;
& x8 `7 F  ?2 U info = (struct Info*)malloc(sizeof(struct Info));5 k) b9 b  w- S' `' d
if (info == NULL)* c% q) @7 w) Q" A( K7 g
{% w( ]' u: W3 V" g3 n% B+ c
      printf("内存分配失败！\n");1 ^  N+ v5 W7 |& a5 i" M6 Y
      exit(1);
8 _% e! F( F7 d7 @5 h& |6 n }* h3 M' f* h; D1 i
; Z; a# X0 a& [* ^  O
getInput(info);
. D/ O9 c2 [- ^: z% Z6 X4 j* T
. `- F5 f% {- ^' G" L/ a if (*students != NULL)
! ?4 r  O4 m8 J0 M2 d% f' W) t {
* E* v  R9 a8 d) a4 g0 g7 ]' _       temp = *students;  }3 L  z9 j, o, f) v5 J) K
      *students = info;
" B) I+ S: j' t; f9 O0 V       info->next = temp;2 D0 q1 U* b7 d2 L2 S3 o: i3 z
}
5 L4 w0 Q, j7 m# v else
1 q6 ~3 I7 D. ^% P5 r {
, e+ ?6 N( Q- z) K       *students = info;) Q8 f  g" N/ ?+ ?, B
      info->next = NULL;6 v! i3 T  C; S6 e  c5 B
}; t' M7 i* E/ A
}
❝
由于students存放的是头指针，因此我们需要传入它的地址传递给函数，才能够改变它本身的值。而students本身又是一个指向Info结构体的指针，所以参数的类型应该就是struct Info**。
❞
往单链表里面添加一个结点，也就是先申请一个结点，然后判断链表是否为空。如果为空，那么直接将头指针指向它，然后next成员指向NULL。若不为空，那么先将next指向头指针原本指向的结点，然后将头指针指向新结点即可。
那么，打印链表也变得很简单：
void printStu(struct Info* students)6 i5 P8 l& }6 x- J9 u' L( @
{
( [/ `' s: ?! d6 a struct Info* info;4 ]# Z) y5 ]; h( X3 G+ x
int count = 1;9 g# L! p3 h# Z: O7 ^' ]" X) Y* R
: u  t: m3 u& Z9 l! W
info = students;
& w3 y3 s' l, @. t while (book != NULL)0 b! j9 Z6 U0 B& D) T. p5 A
{
$ v1 B# w! _1 E! B       printf("Student%d:\n", count);
; _  i# r% o/ K; ]       printf("姓名：%s\n", info->name);/ c# R5 A: _& Q6 _  d
      printf("学号：%d\n", info->identifier);
9 p5 V! M% B1 }- D       info = info->next;( t' f/ l6 W* d9 ^) n: V
      count++;" k' l7 W/ Z) X8 M. i
}0 g/ @* k7 W6 n1 B
}
想要读取单链表里面的数据，只需要迭代单链表中的每一个结点，直到next成员为NULL，即表示单链表的结束。
最后，当然还是别忘了释放空间：
void releaseStu(struct Info** students)
+ c! j* t' T. u) ~3 R  m{
" l2 J! u; B- D, W( T4 U- f( x; } struct Info* temp;  k. n! g1 p( t) W& ^  x" J
9 X' Y' |  B. O( R
while (*students != NULL)) Z2 h( l0 M- R( R
{7 Z" A- t# x; G) P8 j' E5 O
      temp = *students;
  ]) C, g% w" l9 g2 J$ d       *students = (*students)->next;
( Y7 g0 {/ j6 k8 ?2 t- a       free(temp);
4 Z  W* ?, [# A; J) ~ }
! N6 k! y8 ^6 r}
尾插法
与头插法类似，尾插法就是把每一个数据都插入到链表的末尾。
void addInfo(struct Info** students)
, P: E3 X5 I. R' e! N7 ~{
struct Info* info, *temp;
( m1 ]" ]2 }9 X info = (struct Info*)malloc(sizeof(struct Info));
5 G7 ^. V. O; f& q1 j* g8 [ if (info == NULL)! f, r- c  q7 x' B% g+ y3 m
{
+ y. x9 K4 L$ d: I. h# {2 [       printf("内存分配失败！\n");) d( p  c+ S  A4 ]8 F) \
      exit(1);
; ?# {2 q* C0 K2 h( i; d! a  Q }
0 G" J- y' N. d) O% b1 v 3 X0 e+ H$ U' ^; p* B( S
getInput(info);
4 A& r1 G+ R% X9 M* {! X 5 A% K3 I; s0 V0 I
if (*students != NULL)8 h0 ?5 n' h0 r) M2 Z- k9 Q0 |
{$ E1 T9 O9 `9 k; x) C) O
      temp = *students;; o5 M3 q1 Z9 C2 ?" T
      *students = info;4 K, d) |4 g$ q3 Y/ f' K4 g
      //定位到链表的末尾的位置0 ?; C3 |* P, T  n8 p" C) n. e' O0 \
      while (temp->next != NULL)2 w7 F, t% {" c' i
      {6 f, ]0 M0 f' N1 T0 ?1 @
         temp = temp->next;* R! \% [2 I( ~0 ~: @, j  X
      }
" E8 @7 c4 Q6 A2 h       //插入数据
; q  A4 V0 _/ |5 ?0 W! W3 M       temp->next = info;" l' z6 H1 z1 [& Z
      info->next = temp;
4 l$ X) {8 Q  {, a4 C }0 ^. u) O- T+ w+ J
else, t+ S' @$ Y9 R: I1 A" |
{: l+ K3 |& U0 }. E5 {5 N7 G- o
      *students = info;3 E( B: N* c- G9 e6 c, x
      info->next = NULL;$ ^2 A1 w$ n  @1 X9 O  z/ v
}
8 I  O4 `( j! O0 y: b* z1 G) E}
这么一来，程序执行的效率难免要降低很多，因为每次插入数据，都要先遍历一次链表。如果链表很长，那么对于插入数据来说就是一次灾难。不过，我们可以给程序添加一个指针，让它永远都指向链表的尾部，这样一来，就可以用很少的空间换取很高的程序执行效率。
代码更改如下：
void addInfo(struct Info** students)
4 a# S9 I* S1 a$ e2 w. k& C{! _+ U" G7 H, E/ i% K
struct Info* info, *temp;
0 i/ Y% Y1 |. v0 n* c! m4 K6 W1 U static struct Info* tail;//设置静态指针% T6 z4 \" p; F
info = (struct Info*)malloc(sizeof(struct Info));
4 M. X, }) Y8 L$ t, Z7 l" ?# W if (info == NULL)
6 ~9 t/ ?' S# x& x- O {2 J2 ^4 x" _. e3 I
      printf("内存分配失败！\n");- A2 d2 T8 Z$ t" G9 b
      exit(1);
. N  e% `  I  ?( N4 } }
1 q' Z& i8 ?( n
6 }7 k& v6 Q) [4 ~# { getInput(info);
5 [  g. J9 v0 c0 U- [# w6 g4 } . n- U$ y+ ?: e6 _8 f2 ]2 s0 n
if (*students != NULL)
4 i; _* D2 R* R! U {" b' b/ F7 s. @5 F- I9 t6 o7 @# W* H
      tail->next = info;( U& O) V3 R- t( v8 a
      info->next = NULL;
' w4 }' q* ?( C, R0 l }# ]( a  c, R# P/ m- x7 |& ]* }
else) D$ Z6 G: l3 `" ]* C) j
{
7 [% ^* Y2 d6 F; x5 l: i       *students = info;
  l' a, ]  Y. q4 Q5 |2 k5 D. C       info->next = NULL;
6 a) ]2 D3 f) `: W4 [0 _ }
, [* D* a. j% l9 ~6 J* M}
搜索单链表
单链表是我们用来存储数据的一个容器，那么有时候需要快速查找信息就需要开发相关搜索的功能。比如说输入学号，查找同学的所有信息。
struct Info *searchInfo(struct Info* students, long* target)! Z9 ~' b( h  Y) R: R' R
{3 |: x" G/ T" M% P  C: X6 u" i
struct Info* info;
! c$ w  F% I( i! C info = students;# U; l8 c+ O, [$ M& E) s
while (info != NULL)( O; `: _% H2 d, D3 O
{0 M( J6 N, [4 B! y' a" e
      if (info->identifier == target)
( k8 S! @6 v+ F; z  A       {
+ m& s  X2 I) w1 @! a          break;
8 A% Z% v) H- \& r/ g  z) d       }2 u8 E; b, m3 [+ G; P
      info = info->next;# d# A7 M' y3 d" o1 u2 X0 ]
}
* V% a! e/ C* K  x0 T 0 u% q' D1 i/ U% m/ B
return book;0 C# p+ Z) C2 q+ S0 y, j. t5 L! a5 ]
};
0 X, f& c' @$ r5 u' d6 A1 q4 P5 g2 }9 u; P/ G, }; X9 T* F, H
void printInfo(struct Info* info)
. |* }3 v1 g4 U6 w9 Q{/ e7 z# z; X- k8 d% V" w( s$ f3 H0 f
...
4 p+ J) v5 ]0 w, k5 F}3 S9 p! t9 x3 Z# |6 d$ w+ d: b
...$ j6 g" N% o) S! ?' C( l

, a# M9 y1 R# t3 B3 oint main(void)
) W$ U6 m) ]: w{
6 e( ?% W/ @4 `3 Y3 k, l% Z ...
! t- L! y4 r% [, a* n( I printf("\n请输入学生学号：");
/ c" I3 f) a2 a. n' q+ C scanf("%d", input);
; [  d2 W7 [$ K+ E3 h8 N info = searchInfo(students, input);" B7 z) O, `' M! W9 G
if (info == NULL)
) T' ]' {" O& s: _3 B4 e6 L {
+ `, d! h3 X$ ?5 G6 w       printf("抱歉，未找到相关结果！\n");6 G2 N, r+ }8 [( N; |) A) v
}" X  M/ W: C" {% H+ f
else6 {* P; }- ~7 ]* ?, C
{+ @% A. W! e! X& t" [- o+ r+ t
      do
5 D2 ]( G2 t. v( h: {3 M       {7 R! u) e0 o$ _& @6 l4 M
         printf("相关结果如下：\n");
- L, U# m; X* u# _% O. `! x9 A          printInfo(book);
, }% l+ T* f+ G       } while ((info = searchInfo(info->next, input)) != NULL);8 L4 Z* Z* ~7 j! A  C* C
}
, b4 _  g. b' T* v7 Z9 `- {) o$ x : O# d1 @9 S9 a) g. S/ j- L
releaseInfo(...);
7 U: o8 l* p3 w return 0;
* ]* T6 u6 E9 ^, P" i4 h}
插入结点到指定位置
到了这里，才体现出链表真正的优势。
设想一下，如果有一个有序数组，现在要求你去插入一个数字，插入完成之后，数组依然保持有序。你会怎么做？
没错，你应该会挨个去比较，然后找到合适的位置（当然这里也可以使用二分法，比较节省算力），把这个位置后面的所有数都往后移动一个位置，然后将我们要插入的数字放入刚刚我们腾出来的空间里面。
你会发现，这样的处理方法，经常需要移动大量的数据，对于程序的执行效率来说，是一个不利因素。那么链表，就无所谓。反正在内存中，链表的存储毫无逻辑，我们只需要改变指针的值就可以实现链表的中间插入。
//Example 036 ~8 T0 y/ O) F" c8 W
#include <stdio.h>+ F: \: R  z5 d2 d) A* b5 |
#include <stdlib.h>
9 x# G' a( N5 j  v: b# ?( f" T' }4 n
struct Node
1 \, X' _# ]# g  n+ N: W{2 r( |2 {+ A5 k( g) \
int value;$ t7 l1 D6 V6 z4 n' v
struct Node* next;, o% j( N* A- I
};6 |& [& K3 R8 \( U/ C1 |% f

  H' k) O2 k# @void insNode(struct Node** head, int value)
' g3 Y& H: o9 s8 T: M/ U2 {0 g{! M3 T: d) Y, ~- J
struct Node* pre;
3 Q. y8 Z0 S/ I. F8 l/ i struct Node* cur;
, |3 y' A/ I, h( ^7 y9 `% @ struct Node* New;
3 v4 e- M; m' M7 M6 A+ D1 }+ c+ v1 |/ K7 Z  i
cur = *head;( d9 ~% a' |0 Y/ j$ U. \2 q
pre = NULL;
9 U- f2 {' p! C0 H' `) X6 ]; G2 ?8 S
8 o/ d3 T) d( {- F while (cur != NULL && cur->value < value)4 L7 _# O( Z7 K9 e% k9 B
{- ~' _  [+ s+ G4 X/ V* W
      pre = cur;6 \& d$ ?7 O. V# ]3 J
      cur = cur->next;
( p5 P+ w. _, Z }: ~2 G. k# k' b1 [

( ?. a, Q6 y  E5 I New = (struct Node*)malloc(sizeof(struct Node));5 g9 [3 _; j! c) {& c; G; a
if (New == NULL)
9 ~% a" [) _3 T+ P; R" G {5 r0 Y1 Y. n. M" `# `
      printf("内存分配失败！\n");; H3 J% D. X" q* I0 }
      exit(1);
5 g1 {. C' h  y% y( p  f }
7 j. o8 K$ i; f/ Q" \ New->value = value;: ?$ `8 s# b# U% i4 b* k# K) ]
New->next = cur;7 Q# Z- h  {; b- {  Z4 E$ i* I
4 D7 Z( N! E( H  B% ]. c
if (pre == NULL): L$ s- [! d, H) z! a$ E
{5 q& i6 k' j; P; O' G% U7 c
      *head = New;
2 T. p( J. I7 f/ l" H( S9 O }8 D# O2 |& |7 }% ^7 c$ _6 E# {
else! \9 ^$ z6 P3 s5 v9 D& q8 s/ N, K$ P
{
$ J$ |. g& ^: {! m8 B4 g! x  X       pre->next = New;
( x+ r8 e9 V: v1 _ }
1 b# P8 E6 Z. u9 F3 [}
, h/ m* _: {; r; J0 b
* J+ {7 }/ S3 P5 Q# H0 y7 B# cvoid printNode(struct Node* head)
+ e; I" D/ Z) R7 R5 F/ l8 b9 S{
$ ^% m% _* [3 t, m9 P' \, G) }( E struct Node* cur;3 e- v9 u4 Z# [1 I7 j* b

4 f$ F0 ^- P% Z" i% t! G  x cur = head;) x& m& Z# O( I) `$ h
while (cur != NULL)6 D0 G0 Q9 @7 p' h2 A
{# E( T* W2 Y: {  m/ H2 z
      printf("%d ", cur->value);( F& O. D: @! f3 X* }1 B
      cur = cur->next;8 G7 d5 t4 l* w" A) T) j( M7 k( k
}
8 |( R0 A; N, V; i& \ putchar('\n');3 F4 z# p3 _5 A/ A
}
' w8 b, @9 H5 E# @" c; `: X) c
% H. J) c+ X9 O& P6 c- Iint main(void)
* j8 U5 B4 H& e1 [4 J9 C9 h$ e{. i( L' e% w5 t+ z, t
struct Node* head = NULL;
* i' p$ B* B- o! T; l; K& r. d int input;* p( I4 V& _) Q  Q6 Q

! `  W% Z6 B# T7 Y+ w printf("开始插入整数...\n");
( w$ A9 e9 v5 x while (1)
7 k, W$ t# a; o( @ {
" w, Y4 z. a6 p3 d/ f! `# f. s8 D% e       printf("请输入一个整数，输入-1表示结束：");6 z/ |/ f) R3 J2 N8 `! d- A
      scanf("%d", &input);/ T" S7 a, s; a3 C* T( U
      if (input == -1)9 c1 M. c! n7 \1 B+ T/ |2 h, H
      {
4 @  j8 y5 e: Z$ t% N. `' r          break;( @: E5 [$ M% n5 m. y1 s$ R# v
      }
9 h, L3 }2 c) z/ d. |, r8 s       insNode(&head, input);1 b5 m; x4 ^3 A  k
      printNode(head);
8 W4 t& u+ T- [ }0 F' q  i  G! ]- t" z: w! m  y1 T- l1 e8 Q
( c1 n; M$ m1 a/ ]  [" m' G
return 0;- ~# m) M, z2 \' Z0 X+ M
}
运行结果如下：
//Consequence 03
$ q4 ]# \; z. A; z开始插入整数...
* n! Z/ q& r# U" J& x$ Y" h请输入一个整数，输入-1表示结束：4! F% B, E8 i' c1 M1 |2 g2 O6 ]
45 N' r/ Q  A$ J$ ]4 L; f
请输入一个整数，输入-1表示结束：5
8 q; P* s* D/ h# g. B4 5
1 h; T8 N& }  ]( `8 d请输入一个整数，输入-1表示结束：3
# z) {1 r0 l  J  p* B3 4 5% v. ]. ~* o. H5 |! L- K' z
请输入一个整数，输入-1表示结束：6# N; o6 d  j! [, H
3 4 5 6$ @8 }" g1 G' ~4 a/ `6 U$ {6 G
请输入一个整数，输入-1表示结束：2
; }9 H/ l: M4 P! F! @9 x2 3 4 5 6: j" M# k! v# P9 I, N
请输入一个整数，输入-1表示结束：5
# d& ?/ ~" t( Z( [7 v, H) n2 3 4 5 5 6
) S( ?  Q' w- o9 s请输入一个整数，输入-1表示结束：1
$ X6 m; B6 }8 F- P# y" G  `1 2 3 4 5 5 6. ]0 V  v+ ^3 i$ D, o! V! a
请输入一个整数，输入-1表示结束：7
5 y( {1 O2 d) x- ^1 2 3 4 5 5 6 7' {& j$ ^: l; [# g5 i3 H, c. M
请输入一个整数，输入-1表示结束：-1
删除结点
删除结点的思路也差不多，首先修改待删除的结点的上一个结点的指针，将其指向待删除结点的下一个结点。然后释放待删除结点的空间。
...
0 J0 {, z, I5 P3 v0 m% hvoid delNode(struct Node** head, int value)
! K9 X" B; T8 {( A) p, F1 T{
3 S1 W. {) f* C struct Node* pre;
- j4 ~5 j! C# g4 ~5 e* A. j struct Node* cur;4 S9 }* q  C1 s1 l8 [, G: t: b

0 F& g, H7 p9 y cur = *head;: L; I; P# ]+ q: P
pre = NULL;
* b" b9 W/ @0 t& k! s. e while (cur != NULL && cur->value != value)
) u1 B; E" z/ C/ N' U( T0 B$ k( b {& |2 D9 b3 v% E: d3 f6 I
      pre = cur;
/ C' U6 h) P+ L+ e' [' I       cur = cur->next;
4 @% C5 `, f. [+ c2 f) D+ E  ?' T }
7 w* {$ `' i. i* Y# ^; n* b if (cur == NULL)1 |- u5 q; y0 P+ h/ Y2 Z+ k
{
( g) \( C; n5 m8 j9 R# j, _       printf("未找到匹配项!\n");
5 i8 P, _# f% C9 |       return ;
& W( T6 D4 t2 i; }) Q }+ i* v8 j1 t4 M/ F0 O
else) Q' Z8 |" s  H1 x' ^) a
{
5 X( r0 d$ b! ]! \3 l+ V       if (pre == NULL)
5 y: u$ v  W4 c8 c7 E4 u       {* D6 C( s: ^8 _$ g( P/ S! ]
         *head = cur->next;& M' j3 j) t* [1 d7 m
      }
: {. b9 C7 |: i% e4 E) C" N$ D       else
# r/ o4 ~$ A+ k1 H, ], F1 Y       {1 v0 h8 ?. Q' @4 W4 M
         pre->next = cur->next;$ l( v0 Z1 k* f" X/ O, b
      }
6 N; V1 P' k: o& b1 A: p       free(cur);
: H: l  U* R2 S( S. W; e }
! ?+ W. J" T& N}
内存池
8 }+ c' `. h& s! @2 _; z

C语言的内存管理，从来都是一个让人头秃的问题。要想更自由地管理内存，就必须去堆中申请，然后还需要考虑何时释放，万一释放不当，或者没有及时释放，造成的后果都是难以估量的。
当然如果就这些，那倒也还不算什么。问题就在于，如果大量地使用malloc和free函数来申请内存，首先使要经历一个从应用层切入系统内核层，调用完成之后，再返回应用层的一系列步骤，实际上使非常浪费时间的。更重要的是，还会产生大量的内存碎片。比如，先申请了一个1KB的空间，紧接着又申请了一个8KB的空间。而后，这个1KB使用完了，被释放，但是这个空间却只有等到下一次有刚好1KB的空间申请，才能够被重新调用。这么一来，极限情况下，整个堆有可能被弄得支离破碎，最终导致大量内存浪费。
那么这种情况下，我们解决这类问题的思路，就是创建一个内存池。
内存池，实际上就是我们让程序创建出来的一块额外的缓存区域，如果有需要释放内存，先不必使用free函数，如果内存池有空，那么直接放入内存池。同样的道理，下一次程序申请空间的时候，先检查下内存池里面有没有合适的内存，如果有，则直接拿出来调用，如果没有，那么再使用malloc。
其实内存池我们就可以使用单链表来进行维护，下面通过一个通讯录的程序来说明内存池的运用。
普通的版本：
//Example 04 V1& P5 w7 b. [& p' i
#include <stdio.h>' i5 L$ H" a4 @; C+ R" k
#include <stdlib.h>0 B! o8 _, H. P, `
#include <string.h>
8 Q/ f  U4 l8 R6 i! y! R7 [! u* t+ Y
struct Person
6 j  l* f2 _2 O1 P( f" A{
% V0 k6 _8 q6 H, M char name[40];  i7 [- L! K' K) k, j/ ?1 f6 h
char phone[20];8 \9 e2 ?3 s- V! o6 G
struct Person* next;
8 X* _, K) S/ U* v$ ^3 Z  K& h};0 l5 `. X% T* X' V* D
' p  I" k# m& C+ X" [
void getInput(struct Person* person);& {+ r) g( N* ?. G0 D- Z
void printPerson(struct Person* person);
' E2 G% G9 x  K. Avoid addPerson(struct Person** contects);
5 k: j2 X' S1 J3 Gvoid changePerson(struct Person* contacts);
; D! K( _7 e  bvoid delPerson(struct Person** contacts);
! a/ R9 [" w/ [7 N% {struct Person* findPerson(struct Person* contacts);
) p; t" y0 \) j4 e( b, R' dvoid displayContacts(struct Person* contacts);' x1 X. ]6 a; U# v0 G
void releaseContacts(struct Person** contacts);
8 O( d7 Q' k7 t  m1 v) B6 t9 p
0 [. |" g9 ^1 y  Z+ wvoid getInput(struct Person* person)# F$ B: |$ \9 T# M7 W# J! E
{6 _" k4 z5 l1 L! }3 Y6 S9 p1 P' M
printf("请输入姓名：");8 G( [* q9 s* p( \! @
scanf("%s", person->name);0 l8 i$ p; _4 x% v! M8 U
printf("请输入电话：");
; D/ G; B" y1 H8 Q* R7 e/ Z2 S scanf("%s", person->phone);& X) B& H# v' Y$ R# ?  C
}; m6 H: b6 R& v% E$ k
) e* s( C* `5 X$ D! c9 E
void addPerson(struct Person** contacts)3 {+ Q# D$ p3 K' F) K7 @
{& T" U, K! `5 e9 _, K
struct Person* person;& z9 G0 ]; k7 L+ K( w0 q% ]
struct Person* temp;8 h( M) @/ r8 o! g, f
; ?: P/ W; b" O/ v  J; e5 R0 U/ z: \: i
person = (struct Person*)malloc(sizeof(struct Person));- w, x. Q( r8 n8 W  u8 m- w3 [
if (person == NULL)
, M' ~1 M  @. M/ {' K1 C {- ~$ S0 e3 p* O
  printf("内存分配失败！\n");8 \; k$ v& p. T, M, H) f
  exit(1);8 l* G/ m% F# p- }; _2 n/ N8 |0 y
}
8 @, b4 G1 n+ w. j/ O, ?4 i& B# {. L
; Y9 p& S+ \/ w9 e2 C( x( G getInput(person);
; K* h  {, Z- v( r( m: }  Z9 i' x  `- L" R7 j
//将person添加到通讯录中
. o& z; k: J( v) h if (*contacts != NULL)
( k3 }9 y" [+ ~; Y0 [ {/ m5 h4 b- e7 ?6 E9 `: l
  temp = *contacts;/ h  h' r$ N3 I/ x6 E! b- `
  *contacts = person;( R( [3 k- e# A! H
  person->next = temp;
* w+ K5 G* l: N }2 s" i5 c1 l) m. D
else
( e! Z; E6 T& d) P3 o) ^ {
4 E& ^0 R; [8 c# O9 _  *contacts = person;% u7 _4 H: A0 Q2 C+ F2 T+ E  S
  person->next = NULL;
) B, X) E( Z! {. j( q7 ^5 k1 P5 M }
4 j5 _7 \! f, L" W}
  ]) _; a7 @2 ?; f- d+ O3 n
) h2 N3 z3 D" \" {. Vvoid printPerson(struct Person* person)# P+ M4 D3 b" A( l' P7 o
{
9 A. V6 A, G# e printf("联系人：%s\n", person->name);
0 ?% I& M3 `$ t* c; `' u' z printf("电话：%s\n", person->phone);; @& v# m1 O& z/ R
}
8 @9 C4 ^& j6 Y7 w4 S, a5 `" b, L- [$ N
struct Person* findPerson(struct Person* contacts)- s( o# B1 y" I
{- A# x, J7 Z1 t! [; \% `
struct Person* current;$ W, E6 r+ k: n
char input[40];/ k3 g; [( B& m

/ C' v* j! i, |( M printf("请输入联系人：");
6 {0 j5 r) T1 \/ d/ [# c scanf("%s", input);( N! L& M5 b4 L( F% ?/ q1 x. E: w

) C$ S$ M' h+ J+ ^$ ~+ I4 K& G; x current = contacts;
5 L. B  p' `% m while (current != NULL && strcmp(current->name, input))1 O# F) }5 w+ P% N# k% D& G5 J
{
6 Z1 x8 _/ i& R# H& Z  current = current->next;
8 D; [. {8 Q, S }
7 M; ?7 ~  J; s/ @& P; O  C4 j! @$ _4 C
return current;
# ?& O. v) a: E- U}
) P$ i% s; |% g. \; l4 N+ r0 c* I0 d* \8 ]! l
void changePerson(struct Person* contacts)
- n: R' b0 e* I) T4 \2 `0 l9 W  H4 Q{' i! C1 \" {8 r. T; N3 e! C$ C! t
struct Person* person;" k( }- h9 W# |! M/ g& J

( D# A8 K. j  A& S( v! [( I person = findPerson(contacts);  w) i! v6 y! |" T# @$ r0 b2 G
if (person == NULL)
/ L/ @  o$ X7 Z, E8 \ {
9 l9 _* n! y% v" d: l  printf("找不到联系人！\n");6 x) e8 U5 F9 T4 j- Z) {2 V
}2 ]6 C% v& `! s# f  k! q& _
else: u3 h1 ^+ u+ @; r  V  I
{
; u3 Q" l7 d! [  printf("请输入联系电话：");. @5 @: N1 U% e) r& [9 v2 I
  scanf("%s", person->phone);
- [; p; ?" G( i( W: | }! }# S+ N5 }$ X9 _( f
}
7 X: @. B) W& @2 J. J1 N. Y! x
4 c5 O+ O! ?" _# e& {9 Hvoid delPerson(struct Person** contacts)
  ^# N0 \) @# J$ ^$ {  v* k, U{' s  p8 x  o5 R) E" p
struct Person* person;
& U$ i7 _8 b. w: f struct Person* current;
3 R7 `( f+ Q/ v3 h; q, Z$ C8 _ struct Person* previous;0 N+ _; K& x' B) ~0 k( b
& j) M4 t5 c- I' J' o; n
//先找到待删除的节点的指针
6 u' p5 }1 E4 |& T7 I person = findPerson(*contacts);( f% M9 \2 b7 i. \9 j' D! V5 h* J% ~. M
if (person == NULL)
: j! D2 j8 k* V' g2 Y* D2 V {% g, G) g$ O7 {  z; v: ^* s2 M
  printf("找不到该联系人！\n");
5 L: W- [/ w6 b9 y9 w5 Z' y2 f }
$ V; h( B. ?' }! ]; J. e- x else
+ ]9 z& S9 W5 B+ N {' w  q' X  e$ U0 k" V+ [, X
  current = *contacts;
& v, F0 o; R" u  \0 g  previous = NULL;2 C$ m/ N& J2 g: `* L9 b  ~! z) D
  L7 I, G5 N( U2 }* a0 A
  //将current定位到待删除的节点0 M0 _4 [3 F" a4 j8 \6 g
  while (current != NULL && current != person)
  `7 j( u6 h7 @9 M) d  {2 N2 w& \- I6 k6 U; A1 Y4 |: Z
previous = current;* f( Y' |: c8 B. y
current = current->next;3 f3 J; q, C  f% P" w! I4 p. p9 U
  }
9 Y2 j! e. U) `4 _! }7 X2 G5 ?  R# t3 ?
  if (previous == NULL)1 ^( _/ b* f9 n+ [8 v
  {
  y  ^; q) I! i* C: j //若待删除的是第一个节点
0 F# [' f. s$ r *contacts = current->next;* a: X1 X( V2 V9 H+ f% C- Y
  }
5 p  `, `+ G/ @, Y; V  else
; b7 W& |+ W2 S6 }* |; P  {7 @7 U/ N+ P$ k9 [4 O
//若待删除的不是第一个节点9 }/ {+ d* r3 P. v- D6 a" H: r
previous->next = current->next;* k! l0 m% t- R0 j$ H' u" p
  }
2 e6 [' j4 Q( u6 Q! k9 Y; {0 j- Y8 a# ]3 H  n; b0 E( _9 `3 \
  free(person);//将内存空间释放
+ {4 I( s" K4 m2 [* r  Q. D* K }
}( H: c# {8 r. K: g6 K
1 ?* c& V6 u2 x
void displayContacts(struct Person* contacts)5 [  U5 b7 [- ^- B- ^
{* {9 i* u' n& C* v
struct Person* current;/ D% Y2 p9 @7 ^5 l7 E+ U) k( _

$ b+ _0 H- C0 z/ U3 R9 D3 h$ d current = contacts;: X; v$ S& G, A( I" k
while (current != NULL)
2 J# O2 U8 E4 s, N7 u, ? {  i2 W) G  k% Y4 P
  printPerson(current);( }# b" K8 _& s/ ]* [4 O* C+ m' w
  current = current->next;
( K; I3 Y* A  D% @' z }
% N" L3 p* Z) t}% g$ C; r  y% m) P) ~
6 |! l7 q3 f# k
void releaseContacts(struct Person** contacts)6 {+ F: y. v7 b: y$ I  _1 L
{
+ L& f; c1 v) c+ r struct Person* temp;7 h9 i- p* [: A3 Z

4 Q0 j- ~& y5 W" r! m* g while (*contacts != NULL)- I0 M0 F2 g( h
{# U/ f# F. |* B5 ]2 l
  temp = *contacts;
$ {3 E. G6 J% ]* }% G" f* T, u  *contacts = (*contacts)->next;
, K8 ?! ~( y0 y% z7 {# K/ C% p  free(temp);( T% ?# _) s4 H+ n: ^0 U. e
}3 S$ R0 R9 o; _: ~' w; y
}
$ d$ k, t8 Z" Z6 o) w3 E4 V! I
1 Z( p1 k+ t: c0 U! c+ ~int main(void)
$ F; H3 A1 h% C4 T! C{
- F. C  Z+ t% l% j int code;
# }# B; i9 e, d7 Q) u/ }- j struct Person* contacts = NULL;
! L: J. u- {* Q struct Person* person;! ?4 u5 ?. U: B; }- l3 j2 c3 q1 K1 f( d

4 i: ~( B! L4 K$ f& Z printf("| 欢迎使用通讯录管理程序 |\n");+ B' p2 T3 y3 S' s: e# R
printf("|--- 1:插入新的联系人 ---|\n");
& Y  `) ^6 O4 h2 w( n printf("|--- 2:查找现有联系人 ---|\n");
4 W" H: u$ n$ `7 K+ F printf("|--- 3:更改现有联系人 ---|\n");
- t2 G2 X5 ]! H( E# \/ i6 e7 d: } printf("|--- 4:删除现有联系人 ---|\n");' r3 j  m* l8 _( r# K; e! w
printf("|--- 5:显示当前通讯录 ---|\n");
$ `$ D& c) r- Y  q9 H5 ] printf("|--- 6:退出通讯录程序 ---|\n");
% I  k( m/ i4 N6 m
) B) J8 |# _) Y% P while (1)
6 e( K$ P+ v$ @' `) \7 m {
, V# G9 o; |( l! e1 G$ N7 z7 ~  printf("\n请输入指令代码：");3 n5 k- w/ @7 Q
  scanf("%d", &code);$ e5 b) X9 j) S0 t
  switch (code): h+ u7 Z1 L- Y
  {
6 H+ M7 ?" I- t0 n% o  G  case 1:addPerson(&contacts); break;1 I% h* y" K4 D: {) Z
  case 2:person = findPerson(contacts);8 N1 O& I. x3 _
if (person == NULL)+ ]3 l: ]) W1 y" S
{( p( ?4 G$ \1 c3 M1 b6 l0 j
printf("找不到该联系人！\n");
4 j/ M2 e% m8 P4 [2 ~: I }
. S5 a  j9 W5 T) C% z else
/ `% x  j  k& l6 U {% \+ c6 V3 D$ m% ~
printPerson(person);
# E) I/ x& G: n3 } }, [8 J2 r; A" t  j% l1 V3 g
break;) x4 }$ k( @8 W0 _# I# d  f
  case 3:changePerson(contacts); break;
4 e, S9 ?: P2 P/ K8 ~6 W1 O  case 4:delPerson(&contacts); break;
. t0 B6 l, T! \& G2 V  case 5:displayContacts(contacts); break;6 J8 S* h) E  z* d6 A! N
  case 6:goto END;
* b: H- Y; d0 T, V. z) r% y  }1 S0 Z, j# W7 s+ ]/ q- p7 Y" k2 |
}' r! \0 `$ U2 a8 M6 ^( }' t3 z
- [6 g% {: \4 L9 X/ ]6 f. b
END://此处直接跳出恒循环
1 N, k; P. G( W1 f* k% U' x4 ]3 R0 S releaseContacts(&contacts);+ ?! p2 ?% w# k( t! ?7 O) a2 p
  e1 R2 i0 T$ l  F- R
return 0;8 O" p; a$ \- p

, ?5 w5 I7 Q8 O. B9 e: E}
运行结果如下：
//Consequence 04 V1
, d+ n7 q0 }# v( y# d| 欢迎使用通讯录管理程序 |
|--- 1:插入新的联系人 ---|/ \  Q5 I, x1 {. i
|--- 2:查找现有联系人 ---|5 F& a+ G4 O/ z/ |6 Q0 \
|--- 3:更改现有联系人 ---|# R: M- R" t8 R; M7 W
|--- 4:删除现有联系人 ---|9 w, G; h* l: }  k
|--- 5:显示当前通讯录 ---|
9 `) i5 g( V4 U  O5 v. r4 g|--- 6:退出通讯录程序 ---|* S8 g4 z3 k9 w; D
$ [3 D* l9 W4 H. R% ]; u4 Z; ~% C
请输入指令代码：1
% M" I# Y3 s  M" z9 ?请输入姓名：HarrisWilde3 L& G; c8 }' t( N' S6 a& g4 d, T
请输入电话：0101111
$ A+ k0 u) ?9 q% `9 m
+ L( Z  l; G4 N' X7 T& {请输入指令代码：1
# h6 S- s. L" j6 }3 j2 G8 l7 c0 h请输入姓名：Jack
+ c# d, A2 d/ S请输入电话：0101112
+ D$ b( z* e5 K1 u8 u# Z0 b. x4 |! ~) k) @
请输入指令代码：13 j9 Q! V1 U: E
请输入姓名：Rose
7 H5 P& w0 ^9 ^3 Q; N8 h2 k% `请输入电话：0101113
$ {+ c! S* t/ P+ D6 c$ Z
- N4 y2 i' r% W0 j: w4 ~请输入指令代码：2+ j/ c# E: ~* ^$ L* c
请输入联系人：HarrisWilde6 f# }3 E( _4 X( R1 ~3 o. U$ C
联系人：HarrisWilde3 Z' i; o" T( ?4 L% {8 d0 B
电话：0101111" W  G  E/ w% p5 C2 o
/ R" y5 e3 M$ o7 |" |/ y3 h% g
请输入指令代码：2: t( _0 B" i4 W4 f3 M9 [: [
请输入联系人：Mike6 k. {- M3 i; _- t: d( h+ x5 I1 o
找不到该联系人！+ \4 [- L9 T. _8 `4 w$ U
. r- @" D9 S5 o7 F& Y
请输入指令代码：56 q; J/ M& \9 S
联系人：Rose7 {* p; T5 U9 I9 M6 g
电话：0101113
! ~- T( Q( Y$ T4 k+ ?3 p1 d  _0 [( ?联系人：Jack
- f3 l9 b% r+ w$ A4 d) _电话：0101112! t7 ?. g8 g# s; F0 Z
联系人：HarrisWilde; _6 Z; ~  R# k0 H# @9 q; R' y
电话：01011111 h3 j: p# `- c& p2 t4 m
7 d' \6 E3 Y( o! R
请输入指令代码：3/ n' n* h) H7 }2 K
请输入联系人：HarrisWilde
3 }$ O& t% r# U) B& q请输入联系电话：01012348 j. M1 U8 }7 g4 J) ~4 O. t

; t2 a  w; Y9 z; p: Y请输入指令代码：59 z" }* x; Y* C6 ^) G. j( ?
联系人：Rose: @) N$ G1 e$ ]
电话：0101113% d; {) C, ~# C( E6 |. |1 d
联系人：Jack: w) R1 q; A3 V4 V
电话：01011126 d$ a, E+ o, B( p- w! n" t9 b3 e9 G" M7 E
联系人：HarrisWilde
, v% P& b( k8 v4 ~! o8 f5 }3 j电话：0101234
7 p& p6 h9 v) K0 C$ K- ]8 f5 ]) h2 @  O1 L
请输入指令代码：6
下面加入内存池：
//Example 04 V2
6 R& U, b8 Y1 c#include <stdio.h>
) M& V$ Z2 V! L' T6 t, ~#include <stdlib.h>  v" [6 x' v- z
#include <string.h>
/ c. ^! C7 G, R; m
; b) I. s, z5 I. g#define MAX 1024
( |( s% B* z' k( R! J% H& g/ ?- s$ |0 m* D% C9 X: ~! U
struct Person
7 ?4 r  S: I! ^# ?{# x$ H* j0 S! Y9 G& ?
char name[40];& }0 P; E! U# \& y/ w
char phone[20];
: K! W8 T( V; n: P. R struct Person* next;
( i. z7 X! S4 d; s8 P$ q) u};& x3 R  W/ T! P8 k

( [' \, }- B% c. @. m: K, b, D* I+ \struct Person* pool = NULL;' t: ^4 y3 j% r: I+ N
int count;8 {' l4 [: C: H' W# |7 ^. c6 g+ Q
1 F9 O9 I3 }- y4 l- v. c1 D
void getInput(struct Person* person);
' [# f4 L' P  |8 d/ @' jvoid printPerson(struct Person* person);7 ?7 V: n" A8 ?( O& k+ a
void addPerson(struct Person** contects);: t6 l  x& I/ i/ l/ P& C' [
void changePerson(struct Person* contacts);
+ z: b7 l( M* o9 t# |void delPerson(struct Person** contacts);: V' X; ^/ b) w$ h& K% o$ ]  M& j* o
struct Person* findPerson(struct Person* contacts);
  R: a- e: f, B/ P3 Hvoid displayContacts(struct Person* contacts);  q$ S2 l' `8 Q4 I, E1 u
void releaseContacts(struct Person** contacts);  P& t# R7 M  N  Z
void releasePool(void);
- Y- y5 }5 \" C# a/ U/ P9 R+ e( Q! ~9 T0 S0 b% c
void getInput(struct Person* person): W" \: x* o8 a
{
2 \9 D9 H7 z) f4 p printf("请输入姓名：");5 D: I7 ?& q$ T( a: H7 s3 G
scanf("%s", person->name);
. }' v, I% X% k printf("请输入电话：");
1 w$ }5 `( X# d% E; J scanf("%s", person->phone);
: f7 n/ y6 C5 D6 `' h  H}7 o7 {9 R1 q/ B

) }+ u. E, [0 pvoid addPerson(struct Person** contacts)
4 @' J. O" {, [' L" L6 B2 _{4 i7 d' N2 B2 k0 r. w' ~" n3 u
struct Person* person;' N! s7 a+ ?$ w# \* p7 c
struct Person* temp;- {! {' N, L5 Q7 i2 }9 O
! \/ c" w5 N- W# V  o+ V
//如果内存池不是空的，那么首先从里面获取空间+ A4 a! H* g, r* c
if (pool != NULL)
' `; [0 O* F% G  Z2 r1 }/ z {
4 f- E3 B4 \7 F% H  person = pool;
; Z2 G0 C' U' v7 y8 O/ R2 b  pool = pool->next;
* ^( Y+ s, C8 [6 x  count--;* E" d* B& b! j; Q
}9 G4 ~: E4 F3 U3 U/ D$ O
//内存池为空，则直接申请
7 P& ~* b9 L- ^" V8 x else
; c) t6 V0 h3 g {0 r& R% l, ~7 I# @
  person = (struct Person*)malloc(sizeof(struct Person));; ]9 S( }) X" r; T6 G. `& O# J% }5 w( \
  if (person == NULL), k1 F6 E' n5 f' Q- T
  {
! o( Q; u1 a6 ~( N) V9 p0 ? printf("内存分配失败！\n");
exit(1);) @! n8 b1 A2 r* D$ Y
  }, C% K' S; U1 \; B: \5 l' ?- j
}8 L* P& N2 B: d' `+ E. ~; i1 M
% |  ^% t0 U" @" H- @! n7 G5 R, ^
( r4 {' c. t- A, M, K) F+ ]
getInput(person);
- h$ V. a. d9 n
- @3 m5 n7 T- ^0 ^! D' Y1 O% q //将person添加到通讯录中8 J: V. E& H( e7 [  h4 U
if (*contacts != NULL)
8 D/ E9 G  n' J$ P$ v; n  ?  ~ {$ l& S* p; d" [3 a1 h
  temp = *contacts;  _5 x5 F7 x6 |$ D( h3 c
  *contacts = person;7 H- m- \- Q* g5 T/ q* O
  person->next = temp;
% L! I0 K; S8 D' [ }6 g$ ?6 d. U. M' O. L/ T
else& J1 J! z: j$ i
{
- N2 w+ G. f  p  *contacts = person;. i$ [& y5 B1 p2 F: L0 |+ e6 p
  person->next = NULL;* J; z; i2 w/ `' G1 `& ~
}- e1 J- y7 k* |5 k2 a) m' M
}: v) ^7 H* X5 X9 h! X
* Y1 Y, a, r" @
void printPerson(struct Person* person)) W& _5 p1 Z+ N5 b9 g2 o2 Q8 b6 \
{
5 ~7 L9 D  l2 [ printf("联系人：%s\n", person->name);
0 L* ~* \2 y. p( a9 Q printf("电话：%s\n", person->phone);
1 ~, m6 R/ c) i7 |* F5 {}
* x: W* ?+ l9 q1 W! f8 U8 y, P% N3 \0 ~! P/ X+ ]" I
struct Person* findPerson(struct Person* contacts)
7 V5 P! s6 @/ l. s6 `3 k/ U5 M{
: G+ \3 V- ^2 E4 N8 @ struct Person* current;2 @3 l1 N2 h6 k4 b0 t2 m+ }
char input[40];/ C4 X* ?2 k( T6 d7 B

$ ?8 G1 s4 C& ]) @. z printf("请输入联系人：");
( u3 O+ H% q! {2 W6 \" S scanf("%s", input);1 Z$ _  M7 |8 B( Q* b
4 d9 i. i* D2 d
current = contacts;) d" G+ M6 i% x' i
while (current != NULL && strcmp(current->name, input))7 ?; s+ p3 e+ T; L. h- w& b# A
{" U5 R6 u6 g9 ?( B
  current = current->next;
2 T" e& _8 H- b& h }
  i/ U  H% E0 C" F7 |8 v% V. U7 ?, J; J; b
return current;) c) {, {1 x( ^8 F$ ^
}
1 o: G* J9 V5 U  t1 V3 }0 t) h5 m4 s# H7 f# U( A7 y8 v
void changePerson(struct Person* contacts)
  s/ i4 f* T5 B) \* [' M{
" V* V; r& r6 v5 f. `5 B- Y* ] struct Person* person;3 Q# q0 f9 j" ^" b/ X& D
" E9 W  ~: C* ^- C& ?! `
person = findPerson(contacts);
; e2 @7 f2 C, W/ r5 j! r7 ^ if (person == NULL)6 A( A6 [* {4 q  X5 @4 P
{+ m$ d2 `+ ?1 n0 [
  printf("找不到联系人！\n");
, m# V* A' `  v5 ]/ s3 M% S5 J }
( v& V9 \$ R, A+ Y  J& j$ U8 I' P else" Z" Y6 ?0 u$ X1 g- ^5 K- s' s
{: O0 w- B$ E) t+ ~
  printf("请输入联系电话：");
' }+ W( d) g. I" a4 V  scanf("%s", person->phone);" ?& x. W, [  w" {8 z
}" F5 p+ P$ D1 `: |, z! Q* Y. G1 w
}
+ A2 q2 b6 f! u* ^" W% U) x, t6 ~9 D8 |( z2 u( c1 ]
void delPerson(struct Person** contacts)2 |' |+ s  k& w. R
{
! ^' c/ L9 u, W struct Person* person;3 M1 p. a2 s! `$ H, A8 [& ?
struct Person* current;! W3 s8 w. J$ ~
struct Person* previous;
' o3 ?0 v( c8 u3 C4 ]4 d struct Person* temp;/ ^4 c% D0 U# k7 w
{; I. |( ]& t9 D

$ |5 r' F, _6 W' r0 K };
, ~# N/ C, b! d+ c6 f  ^" T
( E7 T1 [1 q4 P& |/ X8 F: @ //先找到待删除的节点的指针
8 b0 A" C/ d& V1 m2 C% \ person = findPerson(*contacts);
" p; L# ]! {  ]" K5 E if (person == NULL)
- M4 K) G6 B. Q# g, r9 s {4 Y0 C* s! v! i3 |% {  ]
  printf("找不到该联系人！\n");
2 ?9 `0 D! D! a9 N2 K" } }
! ]) h/ m& _( C" P+ `( b& } else6 B; _+ ?( N/ W9 y3 K7 K
{3 ]# z8 o+ Q2 X8 R
  current = *contacts;) n' ]6 U; d, T0 T0 d
  previous = NULL;
5 c0 x: f) H2 T. o
! }  i9 d/ M& q" B  //将current定位到待删除的节点$ V1 R! w( j: I: r; K
  while (current != NULL && current != person)
" A, k" p7 q! H  N- e. p0 d  {
0 I- V5 F' ~# Q$ V previous = current;
' I8 ~9 @) m) p7 t0 H; x' L current = current->next;% Q8 N, U5 Q% T
  }
/ g& D  e7 P$ k
8 @' s8 _7 k+ k4 ^5 x% R  if (previous == NULL)2 N  _& B  n' w4 j* R" y
  {' V/ Z3 s" R% [5 }* u
//若待删除的是第一个节点
1 S6 o5 S3 B5 ]( h *contacts = current->next;
  }7 }; S9 W  r+ T
  else* J# J) d# }# E" C
  {$ R& m' \' ~9 N- H5 q5 z9 c
//若待删除的不是第一个节点
( {! z9 A& T1 s  f8 u previous->next = current->next;; |4 H4 a; C* C1 T& z
  }
$ s% [" Q" N& ^) @6 Q! _, o6 O  I& p# o8 J0 R# J- _5 s: n
  //判断内存池中有没有空位
( g8 ~, Y( @7 R- V4 h, S  if (count < MAX)
7 Y! [* ]# l+ ~2 a* F+ k  {
' X+ I% {# Q/ r7 D' _ //使用头插法将person指向的空间插入内存池中. s5 _( h; ?; a# W% y
if (pool != NULL)
9 l) h" A. ]( S1 }4 ^. k# u7 S9 N- E {/ [3 Y% G* \7 c" g- Q" v
temp = pool;5 K* r/ x5 `4 s) Z) P  @9 e
pool = person;6 m6 C- Y% \8 y- |+ |3 }" N0 _
person->next = temp;4 V$ \9 i  w, u, a6 X& C, S
}
+ b0 ^) Q6 Z- U* S5 i else
: ~+ B$ V0 d7 a {
$ O2 K% N' {  O" [ pool = person;* |" @5 l" H% `. |8 C4 B* V
person->next = NULL;. K1 I, b6 A" Z
}& r# H# v6 c7 Q- Q5 M
count++;5 t- h3 e& N7 T- \7 `0 D- ]
  }# J) f& ]! r, G& h+ {( k$ n4 U
  //没有空位，直接释放" d, y, S. D8 c8 U5 K- f7 r3 n
  else+ _$ g  c& j9 g% G& {2 o/ k
  {3 R5 @- M- R0 ?4 ~; I
free(person);//将内存空间释放, m2 G2 s. a( G- J" w& p/ ~
  }
$ V0 O/ f. W# O0 I }
; T0 O" ]* V. t( M  \3 `, g4 a}
1 _+ e( w& D* z' c) R( j. J+ r
, L; o& a+ m. }( L3 t6 {* K' [void displayContacts(struct Person* contacts)* n) e; ~2 I" C* k- }3 Y! x4 D
{
# u& u0 p+ j5 u5 {0 Z' e" I' y struct Person* current;2 N8 `0 [+ G! ^8 p

" c( W: Y2 B/ k current = contacts;3 [: S/ u1 Q2 T2 I2 v7 [1 I
while (current != NULL)2 |3 _) }  {6 ]7 [% b
{
. C6 E) ~7 g& v! O' L) I6 E9 p  printPerson(current);
. B4 y+ O* a! i  current = current->next;
+ U; w8 E" J( v2 D% E  \  u+ P }2 N! f1 i% u8 d- c* N3 q7 N; S
}
' J" y+ `( e& ]* B8 V
  ~9 F% [! Y9 f; D0 Vvoid releaseContacts(struct Person** contacts)
" [3 w# y( O" {( j/ u: h1 Q8 W. F{
" {7 A# F; v3 H struct Person* temp;
2 @7 U/ y% ]4 s* B4 {
! r6 q( `8 o7 V$ x while (*contacts != NULL)) E7 H4 j( J# q- Z
{. m0 z3 [1 u- |; L( Y% n0 n+ c  C0 P7 I
  temp = *contacts;) M3 K7 a9 b- f7 @" B
  *contacts = (*contacts)->next;
2 z! ]) f; k; S$ y% E2 c+ N) J  free(temp);: R/ _/ C, M6 ?% D. K
}
1 Z' t; D6 {& V: C3 n. g* I}
& d* q* u% [9 J/ k/ S. I+ {! o; I4 j1 w. E  }! F5 f! d
void releasePool(void)# H/ P/ I" I% E
{
: ^. p7 a/ W5 \/ P) k9 E3 }& f struct Person* temp;- m3 G& r9 a0 I: X4 H
while (pool != NULL)$ V. p6 l7 s/ v9 H
{! I& u* b: c" T
  temp = pool;8 S8 Z+ g# ~2 g: h. g
  pool = pool->next;
/ U: @0 X) e1 T; U. {/ v% R  free(temp);; ]1 P. b# a6 S+ e5 Y
}3 P" ~- `6 T' i
}
% \0 @9 }; x* h! m4 k) |& }8 M! i% ?5 W; Y
int main(void)8 i2 G. F, a2 o7 |
{1 n9 ^3 l2 E# P; @1 O" g
int code;8 l/ L* ~2 H8 w) C" Y! U# C( p' D6 M+ ^
struct Person* contacts = NULL;
" W4 k7 w$ P) b; v2 r9 d/ z) n struct Person* person;& u& x2 q7 L5 y8 T5 g4 _
  }" c# ^9 y; g( @( D' c7 n
printf("| 欢迎使用通讯录管理程序 |\n");9 @6 n8 P- J( B4 v. Z' g7 x6 c" a
printf("|--- 1:插入新的联系人 ---|\n");
% H3 Z! y7 q1 `9 j- U printf("|--- 2:查找现有联系人 ---|\n");
3 p$ I9 n+ F  q4 q printf("|--- 3:更改现有联系人 ---|\n");/ d( _# c: L& _2 e
printf("|--- 4:删除现有联系人 ---|\n");
5 }3 T: b! u0 J$ B( i) F' O printf("|--- 5:显示当前通讯录 ---|\n");3 [# C& ]7 u: J9 v1 [6 J3 D
printf("|--- 6:退出通讯录程序 ---|\n");2 N" v, C( M" ]# {9 \

+ y5 ^8 [8 h% B$ ^1 A8 M( Z, U; D% C while (1)
5 j" C* L, \+ e) U, L4 W( U {
; r* A+ v$ x! p. Z+ _3 a  printf("\n请输入指令代码：");- x: w' |+ b9 @
  scanf("%d", &code);
$ a4 J% d; s$ W( n4 [& M9 D  switch (code)
2 p" s/ t3 q+ j0 m  e+ |  {: z5 Q2 L; @! l0 @. X$ g* `7 K
  case 1:addPerson(&contacts); break;. \3 [0 q5 [: ?. X" o- F
  case 2:person = findPerson(contacts);4 a/ B, d5 b# k* h* |! O
if (person == NULL)! ~. ^2 _$ W4 L0 d7 p6 F8 K
{
8 P1 l6 N+ `1 `3 i6 l  \ printf("找不到该联系人！\n");2 z* }  h0 L/ \- G; t8 D
}
% e5 [% U  |: @- x* R% V/ | else$ q+ M; V6 e/ i6 L- Y) {
{+ F& @* l9 A: r) ]! H2 ^+ v! Y9 p
printPerson(person);, b4 D/ p# j6 M$ C% [6 t, C9 h
}
! O# V) H. @4 K: p+ }( r break;( N  c( M) ^/ a, U& n9 y
  case 3:changePerson(contacts); break;& S) F* ^, \6 _4 h# b) E9 z
  case 4:delPerson(&contacts); break;+ t4 U( H: f1 @* C
  case 5:displayContacts(contacts); break;4 ]( K9 d4 h  u; s9 N4 }
  case 6:goto END;# l( k: Z9 J  z& D
  }1 Y! m1 C2 t3 n
}
  j% D/ h0 \6 b# P
7 R- r, }( K, |! P; g- FEND://此处直接跳出恒循环  h# ~& C9 L0 `2 b) s
releaseContacts(&contacts);
: s, b3 n$ w/ s( ?5 [/ l+ q releasePool();' g' H7 |: [7 g5 B! p* n
' c' X& W, u) k) O
return 0;
/ @  b3 I# D# r6 C- \' n# K0 C# p5 K" W7 T/ C8 r- E
}
typedef

5 K8 K4 W& }; ^, H7 E+ Q5 J7 n5 Q
给数据类型起别名
C语言是一门古老的语言，它是在1969至1973年间，由两位天才丹尼斯·里奇和肯·汤普逊在贝尔实验室以B语言为基础开发出来的，用于他们的重写UNIX计划（这也为后来UNIX系统的可移植性打下了基础，之前的UNIX是使用汇编语言编写的，当然也是这两位为了玩一个自己设计的游戏而编写的）。天才就是和咱常人不一样，不过他俩的故事，在这篇里面不多啰嗦，我们回到话题。
虽然C语言诞生的很早，但是却依旧不是最早的高级编程语言。目前公认的最早的高级编程语言，是IBM公司于1957年开发的FORTRAN语言。C语言诞生之时，FORTRAN已经统领行业数十年之久。因此，C语言要想快速吸纳FORTRAN中的潜在用户，就必须做出一些妥协。
我们知道，不同的语言的语法，一般来说是不同的，甚至还有较大的差距。比如：
C:
int a, b, c;
& W% u5 y/ o( G, Q: Q) Ufloat i, j, k;
而FORTRAN语言是这样的：
integer :: a, b, c;. z$ d3 }) k- L- h4 m& C! v
real :: i, j, k;
如果让FORTRAN用户使用原来的变量名称进行使用，那么就能够快速迁移到C语言上面来，这就是typedef的用处之一。
我们使用FORTRAN语言的类型名，那就这么办：
typedef int integer;
; u! v6 y$ o* V' A, ~% r( ptypedef float real;% G6 d- Q- C+ i
1 B% A% E7 A* h" q8 v7 L
integer a, b, c;
+ i( K$ Q2 W! D' Mreal i, j, k;
结构体的搭档
虽然结构体的出现能够让我们有一个更科学的数据结构来管理数据，但是每次使用结构体都需要struct...，未免显得有些冗长和麻烦。有了typedef的助攻，我们就可以很轻松地给结构体类型起一个容易理解的名字：
typedef struct date: V( _$ D' r9 P1 B& D& h
{
; q9 f! A. E* g* M$ e int year;; G3 f( @2 H4 q+ q' N9 D
int month;
8 o: O  L# [. A7 p( X8 O int day;: D+ ^% n. A( D+ l# Z+ r
} DATE;//为了区分，一般用全大写  K- [; z+ i4 |% I8 m+ ]" Q
5 W: M' e; u1 U5 \: P9 _, D
int main(void)
$ R6 a* v+ i- ?4 w9 j{
$ U% C( R$ j/ W) I- J1 d, p DATE* date;* A' H: K3 W  [6 O  {' l3 O0 G
...
! s, b9 O5 b0 q}
甚至还可以顺便给它的指针也定义一个别名：
typedef struct date
* m& Y) u, f$ L5 s+ m  s6 [' {{
# o& b3 u( ~2 _* X int year;2 `4 ?8 s  L. L  O6 ~
int month;1 i% E0 P) l- y% N# m
int day;
& u2 `( p0 {4 q3 Z5 t; L} DATE, *PDATE;
进阶
我们还可以利用typedef来简化一些比较复杂的命令。
比如：
int (*ptr) [5];
我们知道这是一个数组指针，指向一个5元素的数组。那么我们可以改写成这样：
typedef int(*PTR_TO_ARRAY)[3];
这样就可以把很复杂的声明变得很简单：
PTR_TO_ARRAY a = &array;
取名的时候要尽量使用容易理解的名字，这样才能达到使用typedef的最终目的。
共用体
( c9 e7 z, Q( V- @- P

共用体也称联合体。
声明
和结构体还是有点像：
union 共用体名称
& F7 w# `  W5 H: u! f# H' f2 T{
5 z* b1 i" \8 T) H 成员1;8 a6 ^$ S" Q/ x9 B% c  Y
成员2;' X3 R( D1 i2 r' d
成员3;- b" a2 \6 r! z# |' D1 a3 U
};
但是两者有本质的不同。共用体的每一个成员共用一段内存，那么这也就意味着它们不可能同时被正确地访问。如：
//Example 05* f7 j. m( T. @# y/ O. l! w
#include <stdio.h>
% Z& v# E5 Q% o; j! i) U" Z#include <string.h>  F4 v# A. n$ X: P" {, x+ o

) y, X6 G, e4 b0 ]) A; s$ K( Munion Test
7 F% K8 _) j3 b" c: c) I3 u{
* L) D0 o8 d0 O" Q int i;
- P9 d. ?* j7 V double pi;- t+ b- N% T( [% `8 k4 E
char str[9];
' q2 h( i' D5 h- ^};
% _' c# n! \; |& E7 h: i0 M( t& m* e) ~$ b7 z/ W1 B0 [0 N
int main(void)
, |' E# n1 k5 S3 J9 b{
, ^. P" [$ H$ F7 \$ l union Test test;, o" }  P. H# ]* G( u

$ I# u; h4 Y( V- I0 K' Z5 t test.i = 10;/ Z& g2 ?! L0 @9 C  c& v, O
test.pi = 3.14;
( G5 e3 V& A- ~2 v$ v. L' m& Q& f strcpy(test.str, "TechZone");
7 M( I0 W$ m/ ~2 W: B3 j/ @3 x; B
printf("test.i: %d\n", test.i);
6 E' i# r  q7 H1 D" s printf("test.pi: %.2f\n", test.pi);* d! O% a" }6 D3 h, Q
printf("test.str: %s\n", test.str);
8 t# t2 m! Q6 K! y% a5 r/ G. d: a" z) X* x' F1 a( V% o2 X: B
return 0;, t9 ?) r! v2 k! _" u, G  O6 H
}
执行结果如下：
//Consequence 05
9 ^- m. X% v& Otest.i: 1751344468  w( `+ }( c" B
test.pi:3946574856045802736197446431383475413237648487838717723111623714247921409395495328582015991082102150186282825269379326297769425957893182570875995348588904500564659454087397032067072.00; S* l( s- U! F7 T
test.str: TechZone
可以看到，共用体只能正确地展示出最后一次被赋值的成员。共用体的内存应该要能够满足最大的成员能够正常存储。但是并不一定等于最大的成员的尺寸，因为还要考虑内存对齐的问题。
共用体可以类似结构体一样来定义和声明，但是共用体还可以允许不带名字：
union
: Z+ H) |. j' ?. D5 C{
% j4 |& X1 J; |3 X- L int i;
$ x$ u8 C7 Q8 x+ Z" S; ~, ^ char ch;
' |  w, R  Y+ Z& Y9 p3 {, e. P float f;. ?9 z  C  e& `2 S7 Y' z  {
} a, b;
初始化
共用体不能在同一时间存放多个成员，所以不能批量初始化
union data
* V/ d! [5 Y8 `# a( A8 m: U& w{
1 k6 `! ?0 V. Y) e9 V2 h int i;
! s  D6 S& O- a char ch;$ k, r+ K& G" g
float f;
' o4 R* U- ?; E/ F& I- T};* I7 T0 W$ U* h' B
/ n6 w1 s& x( e! K, `. |5 v
union data a = {520};       //初始化第一个成员
( j  v$ P$ _+ Hunion data b = a;          //直接使用一个共用体初始化另一个共用体  }+ f# c5 Q% o" _8 s% B& ~0 T+ |; |4 N
union data c = {.ch = 'C'};  //C99的特性，指定初始化成员
枚举

6 U$ W$ N: j: k2 `6 g
枚举是一个基本的数据类型，它可以让数据更简洁。
如果写一个判断星期的文章，我们当然可以使用宏定义来使代码更加易懂，不过：
#define MON 1
3 {; R# C6 d6 ]# G% T8 H  Z( R#define TUE 2
& ^" {3 I: w) U1 D" E#define WED 3
5 p* b6 w0 m8 r( T5 O0 O: \#define THU 4: D+ t8 I/ U! e1 U* j4 R1 L$ M+ [
#define FRI 5+ K3 X8 v2 S  a9 V2 _$ A  w
#define SAT 6, u% N* T) B3 L0 ~- T8 |# z
#define SUN 7
这样的写法有点费键盘。那么枚举就简单多了：
enum DAY
, S- M4 u2 v  t- g{$ A2 h$ a4 K& O( b6 y
   MON=1, TUE, WED, THU, FRI, SAT, SUN
% ~- M$ H8 A! P; G7 f};
❝
**注意：**第一个枚举成员的默认值为整型的 0，后续枚举成员的值在前一个成员上加 1。我们在这个实例中把第一个枚举成员的值定义为 1，第二个就为 2，以此类推。
❞
枚举变量的定义和声明方法和共用体一样，也可以省略枚举名，直接声明变量名。
//Example 069 w  v7 s6 y& S* P" n& F
#include <stdio.h>$ f: Z0 R' R8 Q& Z6 K4 Y
#include <stdlib.h>
: z7 n; p/ d$ }" S5 r2 U% l+ d* ?+ A4 s: [: u
int main()
: }. c( H1 V6 X4 L" J- L{% G3 Y. _1 E- O8 {! U( }! u
* f3 M+ \# \/ J' T% w: }
enum color { red = 1, green, blue };. d+ {7 z. s7 x0 X- h/ `
6 y* Z6 ?3 t' c, }! I$ f% N
enum  color favorite_color;
8 a; z6 a# i5 G8 z' A0 h+ a6 x, C4 K, U5 `! C0 M! s' l3 s# ?
printf("请输入你喜欢的颜色: (1. red, 2. green, 3. blue): ");: [5 u3 d: w8 B
scanf("%d", &favorite_color);
% U& a( A% z6 ^3 L; y
; Z$ E: a, e) |! c: I0 O //输出结果
+ d) h# u$ [1 V1 Q8 @# z6 t switch (favorite_color)
/ I3 F$ G7 W1 E  P( ~" W4 d3 ~7 [ {
3 A4 D" i  X% ~3 O# e2 X9 |5 H case red:9 d: X5 t: W5 X7 ?1 D
      printf("你喜欢的颜色是红色");
9 u2 Q0 a9 `9 i8 X1 X       break;8 ~& b; F. J+ V' F  s: X
case green:7 h8 }: T7 p  h1 l$ P. {# }
      printf("你喜欢的颜色是绿色");
0 F5 x6 C3 g: R7 W$ N$ i       break;/ q" h8 f( ?* B2 S0 u+ C- B: {' }5 i
case blue:- h( g* q' Z4 Q( k6 M
      printf("你喜欢的颜色是蓝色");2 S' ?7 Z. P4 x1 t
      break;* `* {' l% k2 q! [) n' ^% N
default:; @( ?/ s" Y0 K4 n# F
      printf("你没有选择你喜欢的颜色");# J) I5 Y8 }7 \# A" L" K" Q6 X
}' e- F. _. c! w, ^% U+ _; N' m
5 F9 `) }3 Y; P5 Y
return 0;
) p& t. T" S6 h}
执行结果如下：
//Consequence 06
& g, J9 l9 h+ h2 H请输入你喜欢的颜色: (1. red, 2. green, 3. blue): 3
8 z/ q8 L3 V6 p! t$ r4 E你喜欢的颜色是蓝色
也可以把整数转换为枚举类型：
//Example 07
2 }9 e7 B/ b- X  Y. Q- E7 X
% g6 q2 o0 w; q% [0 X#include <stdio.h>
$ r: p9 M! G: R1 y8 a: f#include <stdlib.h>
, i& g! B, {1 c  p# J: `0 f- q# W6 y2 }! M/ w
int main()6 T7 X/ [5 i+ q$ B" \$ E5 t
{8 w/ x, ~4 V! r& j4 B
enum day7 f' T8 V# X$ H/ I5 H
{$ w8 ~, {8 w9 \/ ^9 J, M  e4 E
      saturday,
" _0 s4 m$ S& J# i3 H2 u       sunday,
. v0 ~4 [& z* {- a3 v       monday,
% G! _  z$ ?3 g& L/ v9 }) p: z! s       tuesday,
5 F1 F2 X' f* h# q: j       wednesday,0 `- B# q9 ]) [1 x
      thursday,
3 \* p1 |1 K; T+ P6 c7 R       friday
& `: N8 `; F: c. h( N2 e3 N4 W } workday;
' r# y: i5 v% v- {
, t. q3 Z/ y( M# |7 w. G int a = 1;
# X1 S1 N" J/ A0 t  T+ ^& D/ Z enum day weekend;
1 d6 Z7 }2 d' A+ S3 a! O* C weekend = (enum day) a;  //使用强制类型转换# |2 p, \; A/ Q" E
//weekend = a; //错误
5 y! R5 {, J8 m3 U- W6 S printf("weekend:%d", weekend);3 G) _6 \: W: J  |" b
return 0;$ {5 R6 ?. s& s
}
运行结果如下：
//Consequence 070 x# Y; w% ?- S$ v2 X# l4 x
weekend:1
位域

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

5 ?  [( q8 V9 R9 i7 Cint main(void)+ o" M5 X& _; N5 o
{
2 F/ i, v& t4 ^) t+ ?% G struct Test, t* x4 {: }0 X. D0 H  E% \
{6 X% Z$ v' B2 y, r; U
  unsigned int a : 1;- d. |) X3 O4 Z% o, }
  unsigned int b : 1;' z, d; Z$ W4 j- {
  unsigned int c : 2;
) h- W0 Z2 j% C6 F } test;0 d& B$ n& d8 q0 k7 ], F
1 q/ I- c- J( P2 z" ]
test.a = 0;
% @9 A& V) `5 ~: Q) C test.b = 1;. {$ V% H8 z6 H; I! t  ]
test.c = 2;
$ S6 X" o8 d: a. t2 y: ^  ?! p: q8 ^5 }) C! U2 d
printf("a = %d, b = %d, c = %d\n", test.a, test.b, test.c);
% \  k. O$ g* i% E) h printf("size of test = %d\n", sizeof(test));/ W0 d" C6 d! N
0 {3 _2 @$ _; ^: n
return 0;
) S7 i! t& @8 D7 ?- b}
运行结果如下：
//Consequence 08# P9 l! l: y# X9 i1 v
a = 0, b = 1, c = 2
% r) g1 ^2 W( y$ r$ ksize of test = 4
如此一来，结构体test只用了4bit，却存放下了0、1、2三个整数。但是由于2在二进制中是10，因此占了2个bit。如果把test.b赋值为2，那么：
//Consequence 08 V2
% c) R/ `' t9 `' Ba = 0, b = 0, c = 2
- c+ a6 t( E/ M. P1 Fsize of test = 4
可以看到，b中的10溢出了，只剩下0。
当然，位域的宽度不能够超过本身类型的长度，比如：
unsigned int a : 100;
那么就会报错：
错误  C2034    “main::test::a”: 位域类型对位数太小
位域成员也可以没有名称，只要给出类型和宽度即可：
struct Test  C. o( B% g  V/ h+ q6 S3 o6 J
{$ S4 t) Y% [9 G
unsigned int x : 1;& F# |. C4 {! x' x1 N8 s: r
unsigned int y : 2;
$ }) ^4 s! c" V/ g; b  g unsigned int z : 3;% G3 s" j' `4 r6 m5 s3 Z
unsigned int : 26;# w( E2 _: O, H7 Q
};
无名位域一般用来作为填充或者调整成员的位置，因为没有名称，所以无名位域并不能够拿来使用。
❝
C语言的标准只说明unsigned int和signed int支持位域，然后C99增加了_Bool类型也支持位域，其他数据类型理论上是不支持的。不过大多数编译器在具体实现时都进行了扩展，额外支持了signed char、unsigned char以及枚举类型，所以如果对char类型的结构体成员使用位域，基本上也没什么问题。但如果考虑到程序的可移植性，就需要谨慎对待了。另外，由于内存的基本单位是字节，而位域只是字节的一部分，所以并不能对位域进行取地址运算。
❞
虽然科技发展日新月异，但是秉承着节约成本这个放之四海而皆准的原则，还是要注意使用！毕竟5毛钱可能是小钱，但是乘以5000万呢？

1 u; B1 {8 h' c. k- G8 ]5 T