通讯录的实现详细——C语言进阶

       

目录

一、创建联系人信息（结构体）

二、创建通讯录（结构体）

三、define定义常量

四、打印通讯录菜单

五、枚举菜单选项

六、初始化通讯录

七、实现通讯的的功能

7.1 增加加联系人

7.2 显示所有联系人的信息

7.3 单独查找人的函数

7.4 删除指定联系人

7.5 查找指定联系人

7.6 修改指定联系人

7.7 按照名字顺序进行排序

7.8  清空所有联系人

八、通讯录优化——静态->动态

8.1 通讯录结构体优化

8.2 初始化函数的优化

8.3增加联系人的优化

8.4 释放通讯录的空间

九、完整代码 

test.c

contact.h

contact.c

---

实现一个通讯录，这里我们先来简单构思一下，通讯录中保存人的信息，分别有姓名，年龄，性别，电话，住址，假设我们通讯录中可以存放1000个人的信息。同时我们通讯录还要具备一些功能。包括;

①  增加联系人

②  删除指定联系人

③  修改指定联系人

④  查找指定联系人

⑤  显示所有联系人的信息

⑥  按照名字顺序进行排序

⑦  清空所有联系人

在写完之后，我们紧接着可以对通讯录进行优化，将静态通讯录改为动态通讯录。

一起跟着博主的思路来完成通讯录的实现吧！

        首先我们需要三个文件，分别是test.c——测试通讯录，contact.h——函数和类型的声明，contact.c——函数的实现，其次我们需要创建保存人信息的结构体。接下来我们开始慢代码实现吧！

一、创建联系人信息（结构体）

        为了保存联系人的各个信息，我们创建了一个结构体，放在头文件中，同时为了方便使用，对结构体重命名。

1.  
   typedef struct PeoInfo
2.  
   {
3.  
   char name[20];
4.  
   int age;
5.  
   char sex[5];
6.  
   char tele[12];
7.  
   char addr[30];
8.  
   }PeoInfo;

二、创建通讯录（结构体）

为了方便记录通讯录中现在的人数，创建一个结构体将联系人结构体和人数封装在一起。

1.  
   //通讯录
2.  
   typedef struct Contact
3.  
   {
4.  
   PeoInfo data[100];
5.  
   int sz;
6.  
   }Contact;

三、define定义常量

写到这里，我们发现如果以后想要更改通讯录的人数，或者名字的宽度，以及地址的宽度这些变量，要到代码中修改，很麻烦，我们可以通过define定义常量，这样使用或者更改的时候就会很方便，达到我们想要的效果。

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

四、打印通讯录菜单

因为每次使用至少使用一次，所以我们采用do—while循环来设计测试通讯录。

1.  
   void menu()
2.  
   {
3.  
   printf("*******************************\n");
4.  
   printf("********1.add 2.del*******\n");
5.  
   printf("********3.search 4.modify****\n");
6.  
   printf("********5.show 6.sort******\n");
7.  
   printf("********* 7.clear***********\n");
8.  
   printf("********* 0.exit ***********\n");
9.  
   printf("*******************************\n");
10.  
    }
11.  
    void test()
12.  
    {
13.  
    int input = 0;
14.  
    do
15.  
    {
16.  
    menu();
17.  
    printf("请选择:> ");
18.  
    scanf("%d", &input);
19.  
    } while(input);
20.  
    }

五、枚举菜单选项

为了代码美观，以及更方便的去识别代码的意思，我们可以采用自定义枚举的方式来实现功能选择。具体代码如下

1.  
   enum Option
2.  
   {
3.  
   Exit,//0 ——退出
4.  
   Add,//1 ——增加联系人
5.  
   Del,//2 ——删除指定联系人
6.  
   Search,//3 ——查找指定联系人信息
7.  
   Modify,//4 ——修改指定联系人信息
8.  
   Show,//5 ——显示通讯录中所有联系人
9.  
   Sort,//6 ——排序联系人
10.  
    Clear//7 ——清空所有联系人
11.  
     
12.  
    };

 这样就容易理解许多，效果如下所示：

1.  
   void test()
2.  
   {
3.  
   int input = 0;
4.  
   //定义通讯录
5.  
   Contact con;
6.  
   InitContact(&con);
7.  
   do
8.  
   {
9.  
   menu();//打印菜单
10.  
    printf("请选择：");
11.  
    scanf("%d", &input);
12.  
    switch (input)
13.  
    {
14.  
    case Add:
15.  
    AddContact(&con);
16.  
    break;
17.  
    case Del:
18.  
    DelContact(&con);
19.  
    break;
20.  
    case Search:
21.  
    SearchContact(&con);
22.  
    break;
23.  
    case Modify:
24.  
    ModifyContact(&con);
25.  
    break;
26.  
    case Show:
27.  
    ShowContact(&con);
28.  
    break;
29.  
    case Sort:
30.  
    SortContact(&con);
31.  
    break;
32.  
    case Clear:
33.  
    ClearContact(&con);
34.  
    break;
35.  
    case Exit:
36.  
    printf("退出通讯录\n");
37.  
    break;
38.  
    default:
39.  
    printf("选择错误，请重新选择\n");
40.  
    break;
41.  
    }
42.  
    } while (input);
43.  
    }

六、初始化通讯录

当我们创建完通讯录之后，为了更好的实现后面的功能，最好初始化一下通讯录。

注意：在contact.h中声明，在contact.c中实现。

        这里博主使用memset来讲通讯录中的信息全部初始化为0，如果不想使用memset，也可以采用循环的形式来初始化。具体代码如下：

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

七、实现通讯的的功能

注意：①以下函数的实行都是在contact.h中声明类型，然后在contact.v中实现

           ②在进入函数时，需要assert进行断言，防止传入空指针

           ③如果要进行的操作不需要更改通讯录的内容(例如：显示所有联系人）时，要用const修饰以下，保护通讯录内容。

7.1 增加加联系人

增加联系人我们首先需要判断通讯录里面的人数是否满了。没满才能继续进行操作

1.  
   //增加联系人
2.  
   void AddContact(Contact* pc)
3.  
   {
4.  
   assert(pc);//断言，防止pc是空指针
5.  
   //判断通讯录是否满了
6.  
   if (pc->sz == MAX)
7.  
   {
8.  
   printf("通讯录已满，无法添加\n");
9.  
   return;
10.  
    }
11.  
    printf("请输入名字：");
12.  
    scanf("%s", pc->data[pc->sz].name);
13.  
    printf("请输入年龄：");
14.  
    scanf("%d", &(pc->data[pc->sz].age));
15.  
    printf("请输入性别：");
16.  
    scanf("%s", pc->data[pc->sz].sex);
17.  
    printf("请输入电话：");
18.  
    scanf("%s", pc->data[pc->sz].tele);
19.  
    printf("请输入地址：");
20.  
    scanf("%s", pc->data[pc->sz].addr);
21.  
     
22.  
    pc->sz ;
23.  
    printf("成功添加联系人");
24.  
     
25.  
    }

7.2 显示所有联系人的信息

当我们增加完联系人之后，我们想要看看是否成功添加，来看看通讯录中存在的联系人。

注意：我们打印的时候可以借助\t制表符来进行打印，这样打印出来会很整齐，很好看！

1.  
   //显示所有联系人
2.  
   void ShowContact(const Contact* pc)
3.  
   {
4.  
   //断言
5.  
   assert(pc);
6.  
   //打印列标题
7.  
   printf("%-10s\t%-4s\t%-5s\t%-12s\t%-30s\n","姓名","年龄","性别","电话","地址");
8.  
   int i = 0;
9.  
   //打印数据
10.  
    for (i = 0; i < pc->sz; i )
11.  
    {
12.  
    printf("%-10s\t%-4d\t%-5s\t%-12s\t%-30s\n", pc->data[i].name,
13.  
    pc->data[i].age,
14.  
    pc->data[i].sex,
15.  
    pc->data[i].tele,
16.  
    pc->data[i].addr);
17.  
    }
18.  
    }

具体效果如下图所示：

 7.3 单独查找人的函数

写到这里我们发现不管是删除联系人还是查找联系人以及修改联系人，都会经过查找这一步，所以单独写个查找的函数代码如下：

1.  
   //只在本文件使用
2.  
   static int FindName(const Contact* pc, char name[])
3.  
   {
4.  
   int i = 0;
5.  
   for (i = 0; i < pc->sz; i )
6.  
   {
7.  
   if (strcmp(pc->data[i].name, name)==0)
8.  
   {
9.  
   return i;
10.  
    }
11.  
    }
12.  
    return -1;
13.  
    }

7.4 删除指定联系人

当我们写完单独查找人的函数后，这个删除指定联系人就会简单许多，在查找前仍然要检查一下通讯录是否为空，如果为空就没必要再继续下去了，先查找到指定联系人，看看是否存在，然后再删除，具体代码如下：

1.  
   //删除指定联系人
2.  
   void DelContact(Contact* pc)
3.  
   {
4.  
   if (pc->sz == 0)
5.  
   {
6.  
   printf("通讯录为空，无法删除\n");
7.  
   return;
8.  
   }
9.  
   char name[MAX_NAME]={0};
10.  
    assert(pc);
11.  
    //删除
12.  
    printf("请输入要删除人的名字：");
13.  
    scanf("%s", name);
14.  
    // 不管是删除联系人还是查找联系人以及修改联系人，都会经过查找这一步，所以单独写个查找的函数
15.  
    int del=FindName(pc, name);
16.  
    if (del == -1)
17.  
    {
18.  
    printf("要删除的人不存在\n");
19.  
    return;
20.  
    }
21.  
    //删除所要删除的联系人
22.  
    int i = 0;
23.  
    for (i = del; i < pc->sz-1; i )
24.  
    {
25.  
    pc->data[i] = pc->data[i 1];
26.  
    }
27.  
    //人数减一
28.  
    pc->sz--;
29.  
     
30.  
    printf("成功删除联系人\n");
31.  
    }

7.5 查找指定联系人

直接调用单独查找人的函数即可，是不是很方便！如果查找的人不存在，那就直接跳出即可，如果找到，就答应查找的联系人，代码如下：

1.  
   //查找指定联系人
2.  
   void SearchContact(const Contact* pc)
3.  
   {
4.  
   char name[MAX_NAME] = { 0 };
5.  
   assert(pc);
6.  
   printf("请输入要查找人的名字：");
7.  
   scanf("%s", name);
8.  
   int pos = FindName(pc, name);
9.  
   if (pos == -1)
10.  
    {
11.  
    printf("要查找的人不存在\n");
12.  
    }
13.  
    else
14.  
    {
15.  
    printf("%-10s\t%-4s\t%-5s\t%-12s\t%-30s\n", "姓名", "年龄", "性别", "电话", "地址");
16.  
    printf("%-10s\t%-4d\t%-5s\t%-12s\t%-30s\n", pc->data[pos].name,
17.  
    pc->data[pos].age,
18.  
    pc->data[pos].sex,
19.  
    pc->data[pos].tele,
20.  
    pc->data[pos].addr);
21.  
    }
22.  
    }

7.6 修改指定联系人

修改联系人很简单，这里就不多做解释啦，直接上代码！

1.  
   //修改联系人
2.  
   void ModifyContact(Contact* pc)
3.  
   {
4.  
   char name[MAX_NAME] = { 0 };
5.  
   assert(pc);
6.  
   printf("请输入要修改联系人的姓名：");
7.  
   scanf("%s", name);
8.  
   int pos = FindName(pc, name);
9.  
   if (pos == -1)
10.  
    {
11.  
    printf("要修改的联系人不存在\n");
12.  
    }
13.  
    else
14.  
    {
15.  
    printf("请输入名字：");
16.  
    scanf("%s", pc->data[pos].name);
17.  
    printf("请输入年龄：");
18.  
    scanf("%d", &(pc->data[pos].age));
19.  
    printf("请输入性别：");
20.  
    scanf("%s", pc->data[pos].sex);
21.  
    printf("请输入电话：");
22.  
    scanf("%s", pc->data[pos].tele);
23.  
    printf("请输入地址：");
24.  
    scanf("%s", pc->data[pos].addr);
25.  
    }
26.  
    }

7.7 按照名字顺序进行排序

这里博主就拿按照名字顺序进行排序，利用库函数qsort函数进行排序，具体qsort函数是什么，博主这里建议大家去查一查，了解一下，当然小编也准备单独写一篇博客来介绍qsort函数以及qsort的模拟实现，如果感兴趣，可以关注，期待小编更新哦。

1.  
   int cmp_name(const void* p1, const void* p2)
2.  
   {
3.  
   return strcmp(((PeoInfo*)p1)->name, ((PeoInfo*)p2)->name);
4.  
   }
5.  
   //排序联系人
6.  
   void SortContact(Contact* pc)
7.  
   {
8.  
   assert(pc);
9.  
   //就拿按照名字排序吧
10.  
    //利用qsort函数
11.  
    qsort(pc->data, pc->sz, sizeof((pc->data)[0]), cmp_name);
12.  
    //排序结束，输出通讯录
13.  
    //打印列标题
14.  
    printf("%-10s\t%-4s\t%-5s\t%-12s\t%-30s\n", "姓名", "年龄", "性别", "电话", "地址");
15.  
    int i = 0;
16.  
    //打印数据
17.  
    for (i = 0; i < pc->sz; i )
18.  
    {
19.  
    printf("%-10s\t%-4d\t%-5s\t%-12s\t%-30s\n", pc->data[i].name,
20.  
    pc->data[i].age,
21.  
    pc->data[i].sex,
22.  
    pc->data[i].tele,
23.  
    pc->data[i].addr);
24.  
    }
25.  
    }

7.8  清空所有联系人

清空联系人也会很简单，就直接讲通讯录里面的sz人数置为0即可，具体代码如下

1.  
   void ClearContact(Contact* pc)
2.  
   {
3.  
   assert(pc);
4.  
   //其实清空联系人只需要把里面的人数清零即可
5.  
   int i = 0;
6.  
   printf("确定要清空所有联系人吗？确定请按1，按其余键返回\n");
7.  
   scanf("%d", &i);
8.  
   if (i == 1)
9.  
   {
10.  
    pc->sz = 0;
11.  
    printf("清空联系人成功");
12.  
    }
13.  
    }

八、通讯录优化——静态->动态

写到这里，其实简单的通讯录已经介绍完毕，但是我们这个通讯录其实可以进行优化的。

优化目标：

                ①通讯录空间不是固定的，大小可以调整的。

                ②默认能放三个人的信息，如果不够，就每次增加两个人的容量

8.1 通讯录结构体优化

因为这里的通讯录人数不是固定的了，所以我们首先想到的是优化通讯录这个结构。通讯录的空间是动态开辟的，由malloc开辟即可。

注意：①sz是记录当前放的有效元素的个数

            ②capacity是记录通讯录当前最大容量

1.  
   #define DEFAULT_SZ 3 //起始容量
2.  
   #define ADD_SZ 2 //每次需要增加的容量
3.  
    
4.  
   //动态版本
5.  
    
6.  
   //通讯录容量可以更改，不够时进行增加
7.  
   typedef struct contact
8.  
   {
9.  
   PeoInfo* data;//指向存放数据的空间
10.  
    int sz;//当前放的有效元素的个数
11.  
    int capacity;//通讯录当前最大容量
12.  
    }Contact;

8.2 初始化函数的优化

初始化函数也不能是固定的100人全部初始化。而是应该最开始开辟三个人的空间。人数为0，容量为3。

1.  
   //动态版本
2.  
   void InitContact(Contact* pc)
3.  
   {
4.  
   assert(pc);
5.  
   pc->data = (PeoInfo*)malloc(DEFAULT_SZ * sizeof(PeoInfo));
6.  
   if (pc->data == NULL)
7.  
   {
8.  
   perror("InitContact");
9.  
   return;
10.  
    }
11.  
    pc->sz = 0;
12.  
    pc->capacity = DEFAULT_SZ;
13.  
    }

8.3增加联系人的优化

这时动态版本的增加联系人就不存在满的问题了，而是先检查人数是否等于这里的最大容量的，如果等于，那就需要进行扩容了。（利用realloc函数）这里的好处就体现出来了，我们用多少空间，就开辟多少空间，每次只多开辟两个人的空间即可。

我们这里用int来接收增容的结果，如果增容成功，就返回1，增容失败就返回0，然后在进行判断，如果失败，就没必要继续往下走了。

1.  
   //动态版本
2.  
   void AddContact(Contact* pc)
3.  
   {
4.  
   assert(pc);//断言，防止pc是空指针
5.  
   CheckCapacity(pc);
6.  
   if (0 == CheckCapacity(pc))
7.  
   {
8.  
   return;
9.  
   }
10.  
     
11.  
    printf("请输入名字：");
12.  
    scanf("%s", pc->data[pc->sz].name);
13.  
    printf("请输入年龄：");
14.  
    scanf("%d", &(pc->data[pc->sz].age));
15.  
    printf("请输入性别：");
16.  
    scanf("%s", pc->data[pc->sz].sex);
17.  
    printf("请输入电话：");
18.  
    scanf("%s", pc->data[pc->sz].tele);
19.  
    printf("请输入地址：");
20.  
    scanf("%s", pc->data[pc->sz].addr);
21.  
     
22.  
    pc->sz ;
23.  
    printf("成功添加联系人\n");
24.  
     
25.  
    }
26.  
    int CheckCapacity(Contact* pc)
27.  
    {
28.  
    assert(pc);
29.  
    //判断通讯录是否满了
30.  
    if (pc->sz == pc->capacity)
31.  
    {
32.  
    PeoInfo* ptr=(PeoInfo*)realloc(pc->data, (pc->capacity ADD_SZ)*sizeof(PeoInfo));
33.  
    if (ptr == NULL)
34.  
    {
35.  
    perror("CheckCapacity");
36.  
    return 0;
37.  
    }
38.  
    else
39.  
    {
40.  
    pc->data = ptr;
41.  
    pc->capacity = ADD_SZ;
42.  
    printf("增容成功\n");
43.  
    return 1;
44.  
    }
45.  
    }
46.  
    return 1;
47.  
    }

8.4 释放通讯录的空间

因为这里的通讯录是动态开辟，所以当我们使用完之后要将开辟的内存释放掉，防止内存泄漏。

当然释放完空间，我们里面的信息也就没有了，这时要把人数置为0，容量变为3.

1.  
   //因为通讯录是动态开辟的，所以使用完需要释放
2.  
   void DestroyContact(Contact* pc)
3.  
   {
4.  
   free(pc->data);
5.  
   pc->data = NULL;
6.  
   pc->capacity = 0;
7.  
   pc->sz = 0;
8.  
   }

九、完整代码 

到这里，我们不管是简单的静态通讯录，还是动态的通讯录都实现完毕，代码博主这里放在一起来展示。

test.c

1.  
   #define _CRT_SECURE_NO_WARNINGS 1
2.  
    
3.  
   #define _CRT_SECURE_NO_WARNINGS 1
4.  
    
5.  
   #include"contact.h"
6.  
   void menu()
7.  
   {
8.  
   printf("*******************************\n");
9.  
   printf("********1.add 2.del*******\n");
10.  
    printf("********3.search 4.modify****\n");
11.  
    printf("********5.show 6.sort******\n");
12.  
    printf("********** 7.clear***********\n");
13.  
    printf("********* 0.exit************\n");
14.  
    printf("*******************************\n");
15.  
    }
16.  
    void test()
17.  
    {
18.  
    int input = 0;
19.  
    //定义通讯录
20.  
    Contact con;
21.  
    InitContact(&con);
22.  
    do
23.  
    {
24.  
    menu();//打印菜单
25.  
    printf("请选择：");
26.  
    scanf("%d", &input);
27.  
    switch (input)
28.  
    {
29.  
    case Add:
30.  
    AddContact(&con);
31.  
    break;
32.  
    case Del:
33.  
    DelContact(&con);
34.  
    break;
35.  
    case Search:
36.  
    SearchContact(&con);
37.  
    break;
38.  
    case Modify:
39.  
    ModifyContact(&con);
40.  
    break;
41.  
    case Show:
42.  
    ShowContact(&con);
43.  
    break;
44.  
    case Sort:
45.  
    SortContact(&con);
46.  
    break;
47.  
    case Clear:
48.  
    ClearContact(&con);
49.  
    break;
50.  
    case Exit:
51.  
    DestroyContact(&con);
52.  
    printf("退出通讯录\n");
53.  
    break;
54.  
    default:
55.  
    printf("选择错误，请重新选择\n");
56.  
    break;
57.  
    }
58.  
    } while (input);
59.  
    }
60.  
    int main()
61.  
    {
62.  
    test();
63.  
    return 0;
64.  
    }

contact.h

1.  
   #define _CRT_SECURE_NO_WARNINGS 1
2.  
    
3.  
   #pragma once
4.  
    
5.  
   #define MAX 100
6.  
   #define MAX_NAME 20
7.  
   #define MAX_SEX 5
8.  
   #define MAX_TELE 12
9.  
   #define MAX_ADDR 30
10.  
     
11.  
    #define DEFAULT_SZ 3
12.  
    #define ADD_SZ 2
13.  
     
14.  
    #include<string.h>
15.  
     
16.  
    #include<stdio.h>
17.  
     
18.  
    #include<assert.h>
19.  
     
20.  
    #include<stdlib.h>
21.  
     
22.  
     
23.  
    //类型的声明
24.  
     
25.  
    enum Option
26.  
    {
27.  
    Exit,//0
28.  
    Add,//1
29.  
    Del,//2
30.  
    Search,//3
31.  
    Modify,//4
32.  
    Show,//5
33.  
    Sort,//6
34.  
    Clear//7
35.  
     
36.  
    };
37.  
     
38.  
    typedef struct PeoInfo
39.  
    {
40.  
    char name[MAX_NAME];
41.  
    int age;
42.  
    char sex[MAX_SEX];
43.  
    char tele[MAX_TELE];
44.  
    char addr[MAX_ADDR];
45.  
    }PeoInfo;
46.  
     
47.  
    //通讯录
48.  
    静态版本
49.  
    //typedef struct contact
50.  
    //{
51.  
    // PeoInfo data[MAX];
52.  
    // int sz;
53.  
    //}Contact;
54.  
     
55.  
    //动态版本
56.  
    //通讯录容量可以更改，不够时进行增加
57.  
    typedef struct contact
58.  
    {
59.  
    PeoInfo* data;//指向存放数据的空间
60.  
    int sz;//当前放的有效元素的个数
61.  
    int capacity;//通讯录当前最大容量
62.  
    }Contact;
63.  
     
64.  
     
65.  
     
66.  
    //函数声明
67.  
    //初始化通讯录函数
68.  
    void InitContact(Contact* pc);
69.  
     
70.  
    //增加联系人信息
71.  
    void AddContact(Contact* pc);
72.  
     
73.  
    //显示所有联系人的信息
74.  
    void ShowContact(const Contact* pc);
75.  
     
76.  
    //删除指定联系人
77.  
    void DelContact(Contact* pc);
78.  
     
79.  
    //查找指定联系人
80.  
    void SearchContact(const Contact* pc);
81.  
     
82.  
    //修改联系人
83.  
    void ModifyContact(Contact* pc);
84.  
     
85.  
    //排序联系人
86.  
    void SortContact(Contact* pc);
87.  
     
88.  
     
89.  
    //清空联系人
90.  
    void ClearContact(Contact* pc);
91.  
     
92.  
    //释放通讯录的空间
93.  
    void DestroyContact(Contact* pc);

contact.c

1.  
   #define _CRT_SECURE_NO_WARNINGS 1
2.  
    
3.  
   #define _CRT_SECURE_NO_WARNINGS 1
4.  
   #include"contact.h"
5.  
   //函数的实现
6.  
    
7.  
   //静态版本
8.  
   初始化通讯录
9.  
   //void InitContact(Contact* pc)
10.  
    //{
11.  
    // memset(pc->data, 0, sizeof(pc->data));
12.  
    // pc->sz = 0;
13.  
    //}
14.  
     
15.  
    //动态版本
16.  
    void InitContact(Contact* pc)
17.  
    {
18.  
    assert(pc);
19.  
    pc->data = (PeoInfo*)malloc(DEFAULT_SZ * sizeof(PeoInfo));
20.  
    if (pc->data == NULL)
21.  
    {
22.  
    perror("InitContact");
23.  
    return;
24.  
    }
25.  
    pc->sz = 0;
26.  
    pc->capacity = DEFAULT_SZ;
27.  
    }
28.  
     
29.  
     
30.  
    //静态版本
31.  
    //增加联系人
32.  
    //void AddContact(Contact* pc)
33.  
    //{
34.  
    // assert(pc);//断言，防止pc是空指针
35.  
    // //判断通讯录是否满了
36.  
    // if (pc->sz == MAX)
37.  
    // {
38.  
    // printf("通讯录已满，无法添加\n");
39.  
    // return;
40.  
    // }
41.  
    // printf("请输入名字：");
42.  
    // scanf("%s", pc->data[pc->sz].name);
43.  
    // printf("请输入年龄：");
44.  
    // scanf("%d", &(pc->data[pc->sz].age));
45.  
    // printf("请输入性别：");
46.  
    // scanf("%s", pc->data[pc->sz].sex);
47.  
    // printf("请输入电话：");
48.  
    // scanf("%s", pc->data[pc->sz].tele);
49.  
    // printf("请输入地址：");
50.  
    // scanf("%s", pc->data[pc->sz].addr);
51.  
    //
52.  
    // pc->sz ;
53.  
    // printf("成功添加联系人");
54.  
    //
55.  
    //}
56.  
     
57.  
    //动态版本
58.  
    int CheckCapacity(Contact* pc)
59.  
    {
60.  
    assert(pc);
61.  
    //判断通讯录是否满了
62.  
    if (pc->sz == pc->capacity)
63.  
    {
64.  
    PeoInfo* ptr=(PeoInfo*)realloc(pc->data, (pc->capacity ADD_SZ)*sizeof(PeoInfo));
65.  
    if (ptr == NULL)
66.  
    {
67.  
    perror("CheckCapacity");
68.  
    return 0;
69.  
    }
70.  
    else
71.  
    {
72.  
    pc->data = ptr;
73.  
    pc->capacity = ADD_SZ;
74.  
    printf("增容成功\n");
75.  
    return 1;
76.  
    }
77.  
    }
78.  
    return 1;
79.  
    }
80.  
    void AddContact(Contact* pc)
81.  
    {
82.  
    assert(pc);//断言，防止pc是空指针
83.  
    CheckCapacity(pc);
84.  
    if (0 == CheckCapacity(pc))
85.  
    {
86.  
    return;
87.  
    }
88.  
     
89.  
    printf("请输入名字：");
90.  
    scanf("%s", pc->data[pc->sz].name);
91.  
    printf("请输入年龄：");
92.  
    scanf("%d", &(pc->data[pc->sz].age));
93.  
    printf("请输入性别：");
94.  
    scanf("%s", pc->data[pc->sz].sex);
95.  
    printf("请输入电话：");
96.  
    scanf("%s", pc->data[pc->sz].tele);
97.  
    printf("请输入地址：");
98.  
    scanf("%s", pc->data[pc->sz].addr);
99.  
     
100.  
     pc->sz ;
101.  
     printf("成功添加联系人\n");
102.  
      
103.  
     }
104.  
      
105.  
     //显示所有联系人
106.  
     void ShowContact(const Contact* pc)
107.  
     {
108.  
     //断言
109.  
     assert(pc);
110.  
     //打印列标题
111.  
     printf("%-10s\t%-4s\t%-5s\t%-12s\t%-30s\n", "姓名", "年龄", "性别", "电话", "地址");
112.  
     int i = 0;
113.  
     //打印数据
114.  
     for (i = 0; i < pc->sz; i )
115.  
     {
116.  
     printf("%-10s\t%-4d\t%-5s\t%-12s\t%-30s\n", pc->data[i].name,
117.  
     pc->data[i].age,
118.  
     pc->data[i].sex,
119.  
     pc->data[i].tele,
120.  
     pc->data[i].addr);
121.  
     }
122.  
     }
123.  
      
124.  
     //只在本文件使用
125.  
     static int FindName(const Contact* pc, char name[])
126.  
     {
127.  
     int i = 0;
128.  
     for (i = 0; i < pc->sz; i )
129.  
     {
130.  
     if (strcmp(pc->data[i].name, name) == 0)
131.  
     {
132.  
     return i;
133.  
     }
134.  
     }
135.  
     return -1;
136.  
     }
137.  
      
138.  
      
139.  
     //删除指定联系人
140.  
     void DelContact(Contact* pc)
141.  
     {
142.  
     if (pc->sz == 0)
143.  
     {
144.  
     printf("通讯录为空，无法删除\n");
145.  
     return;
146.  
     }
147.  
     char name[MAX_NAME] = { 0 };
148.  
     assert(pc);
149.  
     //删除
150.  
     printf("请输入要删除人的名字：");
151.  
     scanf("%s", name);
152.  
     找到要删除的人
153.  
     //int i = 0;
154.  
     //int del = 0;
155.  
     //int flag = 0;
156.  
     //for (i = 0; i < pc->sz; i )
157.  
     //{
158.  
     // if (strcmp(pc->data[i].name, name)==0)
159.  
     // {
160.  
     // del = i;
161.  
     // flag = 1;//找到了
162.  
     // break;
163.  
     // }
164.  
     //}
165.  
     //if (flag == 0)
166.  
     //{
167.  
     // printf("要删除的人不存在\n");
168.  
     // return;
169.  
     //}
170.  
     // 不管是删除联系人还是查找联系人以及修改联系人，都会经过查找这一步，所以单独写个查找的函数
171.  
     int del = FindName(pc, name);
172.  
     if (del == -1)
173.  
     {
174.  
     printf("要删除的人不存在\n");
175.  
     return;
176.  
     }
177.  
     //删除所要删除的联系人
178.  
     int i = 0;
179.  
     for (i = del; i < pc->sz - 1; i )
180.  
     {
181.  
     pc->data[i] = pc->data[i 1];
182.  
     }
183.  
     //人数减一
184.  
     pc->sz--;
185.  
      
186.  
     printf("成功删除联系人\n");
187.  
     }
188.  
      
189.  
      
190.  
     //查找指定联系人
191.  
     void SearchContact(const Contact* pc)
192.  
     {
193.  
     char name[MAX_NAME] = { 0 };
194.  
     assert(pc);
195.  
     printf("请输入要查找人的名字：");
196.  
     scanf("%s", name);
197.  
     int pos = FindName(pc, name);
198.  
     if (pos == -1)
199.  
     {
200.  
     printf("要查找的人不存在\n");
201.  
     }
202.  
     else
203.  
     {
204.  
     printf("%-10s\t%-4s\t%-5s\t%-12s\t%-30s\n", "姓名", "年龄", "性别", "电话", "地址");
205.  
     printf("%-10s\t%-4d\t%-5s\t%-12s\t%-30s\n", pc->data[pos].name,
206.  
     pc->data[pos].age,
207.  
     pc->data[pos].sex,
208.  
     pc->data[pos].tele,
209.  
     pc->data[pos].addr);
210.  
     }
211.  
     }
212.  
      
213.  
     //修改联系人
214.  
     void ModifyContact(Contact* pc)
215.  
     {
216.  
     char name[MAX_NAME] = { 0 };
217.  
     assert(pc);
218.  
     printf("请输入要修改联系人的姓名：");
219.  
     scanf("%s", name);
220.  
     int pos = FindName(pc, name);
221.  
     if (pos == -1)
222.  
     {
223.  
     printf("要修改的联系人不存在\n");
224.  
     }
225.  
     else
226.  
     {
227.  
     printf("请输入名字：");
228.  
     scanf("%s", pc->data[pos].name);
229.  
     printf("请输入年龄：");
230.  
     scanf("%d", &(pc->data[pos].age));
231.  
     printf("请输入性别：");
232.  
     scanf("%s", pc->data[pos].sex);
233.  
     printf("请输入电话：");
234.  
     scanf("%s", pc->data[pos].tele);
235.  
     printf("请输入地址：");
236.  
     scanf("%s", pc->data[pos].addr);
237.  
     }
238.  
     }
239.  
      
240.  
     int cmp_name(const void* p1, const void* p2)
241.  
     {
242.  
     return strcmp(((PeoInfo*)p1)->name, ((PeoInfo*)p2)->name);
243.  
     }
244.  
     //排序联系人
245.  
     void SortContact(Contact* pc)
246.  
     {
247.  
     assert(pc);
248.  
     //就拿按照名字排序吧
249.  
     //利用qsort函数
250.  
     qsort(pc->data, pc->sz, sizeof((pc->data)[0]), cmp_name);
251.  
     //排序结束，输出通讯录
252.  
     //打印列标题
253.  
     printf("%-10s\t%-4s\t%-5s\t%-12s\t%-30s\n", "姓名", "年龄", "性别", "电话", "地址");
254.  
     int i = 0;
255.  
     //打印数据
256.  
     for (i = 0; i < pc->sz; i )
257.  
     {
258.  
     printf("%-10s\t%-4d\t%-5s\t%-12s\t%-30s\n", pc->data[i].name,
259.  
     pc->data[i].age,
260.  
     pc->data[i].sex,
261.  
     pc->data[i].tele,
262.  
     pc->data[i].addr);
263.  
     }
264.  
     }
265.  
      
266.  
     //清空联系人
267.  
      
268.  
     void ClearContact(Contact* pc)
269.  
     {
270.  
     assert(pc);
271.  
     //其实清空联系人只需要把里面的人数清零即可
272.  
     int i = 0;
273.  
     printf("确定要清空所有联系人吗？确定请按1，按其余键返回\n");
274.  
     scanf("%d", &i);
275.  
     if (i == 1)
276.  
     {
277.  
     pc->sz = 0;
278.  
     printf("清空联系人成功");
279.  
     }
280.  
     }
281.  
      
282.  
     //因为通讯录是动态开辟的，所以使用完需要释放
283.  
     void DestroyContact(Contact* pc)
284.  
     {
285.  
     free(pc->data);
286.  
     pc->data = NULL;
287.  
     pc->capacity = 0;
288.  
     pc->sz = 0;
289.  
     }

好啦，到这里，今天的博主给大家带来的通讯录到这里就结束啦，如果哪里有问题，欢迎在评论区留言。如果觉得小编写的还不错的，那么可以一键三连哦，您的关注点赞和收藏是对小编最大的鼓励。谢谢大家！！！

这篇好文章是转载于：学新通技术网