• c语言：通讯录管理系统（文件版本）

    前言：本通讯录管理系统一共三个版本，除此文章以外还有如下俩个版本，大家可以根据需求自取：

    基础增删查改功能版本：c语言：通讯录管理系统（增删查改）-CSDN博客

    动态分配内存版本：c语言：通讯录管理系统（动态分配内存版）-CSDN博客

            本文是在基础的通讯录管理系统上进行改进（文末有完整代码，欢迎大家使用），如果对于基础的通讯录管理系统有什么不懂的地方，可以参考笔者的上一篇文章 

    目录

    一.非文件操作版本

    头文件部分（Contact.h）

    函数实现部分（Contact.cpp）

    主函数部分（test.cpp）

    二.文件的生成

    选择何种方式写文件？

    SaveContact

    三.文件数据的读取

    LoadContact

    四.运行结果截图

    五.完整代码 

    头文件部分（Contact.h）

    函数实现部分（Contact.cpp）

    主函数部分（test.cpp）

            关于通讯录管理系统，笔者一共设计了3套，分别是最基础的版本，动态管理内存版本，文件操作版本，本文是在动态管理的通讯录管理系统上进行改进，如果对于普通的通讯录管理系统有什么不懂的地方，可以参考笔者的前俩篇文章，里面有详细的万字解读，大家也可以根据自己的需求提取完整代码： 

    c语言：通讯录管理系统（增删查改）

    c语言：通讯录管理系统（动态分配内存版）

    一.非文件操作版本

    这里我们给出不包含文件操作版本的代码，然后本文后续内容都是基于此进行改进

    我们分为 3 个文件来设计：

    • Contact.h： 包含头文件的声明，对函数的声明，以及宏的申明
    • Contact.cpp： 通讯录管理系统中具体每一个函数的实现
    • test.cpp： 主函数，根据用户的选择进行调用相应的函数

     

    头文件部分（Contact.h）

    1. #pragma once
    2. #pragma once
    3. #include
    4. #include
    5. #include
    6. #include
    7.  
    8. #define Name_Max 20
    9. #define Tel_Number 12
    10. #define Sex_Max 5
    11. #define Address_Max 30
    12. #define Contact_Max 100
    13. #define Contact_SZ 3
    14.  
    15. //联系人结构体
    16. typedef struct PeopleInformation
    17. {
    18. 	char name[Name_Max];
    19. 	char telnumber[Tel_Number];
    20. 	int age;
    21. 	char sex[Sex_Max];
    22. 	char address[Address_Max];
    23. }PeoInfor;
    24.  
    25. //通讯录结构体
    26. typedef struct Contact
    27. {
    28. 	PeoInfor* data;//结构体数组存放联系人结构体
    29. 	int size;//记录当前通讯录中有多少个联系人
    30. 	int capacity;//记录当前存放的容量
    31. }Contact;
    32.  
    33.  
    34. //目录
    35. void menu();
    36.  
    37. //初始化通讯录
    38. void InitContact(Contact* cp);
    39.  
    40. //增加联系人
    41. void AddContact(Contact* cp);
    42.  
    43. //删除联系人
    44. void DelContact(Contact* cp);
    45.  
    46. //通过姓名进行查找联系人
    47. int FindPeople(Contact* cp, char name[]);
    48.  
    49. //展示全部通讯录信息
    50. void ShowContact(const Contact* cp);
    51.  
    52. //查询联系人
    53. void SeachPeople(Contact* cp);
    54.  
    55. //修改联系人信息
    56. void ModifyContact(Contact* cp);
    57.  
    58. //扩容
    59. void CheckContact(Contact* cp);
    60.  
    61. //销毁通讯录
    62. void DestoryContact(Contact* cp);

    函数实现部分（Contact.cpp）

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include "Contact.h"
    3.  
    4. void menu()
    5. {
    6. 	printf("\n");
    7. 	printf("-----------------------------\n");
    8. 	printf("---   1.添加联系人      -----\n");
    9. 	printf("---   2.删除联系人      -----\n");
    10. 	printf("---   3.查找联系人      -----\n");
    11. 	printf("---   4.修改联系人信息  -----\n");
    12. 	printf("---   5.显示全部信息    -----\n");
    13. 	printf("---   0.退出通讯录      -----\n");
    14. 	printf("-----------------------------\n");
    15. }
    16.  
    17. //初始化通讯录
    18. void InitContact(Contact* cp)
    19. {
    20. 	//判断非空
    21. 	assert(cp);
    22.  
    23. 	cp->size = 0;
    24. 	cp->capacity = Contact_SZ;
    25. 	cp->data =(PeoInfor*)calloc(cp->capacity, sizeof(PeoInfor));
    26. 	if (cp->data == NULL)
    27. 	{
    28. 		perror("InitContact->calloc");
    29. 		return;
    30. 	}
    31. }
    32.  
    33. void CheckContact(Contact* cp)
    34. {
    35. 	if (cp->size == cp->capacity)
    36. 	{
    37. 		PeoInfor* ptr = (PeoInfor*)realloc(cp->data, (cp->capacity + 2) * sizeof(PeoInfor));
    38. 		if (ptr != NULL)
    39. 		{
    40. 			cp->data = ptr;
    41. 			cp->capacity += 2;
    42. 			printf("增容成功\n");
    43. 		}
    44. 		else
    45. 		{
    46. 			perror("AddContact->realloc");
    47. 			return;
    48. 		}
    49. 	}
    50. }
    51.  
    52. //增加联系人
    53. void AddContact(Contact* cp)
    54. {
    55. 	//判断非空
    56. 	assert(cp);
    57.  
    58. 	//判断满后扩容
    59. 	CheckContact(cp);
    60.  
    61. 	printf("请输入要添加的联系人的姓名：\n");
    62. 	scanf("%s", cp->data[cp->size].name);
    63.  
    64. 	printf("请输入要添加的联系人的电话号：\n");
    65. 	scanf("%s", cp->data[cp->size].telnumber);
    66.  
    67. 	printf("请输入要添加的联系人的年龄：\n");
    68. 	scanf("%d", &(cp->data[cp->size].age));
    69.  
    70. 	printf("请输入要添加的联系人的性别：\n");
    71. 	scanf("%s", cp->data[cp->size].sex);
    72.  
    73. 	printf("请输入要添加的联系人的住址：\n");
    74. 	scanf("%s", cp->data[cp->size].address);
    75.  
    76. 	cp->size++;
    77. 	printf("添加成功\n");
    78. }
    79.  
    80. //通过姓名进行查找联系人
    81. int FindPeople(Contact* cp, char name[])
    82. {
    83. 	assert(cp);
    84. 	for (int i = 0; i < cp->size; i++)
    85. 	{
    86. 		if (strcmp(cp->data[i].name, name) == 0)
    87. 		{
    88. 			return i;
    89. 		}
    90. 	}
    91. 	return -1;
    92. }
    93.  
    94. //删除联系人
    95. void DelContact(Contact* cp)
    96. {
    97. 	assert(cp);
    98. 	char name[Name_Max];
    99. 	if (cp->size == 0)
    100. 	{
    101. 		printf("通讯录为空，无需删除\n");
    102. 		return;
    103. 	}
    104. 	printf("请输入选择删除的联系人的姓名：\n");
    105. 	scanf("%s", name);
    106. 	int ret = FindPeople(cp, name);
    107. 	if (ret == -1)
    108. 	{
    109. 		printf("要删除的联系人不存在\n");
    110. 		return;
    111. 	}
    112. 	for (int i = ret; i < cp->size - 1; i++)
    113. 	{
    114. 		cp->data[i] = cp->data[i + 1];
    115. 	}
    116. 	cp->size--;
    117. 	printf("删除成功\n");
    118. }
    119.  
    120. //查询联系人
    121. void SeachPeople(Contact* cp)
    122. {
    123. 	assert(cp);
    124. 	char name[Name_Max];
    125. 	if (cp->size == 0)
    126. 	{
    127. 		printf("通讯录为空\n");
    128. 		return;
    129. 	}
    130. 	printf("请输入选择查找的联系人的姓名：\n");
    131. 	scanf("%s", name);
    132. 	int ret = FindPeople(cp, name);
    133. 	if (ret == -1)
    134. 	{
    135. 		printf("要查找的联系人不存在\n");
    136. 		return;
    137. 	}
    138.  
    139. 	//名字  年龄  性别    电话    地址
    140. 	//xxx   xxx    xxx    xxx     xxx
    141. 	printf("%-10s%-5s%-5s%-12s%-30s\n", "名字", "年龄", "性别", "电话", "地址");
    142. 	//打印个人的信息
    143. 	printf("%-10s%-5d%-5s%-12s%-30s\n", cp->data[ret].name, cp->data[ret].age, cp->data[ret].sex, cp->data[ret].telnumber, cp->data[ret].address);
    144. }
    145.  
    146. //展示全部通讯录信息
    147. void ShowContact(const Contact* cp)
    148. {
    149. 	assert(cp);
    150. 	if (cp->size == 0)
    151. 	{
    152. 		printf("通讯录为空\n");
    153. 		return;
    154. 	}
    155. 	//名字  年龄  性别    电话    地址
    156. 	//xxx   xxx    xxx    xxx     xxx
    157. 	printf("%-10s%-5s%-5s%-12s%-30s\n", "名字", "年龄", "性别", "电话", "地址");
    158. 	for (int i = 0; i < cp->size; i++)
    159. 	{
    160. 		//打印每个人的信息
    161. 		printf("%-10s%-5d%-5s%-12s%-30s\n", cp->data[i].name, cp->data[i].age, cp->data[i].sex, cp->data[i].telnumber, cp->data[i].address);
    162. 	}
    163. }
    164.  
    165. //修改联系人信息
    166. void ModifyContact(Contact* cp)
    167. {
    168. 	assert(cp);
    169. 	char name[Name_Max];
    170. 	if (cp->size == 0)
    171. 	{
    172. 		printf("通讯录为空\n");
    173. 		return;
    174. 	}
    175. 	printf("请输入选择修改的联系人的姓名：\n");
    176. 	scanf("%s", name);
    177. 	int ret = FindPeople(cp, name);
    178. 	if (ret == -1)
    179. 	{
    180. 		printf("要修改的联系人信息不存在\n");
    181. 		return;
    182. 	}
    183.  
    184. 	printf("请输入要修改的联系人的姓名：\n");
    185. 	scanf("%s", cp->data[ret].name);
    186.  
    187. 	printf("请输入要修改的联系人的电话号：\n");
    188. 	scanf("%s", cp->data[ret].telnumber);
    189.  
    190. 	printf("请输入要修改的联系人的年龄：\n");
    191. 	scanf("%d", &(cp->data[ret].age));
    192.  
    193. 	printf("请输入要修改的联系人的性别：\n");
    194. 	scanf("%s", cp->data[ret].sex);
    195.  
    196. 	printf("请输入要修改的联系人的住址：\n");
    197. 	scanf("%s", cp->data[ret].address);
    198.  
    199. 	printf("修改成功\n");
    200. }
    201.  
    202. //销毁通讯录
    203. void DestoryContact(Contact* cp)
    204. {
    205. 	free(cp->data);
    206. 	cp->data = NULL;
    207. 	cp->size = 0;
    208. 	cp->capacity = 0;
    209. }

    主函数部分（test.cpp）

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include "Contact.h"
    3.  
    4. //枚举，增加程序的可读性
    5. enum options
    6. {
    7. 	EXIT,
    8. 	ADD,
    9. 	DEL,
    10. 	SEACH,
    11. 	MODIFY,
    12. 	SHOW
    13. };
    14.  
    15. int main()
    16. {
    17. 	int input = 0;
    18. 	//创建通讯录
    19. 	Contact con;
    20. 	//初始化通讯录
    21. 	InitContact(&con);
    22.  
    23. 	do
    24. 	{
    25. 		menu();
    26. 		printf("请输入你的选择： ");
    27. 		scanf("%d", &input);
    28.  
    29. 		switch (input)
    30. 		{
    31. 			//增加联系人信息
    32. 		case ADD:
    33. 			AddContact(&con);
    34. 			break;
    35. 			//删除联系人信息
    36. 		case DEL:
    37. 			DelContact(&con);
    38. 			break;
    39. 			//查找某个联系人的信息
    40. 		case SEACH:
    41. 			SeachPeople(&con);
    42. 			break;
    43. 			//修改某个联系人的信息
    44. 		case MODIFY:
    45. 			ModifyContact(&con);
    46. 			break;
    47. 			//展示通讯录内的每一个联系人的信息
    48. 		case SHOW:
    49. 			ShowContact(&con);
    50. 			break;
    51. 			//退出通讯录管理系统
    52. 		case EXIT:
    53. 			DestoryContact(&con);
    54. 			printf("通讯录已退出\n");
    55. 			break;
    56. 			//预防非法输入
    57. 		default:
    58. 			printf("输入错误，请重新输入\n");
    59. 			break;
    60. 		}
    61. 	} while (input);
    62.  
    63. 	return 0;
    64. }

    二.文件的生成

            想要把通讯录里的数据保存在文件中，首先就得生成一个文件，但生成文件的思路应该注意，以下笔者给大家提供俩个思路：

    1. 写入一个数据就生成文件，如果文件已生成，那就写入文件
    2. 在用户使用完通讯录后一次性将所有数据写入

            大家可以思考，哪种思路更高效，很显然，频繁的打开，写入，关闭文件是不利于我们执行程序的，因此，我们选择第二条思路，当然第一条思路也是可行的，在某些特定的需求下，可能第一条思路还要更优秀一点，但是作为一般讲，我们还是希望程序运行所需的时间和空间越简单越好 

            因此，本文采取第二种生成文件的思路：在用户使用完通讯录后一次性将所有数据写入，也就是说，我们需要在用户使用完通讯录程序以后，选择退出通讯录的时候进行生成文件，并且将通讯录中的数据导入

    因此，我们封装一个函数，来生成通讯录文件

    1. //读取文件信息到通讯录
    2. void LoadContact(Contact* cp);

    选择何种方式写文件？

            我们的通讯录管理系统中，有字符串，有整形，还可能有浮点型，短整形，结构体类型等等复杂的数据类型，因此单一的某中写入方式必然是不在我们考虑范围内的，针对我们的需求，我们需要选择一个 “万金油” 的写入方式————二进制写入

            不管是整形，浮点型，字符串，我们使用二进制去读取写入都是通用的，因此后文中对通讯录文件的读取也是使用的二进制读取

    SaveContact

    我们可以这样设计：

            首先，我们先打开文件，如果打开失败，那就报错提醒，如果正确打开了，那我们就进行写入文件，使用一个循环，一共有多少个联系人信息，我们就写入多少次，每次写入一个联系人的信息，写入完成后关闭文件，并且把指针置为空，避免造成野指针的问题

    1. //生成文件，保存通讯录中的数据
    2. void SaveContact(Contact* cp)
    3. {
    4. 	//打开文件
    5. 	FILE* pf = fopen("contact.txt", "wb");
    6. 	if (pf == NULL)
    7. 	{
    8. 		perror("SaveContact");
    9. 		return;
    10. 	}
    11.  
    12. 	//写文件
    13. 	for (int i = 0; i < cp->size; i++)
    14. 	{
    15. 		fwrite(cp->data + i, sizeof(PeoInfor), 1, pf);
    16. 	}
    17.  
    18. 	//关闭文件
    19. 	fclose(pf);
    20. 	pf = NULL;
    21. }

    三.文件数据的读取

            光有文件的生成是不够的，假如文件内部已经存了许多联系人的信息了，当我们打开通讯录管理系统的时候，这些数据也应该已经被读取了才合理

            因此，我们将文件数据的读取放在通讯录的初始化部分

    我们封装一个函数来帮助我们实现这部分功能：

    1. //读取文件信息到通讯录
    2. void LoadContact(Contact* cp);

            当我们打开通讯录管理系统后，首先进行初步的初始化通讯录，然后我们将文件中的数据读取到里面

    1. //初始化通讯录
    2. void InitContact(Contact* cp)
    3. {
    4. 	//判断非空
    5. 	assert(cp);
    6.  
    7. 	//初步初始化
    8. 	cp->size = 0;
    9. 	cp->capacity = Contact_SZ;
    10. 	cp->data = (PeoInfor*)calloc(cp->capacity, sizeof(PeoInfor));
    11. 	if (cp->data == NULL)
    12. 	{
    13. 		perror("InitContact->calloc");
    14. 		return;
    15. 	}
    16.  
    17. 	//读取文件信息到通讯录
    18. 	LoadContact(cp);
    19. }

    LoadContact

    为了对应我们前面用二进制写入文件，这里我们就应该使用二进制读取文件

    1. 	//打开文件
    2. 	FILE* pf = fopen("contact.txt", "rb");
    3. 	if (pf == NULL)
    4. 	{
    5. 		perror("LoadContact");
    6. 		return;
    7. 	}

            我们构建一个结构体数组的临时变量，我们先将数据从文件读出来一个，然后再判断通讯录是否已经满了，如果满了，那就先扩容，然后再把临时变量中的数据放入通讯录中，如果没有满，那就直接放入通讯录 

    1. //读取文件信息到通讯录
    2. void LoadContact(Contact* cp)
    3. {
    4. 	//打开文件
    5. 	FILE* pf = fopen("contact.txt", "rb");
    6. 	if (pf == NULL)
    7. 	{
    8. 		perror("LoadContact");
    9. 		return;
    10. 	}
    11.  
    12. 	//读取文件
    13. 	PeoInfor temp = { 0 };
    14. 	while (fread(&temp, sizeof(PeoInfor), 1, pf))
    15. 	{
    16. 		CheckContact(cp);
    17. 		cp->data[cp->size] = temp;
    18. 		cp->size++;
    19. 	}
    20. }

    其中判断扩容函数如下：

    1. //检查扩容
    2. void CheckContact(Contact* cp)
    3. {
    4. 	if (cp->size == cp->capacity)
    5. 	{
    6. 		PeoInfor* ptr = (PeoInfor*)realloc(cp->data, (cp->capacity + 2) * sizeof(PeoInfor));
    7. 		if (ptr != NULL)
    8. 		{
    9. 			cp->data = ptr;
    10. 			cp->capacity += 2;
    11. 			printf("增容成功\n");
    12. 		}
    13. 		else
    14. 		{
    15. 			perror("AddContact->realloc");
    16. 			return;
    17. 		}
    18. 	}
    19. }

    四.运行结果截图

    我们先输入4个人的信息，然后退出程序

            观察文件，因为我们使用的是二进制保存，而记事本使用的是 UTF-8 的格式，故而这里无法直观看到信息，信息相当于被加密了，但是可以确定的是我们确实是将数据保存下来了

    然后我们重新再打开一遍程序，可以看见，数据一开始就增容成功读取到了

    后续再进行增删查改等操作也是没有影响的

    五.完整代码 

    头文件部分（Contact.h）

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6.  
    7. #define Name_Max 20
    8. #define Tel_Number 12
    9. #define Sex_Max 5
    10. #define Address_Max 30
    11. #define Contact_Max 100
    12. #define Contact_SZ 3
    13.  
    14. //联系人结构体
    15. typedef struct PeopleInformation
    16. {
    17. 	char name[Name_Max];
    18. 	char telnumber[Tel_Number];
    19. 	int age;
    20. 	char sex[Sex_Max];
    21. 	char address[Address_Max];
    22. }PeoInfor;
    23.  
    24. //通讯录结构体
    25. typedef struct Contact
    26. {
    27. 	PeoInfor* data;//结构体数组存放联系人结构体
    28. 	int size;//记录当前通讯录中有多少个联系人
    29. 	int capacity;//记录当前存放的容量
    30. }Contact;
    31.  
    32.  
    33. //目录
    34. void menu();
    35.  
    36. //初始化通讯录
    37. void InitContact(Contact* cp);
    38.  
    39. //增加联系人
    40. void AddContact(Contact* cp);
    41.  
    42. //删除联系人
    43. void DelContact(Contact* cp);
    44.  
    45. //通过姓名进行查找联系人
    46. int FindPeople(Contact* cp, char name[]);
    47.  
    48. //展示全部通讯录信息
    49. void ShowContact(const Contact* cp);
    50.  
    51. //查询联系人
    52. void SeachPeople(Contact* cp);
    53.  
    54. //修改联系人信息
    55. void ModifyContact(Contact* cp);
    56.  
    57. //jia扩容
    58. void CheckContact(Contact* cp);
    59.  
    60. //销毁通讯录
    61. void DestoryContact(Contact* cp);
    62.  
    63. //生成文件，保存通讯录中的数据
    64. void SaveContact(Contact* cp);
    65.  
    66. //读取文件信息到通讯录
    67. void LoadContact(Contact* cp);

    函数实现部分（Contact.cpp）

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include "Contact.h"
    3.  
    4. void menu()
    5. {
    6. 	printf("\n");
    7. 	printf("-----------------------------\n");
    8. 	printf("---   1.添加联系人      -----\n");
    9. 	printf("---   2.删除联系人      -----\n");
    10. 	printf("---   3.查找联系人      -----\n");
    11. 	printf("---   4.修改联系人信息  -----\n");
    12. 	printf("---   5.显示全部信息    -----\n");
    13. 	printf("---   0.退出通讯录      -----\n");
    14. 	printf("-----------------------------\n");
    15. }
    16.  
    17.  
    18. //读取文件信息到通讯录
    19. void LoadContact(Contact* cp)
    20. {
    21. 	//打开文件
    22. 	FILE* pf = fopen("contact.txt", "rb");
    23. 	if (pf == NULL)
    24. 	{
    25. 		perror("LoadContact");
    26. 		return;
    27. 	}
    28.  
    29. 	//读取文件
    30. 	PeoInfor temp = { 0 };
    31. 	while (fread(&temp, sizeof(PeoInfor), 1, pf))
    32. 	{
    33. 		CheckContact(cp);
    34. 		cp->data[cp->size] = temp;
    35. 		cp->size++;
    36. 	}
    37. }
    38.  
    39. //初始化通讯录
    40. void InitContact(Contact* cp)
    41. {
    42. 	//判断非空
    43. 	assert(cp);
    44.  
    45. 	//初步初始化
    46. 	cp->size = 0;
    47. 	cp->capacity = Contact_SZ;
    48. 	cp->data = (PeoInfor*)calloc(cp->capacity, sizeof(PeoInfor));
    49. 	if (cp->data == NULL)
    50. 	{
    51. 		perror("InitContact->calloc");
    52. 		return;
    53. 	}
    54.  
    55. 	//读取文件信息到通讯录
    56. 	LoadContact(cp);
    57. }
    58.  
    59.  
    60. //检查扩容
    61. void CheckContact(Contact* cp)
    62. {
    63. 	if (cp->size == cp->capacity)
    64. 	{
    65. 		PeoInfor* ptr = (PeoInfor*)realloc(cp->data, (cp->capacity + 2) * sizeof(PeoInfor));
    66. 		if (ptr != NULL)
    67. 		{
    68. 			cp->data = ptr;
    69. 			cp->capacity += 2;
    70. 			printf("增容成功\n");
    71. 		}
    72. 		else
    73. 		{
    74. 			perror("AddContact->realloc");
    75. 			return;
    76. 		}
    77. 	}
    78. }
    79.  
    80. //增加联系人
    81. void AddContact(Contact* cp)
    82. {
    83. 	//判断非空
    84. 	assert(cp);
    85.  
    86. 	//判断满后扩容
    87. 	CheckContact(cp);
    88.  
    89. 	printf("请输入要添加的联系人的姓名：\n");
    90. 	scanf("%s", cp->data[cp->size].name);
    91.  
    92. 	printf("请输入要添加的联系人的电话号：\n");
    93. 	scanf("%s", cp->data[cp->size].telnumber);
    94.  
    95. 	printf("请输入要添加的联系人的年龄：\n");
    96. 	scanf("%d", &(cp->data[cp->size].age));
    97.  
    98. 	printf("请输入要添加的联系人的性别：\n");
    99. 	scanf("%s", cp->data[cp->size].sex);
    100.  
    101. 	printf("请输入要添加的联系人的住址：\n");
    102. 	scanf("%s", cp->data[cp->size].address);
    103.  
    104. 	cp->size++;
    105. 	printf("添加成功\n");
    106. }
    107.  
    108. //通过姓名进行查找联系人
    109. int FindPeople(Contact* cp, char name[])
    110. {
    111. 	assert(cp);
    112. 	for (int i = 0; i < cp->size; i++)
    113. 	{
    114. 		if (strcmp(cp->data[i].name, name) == 0)
    115. 		{
    116. 			return i;
    117. 		}
    118. 	}
    119. 	return -1;
    120. }
    121.  
    122. //删除联系人
    123. void DelContact(Contact* cp)
    124. {
    125. 	assert(cp);
    126. 	char name[Name_Max];
    127. 	if (cp->size == 0)
    128. 	{
    129. 		printf("通讯录为空，无需删除\n");
    130. 		return;
    131. 	}
    132. 	printf("请输入选择删除的联系人的姓名：\n");
    133. 	scanf("%s", name);
    134. 	int ret = FindPeople(cp, name);
    135. 	if (ret == -1)
    136. 	{
    137. 		printf("要删除的联系人不存在\n");
    138. 		return;
    139. 	}
    140. 	for (int i = ret; i < cp->size - 1; i++)
    141. 	{
    142. 		cp->data[i] = cp->data[i + 1];
    143. 	}
    144. 	cp->size--;
    145. 	printf("删除成功\n");
    146. }
    147.  
    148. //查询联系人
    149. void SeachPeople(Contact* cp)
    150. {
    151. 	assert(cp);
    152. 	char name[Name_Max];
    153. 	if (cp->size == 0)
    154. 	{
    155. 		printf("通讯录为空\n");
    156. 		return;
    157. 	}
    158. 	printf("请输入选择查找的联系人的姓名：\n");
    159. 	scanf("%s", name);
    160. 	int ret = FindPeople(cp, name);
    161. 	if (ret == -1)
    162. 	{
    163. 		printf("要查找的联系人不存在\n");
    164. 		return;
    165. 	}
    166.  
    167. 	//名字  年龄  性别    电话    地址
    168. 	//xxx   xxx    xxx    xxx     xxx
    169. 	printf("%-10s%-5s%-5s%-12s%-30s\n", "名字", "年龄", "性别", "电话", "地址");
    170. 	//打印个人的信息
    171. 	printf("%-10s%-5d%-5s%-12s%-30s\n", cp->data[ret].name, cp->data[ret].age, cp->data[ret].sex, cp->data[ret].telnumber, cp->data[ret].address);
    172. }
    173.  
    174. //展示全部通讯录信息
    175. void ShowContact(const Contact* cp)
    176. {
    177. 	assert(cp);
    178. 	if (cp->size == 0)
    179. 	{
    180. 		printf("通讯录为空\n");
    181. 		return;
    182. 	}
    183. 	//名字  年龄  性别    电话    地址
    184. 	//xxx   xxx    xxx    xxx     xxx
    185. 	printf("%-10s%-5s%-5s%-12s%-30s\n", "名字", "年龄", "性别", "电话", "地址");
    186. 	for (int i = 0; i < cp->size; i++)
    187. 	{
    188. 		//打印每个人的信息
    189. 		printf("%-10s%-5d%-5s%-12s%-30s\n", cp->data[i].name, cp->data[i].age, cp->data[i].sex, cp->data[i].telnumber, cp->data[i].address);
    190. 	}
    191. }
    192.  
    193. //修改联系人信息
    194. void ModifyContact(Contact* cp)
    195. {
    196. 	assert(cp);
    197. 	char name[Name_Max];
    198. 	if (cp->size == 0)
    199. 	{
    200. 		printf("通讯录为空\n");
    201. 		return;
    202. 	}
    203. 	printf("请输入选择修改的联系人的姓名：\n");
    204. 	scanf("%s", name);
    205. 	int ret = FindPeople(cp, name);
    206. 	if (ret == -1)
    207. 	{
    208. 		printf("要修改的联系人信息不存在\n");
    209. 		return;
    210. 	}
    211.  
    212. 	printf("请输入要修改的联系人的姓名：\n");
    213. 	scanf("%s", cp->data[ret].name);
    214.  
    215. 	printf("请输入要修改的联系人的电话号：\n");
    216. 	scanf("%s", cp->data[ret].telnumber);
    217.  
    218. 	printf("请输入要修改的联系人的年龄：\n");
    219. 	scanf("%d", &(cp->data[ret].age));
    220.  
    221. 	printf("请输入要修改的联系人的性别：\n");
    222. 	scanf("%s", cp->data[ret].sex);
    223.  
    224. 	printf("请输入要修改的联系人的住址：\n");
    225. 	scanf("%s", cp->data[ret].address);
    226.  
    227. 	printf("修改成功\n");
    228. }
    229.  
    230. //销毁通讯录
    231. void DestoryContact(Contact* cp)
    232. {
    233. 	free(cp->data);
    234. 	cp->data = NULL;
    235. 	cp->size = 0;
    236. 	cp->capacity = 0;
    237. }
    238.  
    239.  
    240. //生成文件，保存通讯录中的数据
    241. void SaveContact(Contact* cp)
    242. {
    243. 	//打开文件
    244. 	FILE* pf = fopen("contact.txt", "wb");
    245. 	if (pf == NULL)
    246. 	{
    247. 		perror("SaveContact");
    248. 		return;
    249. 	}
    250.  
    251. 	//写文件
    252. 	for (int i = 0; i < cp->size; i++)
    253. 	{
    254. 		fwrite(cp->data + i, sizeof(PeoInfor), 1, pf);
    255. 	}
    256.  
    257. 	//关闭文件
    258. 	fclose(pf);
    259. 	pf = NULL;
    260. }

    主函数部分（test.cpp）

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include "Contact.h"
    3.  
    4. //枚举，增加程序的可读性
    5. enum options
    6. {
    7. 	EXIT,
    8. 	ADD,
    9. 	DEL,
    10. 	SEACH,
    11. 	MODIFY,
    12. 	SHOW
    13. };
    14.  
    15. int main()
    16. {
    17. 	int input = 0;
    18. 	//创建通讯录
    19. 	Contact con;
    20. 	//初始化通讯录
    21. 	InitContact(&con);
    22.  
    23. 	do
    24. 	{
    25. 		menu();
    26. 		printf("请输入你的选择： ");
    27. 		scanf("%d", &input);
    28.  
    29. 		switch (input)
    30. 		{
    31. 			//增加联系人信息
    32. 		case ADD:
    33. 			AddContact(&con);
    34. 			break;
    35. 			//删除联系人信息
    36. 		case DEL:
    37. 			DelContact(&con);
    38. 			break;
    39. 			//查找某个联系人的信息
    40. 		case SEACH:
    41. 			SeachPeople(&con);
    42. 			break;
    43. 			//修改某个联系人的信息
    44. 		case MODIFY:
    45. 			ModifyContact(&con);
    46. 			break;
    47. 			//展示通讯录内的每一个联系人的信息
    48. 		case SHOW:
    49. 			ShowContact(&con);
    50. 			break;
    51. 			//退出通讯录管理系统
    52. 		case EXIT:
    53. 			SaveContact(&con);
    54. 			DestoryContact(&con);
    55. 			printf("通讯录已退出\n");
    56. 			break;
    57. 			//预防非法输入
    58. 		default:
    59. 			printf("输入错误，请重新输入\n");
    60. 			break;
    61. 		}
    62. 	} while (input);
    63.  
    64. 	return 0;
    65. }

    本次分享就到此为止了，感谢您的支持，如有错误，欢迎积极指正

  • 相关阅读:
    【POJ No. 3134】幂运算 Power Calculus
    910数据结构（2020年真题）
    详解设计模式：责任链模式
    【无标题】力扣报错：member access within null pointer of type ‘struct ListNode‘
    梳理自动驾驶中的各类坐标系
    【Linux】TCP的服务端（守护进程） + 客户端
    HDFS-FSCK命令输出
    探索Django验证码功能的实现 - DjangoStarter项目模板里的封装
    gateway动态网关/通用网关配置
    高精度RC振荡器的设计
  • 原文地址：https://blog.csdn.net/m0_69519887/article/details/133745818