经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C 语言 » 查看文章
精通C语言：打造高效便捷的通讯录管理系统
来源：cnblogs　　作者：Betty’sSweet　　时间：2024/2/18 9:01:02　　对本文有异议

pFp8UCq.jpg

?? 欢迎大家来到贝蒂大讲堂??

????养成好习惯，先赞后看哦~????

所属专栏：C语言项目
贝蒂的主页：Betty‘s blog

引言：

在我们大致学习完C语言之后，我们就可以利用目前所学的知识去做一些有意思的项目，而今天贝蒂就带大家完成一个通讯录的简易实现，

本章你可能需要的知识：

  1. 动态内存的使用：动态内存管理
  2. 文件的创建与使用：文件操作

1. 通讯录要求

  1. 通讯录包括每个人的姓名，性别，年龄，电话与地址。
  2. 玩家可以自由选择通讯录的进出。
  3. 玩家可以自由增删查改通讯录中的数据。

2. 多文件管理

为了方便代码的管理和保证通讯录实现逻辑的清晰性，我们将采用多文件管理的模式。

  1. 创建头文件contact.c，包含所有头文件(其他源文件只需引用它即可)，以及所有通讯录功能的展现。

  2. 创建源文件contact.c，负责通讯录所有功能的具体代码实现。

  3. 创建源文件text.c，负责展现通讯录实现的总体逻辑。

3. 通讯录的准备

3.1 预处理信息

为了方便我们后续更换通讯的信息，我们可以利用宏来定义通讯录的具体信息的大小。

  1. #define MAX 100//最大人数
  2. #define MAX_NAME 20//名字最大长度
  3. #define MAX_SEX 5//性别最大长度
  4. #define MAX_TELE 12//电话最大长度
  5. #define MAX_ADDR 30//地址最大长度

3.2 结构体定义

每个人的通讯录都要包含姓名，性别，年龄，电话与地址等信息，这时就需要我们创建一个结构体来方便管理。

  1. typedef struct PeoInfo
  2. {
  3. 	char name[MAX_NAME];//名字
  4. 	int age;//年龄
  5. 	char sex[MAX_SEX];//性别
  6. 	char tele[MAX_TELE];//电话
  7. 	char addr[MAX_ADDR];//地址
  8. }PeoInfo;

而我们需要用这个结构体创建一个大小为100的数组，并且我们还需要知道当前通讯录的大小才能进行增删查改的操作，这两者息息相关，为了简化代码和增加代码的可读性，我们可以将这两者重新定义一个结构体。

  1. typedef struct contact
  2. {
  3. 	PeoInfo data[MAX];//一百个人的数据
  4. 	int sz;//通讯录的大小
  5. }contact;

4. 简易菜单

  1. void menu()
  2. {
  3.     printf("***********************************\n");
  4.     printf("**    1.add          2.delete    **\n");
  5.     printf("**    3.search       4.modify    **\n");
  6.     printf("**    5.display      6.sort      **\n");
  7.     printf("**             0.exit            **\n");
  8.     printf("***********************************\n");
  9. }

画面展示：

5. 通讯录具体功能

5.1 初始化

我们首先对通讯录进行初始化。

  1. void InitContact(contact* pc)//初始化
  2. {
  3. 	assert(pc);
  4. 	pc->sz = 0;
  5. 	memset(pc->data, 0, sizeof(pc->data));
  6. }

5.2 展示联系人

当用户选择5时自动展示通讯录中的用户，并且展示用户过程中需要进行对齐，便于用户观看。

  1. void DisplayContact(contact* pc)//打印信息
  2. {
  3. 	assert(pc);
  4. 	printf("%-15s\t%-5s\t%-5s\t%-12s\t%-30s\n", "姓名", "年纪",
  5. 		"性别", "电话", "地址");//默认右对齐，修改为左对齐
  6. 	//中间也要留下足够的空间
  7. 	for (int i = 0; i < pc->sz; i++)
  8. 	{
  9. 		printf("%-15s\t%-5d\t%-5s\t%-12s\t%-30s\n", pc->data[i].name,
  10. 			pc->data[i].age,
  11. 			pc->data[i].sex,
  12. 			pc->data[i].tele,
  13. 			pc->data[i].addr);
  14. 	}
  15. }

5.3 添加联系人

用户选择1可以自由添加联系人，如果通讯录已满，则提醒用户通讯录已满，请先清理通讯录。

(1) 检查通讯录是否已满

如果通讯录满了返回0，未满则返回1。

  1. int CheckContact(contact*pc)//检查大小
  2. {
  3. 	assert(pc);
  4. 	if (pc->sz == 100)
  5. 	{
  6. 		return 0;
  7. 	}
  8. 	return 1;
  9. }

(2) 添加

当通讯录未满时，用户可以输入数据添加新用户。

  1. void AddContact(contact* pc)//增加联系人
  2. {
  3. 	assert(pc);
  4. 	int ret = CheckContact(pc);//检查是否满了
  5. 	if (ret == 0)
  6. 	{
  7. 		printf("通讯录已满，请先清理通讯录！！\n");
  8. 		return;
  9. 	}
  10. 	printf("请输入联系人的姓名：> ");
  11. 	scanf("%s", pc->data[pc->sz].name);
  12. 	printf("请输入联系人的年龄：> ");
  13. 	scanf("%d", &(pc->data[pc->sz].age));
  14. 	printf("请输入联系人的性别：> ");
  15. 	scanf("%s", pc->data[pc->sz].sex);
  16. 	printf("请输入联系人的电话：> ");
  17. 	scanf("%s", pc->data[pc->sz].tele);
  18. 	printf("请输入联系人的地址：> ");
  19. 	scanf("%s", pc->data[pc->sz].addr);
  20. 	printf("用户添加成功！\n");
  21. 	pc->sz++;
  22. }

5.4 删除联系人

用户可以选择2清理通讯录，删除指定联系人。

(1) 寻找下标

在删除指定练习人时我们需通过其姓名寻找该联系人的下标。找到返回其下标，否则返回-1、

  1. int FindName(contact* pc, char name[])
  2. {
  3. 	assert(pc&&name);
  4. 	for (int pos = 0; pos < pc->sz; pos++)
  5. 	{
  6. 		if (strcmp(pc->data[pos].name, name) == 0)
  7. 		{
  8. 			return pos;
  9. 		}
  10. 	}
  11. 	return -1;
  12. }

(2) 删除

通过寻找到的下标，我们可以利用后面的数据依次覆盖来达到删除的目的。

注意：我们不能覆盖最后一个数据否则就会发生数组越界，这时我们只需减去通讯录此时的大小就好了。

  1. void DeleteContact(contact* pc)//删除联系人
  2. {
  3. 	assert(pc);
  4.          assert(pc->sz >= 0);
  5. 	char name[MAX_NAME];
  6. 	printf("请输入需要删除人的姓名:> ");
  7. 	scanf("%s", name);
  8. 	int pos = FindName(pc, name);
  9. 	if (pos == -1)
  10. 	{
  11. 		printf("通讯录中并没有这个人!!\n");
  12. 		return;
  13. 	}
  14. 	for (int i = pos; i < pc->sz - 1; i++)
  15. 	{
  16. 		pc->data[i] = pc->data[i + 1];//覆盖
  17. 	}
  18.     	printf("删除成功\n")；
  19. 	pc->sz--;
  20. }

删除前：

删除后 :

5.5 查找联系人

通过选择3查找指定联系人，没有找到则提醒用户没有该用户，查找到就打印其信息。

  1. void SearchContact(contact* pc)//查找联系人
  2. {
  3. 	assert(pc);
  4. 	char name[MAX_NAME];
  5. 	printf("请输入需要查找人的姓名:> ");
  6. 	scanf("%s", name);
  7. 	int pos = FindName(pc, name);
  8. 	if (pos == -1)
  9. 	{
  10. 		printf("通讯录中并没有这个人!!\n");
  11. 		return;
  12. 	}
  13. 	printf("%-15s\t%-5s\t%-5s\t%-12s\t%-30s\n", "姓名", "年纪",
  14. 		"性别", "电话", "地址");
  15. 	printf("%-15s\t%-5d\t%-5s\t%-12s\t%-30s", pc->data[pos].name,
  16. 		pc->data[pos].age,
  17. 		pc->data[pos].sex,
  18. 		pc->data[pos].tele,
  19. 		pc->data[pos].addr);
  20. }

5.6 修改联系人

我们可以通过选择4修改指定联系人的信息。

  1. void ModifyContact(contact* pc)//修改联系人
  2. {
  3. 	assert(pc);
  4. 	char name[MAX_NAME];
  5. 	printf("请输入需要修改人的姓名:> ");
  6. 	scanf("%s", name);
  7. 	int pos = FindName(pc, name);
  8. 	if (pos == -1)
  9. 	{
  10. 		printf("通讯录中并没有这个人!!\n");
  11. 		return;
  12. 	}
  13. 	printf("请输入联系人的姓名：> ");
  14. 	scanf("%s", pc->data[pos].name);
  15. 	printf("请输入联系人的年龄：> ");
  16. 	scanf("%d", &(pc->data[pos].age));
  17. 	printf("请输入联系人的性别：> ");
  18. 	scanf("%s", pc->data[pos].sex);
  19. 	printf("请输入联系人的电话：> ");
  20. 	scanf("%s", pc->data[pos].tele);
  21. 	printf("请输入联系人的地址：> ");
  22. 	scanf("%s", pc->data[pos].addr);
  23. 	printf("修改成功\n");
  24. }

修改前：

修改后：

5.7 排序联系人

我们可以选择6对通讯录进行排序，可以按照姓名，年纪，性别，电话，地址排序。

  1. int cmp1(const void* p1, const void* p2)
  2. {
  3. 	return strcmp(((PeoInfo*)p1)->name, ((PeoInfo*)p2)->name);
  4. }
  5. int cmp2(const void* p1, const void* p2)
  6. {
  7. 	return ((PeoInfo*)p1)->age- ((PeoInfo*)p2)->age;
  8. }
  9. int cmp3(const void* p1, const void* p2)
  10. {
  11. 	return strcmp(((PeoInfo*)p1)->sex, ((PeoInfo*)p2)->sex);
  12. }
  13. int cmp4(const void* p1, const void* p2)
  14. {
  15. 	return strcmp(((PeoInfo*)p1)->tele, ((PeoInfo*)p2)->tele);
  16. }
  17. int cmp5(const void* p1, const void* p2)
  18. {
  19. 	return strcmp(((PeoInfo*)p1)->addr, ((PeoInfo*)p2)->addr);
  20. }
  21. void SortByName(contact* pc)
  22. {
  23. 	qsort(pc, pc->sz, sizeof(PeoInfo), cmp1);
  24. }
  25. void SortByAge(contact* pc)
  26. {
  27. 	qsort(pc, pc->sz, sizeof(PeoInfo), cmp2);
  28. }
  29. void SortBySex(contact* pc)
  30. {
  31. 	qsort(pc, pc->sz, sizeof(PeoInfo), cmp3);
  32. }
  33. void SortByTele(contact* pc)
  34. {
  35. 	qsort(pc, pc->sz, sizeof(PeoInfo), cmp4);
  36. }
  37. void SortByAddr(contact* pc)
  38. {
  39. 	qsort(pc, pc->sz, sizeof(PeoInfo), cmp4);
  40. }
  41. void SortContact(contact* pc)//排序联系人
  42. {
  43. 	assert(pc);
  44. 	printf("请选择如何排序：> ");
  45. 	char input[20];
  46. 	scanf("%s", input);
  47. 	if (strcmp(input, "姓名")==0)
  48. 	{
  49. 		SortByName(pc);//按姓名排序
  50. 	}
  51. 	else if (strcmp(input, "年龄") == 0)
  52. 	{
  53. 		SortByAge(pc);//按年龄排序
  54. 	}
  55. 	else if (strcmp(input, "性别") == 0)
  56. 	{
  57. 		SortBySex(pc);//按性别排序
  58. 	}
  59. 	else if (strcmp(input, "电话") == 0)
  60. 	{
  61. 		SortByTele(pc);//按电话排序
  62. 	}
  63. 	else if (strcmp(input, "地址") == 0)
  64. 	{
  65. 		SortByAddr(pc);//按地址排序
  66. 	}
  67. 	else
  68. 	{
  69. 		printf("输入非法，请重新输入\n");
  70. 	}
  71. }

6. 改进通讯录

6.1 动态内存开辟

上述通讯录有一个致命的缺点——通讯录大小固定，为了解决这个问题我可以使用我们前面学过的动态内存开辟。

(1) 新增变量

为了方便我们知道此时的容量大小，我们将在结构体中加入新的变量。

  1. typedef struct contact
  2. {
  3. 	PeoInfo *data;//动态开辟的数据
  4. 	int sz;//通讯录的大小
  5. 	int capacity;//通讯录的容量
  6. }contact;

(2) 初始化

  1. void InitContact(contact* pc)//初始化
  2. {
  3. 	assert(pc);
  4. 	pc->sz = 0;
  5. 	pc->data = (PeoInfo*)calloc(2, sizeof(PeoInfo));
  6. 	if (pc->data == NULL)
  7. 	{
  8. 		perror("InitContact:");
  9. 		return;
  10. 	}
  11. 	pc->capacity = 2;
  12. 	/*memset(pc->data, 0, sizeof(pc->data));*/
  13. }

(3) 增容

当通讯录用户数量满时增加内存空间。

  1. void CheckCapacity(contact* pc)//增容
  2. {
  3. 	if (pc->sz == pc->capacity)
  4. 	{
  5. 		PeoInfo* tmp = (PeoInfo*)realloc(pc->data, (pc->capacity + 2) * sizeof(PeoInfo));
  6. 		if (tmp != NULL)
  7. 		{
  8. 			pc->data = tmp;
  9. 		}
  10. 		else
  11. 		{
  12. 			perror("CheckCapacity:");
  13. 			return;
  14. 		}
  15. 		pc->capacity += 2;
  16. 		printf("增容成功\n");
  17. 	}
  18. }

6.2 文件保存

我们发现每当我们关闭程序时我们写入的数据会被清空，我们要想保存上次写入的数据就应该使用文件操作。

(1) 加载数据

每次初始化时就要将上次文件的数据导入进来。

  1. void LoadContact(contact* pc)//加载上次数据
  2. {
  3. 	PeoInfo tmp = { 0 };
  4. 	FILE* pf = fopen("contact.txt", "rb");
  5. 	if (pf == NULL)
  6. 	{
  7. 		return;
  8. 	}
  9. 	//读取文件，存放到通讯录
  10. 	while (fread(&tmp, sizeof(PeoInfo), 1, pf))
  11. 	//返回值为0就是遇见文件末尾
  12. 	{
  13. 		CheckCapacity(pc);
  14. 		pc->data[pc->sz] = tmp;
  15. 		pc->sz++;
  16. 	}
  18. 	fclose(pf);
  19. 	pf = NULL;
  20. }

(2) 保存数据

当程序正常结束时保存数据。

  1. void SaveContact(contact* pc)//保存数据
  2. {
  3. 	FILE* pfWrite = fopen("contact.txt", "wb");
  4. 	if (pfWrite == NULL)
  5. 	{
  6. 		perror("fopen:");
  7. 		return;
  8. 	}
  9. 	//写通讯录中数据到文件中
  10. 	int i = 0;
  11. 	for (i = 0; i < pc->sz; i++)
  12. 	{
  13. 		fwrite(&(pc->data[i]), sizeof(PeoInfo), 1, pfWrite);
  14. 	}
  15. 	fclose(pfWrite);
  16. 	pfWrite = NULL;
  17. 	printf("保存成功\n");
  19. }

7. 通讯录逻辑的搭建

  1. 用户通过数字选择功能。
  2. 每次选择完之后返回菜单。
  3. 选择退出之后保存数据，程序结束。
  1. enum Option
  2. 	//利用枚举增加代码的可读性
  3. {
  4. 	EXIT,//0
  5. 	ADD,
  6. 	DEL,
  7. 	SEARCH,
  8. 	MODIFY,
  9. 	DISPLAY,
  10. 	SORT
  11. };
  12. void test()
  13. {
  14. 	int input = 0;
  15. 	contact con;
  16. 	InitContact(&con);
  17. 	do
  18. 	{
  19. 		menu();
  20. 		printf("请输入你的选择:>");
  21. 		scanf("%d", &input);
  22. 		switch (input)
  23. 		{
  24. 		case ADD:
  25. 			AddContact(&con);
  26. 			break;
  27. 		case DEL:
  28. 			DeleteContact(&con);
  29. 			break;
  30. 		case SEARCH:
  31. 			SearchContact(&con);
  32. 			break;
  33. 		case MODIFY:
  34. 			ModifyContact(&con);
  35. 			break;
  36. 		case DISPLAY:
  37. 			DisplayContact(&con);
  38. 			break;
  39. 		case SORT:
  40. 			SortContact(&con);
  41. 			break;
  42. 		case EXIT:
  43. 			SaveContact(&con);//退出保存数据
  44. 		    DestroyContact(&con);
  45. 			break;
  46. 		default:
  47. 			printf("非法输入，请重新输入\n");
  48. 			break;
  49. 		}
  50. 	} while (input);
  51. }
  52. int main()
  53. {
  54. 	test();
  55. 	return 0;
  56. }

8. 完整代码

8.1 contact.h

  1. #include<stdio.h>
  2. #include<string.h>
  3. #include<stdlib.h>
  4. #include<assert.h>
  5. #define MAX_NAME 20//名字最大长度
  6. #define MAX_SEX 5//性别最大长度
  7. #define MAX_TELE 12//电话最大长度
  8. #define MAX_ADDR 30//地址最大长度
  9. typedef struct PeoInfo
  10. {
  11. 	char name[MAX_NAME];//名字
  12. 	int age;//年龄
  13. 	char sex[MAX_SEX];//性别
  14. 	char tele[MAX_TELE];//电话
  15. 	char addr[MAX_ADDR];//地址
  16. }PeoInfo;
  17. typedef struct contact
  18. {
  19. 	PeoInfo *data;//动态开辟的数据
  20. 	int sz;//通讯录的大小
  21. 	int capacity;//通讯录的容量
  22. }contact;
  23. void InitContact(contact* pc);//初始化
  24. void DisplayContact(contact* pc);//打印信息
  25. void AddContact(contact* pc);//增加联系人
  26. void DeleteContact(contact* pc);//删除联系人
  27. void SearchContact(contact* pc);//查找联系人
  28. void ModifyContact(contact* pc);//修改联系人
  29. void SortContact(contact* pc);//排序联系人
  30. void SaveContact(contact* pc);//保存数据
  31. void DestroyContact(contact* pc);//销毁内存

8.2 contact.c

  1. #include"contact.h"
  2. void CheckCapacity(contact* pc)//增容
  3. {
  4. 	if (pc->sz == pc->capacity)
  5. 	{
  6. 		PeoInfo* tmp = (PeoInfo*)realloc(pc->data, (pc->capacity + 2) * sizeof(PeoInfo));
  7. 		if (tmp != NULL)
  8. 		{
  9. 			pc->data = tmp;
  10. 		}
  11. 		else
  12. 		{
  13. 			perror("CheckCapacity:");
  14. 			return;
  15. 		}
  16. 		pc->capacity += 2;
  17. 		printf("增容成功\n");
  18. 	}
  19. }
  20. void LoadContact(contact* pc)//加载上次数据
  21. {
  22. 	PeoInfo tmp = { 0 };
  23. 	FILE* pf = fopen("contact.txt", "rb");
  24. 	if (pf == NULL)
  25. 	{
  26. 		return;
  27. 	}
  28. 	//读取文件，存放到通讯录
  29. 	while (fread(&tmp, sizeof(PeoInfo), 1, pf))
  30. 	//返回值为0就是遇见文件末尾
  31. 	{
  32. 		CheckCapacity(pc);
  33. 		pc->data[pc->sz] = tmp;
  34. 		pc->sz++;
  35. 	}
  37. 	fclose(pf);
  38. 	pf = NULL;
  39. }
  41. void InitContact(contact* pc)//初始化
  42. {
  43. 	assert(pc);
  44. 	pc->sz = 0;
  45. 	pc->data = (PeoInfo*)calloc(2, sizeof(PeoInfo));
  46. 	if (pc->data == NULL)
  47. 	{
  48. 		perror("InitContact:");
  49. 		return;
  50. 	}
  51. 	pc->capacity = 2;
  52. 	LoadContact(pc);
  53. 	/*memset(pc->data, 0, sizeof(pc->data));*/
  54. }
  55. void DisplayContact(contact* pc)//打印信息
  56. {
  57. 	assert(pc);
  58. 	printf("%-15s\t%-5s\t%-5s\t%-12s\t%-30s\n", "姓名", "年纪",
  59. 		"性别", "电话", "地址");//默认右对齐，修改为左对齐
  60. 	//中间也要留下足够的空间
  61. 	for (int i = 0; i < pc->sz; i++)
  62. 	{
  63. 		printf("%-15s\t%-5d\t%-5s\t%-12s\t%-30s\n", pc->data[i].name,
  64. 			pc->data[i].age,
  65. 			pc->data[i].sex,
  66. 			pc->data[i].tele,
  67. 			pc->data[i].addr);
  68. 	}
  69. }
  71. void AddContact(contact* pc)//增加联系人
  72. {
  73. 	assert(pc);
  74. 	CheckCapacity(pc);//检查是否满了
  75. 	printf("请输入联系人的姓名：> ");
  76. 	scanf("%s", pc->data[pc->sz].name);
  77. 	printf("请输入联系人的年龄：> ");
  78. 	scanf("%d", &(pc->data[pc->sz].age));
  79. 	printf("请输入联系人的性别：> ");
  80. 	scanf("%s", pc->data[pc->sz].sex);
  81. 	printf("请输入联系人的电话：> ");
  82. 	scanf("%s", pc->data[pc->sz].tele);
  83. 	printf("请输入联系人的地址：> ");
  84. 	scanf("%s", pc->data[pc->sz].addr);
  85. 	printf("用户添加成功！\n");
  86. 	pc->sz++;
  87. }
  88. int FindName(contact* pc, char name[])
  89. {
  90. 	assert(pc&&name);
  91. 	for (int pos = 0; pos < pc->sz; pos++)
  92. 	{
  93. 		if (strcmp(pc->data[pos].name, name) == 0)
  94. 		{
  95. 			return pos;
  96. 		}
  97. 	}
  98. 	return -1;
  99. }
  100. void DeleteContact(contact* pc)//删除联系人
  101. {
  102. 	assert(pc);
  103. 	assert(pc->sz >= 0);
  104. 	char name[MAX_NAME];
  105. 	printf("请输入需要删除人的姓名:> ");
  106. 	scanf("%s", name);
  107. 	int pos = FindName(pc, name);
  108. 	if (pos == -1)
  109. 	{
  110. 		printf("通讯录中并没有这个人!!\n");
  111. 		return;
  112. 	}
  113. 	for (int i = pos; i < pc->sz - 1; i++)
  114. 	{
  115. 		pc->data[i] = pc->data[i + 1];//覆盖
  116. 	}
  117. 	printf("删除成功\n");
  118. 	pc->sz--;
  119. }
  120. void SearchContact(contact* pc)//查找联系人
  121. {
  122. 	assert(pc);
  123. 	char name[MAX_NAME];
  124. 	printf("请输入需要查找人的姓名:> ");
  125. 	scanf("%s", name);
  126. 	int pos = FindName(pc, name);
  127. 	if (pos == -1)
  128. 	{
  129. 		printf("通讯录中并没有这个人!!\n");
  130. 		return;
  131. 	}
  132. 	printf("%-15s\t%-5s\t%-5s\t%-12s\t%-30s\n", "姓名", "年纪",
  133. 		"性别", "电话", "地址");
  134. 	printf("%-15s\t%-5d\t%-5s\t%-12s\t%-30s", pc->data[pos].name,
  135. 		pc->data[pos].age,
  136. 		pc->data[pos].sex,
  137. 		pc->data[pos].tele,
  138. 		pc->data[pos].addr);
  139. }
  140. void ModifyContact(contact* pc)//修改联系人
  141. {
  142. 	assert(pc);
  143. 	char name[MAX_NAME];
  144. 	printf("请输入需要修改人的姓名:> ");
  145. 	scanf("%s", name);
  146. 	int pos = FindName(pc, name);
  147. 	if (pos == -1)
  148. 	{
  149. 		printf("通讯录中并没有这个人!!\n");
  150. 		return;
  151. 	}
  152. 	printf("请输入联系人的姓名：> ");
  153. 	scanf("%s", pc->data[pos].name);
  154. 	printf("请输入联系人的年龄：> ");
  155. 	scanf("%d", &(pc->data[pos].age));
  156. 	printf("请输入联系人的性别：> ");
  157. 	scanf("%s", pc->data[pos].sex);
  158. 	printf("请输入联系人的电话：> ");
  159. 	scanf("%s", pc->data[pos].tele);
  160. 	printf("请输入联系人的地址：> ");
  161. 	scanf("%s", pc->data[pos].addr);
  162. 	printf("修改成功\n");
  163. }
  164. int cmp1(const void* p1, const void* p2)
  165. {
  166. 	return strcmp(((PeoInfo*)p1)->name, ((PeoInfo*)p2)->name);
  167. }
  168. int cmp2(const void* p1, const void* p2)
  169. {
  170. 	return ((PeoInfo*)p1)->age- ((PeoInfo*)p2)->age;
  171. }
  172. int cmp3(const void* p1, const void* p2)
  173. {
  174. 	return strcmp(((PeoInfo*)p1)->sex, ((PeoInfo*)p2)->sex);
  175. }
  176. int cmp4(const void* p1, const void* p2)
  177. {
  178. 	return strcmp(((PeoInfo*)p1)->tele, ((PeoInfo*)p2)->tele);
  179. }
  180. int cmp5(const void* p1, const void* p2)
  181. {
  182. 	return strcmp(((PeoInfo*)p1)->addr, ((PeoInfo*)p2)->addr);
  183. }
  184. void SortByName(contact* pc)
  185. {
  186. 	qsort(pc, pc->sz, sizeof(PeoInfo), cmp1);
  187. }
  188. void SortByAge(contact* pc)
  189. {
  190. 	qsort(pc, pc->sz, sizeof(PeoInfo), cmp2);
  191. }
  192. void SortBySex(contact* pc)
  193. {
  194. 	qsort(pc, pc->sz, sizeof(PeoInfo), cmp3);
  195. }
  196. void SortByTele(contact* pc)
  197. {
  198. 	qsort(pc, pc->sz, sizeof(PeoInfo), cmp4);
  199. }
  200. void SortByAddr(contact* pc)
  201. {
  202. 	qsort(pc, pc->sz, sizeof(PeoInfo), cmp4);
  203. }
  204. void SortContact(contact* pc)//排序联系人
  205. {
  206. 	assert(pc);
  207. 	printf("请选择如何排序：> ");
  208. 	char input[20] = { 0 };
  209. 	scanf("%s", input);
  210. 	if (strcmp(input, "姓名")==0)
  211. 	{
  212. 		SortByName(pc);//按姓名排序
  213. 	}
  214. 	else if (strcmp(input, "年龄") == 0)
  215. 	{
  216. 		SortByAge(pc);//按年龄排序
  217. 	}
  218. 	else if (strcmp(input, "性别") == 0)
  219. 	{
  220. 		SortBySex(pc);//按性别排序
  221. 	}
  222. 	else if (strcmp(input, "电话") == 0)
  223. 	{
  224. 		SortByTele(pc);//按电话排序
  225. 	}
  226. 	else if (strcmp(input, "地址") == 0)
  227. 	{
  228. 		SortByAddr(pc);//按地址排序
  229. 	}
  230. 	else
  231. 	{
  232. 		printf("输入非法，请重新输入\n");
  233. 	}
  234. }
  235. void DestroyContact(contact* pc)
  236. {
  237. 	free(pc->data);
  238. 	pc->data= NULL;
  239. 	pc->capacity = 0;
  240. 	pc->sz = 0;
  241. 	printf("销毁成功\n");
  242. }
  243. void SaveContact(contact* pc)//保存数据
  244. {
  245. 	FILE* pfWrite = fopen("contact.txt", "wb");
  246. 	if (pfWrite == NULL)
  247. 	{
  248. 		perror("fopen:");
  249. 		return;
  250. 	}
  251. 	//写通讯录中数据到文件中
  252. 	int i = 0;
  253. 	for (i = 0; i < pc->sz; i++)
  254. 	{
  255. 		fwrite(&(pc->data[i]), sizeof(PeoInfo), 1, pfWrite);
  256. 	}
  257. 	fclose(pfWrite);
  258. 	pfWrite = NULL;
  259. 	printf("保存成功\n");
  261. }

8.3 text.c

  1. #include"contact.h"
  3. enum Option
  4. 	//利用枚举增加代码的可读性
  5. {
  6. 	EXIT,//0
  7. 	ADD,
  8. 	DEL,
  9. 	SEARCH,
  10. 	MODIFY,
  11. 	DISPLAY,
  12. 	SORT
  13. };
  15. void menu()
  16. {
  17.     printf("***********************************\n");
  18.     printf("**    1.add          2.delete    **\n");
  19.     printf("**    3.search       4.modify    **\n");
  20.     printf("**    5.display      6.sort      **\n");
  21.     printf("**             0.exit            **\n");
  22.     printf("***********************************\n");
  23. }
  24. void test()
  25. {
  26. 	int input = 0;
  27. 	contact con;
  28. 	InitContact(&con);
  29. 	do
  30. 	{
  31. 		menu();
  32. 		printf("请输入你的选择:>");
  33. 		scanf("%d", &input);
  34. 		switch (input)
  35. 		{
  36. 		case ADD:
  37. 			AddContact(&con);
  38. 			break;
  39. 		case DEL:
  40. 			DeleteContact(&con);
  41. 			break;
  42. 		case SEARCH:
  43. 			SearchContact(&con);
  44. 			break;
  45. 		case MODIFY:
  46. 			ModifyContact(&con);
  47. 			break;
  48. 		case DISPLAY:
  49. 			DisplayContact(&con);
  50. 			break;
  51. 		case SORT:
  52. 			SortContact(&con);
  53. 			break;
  54. 		case EXIT:
  55. 			SaveContact(&con);//退出保存数据
  56. 		    DestroyContact(&con);
  57. 			break;
  58. 		default:
  59. 			printf("非法输入，请重新输入\n");
  60. 			break;
  61. 		}
  62. 	} while (input);
  63. }
  65. int main()
  66. {
  67. 	test();
  68. 	return 0;
  69. }

原文链接：https://www.cnblogs.com/bett/p/18018489

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C 语言热门文章

  • 图形学入门(1)——直线生成算法（DDA和Bresenham）
  • 用C语言制作一个最简单的飞机游戏！
  • MODBUS 超时时间计算
  • zabbix wait for 15s seconds 出现原因及调优建议
  • C/C++知识分享：assert()函数
  • 图形学入门(2)——圆弧生成算法（中点画圆法）
  • C 共享内存封装
  • C语言中break与continue的用法和区别详解
  • GStreamer基础教程09 - Appsrc及Appsink
  • 三元组矩阵行列式的计算（用递归）

    • C 语言推荐文章

  • C语言指针易混淆知识点总结
  • 进程间通信
  • 数组降维、函数栈帧、地址空间、可变参数原理剖析
  • 【Learning eBPF-3】一个 eBPF 程序的深入剖析
  • [apue] 进程控制那些事儿
  • 解密C语言选择结构：掌握条件语句与分支逻辑的利器
  • 精通C语言：打造高效便捷的通讯录管理系统
  • c语言实现内存池
  • [数据结构] 数组与特殊矩阵
  • 探索C语言结构体：编程中的利器与艺术

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号