devbox
人工智能uu
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言:基于单链表实现通讯录项目

作者：人工智能uu | 2024-08-14 20:14:00

赞

踩

C语言:基于单链表实现通讯录项目

前言

之前我们用顺序表实现了通讯录，这次我们使用单链表实现。我们定义五个文件，

SingleLinkedList.h   SingleLinkedList.c  Contact.h Contact.c test.c

SingleLinkedList.h 是包含了单链表的结构，及各类库文件声明，各个单链表接口声明

SingleLinkedList.c 用于实现各类单链表接口

Contact.h是包含了通讯录的结构，各个通讯录接口声明

Contact.c用于实现通讯录接口

test.c用作测试和实现通讯录的菜单，控制增删查改的选项

SingleLinkedList.h文件

在我的上一篇博客中已经实现过单链表了，所以这里不作实现讲解

  1. SingleLinkedList.h文件：
  2. #define _CRT_SECURE_NO_WARNINGS	1
  3. #include<stdio.h>
  4. #include<assert.h>
  5. #include<stdlib.h>
  6. #include"Contact.h"
  7. #include"string.h"
  8. #include<windows.h>
  9. typedef PeoInfo SLLDataType;
  10. typedef struct _SingleLinkedListNode
  11. {
  12. 	SLLDataType x;
  13. 	struct _SingleLinkedListNode* next;
  14. }SLLNode;
  15. //获取一个新节点
  16. SLLNode* BuynewNode(SLLDataType x);
  17. //尾插
  18. void SLLPushBack(SLLNode** pphead, SLLDataType x);
  19. //头插
  20. void SLLPushFront(SLLNode** pphead, SLLDataType x);
  21. //尾删
  22. void SLLPopBack(SLLNode** pphead);
  23. //头删
  24. void SLLPopFront(SLLNode** pphead);
  25. //查找
  26. SLLNode* SLLFind(SLLNode* phead, SLLDataType x);
  27. //在指定位置之前插入数据
  28. void SLLInsert(SLLNode** pphead, SLLNode* pos, SLLDataType x);
  29. //在指定位置之后插入数据
  30. void SLLInsertAfter(SLLNode* pos, SLLDataType x);
  31. //删除指定位置之后的数据
  32. void SLLEraseAfter(SLLNode* pos);
  33. //删除指定位置的数据
  34. void SLLErase(SLLNode** pphead, SLLNode* pos);
  35. //打印链表
  36. void SLLPrint(SLLNode* phead);
  37. //销毁链表
  38. void SLLDestroy(SLLNode** pphead);

SingleLinkedList.c文件

  1. ​
  2. SingleLinkedList.c文件：
  3. #include"SingleLinkedList.h"
  4. //打印链表
  5. //void SLLPrint(SLLNode* phead)
  6. //{
  7. //	SLLNode* pcur = phead;
  8. //	while (pcur)
  9. //	{
  10. //		printf("%d->", pcur->x);
  11. //		pcur = pcur->next;
  12. //	}
  13. //	printf("NULL\n");
  14. //}
  15. //获取一个新节点
  16. SLLNode* BuynewNode(SLLDataType x)
  17. {
  18. 	SLLNode* newnode = (SLLNode*)malloc(sizeof(SLLNode));
  19. 	if (newnode == NULL)
  20. 	{
  21. 		perror("malloc fail!");
  22. 		exit(1);
  23. 	}
  24. 	newnode->x = x;
  25. 	newnode->next = NULL;
  26. 	return newnode;
  27. }
  28. //尾插
  29. void SLLPushBack(SLLNode** pphead, SLLDataType x)
  30. {
  31. 	assert(pphead);
  32. 	SLLNode* newnode = BuynewNode(x);
  33. 	if (*pphead == NULL)
  34. 	{
  35.  
  36. 		*pphead = newnode;
  37. 	}
  38. 	else
  39. 	{
  40. 		SLLNode* ptail = *pphead;
  41. 		while (ptail->next)
  42. 		{
  43. 			ptail = ptail->next;
  44. 		}
  45. 		ptail->next = newnode;
  46. 	}
  47.  
  48. }
  49. //头插
  50. void SLLPushFront(SLLNode** pphead, SLLDataType x)
  51. {
  52. 	assert(pphead);
  53. 	SLLNode* newnode = BuynewNode(x);
  54. 	newnode->next = *pphead;
  55. 	*pphead = newnode;
  56. }
  57. //尾删
  58. void SLLPopBack(SLLNode** pphead)
  59. {
  60. 	assert(pphead && *pphead);
  61. 	if ((*pphead)->next == NULL)
  62. 	{
  63. 		free(*pphead);
  64. 		*pphead = NULL;
  65. 	}
  66. 	else
  67. 	{
  68. 		SLLNode* prev = *pphead;
  69. 		SLLNode* ptail = *pphead;
  70. 		while (ptail->next)
  71. 		{
  72. 			prev = ptail;
  73. 			ptail = ptail->next;
  74. 		}
  75. 		prev->next = NULL;
  76. 		free(ptail);
  77. 		ptail = NULL;
  78. 	}
  79.  
  80. }
  81. //头删
  82. void SLLPopFront(SLLNode** pphead)
  83. {
  84. 	assert(pphead && *pphead);
  85. 	SLLNode* next = (*pphead)->next;
  86. 	free(*pphead);
  87. 	*pphead = next;
  88. }
  89. //查找
  90. //SLLNode* SLLFind(SLLNode* phead, SLLDataType x)
  91. //{
  92. //	assert(phead);
  93. //	SLLNode* pcur = phead;
  94. //	while (pcur)
  95. //	{
  96. //		if (pcur->x == x)
  97. //		{
  98. //			return pcur;
  99. //		}
  100. //		pcur = pcur->next;
  101. //	}
  102. //	return NULL;
  103. //}
  104. //在指定位置之前插入数据
  105. void SLLInsert(SLLNode** pphead, SLLNode* pos, SLLDataType x)
  106. {
  107. 	assert(pphead && *pphead);
  108. 	assert(pos);
  109. 	SLLNode* newnode = BuynewNode(x);
  110. 	if (*pphead == pos)
  111. 	{
  112. 		SLLPushFront(pphead, x);
  113. 	}
  114. 	else
  115. 	{
  116. 		SLLNode* prev = *pphead;
  117. 		while (prev->next != pos)
  118. 		{
  119. 			prev = prev->next;
  120. 		}
  121. 		newnode->next = pos;
  122. 		prev->next = newnode;
  123. 	}
  124.  
  125. }
  126. //在指定位置之后插入数据
  127. void SLLInsertAfter(SLLNode* pos, SLLDataType x)
  128. {
  129. 	assert(pos);
  130. 	SLLNode* newnode = BuynewNode(x);
  131. 	SLLNode* next = pos->next;
  132.  
  133. 	newnode->next = next;
  134. 	pos->next = newnode;
  135. }
  136. //删除指定位置之后的数据
  137. void SLLEraseAfter(SLLNode* pos)
  138. {
  139. 	assert(pos && pos->next);
  140. 	SLLNode* del = pos->next;
  141. 	pos->next = del->next;
  142. 	free(del);
  143. 	del = NULL;
  144. }
  145. //删除指定位置的数据
  146. void SLLErase(SLLNode** pphead, SLLNode* pos)
  147. {
  148. 	assert(pphead && *pphead);
  149. 	assert(pos);
  150. 	if (*pphead == pos)
  151. 	{
  152. 		SLLPopFront(pphead);
  153. 	}
  154. 	else
  155. 	{
  156. 		SLLNode* del = pos;
  157. 		SLLNode* prev = *pphead;
  158. 		while (prev->next != pos)
  159. 		{
  160. 			prev = prev->next;
  161. 		}
  162. 		prev->next = del->next;
  163. 		free(pos);
  164. 		pos = NULL;
  165. 	}
  166.  
  167. }
  168. //销毁链表
  169. void SLLDestroy(SLLNode** pphead)
  170. {
  171. 	assert(pphead && *pphead);
  172. 	while (*pphead)
  173. 	{
  174. 		SLLNode* next = (*pphead)->next;
  175. 		free(*pphead);
  176. 		*pphead = next;
  177. 	}
  178.  
  179. }
  180.  
  181. ​

这里我们把影响Contact.c文件的部分接口注释掉。

Contact.h文件

  1. #pragma once
  2. #define NAME_MAX 100
  3. #define GENDER_MAX 10
  4. #define TEL_MAX 19
  5. #define ADDR_MAX 100
  6. enum
  7. {
  8.     EXIT ,
  9.     ADD,
  10.     ERASE,
  11.     FIND,
  12.     MODIFY,
  13.     SHOW
  14. };
  15. //前置声明
  16. typedef struct _SingleLinkedListNode Contact;
  17. //用户数据
  18. typedef struct PersonInfo
  19. {
  20.     char name[NAME_MAX];
  21.     char gender[GENDER_MAX];
  22.     int age;
  23.     char tel[TEL_MAX];
  24.     char addr[ADDR_MAX];
  25. }PeoInfo;
  26.  
  27. //初始化通讯录
  28. void InitContact(Contact** con);
  29. //添加通讯录数据
  30. void AddContact(Contact** con);
  31. //删除通讯录数据
  32. void DelContact(Contact** con);
  33. //展示通讯录数据
  34. void ShowContact(Contact* con);
  35. //查找通讯录数据
  36. void FindContact(Contact* con);
  37. //修改通讯录数据
  38. void ModifyContact(Contact** con);
  39. //销毁通讯录数据
  40. void DestroyContact(Contact** con);

Contact.c文件各类接口实现

初始化通讯录

  1. 头文件声明：
  2. void InitContact(Contact** con);
  1. 实现：
  2. //初始化通讯录
  3. void InitContact(Contact** con)
  4. {
  5. 	assert(con);
  6. 	(*con) = NULL;
  7. 	PeoInfo pi;
  8. 	strcpy(pi.name,"NULL");
  9. 	strcpy(pi.gender, "NULL");
  10. 	pi.age = 0;
  11. 	strcpy(pi.tel, "NULL");
  12. 	strcpy(pi.addr, "NULL");
  13.    SLLPushBack(con, pi);
  14. 	
  15. }

字符数组用strcpy拷贝值，整型数据直接赋值

初始化：将数据都置为空，这样做的目的是为了再后期在通讯录没有数据的时候其他功能不会被断言报错，看一下后期实现的结果：


添加通讯录数据

  1. 头文件声明：
  2. void AddContact(Contact** con);
  1. 实现：
  2. //添加通讯录数据
  3. void AddContact(Contact** con)
  4. {
  5. 	assert(con);
  6. 	PeoInfo pi;
  7. 	printf("请输入要添加的联系人姓名:>\n");
  8. 	scanf("%s",pi.name);
  9. 	printf("请输入要添加的联系人性别:>\n");
  10. 	scanf("%s", pi.gender);
  11. 	printf("请输入要添加的联系人年龄:>\n");
  12. 	scanf("%d", &pi.age);
  13. 	printf("请输入要添加的联系人电话:>\n");
  14. 	scanf("%s", pi.tel);
  15. 	printf("请输入要添加的联系人家庭住址:>\n");
  16. 	scanf("%s", pi.addr);
  17.      free(*con);
  18. 	*con = NULL;
  19. 	SLLPushBack(con,pi);
  20.  
  21. 	printf("添加联系人信息成功!\n");
  22. }

我们先定义一个联系人类的自定义结构体pi，将pi的各个数据填充好后，调用之前写好的尾插方法，尾插到通讯录（链表）中在尾插前，可以看到我先写了个*con=NULL，因为我之前初始化的时候，将字符串"NULL",先插入了通讯录中，只是为了后期不影响其他功能，而不能让真正意义上的通讯录打印出来的第一条数据是“NULL”，所以这里将链表先释放再置为NULL，然后再填充数据

后期的结果我们来看看：

没有数据前的通讯录：

添加数据后的通讯录：


删除通讯录数据

  1. 头文件声明：
  2. void DelContact(Contact** con);
  1. 实现：
  2. //删除通讯录数据
  3. void DelContact(Contact** con)
  4. {
  5. 	assert(con && *con);
  6. 	char name[NAME_MAX] = { 0 };
  7. 	Contact* pcur = *con;
  8. 	printf("请输入要删除的联系人姓名:>\n");
  9. 	scanf("%s", name);
  10. 	int flag = 0;
  11. 	while (pcur)
  12. 	{
  13. 		if (strcmp(name, pcur->x.name) == 0)
  14. 		{
  15. 			flag = 1;
  16. 			SLLErase(con, pcur);
  17. 			break;
  18. 		}
  19. 		else
  20. 		{
  21. 			pcur = pcur->next;
  22. 		}	
  23. 	}
  24. 	if (flag == 1)
  25. 	{
  26. 		printf("删除联系人成功!\n");
  27. 	}
  28. 	else
  29. 	{
  30. 		printf("要删除的联系人不存在\n");
  31. 	}
  32. 	
  33. }

首先，我们定义一个字符数组，一个临时指针pcur指向*con，定义一个标志flag，当flag为1时，代表有这个数据，flag=0时代表，通讯录没有这个数据。然后输入一个姓名与我们通讯录中存在的姓名比较，如果二者相等就将flag置为1否则就不改动

SLLErase(con, pcur);

这个接口是我们之前写好的，用来删除pos位置的节点，如果找到了，那么就将这个pos位置的节点删除，那么从而实现通讯录的数据删除

来看看后期实现的效果：

删除前：

删除后：


展示通讯录数据

  1. 头文件声明：
  2. void ShowContact(Contact* con);
  1. 实现：
  2. //展示通讯录数据
  3. void ShowContact(Contact* con)
  4. {
  5. 	Contact* tmp = con;
  6. 	printf("        联系人信息\n");
  7. 	int i = 1;
  8. 	printf("序号 ""姓名 " "性别 " "年龄 " "电话 " "家庭住址\n");
  9. 	while (tmp)
  10. 	{
  11. 		
  12. 		printf(" %d %s  %s  %d  %s  %s ",i++, tmp->x.name,
  13. 			tmp->x.gender,
  14. 			tmp->x.age, tmp->x.tel,
  15. 			tmp->x.addr);
  16. 		tmp = tmp->next;
  17. 		printf("\n");
  18. 	}
  19. 	
  20. }

实现效果：



查找通讯录数据

  1. 头文件声明：
  2. void FindContact(Contact* con);
  1. 实现：
  2. //查找通讯录数据
  3. void FindContact(Contact* con)
  4. {
  5. 	assert(con);
  6. 	char name[NAME_MAX] = { 0 };
  7. 	Contact* pcur = con;
  8. 	printf("请输入要查找的联系人姓名:>\n");
  9. 	scanf("%s", name);
  10. 	int flag = 0;
  11. 	while (pcur)
  12. 	{
  13. 		if (strcmp(name, pcur->x.name) == 0)
  14. 		{
  15. 			flag = 1;
  16. 			break;
  17. 		}
  18. 		else
  19. 		{
  20. 			pcur = pcur->next;
  21. 		}
  22. 	}
  23. 	if (flag == 1)
  24. 	{
  25. 		printf("%s的信息如下:>\n", pcur->x.name);
  26. 		printf( "姓名 " "性别 " "年龄 " "电话 " "家庭住址\n");
  27. 		printf(" %s  %s  %d  %s  %s ", pcur->x.name,
  28. 			pcur->x.gender,
  29. 			pcur->x.age, pcur->x.tel,
  30. 			pcur->x.addr);
  31. 		printf("\n");
  32. 	}
  33. 	else
  34. 	{
  35. 		printf("%s不在通讯录中\n",name);
  36. 	}
  37. }

类似于删除操作，我们要遍历通讯录，然后找到那个对应的pcur指针，然后将pcur指针指向的结构体数据打印出来

实现效果：


 

修改通讯录数据

  1. 头文件声明：
  2. void ModifyContact(Contact** con);
  1. 实现：
  2. //修改通讯录数据
  3. void ModifyContact(Contact** con)
  4. {
  5. 	assert(con&&*con);
  6. 	printf("请输入要修改的联系人姓名:\n");
  7. 	char name[NAME_MAX] = { 0 };
  8.  
  9. 	Contact* pcur = *con;
  10. 	scanf("%s", name);
  11. 	int flag = 0;
  12. 	while (pcur)
  13. 	{
  14. 		if (strcmp(name, pcur->x.name) == 0)
  15. 		{
  16. 			flag = 1;
  17. 			break;
  18. 		}
  19. 		else
  20. 		{
  21. 			pcur = pcur->next;
  22. 		}
  23. 	}
  24. 	if (flag == 1)
  25. 	{
  26. 		printf("请输入要修改的联系人姓名:>\n");
  27. 		scanf("%s", pcur->x.name);
  28. 		printf("请输入要修改的联系人性别:>\n");
  29. 		scanf("%s", pcur->x.gender);
  30. 		printf("请输入要修改的联系人年龄:>\n");
  31. 		scanf("%d", &pcur->x.age);
  32. 		printf("请输入要修改的联系人电话:>\n");
  33. 		scanf("%s", pcur->x.tel);
  34. 		printf("请输入要修改的联系人家庭住址:>\n");
  35. 		scanf("%s", pcur->x.addr);
  36. 		printf("修改成功!\n");
  37. 		printf("\n");
  38. 	}
  39. 	else
  40. 	{
  41. 		printf("%s不在通讯录中\n", name);
  42. 	}
  43. }

实现效果：



销毁通讯录数据

  1. 头文件声明：
  2. void DestroyContact(Contact** con);
  1. 实现：
  2. //销毁通讯录数据
  3. void DestroyContact(Contact** con)
  4. {
  5. 	SLLDestroy(con);
  6. }

通讯录的销毁就是链表的销毁，所以我们直接调用我们之前写好的销毁链表接口。

补充说明

  1. char name[NAME_MAX] = { 0 };
  2.  
  3. 	Contact* pcur = *con;
  4. 	scanf("%s", name);
  5. 	int flag = 0;
  6. 	while (pcur)
  7. 	{
  8. 		if (strcmp(name, pcur->x.name) == 0)
  9. 		{
  10. 			flag = 1;
  11. 			break;
  12. 		}
  13. 		else
  14. 		{
  15. 			pcur = pcur->next;
  16. 		}
  17. 	}

这块代码出现了很多次，其实可以封装成一个函数，多个函数进行调用，代码就不会那么冗余

完整Contact.c文件源码

  1. #include"SingleLinkedList.h"
  2. //初始化通讯录
  3. void InitContact(Contact** con)
  4. {
  5. 	assert(con);
  6. 	(*con) = NULL;
  7. 	PeoInfo pi;
  8. 	strcpy(pi.name,"NULL");
  9. 	strcpy(pi.gender, "NULL");
  10. 	pi.age = 0;
  11. 	strcpy(pi.tel, "NULL");
  12. 	strcpy(pi.addr, "NULL");
  13.    SLLPushBack(con, pi);
  14. 	
  15. }
  16. //添加通讯录数据
  17. void AddContact(Contact** con)
  18. {
  19. 	assert(con);
  20. 	PeoInfo pi;
  21. 	printf("请输入要添加的联系人姓名:>\n");
  22. 	scanf("%s",pi.name);
  23. 	printf("请输入要添加的联系人性别:>\n");
  24. 	scanf("%s", pi.gender);
  25. 	printf("请输入要添加的联系人年龄:>\n");
  26. 	scanf("%d", &pi.age);
  27. 	printf("请输入要添加的联系人电话:>\n");
  28. 	scanf("%s", pi.tel);
  29. 	printf("请输入要添加的联系人家庭住址:>\n");
  30. 	scanf("%s", pi.addr);
  31. 	free(*con);
  32. 	*con = NULL;
  33. 	SLLPushBack(con,pi);
  34.  
  35. 	printf("添加联系人信息成功!\n");
  36. }
  37. //展示通讯录数据
  38. void ShowContact(Contact* con)
  39. {
  40. 	Contact* tmp = con;
  41. 	printf("        联系人信息\n");
  42. 	int i = 1;
  43. 	printf("序号 ""姓名 " "性别 " "年龄 " "电话 " "家庭住址\n");
  44. 	while (tmp)
  45. 	{
  46. 		
  47. 		printf(" %d %s  %s  %d  %s  %s ",i++, tmp->x.name,
  48. 			tmp->x.gender,
  49. 			tmp->x.age, tmp->x.tel,
  50. 			tmp->x.addr);
  51. 		tmp = tmp->next;
  52. 		printf("\n");
  53. 	}
  54. 	
  55. }
  56. //删除通讯录数据
  57. void DelContact(Contact** con)
  58. {
  59. 	assert(con && *con);
  60. 	char name[NAME_MAX] = { 0 };
  61. 	Contact* pcur = *con;
  62. 	printf("请输入要删除的联系人姓名:>\n");
  63. 	scanf("%s", name);
  64. 	int flag = 0;
  65. 	while (pcur)
  66. 	{
  67. 		if (strcmp(name, pcur->x.name) == 0)
  68. 		{
  69. 			flag = 1;
  70. 			SLLErase(con, pcur);
  71. 			break;
  72. 		}
  73. 		else
  74. 		{
  75. 			pcur = pcur->next;
  76. 		}	
  77. 	}
  78. 	if (flag == 1)
  79. 	{
  80. 		printf("删除联系人成功!\n");
  81. 	}
  82. 	else
  83. 	{
  84. 		printf("要删除的联系人不存在\n");
  85. 	}
  86. 	
  87. }
  88. //查找通讯录数据
  89. void FindContact(Contact* con)
  90. {
  91. 	assert(con);
  92. 	char name[NAME_MAX] = { 0 };
  93. 	Contact* pcur = con;
  94. 	printf("请输入要查找的联系人姓名:>\n");
  95. 	scanf("%s", name);
  96. 	int flag = 0;
  97. 	while (pcur)
  98. 	{
  99. 		if (strcmp(name, pcur->x.name) == 0)
  100. 		{
  101. 			flag = 1;
  102. 			break;
  103. 		}
  104. 		else
  105. 		{
  106. 			pcur = pcur->next;
  107. 		}
  108. 	}
  109. 	if (flag == 1)
  110. 	{
  111. 		printf("%s的信息如下:>\n", pcur->x.name);
  112. 		printf( "姓名 " "性别 " "年龄 " "电话 " "家庭住址\n");
  113. 		printf(" %s  %s  %d  %s  %s ", pcur->x.name,
  114. 			pcur->x.gender,
  115. 			pcur->x.age, pcur->x.tel,
  116. 			pcur->x.addr);
  117. 		printf("\n");
  118. 	}
  119. 	else
  120. 	{
  121. 		printf("%s不在通讯录中\n",name);
  122. 	}
  123. }
  124. //修改通讯录数据
  125. void ModifyContact(Contact** con)
  126. {
  127. 	assert(con&&*con);
  128. 	printf("请输入要修改的联系人姓名:\n");
  129. 	char name[NAME_MAX] = { 0 };
  130.  
  131. 	Contact* pcur = *con;
  132. 	scanf("%s", name);
  133. 	int flag = 0;
  134. 	while (pcur)
  135. 	{
  136. 		if (strcmp(name, pcur->x.name) == 0)
  137. 		{
  138. 			flag = 1;
  139. 			break;
  140. 		}
  141. 		else
  142. 		{
  143. 			pcur = pcur->next;
  144. 		}
  145. 	}
  146. 	if (flag == 1)
  147. 	{
  148. 		printf("请输入要修改的联系人姓名:>\n");
  149. 		scanf("%s", pcur->x.name);
  150. 		printf("请输入要修改的联系人性别:>\n");
  151. 		scanf("%s", pcur->x.gender);
  152. 		printf("请输入要修改的联系人年龄:>\n");
  153. 		scanf("%d", &pcur->x.age);
  154. 		printf("请输入要修改的联系人电话:>\n");
  155. 		scanf("%s", pcur->x.tel);
  156. 		printf("请输入要修改的联系人家庭住址:>\n");
  157. 		scanf("%s", pcur->x.addr);
  158. 		printf("修改成功!\n");
  159. 		printf("\n");
  160. 	}
  161. 	else
  162. 	{
  163. 		printf("%s不在通讯录中\n", name);
  164. 	}
  165. }
  166. //销毁通讯录数据
  167. void DestroyContact(Contact** con)
  168. {
  169. 	SLLDestroy(con);
  170. }

test.c文件逻辑实现

  1. #include"SingleLinkedList.h"
  2. void test01()
  3. {
  4. 	Contact* con;
  5. 	InitContact(&con);
  6. 	AddContact(&con);
  7. 	AddContact(&con);
  8. 	//DelContact(&con);
  9. 	//FindContact(con);
  10. 	//ModifyContact(&con);
  11. 	ShowContact(con);
  12.     DestroyContact(&con);
  13. 	ShowContact(con);
  14. }
  15.  
  16.  
  17. int main()
  18. {
  19. 	test01();
  20.  
  21. 	return 0;
  22. }

定义一个test01函数将各类通讯录接口测试一下，没有问题，我们开始写通讯录调用逻辑及菜单打印的实现：

menu()菜单函数实现

  1. void menu()
  2. {
  3. 	printf("          ---------我的通讯录---------\n");
  4. 	printf("          |1.添加联系人||2.删除联系人|\n");
  5. 	printf("          ----------------------------\n");
  6. 	printf("          |3.查找联系人||4.修改联系人|\n");
  7. 	printf("          ----------------------------\n");
  8. 	printf("          |5.展示联系人||0.退出      |\n");
  9. 	printf("          ----------------------------\n");
  10. }

实现效果：

main()主函数逻辑实现

  1. int main()
  2. {
  3. 	int input = 0;
  4. 	Contact* con;
  5. 	InitContact(&con);
  6. 	do
  7. 	{
  8. 		menu();
  9. 		printf("请选择:>\n");
  10. 		scanf("%d", &input);
  11. 		system("cls");
  12. 		switch (input)
  13. 		{
  14. 		case EXIT:
  15. 			exit(0);
  16. 		case ADD:
  17. 			AddContact(&con);
  18. 			system("pause");
  19. 			system("cls");
  20. 			break;
  21. 		case ERASE:
  22. 			DelContact(&con);
  23. 			system("pause");
  24. 			system("cls");
  25. 			break;
  26. 		case FIND:
  27. 			FindContact(con);
  28. 			system("pause");
  29. 			system("cls");
  30. 			break;
  31. 		case MODIFY:
  32. 			ModifyContact(&con);
  33. 			system("pause");
  34. 			system("cls");
  35. 			break;
  36. 		case SHOW:
  37. 			ShowContact(con);
  38. 			system("pause");
  39. 			system("cls");
  40. 			break;
  41. 		}
  42. 	} while (input);
  43. 	DestroyContact(&con);
  44. 	return 0;
  45. }

添加system("pause");和system("cls");程序暂停和程序清理语句，让各类接口衔接连贯，最后循环结束，将通讯录销毁，程序return 0正常退出。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/980612
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号