C语言——结构体

[复制链接]

gaosmile 发布时间：2021-2-26 15:41

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

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

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

批量存储数据
存储不同类型的数据
支持嵌套
5 m3 a! w( u% r

结构体的声明与定义声明

结构体的声明使用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)
{
/**
- A0 R" G/ A6 ]8 E  q    *在main函数中声明结构体变量# X9 |* W0 m- _
   *结构体变量名叫info
/ n/ n; w* _( G! F: v    *struct关键字不能丢% H7 d* p$ z- }% L2 B0 T% d  Y
   */
struct Info info;
...
}

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

#include <stdio.h>

struct Info
{
unsigned long identifier;//学号，用无符号长整数表示
char name[20];//名字，用字符数组表示
unsigned int year;//入学年份，用无符号整数表示
unsigned int years;//学制，用无符号整数表示
} info;
/**# R, S; e1 W' E
*此时直接定义了变量
5 m4 u7 ~( i& o& y* k *该变量是全局变量5 t' ~: O7 C$ a* A! t0 K0 ]
*变量名叫info
& \0 T9 `8 |8 f5 n" e4 ] */

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;

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

(*结构体指针).成员名
结构体指针->成员名
) g! }: u3 L9 q. C

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

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

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

第一种方法：

#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;4 d* p  o7 g5 E/ l/ _0 V, o) ]2 c0 i, T
}; Y' O3 m. D" ^( a! r0 o
}
( r2 y9 E7 X# d" u$ n& O3 {0 Q6 x1 I( p0 o- m0 a# X. v7 J
void printLibrary(struct Book* lib[])
! @" z' z/ e& K3 s! x7 J{
( L, e' B0 i  p! O$ L; L( [ for (int i = 0; i < MAX_SIZE; i++)
1 r& m9 r/ H& V2 O! k3 T( c {; k7 u/ E: V! W/ \. n( Z
      if (lib != NULL)
2 d9 g5 L: M, }       {
. Y% G- h8 R7 V          printBook(lib);* n* ?0 O# T5 ?6 }. g8 a6 Y/ B
         putchar('\n');
9 w1 T! L/ B1 q: W       }0 I/ f( Y3 B4 V8 {$ E
}/ z. |1 {' p$ N6 }7 U. w
}+ U$ M  C. i+ z" |

) C$ i% e* ?3 S- \! K; |+ Tvoid releaseLibrary(struct Book* lib[])
' K) j* [! W" V0 H0 ]{4 i7 j# `# f1 n! `2 e% T. a
for (int i = 0; i < MAX_SIZE; i++): G9 L/ R' [& N  b
{
" l/ U# ?4 }0 y1 Y+ M; h5 T- \/ B/ S       if (lib != NULL)
- E5 p& q  j' y/ T. @' x. S8 ?* D       {
  X' T. k- ~3 h! m* m4 g          free(lib);+ j' N: h! |, ^, Y% b
      }
' O/ L$ b' c& O% o; L( Q }
$ ~+ O: m5 C+ a7 M- d}
' v" X, ]3 d( Y/ q6 V, G
, P9 {" ?" h/ s% n3 Q( Eint main(void)
9 P; M: @, ?# {1 I$ e) |+ M- `% g1 Z{/ t3 N9 W( Z. Y+ {
struct Book* lib[MAX_SIZE];, Q3 L) m$ W! u! m$ w
struct Book* p = NULL;% W) N0 O% |' ^4 E! @
int ch, index = 0;
, O2 _2 t9 Q! P2 v1 u9 A. q7 A& ^% J$ s. S3 N# [4 d* d/ {
initLibrary(lib);5 U+ N+ e: W0 [; u0 @
5 @+ \* l* l  |+ p+ ?
while (1)
* ]3 F6 I3 E! Q4 T$ i3 p {1 x' p! h9 d+ t. U$ M# k6 o
      printf("请问是否要录入图书信息(Y/N):");
1 R6 F/ O* l$ K       do4 d5 H6 |+ @1 H; G/ Y( E; s+ Y) P
      {
" g, I: ^# R4 {' z! ^+ _( L/ D          ch = getchar();
& r5 l9 G/ I0 H       } while (ch != 'Y' && ch != 'N');$ s9 K4 M/ I  Z* J
, Y! H- I1 Q6 o+ W- L/ d4 s9 d
      if (ch == 'Y')
9 F# `- ]7 Y0 Z. S( x8 O" @6 b4 n       {
7 B! e/ p" u1 N: n          if (index < MAX_SIZE)
5 Z- i/ e* _3 D& `. O# O          {
) t1 }6 r; `; B- m$ p; ?             p = (struct Book*)malloc(sizeof(struct Book));6 y" h, @; Q. X- s
            getInput(p);
( M$ a" j& Z; F* f# [             lib[index] = p;
- U3 z7 X& J! m; @             index++;9 I* A" b) G" Q8 f
            putchar('\n');
$ W9 o, W1 i/ B; C5 V. i! A          }3 p( b4 v  z) w6 m0 D
         else
- v, h, e: Q! }' ?* ^) O0 }          {4 d: s/ g. w- H* T: [4 o  O
            printf("数据库已满！\n");) E5 L, B( O3 P1 z
            break;/ z- f- l) Q* Q/ K0 j
         }& k: G/ x4 G5 ]& \) {/ Z7 `
      }( w( c3 q. g" L; s6 \+ Y
      else
) X6 I9 |5 f9 H& V% h$ s       {* s" Q& g( I1 j
         break;1 d+ |8 M8 p/ Z. a( ]
      }* x% s, @2 h/ X5 d( l/ A* @
}& n8 [, J6 }, t9 Q

6 `2 z9 r2 y( @1 ]2 H; R printf("\n数据录入完毕，开始打印验证...\n\n");5 |# W" O/ y7 \
printLibrary(lib);
& Y: k9 o% Z4 r  \& V7 T6 j2 F: ~ releaseLibrary(lib);) H5 A( u" k$ m: ]' F' Z7 p* |
2 P1 X2 W: E) O3 C/ v
return 0;
8 `; Z9 h: d! ^$ i$ B, W2 s}
6 S, ~7 u4 d$ t# A) ^# O! N

运行结果如下：

//Consequence 021 X5 F" H* ?, W
请问是否要录入图书信息(Y/N):Y
+ w; z; c# e. y请输入书名：人类简史$ ^, c) o! u& q9 e5 H; [' r- M2 d
请输入作者：尤瓦尔·赫拉利
( s4 b1 F( m* x7 }" Q! p8 ?请输入售价：32.25
2 A! Y1 N7 X! x, k0 m请输入出版日期：2016-3-4! M: p1 C8 c4 [: c/ d& |5 U# t: _
请输入出版社：中信出版集团
8 j! s' p0 ^+ d" E+ W
+ b& E4 L+ L. k$ ?3 x请问是否要录入图书信息(Y/N):N  e  ]0 e* O! k

8 c/ ?7 s6 V# S# |, T数据录入完毕，开始打印验证...
; F. y7 j0 C/ f4 k, z" l' k; Q& L$ f0 X$ h& c8 h* X
书名：人类简史2 u: M1 _5 B, q; i7 q# Z
作者：尤瓦尔·赫拉利/ |, p& k4 x9 u7 {
售价：32.25
$ \4 {  ]8 s6 m3 K) o+ _0 P( u出版日期：2016-3-47 @1 j. `4 ~! a# E. o0 B0 x: P  v
出版社：中信出版集团
, i4 ]3 @6 `* X* [: v% a2 w9 z单链表
我们知道，数组变量在内存中，是连续的，而且不可拓展。显然在一些情况下，这种数据结构拥有很大的局限性。比如移动数据的时候，会牵一发而动全身，尤其是反转这种操作更加令人窒息。那么，需要需要一种数据结构来弄出一种更加灵活的“数组”，那么这，就是「链表」。
本节我们只讲讲单链表。
所谓链表，就是由一个个「结点」组成的一个数据结构。每个结点都有「数据域」和「指针域」组成。其中数据域用来存储你想要存储的信息，而指针域用来存储下一个结点的地址。如图：
单链表
当然，链表最前面还有一个头指针，用来存储头结点的地址。
这样一来，链表中的每一个结点都可以不用挨个存放，因为有了指针把他们串起来。因此结点放在哪都无所谓，反正指针总是能够指向下一个元素。我们只需要知道头指针，就能够顺藤摸瓜地找到整个链表。
因此对于学籍数据库来说，我们只需要在Info结构体中加上一个指向自身类型的成员即可：
struct Info
0 q; y; t/ b7 \$ c+ q7 Z# x$ D{* y( j1 S& r% W  Q% v( }
unsigned long identifier;/ O* {3 G& v$ C! q8 e2 a
char name[20];
, ?5 M, ?$ f' F7 u! H& y% j struct Date date;
! Y# l& i& R( O$ O7 S- K$ h! r unsigned int years;
+ }3 J8 E4 _; y, C. P struct Info* next;8 I" g8 X" k, m8 [0 E( t! g
};& z/ J6 K: x; [) }
在单链表中插入元素头插法
这种每次都将数据插入单链表的头部（头指针后面）的插入法就叫头插法。
如果要把学生信息加入到单链表，可以这么写：
void addInfo(struct Info** students)//students是头指针
( |9 Z" _0 C% ]1 J{
0 k+ {2 l, e  n( Y5 ^5 w: {7 Z1 I; l struct Info* info, *temp;9 d4 B  [$ v' G, k7 N& ~# g9 {
info = (struct Info*)malloc(sizeof(struct Info));, Q* V/ t# d: l; U5 a
if (info == NULL)
6 l" q9 m& J* O {
' r# |+ i% D/ Z; k& g7 n  }; r       printf("内存分配失败！\n");; d- y9 ^9 w7 b& G) B/ e) y( p0 S8 @
      exit(1);% q. Z+ C9 g' {2 }3 V! N1 h  q9 L
}. P% n. o* P8 m' R
- E" p4 S9 _( b
getInput(info);5 L2 Q3 b4 f' x& H/ d! F0 E
! O3 o: y! W8 n8 O" c- W
if (*students != NULL)* k. K+ }& `& A7 k  b
{
: f* Y% Z% a2 W. M       temp = *students;0 a" M$ v& W) G$ @/ P$ h+ u
      *students = info;
" p' B6 L2 b8 F       info->next = temp;
% V1 F+ C/ p5 {' i0 m4 i" H8 } }2 l7 E/ Z- }* ?/ e1 q( `
else
{
/ m* |7 T# ^2 ?; y5 P       *students = info;
) l& [9 y7 j' w2 z' A3 ?       info->next = NULL;. ^$ }: R) u/ G9 {; a3 ^; E
}
$ ?! x& x0 D$ g* J8 `* r$ t) i}
3 x: r8 t( W& R% x# D
❝
由于students存放的是头指针，因此我们需要传入它的地址传递给函数，才能够改变它本身的值。而students本身又是一个指向Info结构体的指针，所以参数的类型应该就是struct Info**。
❞
往单链表里面添加一个结点，也就是先申请一个结点，然后判断链表是否为空。如果为空，那么直接将头指针指向它，然后next成员指向NULL。若不为空，那么先将next指向头指针原本指向的结点，然后将头指针指向新结点即可。
那么，打印链表也变得很简单：
void printStu(struct Info* students)3 a, ~0 J9 w2 f3 c6 l/ W3 h) `
{
) A8 s3 x6 w+ w  L9 R% m struct Info* info;
8 X% }' S9 `7 y% {1 G2 z% G9 b int count = 1;# m  L# K% F5 y7 U& O0 Y
, Q: o0 d# c) f7 n5 _/ p+ _
info = students;
+ o7 W4 s# Z0 }2 y. K6 n4 Q while (book != NULL)
/ B) {3 D* z  m; ~ {
7 f6 Q& Y. `' b8 s$ I9 v0 }2 p       printf("Student%d:\n", count);0 g/ H: `3 H, \$ A
      printf("姓名：%s\n", info->name);
# Q3 c  [/ ?/ J; ^2 s9 m2 o       printf("学号：%d\n", info->identifier);! F  _8 u2 r5 w3 c+ V4 a
      info = info->next;
& k: ?( R6 ~  M" X/ q, r       count++;0 {/ r5 t: n4 A) p
}; @; j3 ]" s, T
}
. Q; Z( {4 C, t
想要读取单链表里面的数据，只需要迭代单链表中的每一个结点，直到next成员为NULL，即表示单链表的结束。
最后，当然还是别忘了释放空间：
void releaseStu(struct Info** students)/ ?3 F4 \! \9 Q: L
{" N# A- C2 q& S, j1 U& b
struct Info* temp;
1 V$ Y) m/ E8 e- H8 t# D- {  D5 @8 W
, k1 v2 _1 N5 @7 y while (*students != NULL)
% Y! I' d0 R: b6 v7 \7 a3 t* [: N {3 @6 K% O2 }+ f, Z5 Z
      temp = *students;
4 F$ c' Z# |' e       *students = (*students)->next;% \: O+ X+ b0 x. L2 e( h3 j+ X
      free(temp);! Y) E) J& o) v8 L
}; p4 f! o& h* X
}5 B" `, a$ w( c) w
尾插法
与头插法类似，尾插法就是把每一个数据都插入到链表的末尾。
void addInfo(struct Info** students)
& `" A! h0 ]7 v6 A+ [{; D- I+ |% l+ c# F- p. Q
struct Info* info, *temp;
: I1 o$ j* }: B% g+ d3 o info = (struct Info*)malloc(sizeof(struct Info));
" m. U8 v. S$ n; m2 ]5 U: L if (info == NULL)2 A! @8 n+ m0 T
{/ k3 }/ l. M" O$ k
      printf("内存分配失败！\n");7 A9 F9 F! v. Z" T6 O* J3 f6 k$ ]
      exit(1);
; ^* L& R4 s" ]# Z$ m: \. D }0 V6 }0 c* j2 X
: o0 d! d% G' F) X. X- P
getInput(info);* p8 x) P* ~2 g5 @3 G

1 j9 j/ W6 w& i8 i0 f! Q; |$ j5 N if (*students != NULL)4 y$ ^  ?: A& F% P' J
{
  v( |2 x" q2 Q5 `9 Z       temp = *students;
% g- B4 }/ q4 o! b) H- L       *students = info;' A% ^& z7 c, B1 M
      //定位到链表的末尾的位置9 a2 S& a) W1 n8 ^0 L9 w
      while (temp->next != NULL)
& l) i6 J) e( l$ d       {
; c" ?+ r2 _6 L: a. {  Z* z          temp = temp->next;
9 D* e/ H6 L8 p, R       }5 {5 H4 F& d8 O' S; r: S! C% O
      //插入数据
, Q5 J5 J& b; R3 E" L/ J  P0 h, ?       temp->next = info;6 [# F7 X; ^8 Z: N, _# {
      info->next = temp;2 a/ c# E8 i. o1 B: e  w* d9 b& h
}
8 A0 v3 o4 q( R( ?$ p4 f% B else0 ?' a7 c  z+ K0 w1 l
{
  h4 H" o8 _' M- X" [       *students = info;5 b: L5 B7 H1 d# v. _0 B8 t6 W5 C
      info->next = NULL;
3 B. J/ `$ E  D9 u# d }! f+ e% M! x; j8 s5 p% x, w
}
! s  v  @/ Z# f2 M# `
这么一来，程序执行的效率难免要降低很多，因为每次插入数据，都要先遍历一次链表。如果链表很长，那么对于插入数据来说就是一次灾难。不过，我们可以给程序添加一个指针，让它永远都指向链表的尾部，这样一来，就可以用很少的空间换取很高的程序执行效率。
代码更改如下：
void addInfo(struct Info** students)
8 U  [" D& B3 Y0 E{
, H- V% J# Y9 m5 i3 {% T struct Info* info, *temp;
) ^( U& x4 |$ z static struct Info* tail;//设置静态指针
( }9 U6 D" E0 F) X, n. x. w info = (struct Info*)malloc(sizeof(struct Info));
+ L6 Q/ X9 {! h) Z& u# { if (info == NULL)
0 Q' {( w, M" g  i {
, V  a3 C0 ?# L  O       printf("内存分配失败！\n");4 b/ j5 N; \! q' D0 e
      exit(1);- t0 d! [7 b4 y3 N+ ~. T
}
( _0 z& [6 u8 g ( c: x9 |+ L! U0 }1 g# F
getInput(info);
, a( B" y1 a3 |6 Z5 f" Y. \3 n . k' u. T: b; z
if (*students != NULL)
7 |0 w1 a0 x& A" b- x: Z& A$ G! Y {
7 |+ n* s1 ]+ ]2 |) c       tail->next = info;% k* d6 i6 P0 X! a. a0 ^% n: R
      info->next = NULL;
& y% M9 s7 R- j- k8 p9 S }
7 y5 T( o% F4 _ else  u7 a$ }3 D1 j' n3 M4 C3 Z
{
% ?1 C7 X& C& B& N2 G; {. f       *students = info;
$ z6 Z  J* M1 I1 b% [       info->next = NULL;
* x" x/ V+ k0 D }
! [6 ?8 i. O9 n( V5 R; Q8 F}
' J  s, b5 [+ q9 @$ s+ m1 N$ N搜索单链表
单链表是我们用来存储数据的一个容器，那么有时候需要快速查找信息就需要开发相关搜索的功能。比如说输入学号，查找同学的所有信息。
struct Info *searchInfo(struct Info* students, long* target)
$ O' {5 @% u- V3 y- I% J{9 X. {3 E# N# G7 A4 j7 V
struct Info* info;
8 F. @$ M+ Z, R3 a7 J info = students;, F4 e. ?# ?9 \8 q8 r) o. m
while (info != NULL)
7 e  c- F( c% B' W0 f! C, P, Q/ i {9 J4 [* q, _3 d8 {; n
      if (info->identifier == target)/ \6 C. a/ s& N6 }
      {, ^1 @, S* m6 i7 \. n/ n
         break;; H- d- z/ K* W
      }
0 y6 i* T; [1 }) F       info = info->next;  }2 E" }2 H6 a; F: \+ p
}
; W2 z3 T# Z5 ~4 r# J  ? ) m% D& k3 X- V
return book;
, o- [& i( C( H5 Q7 t% [- U};4 V3 _  I5 y4 T( x" P6 d+ Y  `5 p

1 X7 X- [! w" ~4 s) F+ Xvoid printInfo(struct Info* info)
$ A/ I9 d8 N! ?, x8 D* @; O! ^{
/ X( D7 x, d) C  H* _2 j. M* I ...: p1 Z" V& H" b' u3 N: M
}& \8 s2 K2 B( x: e
...5 V9 p# v! Z/ |" ~3 _
# z  R$ T# \& S% }: u5 W8 U
int main(void). z9 {/ Y9 P; B! R
{3 F: K0 D9 r( v8 T. F) c, A
...: Y/ y9 {; d) V; Y1 y/ m: n
printf("\n请输入学生学号：");- _8 c0 r0 ^& P/ m+ {+ f+ D+ Z
scanf("%d", input);
1 F- k" p* {) w info = searchInfo(students, input);
% D0 d( ?# {$ t6 O: o$ A5 o  T if (info == NULL)5 w. Z- E3 ~3 F0 l8 G" \& i  I8 v
{8 V4 V# Y- T4 @
      printf("抱歉，未找到相关结果！\n");" U3 x& d+ J% [: Q# @# l' D
}
/ }+ s. U7 K5 S7 e+ k7 l0 N3 k# } else8 c8 j  j, G. D  r' K3 V* i: I
{% T1 {/ O5 ~! I2 g" B
      do
' e) u& N6 I: [& c' {$ P2 o3 p       {
* G0 F/ c% U+ o          printf("相关结果如下：\n");& v/ _4 H: E6 L2 z$ q4 B' D
         printInfo(book);2 f! z, Y* g' k* P
      } while ((info = searchInfo(info->next, input)) != NULL);
$ \9 p. b3 m; s/ J: f& G! V6 ?0 Y }
- W4 d2 S0 a; r) s, |- s 1 ~5 q  B. ?! S6 C8 w# a
releaseInfo(...);
! ^0 h$ x: w' u2 \ return 0;
) w0 c' ~( s5 x8 |' [6 W}
3 H/ B, ~, j0 F& b, g% Z: [9 S1 z# H- B插入结点到指定位置
到了这里，才体现出链表真正的优势。
设想一下，如果有一个有序数组，现在要求你去插入一个数字，插入完成之后，数组依然保持有序。你会怎么做？
没错，你应该会挨个去比较，然后找到合适的位置（当然这里也可以使用二分法，比较节省算力），把这个位置后面的所有数都往后移动一个位置，然后将我们要插入的数字放入刚刚我们腾出来的空间里面。
你会发现，这样的处理方法，经常需要移动大量的数据，对于程序的执行效率来说，是一个不利因素。那么链表，就无所谓。反正在内存中，链表的存储毫无逻辑，我们只需要改变指针的值就可以实现链表的中间插入。
//Example 03& U9 w" L  }$ W$ l1 n" p
#include <stdio.h>. P9 `# G1 S  |. H  c
#include <stdlib.h>! K0 b+ E5 |9 z% G: S, c
6 R; y& _# Y5 ?
struct Node
8 o2 m7 ~) _* C0 M% e8 C- X6 E1 i" t{
( d' u3 ^4 V9 B! S int value;, @( N* |7 [2 M& B6 L! w' F1 s! J9 P
struct Node* next;  G( T( q2 i4 P& j
};
% T! e7 L9 W/ Y
  j+ w% t; u2 ~5 bvoid insNode(struct Node** head, int value)
; d  l5 S& ~9 S3 i* f1 M{
( v. ^  B( v3 X. \5 c struct Node* pre;
( A% Z5 e; m, [, R- @  n struct Node* cur;
, a( X9 _7 L* l5 Z' C5 ` struct Node* New;& ]& s5 y0 I: r: d# l. E
1 K/ k5 Y. A7 p- \
cur = *head;4 L+ u3 z6 S3 r, m. n
pre = NULL;
/ H- {/ I/ [; d% p6 z
" ^1 z- u" A& Q* Q+ ?" d) j! L. w while (cur != NULL && cur->value < value)
; [& L  k8 T; E4 e+ \- d {
! X$ b% i  q0 @2 P       pre = cur;
# {4 ]& t4 T8 R3 k: O" x) o       cur = cur->next;
6 _  u5 h. r# ]. {- z }
( i6 i  j  J! C; S" t
2 e- k4 Q0 e6 @7 G* s# w New = (struct Node*)malloc(sizeof(struct Node));0 k9 y" t2 o5 ^  V3 p* _. Y
if (New == NULL)7 U5 ~* m3 m" h2 Y* s
{
* {, I$ |$ T8 l3 }* i       printf("内存分配失败！\n");5 E5 o6 I+ q: r2 V/ ]0 H
      exit(1);
( |3 C. D% ~0 h7 K4 [' A2 q3 t }8 G7 Z6 Z0 o5 r5 x7 G! ~
New->value = value;
4 v, c) Y; m! d1 s: D/ \9 @* N New->next = cur;5 ~7 P+ |) B3 c! j5 k" @

. o) @& V! f' a0 |  n8 J if (pre == NULL)
% M. z+ y& n% b' m/ W; a {& C) S3 S  Q2 b# X5 }; l2 F5 s
      *head = New;9 f2 d2 H2 |1 w2 f9 f2 r
}
) s/ F" {* S# r% x" F/ T; v else' t: {  ?. E5 v
{
: c$ _: B! q( m* x       pre->next = New;4 P: J+ f& I, s6 \8 Q5 f
}0 z4 [: ]/ F/ ~. L
}
* e2 w' N' Y9 r. D- p; o& D
& x* b' u0 a1 `/ |! E1 Wvoid printNode(struct Node* head)
' Z2 S+ t% P+ p5 V{
% u! p2 ~5 o0 `' g* a) B' \* P struct Node* cur;9 t( w1 S" ^6 f% C8 |

7 C1 g2 Q) A+ V; ~ cur = head;+ P* ^5 Y0 Y: U# _+ ~& V- }7 y4 y
while (cur != NULL)
! I! x1 Z. c0 e9 N& v! @; o% o6 n {
; e9 L0 s2 d. ?) W       printf("%d ", cur->value);
3 ^. M- ~7 U9 u2 B! L# C/ r       cur = cur->next;
9 u8 Y5 q" o9 |* e" L) r- r }% K# c  H$ L2 K" i. w
putchar('\n');
3 ]6 t: m3 y1 n- Y/ [3 {}
0 ?' |2 ?. ?3 H- ^) I- Q" r  o; m- }& l# H
int main(void)2 d' O. r2 f& [, a1 b
{$ |7 a* ?0 _' ^5 H! W' H
struct Node* head = NULL;5 D9 W- l1 _7 v2 O
int input;
4 H4 {8 G# [0 d9 _$ B1 a: _
& J  A! Z5 J7 y3 C4 Q& s4 n printf("开始插入整数...\n");5 |7 W0 |" M+ V# S' W; v
while (1)
* x( K/ V6 o% i0 l; N! Q& S {, O* r1 W: l6 q6 ~1 D
      printf("请输入一个整数，输入-1表示结束：");/ U; ^3 t2 O3 H7 U5 ?/ G" j! p8 D
      scanf("%d", &input);3 A2 G* h' T) j8 L
      if (input == -1)
" Z" b) w0 }2 F; ?1 Z5 K# j       {
  {: g: E5 S1 o+ g          break;3 P0 W  d& J4 o- C; M
      }7 Z; A$ x4 ?/ }' U+ a
      insNode(&head, input);% t9 z/ ?5 ^+ \) i! C9 a" ~2 e- G
      printNode(head);
, p7 l+ n* P+ G; U. ^' o% b3 W/ U }
7 {9 q7 ^! s$ O4 a4 m" U+ s* `  P! @. P! Y! y3 ~
return 0;9 X0 @" y; F7 k/ q
}
# C0 Z" Y- N- P5 p+ ^
运行结果如下：
//Consequence 03/ R4 r* {* n4 r% z& H1 r
开始插入整数...
, C3 J! p+ d& V6 y0 |/ C请输入一个整数，输入-1表示结束：4/ d1 ~, j$ p% f" }% w
4
$ ]7 _; d& J3 f- T1 L' i8 k请输入一个整数，输入-1表示结束：5: z( N: T! X  g0 S" U
4 57 ^6 C/ A5 f$ F9 Z& D9 a' F4 N
请输入一个整数，输入-1表示结束：32 O$ n2 }! a2 K
3 4 5
4 }0 t7 E+ v$ b2 h) J( v& k8 [7 C请输入一个整数，输入-1表示结束：6  r, _; L( r9 [" N" L- C$ c
3 4 5 6
2 x) S' {9 X: c9 K2 O2 V" \, b6 ~请输入一个整数，输入-1表示结束：2
7 `; @7 K  ~9 q* t: X2 3 4 5 6
2 ?' h& Y& t1 b4 l3 |( ~& m) n  @请输入一个整数，输入-1表示结束：5+ z  y8 U& M8 l6 H
2 3 4 5 5 6! ^) {& b) c% d% _2 H, _
请输入一个整数，输入-1表示结束：14 D. }7 B% C& i
1 2 3 4 5 5 67 _, G! W2 D8 r+ W7 C! H/ o
请输入一个整数，输入-1表示结束：7
+ `/ g. \8 S: `: b, _1 2 3 4 5 5 6 7
5 `/ N. D( v4 H) s, q请输入一个整数，输入-1表示结束：-15 ]& @: Q; L: f& U) t5 @
删除结点
删除结点的思路也差不多，首先修改待删除的结点的上一个结点的指针，将其指向待删除结点的下一个结点。然后释放待删除结点的空间。
...; Q8 @: }/ O/ p  \. O
void delNode(struct Node** head, int value)
, G. l, D3 o- R, P! J3 b{
5 ]/ R5 r- R0 [ struct Node* pre;
& q4 r( k3 o+ A3 \+ K9 o struct Node* cur;/ g& T- A6 E! {

+ t2 {$ r+ K8 ?0 W6 C  @" Z cur = *head;' p" j% [2 U9 ~; f' s5 N
pre = NULL;
  C; ]$ q3 f2 l+ ^: y* G9 L while (cur != NULL && cur->value != value)
. ^% B) z4 H- x3 G; s {' l+ |0 m& {6 V' O
      pre = cur;$ L3 v+ L8 L8 @! z! o- q0 s
      cur = cur->next;
( m3 B- h% |) d- a5 s! f; W }
& f7 K9 p5 w8 u& ^) r6 X) `9 w$ @$ q if (cur == NULL)" V- u1 p8 i5 j
{. n- K3 [; l6 D
      printf("未找到匹配项!\n");% b9 b" G8 _6 r3 ]' u0 c
      return ;) H3 s0 P% l) U& ^
}
+ _8 }1 s) ^( N( U5 Z% I  ~ else
, Z8 p+ F# K! L; C {$ {9 R2 ?- T' O* e( C& @/ t6 @
      if (pre == NULL)) h; Y7 n; l( G
      {9 S* F% ?8 ^! J  \
         *head = cur->next;
- S3 M- S7 B0 r% c2 J% d# `       }
) a) H, g) m$ B! d       else
% i+ q- u2 g: b( f8 E  }0 p0 ^! u2 S       {" l% y0 D0 D( t1 M
         pre->next = cur->next;* n, k8 g# |: ?* X- E" f# p
      }
      free(cur);7 B7 `% N/ I! l/ B. Z) G5 }, j
}5 j6 W  i9 b; e1 z) `1 Q
}
7 I" V0 @% m* u内存池
C语言的内存管理，从来都是一个让人头秃的问题。要想更自由地管理内存，就必须去堆中申请，然后还需要考虑何时释放，万一释放不当，或者没有及时释放，造成的后果都是难以估量的。
当然如果就这些，那倒也还不算什么。问题就在于，如果大量地使用malloc和free函数来申请内存，首先使要经历一个从应用层切入系统内核层，调用完成之后，再返回应用层的一系列步骤，实际上使非常浪费时间的。更重要的是，还会产生大量的内存碎片。比如，先申请了一个1KB的空间，紧接着又申请了一个8KB的空间。而后，这个1KB使用完了，被释放，但是这个空间却只有等到下一次有刚好1KB的空间申请，才能够被重新调用。这么一来，极限情况下，整个堆有可能被弄得支离破碎，最终导致大量内存浪费。
那么这种情况下，我们解决这类问题的思路，就是创建一个内存池。
内存池，实际上就是我们让程序创建出来的一块额外的缓存区域，如果有需要释放内存，先不必使用free函数，如果内存池有空，那么直接放入内存池。同样的道理，下一次程序申请空间的时候，先检查下内存池里面有没有合适的内存，如果有，则直接拿出来调用，如果没有，那么再使用malloc。
其实内存池我们就可以使用单链表来进行维护，下面通过一个通讯录的程序来说明内存池的运用。
普通的版本：
//Example 04 V1
: o8 d4 X5 n  x! x#include <stdio.h>
- |$ z+ r  U: e( D# f  l#include <stdlib.h>. p* @- q' K# c& R
#include <string.h>
3 I/ h9 S: ?, o7 H) G" k/ T* T% h/ `) x
struct Person* x- O) t# \. ^, z' T; b/ [
{1 ^! ^; T3 G% }/ z6 c6 e
char name[40];, k/ p& d: L7 `* A3 J4 }
char phone[20];: D% Z4 Q  |7 {0 B
struct Person* next;) ^4 L$ H8 H/ D( \5 x
};8 b5 R1 O% ]  L4 j7 \2 F
* M0 c0 N" d" o0 P) o
void getInput(struct Person* person);0 \+ d: |+ K1 u
void printPerson(struct Person* person);
1 X- l5 u  S7 f1 S% t8 dvoid addPerson(struct Person** contects);$ F  ~6 E; g1 h- V( _1 `; e( j
void changePerson(struct Person* contacts);
) S, R: I: v$ |" X, zvoid delPerson(struct Person** contacts);
7 a# @2 m' Z1 H  {" Qstruct Person* findPerson(struct Person* contacts);& `% k( F1 u& ^$ ^2 E9 P7 ]0 Z
void displayContacts(struct Person* contacts);( N& L8 Q; b6 D( Q/ l
void releaseContacts(struct Person** contacts);( |, h! M- p, T$ J' s: Q
  A5 x2 W& ]8 ~
void getInput(struct Person* person)4 f7 r. H) s4 y# S' D% f+ _
{
7 r+ r  `# A; O0 Z; U printf("请输入姓名：");1 u) S  D; C$ u, _1 v
scanf("%s", person->name);/ ^5 @: h: \2 k
printf("请输入电话：");9 _' B- o. ^$ M/ h7 G. N
scanf("%s", person->phone);# Q6 s1 ^0 [0 \# L7 e: Y$ C# m
}
8 u9 j* u9 o" ]% i0 Q3 h: t1 V" a& I1 _1 n5 H+ n3 d# |
void addPerson(struct Person** contacts)! [, U- c1 w6 v
{( K% j  G4 b6 h0 T6 r; E
struct Person* person;
% o6 X& H& w0 e/ w4 ^! @ struct Person* temp;8 S; l$ t0 {/ O$ E: [
, ]7 u1 l6 s/ m8 w0 S
person = (struct Person*)malloc(sizeof(struct Person));
( @3 w' b5 E+ z% m+ f& ` if (person == NULL)7 Q* r: x. p5 d& k
{5 q( _# V2 h4 g* ]1 a
  printf("内存分配失败！\n");  {: r2 Q2 w+ V# ^" Z
  exit(1);$ ^+ n: y% A' v. ~5 t1 o
}! \& U, G' j4 V% z" T7 X
& Q' H/ F2 b* o5 b, e: ^3 \
getInput(person);+ R: F: m; ~# a' u

" |7 T7 ]1 y* }% @5 l //将person添加到通讯录中2 k6 a  }1 G  Y' g( F+ I6 g
if (*contacts != NULL)6 ~8 q! j1 Y2 S2 U
{) J6 C3 C5 S9 c9 [8 A3 B5 C
  temp = *contacts;
8 x5 S' O0 s& H7 B' _6 H8 h  *contacts = person;
6 |6 c+ ^3 |0 z, [# w  person->next = temp;& x" K. p8 a5 m( Z- U7 v
}
6 ?# D; m: a/ H' D+ l else. k  ?4 {9 T$ i& n* Q8 @
{, x. G) e& w% s' Y( k3 N7 w
  *contacts = person;
8 z5 C9 v8 I$ T  person->next = NULL;
! P1 G) j- R5 x }
: V% D8 i3 |/ v: i% D}
- Q0 A$ V! O  u; z; S' h4 Y; o: g" v9 W, }
void printPerson(struct Person* person)4 b$ N2 O$ p5 k" a
{
6 t8 f1 [& F2 W( Q3 u* F" T printf("联系人：%s\n", person->name);9 z4 z4 j" @1 W- n1 R3 ]5 P0 h. A
printf("电话：%s\n", person->phone);4 X- s0 s9 Q& |' F5 K9 p2 \5 T
}# h& |7 r# Y9 ~! P$ }( M% q$ W2 B

$ _0 x6 D/ X4 o& B- R4 o  tstruct Person* findPerson(struct Person* contacts)
8 r0 [3 E" p7 ?- Z# E, t3 }{9 Y" R5 R! o$ W: z1 v. I0 X
struct Person* current;
  R' [: D# b7 o  V; C4 v2 b0 t  ^ char input[40];3 A, N- j7 c* u3 b

5 g2 M9 Y6 `0 h  S printf("请输入联系人：");4 A3 ^8 e7 |* }! ?% o
scanf("%s", input);
/ r2 w' s. L7 T% n
; _8 T9 O- x9 ]- q" ~ current = contacts;
# M" T$ I$ h+ [2 F& W while (current != NULL && strcmp(current->name, input)); w' A5 J! U5 w  N; B
{1 I% p1 |2 Q. b6 d7 n3 P! F
  current = current->next;
# v. {1 |0 v* x }
' p3 `/ v8 ^# ?+ o1 S: w
4 ^5 s3 v( G( ]; H# [ return current;5 |  X" ~0 u; N" s' n+ a! w: f
}
; o0 O$ G" O( @1 O( |: W) s( }8 U( A! P* }3 y' q1 L+ _
void changePerson(struct Person* contacts)$ [, U8 m2 Y+ G  B
{
! w! L$ j$ f, T5 _7 X struct Person* person;$ q/ `- e. L( b4 x) t! f

% x/ A$ _8 O( W9 H/ L person = findPerson(contacts);
6 x( k1 U$ I, n; ?* w2 `8 q if (person == NULL)  ~9 Z+ Q4 D' l+ U
{* g0 J5 W$ q; t& I* R
  printf("找不到联系人！\n");
# _- K# J- O( S& p }
) N: a' b, G. G- t5 C else
7 f& C  \# L7 t5 n {
1 Y" p7 o$ k2 _- B; F* m  printf("请输入联系电话：");
; d8 E- N2 E; R; w; e# f  scanf("%s", person->phone);
3 e% z1 p8 V3 l$ i9 | }
; e3 |2 F4 p$ I& ~}) r0 O2 }& ~$ _+ L; |, Z: r
% N7 j+ u4 O" P! X  Z
void delPerson(struct Person** contacts)4 t, M. A: _5 k+ n4 |3 a- \  H$ s# q! f
{3 [( ]% P8 [& I8 I
struct Person* person;" @# {- ]7 }* `
struct Person* current;, M! H" c* z, p! R% [9 v; K5 t! q
struct Person* previous;
/ l6 I# Q9 o0 m" o
. U2 e) d* c  {+ M //先找到待删除的节点的指针
' M& U8 E8 y- b person = findPerson(*contacts);
4 t( v- O( }' R if (person == NULL)9 G0 I+ e+ R$ u
{
- B/ X( Q8 ^2 Q" |  printf("找不到该联系人！\n");4 ~  ~  q( C0 M2 [/ W
}( ~+ \4 V% l3 i+ R" n( N7 a, q
else, }  K! E# U& N! y
{6 f6 y3 ]) M$ l
  current = *contacts;
4 w  W# v! x3 S3 M9 ?  previous = NULL;
8 _, c2 A6 |8 `# \0 o- f. l0 O9 s6 |4 P4 m, B
  //将current定位到待删除的节点
) q) P- s. B( ^3 z5 ?  while (current != NULL && current != person)
8 l! C# d; V2 T( C4 B# w- w  {
6 Y/ S( Q+ K& b$ ]! G previous = current;4 A6 v) s3 w# Y1 J1 E
current = current->next;! _/ i1 D5 `1 g9 ^% i
  }
. G3 Y, J; X, ~! X1 |  H; ]$ Y9 A- t$ B
  if (previous == NULL)% y! F" o, L! p& P5 M
  {
" E( D! y1 U1 T' ^ //若待删除的是第一个节点
( y+ Y8 V$ p! N  d2 k *contacts = current->next;" b( ^) U+ h8 }: U6 ~. w8 y
  }
. Z9 E; Q- E  _6 @, n; P# M' M  else
: s% p( o3 ?* j' [  {+ D, p$ ?" R4 T0 a. I, v7 G: M' o
//若待删除的不是第一个节点: v0 Y+ x$ B% M4 x) w0 b( `
previous->next = current->next;, k7 ^7 v7 Y4 q6 k
  }
! t, O5 K+ G0 m8 I7 K5 q
) ~1 `% r* l3 ]- r& ~. L# c/ W' X  free(person);//将内存空间释放
# y- N' `' ~8 F1 [, i( }1 t: l+ k }
; |1 Y$ [* f/ z! G}- N/ Q8 J% g  Y6 o
6 C7 @# z* o, A) {( ?' b5 q
void displayContacts(struct Person* contacts)3 D9 ]& c, Z- F! i. a$ {  z
{3 u& U3 D2 }# ]. W
struct Person* current;: h' M+ o0 O9 j% H, F
8 m% ~) A  E3 b( a1 H4 o7 D3 o( O' |
current = contacts;
" V" K! ~: Q: I) r1 \ while (current != NULL)  C9 a- T, x- Y( T7 {9 Y& W
{' A' A$ L: C* I6 Z( Y( |( s+ b2 b
  printPerson(current);2 V/ p" Z" u2 f) Q' G8 {/ o3 j; [: ]
  current = current->next;9 b' ^5 S, m% \8 ?2 x
}
6 m; v* B; z. z}4 b' h$ E$ A& S  n& S# s+ I0 j

5 m! W5 |  A4 Svoid releaseContacts(struct Person** contacts)
8 x) b# z3 _* P2 B& G9 |{
: s7 j' }2 e% S5 V struct Person* temp;
( ?$ z3 a3 Q" j3 S7 A  `- V; v8 J: p0 O3 E
while (*contacts != NULL)6 W% V8 Q" b* T. x1 h' [' r  `
{
" D* Y1 S8 Z7 u! n  temp = *contacts;! k" E/ p3 r. B: f
  *contacts = (*contacts)->next;' z. _7 O8 U% w$ m8 ^, F
  free(temp);$ ?. r- h1 a! C1 y/ p1 j" H
}
) q3 E9 k- O' T+ p}
$ N* X7 M' |4 q* P- B* t0 r4 v0 j; w1 q- g0 Q0 R% P, @
int main(void)
% B8 x; C" ?$ i# Q{
: n) U7 ?( n# ` int code;5 e: C% y1 R! \/ F1 v% w9 n
struct Person* contacts = NULL;
' M, x3 M2 |# w$ ]! {/ c struct Person* person;" Q8 D, ?" y( Y9 f0 ^0 p+ @

: Z' A. t/ G$ {) ^$ ? printf("| 欢迎使用通讯录管理程序 |\n");0 Q. H. @$ p+ f" m( i. ~7 M! s
printf("|--- 1:插入新的联系人 ---|\n");& Z( I/ G6 I  G( A  j
printf("|--- 2:查找现有联系人 ---|\n");* v" A6 E# o* m1 z* w! Q
printf("|--- 3:更改现有联系人 ---|\n");
1 I! q9 o0 _2 u3 K printf("|--- 4:删除现有联系人 ---|\n");% z) y, p) }/ K: v8 R" F
printf("|--- 5:显示当前通讯录 ---|\n");9 m0 g7 J* q5 I) W9 R3 E
printf("|--- 6:退出通讯录程序 ---|\n");
  [5 }- X1 r- c) c# W
. H- A! J# x, R) r while (1)4 Z- U& ?  V5 W! |
{
( q5 h& S' W' s% p, z  C; y  printf("\n请输入指令代码：");' M% Z5 W; |( a& o, Z
  scanf("%d", &code);0 M9 U5 t& @6 ]+ a; ?7 h
  switch (code)
% w/ s" x* M) t+ l) ]  {/ B+ f7 G# m. l! g) p
  case 1:addPerson(&contacts); break;) S  H( u1 O5 z; `( }; T, x
  case 2:person = findPerson(contacts);
! b$ m. C& e! V6 R5 d; @/ E8 F if (person == NULL)
( W& s) Q8 [0 p: @7 ~1 W {# {' A' k$ y% ~8 A# ~
printf("找不到该联系人！\n");- `1 [2 M+ e+ o; [& }
}& d  K- o3 A7 ~& ]" i" C
else
; L# y, ?6 }  [0 o8 ?5 ~ {+ c) K5 s: Y* {6 t1 h4 u# ?& l; |  _
printPerson(person);
' B  r& J% Y+ g& z3 g }* W0 x1 z- Q  j
break;: V% @# w  v" m# r& r" z
  case 3:changePerson(contacts); break;
$ a# a4 D9 L$ [2 c; n  case 4:delPerson(&contacts); break;  z$ r" A0 v/ e
  case 5:displayContacts(contacts); break;* V4 H8 _$ e* o" I4 v/ q! L$ l2 A. p
  case 6:goto END;. ?0 {; E+ N4 q" W: E
  }
' Q/ e1 R1 U$ | }
1 V+ K8 M6 F" O) w6 T! z/ ]/ E; H  x% v: M. {6 D
END://此处直接跳出恒循环# ~5 R$ L0 B) A4 o) n+ ]2 b6 e
releaseContacts(&contacts);
( J  G3 F" M3 G& u! ~) u4 X5 V  m0 C' }3 O4 y
return 0;7 _) \% T" s9 M$ G

$ ~- V3 @8 l" b# I7 u! i# Y}
/ |0 W5 K$ R! e
运行结果如下：
//Consequence 04 V1
/ c; m4 i: C6 ]' }& A| 欢迎使用通讯录管理程序 |. p9 I# u' y3 Y8 H
|--- 1:插入新的联系人 ---|/ T( b$ r- C; ?6 ?& r- a7 \
|--- 2:查找现有联系人 ---|
& _& ]6 t) q& A: f# W; Z9 O' ||--- 3:更改现有联系人 ---|/ l! t( y4 ]: |- z$ }
|--- 4:删除现有联系人 ---|
* @# C" R- s" g( K2 O! R2 G|--- 5:显示当前通讯录 ---|
$ i* i/ R6 B. O% |/ D) e|--- 6:退出通讯录程序 ---|( h% j$ M* m- p8 t/ K

) A' C; e: G8 e请输入指令代码：16 z4 v1 `# r8 \) V6 T
请输入姓名：HarrisWilde7 I% l6 A- k. n
请输入电话：0101111
6 m* K4 c8 D% F9 W" }+ H2 L9 }4 \$ v8 s& v3 }% p7 N+ W
请输入指令代码：15 T& S+ h* r9 D' Q' Y: c
请输入姓名：Jack
2 d9 l3 J  |# c7 A# v; X请输入电话：0101112' S0 B' \& x$ s8 S7 I

3 D. N: g$ W8 h3 f& T请输入指令代码：1
8 v% k4 Q' J7 k1 c  y3 c请输入姓名：Rose# t# G; @6 \6 T3 W" N% v, k
请输入电话：01011136 B: U- a5 S+ j" K, }0 q' E
7 j" c% a& T( s* l, `  _2 {
请输入指令代码：2% n. j# K0 g# r7 a1 F
请输入联系人：HarrisWilde
) t  o1 e; x: u$ K7 r7 b联系人：HarrisWilde
) d4 {7 W+ `1 r6 H: I电话：0101111
: ]/ ~/ m0 N3 F* o  r, A$ T3 k) h9 ~0 r% i+ U4 H; P: x
请输入指令代码：2
4 j7 F5 ]/ p1 ]# y. d请输入联系人：Mike
4 R, J: k6 [- j; d8 b2 v3 r9 {  A找不到该联系人！
$ F" g( W# N# H; H( N# m2 K, p6 V9 D5 A
请输入指令代码：5! h" V: s  K' R6 j) y* y
联系人：Rose
# n6 h, y0 {- o8 {电话：0101113
5 m4 }( H: K9 ]联系人：Jack* S) J% i, N0 k- ?, ?: b/ Q
电话：0101112) v0 Q" c+ f8 C/ @3 s/ \
联系人：HarrisWilde
. y! i) V0 J! P, p" A+ Y电话：0101111
) e7 `2 F4 l' l
6 k9 A% F  P% z3 `1 n& `请输入指令代码：3
2 S& [( B/ W( d5 @6 ^请输入联系人：HarrisWilde
; ^8 H. [; C* ]& O# J0 f! X请输入联系电话：0101234+ w9 T0 D$ O, ^1 V' x- F6 j& K" h
8 ?' R: s0 l; I- q% T$ G2 o
请输入指令代码：5
# }+ V. U  n4 ^/ g$ c联系人：Rose7 i, z+ ~# p1 f- z# p
电话：0101113- Q$ M- J* D& n. C# l" U- r  g3 }
联系人：Jack
; e7 N# V, g9 @  U( C电话：0101112
* _2 F) _' V0 w" N! S  M. Y' r联系人：HarrisWilde% A$ h3 k! T7 f2 T: I4 M
电话：01012347 D+ k: N6 Z* }2 Y0 A; W* ?, b$ l

/ O; u% p; w- n& E- O请输入指令代码：6
$ g( s9 a* p5 |
下面加入内存池：
//Example 04 V24 e! ^8 k1 M3 I% n5 A
#include <stdio.h>
. ]2 p7 Z3 \. M5 Z  n#include <stdlib.h>2 a. ]% g, e( C- f( a) Z3 I
#include <string.h>
  u0 d/ T* S) g3 e! ^4 d
5 y2 o/ D+ u6 i3 {: F( Y, Q#define MAX 1024  e  J& \" j. p' U3 e2 ?( H

( Z8 t+ w* t) d/ F+ Ustruct Person
* i4 Y6 k0 a" R6 \4 V2 a{
% j* e* r' x  t4 H+ k char name[40];5 \( i, g/ W- J. H! ~0 k
char phone[20];
! q$ ]( T! C1 p struct Person* next;
8 d" s2 ^% Q( t) A. p' B};
/ v* Q2 ?, e1 b5 w0 Y3 h/ {2 E" [! f/ a) y2 ~
struct Person* pool = NULL;! D$ V  M9 d9 A* u9 \6 L
int count;
' o4 E0 t. I% G% g; P; |( w& O
$ M8 v. e; Z1 s  ^- ^9 cvoid getInput(struct Person* person);
' J. T% i. m& f6 f7 {void printPerson(struct Person* person);: i; O  F* A, v7 X9 \5 c' v1 U
void addPerson(struct Person** contects);
+ D0 ^7 n1 A5 E! h0 n7 F  avoid changePerson(struct Person* contacts);2 D/ h$ T0 t- T: S
void delPerson(struct Person** contacts);
3 U" y! _; L' N$ V' A) I% U- \% F, S# istruct Person* findPerson(struct Person* contacts);
, }+ y! a$ M0 Yvoid displayContacts(struct Person* contacts);
* N, ^  P" G, h. Xvoid releaseContacts(struct Person** contacts);( C* K2 ^+ N5 V. U# Z/ y
void releasePool(void);3 U1 J# u( o1 P
( `2 E2 d* l2 S% C: j- l
void getInput(struct Person* person); A6 q5 n3 e, f6 _, w
{" S/ {8 H$ z& J+ G% ^
printf("请输入姓名：");' [: N3 ~8 j4 |! h4 P
scanf("%s", person->name);8 E3 [, Z3 m6 [5 r& s! F
printf("请输入电话：");, s$ T& h+ {$ Y, I- D$ Y5 U( @
scanf("%s", person->phone);
1 E/ F3 k' G/ S6 D& F5 r, G* @}
+ G4 w, W8 O  r6 b# y4 o. L% d$ U3 ~+ w& }% S' T
void addPerson(struct Person** contacts)/ p+ _! `% l& c( n
{1 t3 h, G/ Q! L; c/ Y- v. R
struct Person* person;2 V4 g5 x6 p- G' W5 ?. M9 {3 Q' ]
struct Person* temp;
* f; H- G- b! J+ Z0 |
0 ^4 k" @: C# ~# w" H* J //如果内存池不是空的，那么首先从里面获取空间
  B) E5 r$ X3 h' \( |2 b* O6 A if (pool != NULL)* m7 k- l) x: t2 K8 S! N9 o
{, @5 v+ e! E. E2 F0 b* G$ J+ i- W+ _
  person = pool;
5 J8 T7 E; T, ^0 d; X. T  pool = pool->next;* F3 O8 ^5 `. _8 p' Y
  count--;
' I4 V/ Y2 W- x* A+ R  y9 h }; h7 B- n0 ?2 ^2 s" I3 o; x
//内存池为空，则直接申请7 T; e& W7 m5 t1 O
else
6 O$ H5 N/ ]3 H2 p6 Z {
" [. X" s4 w' ?3 u1 v+ {  person = (struct Person*)malloc(sizeof(struct Person));$ d( l# F: M' k
  if (person == NULL)$ ^( |/ D! T( @+ Z
  {  Q* j9 w* D# |6 j
printf("内存分配失败！\n");
. q( v7 ]6 ?6 u/ Y9 Q exit(1);) l$ q$ t: s5 y  W$ \
  }$ H& Z0 ]7 r/ g0 Y2 z& |
}7 Y& P% c% M* O9 C( V
2 E5 ^% o" O# n1 g% K1 Q1 C7 ?% Z

0 _( M. m3 b! w3 M8 r getInput(person);" c5 A5 r6 \  x+ c* [

+ m) T3 S1 q. f) X+ @. W //将person添加到通讯录中3 Y, s7 U' D; f' |
if (*contacts != NULL)1 r" z: r5 n3 x/ C$ y9 C3 s
{
+ K- q6 n# q5 q! @5 f" l4 n- u+ Z  temp = *contacts;
7 Q1 e' G- |+ z( h% J$ [  *contacts = person;
3 ?9 m# y$ S1 ^1 r: J  person->next = temp;/ E1 w4 v2 p  Z% B  R* i& k2 J) h2 |
}
3 h4 q3 u; E5 b, u% Q/ Z1 q* I else2 a0 r4 a: O: R3 [3 [
{
! f, H3 N' L3 Y: Y/ R, P6 w. ^  *contacts = person;
! a/ F! p+ ?9 y+ N- C  person->next = NULL;! X0 p3 e) b$ i* |$ M# H
}, D& [$ q' M9 V& ~6 F. w
}' t# J$ ?, k; R" E- T

) A) ~8 q9 G" [7 d: W2 @void printPerson(struct Person* person)  |7 s9 Z& S) P- Q# c4 z
{
  V/ y' [: w- S: k) |; m% b printf("联系人：%s\n", person->name);
$ z4 {  Q. J" `" ^ printf("电话：%s\n", person->phone);
; t, ]$ r& h" B}3 _) B* Y0 \& O5 x' L0 G
9 z9 A7 W6 Y: m
struct Person* findPerson(struct Person* contacts)4 b9 \* _/ v3 {; B5 A
{
3 d2 U, @! C+ O" @! [" [ struct Person* current;! F' {$ A5 |, K6 _# Y' c
char input[40];
. q: g. ^: P$ c% j0 m# T2 }: L9 M- f5 N5 ]/ j( F0 a
printf("请输入联系人：");
  y: K" o7 i/ K- v1 s scanf("%s", input);
* {1 E, s2 Z. ~9 P' L7 m: W; a# \9 C% D) H' a' `+ i
current = contacts;$ Z$ A. I6 k' \3 q
while (current != NULL && strcmp(current->name, input)), ~  I* I) N- m# y! ^2 o, V
{
  current = current->next;
( N6 S) T5 j7 B5 d" e- @ }& R- S; ~+ O$ z4 o  I& M- Y) b
2 K6 h4 |! K) {, f
return current;
6 o, T1 B8 W( D/ U}
+ b, R1 Q% O8 c+ R
1 t3 T. j% o3 k, _$ r( F1 ^void changePerson(struct Person* contacts)/ p0 h  X' M' |; o) `5 G+ ?$ K
{& ^! {0 p3 s$ w) m) P) F
struct Person* person;# ?! K- ?& Z  i5 C3 r
, Q( d% ^! F6 E/ P0 d2 J5 W
person = findPerson(contacts);/ O3 x0 s% Z. P" {1 r+ ~
if (person == NULL): w- v8 U1 [; B, c* s
{+ N) b$ f$ b3 q3 {2 H0 L! W8 u. ?* j- X
  printf("找不到联系人！\n");: k+ y! D" a8 A
}; D5 F8 ^+ P) H0 L
else
8 O3 J- B/ G0 C* Y( }% g6 X {, |# u. l! Q; y5 i" C, R/ l
  printf("请输入联系电话：");
: m7 H0 o' X; a0 V$ d  scanf("%s", person->phone);
/ I8 i/ A; W3 c }( `# k" _, m3 r* y( z1 {
}
8 a( A8 V! M* {- E, K& p4 `# a& B; E9 c* x8 P
void delPerson(struct Person** contacts)! \% f0 F7 `: l3 z. `% G/ i4 S8 I6 d
{
+ t: G! d1 l9 V* n9 S2 P. X struct Person* person;* r2 o3 g( n% Z/ K1 p5 C7 f
struct Person* current;5 u  A7 B% t4 Y. t* {
struct Person* previous;! {9 m, b" c1 h+ n0 u6 ~6 d
struct Person* temp;
8 d9 G. F, e" H {$ W/ e) S6 _" Q( Z
8 b% `% U3 \: a! P
};
/ d3 L5 D  b1 u" G4 |+ E# `# J( f
  z  I2 p! c1 T7 E //先找到待删除的节点的指针
% A' I( r$ J$ ^# v7 f% B person = findPerson(*contacts);
" i, l# U$ l! [1 X0 c7 }- F/ I8 O: u if (person == NULL). ^8 ]6 Q4 j9 O0 a% W7 \
{
, v+ ?2 @, w8 O" F) p  printf("找不到该联系人！\n");
7 X2 c$ |+ X+ j$ ]. f( B9 l& r% H8 _ }2 ^% Q" ?7 _0 k/ `, x5 P# z
else: F1 j% b  h- D
{
  |" b% E' F% C! B$ U; Z  current = *contacts;* I% Q4 k' `8 g" ]
  previous = NULL;
4 i( m# y$ O; k7 n
/ \7 q% S6 L$ e/ X6 o# n* H  //将current定位到待删除的节点
% D( @, n) C. Y8 I1 J0 }  while (current != NULL && current != person)( p+ G7 U2 X& Q( `$ ^  L
  {; y: a, p' g& m. V
previous = current;
. C1 w; [! t. ?5 l current = current->next;
, Q: b- q: d& _& }  }
( C+ W  w! a( i: q1 s4 Z. f
$ n% G3 L% G1 W& }/ y* e# b  if (previous == NULL)
4 o, J( ?( O9 z) M  _" O  {
* c& T/ Y% r2 T9 k- m+ h" _- {* B //若待删除的是第一个节点
3 H: g5 \8 H4 a% q3 k& C+ c, }' E *contacts = current->next;1 B/ H% ~7 B. J' p( @( q0 k
  }
; w6 p+ g$ |( r' }  else! B% @% K4 v. w% S- r# c
  {
3 Z3 Y4 r/ B0 u; ?6 ^ //若待删除的不是第一个节点0 N9 t. v0 t. s" V" \
previous->next = current->next;. t: t  h4 ]" R7 ]( c$ e
  }1 c2 f9 q: X8 B. l

6 T* w+ `$ N* _$ `: k& y/ Q0 b  //判断内存池中有没有空位
! ?. j# ^3 u9 q% t6 ]+ F  if (count < MAX)% ?3 I2 O# @! F8 v! }6 Y
  {- f! A9 I: I$ I: V
//使用头插法将person指向的空间插入内存池中
- K1 d( g) E9 W' @. d& B6 A if (pool != NULL)
( v3 N3 ~! k0 ?) Z# f {7 q2 Q, W- M+ n, y
temp = pool;2 |/ i' u7 k0 G: V; w6 c
pool = person;4 s! ^# w) a3 T6 Y, P
person->next = temp;
! r- V. S$ ?7 }9 ]* {" ^8 l9 [! j# a }
  A; w+ {) [$ ^6 J+ J  K else
7 ], J3 E) Q0 b! R3 N& F6 n8 u {: R4 b( i6 h* x, k6 k" j
pool = person;
. A; K- y4 S  p% {' a% s. Q' S person->next = NULL;
0 Y6 @  }- H/ k }
1 R( D$ u9 C4 G" p6 c2 Z9 A count++;, ~! Y+ r% ~1 m/ Q6 r
  }! F1 A) u. m9 U! J7 s5 t4 h, A
  //没有空位，直接释放
: B( Q! C& u! k$ S" c1 K& W7 z  else
- k; Y8 ]% m5 E6 O" v1 h! D  {  b  k# P8 o. L! Z! |
free(person);//将内存空间释放" ?6 a3 {" `, j8 t4 v
  }
+ R1 H- E" I. y7 m. W }  d9 ?/ `3 \7 B; X8 l* A
}
/ h- L3 F- o4 M; x0 d# U
/ @, _3 K" i4 ^void displayContacts(struct Person* contacts)& c8 Q5 O) R* @9 r3 v# G  L5 q
{
- \0 v  J( s; G4 a' t" u struct Person* current;
! p6 h& b8 h) E  C3 l! e2 p& I# u' q& m
current = contacts;+ U+ I# p. x; T5 ?- H
while (current != NULL)
# ^  l6 l( M5 H" b {. ]1 T$ z/ |7 ?  ~6 [+ }& _
  printPerson(current);1 i" `. ?! p0 l3 O5 ?
  current = current->next;* R( T+ e) P- S8 e7 t
}
1 {/ _+ ^4 N; ]& A}/ Q- Y. I' b$ T0 A

% R% y" y5 G0 `" ~0 k/ Y6 uvoid releaseContacts(struct Person** contacts)6 Q9 A- f' z4 e9 C
{( q# [( e* }( \# x2 a! ?0 N( c
struct Person* temp;+ |5 g! E8 f3 c
/ m6 w. K9 U0 K$ `2 E
while (*contacts != NULL)) l5 Q4 m) R. d
{
& m2 M5 x. T' A" O  temp = *contacts;
1 D- R9 N' Q. S% C+ U, _  *contacts = (*contacts)->next;( q4 r9 X* l, |  \8 G% v
  free(temp);
7 ?% O3 Y, u' [8 I7 @1 m) E }
4 ?, j7 J0 U2 K4 {: i" E) h}
1 x8 H* n; H' B5 g& ~; C, I' u( {" s
. Y- C" T! i4 `# v7 r8 X# A1 Pvoid releasePool(void)) b- b# E& A# w# g4 F
{
1 X$ j+ }1 r0 W# d. Y$ g! ` struct Person* temp;
( b2 M6 G/ X( _1 Q while (pool != NULL)- _) t  s) t) l
{
7 @5 x1 s; x' X% t  temp = pool;
3 T$ b9 N% [- l- u/ j+ j2 c0 R1 j  pool = pool->next;5 c& k8 ~# v" u% n$ g8 l- J( w
  free(temp);5 b: o8 @: ^+ b0 s
}, U4 |/ Y$ t2 e% j" f7 _9 D+ v
}
$ V3 H: N# |- g; u* n. f5 L8 S+ a) P3 D: U
int main(void)" G+ i) R. ?# ?% F" c
{* {4 `& L4 I# f8 x& r
int code;
1 m$ N% m) s' a struct Person* contacts = NULL;
* m. {: T- a3 G% l, b$ I struct Person* person;
+ Y, j- t" O6 x, Q' x, Q6 H6 G/ H/ c0 \8 Q
printf("| 欢迎使用通讯录管理程序 |\n");
4 i, u" u) g0 t5 u5 I! o$ T printf("|--- 1:插入新的联系人 ---|\n");
! M) B" y( X+ V printf("|--- 2:查找现有联系人 ---|\n");; w; E& b2 j4 J
printf("|--- 3:更改现有联系人 ---|\n");- F/ g0 c: Q" h* J& o
printf("|--- 4:删除现有联系人 ---|\n");( C7 q. {( I5 N0 Q% r! a
printf("|--- 5:显示当前通讯录 ---|\n");4 u% |: X6 W# N+ U7 ]" ]9 ~( o6 o
printf("|--- 6:退出通讯录程序 ---|\n");
( B' d! {" i6 c% e) }+ V0 h  Z3 P+ r* r! \1 x4 s& j
while (1)
+ w7 r; j# K; d7 f, D& k {
- o: U8 i! Q% |, u6 j. P) }  printf("\n请输入指令代码：");0 v9 i# X1 Q3 |. _  N5 L
  scanf("%d", &code);
/ w2 r# Q$ V' q" |% ?2 x' x  switch (code)
4 w- ?  N) E; z: S- H; s  {
4 j, s1 }. H9 F, e  case 1:addPerson(&contacts); break;: ~3 ^" t! k: G# A. b* H; Y
  case 2:person = findPerson(contacts);
- g" b" O3 Z+ b0 t if (person == NULL)1 u) \5 S$ f/ h, v+ w. b
{- X1 e( X6 r6 n0 K. {
printf("找不到该联系人！\n");
# M0 j* W$ T% D }
4 |8 x: Z/ c; Q6 s* T else2 G. K3 c. a& W" Y* O7 V! ~
{
( d8 [, B0 w6 p0 Q" n% ] printPerson(person);
* R, }  g0 N, I6 U+ v  X }
( a9 @9 ?: K- N7 I# A7 A break;& y8 E, Q: g8 o7 \5 L$ J. X
  case 3:changePerson(contacts); break;
% t/ ?6 e, h9 E* I. {& G  case 4:delPerson(&contacts); break;
$ ?, P9 h! n* M( P' i  case 5:displayContacts(contacts); break;
8 c' l2 B" L! c! w4 P  case 6:goto END;' J: v- [+ Z; N* F) X$ S& L
  }( o4 H* r' o/ W, j2 `
}
3 r" k; Y% n3 Z4 ^2 G1 b! R. z" R6 p& J% q+ m; B4 n
END://此处直接跳出恒循环! L2 k+ `% `6 K/ _' }# x" U
releaseContacts(&contacts);& K3 @7 U4 i8 S/ }, a2 C0 t; B5 t
releasePool();& K; [% F" u6 i0 ~5 R% t

6 c: {- A! O; x* v% t return 0;( U8 L# ?9 ]- ?, X) g' g$ e
7 \# w" q7 m+ H
}& }- W+ v8 G/ f$ n9 `
typedef给数据类型起别名
C语言是一门古老的语言，它是在1969至1973年间，由两位天才丹尼斯·里奇和肯·汤普逊在贝尔实验室以B语言为基础开发出来的，用于他们的重写UNIX计划（这也为后来UNIX系统的可移植性打下了基础，之前的UNIX是使用汇编语言编写的，当然也是这两位为了玩一个自己设计的游戏而编写的）。天才就是和咱常人不一样，不过他俩的故事，在这篇里面不多啰嗦，我们回到话题。
虽然C语言诞生的很早，但是却依旧不是最早的高级编程语言。目前公认的最早的高级编程语言，是IBM公司于1957年开发的FORTRAN语言。C语言诞生之时，FORTRAN已经统领行业数十年之久。因此，C语言要想快速吸纳FORTRAN中的潜在用户，就必须做出一些妥协。
我们知道，不同的语言的语法，一般来说是不同的，甚至还有较大的差距。比如：
C:
int a, b, c;' g6 t  v  T8 c* m. o/ R
float i, j, k;; M. C$ I9 ~. W# Q

而FORTRAN语言是这样的：
integer :: a, b, c;
$ j; v2 v8 [: W& p5 @+ Rreal :: i, j, k;( K) E3 X1 r8 |: n) z

如果让FORTRAN用户使用原来的变量名称进行使用，那么就能够快速迁移到C语言上面来，这就是typedef的用处之一。
我们使用FORTRAN语言的类型名，那就这么办：
typedef int integer;
/ Q; V$ W- r( o. x& ytypedef float real;' [, S4 B6 S, d  m6 T# I
) a7 Z; {! K' T' ^$ \, ~/ m( S
integer a, b, c;
" h5 w  Y2 |, F1 d) B  }" creal i, j, k;
1 p5 r+ b% l, P8 `0 m/ p0 k: M结构体的搭档
虽然结构体的出现能够让我们有一个更科学的数据结构来管理数据，但是每次使用结构体都需要struct...，未免显得有些冗长和麻烦。有了typedef的助攻，我们就可以很轻松地给结构体类型起一个容易理解的名字：
typedef struct date& S0 C' b5 x; f( Q3 P
{
, i5 T. |* D+ J7 {9 p% n' J' N8 S int year;0 d5 j1 @& F" j: `3 s
int month;' Z9 m7 t. w" \, C$ q! l
int day;6 m+ w8 ]# T8 B5 |3 h/ P( g
} DATE;//为了区分，一般用全大写6 m7 A% ?/ [5 T- w
6 H7 p. d8 G4 x6 r. v8 E# C
int main(void)% d7 ^7 E1 w) A7 {  Q$ D! o. g
{+ P* y- W( t7 P2 w
DATE* date;- L/ P9 a# y/ i
...
5 P( M6 \6 Q/ w7 Q" O6 u* W}( z5 j  R, ?7 [# m, J8 X

甚至还可以顺便给它的指针也定义一个别名：
typedef struct date* U9 |, Y) {5 O5 [9 m9 ^
{
9 K  D3 i- c8 I+ T3 H int year;9 Z. y; x7 G$ y4 D2 `( q" T
int month;  }1 R1 x( u9 N: ]5 X1 F" c8 P
int day;: [! f, E' \' l. h# j( \
} DATE, *PDATE;
! ]3 A" g! ]: F7 x+ B0 t7 _进阶
我们还可以利用typedef来简化一些比较复杂的命令。
比如：
int (*ptr) [5];1 g" J; e7 W1 G- k; u

我们知道这是一个数组指针，指向一个5元素的数组。那么我们可以改写成这样：
typedef int(*PTR_TO_ARRAY)[3];
  u# e! q  d$ k- _- T4 `
这样就可以把很复杂的声明变得很简单：
PTR_TO_ARRAY a = &array;
5 a  U: p7 X0 d' E' V1 t
取名的时候要尽量使用容易理解的名字，这样才能达到使用typedef的最终目的。
共用体
共用体也称联合体。
声明
和结构体还是有点像：
union 共用体名称3 [" j/ u' q2 t" \6 e, H
{$ k' Z' \4 ]' G
成员1;
' ?: r$ Q7 S* c% l 成员2;
, @. z6 X5 s' l9 |0 z/ p 成员3;
# ]. m  J0 a% g3 U" f};
6 z, ?$ a% \5 @5 N; ]
但是两者有本质的不同。共用体的每一个成员共用一段内存，那么这也就意味着它们不可能同时被正确地访问。如：
//Example 05
% Z9 n+ ~2 K+ {. W' g( M# }/ o( m! D#include <stdio.h># m& f% _0 O* U6 o
#include <string.h>
1 i( z$ K. z9 Y+ O. }5 C5 _# F' @5 \+ ?
union Test
" V; z8 x* l- r" m{: _' ]2 e) ^2 j: v( P6 X0 v
int i;
! Q. d: e4 Y8 m, U& G7 k double pi;4 D! |5 f. t* d# }4 L
char str[9];- r& }" e8 n1 t! L+ p
};! B: I3 f9 I, |6 D
  A4 X  E8 `  |* |4 C3 k
int main(void)
7 y* M; T7 e: M' [' s. C: X{9 n! D# a8 Y9 B7 _/ {1 v$ [5 @
union Test test;  b3 u# h+ [7 x# ^% O
6 a9 M) F- F' g( r" [7 |
test.i = 10;
# [4 N; E1 ]6 c" b$ J test.pi = 3.14;
' K& \- j- D$ O+ L, _. k) @5 C strcpy(test.str, "TechZone");2 i3 r! h. y# @: s
3 j5 w' O5 L  c* s2 J; j+ i
printf("test.i: %d\n", test.i);
2 v" Z5 P! a+ d printf("test.pi: %.2f\n", test.pi);# t' r0 x4 k) g, M* w: E
printf("test.str: %s\n", test.str);* X6 ?: @; J' c

' g/ y4 ^! @# C0 A+ H return 0;. I' g! v" F! O  t( z9 H- ~
}) v7 y2 E" W3 E

执行结果如下：
//Consequence 054 d& F" X+ f3 Z5 C% [
test.i: 1751344468
8 B* K; f2 L- E$ g; F& Y" }4 gtest.pi: 3946574856045802736197446431383475413237648487838717723111623714247921409395495328582015991082102150186282825269379326297769425957893182570875995348588904500564659454087397032067072.008 N+ S7 r/ s- Q% v. S* v8 k4 m
test.str: TechZone
3 g6 m, b* R7 E$ w' q
可以看到，共用体只能正确地展示出最后一次被赋值的成员。共用体的内存应该要能够满足最大的成员能够正常存储。但是并不一定等于最大的成员的尺寸，因为还要考虑内存对齐的问题。
共用体可以类似结构体一样来定义和声明，但是共用体还可以允许不带名字：
union
1 t" r5 n( N( @1 ~" }{
$ c1 s; g/ l6 p! T! o5 ?3 M int i;
, k# t- r; z8 F; ]6 C& Q3 `1 w char ch;
4 s  R. R' z) V! t, ^4 d float f;
+ d8 B- E, U% [; r9 o& y/ x1 K+ L% G} a, b;
9 l  J% Q: `) `0 o' e5 G初始化
共用体不能在同一时间存放多个成员，所以不能批量初始化
union data
# S, X+ F- a* _  P{; i4 m* k! I/ g/ p
int i;, V5 `( V; w' x2 _, H
char ch;8 L9 |: t, x2 ?1 i
float f;
: S9 M6 H$ Q/ J' g};) x1 E. c% R. z0 j

, _+ z: l5 E2 G) ?& lunion data a = {520};       //初始化第一个成员
" T" c) g8 [$ G3 ~0 tunion data b = a;          //直接使用一个共用体初始化另一个共用体0 N0 Q7 U* ?: k) ?: w8 p
union data c = {.ch = 'C'};  //C99的特性，指定初始化成员9 w$ P$ V$ o. M$ |" z- n8 H
枚举
枚举是一个基本的数据类型，它可以让数据更简洁。
如果写一个判断星期的文章，我们当然可以使用宏定义来使代码更加易懂，不过：
#define MON 16 ?$ s5 t+ l( C9 {4 n
#define TUE 23 C' a( T7 {9 F9 `* j4 ~
#define WED 3
6 k6 n- C' R9 }6 A8 @#define THU 45 \. H# [! k5 L2 a, t
#define FRI 5
/ h4 }$ `- F2 S* [+ k' D#define SAT 6
, w5 {" Y% d: B3 Z  b: E- Z#define SUN 7
0 `8 |" c- j( J$ g
这样的写法有点费键盘。那么枚举就简单多了：
enum DAY
7 x! z9 P: r; w$ M# ~{/ x8 o. q) D6 c0 t( O$ K* O' T
   MON=1, TUE, WED, THU, FRI, SAT, SUN
7 ~! M6 S$ y+ c( i7 ~* g};
5 [  E  x# N5 b
❝
**注意：**第一个枚举成员的默认值为整型的 0，后续枚举成员的值在前一个成员上加 1。我们在这个实例中把第一个枚举成员的值定义为 1，第二个就为 2，以此类推。
❞
枚举变量的定义和声明方法和共用体一样，也可以省略枚举名，直接声明变量名。
//Example 06. m7 ]' k/ g$ P$ e4 i9 l, z5 @$ s4 D
#include <stdio.h>
, R, U" B; n% h5 ~% V  D# U#include <stdlib.h>
+ C$ j8 ~- X4 E- A, i
, X" f  j; O  B9 Y4 U) v8 vint main()
' y9 W; [! Z1 T2 H7 D6 s( [{/ }; ]! h1 R6 u: v- q. X
5 g2 d8 \2 U; E0 I
enum color { red = 1, green, blue };
( U4 B  F  S( z
1 O( u$ x5 f* q8 f7 Q3 {0 M enum  color favorite_color;* {( z& A+ F; U

7 o+ V4 }1 `6 r/ r# y# \ printf("请输入你喜欢的颜色: (1. red, 2. green, 3. blue): ");+ G' }1 ^$ R9 z. b$ l! W
scanf("%d", &favorite_color);$ G: l. u' ~# H0 M" D, L6 r; w3 d& G

, P6 n) k" l( a //输出结果5 n% u# a2 h) t, r5 `4 _
switch (favorite_color)
8 C$ p) m, J1 i+ s7 s3 [ {' v& K8 ^8 V* C1 q7 y  y
case red:
+ Z& i' u5 C1 z5 B       printf("你喜欢的颜色是红色");: g& a& G! [: \6 S) i1 o, ^
      break;
- ?* g0 J' U/ \& _5 X case green:
6 Y, y* g9 L# S, L7 I       printf("你喜欢的颜色是绿色");
) c) i) g1 g0 `       break;5 B. f$ o- ]( X- I4 B0 B; T1 r
case blue:; B; [1 b/ b' I
      printf("你喜欢的颜色是蓝色");
% B5 F; _4 \7 Y5 F       break;- w4 }6 y. Y& v6 b% r/ U' V( D- m% t
default:( A4 a5 R0 A3 v5 ~
      printf("你没有选择你喜欢的颜色");4 q8 ^5 A2 s! F5 f& c1 {8 `2 ^# y1 w
}
! N1 |, l9 q8 f# r. r" b4 @! c, l$ d3 w8 d7 H8 n0 C
return 0;5 @; }: ]* ]* L: C/ N: B
}
7 i$ E/ K1 D5 [% z
执行结果如下：
//Consequence 06
1 u. a4 l% Z5 I& X# R. h' _请输入你喜欢的颜色: (1. red, 2. green, 3. blue): 39 O* \6 P1 d. p7 c( G2 V: K& `
你喜欢的颜色是蓝色" R9 l' `* D; a' ~- W9 b. r1 t

也可以把整数转换为枚举类型：
//Example 07
+ Z" {& u0 G/ _$ o( p  s3 X6 m& E4 k. f- V$ s! @7 V
#include <stdio.h># l8 b! g  Q5 s; t5 `8 k3 Q
#include <stdlib.h>, c( T- j" u' A6 v' x& K: a: [. D

: z6 C) T& U3 A' a8 G+ v8 ]' x5 V7 |int main()
  u. P2 M+ X; z8 G# ]& ^* L{, \& B. `: L" u( A- q' j2 J
enum day
1 M& e& K$ h. r" h {, x& {" f6 h* t" v0 R
      saturday,1 d" _( F3 U1 y: n+ i2 q  v# A
      sunday,- G5 i. c9 R5 l, i$ x5 H# I6 v
      monday,
/ }3 E9 x. p/ J5 M3 y8 h       tuesday,7 s8 o1 {1 L1 q- T
      wednesday,6 }+ [- U( G0 W6 G" Q- w$ x
      thursday,& r' ~8 v9 J! Y% t5 ^! f0 {+ U
      friday: N" D4 H' }4 R3 }, V; b# J  D6 D
} workday;
( N) n) k0 h4 ^* c" T, I
, [7 X4 k, N( n2 r4 e$ M int a = 1;
, ]$ z  C5 N7 u6 v% m enum day weekend;) u6 E9 k) F3 S! U% k
weekend = (enum day) a;  //使用强制类型转换
3 W! d8 ~; X8 `* h- x: w$ }8 k //weekend = a; //错误
2 l( ?8 a8 F7 R printf("weekend:%d", weekend);
2 t" J$ v% R# W4 a return 0;
0 K" Y8 p" F. v$ W' Q9 E}( U5 a, L5 I! ^" V# g7 z& _

运行结果如下：
//Consequence 07! b2 _2 x4 \9 S6 G/ m6 h8 x6 H
weekend:1. p8 P. J$ [/ k5 F+ W* h
位域
C语言除了开发桌面应用等，还有一个很重要的领域，那就是「单片机」开发。单片机上的硬件资源十分有限，容不得我们去肆意挥洒。单片机使一种集成电路芯片，使采用超大规模集成电路技术把具有数据处理能力的CPU、RAM、ROM、I/O、中断系统、定时器/计数器等功能（有的还包括显示驱动电路、脉宽调制电路、模拟多路转换器、A/D转换器等电路）集成到一块硅片上构成的一个小而完善的微型计算机系统，在工控领域使用广泛。
对于这样的设备，通常内存只有256B，那么能够给我们利用的资源就十分珍贵了。在这种情况下，如果我们只需要定义一个变量来存放布尔值，一般就申请一个整型变量，通过1和0来间接存储。但是，显然1和0只用1个bit就能够放完，而一个整型却是4个字节，也就是32bit。这就造成了内存的浪费。
好在，C语言为我们提供了一种数据结构，称为「位域」（也叫位端、位字段）。也就是把一个字节中的二进制位划分，并且你能够指定每个区域的位数。每个域有一个域名，并允许程序中按域名进行单独操作。
使用位域的做法是在结构体定义的时候，在结构体成员后面使用冒号（:）和数字来表示该成员所占的位数。
//Example 08
; |7 W5 j3 a5 C1 \( l0 p7 |" N- P7 q9 l#include <stdio.h>6 a( Q5 \( `# j7 |0 N
; @8 u* Q, }- Q! k( @6 s8 i& k
int main(void)
& I! b+ y& B- I* J  ?/ a{1 N0 A4 p4 l( }. Z8 Y' v5 a
struct Test
: k. x% Q) z; y; T* C {
2 y1 O/ b. n$ |. M, C. U( G% o  unsigned int a : 1;
$ T- {) |: J* Q; Q  I$ ]- a" f  unsigned int b : 1;9 x8 y1 l' ?0 O, d$ F$ h) q! t
  unsigned int c : 2;# ]$ K+ c: j1 }; C3 W5 L
} test;
0 }" g9 k% q7 F2 M  Z 1 x0 \- u# _, u* Y0 D
test.a = 0;
( L8 u" A' F- D# y; z& P test.b = 1;
( B2 G; R8 |0 @3 L, @0 J2 ?( k' o test.c = 2;
/ C1 @& `; Z& X/ A8 Z0 {
6 G8 k$ k; e) r% f- D4 O, \# ^ printf("a = %d, b = %d, c = %d\n", test.a, test.b, test.c);2 E) D7 Q0 W7 P8 A- D' ~; q
printf("size of test = %d\n", sizeof(test));! z, o6 s% u( u& K
+ s0 l/ _) G; a' T' B, z. A1 B- Q$ ?
return 0;+ X  e& `- S+ \6 P) t
}* X- m7 _2 b* Y

运行结果如下：
//Consequence 08
# t3 [* H+ x- Q9 k/ ka = 0, b = 1, c = 2
" U& g: c- H5 c$ M' y- p! bsize of test = 4' W% U8 k1 `) X; E# m

如此一来，结构体test只用了4bit，却存放下了0、1、2三个整数。但是由于2在二进制中是10，因此占了2个bit。如果把test.b赋值为2，那么：
//Consequence 08 V2
! f" Z' ~& v5 f! k% ^8 Ua = 0, b = 0, c = 2* [0 L& S5 [+ S/ ^( Y& z/ _6 g
size of test = 4
4 v. h8 E+ F) W: A" R# R9 m5 N
可以看到，b中的10溢出了，只剩下0。
当然，位域的宽度不能够超过本身类型的长度，比如：
unsigned int a : 100;4 V, V$ _. M, q  y* u3 w8 o1 I

那么就会报错：
错误 C2034 “main::test::a”: 位域类型对位数太小
+ i9 |% p3 _: C9 k
位域成员也可以没有名称，只要给出类型和宽度即可：
struct Test
/ e# d2 o0 L# b{
6 R% O- p: n8 l0 `* n+ J unsigned int x : 1;
! C% \$ U; }# }! {3 a unsigned int y : 2;; n8 V& G& l8 Z  F/ ]  l
unsigned int z : 3;5 s. _1 W" n- u# K" ?5 _
unsigned int : 26;" `3 _0 S% U2 u8 T) Z
};
" w) q. Z6 V; D# t3 t
无名位域一般用来作为填充或者调整成员的位置，因为没有名称，所以无名位域并不能够拿来使用。
❝
C语言的标准只说明unsigned int和signed int支持位域，然后C99增加了_Bool类型也支持位域，其他数据类型理论上是不支持的。不过大多数编译器在具体实现时都进行了扩展，额外支持了signed char、unsigned char以及枚举类型，所以如果对char类型的结构体成员使用位域，基本上也没什么问题。但如果考虑到程序的可移植性，就需要谨慎对待了。另外，由于内存的基本单位是字节，而位域只是字节的一部分，所以并不能对位域进行取地址运算。
❞
虽然科技发展日新月异，但是秉承着节约成本这个放之四海而皆准的原则，还是要注意使用！毕竟5毛钱可能是小钱，但是乘以5000万呢？
0 t$ C  E7 G2 E! E3 I