• 简易通讯录Promax

    前言：哈喽小伙伴们，我们在前边的文章中已经介绍过了如何用C语言实现一个简易的通讯录，但是我们这个通讯录存在两个问题：

    一是通讯录的大小不能自由变化；二是通讯录的信息在程序退出之后就没有了，不能保存。

    那么，在我们学习完动态内存管理和文件操作之后，这些问题就迎刃而解啦。

    下面我们就来一起实现真正意义上的通讯录。

    一.动态内存改进

    1.创建联系人改进

    在最初的通讯录中，我们是用一个结构体类型的数组来存储信息：

    1. typedef struct Contact
    2. {
    3. 	Peomessage data[DATA_MAX];
    4. 	int sz;
    5. }Contact;

    那么当我们用到动态内存管理时，就不需要数组了，转而需要一个能够指向我们所开辟的空间的Peomessage类型的指针：

    1. typedef struct Contact
    2. {
    3. 	Peomessage* data;
    4. 	int sz;
    5. 	int Length;
    6. }Contact;

    能够看出，我们这里多了一个Length变量，它的作用是记录通讯录当前的大小，因为我们要根据存取的联系人信息数量是否要大于当前通讯录的大小来对通讯录进行扩充。

    通讯录都要有一个初始大小，所以我们规定通讯录的初始大小为3，每次扩充时增加2个空间：

    1. #define LENGTH 3
    2. #define ADD_LENGTH 2

     2.初始化改进

    初始化通讯录，就是用calloc函数动态开辟一块大小为LENGTH的空间。

    按照我们动态开辟空间的步骤即可：

    1. void InitContact(Contact* pc)
    2. {
    3. 	assert(pc);
    4. 	pc->sz = 0;
    5. 	pc->Length = LENGTH;
    6. 	pc->data = calloc(pc->Length, sizeof(Peomessage));
    7. 	if (pc->data == NULL)
    8. 	{
    9. 		perror("InitContact->calloc");
    10. 		return;
    11. 	}
    12. }

    将sz初始化为0，Length初始化为LENGTH。

    一定要注意对内存是否开辟成功的判断。

    3.增加联系人改进

    1. void AddContact(Contact* pc)
    2. {
    3. 	assert(pc);
    4. 	if (pc->sz == pc->Length)
    5. 	{
    6. 		Add_Length(pc);
    7. 	}
    8. 	printf("请输入名字：");
    9. 	scanf("%s", pc->data[pc->sz].name);
    10. 	printf("请输入电话：");
    11. 	scanf("%s", pc->data[pc->sz].tele);
    12. 	printf("请输入住址：");
    13. 	scanf("%s", pc->data[pc->sz].addr);
    14. 	pc->sz++;
    15. 	printf("添加成功\n");
    16. }

    增加联系人时，我们要进行sz是否等于当前Length的判断，如果相等，说明当前通讯录已满，需要扩充，所以我们就调用扩容函数：

    1. void Add_Length(Contact* pc)
    2. {
    3. 	Peomessage* ptr = (Peomessage*)realloc(pc->data, (pc->Length + 2) * sizeof(Peomessage));
    4. 	if (ptr == NULL)
    5. 	{
    6. 		perror("Add_Length->realloc");
    7. 		return;
    8. 	}
    9. 	else
    10. 	{
    11. 		pc->data = ptr;
    12. 		pc->Length += 2;
    13.         printf("扩容成功\n");
    14. 	}
    15.  
    16. }

     既然是扩容，那么就是修改我们已经开辟的空间大小，要用到realloc函数来修改大小，新的大小为Length + 2。

    这里要注意一点，realloc函数修改空间也可能会失败，如果就直接用data指针来接收的话，如果失败，就会返回空指针，那我们原本所存的数据就不复存在了。

    所以要用一个新的指针ptr来测试，如果不为空，再将ptr赋给data，同时要注意Length要加2。

     

    来看结果，我们当前已经存了三个人的信息，再次选择存信息时，就会显示扩容成功。 

    4. 销毁通讯录

    在动态内存管理里边我们已经学习过，动态开辟的空间使用之后要及时销毁，所以我们在通讯录退出之时，要用一个销毁函数来释放空间并还原通讯录。

    1. case EXIT:
    2. 	Destroy_Contact(&con);
    3. 	printf("退出通讯录\n");
    4. 	break;
    1. void Destroy_Contact(Contact* pc)
    2. {
    3. 	free(pc->data);
    4. 	pc->data = NULL;
    5. 	pc->sz = 0;
    6. 	pc->Length = LENGTH;
    7. }

    要将指针data释放并置空，同时sz和Length也要还原。

    这样我们便能够实现通讯录的动态大小变换了。

    接下来，我们再用文件操作的相关知识来实现信息的真正存储。

    二.文件操作改进

    1.写文件

    想保存我们已经写过的联系人信息，就要把它们写入文件，那么请小伙伴们思考一下，什么时候写入文件最合适呢？？？

    是不是当我们不需要在进行任何操作，要退出通讯录的时候呀。

    所以这个时候我们就需要一个写文件的函数WriteContact来实现：

    1. case EXIT:
    2. 	WriteContact(&con);
    3. 	Destroy_Contact(&con);
    4. 	printf("退出通讯录\n");
    5. 	break;

    那么小伙伴们再来思考一下，我们该怎么写文件呢？？？

    我们已经知道，要写的数据是一个结构体，含有多种数据类型，那对于我们已经学习过的文件读写函数，是不是用二进制读写函数是最好的，因为二进制不分数据类型：

    1. void WriteContact(Contact* pc)
    2. {
    3. 	assert(pc);
    4. 	FILE* pf = fopen("Contact.txt", "wb");
    5. 	if (pf == NULL)
    6. 	{
    7. 		perror("WriteContact->fopen");
    8. 		return;
    9. 	}
    10. 	int i = 0;
    11. 	for (i = 0; i < pc->sz; i++)
    12. 	{
    13. 		fwrite(pc->data + i, sizeof(Peomessage), 1, pf);
    14. 	}
    15. 	fcolse(pf);
    16. 	pf = NULL;
    17. }

    因为我们读入的数据可能不止一个，所以要使用for循环来实现全部读写。

    这时候当我们的程序文件目录下就会生成一个Contact.txt文件，打开内容为：

    这里虽然没有对齐，但是我们不用管，因为我们并不是要通过文件来看通讯录信息，而是通过程序来看的。 文件只是一个后台，而真正展现给用户的是程序运行窗口。

    这样我们就实现了数据保存到文件的操作。

    你以为这样就结束了吗，太天真了，当我们再次运行程序时，结果为：

    通讯录依然为空，这是为什么呢？？？

     因为虽然我们的文件确实还存在，内容也存在，但是我们的内存空间不存在了，我们的代码重启是开辟一个新的空间，新的空间中并没有我们已经写入的文件的数据。

    所以在此之前，我们需要先将文件里的数据输入到我们开辟的新的空间中去。

    2.读文件

    读文件的操作，需要在我们对文件进行任何操作之前，也就是在初始化的时候就完成。

    读二进制文件就要用到fread函数了，注意，因为我们的通讯录初始大小仅为3，但是文件中已经存放的数据可能要多余3个，所以要提前进行判断是否需要扩容，所以我们要先用一个临时指针ptr来接收信息，随后再赋值给data。

    来看代码实现：

    1. void ReadContact(Contact* pc)
    2. {
    3. 	assert(pc);
    4. 	FILE* pf = fopen("Contact.txt", "rb");
    5. 	if (pf == NULL)
    6. 	{
    7. 		perror("ReadContact -> fopen");
    8. 		return;
    9. 	}
    10. 	Peomessage ptr = { 0 };
    11. 	while (fread(&ptr, sizeof(Peomessage), 1, pf))
    12. 	{
    13. 		if (pc->sz == pc->Length)
    14. 		{
    15. 			Add_Length(pc);
    16. 		}
    17. 		pc->data[pc->sz] = ptr;
    18. 		pc->sz++;
    19. 	}
    20. }

    这个时候来看结果，当我们运行代码，并选择显示通讯录5时，我们已经有数据了，

    然后我们再添加一位联系人信息并关闭，再次打开时，就多了一个：

     至此，我们就完成了通讯录Promax的实现。

    三.完整代码展示

    1.Contact.h

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6.  
    7. #define NAME_MAX 20
    8. #define ADDR_MAX 30
    9. #define DATA_MAX 100 
    10. #define LENGTH 3
    11. #define ADD_LENGTH 2
    12. //选项
    13. enum Function
    14. {
    15. 	EXIT,//默认从0开始
    16. 	ADD,
    17. 	DEL,
    18. 	SEARCH,
    19. 	REVISE,
    20. 	SHOW,
    21. 	SORT,
    22. 	EMPTY
    23. };
    24. enum Type
    25. {
    26. 	QUIT,
    27. 	NAME,
    28. 	TELE,
    29. 	ADDR
    30. };
    31. //联系人信息
    32. typedef struct Peomessage
    33. {
    34. 	char name[NAME_MAX];
    35. 	char tele[12];
    36. 	char addr[ADDR_MAX];
    37. }Peomessage;
    38. //原通讯录
    39. //typedef struct Contact
    40. //{
    41. //	Peomessage data[DATA_MAX];
    42. //	int sz;
    43. //}Contact;
    44. //改进通讯录
    45. typedef struct Contact
    46. {
    47. 	Peomessage* data;
    48. 	int sz;
    49. 	int Length;
    50. }Contact;
    51. //初始化通讯录
    52. void InitContact(Contact* pc);
    53. //增加联系人信息
    54. void AddContact(Contact* pc);
    55. //显示联系人信息
    56. void ShowContact(Contact* pc);
    57. //查找联系人信息
    58. void SearchContact(Contact* pc);
    59. //删除联系人信息
    60. void DelContact(Contact* pc);
    61. //修改联系人信息
    62. void ReviseContact(Contact* pc);
    63. //排序联系人信息
    64. void SortContact(Contact* pc);
    65. //清空所有联系人
    66. void EmptyContact(Contact* pc);
    67. //摧毁通讯录
    68. void Destroy_Contact(Contact* pc);
    69. //写文件
    70. void WriteContact(Contact* pc);
    71. //读文件
    72. void ReadContact(Contact* pc);

     2.Contact.c

    1. #include"Contact.h"
    2. void Add_Length(Contact* pc);
    3. //读文件
    4. void ReadContact(Contact* pc)
    5. {
    6. 	assert(pc);
    7. 	FILE* pf = fopen("Contact.txt", "rb");
    8. 	if (pf == NULL)
    9. 	{
    10. 		perror("ReadContact -> fopen");
    11. 		return;
    12. 	}
    13. 	Peomessage ptr = { 0 };
    14. 	while (fread(&ptr, sizeof(Peomessage), 1, pf))
    15. 	{
    16. 		if (pc->sz == pc->Length)
    17. 		{
    18. 			Add_Length(pc);
    19. 		}
    20. 		pc->data[pc->sz] = ptr;
    21. 		pc->sz++;
    22. 	}
    23. }
    24. // 改进初始化
    25. void InitContact(Contact* pc)
    26. {
    27. 	assert(pc);
    28. 	pc->sz = 0;
    29. 	pc->Length = LENGTH;
    30. 	pc->data = calloc(pc->Length, sizeof(Peomessage));
    31. 	if (pc->data == NULL)
    32. 	{
    33. 		perror("InitContact->calloc");
    34. 		return;
    35. 	}
    36. 	ReadContact(pc);
    37. }
    38. //扩容通讯录
    39. void Add_Length(Contact* pc)
    40. {
    41. 	Peomessage* ptr = (Peomessage*)realloc(pc->data, (pc->Length + 2) * sizeof(Peomessage));
    42. 	if (ptr == NULL)
    43. 	{
    44. 		perror("Add_Length->realloc");
    45. 		return;
    46. 	}
    47. 	else
    48. 	{
    49. 		pc->data = ptr;
    50. 		pc->Length += 2;
    51. 	}
    52.  
    53. }
    54. //增加联系人信息
    55. void AddContact(Contact* pc)
    56. {
    57. 	assert(pc);
    58. 	//增加容量
    59. 	if (pc->sz == pc->Length)
    60. 	{
    61. 		Add_Length(pc);
    62. 	}
    63. 	printf("请输入名字：");
    64. 	scanf("%s", pc->data[pc->sz].name);
    65. 	printf("请输入电话：");
    66. 	scanf("%s", pc->data[pc->sz].tele);
    67. 	printf("请输入住址：");
    68. 	scanf("%s", pc->data[pc->sz].addr);
    69. 	pc->sz++;
    70. 	printf("添加成功\n");
    71. }
    72. //显示联系人信息
    73. void ShowContact(Contact* pc)
    74. {
    75. 	assert(pc);
    76. 	if (pc->sz == 0)
    77. 	{
    78. 		printf("通讯录为空\n");
    79. 		return;
    80. 	}
    81. 	printf("%-20s%-12s%-30s\n", "姓名", "电话", "住址");
    82. 	int i = 0;
    83. 	for (i = 0; i < pc->sz; i++)
    84. 	{
    85. 		printf("%-20s%-12s%-30s\n", pc->data[i].name, pc->data[i].tele, pc->data[i].addr);
    86. 	}
    87. }
    88. //通过名字查找
    89. int FindByName(Contact* pc, char* name)
    90. {
    91. 	assert(pc && name);
    92. 	int i = 0;
    93. 	for (i = 0; i < pc->sz; i++)
    94. 	{
    95. 		if (strcmp(name, pc->data[i].name) == 0)
    96. 		{
    97. 			return i;
    98. 		}
    99. 	}
    100. 	return -1;
    101. }
    102. //查找联系人信息
    103. void SearchContact(Contact* pc)
    104. {
    105. 	assert(pc);
    106. 	char name[NAME_MAX];
    107. 	printf("请输入要查找人的名字：");
    108. 	scanf("%s", name);
    109. 	int ret = FindByName(pc, name);
    110. 	if (ret == -1)
    111. 	{
    112. 		printf("找不到该联系人\n");
    113. 		return;
    114. 	}
    115. 	printf("%-20s%-12s%-30s\n", "姓名", "电话", "住址");
    116. 	printf("%-20s%-12s%-30s\n", pc->data[ret].name, pc->data[ret].tele, pc->data[ret].addr);
    117. }
    118. //删除联系人信息
    119. void DelContact(Contact* pc)
    120. {
    121. 	assert(pc);
    122. 	char name[NAME_MAX];
    123. 	printf("请输入要删除联系人的名字：");
    124. 	scanf("%s", name);
    125. 	int ret = FindByName(pc, name);
    126. 	if (ret == -1)
    127. 	{
    128. 		printf("该联系人信息不存在\n");
    129. 		return;
    130. 	}
    131. 	//删除联系人
    132. 	int i = 0;
    133. 	for (i = ret; i < pc->sz - 1; i++)
    134. 	{
    135. 		pc->data[i] = pc->data[i + 1];
    136. 	}
    137. 	pc->sz--;
    138. 	printf("删除成功\n");
    139. }
    140. void menu2()
    141. {
    142. 	printf("*******************************\n");
    143. 	printf("***** 0.exit       1.name *****\n");
    144. 	printf("***** 2.tele       3.addr *****\n");
    145. 	printf("*******************************\n");
    146. }
    147. //修改联系人信息
    148. void ReviseContact(Contact* pc)
    149. {
    150. 	assert(pc);
    151. 	char name[NAME_MAX];
    152. 	printf("请输入要修改联系人的名字：");
    153. 	scanf("%s", name);
    154. 	int ret = FindByName(pc, name);
    155. 	if (ret == -1)
    156. 	{
    157. 		printf("该联系人信息不存在\n");
    158. 		return;
    159. 	}
    160. 	int input;
    161. 	do
    162. 	{
    163. 		menu2();
    164. 		printf("请选择要修改的信息类型：");
    165. 		scanf("%d", &input);
    166. 		switch (input)
    167. 		{
    168. 		case QUIT:
    169. 			printf("退出修改\n");
    170. 			break;
    171. 		case NAME:
    172. 			printf("请输入名字：");
    173. 			scanf("%s", pc->data[ret].name);
    174. 			printf("修改成功\n");
    175. 			break;
    176. 		case TELE:
    177. 			printf("请输入电话：");
    178. 			scanf("%s", pc->data[ret].tele);
    179. 			printf("修改成功\n");
    180. 			break;
    181. 		case ADDR:
    182. 			printf("请输入地址：");
    183. 			scanf("%s", pc->data[ret].addr);
    184. 			printf("修改成功\n");
    185. 			break;
    186. 		default:
    187. 			printf("选择错误，请重新选择\n");
    188. 			break;
    189. 		}
    190. 	} while (input);
    191. }
    192. //排序联系人信息
    193. int compare(const void* a, const void* b)
    194. {
    195. 	return strcmp(((Peomessage*)a)->name, ((Peomessage*)b)->name);
    196. }
    197. void SortContact(Contact* pc)
    198. {
    199. 	assert(pc);
    200. 	qsort(pc->data, pc->sz, sizeof(pc->data[0]), compare);
    201. 	printf("排序成功\n");
    202. }
    203. //清空所有联系人
    204. void EmptyContact(Contact* pc)
    205. {
    206. 	assert(pc);
    207. 	pc->sz = 0;
    208. 	memset(pc->data, 0, sizeof(pc->data));
    209. 	printf("已清空通讯录\n");
    210. }
    211. //还原通讯录
    212. void Destroy_Contact(Contact* pc)
    213. {
    214. 	assert(pc);
    215. 	free(pc->data);
    216. 	pc->data = NULL;
    217. 	pc->sz = 0;
    218. 	pc->Length = LENGTH;
    219. }
    220.  
    221. //写文件
    222. void WriteContact(Contact* pc)
    223. {
    224. 	assert(pc);
    225. 	FILE* pf = fopen("Contact.txt", "wb");
    226. 	if (pf == NULL)
    227. 	{
    228. 		perror("WriteContact->fopen");
    229. 		return;
    230. 	}
    231. 	int i = 0;
    232. 	for (i = 0; i < pc->sz; i++)
    233. 	{
    234. 		fwrite(pc->data + i, sizeof(Peomessage), 1, pf);
    235. 	}
    236. 	fclose(pf);
    237. 	pf = NULL;
    238. }

    3. test.c

    1. #include "Contact.h"
    2. void menu1()//菜单
    3. {
    4. 	printf("*********************************\n");
    5. 	printf("***** 1.add        2.del    *****\n");
    6. 	printf("***** 3.search     4.revise *****\n");
    7. 	printf("***** 5.show       6.sort   *****\n");
    8. 	printf("***** 7.empty      0.exit   *****\n");
    9. 	printf("*********************************\n");
    10. }
    11. int main()
    12. {
    13. 	Contact con;
    14. 	//初始化通讯录
    15. 	InitContact(&con);
    16. 	int input;
    17. 	do {
    18. 		menu1();
    19. 		printf("请选择->：");
    20. 		scanf("%d", &input);
    21. 		switch (input)
    22. 		{
    23. 		case EXIT:
    24. 			WriteContact(&con);
    25. 			Destroy_Contact(&con);
    26. 			printf("退出通讯录\n");
    27. 			break;
    28. 		case ADD:
    29. 			AddContact(&con);
    30. 			break;
    31. 		case DEL:
    32. 			DelContact(&con);
    33. 			break;
    34. 		case SEARCH:
    35. 			SearchContact(&con);
    36. 			break;
    37. 		case REVISE:
    38. 			ReviseContact(&con);
    39. 			break;
    40. 		case SHOW:
    41. 			ShowContact(&con);
    42. 			break;
    43. 		case SORT:
    44. 			SortContact(&con);
    45. 			break;
    46. 		case EMPTY:
    47. 			EmptyContact(&con);
    48. 			break;
    49. 		default:
    50. 			printf("输入错误，请重新输入\n");
    51.  
    52. 		}
    53. 	} while (input);
    54. 	return 0;
    55. }

    四.总结

    每次写完一个大项目时，我都会为自己感到自豪，因为自己在不断地进步。

    希望小伙伴们也能够不断地奋斗，争取早日拿到自己心意的offer！

    最后还是不要忘记一键三连呀！

    我们下期再见啦！！！

  • 相关阅读:
    Java—数组中涉及的常见算法
    跨境分析 | 疫情之下跨境电商如何选品？这类商品亚马逊销量不降反增
    uni-app编程checkbox-group获取选中的每个checkbox的value值
    nodejs+vue教学辅助管理系统
    Java学习路线图，全套Java基础视频教程
    Spark 环境安装与案例演示
    持续集成部署-k8s-服务发现-Ingress
    C++强制类型转换操作符
    堆排序算法和Topk思想
    智能窗帘电机究竟有何亮点？智汀小米有何优势？
  • 原文地址：https://blog.csdn.net/2303_78442132/article/details/133839041