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)
{
/**: B: R9 S8 v6 j3 A7 ?
   *在main函数中声明结构体变量% A- D2 ]# }, p4 B. f
   *结构体变量名叫info
  {  ~/ d* Q) K3 a1 b9 r0 ?4 [    *struct关键字不能丢
, o6 j+ L* u% m    */
struct Info info;
...
}

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

#include <stdio.h>

struct Info
{
unsigned long identifier;//学号，用无符号长整数表示
char name[20];//名字，用字符数组表示
unsigned int year;//入学年份，用无符号整数表示
unsigned int years;//学制，用无符号整数表示
} info;
/**
$ s( [+ [ G% g+ E5 v) L; g *此时直接定义了变量
j& U4 p7 q& x( c" t* P! v3 T; T' H *该变量是全局变量
% \* [9 R% \$ V" l& T *变量名叫info
7 s5 v" c7 r% m */

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;( a2 `7 @( ], ?4 b
}
+ C1 _" M, a* x# R' e; x6 X% N' P}
) H' s; W: _# ]: E# V* q
( x3 e: H0 l$ ~! J" p5 q3 G& Dvoid printLibrary(struct Book* lib[])# D; x  x- K7 T  G! Z% t
{3 h; H; k' y  Y9 d8 o4 z
for (int i = 0; i < MAX_SIZE; i++)6 I  p: \1 d* _/ H
{
* v' ^+ ]4 \9 a1 d+ m- W       if (lib != NULL)
% d# t% S. M$ r$ t       {
+ v* F6 K+ R" A- M+ s+ \' ~          printBook(lib);
8 ~2 |" |6 S& U, _: e( @          putchar('\n');
# N6 z3 H% I1 m       }
* _% J" \8 G; i }; p6 D4 k  q; z; v5 K; o
}1 U- |( W# l; N+ q

" C3 f- ]- |8 a$ h; G7 Tvoid releaseLibrary(struct Book* lib[])
5 E8 v! e, l. J9 C: E{
! l/ o+ Y! r  R5 S  X7 s; f for (int i = 0; i < MAX_SIZE; i++)6 B+ p! a: P0 g( S7 M
{) I5 ?+ A3 a7 l
      if (lib != NULL)
# o3 n7 x# r4 g* ?% \. X" X       {
0 z. Y+ `3 R+ O  ]          free(lib);+ o" r4 F. n1 ^! z/ z/ @0 s, l$ h
      }4 H  u9 B4 B- ~1 G( D  c4 V) B
}
9 O. V2 |3 U: ?* w  Z  ^9 o}
" e5 r0 K& ^" ?; v4 E7 W  ~7 J4 x
  V6 F% N+ f0 t6 D' S/ {) U6 L) mint main(void). P& i5 d( U# N7 [0 Y# H3 u
{2 W7 o5 U+ x0 [% ]: }4 ?1 ^2 I
struct Book* lib[MAX_SIZE];3 d+ e7 ^) a3 e$ I$ ~' d
struct Book* p = NULL;
' ~, e0 t+ q  B; V int ch, index = 0;
# v' }; Y2 I5 f- M: j
5 z; m6 }+ }3 e- K* g/ S initLibrary(lib);! {3 f; ]/ k# O2 m+ f9 N

# A9 F! @! c1 D7 P$ M( f while (1)+ w( }% t( E! @
{
; _) z' A7 Z9 o  L3 Y3 {       printf("请问是否要录入图书信息(Y/N):");
( |1 ]: u/ ]) k0 T" h; u       do0 @+ J5 N" j4 i: S
      {
6 V. @/ U% a3 ~3 h8 c/ u* F6 M          ch = getchar();
8 G7 P9 A7 t9 [$ I       } while (ch != 'Y' && ch != 'N');! D! U: D4 a) g* P, k6 k4 b& a  o1 k
& Y+ F+ `7 D+ Y
      if (ch == 'Y')
: D" N4 `, K& A. v       {$ {: a, w5 U2 ^3 ?
         if (index < MAX_SIZE)0 ^7 c3 `. G4 u3 f  k* D. Y( I  G- i
         {5 ~% x& Q# `+ R( W
            p = (struct Book*)malloc(sizeof(struct Book));
* G+ A4 _4 H; b( }             getInput(p);
+ ^) u( v, w7 ~* c) M             lib[index] = p;8 M4 ?) P$ ^3 }3 O4 a$ R
            index++;5 J  r! W4 @8 b
            putchar('\n');
4 H+ w2 @7 \0 K) n  o) T- F          }
1 j- K. |! d7 C& b* ]8 p          else* `* s; x( c. W- ~
         {
# p# Q* @) o/ J* @5 g% U) L0 T, c* z             printf("数据库已满！\n");' Q: |2 v8 H. n4 j# V6 p/ Q
            break;4 T% {/ X$ v$ X2 I0 K
         }
. g: |% \5 i$ b- i       }. W5 C7 J- c; ~1 {, q$ b$ K( i- |$ [' ~& S
      else
8 W. c, B/ c3 G1 y       {: h1 v. L0 b1 S4 ?; m
         break;
7 B5 D/ X+ H1 C/ c6 u       }
% z% S8 _  J/ p7 V# y+ @ }7 M& z! s; E) ]# f

4 u9 [9 ]5 s5 h printf("\n数据录入完毕，开始打印验证...\n\n");, R2 B8 k+ F! @3 }: i0 |) d( u  C# k
printLibrary(lib);
& m: C* m' s% r- `0 e releaseLibrary(lib);, o4 ?8 ]( Y# i- T+ {% n( D
% J& C  I' g( e. }9 C* M# n8 T
return 0;) l: @$ @- o+ x6 Q2 m% L! y$ s
}

运行结果如下：

//Consequence 021 V+ S4 N: I. F% V' ^6 ^
请问是否要录入图书信息(Y/N):Y5 {2 q" L2 u& d5 q2 ^0 N
请输入书名：人类简史
8 W9 b8 g3 N4 ~ [& L请输入作者：尤瓦尔·赫拉利/ E, a0 N1 H! B8 i e
请输入售价：32.25
/ v: M) z' i- `* K6 ~! S请输入出版日期：2016-3-4
2 i2 k' z% |4 u! Z请输入出版社：中信出版集团
& U5 R" [1 {; q! ~! [' Y5 m) a1 S9 G( x
请问是否要录入图书信息(Y/N):N' |* `- }8 h( v' s% b/ `7 k* H
# V/ g6 A) ?# u$ k9 P, Q1 L: r5 A
数据录入完毕，开始打印验证...
/ o8 g; f+ m8 v5 P8 Q
+ c9 c+ Q! D/ v2 k9 |1 H1 D3 X! w% S书名：人类简史' X0 x% g7 a1 b) B. O/ X4 F0 R
作者：尤瓦尔·赫拉利! a8 U9 @) P) W1 A8 u$ H# I) q* ]
售价：32.253 y2 n" _3 M6 R) n* h# X1 j+ G" N
出版日期：2016-3-4! A1 J% p# q, g3 D/ ], B
出版社：中信出版集团

单链表

: ~5 o7 f- P4 _1 N9 m) t1 i

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

5 @7 Y* W  r( Z$ i4 y: _
单链表
当然，链表最前面还有一个头指针，用来存储头结点的地址。
这样一来，链表中的每一个结点都可以不用挨个存放，因为有了指针把他们串起来。因此结点放在哪都无所谓，反正指针总是能够指向下一个元素。我们只需要知道头指针，就能够顺藤摸瓜地找到整个链表。
因此对于学籍数据库来说，我们只需要在Info结构体中加上一个指向自身类型的成员即可：
struct Info6 V& x% W, S# U% e
{0 \5 t( M& F$ t$ s% C2 a2 `2 H
unsigned long identifier;0 T; E5 ?9 P. x" e$ F+ n/ C/ f) S
char name[20];
7 N  k" B1 W6 k# k; x struct Date date;/ |' {$ V7 F7 a7 e* \1 J( e
unsigned int years;
0 @3 [- G3 L2 U; ^0 \6 e struct Info* next;" p7 Q) ^/ z, r0 n5 z: V
};
在单链表中插入元素
头插法
这种每次都将数据插入单链表的头部（头指针后面）的插入法就叫头插法。
如果要把学生信息加入到单链表，可以这么写：
void addInfo(struct Info** students)//students是头指针
' {1 P: ?0 z- ?" W0 P8 x  z* m{
1 y7 M7 x6 B  z# R5 |9 p struct Info* info, *temp;
$ M$ _$ b6 N# E2 a: x info = (struct Info*)malloc(sizeof(struct Info));
* D3 f& ~' b5 E- e1 ~5 T  k1 u if (info == NULL)$ B0 m8 h8 g4 a5 n, ^  N
{# w: Z2 z  ^* m, R( ?& z# T: S
      printf("内存分配失败！\n");4 ~8 k. ~# V8 G9 w/ \( |! o" u
      exit(1);* n; I+ f% C: ]( \' i; H. Y
}
$ U" I5 ~2 Y' G6 ]# q! U. ^* f0 A
" ?" ?( X) H4 a/ G getInput(info);
% x% o, ^6 e  {$ m6 V8 c/ T
, T! R3 V& g- s1 c8 S6 r if (*students != NULL)7 P" n% S9 f; G$ W
{
" s3 [  S7 B' i* h8 J/ |& P       temp = *students;
3 D$ g( U0 k) p7 {4 D9 Q3 j       *students = info;
, U  q$ Y6 v$ O/ T/ e  g       info->next = temp;. ]" P6 F3 j* B+ K% j
}
+ O' b% I- I0 G- J1 M else( t+ X  s9 u9 R- J
{9 p2 D* ?, D6 j; v1 C
      *students = info;  Q) A' B- i1 _' e- S3 F5 h, K
      info->next = NULL;
( M9 z7 e2 `2 T" _9 a }
$ l' R2 r4 F# _( E, c  J}
❝
由于students存放的是头指针，因此我们需要传入它的地址传递给函数，才能够改变它本身的值。而students本身又是一个指向Info结构体的指针，所以参数的类型应该就是struct Info**。
❞
往单链表里面添加一个结点，也就是先申请一个结点，然后判断链表是否为空。如果为空，那么直接将头指针指向它，然后next成员指向NULL。若不为空，那么先将next指向头指针原本指向的结点，然后将头指针指向新结点即可。
那么，打印链表也变得很简单：
void printStu(struct Info* students)6 G: @& m0 h  R8 y- ?2 S
{- ]) O; Y1 m/ E& g  m
struct Info* info;& y1 U% r( {! V/ w
int count = 1;( _! v% f, B1 N* z3 }9 C$ p
  f0 |. \+ V4 ^" }) P
info = students;. D# M+ }& N* P. R% R* \; l* G
while (book != NULL)9 v  j6 f# Z0 t! E: o
{
0 {' X; m: I' y0 _       printf("Student%d:\n", count);8 R4 E+ ]0 c: x5 \* p, b
      printf("姓名：%s\n", info->name);0 Q' |7 T. s$ N2 e: }
      printf("学号：%d\n", info->identifier);9 C% J& C7 f, x$ H, O/ e9 w
      info = info->next;4 I& y, [2 J; u( f; s4 n1 H
      count++;
9 F$ z! N" ]* x8 `3 B6 Z0 k }
7 _' m; t6 l9 B# N+ S, h}
想要读取单链表里面的数据，只需要迭代单链表中的每一个结点，直到next成员为NULL，即表示单链表的结束。
最后，当然还是别忘了释放空间：
void releaseStu(struct Info** students)
" W* v5 L. C  w8 q9 t7 @: u! T{( B1 y& y$ ~3 [+ |$ R
struct Info* temp;
% G1 N, ]; w/ f5 c 6 i* H  p1 v, r+ o& \
while (*students != NULL)
) ]9 O$ o; q* R& C& {0 ? {* h" E& i1 q$ O+ g0 I3 b) H" U
      temp = *students;
' p' P* `  u4 }; x. J       *students = (*students)->next;. n2 C, R4 _, J* E3 [, w
      free(temp);
+ D% e! X/ r$ M; G9 ?: v }1 M4 X( L5 [2 J5 q% x2 w
}
尾插法
与头插法类似，尾插法就是把每一个数据都插入到链表的末尾。
void addInfo(struct Info** students)" G) K, s4 b" G! `
{
8 Z" @# I" R8 u0 z0 J7 r, U struct Info* info, *temp;2 q- B; g) E' B" f- B% N' c4 \
info = (struct Info*)malloc(sizeof(struct Info));5 T6 j6 S! p- [4 @. Q0 w
if (info == NULL)
9 |! ^0 C3 a0 \- C, B. h4 e {9 U2 s1 F; ~$ P$ i
      printf("内存分配失败！\n");
5 y3 j; Q& W" r/ l+ ?       exit(1);
8 P/ O, K2 D6 Z+ ]& p$ | }
7 ?" G3 n' t/ M' S# @/ \1 m) ~
& [* g8 a# {' ?! ? getInput(info);
. t$ `" X4 N" a' G2 m
. j- b% o! H. e! H if (*students != NULL): H* u& q5 L7 @& x* j4 q
{# c2 I) v! d, m4 x! S
      temp = *students;" @6 K7 \' W' n# W
      *students = info;6 V4 D/ W( b3 T, Z7 S
      //定位到链表的末尾的位置0 C4 x, s% I) ?' N
      while (temp->next != NULL)
. X4 ], I$ I6 R# _! s8 k: M       {; a; M3 i* k! q* D8 \, @1 Y8 G6 p
         temp = temp->next;
) z1 v# i+ f5 {7 ]" ^; }9 U8 z       }9 f  F4 b" o. g; L0 |" t% @; s
      //插入数据
1 o4 i* L, D  a7 G9 d% A       temp->next = info;  c, U! ]3 N  ^# S8 w
      info->next = temp;
# e7 o8 E1 e7 g# k- m }6 ~: U+ m6 l& @! o7 Q) @
else
) e; o1 q' E4 ~% U, y5 P" F% o {
* I, [. z1 w* A0 v+ i  }       *students = info;
- Z0 y( d; J- c; P+ ~4 r" P       info->next = NULL;" r9 j: `; y' `4 C# p6 T+ U# x
}" s& a- R* Z. U4 N$ P1 ]
}
这么一来，程序执行的效率难免要降低很多，因为每次插入数据，都要先遍历一次链表。如果链表很长，那么对于插入数据来说就是一次灾难。不过，我们可以给程序添加一个指针，让它永远都指向链表的尾部，这样一来，就可以用很少的空间换取很高的程序执行效率。
代码更改如下：
void addInfo(struct Info** students)% J8 w; a5 I4 s1 V- B
{
  c- X$ }2 x. a; U; q* |( p0 S struct Info* info, *temp;
# e, E- [! z  E4 G static struct Info* tail;//设置静态指针
0 A' F8 {5 B. u3 { info = (struct Info*)malloc(sizeof(struct Info));
5 h% z8 S3 s, W! F2 ?" F if (info == NULL)
* o9 R; n  u/ Z6 Q; W6 l3 O {
5 ?! H; L% _6 L/ l! s3 a2 Y! v6 ]; Y       printf("内存分配失败！\n");3 F1 B! _  @6 K; w
      exit(1);
2 ]; V/ i, u, Q7 K% F+ H }
+ X8 ?0 `. `+ J ; U6 ?( H5 h- E& Z3 Z) O
getInput(info);
1 a2 `: h7 R& g& J: M% i + L* e" [3 B* p
if (*students != NULL)
& r8 i3 Y# d% n- S; _2 F {  V6 h" r% k4 T) y% d( o3 c! p
      tail->next = info;
' [6 ~5 S9 g! C$ ^5 k       info->next = NULL;
# \/ v& C! ~: b% u, k }
+ L) U! `0 |/ R4 i) D/ }8 w/ q% _ else: G6 r$ S5 j! W% K' T$ _
{0 I6 ^& b" G$ I# T$ y2 f) F
      *students = info;* ?9 ~7 z' v/ X7 D1 w
      info->next = NULL;+ ?8 j- V2 V* t2 \# C# m
}% d. g  _/ G# x5 z3 A
}
搜索单链表
单链表是我们用来存储数据的一个容器，那么有时候需要快速查找信息就需要开发相关搜索的功能。比如说输入学号，查找同学的所有信息。
struct Info *searchInfo(struct Info* students, long* target)
6 O5 Y( F* ]' J7 M{
/ F5 S. z- o& v% r4 Z+ b5 T struct Info* info;
2 R% E# z- j; m' @ info = students;
8 `5 v9 m, E* k) O* _- @' i3 h while (info != NULL): t% y6 T! q" e+ F- ?6 u3 ?
{
; e5 X, J( N  Q4 a: C2 e       if (info->identifier == target)5 h9 ]- I1 o2 h4 B( g
      {+ ^8 G9 A' m2 y
         break;
' u; o$ D% e$ {8 j       }1 O) P% Y7 r* b+ F. d
      info = info->next;6 u& Z3 M5 _7 f- R$ G% C% ~
}
" t/ d8 V3 S7 q; i! t 4 o) \) o# g2 v5 Z( c! ~! q0 c- ~0 V
return book;
5 \0 A3 l2 m2 x- I% `, Q+ F) ^! q5 `};
$ Y+ ?3 `$ g( I+ y* V9 [! i
( m* |! O7 N& C) Avoid printInfo(struct Info* info)
" e7 Y7 o& o1 J! I& q  D8 D{! H, D2 ~* t" j
...
& a5 N" Z. t, ^# d3 [: f* J: X}
$ t& {$ w) x! q! ]; X...  |+ ]  d2 o( L
" K9 w, N9 z  E. R
int main(void)
1 e9 l8 g+ }8 v- w9 I{
" z7 ?3 C1 P4 ^2 L4 D. h! L/ I ...
4 f7 M' f0 M- v+ R' k6 j1 w; D) o0 { printf("\n请输入学生学号：");  {6 g) l/ n( A8 m& r
scanf("%d", input);9 B& T, {" @  q( B, S6 h6 c
info = searchInfo(students, input);& p$ J. B; q9 `* |. n& C4 P
if (info == NULL)
# X, L7 `- \# I( s {
, r1 ]$ Z/ V1 l5 `. M2 T) g       printf("抱歉，未找到相关结果！\n");
& w2 Q' C: y7 P3 O }
7 ]* u: }+ w5 x$ l. P( _. D7 I else
/ d) p4 j! b8 t {+ @: P- d; V4 g+ o
      do
5 q. n) ~! n7 ^# w6 p- o3 f- d% |( E4 O       {
; T5 H0 s: h# m6 k6 Q/ @9 S' Y5 m          printf("相关结果如下：\n");
: z" y) c2 v3 p+ p7 ]) j' y          printInfo(book);- k7 |7 z( f5 j' I( K
      } while ((info = searchInfo(info->next, input)) != NULL);" A5 q, o# c0 D- T$ F4 z
}
6 a. K) z! L' p* H, q
. C6 N1 R5 J0 W9 ~  ~, m releaseInfo(...);+ J, t$ i- G$ r  H
return 0;
* h+ B# E' O2 y. }, I4 q}
插入结点到指定位置
到了这里，才体现出链表真正的优势。
设想一下，如果有一个有序数组，现在要求你去插入一个数字，插入完成之后，数组依然保持有序。你会怎么做？
没错，你应该会挨个去比较，然后找到合适的位置（当然这里也可以使用二分法，比较节省算力），把这个位置后面的所有数都往后移动一个位置，然后将我们要插入的数字放入刚刚我们腾出来的空间里面。
你会发现，这样的处理方法，经常需要移动大量的数据，对于程序的执行效率来说，是一个不利因素。那么链表，就无所谓。反正在内存中，链表的存储毫无逻辑，我们只需要改变指针的值就可以实现链表的中间插入。
//Example 03
2 }+ k+ X" r, F# A+ U#include <stdio.h>
' a0 [' `0 W, s* N' a#include <stdlib.h>
" o1 I( n/ {7 w: D/ z+ h4 y
/ B. c  F7 G2 u; Mstruct Node
' |+ O3 p; |5 f2 `, V& ^2 Q{  {# C1 T" X' I4 T7 C
int value;+ `3 Y6 t% r3 v2 \
struct Node* next;$ R# A! v! D) e1 d5 A5 Z4 a% O
};9 M3 G! i5 S) ]9 q; x

% e- Y. i7 N0 U8 ]) ?# Zvoid insNode(struct Node** head, int value)  e7 I6 y; L4 M
{2 C# ?  }4 r& ?& {6 ~% k# @
struct Node* pre;
+ D7 n: y" Y3 @: e8 Q struct Node* cur;
8 j3 C  B0 U! l struct Node* New;
' |' Q3 p5 n  D4 G
& u& c; t7 t6 V8 G, Z2 o2 M  G cur = *head;
2 z$ D; \5 t6 K7 j" B3 k4 O8 f pre = NULL;4 T9 O. h1 w4 Z( ?; p5 I2 m; a

0 X8 V* F7 f3 H6 F7 o, o. _ while (cur != NULL && cur->value < value)
, r, L. E8 G' U {/ W. {3 q  d2 }
      pre = cur;
" S9 Y0 }* n( ]2 D0 h2 Z       cur = cur->next;
/ f2 u0 M7 e. u  t' i0 {  x/ l }
+ \( Y- V# Z5 j
' E1 e. |) W, f  G. n" Z7 t New = (struct Node*)malloc(sizeof(struct Node));6 F" \. u0 p) j, M4 E9 C0 E
if (New == NULL)
  E( n# f9 e! [/ B- X! i {6 N4 I% I( t  X, N
      printf("内存分配失败！\n");
& T, `+ T+ V1 q: g7 M2 u       exit(1);
  \3 l0 y& f7 t8 c+ j7 { }
2 V% Y& P9 m3 s2 p! W" R New->value = value;
, c" J2 y  l8 f* H2 B New->next = cur;
8 ?5 {1 g4 e* b2 U  w. F3 I+ x0 I; P- ^! j; Y3 D
if (pre == NULL)
8 w2 n' m; N% V- P& [! O% ^* v+ n {* h( ~! W4 t# T/ P( C1 P8 m9 M4 a
      *head = New;
3 _( q/ ~* x# ]  F$ I& a" S5 }5 Y }9 z. S2 W$ \' O/ L3 E5 R" ^* g
else' R- A" u* r/ t: C; H
{
% e: ~* l' h' F3 i$ _       pre->next = New;; m$ ^3 b; m. W7 _  Y/ s; X( r' R* n
}+ h3 Z+ ~- T3 H
}
7 }+ u1 q+ D* Z  c( d5 \5 _+ N; i4 D: |3 \' w; q
void printNode(struct Node* head)5 Y$ e( P" e  M1 \* ~' U; q
{
' t! i0 A0 p$ c7 C struct Node* cur;
5 u9 l) O9 m/ p4 `, Z, f' T' z6 g/ m# I
cur = head;6 @5 t1 ^4 V# [( [
while (cur != NULL)4 K' k$ d* }" f
{
" m6 h+ D1 I- s. e) e       printf("%d ", cur->value);
4 A- ?' w* r' [- O- _       cur = cur->next;
4 p* s7 [( c9 v7 R/ S( R+ }5 Q5 y }: d* n; z$ Y" X0 |
putchar('\n');
5 Y3 R. v+ U" F2 x8 h}- o& ^7 o+ V4 t; T& Z
# z9 `4 g; [3 {) F; }
int main(void)5 w5 g! W2 V* g( a
{* g* |5 R1 Z- ~- y3 j
struct Node* head = NULL;
1 z$ F# _7 Z% \3 T' w int input;
6 x- _2 C0 v! i9 f* T# d* h7 S$ Z' a9 L
printf("开始插入整数...\n");
6 L% m- {  _- A while (1)5 [: F. s+ e2 S' G% s: K' ^; _
{
% M0 j4 |+ v$ u1 M* I# q       printf("请输入一个整数，输入-1表示结束：");
8 m! ~+ \( r! B" S5 ^       scanf("%d", &input);
+ R2 E! N+ d. ?' _8 \- m( P9 O       if (input == -1)( S. S/ z& |9 k" f$ z8 \6 ?8 m
      {
. `6 q1 q: `" u; D          break;; j* n1 \' F+ t: Q# {' R
      }
0 s" x0 H( E* J+ m1 w       insNode(&head, input);
2 A" T, a4 x! T+ M       printNode(head);& o' u! g" I1 q' L* _8 g
}
) M) P) \7 {9 a1 P  V$ s( c% S- U8 }# _& ?
return 0;
* h, T: I0 t5 P( w}
运行结果如下：
//Consequence 03
. z# v! [8 x8 M. T* y开始插入整数...
! P# H' f! u) }/ |9 T1 @5 z# N请输入一个整数，输入-1表示结束：45 h% Q! ^$ G! C
4
2 C& h8 [; N; c' ?& ^请输入一个整数，输入-1表示结束：51 x. B/ y- l& k3 R4 g
4 5
* R# E: A8 B' S3 k+ |6 I2 g请输入一个整数，输入-1表示结束：3$ c7 J9 E1 Y% l4 @
3 4 5
) o' c$ Y. f0 e" _9 D请输入一个整数，输入-1表示结束：6; J0 R) A" e. g( g
3 4 5 69 ]( m' H! x4 e
请输入一个整数，输入-1表示结束：20 G0 C( _$ Z& g/ S
2 3 4 5 6
1 |# r0 j0 h' g- m- b请输入一个整数，输入-1表示结束：5* i* t3 T9 _" t4 T* Q
2 3 4 5 5 6
, W: m/ a: w7 X+ K5 k6 l' p请输入一个整数，输入-1表示结束：1. s( Z& c  r( {0 _8 H4 z' f
1 2 3 4 5 5 6" q! ]% s) y% ]  }% r1 X
请输入一个整数，输入-1表示结束：7
! u  C& Y9 Y% x, @! [1 g1 2 3 4 5 5 6 7
3 E' T3 Z' t7 b& }. o0 C请输入一个整数，输入-1表示结束：-1
删除结点
删除结点的思路也差不多，首先修改待删除的结点的上一个结点的指针，将其指向待删除结点的下一个结点。然后释放待删除结点的空间。
...' T( r+ A$ z5 }  z: @  J
void delNode(struct Node** head, int value)
, z1 f7 R4 @, `- l7 z{9 N0 n9 B* L5 A4 X2 t2 b5 C( `
struct Node* pre;
3 v/ v% Y  w) I6 ^" H struct Node* cur;
/ l+ x; v5 S6 O1 d : ~" j1 `7 N7 y8 h( Z9 n1 z
cur = *head;# C; ^0 ?5 w) u0 \% D
pre = NULL;0 x& A# M" e8 e* i; J0 L1 Q
while (cur != NULL && cur->value != value). \1 T9 \' Z4 a5 l
{
8 q# W2 d- j& S1 S& [* m, D       pre = cur;+ Q& q' ^1 W% B+ k5 X5 c: Z4 c+ a
      cur = cur->next;- X2 b5 g* H- e& B' I" F
}
2 r3 Q$ ]1 p8 I2 I9 n% `; s, A if (cur == NULL)- K$ L8 i# V: J0 R1 W% o& ~3 E2 t
{
( j' l0 Y5 |. }% _: N7 D( f       printf("未找到匹配项!\n");
" I+ z! H! L) ?+ u3 ^       return ;3 i7 H- t2 {. _! A6 F5 v* z
}  s+ B* A% M9 Z' n
else
/ m8 {% Q+ e7 X5 G' o" \) A% K( N8 c {& D( e4 ^8 N0 T3 \7 ]: r0 @
      if (pre == NULL)
; I0 X$ z3 H* S$ l0 }       {1 B6 j; r8 F; g7 Z, z
         *head = cur->next;" {  M7 ~( U7 X% D+ }' b
      }$ R" T2 X  ]- g5 y
      else
/ R9 Z/ l+ E1 S" G& v" |3 W       {
: X( ^% T" @" ]1 q9 A( Z          pre->next = cur->next;
/ j5 M( U; F2 S) J- d8 z       }
% w+ d" j( C; r  D) q1 f       free(cur);9 z) S3 G# H+ T9 @% W
}
' d& H# R7 C* F}
内存池

* ^0 i/ O8 {4 N0 }
C语言的内存管理，从来都是一个让人头秃的问题。要想更自由地管理内存，就必须去堆中申请，然后还需要考虑何时释放，万一释放不当，或者没有及时释放，造成的后果都是难以估量的。
当然如果就这些，那倒也还不算什么。问题就在于，如果大量地使用malloc和free函数来申请内存，首先使要经历一个从应用层切入系统内核层，调用完成之后，再返回应用层的一系列步骤，实际上使非常浪费时间的。更重要的是，还会产生大量的内存碎片。比如，先申请了一个1KB的空间，紧接着又申请了一个8KB的空间。而后，这个1KB使用完了，被释放，但是这个空间却只有等到下一次有刚好1KB的空间申请，才能够被重新调用。这么一来，极限情况下，整个堆有可能被弄得支离破碎，最终导致大量内存浪费。
那么这种情况下，我们解决这类问题的思路，就是创建一个内存池。
内存池，实际上就是我们让程序创建出来的一块额外的缓存区域，如果有需要释放内存，先不必使用free函数，如果内存池有空，那么直接放入内存池。同样的道理，下一次程序申请空间的时候，先检查下内存池里面有没有合适的内存，如果有，则直接拿出来调用，如果没有，那么再使用malloc。
其实内存池我们就可以使用单链表来进行维护，下面通过一个通讯录的程序来说明内存池的运用。
普通的版本：
//Example 04 V1
% b& w- q7 T/ e5 b8 l; M) G#include <stdio.h>( X) M( i& l3 ?% U
#include <stdlib.h>
2 S3 h6 ]% p' q: Z5 o! K( s#include <string.h>
4 k- i$ M8 i0 _7 I' d) n# H, T( n( D9 H% f2 w3 Q% u# v
struct Person* [6 P- p+ K; h
{5 @+ P8 F) [) b2 [- E- p% V$ n
char name[40];
! y# p1 |* a* a- e: B$ E) J char phone[20];& \) p6 p- m7 L$ U2 {
struct Person* next;
, N) R  F+ {: x) G8 ?};
( a% Z8 F) `2 w* o7 Z  {9 w) n0 b2 d0 Z
void getInput(struct Person* person);. ?. B3 @1 p9 b2 `) u# E
void printPerson(struct Person* person);
- z+ ?0 U, |( ?3 Dvoid addPerson(struct Person** contects);
+ p7 i# B" y& K4 C3 ^- lvoid changePerson(struct Person* contacts);6 S; Y% f4 o  V5 {; @
void delPerson(struct Person** contacts);1 _4 ]+ ?9 n6 N4 s/ R0 X
struct Person* findPerson(struct Person* contacts);6 J) ], t: q5 R$ a: I
void displayContacts(struct Person* contacts);0 j8 D0 i% y6 t8 I% y$ B) h% c
void releaseContacts(struct Person** contacts);
, _" k' p$ K( w" w  Z6 U: g2 X1 E3 u- r: L
void getInput(struct Person* person); n' q/ H% D4 b" }" S9 O$ L
{
5 y+ i0 Z+ L6 E* k2 s  O printf("请输入姓名：");; z3 I/ L8 a5 h+ |9 R: T- n; d" d
scanf("%s", person->name);
. `2 A- ~# o- |: f! j printf("请输入电话：");. y; J3 k5 i. Y& T9 C  R
scanf("%s", person->phone);: o' Q$ P9 P  ~7 T/ @0 Y1 r
}
2 w" c# K* z& _( A* B* @, o2 Z0 D; s# ~: r
void addPerson(struct Person** contacts)
/ d) t. D% q' W7 u: W{& o' m, b; k0 F! m2 f; ~$ v& n
struct Person* person;" b; u* L5 k7 O/ b
struct Person* temp;
$ n$ D  E# L3 k5 ^4 d* Z
0 u" d! _! _5 G/ t person = (struct Person*)malloc(sizeof(struct Person));! k4 q* P9 ^. D) X8 u9 `6 y
if (person == NULL)
: z$ w+ `4 D9 ?/ ` {
- g7 Y5 B& a$ t. C1 F  printf("内存分配失败！\n");. E6 d, \3 l. S$ S0 G; f& `+ Y
  exit(1);5 L+ B5 }- [) B0 e
}4 O7 K# _2 @9 y! @* n- g

: P  w& h2 h6 d' O. X" m getInput(person);
& {2 y( g6 t0 F0 f. u, x) _) l. r6 p) `2 |( b
//将person添加到通讯录中
if (*contacts != NULL)  Q0 c. J+ j! Q9 H
{
! N7 ]# ]( G6 p& T3 n$ }  temp = *contacts;
3 U. Q5 H8 }5 R% Z5 m7 q  *contacts = person;% p1 R5 P. V2 y; O8 d8 W
  person->next = temp;
% W* e4 W% L2 l9 m% f }
+ k4 A6 I" {2 G& e else2 o$ K: o1 }  C' {
{4 |! W1 M: P  n7 U+ A" O
  *contacts = person;
" S( V2 Q; Z2 p8 t  person->next = NULL;# i, U1 j" j0 O( N/ i
}( D' y' T, D# i& Q; l% F1 q! v- w
}6 @9 m- ]; G# v2 E4 J7 N0 ~- [
* O- J/ q! Y/ H# \6 h# _
void printPerson(struct Person* person)
9 L, M; {9 ^6 O( i/ B{
% K. y, D7 i4 z2 f/ \; S' i: ]) t printf("联系人：%s\n", person->name);
: \4 }6 [/ ^/ I, ?: p printf("电话：%s\n", person->phone);
3 D8 r7 y, ^, u! _}! K5 y9 K- B5 i% k1 {$ p# i

$ z; v* c2 A) [( Hstruct Person* findPerson(struct Person* contacts). H, _1 G. t: i% j2 ?
{6 D$ U; v, I9 P" k; k( J' y3 ^- z6 H
struct Person* current;
) m2 K; q0 T# F& m, O char input[40];+ c6 o! G2 \3 s2 j+ |" f& E3 D

4 |2 f4 q6 w8 A3 S3 |0 `& t) @ printf("请输入联系人：");
/ ?8 k/ P/ D0 Z9 e$ ]% ^( T9 Y scanf("%s", input);
5 k, e0 {" m) t) }) ]+ V4 Z- y- \' O: u2 s# z
current = contacts;. _2 x4 R" \% r  u; |
while (current != NULL && strcmp(current->name, input))
4 f& u  f1 t8 Q0 k2 U# X {7 f2 [0 _& i6 ]; m; N2 `
  current = current->next;- O& U  [8 c/ `1 I; p
}5 W. z4 @0 q7 r0 |
7 ^/ q* o" c# w4 N
return current;
# Z' t/ ~; `+ ?* W& p5 k}- Q" U( {3 L' g2 |, e# S) J
9 _. s6 g6 s% S. U3 |5 G9 B
void changePerson(struct Person* contacts)4 E4 }/ z- M; d4 X& ~  S
{/ K9 g/ |5 W$ F" `! ], R
struct Person* person;
& y$ [! O1 U6 X( n/ H& n6 l& h- u% c- y6 _: `
person = findPerson(contacts);
0 c9 X2 n/ _4 }3 F& K if (person == NULL)
2 m" c* {6 i) t9 ]6 K" E {( P+ {! d/ z' X7 J- M$ \
  printf("找不到联系人！\n");& }; M2 d, `1 ?& W/ o/ v4 A
}
- |; H& B0 k: j+ L! j$ d else
+ S% C9 D: H' t5 \9 Z" B  R* ] {3 U6 T+ `6 \. m9 ]; f6 q, v
  printf("请输入联系电话：");5 K! H9 r9 |, ]# R1 a% D
  scanf("%s", person->phone);1 ?" e: m+ o4 j3 I
}
8 I: f$ k* y9 p4 U  Z" |8 z}
( A) ~3 Q+ g, D3 A- e+ u9 P3 L& t6 E1 R9 C5 a4 y3 o, F
void delPerson(struct Person** contacts)7 R: i$ q+ N) f
{
6 Z! N1 I8 G) V* d) B( f$ s( V) R struct Person* person;
9 h4 E( Q8 D; |5 ^$ q struct Person* current;
& {. {3 o, l* `6 r3 a: l. u struct Person* previous;
6 I, l; a7 l7 O+ K$ d" S0 ~
6 `' m7 u1 T+ [ //先找到待删除的节点的指针9 H3 m: y* \( K  \4 `, ^/ b) E
person = findPerson(*contacts);
$ y* S$ Z- K% ]8 P; p( g if (person == NULL), R+ E' w, n! c1 Z$ U" P
{
- }2 E6 u0 i* C, A& U3 B" @7 V  printf("找不到该联系人！\n");1 U1 F8 `$ w9 n5 B# t, ^
}- l& s9 k: e% F% k7 w
else
* D' f" O: [* J8 ?, `+ D {# V6 J6 ]0 ?8 }0 F$ R
  current = *contacts;& e$ O5 K! W: f4 R4 f
  previous = NULL;
# k) @; ^2 h$ R. S' F5 r% ^* s2 C
  //将current定位到待删除的节点6 ^, D+ f& W2 F4 ?; w* a, s$ M2 h
  while (current != NULL && current != person)* [4 h2 h2 D; H! j  H
  {+ H% q+ Z8 _7 D+ t1 M' r# C
previous = current;
2 I5 i. `1 X& K( W, T$ K  l: o current = current->next;( a0 `1 \/ {4 f; J. z* B
  }
/ S* h& j: y3 q/ i- J1 p
2 r( r  D5 T- I. _4 W; ^9 q  if (previous == NULL)
! Q  o  s0 y: S. u# r: w) C  {
8 O4 R% S8 ]9 \. \; m* R& L. Y/ ` //若待删除的是第一个节点4 ~! |1 x5 t4 e) i$ {
*contacts = current->next;$ I. F: l" @  C$ t
  }
% w1 x& h* N9 S  else
% t. `+ J( I4 b2 Y% H* g  {
2 b. J7 y& t2 o3 {+ T0 C0 y- f //若待删除的不是第一个节点; z: k; o4 C3 D; F( E) _" F
previous->next = current->next;
$ ?8 P0 h% N; m" ]  }
) Q. B& P+ ?3 _1 G9 {& c# y" h
& h) w- k6 E) c7 X1 Y' a6 i  free(person);//将内存空间释放
: X* F5 G6 u! u7 X  O }+ \) M% M' }4 \# h4 W
}
* Q$ c* E  N& G3 [4 U
1 L, ^% }2 J2 q3 \! J) @+ hvoid displayContacts(struct Person* contacts)
0 i; W$ H; s. v' o& n  U4 W{7 ^: B+ q$ I8 S0 `
struct Person* current;
9 c, s! B8 H3 R3 M8 U' F5 y
( H- V/ J/ e* l6 e0 s$ ], R current = contacts;. w. V/ s) P3 @! B" M& R% y
while (current != NULL)
) R- P8 H* a$ U# f {
* r; \# R, a0 c4 V7 o6 G  printPerson(current);
+ E# l: P7 ^7 L. L/ N  current = current->next;
3 o5 i8 z$ x8 l0 L$ P }+ k. R- q- V7 Q0 g7 l9 J) s
}
) U5 a- a5 H  E6 Z
5 O$ P# i( @/ ~: B3 H8 |) Z$ Bvoid releaseContacts(struct Person** contacts)2 C4 I4 R9 I2 M# W( `  l
{! P# S% U' s) d4 l* O* v* q
struct Person* temp;
, J  k# t: a, Y  F8 s+ T; g, Y& Y: J( {: R, N/ t. f5 {
while (*contacts != NULL)( h  a  r# v0 ^( N4 h6 B
{
" C- I0 O9 m! _7 j4 D  temp = *contacts;
9 _0 I; }, Y' ?3 E  *contacts = (*contacts)->next;
& W. m( Q4 }% |! c  free(temp);7 y" l; D1 x7 y( Y3 f4 a
}
$ o( D1 c; }+ u1 e5 V}  h4 Q* a1 L3 J; V& d$ t8 ~
7 w- m. d# ^6 d# n) j
int main(void)
7 b4 X, Q& e* m" M{
$ O; u3 p2 w: y5 \  { int code;
! w& N( f5 d$ ~+ `  f4 j+ z3 P: a1 w struct Person* contacts = NULL;
1 |3 J% t+ l0 c1 E' ]! y  s struct Person* person;
  a' [- w8 Q' |0 Q
6 R* v9 D8 ^4 B printf("| 欢迎使用通讯录管理程序 |\n");  ~2 l2 {/ z& k4 j! I5 ?3 m
printf("|--- 1:插入新的联系人 ---|\n");7 v, q, l- d, [; h7 _2 N9 v  T. J
printf("|--- 2:查找现有联系人 ---|\n");
5 I& C9 b" ^7 N& l* M printf("|--- 3:更改现有联系人 ---|\n");+ F2 N/ O+ s- \6 m9 s
printf("|--- 4:删除现有联系人 ---|\n");+ |5 Q4 O" O( Y& T. \
printf("|--- 5:显示当前通讯录 ---|\n");
" v" Z% `- d0 @$ x6 X9 G printf("|--- 6:退出通讯录程序 ---|\n");
8 |# X9 O6 h* S. X4 u: R* H; b  h& Y
while (1)- i2 N; w* t7 W& Y$ J
{
7 g* u  N( L! p+ [" I1 ]  printf("\n请输入指令代码：");
% f5 N8 ]: k* `7 _3 g7 y4 f0 v6 V  scanf("%d", &code);
2 J7 l- x/ t3 ^% D0 p$ Z  switch (code)
9 v* `' V. g$ z/ S' |9 g  i; K  {* j' }2 I  ~9 f3 k/ s' G
  case 1:addPerson(&contacts); break;! c: U5 z; J7 |. Q# f. r9 h
  case 2:person = findPerson(contacts);. M5 W/ w4 k. y. E
if (person == NULL)
! e! k0 Y' Q" v* Y {
; x+ A; C) y3 X" N3 p5 z/ q printf("找不到该联系人！\n");2 P+ T6 c# l) J  g, v2 ]
}
; W  S6 k5 S! F1 a. V+ y else
; @; b$ s* h" w; u {9 ]8 \) B( }/ V- ^. z. |
printPerson(person);! P; ?# _1 b/ v7 p% b
}/ A& C2 Y" W! v* |$ z  _; H
break;
- F# `, ~& L: c4 _2 O: R  case 3:changePerson(contacts); break;' W$ h( _# X8 {( {! ]1 G$ z
  case 4:delPerson(&contacts); break;
5 T/ K/ }# Z( k' `  case 5:displayContacts(contacts); break;) L- b2 ]& E+ E8 K. V
  case 6:goto END;
$ W" S! T" _( W, ?9 U( v  }
, ^/ w( x+ S5 C! _& o# Z% ~/ D }
6 C# D" q7 x+ I# Z( X! E3 J
" ~4 D& y9 L: ?8 E% @. r4 [4 OEND://此处直接跳出恒循环  X. h7 Q* t# b/ g1 r
releaseContacts(&contacts);8 p' C$ K( I* E& U- O* s; V: U

+ U2 H$ f# E9 i' d* N( w( O& S return 0;
4 i" {5 N% q, U# p! n" f. J; h1 T$ {& y, M
}
运行结果如下：
//Consequence 04 V1
& E1 k" k' ]$ N' v8 t| 欢迎使用通讯录管理程序 |0 r' V& Q1 i) C. C. T4 ]4 c, ?
|--- 1:插入新的联系人 ---|
( n6 d' w1 j+ e- ^: r6 Y1 F& y: m|--- 2:查找现有联系人 ---|
( M5 l  `# r+ N|--- 3:更改现有联系人 ---|
4 ]# ~. W! X- q: q|--- 4:删除现有联系人 ---|
2 Z& \) ^: T, J( p- ~$ ?- ]5 _|--- 5:显示当前通讯录 ---|
; O) J6 D. w* M% w2 r|--- 6:退出通讯录程序 ---|: s. W2 m% b/ W: N5 G3 d4 L6 t

' S, n7 }# _* x. C& e! D0 b) k请输入指令代码：1. C0 A/ D' i+ m$ Q5 F
请输入姓名：HarrisWilde
. Q: ^4 [3 S8 P4 ?7 V8 g# [% q请输入电话：01011113 ^3 Z% F) ~7 A* _2 P- }; [

2 m/ X9 M# o5 `1 o请输入指令代码：1% K- Q  P/ R! E  o2 S
请输入姓名：Jack: ^# P7 p, m" F
请输入电话：01011124 f( S0 V& Y6 ^: x3 Z
3 ~) f7 [% C( z5 T
请输入指令代码：1
1 J( E) w% L! B( x/ x: z* S6 [请输入姓名：Rose# m- N/ H3 Z# l! Y; Z% B$ G
请输入电话：0101113* w) z4 f) G: q4 U5 N5 i
  K; v) u! Z/ K. ~- Q! V
请输入指令代码：2# Y* |. ^1 c# J- B
请输入联系人：HarrisWilde
9 Q3 T' ]& Y% L7 d) I# D7 b% F( E联系人：HarrisWilde
" F0 p9 E  k$ A0 p' R2 k电话：0101111
) D, D3 o6 }, o/ V; n9 d5 h& X1 u- M. X* a( r8 }1 A
请输入指令代码：2
# s6 U% O. h" K9 }  j请输入联系人：Mike3 z. [  ^! _4 G4 J1 j8 Z
找不到该联系人！
/ K: G6 p" t3 r9 l
, S) z- F" Q0 E1 _5 a请输入指令代码：5
- U2 r# |# x" K- q$ N联系人：Rose7 i! |3 }" Q, p# l7 h% i8 c
电话：0101113
: E/ E4 z! ^: m! c) N联系人：Jack
) a" S& `# N& k5 Z6 x0 \& y' v) R电话：0101112
: S+ n8 O/ ^/ j& z+ z6 P联系人：HarrisWilde
; w: T* b: v6 I7 Y/ }8 a) H0 ?电话：0101111  Y% Q0 S+ J2 X$ p# h

+ ^- D  ^+ S$ y  I请输入指令代码：31 k0 N! S5 e* K" G) n
请输入联系人：HarrisWilde; I& b5 J& m" R9 S
请输入联系电话：0101234/ J4 S& p8 O# N: Q/ a
- _" m% e7 [8 Z3 k+ W! c0 \
请输入指令代码：5
, y( e& Q+ i/ e6 n; Z  {0 r联系人：Rose! Y5 {4 d) m+ E' [2 g7 @
电话：0101113
0 c' j5 t& q* _/ x: k联系人：Jack" f+ D6 l8 N/ q9 R! Y6 z4 Q% Z1 o
电话：0101112
0 s: K- V: w3 S% H联系人：HarrisWilde! g( ^" c1 ]# N# F; W* D
电话：0101234
# y9 u6 v. ^2 t# m1 e% `8 {8 `4 I4 E5 g9 `" B& I+ f# D
请输入指令代码：6
下面加入内存池：
//Example 04 V2$ J' J# D- }' s: j& ?) J- n* K% a
#include <stdio.h>
2 o6 R3 V4 p$ g$ d; Y2 z4 G#include <stdlib.h>4 U1 o/ }/ I; C% m& D
#include <string.h>
- t9 G6 C9 n  e1 ]: ?4 [0 Q* a0 G& J* y
#define MAX 10246 B4 L! W" [" S% R2 [' n! {

1 R9 C$ I2 R% k% p$ Y- Y6 Sstruct Person
' _3 G& H1 {' x* R+ k5 S) t' K{9 H! V% e( y/ X! B* X5 \( e
char name[40];
4 ~( M5 A7 ]7 \( z char phone[20];
0 ~' z0 I& ^( E& z) G, G struct Person* next;
7 x9 Z1 x4 T9 T* d+ B- R  t. M};
' l. f0 o5 e) K$ q  t1 o0 ]  A7 C% t* R4 o+ A% i
struct Person* pool = NULL;
* V; U* |) M4 v4 P. Kint count;8 U; `/ f8 q- v" b  ]" g
- O+ _+ Q. W0 L$ r  n
void getInput(struct Person* person);+ ]! _8 i- i: t' [) Y- D
void printPerson(struct Person* person);
! E  o) Y4 d8 H1 U, g. ^" K% tvoid addPerson(struct Person** contects);9 O; R" b; r- u; z7 I* F4 b
void changePerson(struct Person* contacts);0 S# `# a# g, U8 `/ X
void delPerson(struct Person** contacts);
% U0 {# O4 W, H  V6 H- i0 Xstruct Person* findPerson(struct Person* contacts);
( y# `0 t/ o7 D3 ^void displayContacts(struct Person* contacts);
5 {( B; ?: x8 [) h0 j1 D" H) evoid releaseContacts(struct Person** contacts);
; ~! [* W4 F7 M, E3 q. n- ]1 Dvoid releasePool(void);' _, B/ U) H0 {% c; S0 w: L1 ^
2 |/ i/ g3 B) [
void getInput(struct Person* person)
" U; |% f. `; D9 n{  _& q8 U- s5 l. i2 @0 Y& n+ o
printf("请输入姓名：");
) \7 n* \8 g. w2 W- W# Z' I scanf("%s", person->name);
  j7 Y6 E( D# c1 N8 b printf("请输入电话：");/ g) ?$ t- \- q! G2 G7 I% P
scanf("%s", person->phone);
: x) ^; l5 }, K}
4 b% _' m! t! ~3 b# G5 i) @
- t" q* L: n6 `1 L( J# xvoid addPerson(struct Person** contacts)9 l1 C; ^* p! Z# A& H7 [7 V
{
6 R/ Q5 D1 k# w: T struct Person* person;' ]/ ~& o& p6 D* k* O' Y
struct Person* temp;  t, W2 {% W& z$ p* i' T/ a
5 }) X3 T- U- \& ^3 K* ?. h% K
//如果内存池不是空的，那么首先从里面获取空间
7 c$ {- F' P- {& B: M) E" V if (pool != NULL)4 r8 X/ N% s) F0 l, w# r1 K0 x
{/ y1 k: e* a( x3 B0 A% Z  d  R
  person = pool;& M2 ?- |, u) N4 e
  pool = pool->next;
. V- R+ ?+ S. D; \7 I  count--;
- d0 z. [$ c9 J }
0 h3 Y& K, ]* x& P7 D //内存池为空，则直接申请
5 H6 h$ `- i- J' Q else  Y5 Y+ g( v  x1 ^; x
{
8 @7 Q. b0 l' A' G  person = (struct Person*)malloc(sizeof(struct Person));
8 [. Q: l' @; w  if (person == NULL)
4 S5 S3 u  V" V0 B% R  {
9 J2 H+ Q7 L0 }; A; | printf("内存分配失败！\n");
- [5 z/ y6 ~& L, Z3 Z: g' W exit(1);
; D4 {8 q  }0 z" ?6 O  }
; s/ x1 |5 |9 B! ^) S1 V7 R }
' v- J% {+ U; Y; e/ I7 }' T; s+ X6 f* ~" v0 V2 a8 Z% l: V& f1 ]$ j& w& b2 |
! a- [* S( l" B5 [; I1 t& \: V
getInput(person);9 S- {# B8 r6 V6 R/ x' \. U

( j; c" Z! Z5 S7 p- y; X" }$ E4 K8 t; R //将person添加到通讯录中
# e- p! c) C+ [6 Y if (*contacts != NULL)
) ^; W; U+ l: V" _/ r5 ?  i5 j! Y: ] {" l% S( v$ `, d6 q, ]6 e7 Q, z
  temp = *contacts;* P- m8 H! t$ b: V) [
  *contacts = person;' D+ O$ h$ j( D. P3 D! l
  person->next = temp;. I) Z8 p9 M( t0 T5 F
}( w8 d9 a  A0 F
else
1 d& b1 v" r  |: H8 J- a {
0 W% _7 H1 C% F! P  *contacts = person;
; m. \& Q' Z" m: N( P  person->next = NULL;  c& f- v% Z# v
}  Z" f6 _& q7 k$ z
}
# G) K$ C: T8 I: Q9 j; g* C% l# z2 z8 Z/ i, x; ?5 ?6 j
void printPerson(struct Person* person)
2 {6 m# |- b" F$ p4 E0 Z5 Q% B9 N& u{, v$ T" X9 A/ l3 F
printf("联系人：%s\n", person->name);3 s* P! ^7 N4 X! ]
printf("电话：%s\n", person->phone);. D1 _1 u6 H9 U: ^! t! ]6 h# s
}8 l4 m, ?) h# D* ~' W

% K; w- W2 j; ~" J$ x( l/ nstruct Person* findPerson(struct Person* contacts)
7 O7 ~$ `8 G4 r8 {{+ _  f. S7 ]  k) f) I* y
struct Person* current;: I% |8 m' m/ H
char input[40];
( X! p5 L$ o& e0 `: h" z& A5 j
! w* {. Q  U6 ^' M printf("请输入联系人：");) L/ C  g; C& o: c; s: w
scanf("%s", input);0 s6 J6 M( u8 ^7 {! D% U
& V% C0 h; f) X) D; n3 S
current = contacts;
5 p7 ]9 T  Y8 M% f! z! | while (current != NULL && strcmp(current->name, input)). m; W) u3 C- i
{
% ?$ g  x& Y8 F7 O' [  current = current->next;
, q( i. {& h- C }
0 a! M3 w) {, U; e, c  V
2 I# S# q9 \: }# e  o  K return current;% a* a" f& V: L* Q
}
1 g. _! x8 H2 o* J0 s
3 s/ i7 D# c! r6 C/ Qvoid changePerson(struct Person* contacts)
* ^' Z8 `7 {7 [, [% X  P{
* f" ~4 ?/ L9 U8 Z& u, R( E0 x struct Person* person;
! |6 h/ J& Q/ C6 H. b; ]( O) o& V
* h: n+ c! X9 o, O( Z% F( X0 x" \ person = findPerson(contacts);) _. y" G  N) Q
if (person == NULL)% G& j$ t* i$ a
{
9 @" m! K5 ]- q$ C  printf("找不到联系人！\n");5 @& h+ b" H- j6 v" ?
}8 S4 C  @9 ?0 R) w% {- d
else
0 R# F1 g6 ]/ G6 u2 l {
0 q+ C# w, K: |; G' f2 \  printf("请输入联系电话：");8 o( W0 M- }5 l7 H4 m+ h! r4 s
  scanf("%s", person->phone);' }& N6 Q9 h' A/ T5 h' }: U) A
}3 e. Q2 E* m2 I* y
}( a: K2 G0 ]2 E

  W2 w# P& c5 H9 s9 `# Fvoid delPerson(struct Person** contacts)) I" ]4 f) k# G. y! q8 g+ W
{9 A6 _8 t3 A2 o: E: d! {
struct Person* person;
/ R' [- `% F, e struct Person* current;; ^5 Q# G4 ]# r& q: X
struct Person* previous;
; g0 P+ `" P0 H0 h( s/ L struct Person* temp;
( `6 [+ s( U+ v! [ {
+ H$ j  y& j) o& ?% ^8 _- n1 `& U. p7 J6 X" m. W
};  h" P0 I6 U9 P  A0 C7 k

! X0 s4 d7 ?: A! g' N" `4 o+ H  ] //先找到待删除的节点的指针% N, @, F& ]% u. a' [/ w2 n
person = findPerson(*contacts);/ g- b1 t; Y$ R# ?) b+ D
if (person == NULL)# S( a% w( z. x( Y& z6 k6 G! k
{
* _8 c4 q/ p1 A' ?9 O5 V  printf("找不到该联系人！\n");
7 u: y6 R& w6 c' E }
3 F7 A* I: |& B' } else& \9 g3 C9 r% N9 V, K
{
1 _- O, J- J  |! j. U  current = *contacts;: |1 i- K1 V" E7 P: g* V
  previous = NULL;
8 S; t6 \! ]7 s1 ~* p- R: @
: E; L  O' Z/ i$ q. C7 o, U  //将current定位到待删除的节点
9 c0 H3 L) V8 i) L3 I- R  while (current != NULL && current != person)* \; m. W6 N9 ?  B& b+ s
  {
, o1 e+ ?) w" g9 Z& [* I, } previous = current;8 g3 }& E( @) q3 p# m0 c/ T* A
current = current->next;
& k7 d1 h: ~$ a( p+ C: P* G% ]  }
  `& s1 |. l" H0 s: m- W& Q/ l& W. M! U1 K+ N# @
  if (previous == NULL)  }6 F' v% ~3 Q
  {
3 k; s+ S; E) a0 k" h* x3 C //若待删除的是第一个节点' U% g+ }8 F! _1 D
*contacts = current->next;
( y, h' o( _- S7 p/ i: k  }
4 v, V2 s' g# _! F& G  else3 ^6 L) X- a/ h# p; c+ l
  {
+ x5 |' l0 ~* u' d1 ]( h5 b8 e0 o, I //若待删除的不是第一个节点# Z  H) g- Q! k" s
previous->next = current->next;
( P1 d( Z0 _& j7 U5 Z; ^  }
% `1 l6 H4 U! M) @1 R& J& U5 t3 T. a0 H, z" a
  //判断内存池中有没有空位! E2 K+ ]6 |! l7 ^. e
  if (count < MAX)' v$ p  G  W+ {
  {
4 D: L+ n! u- X. L //使用头插法将person指向的空间插入内存池中
2 d3 x! z, L4 J" ]  \$ q6 {+ N9 d if (pool != NULL)
# v9 ]" G( ~0 X. ~ {
0 t% Y2 d- k% x2 t/ t( E temp = pool;* w7 }+ ?: \( _& e& t1 P; z( `
pool = person;
* l8 q8 h: W  Q" A person->next = temp;
" T' A0 P8 U, ? }/ g( ]' N. U6 g6 ^; R" ^  k" d7 J
else
8 Q+ Q( q6 i3 O; D7 Z# @, U# ? {3 J- |1 }  q  T' n
pool = person;
2 A& G7 A# R( x; P person->next = NULL;& Y, z3 u0 k: B" k
}
4 {, ^/ u; r% x  p$ r& c$ ` count++;6 J0 \9 f  ]) p( \9 v. D
  }
% B6 ~* f: j0 C  //没有空位，直接释放* f  Q0 n# \* M8 K  v
  else; J/ z- h/ t) Y
  {( e1 @3 E" y  g' w  V! O; ^1 C
free(person);//将内存空间释放* A; d/ [* b- F
  }
7 D9 x4 j* \2 n/ }8 p# w$ n. [ }7 G- D1 K1 ^6 j& F0 A+ q3 q
}8 q( {; I9 h) A

8 B. U2 F. e5 `, Q# @" `  q3 qvoid displayContacts(struct Person* contacts)+ o# p  p0 y* Y/ ^$ f6 t, c
{
8 V7 N+ M5 e1 _# S struct Person* current;
4 L; T3 Y  s: z
  q0 I. k0 W) A, d+ O1 z current = contacts;
, K. t2 m7 i, `! [ while (current != NULL)4 ~% e* J4 G/ f; O$ [
{
6 v% O2 ]2 F7 V. }. }  printPerson(current);8 O9 j/ M) E9 ~# U: H/ o  C
  current = current->next;
5 E6 A4 s6 v0 J8 X }
  O! s1 F: ]9 g7 m$ S}
- v! ?8 q- q; u- O/ Y1 ^, l8 i
$ ]6 j, s# J* Y+ ~$ i. Uvoid releaseContacts(struct Person** contacts)
4 V3 R8 H# d3 a0 R# w/ a{
struct Person* temp;
* k0 |( `; G1 @( O6 K# S8 f  l: Y( h1 e; M4 ^, s4 c, J7 J# ~
while (*contacts != NULL)! M8 @; D" [3 E) m% \
{1 Q4 A3 W0 T& o9 H+ s# \; A* d
  temp = *contacts;; D5 \$ l5 \/ c
  *contacts = (*contacts)->next;
8 ^* E' v* L  o% y  free(temp);
$ p4 d9 r3 \( q }0 u* q! x* u' a" _) s* r4 ?+ @9 |
}
0 R4 y% W  H4 H! ^9 Z* E4 n! w1 H+ [* n8 `8 L& A
void releasePool(void)4 ~  Z2 [3 K4 Z" r" T8 k3 _! _
{7 R. N/ \4 Z3 u3 z- f6 Z
struct Person* temp;$ L1 K2 N7 W/ b+ v9 K$ A
while (pool != NULL)
. L4 R; F, [% g$ t {3 l+ _) w1 x8 _5 E4 v5 H! A
  temp = pool;
* B! y! F' y  k% R  pool = pool->next;
; H# D* r. ^4 o$ y  free(temp);
& v% X+ B# \: I6 M4 n. }: i5 S' g& d4 n }) r  O+ ?% b- s3 S7 W* T
}$ A1 z; Z/ n+ L3 h. H

% \. W  b) g. B6 jint main(void)( f! _! q  f( Q  Q/ G5 ^  ~
{
! a& v: L5 }5 b8 v int code;% G* S7 Z( g- P4 C+ N0 v
struct Person* contacts = NULL;* D* T& o) L. d) B5 g7 g& v
struct Person* person;
1 p: r- ?$ E1 c! a& m9 b( h% Q; {$ p$ N5 T; H; V
printf("| 欢迎使用通讯录管理程序 |\n");1 L$ `* P9 p: l4 E; q. c
printf("|--- 1:插入新的联系人 ---|\n");
- }, K( J2 o* K5 o printf("|--- 2:查找现有联系人 ---|\n");
1 \3 B" Z$ L# h printf("|--- 3:更改现有联系人 ---|\n");0 O6 I7 k3 K; H
printf("|--- 4:删除现有联系人 ---|\n");' l3 ~( X$ D2 b3 H: M
printf("|--- 5:显示当前通讯录 ---|\n");1 A) ?0 H. }, J& P! _
printf("|--- 6:退出通讯录程序 ---|\n");  M: O4 g4 w9 a: B0 f
" ]: Q/ _6 y+ D6 c: `
while (1)2 J5 x, |* j& ?
{7 W- ~( `# h5 t/ f! \
  printf("\n请输入指令代码：");
( {% N/ W$ A, P3 v- j  scanf("%d", &code);6 q! h% Y* B% F+ g% w! m
  switch (code)5 f! o% ?( S+ r; t* x1 m
  {* M6 f; w/ P' p/ j" {2 T# z
  case 1:addPerson(&contacts); break;
1 Z8 D% e$ z9 K  case 2:person = findPerson(contacts);
! k5 D* C6 c  Q  H if (person == NULL)
8 N, O$ c) p3 i {
4 D3 N8 ]1 A1 h6 z printf("找不到该联系人！\n");5 i8 Z9 A/ p) p% Z5 @8 Z$ A
}
: o; ], D0 n' r5 X else+ [( c( B9 G9 ]# x& c
{- w% Q7 g7 R: n7 w3 E4 e
printPerson(person);% @6 Z3 S# [: N  e5 L( f
}
6 ^9 n5 j$ y! k, o, m2 W" { break;
  r" L" L) [: C  case 3:changePerson(contacts); break;, X9 c: r' x8 W
  case 4:delPerson(&contacts); break;
4 G3 H' c+ V# L( J2 l$ `$ z/ V  case 5:displayContacts(contacts); break;
+ i+ W- S, w/ O  case 6:goto END;
( [4 x' K: F  X: H! e  }
# q, Q( f+ p& `0 _0 Z2 M }0 U8 C& G* }; H$ I: R+ z) I$ R
, F3 [( m) M3 v( L4 W5 N+ G
END://此处直接跳出恒循环
, d, ?9 Q7 N2 K. Y releaseContacts(&contacts);* n  p+ X' ]8 @
releasePool();
0 ~& ?3 a1 T7 S; Y( B5 G) l1 h+ i  @* ?* \- [4 g1 c/ ]
return 0;( W5 c! S; [) D) V8 N
' _! t5 v8 ?5 t6 t, x# f; k# J
}
typedef
* R- w# I) U. Y3 C7 v- Q, @

给数据类型起别名
C语言是一门古老的语言，它是在1969至1973年间，由两位天才丹尼斯·里奇和肯·汤普逊在贝尔实验室以B语言为基础开发出来的，用于他们的重写UNIX计划（这也为后来UNIX系统的可移植性打下了基础，之前的UNIX是使用汇编语言编写的，当然也是这两位为了玩一个自己设计的游戏而编写的）。天才就是和咱常人不一样，不过他俩的故事，在这篇里面不多啰嗦，我们回到话题。
虽然C语言诞生的很早，但是却依旧不是最早的高级编程语言。目前公认的最早的高级编程语言，是IBM公司于1957年开发的FORTRAN语言。C语言诞生之时，FORTRAN已经统领行业数十年之久。因此，C语言要想快速吸纳FORTRAN中的潜在用户，就必须做出一些妥协。
我们知道，不同的语言的语法，一般来说是不同的，甚至还有较大的差距。比如：
C:
int a, b, c;. N2 E( h8 s" H
float i, j, k;
而FORTRAN语言是这样的：
integer :: a, b, c;, Q  i9 g& P( v6 z+ P
real :: i, j, k;
如果让FORTRAN用户使用原来的变量名称进行使用，那么就能够快速迁移到C语言上面来，这就是typedef的用处之一。
我们使用FORTRAN语言的类型名，那就这么办：
typedef int integer;; ~' t2 D, ^  f$ C8 E
typedef float real;8 i2 b& K, T7 u7 T& @
0 ?! w3 v# F% \2 y7 ~6 P
integer a, b, c;* q* D  a% k! g9 B% G" T
real i, j, k;
结构体的搭档
虽然结构体的出现能够让我们有一个更科学的数据结构来管理数据，但是每次使用结构体都需要struct...，未免显得有些冗长和麻烦。有了typedef的助攻，我们就可以很轻松地给结构体类型起一个容易理解的名字：
typedef struct date
* O) }9 G( e" P- @1 W8 d9 A2 C{
$ _9 _0 w( o' v" ~* a3 S  K int year;- N: I  v# R! M7 P1 }
int month;
0 }  ]% t- N3 c0 G; l9 d int day;
0 ]; }) G, F5 W* Z# l- c- N} DATE;//为了区分，一般用全大写# U- @5 {- F, e* k5 U" V4 [; l

5 B2 u1 K# P* b8 W: d& Xint main(void)
1 J6 A* W$ F1 u# x7 g, e{
9 J6 q6 p# o3 Z/ D+ H' A  s DATE* date;
" ?1 o" X- A5 d6 [6 J ...
; y. @4 e3 h1 P) m# D; A}
甚至还可以顺便给它的指针也定义一个别名：
typedef struct date
0 E& ^) \+ ^( K! _/ e) [{
( z3 K. `; d9 `# F0 f+ o4 A0 |6 ] int year;
" F0 U; W, J; k# T: F int month;' s6 Y% ~( s( B( P6 R, B9 u
int day;7 R* v) G$ Z9 o% E. H
} DATE, *PDATE;
进阶
我们还可以利用typedef来简化一些比较复杂的命令。
比如：
int (*ptr) [5];
我们知道这是一个数组指针，指向一个5元素的数组。那么我们可以改写成这样：
typedef int(*PTR_TO_ARRAY)[3];
这样就可以把很复杂的声明变得很简单：
PTR_TO_ARRAY a = &array;
取名的时候要尽量使用容易理解的名字，这样才能达到使用typedef的最终目的。
共用体
1 X. W1 I3 y4 x% C3 j# x

共用体也称联合体。
声明
和结构体还是有点像：
union 共用体名称
$ s$ u6 y# Q5 |. K+ I0 {9 B{
" f3 W  B. x( N. e 成员1;
* G3 R  a" [, t1 A. M8 R 成员2;
" U8 O  g5 Z1 P0 C, u; T 成员3;
5 T4 ~7 c1 z8 D- b- T( {; s};
但是两者有本质的不同。共用体的每一个成员共用一段内存，那么这也就意味着它们不可能同时被正确地访问。如：
//Example 055 k- u2 z5 r6 W9 U4 B' _/ T- c2 x
#include <stdio.h>
. `; |, {8 B1 ?0 \5 T) P/ u' h#include <string.h>6 q$ l# \4 A7 Y! V

. M( o$ n! t; P1 vunion Test
4 T5 U/ C2 X( k{' K# P* E+ b8 Z1 }7 M6 y
int i;
1 q' h2 \; s; J- T$ p double pi;: k# l5 x- ~$ O) y6 s
char str[9];
) E! I- p* @* I( I};
, p6 V5 |6 E- Q  I# q0 f5 P5 E; W& s* U3 d
int main(void)
  `& R6 _0 E( W/ V$ w' q& ^{. O# B9 l% @% c! Q- d
union Test test;3 ]: q+ E% g. k8 K! U
7 l* T& @: R2 p# W3 C
test.i = 10;/ D. g  [; V" T1 ^3 c! [+ e3 e
test.pi = 3.14;/ \. @7 }. J1 ?# X* [2 V
strcpy(test.str, "TechZone");
: x' q# B( r& K' G5 b0 f/ [$ h& Y5 _
printf("test.i: %d\n", test.i);- W: T  g% a7 H$ \2 D; ~
printf("test.pi: %.2f\n", test.pi);2 G+ H# J* m- c+ ?% I* Y
printf("test.str: %s\n", test.str);2 h0 j. l7 Y7 V! q5 W+ \
' s8 o$ v% w* M* ~5 e6 D5 H2 z
return 0;
8 ^. c* M: l& P}
执行结果如下：
//Consequence 053 S8 [* V# O) m5 n/ d4 W. X. F
test.i: 1751344468
2 |& k+ d5 M* l  q$ R+ ~test.pi:3946574856045802736197446431383475413237648487838717723111623714247921409395495328582015991082102150186282825269379326297769425957893182570875995348588904500564659454087397032067072.002 S4 {# `- ^. }7 g
test.str: TechZone
可以看到，共用体只能正确地展示出最后一次被赋值的成员。共用体的内存应该要能够满足最大的成员能够正常存储。但是并不一定等于最大的成员的尺寸，因为还要考虑内存对齐的问题。
共用体可以类似结构体一样来定义和声明，但是共用体还可以允许不带名字：
union
5 a. ]8 \: B+ K% v2 r1 @{% g6 J: k# O; l' n3 S( k. e: g3 c' i
int i;
4 l& C+ O+ p/ N; H7 r4 d char ch;; m8 R$ T$ }* z5 ~+ N2 d7 y
float f;' J' f: o" u# {! n5 a
} a, b;
初始化
共用体不能在同一时间存放多个成员，所以不能批量初始化
union data
: |1 Q! ^* }( O3 }% F{
1 m  V  l, V8 b: w* p2 o int i;( ^1 I  q% c3 K: l- f/ h
char ch;
4 p; F' Q) }  p% w) | float f;$ }3 m# |4 C  `& }1 Y* C( [+ w
};% y- u) f! h1 B! Y& s
4 F2 ]; p3 W) y) X5 V! Q# ~) O" A
union data a = {520};       //初始化第一个成员2 f9 s7 g% H% U
union data b = a;          //直接使用一个共用体初始化另一个共用体
: }+ \* N5 S- W4 l& c, \union data c = {.ch = 'C'};  //C99的特性，指定初始化成员
枚举

/ k9 H6 H, ^9 M# i% Y4 Y) z
枚举是一个基本的数据类型，它可以让数据更简洁。
如果写一个判断星期的文章，我们当然可以使用宏定义来使代码更加易懂，不过：
#define MON 1
0 P* j6 z- h/ M#define TUE 2
2 A3 s$ X# n2 i- b. C" z#define WED 3
9 D* j2 t1 Z, f# H! G#define THU 4
5 w4 O1 z$ S3 o5 s. A#define FRI 5. H* N1 j) L( N; v# [4 N' p
#define SAT 6$ G, F) Y, ^' J5 i9 x5 ]' ]% h  F
#define SUN 7
这样的写法有点费键盘。那么枚举就简单多了：
enum DAY9 w7 B  Z- L9 R4 ^; T6 o" h; q
{
* Z" d+ @$ |6 C3 _0 r# u    MON=1, TUE, WED, THU, FRI, SAT, SUN5 q) i# U- ^7 O8 h/ A2 O# Q
};
❝
**注意：**第一个枚举成员的默认值为整型的 0，后续枚举成员的值在前一个成员上加 1。我们在这个实例中把第一个枚举成员的值定义为 1，第二个就为 2，以此类推。
❞
枚举变量的定义和声明方法和共用体一样，也可以省略枚举名，直接声明变量名。
//Example 06; \" H7 ]- }$ b& f; z% J
#include <stdio.h>! E( L* v1 Q( v9 w
#include <stdlib.h>
& R$ C' L, \1 [  F& y0 v
* g' B8 P3 O6 E+ I, B$ V1 ?  Z, n2 jint main()
, ^& M; }4 ]# h" N9 ?8 P3 V* P{1 j/ D" @" [" C  M2 c
( y: I4 N% x! }" b4 y, j
enum color { red = 1, green, blue };4 ]1 ^3 k* M" H# [- J1 o* x& z4 F7 `

9 ^. {  H$ S9 p% X enum  color favorite_color;
* u8 c# y+ ]8 J+ J* A5 g% L8 w* B* Z  @1 W
printf("请输入你喜欢的颜色: (1. red, 2. green, 3. blue): ");% ]% L& i: Y) Z
scanf("%d", &favorite_color);
8 ~. L8 w+ {3 f
/ R' {0 f+ F' O7 o6 c& k //输出结果
$ g; k2 `, i/ Z2 f) [  i# j/ ] switch (favorite_color)
5 j0 j4 n3 x$ ]5 ^% f' S" x3 g% g* \. F {4 I* ^$ p# ?/ o) T8 i" ?+ z
case red:
% Z6 R7 ]9 H* ~2 f       printf("你喜欢的颜色是红色");8 `4 Q' u6 d8 V5 U
      break;
1 H1 M2 x% p: f; {2 v case green:# {9 H2 N3 o9 |5 Y
      printf("你喜欢的颜色是绿色");
8 K# G  \7 Q0 p3 R  W/ |- D       break;
, @% y! [) Q: ^5 D; E  @" r  d& A case blue:
) M2 `8 W* m5 [       printf("你喜欢的颜色是蓝色");) D; ?# l5 R/ A1 H2 f6 d
      break;1 |) ~' G7 O2 c/ {1 [
default:
, e, ~) l9 O# o8 B8 |* D# K       printf("你没有选择你喜欢的颜色");7 q. |& g  g" i3 V% s/ V
}
- C* P- P/ }/ N, n, m1 Z
" b* B, q* _4 @ return 0;% B- U- J: @3 @9 Q1 b7 V6 z6 P; W( }  w
}
执行结果如下：
//Consequence 06
( [$ b! ~' X# p1 V' b请输入你喜欢的颜色: (1. red, 2. green, 3. blue): 3! L! _9 c" Z$ f4 w
你喜欢的颜色是蓝色
也可以把整数转换为枚举类型：
//Example 07) ?8 J, w0 O# U. `5 D

! e( o/ ^5 O( l7 @2 u#include <stdio.h>
9 F. m  U4 o+ e5 r0 Q5 P) F/ [0 P#include <stdlib.h>
/ g9 ^3 U% e% Y/ s0 L' @. q4 r9 j+ p% u& _
int main()# T0 v: M8 V& N3 t  `4 [0 x4 t6 @' L
{
1 g0 L! D. r! g enum day
2 q% u9 p/ |6 t" e {; W: @" F5 n7 `6 U! Z/ H$ o6 R
      saturday,
1 U1 ]+ |' ~6 @' [$ J; T       sunday,
5 j& A$ b/ ?" b) S       monday,
3 i% E8 O$ t; e3 K       tuesday,
0 m( u+ i  r  ?( y9 r       wednesday,$ u" d. {) N" T, g
      thursday,2 P, d( R& D& y
      friday  K3 Q5 E6 f% H% v& ~# t
} workday;! ]1 ~* L1 r4 Z5 ~
3 x' h% ?# i7 b5 m6 D2 m3 v; W
int a = 1;
; ^1 M" c% h2 n& t: Y! f1 L: c9 A enum day weekend;: O' {. Y. @) [
weekend = (enum day) a;  //使用强制类型转换
% C/ O% o' V4 L: ? //weekend = a; //错误
6 g0 y6 M& [# R  f0 F& T* Q7 ` printf("weekend:%d", weekend);
/ ]5 Z$ k2 x  |" A return 0;6 y' Y: b6 u) G4 q7 w
}
运行结果如下：
//Consequence 07
. o; j# E7 p+ T: Iweekend:1
位域
; Q9 d- i% W: x6 m' c6 q0 A

C语言除了开发桌面应用等，还有一个很重要的领域，那就是「单片机」开发。单片机上的硬件资源十分有限，容不得我们去肆意挥洒。单片机使一种集成电路芯片，使采用超大规模集成电路技术把具有数据处理能力的CPU、RAM、ROM、I/O、中断系统、定时器/计数器等功能（有的还包括显示驱动电路、脉宽调制电路、模拟多路转换器、A/D转换器等电路）集成到一块硅片上构成的一个小而完善的微型计算机系统，在工控领域使用广泛。
对于这样的设备，通常内存只有256B，那么能够给我们利用的资源就十分珍贵了。在这种情况下，如果我们只需要定义一个变量来存放布尔值，一般就申请一个整型变量，通过1和0来间接存储。但是，显然1和0只用1个bit就能够放完，而一个整型却是4个字节，也就是32bit。这就造成了内存的浪费。
好在，C语言为我们提供了一种数据结构，称为「位域」（也叫位端、位字段）。也就是把一个字节中的二进制位划分，并且你能够指定每个区域的位数。每个域有一个域名，并允许程序中按域名进行单独操作。
使用位域的做法是在结构体定义的时候，在结构体成员后面使用冒号（:）和数字来表示该成员所占的位数。
//Example 08
; X1 k- ]* O% l6 Z9 e7 |#include <stdio.h>
) B/ n7 k1 {* N) y
9 I" p/ }2 _# U: Cint main(void)
! W+ L8 s/ [' O! K, H& R9 P{
' |( d! T* k( g struct Test
) L3 t. J# f' ]& m6 V; x {
0 K# t/ X9 H* ]) B9 h2 q: s  unsigned int a : 1;, n7 ?/ {# w3 B# O
  unsigned int b : 1;
" Y8 t) i6 g. y  unsigned int c : 2;1 E) A, `  b# \7 B
} test;) I% M) \) e+ r) R
8 S; U2 n1 K2 P0 c# s2 U
test.a = 0;
! h' W. P+ ]1 k$ c3 B1 p  y: { test.b = 1;7 x* K2 i: Q/ ^, m% ^% s1 Y0 D
test.c = 2;
& d  C% R8 }2 S9 Z4 h- g$ J) s7 S
printf("a = %d, b = %d, c = %d\n", test.a, test.b, test.c);
4 V. c& \! S+ l printf("size of test = %d\n", sizeof(test));
* I* v5 v) j* R9 n5 E/ e  `+ I1 H, U+ |. b
return 0;4 [8 R( Y7 t; m
}
运行结果如下：
//Consequence 08+ o- |7 @3 [3 P8 k' ]
a = 0, b = 1, c = 2
% z+ C' _9 T5 l% t+ S- Usize of test = 4
如此一来，结构体test只用了4bit，却存放下了0、1、2三个整数。但是由于2在二进制中是10，因此占了2个bit。如果把test.b赋值为2，那么：
//Consequence 08 V2! R- ~1 [/ A4 i: \
a = 0, b = 0, c = 2
6 u9 S( |( \! r$ tsize of test = 4
可以看到，b中的10溢出了，只剩下0。
当然，位域的宽度不能够超过本身类型的长度，比如：
unsigned int a : 100;
那么就会报错：
错误  C2034    “main::test::a”: 位域类型对位数太小
位域成员也可以没有名称，只要给出类型和宽度即可：
struct Test$ N' j' s# q* R& H8 M% W
{# I- M6 i3 z% H, S
unsigned int x : 1;
& a, u! x$ {& ` unsigned int y : 2;
: h% @' h: `9 o2 |( | unsigned int z : 3;) y( j9 P8 H9 q- t+ m" {6 }, v
unsigned int : 26;' V/ Y2 d& p# T. }) ?
};
无名位域一般用来作为填充或者调整成员的位置，因为没有名称，所以无名位域并不能够拿来使用。
❝
C语言的标准只说明unsigned int和signed int支持位域，然后C99增加了_Bool类型也支持位域，其他数据类型理论上是不支持的。不过大多数编译器在具体实现时都进行了扩展，额外支持了signed char、unsigned char以及枚举类型，所以如果对char类型的结构体成员使用位域，基本上也没什么问题。但如果考虑到程序的可移植性，就需要谨慎对待了。另外，由于内存的基本单位是字节，而位域只是字节的一部分，所以并不能对位域进行取地址运算。
❞
虽然科技发展日新月异，但是秉承着节约成本这个放之四海而皆准的原则，还是要注意使用！毕竟5毛钱可能是小钱，但是乘以5000万呢？

" C; ]$ D+ N6 _$ y: x" c; I7 R