1. 为什么使用文件
前面学习结构体时，写了通讯录的程序，当通讯录运行起来的时候，可以给通讯录中增加、
删除数据，此时数据是存放在内存中，当程序退出的时候，通讯录中的数据自然就不存在了，
等下次运行通讯录程序的时候，数据又得重新录入，如果使用这样的通讯录就很难受。
既然是通讯录就应该把信息记录下来，只有我们选择删除数据的时候，数据才不复存在。
这就涉及到了数据持久化的问题，一般数据持久化的方法有，把数据存放在磁盘文件、
存放到数据库等方式。使用文件可以将数据直接存放在电脑的硬盘上，做到了数据的持久化。
2. 什么是文件
磁盘上的文件是文件。但是在程序设计中，我们一般谈的文件有两种：程序文件、数据文件（从文件功能的角度来分类的）。
【百度百科】电脑文件，也可以称之为计算机文件，是存储在某种长期储存设备或临时存储设备中的一段数据流，并且归属于计算机文件系统管理之下。所谓“长期储存设备”一般指磁盘、光盘、磁带等。而“短期存储设备”一般指计算机内存。需要注意的是，存储于长期存储设备的文件不一定是长期存储的，有些也可能是程序或系统运行中产生的临时数据，并于程序或系统退出后删除。
简单来讲，就是磁盘上的文件。但是在程序设计中，我们一般谈的文件有两种：程序文件、数据文件（从文件功能的角度来分类的）。
2.1 程序文件
程序文件包括源程序文件（后缀为.c）和目标文件（windows环境后缀为.obj），还有可执行程序（windows环境后缀为.exe）。
2.2 数据文件
文件的内容不一定是程序，而是程序运行时读写的数据，比如程序运行需要从中读取数据的文件，
或者输出内容的文件。本章讨论的是数据文件。在以前各章所处理数据的输入输出都是以终端为对象的，即从终端的键盘输入数据，运行结果显示到显示器上。其实有时候我们会把信息输出到磁盘上，当需要的时候再从磁盘上把数据读取到内存中使用，这里处理的就是磁盘上文件。
随便写一段代码，用于演示：
#include <stdio.h>
int main()
{
printf("hello,world!\n");
return 0;
}随后运行代码（便于生成文件）
那么，什么是程序文件呢？
找到代码路径，打开文件夹双击Dubug查看 “可执行程序” ：
这个exe文件就是程序文件。
退回到上层目录，找 “目标文件”：里面也有个Debug双击打开：
这个obj文件也属于程序文件（程序在编译过程中产生的临时文件）
那数据文件又是什么呢？在代码路径下创建一个文件：
这里先取后缀为.dat
此时，如果我写的程序在读写这个文件，那么这个文件就成为了数据文件。
本篇下面将对数据文件进行讨论。
2.3 文件名
【百度百科】文件名是文件存在的标识，操作系统根据文件名来对其进行控制和管理。不同的操作系统对文件命名的规则略有不同，即文件名的格式和长度因系统而异。为了方便人们区分计算机中的不同文件，而给每个文件设定一个指定的名称。由文件主名和扩展名组成。
一个文件要有一个唯一的文件标识，以便用户识别和引用。
文件名包含3部分：文件路径+文件名主干+文件后缀
例如： D:\data\TestDemo.txt
为了方便起见，文件标识常被称为文件名
3. 文件的打开和关闭
文件读写之前应该先打开文件，在使用结束后应该关闭文件。
在编写程序的时候，再打开文件的同时，都会返回一个 FILE* 指针变量指向该文件，
也相当于建立了指针和文件的关系。
ANSIC 规定使用 fopen 函数来打开文件， fclose 函数来关闭文件。
3.1 文件指针
【百度百科】在C语言中用一个指针变量指向一个文件，这个指针称为文件指针。
通过文件指针就可对它所指的文件进行各种操作。
缓冲文件系统中，关键的概念是“文件类型指针”，简称“文件指针”。
每个被使用的文件都在内存中开辟了一个相应的文件信息区，用来存放文件的相关信息
（如文件的名字，文件状态及文件当前的位置等）。这些信息是保存在一个结构体变量中的。
该结构体类型是有系统声明的，取名FILE（注意是类型）。
例如，VS2013编译环境提供的 stdio.h 头文件中有以下的文件类型声明：
struct _iobuf
{
char *_ptr;
int _cnt;
char *_base;
int _flag;
int _file;
int _charbuf;
int _bufsiz;
char *_tmpfname;
};
typedef struct _iobuf FILE;注意事项：
① FILE 的结构在不同的C编辑器中包含的内容并不是不完全相同的，但还是颇为相似的。
② 每当打开一个文件时，系统会根据文件的状况自动创建一个 FILE 结构的变量，并填充其中的信息，只要文件被读写发生变化，文件信息区也会跟着发生变化。至于文件变化时文件信息区是怎么变化和修改的，我们其实并不需要关心这些细节，因为C语言已经帮你弄好了。
③ 我们一般会通过一个 FILE 的指针来维护这个 FILE 结构的变量。并不会直接使用，而是拿一个结构体指针指向这个结构，通过这个指针来访问和维护相关的数据，这样使用起来会更加方便。
下面我们可以创建一个FILE*的指针变量:
FILE* pf;//文件指针变量定义pf是一个指向FILE类型数据的指针变量。可以使pf指向某个文件的文件信息区
（是一个结构体变量）。通过该文件信息区中的信息就能够访问该文件。也就是说，
通过文件指针变量能够找到与它关联的文件。
比如：
3.2 文件的打开和关闭
文件在读写之前应该先打开文件，在使用结束之后应该关闭文件。
在编写程序的时候，在打开文件的同时，都会返回一个FILE*的指针变量指向该文件，、也相当于建立了指针和文件的关系。
ANSI C 规定使用fopen函数来打开文件，fclose来关闭文件。头文件：stdlib.h
//打开文件
FILE * fopen ( const char * filename, const char * mode );
//关闭文件
int fclose ( FILE * stream );filename 参数指的是文件名，mode 参数为打开方式，打开方式如下：
代码演示：打开刚刚手动创建的TestDemo.dat文件
#include <stdio.h>
int main()
{
FILE* pf = fopen("TestDemo.dat", "w");//没有文件会创造一个文件
// 检查是否为空指针
if (pf == NULL)
{
perror("fopen");
return 1;
}
/* 写文件略 */
// 关闭文件
fclose(pf);
pf = NULL; // 记得将pf置为空指针
return 0;
}（代码正常运行）
//如果手动把创建的TestDemo.dat删除，运行程序后出来看就发现创建了一个test.dat文件
之前我们创建的 TestDemo.dat 的路径是在
这个路径下的，如果放在其他路径下可以读吗？
可以，但文件必须在该工程的路径下才行。
可以使用绝对路径，但是要注意转义绝对路径中的斜杠。
#include <stdio.h>
int main()
{
FILE* pf = fopen("D:\\C\\C_18_file\\C_18_file\\TestDeme.dat", "w");
// 转移字符\
if (pf == NULL)// 检查是否为空指针
{
perror("fopen");
return 1;
}
/* 写文件略 */
// 关闭文件
fclose(pf);
pf = NULL; // 记得将pf置为空指针
return 0;
}在磁盘把 TestDemo.dat 文件删除，然后打开方式改成 r 试试看：
#include <stdio.h>
int main()
{
FILE* pf = fopen("TestDemo.dat", "r");//出错
// 检查是否为空指针
if (pf == NULL)
{
perror("fopen");
return 1;
}
/* 写文件略 */
// 关闭文件
fclose(pf);
pf = NULL; // 记得将pf置为空指针
return 0;
}运行结果如下： （通过刚才的表格可知，如果 r 找不到指定的文件，会导致报错）
注意事项： 不关闭文件的后果：一个程序能够打开的文件是有限的，文件属于一种资源。如果只打开不释放，文件就会被占用。可能会导致一些操作被缓冲在内存中，如果不能正常关闭，缓冲在内存中的数据就不能正常写入到文件中从而导致数据的丢失。
4. 文件的顺序读写
首先要了解什么是读写：我们写的程序是在内存中，而数据是要放到文件中的，文件又是在硬盘上的。当我们把文件里的数据读到内存中去时，这个动作我们称之为输入/读取。反过来，如果把程序中的东西放到硬盘上，这个动作我们称之为输出/写入。
顺序读写，顾名思义就是按照顺序在文件中读和写。
顺序读写函数表
4.IO流：高度抽象的概念
观察刚才的表格我们可以发现有的函数是适用于所有xx流的（比如 fputc 函数）。
fputc 就适用于所有输出流，也就是说它不仅仅可以给文件里写。我们来读一下MSDN的介绍：
那么 stdout 是什么呢？
stdout 就是标准输出流，在这里，要讲一下流的概念。
当写一个程序，但不同的程序我们可能想写到不同的地方
C语言默认打开的3个流：
① stdin - 标准输入流 - 键盘
② stdout - 标准输出流 - 屏幕
③ stderr - 标准输出流 - 屏幕
我们用流向屏幕上输出信息 sputc- stdout：
#include <stdio.h>
int main()
{
fputc('a', stdout);
fputc('b', stdout);
fputc('c', stdout);
return 0;
}运行结果：
fgetc 从标准输入流读取 - stdin
#include <stdio.h>
// 使用fgetc从标准输入流中读
int main()
{
int ret = fgetc(stdin);
printf("%c\n", ret);
ret = fgetc(stdin);
printf("%c\n", ret);
ret = fgetc(stdin);
printf("%c\n", ret);
return 0;
}这里只读取三次（下面有这些函数和其他函数的介绍）
输入hello运行结果：
4.1字符输出函数 fputc
介绍：将参数 char 指定的字符写入到指定的流 stream 中，并把位置标识符向前移动
（字符必须为一个无符号字符）。适用于所有输出流。
代码演示：创建一个 test.txt，随后使用 fputc 函数分别写入 "abc" 到文件中
#include <stdio.h>
int main()
{
FILE* pf = fopen("test.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
// fputc写文件
fputc('a', pf);
fputc('b', pf);
fputc('c', pf);
// 关闭文件
fclose(pf);
pf = NULL;
return 0;
}运行后打开工程文件夹可以成功看到 test.txt 被创建了（大小为1kb可以看出写入成功了）：
打开 test.txt发现abc被成功写进去了
测试下 w 的覆盖效果，把写的内容注释掉：
#include <stdio.h>
int main()
{
FILE* pf = fopen("test.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
// fputc写文件
//fputc('a', pf);
//fputc('b', pf);
//fputc('c', pf);
// 关闭文件
fclose(pf);
pf = NULL;
return 0;
}此时再次运行，我们发现那个文件里的内容不见了（大小也变为0kb）：
值得注意的是，文件的写入是有顺序的。abc，先是a，然后是b，最后是c。
4.2字符输入函数 fgetc
介绍：从指定的流 stream 获取下一个字符，并把位置标识符向前移动（字符必须为一个无符号字符）。如果读取成功会返回相应的ASCII码值，如果读取失败它会返回一个EOF。适用于所有输入流。
代码演示：在工程文件夹里打开 test.txt ，随便手动写入一些数据保存，随后使用 fgetc 函数读取：
#include <stdio.h>
// 使用fgetc从文件里读
int main()
{
FILE* pf = fopen("test.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
// 读文件
int ret = fgetc(pf);
printf("%c\n", ret);
ret = fgetc(pf);
printf("%c\n", ret);
ret = fgetc(pf);
printf("%c\n", ret);
// 关闭文件
fclose(pf);
pf = NULL;
return 0;
}运行结果如下：
注意：读取结束或者遇到错误时会返回EOF（值是-1）。
4.3文本行输出函数 fputs
介绍：将字符串写入到指定的流 stream 中（不包括空字符）。适用于所有输出流。
代码演示：利用 fputs 在 test2.txt 中随便写入几行数据：
#include <stdio.h>
int main()
{
FILE* pf = fopen("test2.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
// 写文件 - 按照行来写
fputs("abcdef\n", pf);//文件里也会显示换行效果
fputs("123456", pf);
// 关闭文件
fclose(pf);
pf = NULL;
return 0;
}4.4文本行输入函数 fgets
介绍：从指定的流 stream 读取一行，并把它存储在 string 所指向的字符串中，当读取（n-1）个字符时，或者读取到换行符、到达文件末尾时，它会停止，具体视情况而定。适用于所有输入流。
注意事项：假如 n 是100，读取到的就是99个字符（n-1），因为要留一个字符给\0。
代码演示：利用 fgets 读取 test2.txt 中的内容：
#include <stdio.h>
int main()
{
char arr[10] = "xxxxxx"; // 存放处
FILE* pf = fopen("test2.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
// 读文件 - 按照行来读
fgets(arr, 4, pf);
printf("%s\n", arr);
fgets(arr, 4, pf);
printf("%s\n", arr);
// 关闭文件
fclose(pf);
pf = NULL;
return 0;
}4.5格式化输出函数 fprintf
介绍：fprintf 用于对格式化的数据进行写文件，发送格式化输出到流 stream 中。适用于所有输出流。
只需要在第一个函数参数放上一个文件指针，后面就和printf一样了。
代码演示：将结构体的三个数据利用 fprintf 写到 test3.txt 中：
#include <stdio.h>
struct student
{
char name[10];
int age;
float x;
};
int main()
{
struct student s = { "GR", 19, 3.14f };
// 对格式化的数据进行写文件
FILE* pf = fopen("test3.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
// 写文件
fprintf(pf, "%s %d %f", s.name, s.age, s.x);
// 关闭文件
fclose(pf);
pf = NULL;
return 0;
}4.6格式化输入函数 fscanf
介绍：fscanf 用于对格式化的数据进行读取，从流 stream 读取格式化输入。适用于所有输入流。
只需要在第一个函数参数放上一个文件指针，后面就和scanf一样了。
代码演示：利用 fscanf 读取刚才 test3.txt 中的内容，并打印：
#include <stdio.h>
struct student
{
char name[10];
int age;
float x;
};
int main()
{
struct student s = { 0 }; // 存放处
// 对格式化的数据进行写文件
FILE* pf = fopen("test3.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
// 读文件
fscanf(pf, "%s %d %f",s.name, &(s.age), &(s.x)); // s.name本身就是地址（不用&）
// 将读到的数据打印
printf("%s %d %f\n", s.name, s.age, s.x);
// 关闭文件
fclose(pf);
return 0;
}4.7二进制输出函数 fwrite
介绍：写一个数据到流中去，把 buffer 所指向的数组中的数据写入到给定流 stream 中。
const void *buffer : 指针指向要写出数据的内存首地址 ;
size_t size : 要写出数据的 基本单元 的字节大小 , 写出单位的大小 ;
size_t count : 要写出数据的 基本单元 的个数 ;
FILE *stream : 打开的文件指针 ;
返回值说明 : size_t 返回值返回的是实际写出到文件的 基本单元 个数 ;
创建一个 test4.txt，用 fwrite 写入一个数据到 text4.txt 中去：
#include <stdio.h>
struct student
{
char name[10];
int age;
float x;
};
int main()
{
struct student s = { "GR", 19, 3.14f }; // 存放处
FILE* pf = fopen("test4.txt", "w");
if (pf == NULL)
{
perror("fopen");
return 1;
}
//写文件
fwrite(&s, sizeof(struct student), 1, pf);
// 关闭文件
fclose(pf);
return 0;
}运行后打开文件后我们发现只有字母看得懂，后面是什么我们看不懂。
① 我们刚才用的都是文本编译器，文本编译器打开二进制形式的文件完全是两种状态。
② 因为字符串以文本形式写进去和以二进制形式写进去是一样的，但是对于整数、浮点数等
来说就不一样了，文本形式写入和二进制形式写入完全是两个概念。
（那么该怎么读呢，我们来看下面的 fread 函数）
4.8二进制输入函数 fread
介绍：从流中读取，从给定流 stream 读取数据到 buffer 所指向的数组中。参数和fwrite一样
用 fread 读取 text4.txt 中的二进制数据：
#include <stdio.h>
struct student
{
char name[10];
int age;
float x;
};
int main()
{
struct student s = { 0 }; // 存放处
FILE* pf = fopen("test4.txt", "r");
if (pf == NULL)
{
perror("fopen");
return 1;
}
// 读文件
fread(&s, sizeof(struct student), 1, pf);
// 将读到的数据打印
printf("%s %d %f", s.name, s.age, s.x);
// 关闭文件
fclose(pf);
return 0;
}总结： fwrite 和 fread 是一对，fwrire 写进去用 fread 读。
把动态通讯录写入文件
首先想到，在上一篇动态通讯录基础性应在退出销毁通讯录函数前设置一个保存通讯录到文件的函数。
那么自然，我们也需要打开通讯录的时候自动读入那个文件，每次打开通讯录我们都会运行init_contact函数，因此我们可以在init_contact函数中利用fread函数读入二进制文件。
写一个加载联系人函数：
//加载联系人函数
void load_contact(contact* p)
{
FILE* pf = fopen("contact.dat", "r");
if (pf == NULL)
{
perror("load_contact");
return;
}
//读文件
peoinfo tmp = { 0 };
while (fread(&tmp, sizeof(peoinfo), 1, pf))
{
//是否需要增容
check_capacity(p);
p->data[p->sz] = tmp;
p->sz++;
}
//关闭文件
fclose(pf);
pf = NULL;
}把之前add函数中负责扩容的部分单独提取出来封装为check_capacity函数，
因为负责扩容的部分利用if语句判断了当前是否需要扩容，这是为了读入文件做的准备。
读文件这里有一个难点，我们并不知道这个二进制文件里头有多少个通讯录成员，
可我们是动态扩容的，无法确定当前容量能不能撑得下这些通讯录成员。
可以利用fread函数的返回值，其返回值表示从二进制文件中读入了多少个元素，
利用一个while循环，每次只读一个通讯录成员信息进来，
循环条件为fread函数的返回值不为0（也就是还没读完），那如果容量不够怎么办？
利用check_capacity函数，每次执行时，先执行check_capacity函数，
如果当前容量不足则扩容，然后再利用fread函数从二进制文件中读入通讯录成员的信息。
代码：
test.c
//通讯录-静态版本
//1.通讯录中能够存放1000个人的信息
//每个人的信息：
//名字+年龄+性别+电话+地址
//2. 增加人的信息
//3. 删除指定人的信息
//4. 修改指定人的信息
//5. 查找指定人的信息
//6. 排序通讯录的信息
//
//版本2：
//动态增长的版本
//1.通讯录初始化后，能存放3个人的信息
//2.当我们空间的存放满的时候，我们增加2个信息
//3+2+2+2+...
//
//版本3
//当通讯录退出的时候，把信息写到文件
//当通讯录初始化的时候，加载文件的信息到通讯录中
//
#include"contact.h"
void menu()
{
printf("****************************************\n");
printf("****** 1.add 2.del ********\n");
printf("****** 3.search 4.modify ********\n");
printf("****** 5.sort 6.print ********\n");
printf("****** 0.exit ********\n");
printf("****************************************\n");
}
enum option
{
EXIT,
ADD,
DEL,
SEARCH,
MODIFY,
SORT,
PRINTF
};
int main()
{
int input = 0;
//创建通讯录 info(信息)
contact con;
//初始化通讯录函数
init_contact(&con);
do
{
menu();
printf("请选择：");
scanf("%d", &input);
switch (input)
{
case ADD:
add_contact(&con);
break;
case DEL:
del_contact(&con);
break;
case SEARCH:
find_contact(&con);
break;
case MODIFY:
modify_contact(&con);
break;
case SORT:
sort_contact(&con);
break;
case PRINTF:
print_contact(&con);
break;
case EXIT:
save_contact(&con);
destroy_contact(&con);
printf("退出程序\n");
break;
default:
printf("选择错误，重新选择\n");
break;
}
} while (input);
return 0;
}contact.h
#include<stdio.h>
#include<string.h>
#include<stdlib.h>//qsort，perror，动态内存开辟函数
#define MAX_NAME 20
#define MAX_SEX 10
#define MAX_TELE 20
#define MAX_ADDR 30
#define DEFAULT_SZ 3 //default 默认
#define INC_SZ 2 //sz增量
//类型的定义
typedef struct peoinfo
{
char name[MAX_NAME];
char sex[MAX_SEX];
int age;
char tele[MAX_TELE];
char addr[MAX_ADDR];
}peoinfo;
静态版本通讯录
//typedef struct contact
//{
// peoinfo data[MAX];//存放添加进来的人的信息
// int sz;//记录的是当前通讯录中有效信息的个数
//}contact;
//动态版本通讯录
typedef struct contact
{
peoinfo* data;//指向动态开辟的空间，存放添加进来的人的信息
int sz;//记录的是当前通讯录中有效信息的个数
int capacity;//记录当前通讯录的最大容量，方便增容
}contact;
//初始化通讯录函数
void init_contact(contact* p);
//是否需要增容函数
void check_capacity(contact* p);
//加载联系人函数
void load_contact(contact* p);
//增加联系人函数
void add_contact(contact* p);
//保存联系人函数
void save_contact(contact* p);
//销毁联系人函数
void destroy_contact(contact* p);
//打印联系人函数
void print_contact(const contact* p);
//删除联系人函数
void del_contact(contact* p);
//查找联系人函数
void find_contact(const contact* p);
//修改联系人函数
void modify_contact(contact* p);
//排序联系人函数
void sort_contact(contact* p);contact.c
#include"contact.h"
初始化通讯录函数 静态版本
//void init_contact(contact* p)
//{
// p->sz = 0;
// memset(p->data, 0, sizeof(p->data));
//}
//初始化通讯录函数 动态版本
void init_contact(contact* p)
{
p->data = (peoinfo*)calloc(DEFAULT_SZ, sizeof(peoinfo));
if (p->data == NULL)
{
perror("init_contact");
return;
}
p->sz = 0;//初始化后默认是0
p->capacity = DEFAULT_SZ;
//加载文件（读文件）
load_contact(p);
}
//是否需要增容函数
void check_capacity(contact* p)
{
if (p->sz == p->capacity)
{
peoinfo* tmp = (peoinfo*)realloc(p->data, (p->capacity + INC_SZ) * sizeof(peoinfo));
if (tmp == NULL)
{
perror("add_contact");
printf("增容失败\n");
return;
}
p->data = tmp;
p->capacity += INC_SZ;
printf("增容成功\n");
}
}
//加载联系人函数
void load_contact(contact* p)
{
FILE* pf = fopen("contact.dat", "r");
if (pf == NULL)
{
perror("load_contact");
return;
}
//读文件
peoinfo tmp = { 0 };
while (fread(&tmp, sizeof(peoinfo), 1, pf))
{
//是否需要增容
check_capacity(p);
p->data[p->sz] = tmp;
p->sz++;
}
//关闭文件
fclose(pf);
pf = NULL;
}
增加联系人函数 静态版本
//void add_contact(contact* p)
//{
// if (p->sz == MAX)
// {
// printf("通讯录已满，无法添加");
// return;
// }
// printf("请输入要添加人的姓名：");
// scanf("%s", p->data[p->sz].name);
// printf("请输入要添加人的性别：");
// scanf("%s", p->data[p->sz].sex);
// printf("请输入要添加人的年龄：");
// scanf("%d", &p->data[p->sz].age);//只用年龄不是数组，要取地址
// printf("请输入要添加人的电话：");
// scanf("%s", p->data[p->sz].tele);
// printf("请输入要添加人的住址：");
// scanf("%s", p->data[p->sz].addr);
//
// p->sz++;
// printf("添加成功\n");
//}
//增加联系人函数 动态版本
void add_contact(contact* p)
{
check_capacity(p);
printf("请输入要添加人的姓名：");
scanf("%s", p->data[p->sz].name);
printf("请输入要添加人的性别：");
scanf("%s", p->data[p->sz].sex);
printf("请输入要添加人的年龄：");
scanf("%d", &p->data[p->sz].age);//只用年龄不是数组，要取地址
printf("请输入要添加人的电话：");
scanf("%s", p->data[p->sz].tele);
printf("请输入要添加人的住址：");
scanf("%s", p->data[p->sz].addr);
p->sz++;
printf("添加成功\n");
}
//保存联系人函数
void save_contact(contact* p)
{
FILE* pf = fopen("contact.dat", "w");
if (pf == NULL)
{
perror("save_contact");
return;
}
//写文件
for (int i = 0;i < p->sz;i++)
{
fwrite(p->data + i, sizeof(peoinfo), 1, pf);
}
//关闭文件
fclose(pf);
pf = NULL;
}
//销毁联系人函数
void destroy_contact(contact* p)
{
free(p->data);
p->data = NULL;
p->sz = 0;
p->capacity = 0;
}
//打印联系人函数
void print_contact(const contact* p)
{
if (p->sz == 0)
{
printf("通讯录为空，无法打印\n");
}
else
{
printf("%-10s %-10s %-10s %-15s %-10s\n", "姓名", "性别", "年龄", "电话", "住址");
for (int i = 0;i < p->sz;i++)
{
printf("%-10s %-10s %-10d %-15s %-10s\n",
p->data[i].name,
p->data[i].sex,
p->data[i].age,
p->data[i].tele,
p->data[i].addr);
}
}
}
//查找函数的一部分，删除和修改也要用，只放在这就行
static int find_by_name(contact* p, char name[])
{
for (int i = 0;i < p->sz;i++)
{
if (strcmp(p->data[i].name,name)==0)
{
return i;
}
}
return -1;
}
//删除联系人函数
void del_contact(contact* p)
{
if (p->sz == 0)
{
printf("通讯录为空，无法删除\n");
}
else
{
char name[MAX_NAME] = { 0 };
printf("请输入要删除人的名字：");
scanf("%s", name);
int pos = find_by_name(p, name);
if (pos == -1)
{
printf("要删除的人不存在\n");
}
else
{
for (int i = pos;i < p->sz - 1;i++)
{
p->data[i] = p->data[i + 1];
}
p->sz--;
printf("删除成功\n");
}
}
}
//查找联系人函数
void find_contact(const contact* p)
{
if (p->sz == 0)
{
printf("通讯录为空，无法查找\n");
}
else
{
char name[MAX_NAME] = { 0 };
printf("请输入要查找人的名字：");
scanf("%s", name);
int pos = find_by_name(p, name);
if (pos == -1)
{
printf("要查找的人不存在\n");
}
else
{
printf("%-10s %-10s %-10s %-15s %-10s\n", "姓名", "性别", "年龄", "电话", "住址");
printf("%-10s %-10s %-10d %-15s %-10s\n",
p->data[pos].name,
p->data[pos].sex,
p->data[pos].age,
p->data[pos].tele,
p->data[pos].addr);
}
}
}
//修改联系人函数
void modify_contact(contact* p)
{
if (p->sz == 0)
{
printf("通讯录为空，无法查找\n");
}
else
{
char name[MAX_NAME] = { 0 };
printf("请输入要修改人的姓名：");
scanf("%s", name);
int pos = find_by_name(p, name);
if (pos == -1)
{
printf("要修改的人不存在\n");
}
else
{
printf("以下是输入要修改人的新信息：\n");
printf("请输入姓名：");
scanf("%s", p->data[pos].name);
printf("请输入性别：");
scanf("%s", p->data[pos].sex);
printf("请输入年龄：");
scanf("%d", &p->data[pos].age);
printf("请输入电话：");
scanf("%s", p->data[pos].tele);
printf("请输入住址：");
scanf("%s", p->data[pos].addr);
printf("修改成功\n");
}
}
}
//排序联系人函数
int cmp(void* e1, void* e2)
{
return strcmp(((peoinfo*)e1)->name, ((peoinfo*)e2)->name);
}
void sort_contact(contact* p)
{
if (p->sz == 0)
{
printf("通讯录为空，无法排序\n");
}
else
{
qsort(p->data, p->sz, sizeof(peoinfo), cmp);
printf("按照姓名排序成功\n");
}
}
void sort_contact2(contact* p)//冒泡，比较麻烦，就用qsort了
{
if (p->sz == 0)
{
printf("通讯录为空，无法排序\n");
}
else
{
for (int i = 0; i < p->sz; i++)
{
for (int j = 0; j < p->sz - i - 1; j++)
{
if (strcmp((p->data[j].name), (p->data[j + 1].name)) > 0)
{
peoinfo data = p->data[j];
p->data[j] = p->data[j + 1];
p->data[j + 1] = data;
}
}
}
printf("按照姓名排序成功\n");
}
}本篇完。
（穿越回来贴个链接）C语言进阶⑲(文件下篇)(文件读写+文本文件和二进制文件+EOF+文件缓冲区)_GR C的博客-CSDN博客
275
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
