（C语言）动态分配的动态通讯录（静态通讯录Plus）（C语言小项目）

最新推荐文章于 2025-04-24 16:42:51 发布
最新推荐文章于 2025-04-24 16:42:51 发布
阅读量1k 收藏 14
点赞数 17
分类专栏： C语言小项目 文章标签： c语言 microsoft 开发语言 算法 数据结构 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_78101238/article/details/146543075
版权
 1.首先是头文件：
//头文件
//contact.h

//防止头文件被重复包含
#pragma once
//定义符号常亮，方便维护和修改
//联系人基本信息容量
#define NAME_MAX 20
#define AGE_MAX 5
#define SEX_MAX 5
#define TELE_MAX 15
#define ADDR_MAX 30
//联系人最大容量
#define MAX 1

//定义联系人结构体
struct PeopleInfo
{
	char name[NAME_MAX];
	char age[AGE_MAX];
	char sex[SEX_MAX];
	char tele[TELE_MAX];
	char addr[ADDR_MAX];
};
//定义通讯录结构体
struct Contact
{
	struct PeopleInfo* data;
	int sz;
	int capacity;
};

//声明函数
void clear_screen();
void AddContact(struct Contact* con);
void DelContact(struct Contact* con);
void ShowContact(struct Contact* con);
int FindContact(const struct Contact* con, char name[]);
void InitContact(struct Contact* con);
void menu();
void ModifyContact(struct Contact* con);
void SearchContact(struct Contact* con);
void SortContact(struct Contact* con);
void ClearContact(struct Contact* con);
void ClearCapContact(struct Contact* con);
2. 然后是功能函数contact.c文件
//功能函数文件
//contact.c	

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "contact.h"

//定义菜单函数
void menu()
{
	printf("*********************************************\n");
	printf("******** 1.添加        2.删除  **************\n");
	printf("******** 3.查询        4.修改  **************\n");
	printf("******** 5.查看        6.排序  **************\n");
	printf("******** 7.清空        0.退出  **************\n");
	printf("*********************************************\n");
}

//定义清屏函数
//清屏操作
void clear_screen() {
	//判断是否为Windows系统
#ifdef _WIN32
	system("cls");
	//其他系统
#else
	system("clear");
#endif
}

//初始化通讯录函数
void InitContact(struct Contact* con)
{
	con->sz = 0;//当前联系人数量：0
	//memset(con->data, 0, MAX * sizeof(struct PeopleInfo));//清空数组
	//动态分配成1，并初始化为0
	con->data = (struct People*)calloc(MAX, sizeof(struct PeopleInfo));
	if (con -> data == NULL) {
		printf("开辟空间失败！\n");
		return -1;
	}
	con->capacity = MAX;
}

//添加联系人函数
void AddContact(struct Contact* con) {
	//检查通讯录是否溢出
	if (con->sz == con->capacity) {
		struct PeopleInfo* cap= (struct PeopleInfo*)realloc(con->data, ((con->capacity)++)* sizeof(struct PeopleInfo));
		if (cap != NULL)
		{
			//扩容成功
			con->data = cap;
			printf("增容成功!\n");
		}
		else
		{
			//扩容失败
			return;
		}
	}
		printf("请输入姓名：");
		scanf("%s", con->data[con->sz].name);
		printf("请输入年龄：");
		scanf("%s", con->data[con->sz].age);
		printf("请输入性别：");
		scanf("%s", con->data[con->sz].sex);
		printf("请输入电话：");
		scanf("%s", con->data[con->sz].tele);
		printf("请输入地址：");
		scanf("%s", con->data[con->sz].addr);
		printf("添加成功!\n");
		(con->sz)++;
}

//查找当前联系人函数
int  FindContact(const struct Contact* con, char name[]) {
	for (int i = 0; i < con->sz; i++) {
		//利用比较函数strcmp判断姓名是否相等
		if (strcmp(con->data[i].name, name) == 0) {
			return i;
		}
	}
	printf("用户不存在！\n");
	return -1;
}

//删除联系人函数
void DelContact(struct Contact* con) {
	if (con->sz == 0) {
		printf("通讯录为空！\n");
	}
	else
	{
		printf("请输入要删除的联系人姓名：\n");
		char name[NAME_MAX];
		scanf("%s", name);
		int ret = FindContact(con, name);
		if (ret != -1) {
			printf("删除成功！\n");
			for (int i = ret; i < con->sz - 1; i++) {
				con->data[i] = con->data[i + 1];
			}
			(con->sz)--;
		}
	}
}

//查询当前通讯录
void ShowContact(struct Contact* con) {
	if (con->sz == 0) {
		printf("该通讯录为空\n");
	}
	else {
		printf("%-15s\t%-5s\t%-8s\t%-15s\t%-30s\n", "姓名", "年龄", "性别", "电话", "地址");

		for (int i = 0; i < con->sz; i++) {
			printf("%-15s\t%-5s\t%-8s\t%-15s\t%-30s\n", con->data[i].name,
				con->data[i].age, con->data[i].sex, con->data[i].tele, con->data[i].addr);
		}
	}
}

//查询联系人函数
void SearchContact(struct Contact* con) {
	if (con->sz == 0) {
		printf("当前通讯录为空\n");
	}
	else
	{
		printf("请输入要查询的联系人姓名：\n");
		char name[NAME_MAX];
		scanf("%s", name);
		int ret = FindContact(con, name);
		if (ret != -1) {
			printf("查询成功！\n");
			printf("%-15s\t%-5s\t%-8s\t%-15s\t%-30s\n", "姓名", "年龄", "性别", "电话", "地址");
			printf("%-15s\t%-5s\t%-8s\t%-15s\t%-30s\n", con->data[ret].name,
				con->data[ret].age, con->data[ret].sex, con->data[ret].tele, con->data[ret].addr);
		}
	}
}

//修改联系人函数
void ModifyContact(struct Contact* con) {
	if (con->sz == 0) {
		printf("通讯录为空\n");
	}
	else
	{
		printf("请输入要修改的联系人姓名：\n");
		char name[NAME_MAX];
		scanf("%s", name);
		int Mod_0 = 2;
		int ret = FindContact(con, name);
		if (ret != -1) {
			printf("当前联系人数据！\n");
			printf("%-15s\t%-5s\t%-8s\t%-15s\t%-30s\n", "姓名", "年龄", "性别", "电话", "地址");
			printf("%-15s\t%-5s\t%-8s\t%-15s\t%-30s\n", con->data[ret].name,
				con->data[ret].age, con->data[ret].sex, con->data[ret].tele, con->data[ret].addr);
			printf("是否确定修改？？(按1继续，按0退出)\n");
			while (1) {
				if (scanf("%d", &Mod_0) != 1) {
					printf("输入不合法，请重新输入");
				}
				if (Mod_0 == 1) {
					printf("请输入姓名：");
					scanf("%s", con->data[ret].name);
					printf("请输入年龄：");
					scanf("%s", con->data[ret].age);
					printf("请输入性别：");
					scanf("%s", con->data[ret].sex);
					printf("请输入电话：");
					scanf("%s", con->data[ret].tele);
					printf("请输入地址：");
					scanf("%s", con->data[ret].addr);
					printf("修改成功!\n");
					break;
				}
				else if (Mod_0 == 0) {
					break;
				}
			}
		}
	}
}


//比较函数
int by_name_cmp1(const void* x1, const void* x2) {
	return strcmp(((struct PeopleInfo*)x1)->name, ((struct PeopleInfo*)x2)->name);
}
int by_name_cmp2(const void* x1, const void* x2) {
	return strcmp(((struct PeopleInfo*)x2)->name, ((struct PeopleInfo*)x1)->name);
}
//排序联系人函数
void SortContact(struct Contact* con) {
	if (con->sz == 0) {
		printf("通讯录为空\n");
	}
	else {
		int Sort_0 = 2;
		printf("请选择排序方式（按1升序，按0降序）：\n");
		while (1) {
			if (scanf("%d", &Sort_0) != 1) {
				printf("输入不合法，请重新输入");
			}
			if (Sort_0 == 1) {
				qsort(con->data, con->sz, sizeof(struct PeopleInfo), by_name_cmp1);
				printf("升序排序已完成\n");
				break;
			}
			else if (Sort_0 == 0)
			{
				qsort(con->data, con->sz, sizeof(struct PeopleInfo), by_name_cmp2);
				printf("降序排序已完成\n");
				break;
			}
		}
	}
}
//清空通讯录函数
void ClearContact(struct Contact* con) {
	if (con->sz == 0) {
		printf("通讯录为空\n");
	}
	else
	{
		con->sz = 0;
		memset(con->data, 0, MAX * sizeof(struct PeopleInfo));
		printf("当前通讯录已经清空\n");
	}
}

//释放空间函数
void ClearCapContact(struct Contact* con) {
	free(con->data);
	con->data = NULL;
	con->sz = 0;
	con->capacity = 0;
}
3.最后是主程序test.c文件：
//主程序文件
//test.c

#include <stdio.h>
#include <stdlib.h>
#include "contact.h"

//枚举条件选择定义（搭配switch使用）
enum Option
{
	EXIT,//0，对应退出通讯录
	ADD,//1，对应添加联系人
	DEL,//2，对应删除联系人
	SEARCH,//3，对应查询联系人
	MODIFY,//4，对应修改联系人
	SHOW,//5，对应查看通讯录
	SORT,//6，对应排序通讯录
	CLEAR,//7，对应清空通讯录
};

//主函数
int main()
{
	int input = 0;
	int menu_0 = 0;
	//创建通讯录
	struct Contact con;
	//调用函数初始化通讯录
	InitContact(&con);//传递参数地址

	do
	{
		//打印菜单
		while (1) {
			printf("************按1继续************\n");
			if (scanf("%d", &menu_0) != 1 && menu_0 != 1) {
				printf("输入不合法,请按1继续\n");
				return 1;
			}
			clear_screen();
			if (menu_0 == 1)
			{
				menu();
				break;
			}
		}
		printf("请选择对应模式（0-7）:\n");
		if (scanf("%d", &input) != 1 || input < 0 || input > 7) {
			printf("输入不合法，请输入整数0-7\n");
			return 1;
		}
		switch (input)
		{
		case EXIT: {
			clear_screen();
			printf("退出通讯录！\n");
			break;
		}
		case ADD: {
			clear_screen();
			AddContact(&con);
			break;
		}
		case DEL: {
			clear_screen();
			DelContact(&con);
			break;
		}
		case SEARCH: {
			clear_screen();
			SearchContact(&con);
			break;
		}
		case SHOW: {
			clear_screen();
			ShowContact(&con);
			break;
		}
		case MODIFY: {
			clear_screen();
			ModifyContact(&con);
			break;
		}
		case SORT: {
			clear_screen();
			SortContact(&con);
			break;
		}
		case CLEAR: {
			clear_screen();
			ClearContact(&con);
			break;
		}
		default:
			break;
		}

	} while (input);
	ClearCapContact(&con);
	return 0;
}

整个项目只有三个文件，头文件和两个源代码

在“静态版通讯录”一章中，我们实现了一个静态版本的通讯录，所谓静态版就是通讯录中数组存储联系人的大小是固定的，如果我们并不需要有那么多的联系人，就造成内存的严重浪费，所以在本章，我们来实现一个动态版的通讯录，能存储联系人的个数可以根据需要改变。

首先，先介绍一下stdlib.h头文件中的动态空间分配库函数，在之前的文章中，我们介绍了malloc函数和realloc函数，今天我们要用calloc函数，下面我们来介绍一下他们之间的区别：

一、calloc 的作用

  1. 功能：

    • 分配一块 连续的内存空间。

    • 自动将分配的内存初始化为零（所有字节设为 0x00）。

    • 适用于需要批量分配并初始化内存的场景（如数组、结构体数组）。

  2. 函数原型：

    void* calloc(size_t num_elements, size_t element_size);

    • 参数：

      • num_elements：需要分配的元素个数。

      • element_size：每个元素的大小（单位：字节）。

    • 返回值：

      • 成功：返回指向分配内存的指针。

      • 失败：返回 NULL（如内存不足）。

二、calloc 的基本用法

示例代码
#include <stdio.h>
#include <stdlib.h>  // 必须包含此头文件

int main() {
    int n = 5;
    // 分配一个包含5个int的数组，并初始化为0
    int* arr = (int*)calloc(n, sizeof(int));
    
    if (arr == NULL) {
        printf("内存分配失败!\n");
        return 1;
    }

    // 使用内存
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);  // 输出：0 0 0 0 0
    }

    // 释放内存
    free(arr);
    return 0;
}

三、calloc vs malloc vs realloc

函数初始化内存参数形式典型用途
calloc初始化为零num_elements, element_size分配并初始化数组、结构体数组
malloc不初始化total_bytes分配内存但不关心初始值
realloc可能保留数据ptr, new_size调整已分配内存的大小
关键区别

  1. 初始化行为：

    • calloc：分配的内存会被自动清零。

    • malloc：分配的内存内容是未定义的（可能是垃圾值）。

    • realloc：调整内存大小时，原有数据可能保留（取决于实现）。

  2. 参数形式：

    • calloc 需要指定 元素个数 和 每个元素的大小，适合分配数组。

    • malloc 直接指定 总字节数。

四、何时使用 calloc？

  1. 需要初始化内存为零：

    • 例如：创建数组或结构体数组时，希望所有元素初始为 0。

    struct Student* students = (struct Student*)calloc(100, sizeof(struct Student));

  2. 避免未初始化导致的问题：

    • 如果直接使用 malloc，内存中可能残留随机值，导致程序行为异常。

五、注意事项

  1. 内存对齐：

    • calloc 分配的内存会按系统要求对齐，无需手动处理。

  2. 性能开销：

    • calloc 的初始化（清零）会带来额外开销，如果不需要初始化，优先用 malloc。

  3. 内存释放：

    • 和 malloc 一样，必须用 free() 释放内存，否则会导致内存泄漏。

  4. 检查返回值：

    • 始终检查 calloc 返回的指针是否为 NULL，避免空指针解引用。

六、总结

  • calloc 是分配并清零内存的工具，适合需要安全初始化的场景。

  • malloc 更快但不初始化，适合不需要初始值的场景。

  • realloc 用于调整内存大小，可能保留原有数据。

知道了这些知识，下面我们就可以操作了：

struct Contact
{
	struct PeopleInfo* data;
	int sz;
	int capacity;
};

 定义结构体这里，定义一个当前空间容量capacity（后面有用）；

//初始化通讯录函数
void InitContact(struct Contact* con)
{
	con->sz = 0;//当前联系人数量：0
	//memset(con->data, 0, MAX * sizeof(struct PeopleInfo));//清空数组
	//动态分配成1，并初始化为0
	con->data = (struct People*)calloc(MAX, sizeof(struct PeopleInfo));
	if (con -> data == NULL) {
		printf("开辟空间失败！\n");
		return -1;
	}
	con->capacity = MAX;
}

初始化函数这里，使用calloc函数来分配空间并初始化通讯录，并检查是否分配成功；

让当前容量为开始时定义MAX（也就是1），这样后面可以用来重新分配；

//添加联系人函数
void AddContact(struct Contact* con) {
	//检查通讯录是否溢出
	if (con->sz == con->capacity) {
		struct PeopleInfo* cap= (struct PeopleInfo*)realloc(con->data, ((con->capacity)++)* sizeof(struct PeopleInfo));
		if (cap != NULL)
		{
			//扩容成功
			con->data = cap;
			printf("增容成功!\n");
		}
		else
		{
			//扩容失败
			return;
		}
	}
		printf("请输入姓名：");
		scanf("%s", con->data[con->sz].name);
		printf("请输入年龄：");
		scanf("%s", con->data[con->sz].age);
		printf("请输入性别：");
		scanf("%s", con->data[con->sz].sex);
		printf("请输入电话：");
		scanf("%s", con->data[con->sz].tele);
		printf("请输入地址：");
		scanf("%s", con->data[con->sz].addr);
		printf("添加成功!\n");
		(con->sz)++;
}

既然是动态分配，添加这里肯定也是需要变化，每次添加时，都要重新分配一次，不断的使容量一次扩充一个；

之后，你要记得释放清理空间：

//释放空间函数
void ClearCapContact(struct Contact* con) {
	free(con->data);
	con->data = NULL;
	con->sz = 0;
	con->capacity = 0;
}

其他的代码和静态的通讯录一样。

下面附上源代码：

双叶/(C语言)动态通讯录

那么这样，我们的动态分配的动态通讯录就做好了，如果大家喜欢，希望可以得到大家的关注呦~

注：该代码是本人自己所写，可能不够好，不够简便，欢迎大家指出我的不足之处。如果遇见看不懂的地方，可以在评论区打出来，进行讨论，或者联系我。上述内容全是我自己理解的，如果你有别的想法，或者认为我的理解不对，欢迎指出！！！如果可以，可以点一个免费的赞支持一下吗？谢谢各位彦祖亦菲！！！！！

C语言实现动态管理通讯录信息系统（静态通讯录plus版)
weixin_67401157的博客
02-21 3229
动态管理通讯录（静态通讯录plus版)
C语言通讯录（静态&动态&文件操作/内附源码）
~
09-28 1652
前言 本章主要讲解如何用C语言实现简易版通讯录 注：手把手教学，实操性非常强！！！
我们天天在使用的通讯录原来是这样实现的呀——C语言实现简单静态通讯录和动态通讯录（基于顺序表）
未见花闻的博客
09-25 1051
⭐️前面的话⭐️ 大家好！在生活中大家一定离不开通讯录或类似功能的联系人列表，比如QQ好友列表，微信朋友列表。在这篇文章中我会详细介绍如何使用C语言来搭建一个简单的通讯录，包括静态通讯录和动态通讯录。
通讯录(动态版)(C语言)(VS)
zhanghgh的博客
08-05 409
动态版通讯录，储存容量会随着人数上升，而上升。
通讯录2.0版本来了文件版——C语言实现简单通讯录文件版（基于顺序表）
未见花闻的博客
10-09 782
⭐️前面的话⭐️ 大家好！上次博主介绍了动态与静态版的通讯录，虽然动态版通讯录能够无限地读取联系人，但是程序结束后数据都没有了，这样的通讯录用起来真的是超级难受，所以通讯录2.0出来了，能够将数据自动存入文件中，并且程序关闭再打开会自动读取保存上次的联系人信息。这篇文章将在动态通讯录的基础上魔改，进化成能够自动保存的通讯录。
通讯录(文件版)(C语言)(VS)
zhanghgh的博客
08-05 383
可以保存的通讯录。
知道它你就可以去找内存要空间了——C语言动态内存管理（malloc大家族，柔性数组）
未见花闻的博客
09-28 1013
⭐️前面的话⭐️ 大家好！在实现动态通讯录的时候，我用到了malloc 和realloc动态申请内存，现在我们就来好好聊一聊动态内存管理。
C语言的内存分配malloc()和free()
Galaxy_Robot的博客
06-26 851
C语言的内存分配malloc()和free() 引言 静态数据在程序载入内存时分配，而且自动变量的数据在程序执行块时分配，并在程序离开该块时销毁。另外，C语言可以在程序运行时分配更多的内存。比如说，你做一个通讯录，但是你不能确定到底有多少人需要存储，因此你就不能确定具体需要多少内存空间，因此你可以使用动态内存分配来解决这个问题，即有一个数据需要存储的时候再分配内存给它，这样就需要使用到malloc()函数了。该函数接受一个参数：所需内存的字节数。 malloc()和free() malloc()函数会找到
c语言 通讯录plus
qq_62872261的博客
07-14 212
这篇文章提供了通讯录的plus版本，与以往静态定义通讯录大小不同，该通讯录可动态的更新需要 的空间，为用户的使用提供了更便利的条件.
基于C++单向链表的通讯录.zip
06-05
它是一种静态数据类型检查的、支持多重编程范式的通用程序设计语言。它支持过程化程序设计、数据抽象、面向对象程序设计、泛型程序设计等多种程序设计风格。 图片 C++是C语言的继承，进一步扩充和完善了C语言，...
c2012-2013C语言公选试题(参考答案)[参考].pdf
10-11
6. 最后一个程序展示了C语言中的静态变量`c`。函数`f`每次调用都会累加`b`，但`c`只在第一次调用时初始化为3。因此，第一次调用`f(a)`时，`a+b+c=2+3+3=8`，第二次调用`f(a)`，`c`已增加到4，所以`a+b+c=2+3+4=9`。...
如何在两个月之内掌握C++入门？
Ahahaha___的博客
08-25 1543
C++是C的扩展（而C被列入了容易学习的语言），C++是一种通用编程语言，据说谷歌Chromium浏览器、微软一些应用程序，甚至摩根士丹利的金融建模都是用C++完成。就在之前Springboard平台选出了最容易学习和最难学的编程语言Top 5，其中C++是第一难学的语言。除此之外最重要的就是重视编程基础，这决定了你的编程之路能走多远。浙江大学 C++ 翁恺老师_哔哩哔哩_bilibili。
嵌入式系统与移动设备开发
qq_45578181的博客
12-07 731
IEEE(国际电气和电子工程师协会)的定义：嵌入式系统是用于控制监视或者辅助操作机器和设备的装置。
【C语言】char unsigned char signed char
weixin_38287114的博客
04-20 389
char unsigned char signed char
中介者模式（Mediator Pattern）
sharpyl的专栏
04-18 490
中介者模式是处理复杂交互关系的利器，但需要谨慎设计以避免中介者过度膨胀。正确应用可以显著降低系统耦合度，提高模块化程度。
【AI 加持下的 Python 编程实战 2_10】DIY 拓展：从扫雷小游戏开发再探问题分解与 AI 代码调试能力（中）
最新发布
PeacefulWinter的博客
04-24 436
本篇为《Learn AI-assisted Python Programming》全新第2版第7/8章内容的自我拓展训练内容，为上、中、下三篇的中篇，主要介绍了自顶而下的问题分解方法在实现前端扫雷游戏设计环节的具体应用，分别就页面渲染和事件绑定两大板块做了深入剖析，并对关键函数实现进行了讲解。下一篇将重点分享 AI 辅助编程在整个过程中起到的作用，以及由此引发的一些深度思考，敬请关注。
Nacos 客户端 SDK 的核心功能是什么？是如何与服务端通信的？
专注于技术分享
04-21 962
Nacos 客户端 SDK 的核心是提供服务注册/发现和动态配置管理的能力。通信机制从早期的 HTTP + 长轮询 + UDP 演进到了 Nacos 2.x 时代以 gRPC 为主、HTTP 为辅的方式。gRPC 的引入显著提升了 Nacos 在服务发现和配置变更推送方面的实时性和性能。我们在使用时，SDK 会智能的选择最优的通信方式与服务端交互。Nacos 客户端 SDK 是应用程序集成 Nacos 能力的桥梁，它封装了与 Nacos 服务端交互的复杂性，为开发者提供了简单易用的 API。
微软承认Win11出现极端错误，只能强制关机或重装系统
meiyimin的专栏
04-16 1134
最近，不少使用 Windows 11 的用户反映，在系统更新后，“Windows Hello”突然失效，原本便捷的人脸识别和PIN登录功能统统无法使用。等真正出现无法登录、系统崩溃、磁盘损坏等问题时，才发现“没有备份”“C盘太乱”“文件全混在一起”，后悔也来不及。虽然微软称这是“边缘场景”（edge case），但已经有用户在社交平台上反馈，自己完全无法进入系统界面，只能强制关机或重装系统。面对这类不可预知的系统异常，很多人事后才意识到，一份完整的系统备份、一套合理的磁盘分区策略，其实比什么都重要。
微软Entra新安全功能引发大规模账户锁定事件
FreeBuf_的博客
04-21 423
微软Entra新安全功能误报致大规模账户锁定，企业用户紧急应对！
C语言动态分配通讯录设计与永久保存数据方法
本文将基于标题“Contact.rar”和描述“C语言通讯录，使用动态内存分配，无空间浪费，可以永久保存数据”，以及标签“C语言通讯录 动态内存 文件调用”来详细解释相关知识点。 ### 知识点一：C语言编程基础 C语言...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值