C语言编程内存分配通讯录静态实现示例代码教程

实现一个通讯录:

通讯录可以用来存储1000个人的信息,每个人的信息包括:姓名、性别、年龄、电话、住址

提供方法:
1. 添加联系人信息
2. 删除指定联系人信息
3. 查找指定联系人信息
4. 修改指定联系人信息
5. 显示所有联系人信息
6. 清空所有联系人
7. 以名字排序所有联系人

首先我们采用顺序表的方式来实现一个通讯录,顺序表就是一种静态的模式。但是呢,静态的方式存在着一些明显的弊端,比如说:(1)信息少了存在空间浪费现象,信息多了存在空间不足的现象;(2)无法对信息进行保存,没有实用性.所以呢,后期会提供动态方式和文件的方式。

为了结构清晰我使用了三个文件来进行封装,Contact.h封装结构体以及函数的声明,test.c封装主函数,Contact.c用来封装函数的算法。

下来进行代码实现:

Contact.h

#define _CRT_SECURE_NO_WARNINGS 1
#ifndef __CONTACT_H__             //防止重定义
#define __CONTACT_H__
#include <stdio.h>
#include <string.h>
#include<stdlib.h>
enum OP
{
	EXIT,
	ADD,
	DEL,
	SEARCH,
	MODIFY,
	DISPLAY,
	SORT,
	CLEAR
};
#define NAME_MAX 20
#define SEX_MAX 5
#define TELE_MAX 12
#define ADDR_MAX 25
#define MAX 1000
typedef struct PerInfo
{
	char name[NAME_MAX];
	int age;
	char sex[SEX_MAX];
	char tele[TELE_MAX];
	char addr[ADDR_MAX];
}PeoInfo;
typedef struct Contact
{
	PeoInfo data[MAX];
	int size;
}Contact,*Pcon;
void init_contact(Pcon pcon);
void _add_contact(Pcon pcon);
void _display_contact(Pcon pcon);
void _del_contact(Pcon pcon);
void _search_contact(Pcon pcon);
void _modify_contact(Pcon pcon);
void _sort_contact(Pcon pcon);
void _clear_contact(Pcon pcon);
#endif 

Test.c

#include "Contact.h"
void menu()
{
	printf("***** 1.add     2.del    ****\n");
	printf("***** 3.modify  4.search ****\n");
	printf("***** 5.display 6.sort   ****\n");
	printf("***** 7.clear   0.exit   ****\n");
}
int main()
{
	Contact con;
	int input = 1;
	init_contact(&con);
	while(input)
	{
		menu();
		printf("请选择>:");
		scanf("%d",&input);
		switch(input)
		{
		case ADD:
			_add_contact(&con);
			break;
		case DEL:
			_del_contact(&con);
			break;
		case SEARCH:
			_search_contact(&con);
			break;
		case MODIFY:
			_modify_contact(&con);
			break;
		case DISPLAY:
			_display_contact(&con);
			break;
		case SORT:
			_sort_contact(&con);
			break;
		case CLEAR:
			_clear_contact(&con);
			break;
		case EXIT:
			break;
		default:
			printf("选择错误\n");
			break;
		}
	}
	return 0;
}

Contact.c

#include"Contact.h"
void init_contact(Pcon pcon)                                     //进行初始化
{
	memset(pcon->data, 0, MAX*sizeof(PeoInfo));
	pcon->size = 0;
}
static int find(Pcon pcon,char arr[])                             //由于在修改,删除,查询的地方都需要查找通讯录的元素,所以对find进行封装
{
	int i=0;
	for(i=0;i<pcon->size;i++)
	{
	    if(strcmp(pcon->data[i].name,arr)==0)
			return i;
	}
	return -1;
}
 void _add_contact(Pcon pcon)
 {
	 if(pcon->size<MAX)
	 {
		 printf("准备添加一个新成员!\n");
		 printf("请输入姓名:");
		 scanf("%s",pcon->data[pcon->size].name);
		 printf("请输入性别:");
		 scanf("%s",pcon->data[pcon->size].sex);
		 printf("请输入年龄:");
		 scanf("%d",&(pcon->data[pcon->size].age));
		 printf("请输入住址:");
		 scanf("%s",pcon->data[pcon->size].addr);
		 printf("请输入联系人电话:");
		 scanf("%s",pcon->data[pcon->size].tele);
		 printf("添加成功!\n");
		 (pcon->size)++;                                      //每添加一个人,通讯录总人数得加1
	 }
	 else
	 {
		 printf("通讯录已经满了!\n");
	 }
 }
void _display_contact(Pcon pcon)
{
   int i=0;
   printf("%s\t%s\t%s\t%s\t%s\n","name","sex","age","tele","addr");
   for(i=0;i<pcon->size;i++)
   {
	   printf("%s\t%s\t%d\t%s\t%s\n",pcon->data[i].name,
		  pcon->data[i].sex,pcon->data[i].age,pcon->data[i].tele,pcon->data[i].addr);
   }
}
void _del_contact(Pcon pcon)
{
	int ret=0;
	char name[NAME_MAX]={0};
	if(pcon->size==0)
	{
		printf("当前通讯录为空!\n");
		return;
	}
	else
	{
		printf("请输入要删除人的姓名:\n");
		scanf("%s",name);
		ret=find(pcon,name);
		if(ret!=-1)
		{
			pcon->data[ret]=pcon->data[(pcon->size)-1];
			pcon->size--;                                    //删除的方法是将数组中最后一个成员移到要删除的成员位置上
                        printf("删除成功!\n");
		}
		else
		{
			printf("未找到要删除的对象!\n");
		}

	}

}
void _search_contact(Pcon pcon)
{
	int ret=0;
	char name[NAME_MAX]={0};
	printf("请输入要查找的人的姓名:\n");
	scanf("%s",name);
	ret=find(pcon,name);
	if(ret!=-1)
	{
	   printf("%s\t%s\t%d\t%s\t%s\t",pcon->data[ret].name,
	   pcon->data[ret].sex,pcon->data[ret].age,pcon->data[ret].tele,
	   pcon->data[ret].addr);
	}
	else
		printf("未找到所要查找的人!\n");
}
void _modify_contact(Pcon pcon)
{
    int select=0;
    int ret=0;
    char modify[20]={0};
    int year=0;
    char name[NAME_MAX]={0};
    printf("请输入要修改的人的姓名:\n");
    scanf("%s",name);
    ret=find(pcon,name);
    if(ret!=-1)
    {
	printf("1.name\n 2.sex\n 3.age\n 4.tele\n 5addr\n");
        printf("请输入要修改的项:");
        scanf("%d",&select);
        switch(select)
        {
        case 1:
	    printf("请输入新的名字:");
            scanf("%s",modify);
            strcpy(pcon->data[ret].name,modify);
            printf("修改成功!\n");
            break;
        case 2:
	    printf("请输入新的性别:");
            scanf("%s",modify);
            strcpy(pcon->data[ret].sex,modify);
            printf("修改成功!\n");
            break;
        case 3:
	    printf("请输入新的电话号:");
            scanf("%s",modify);
            strcpy(pcon->data[ret].tele,modify);
            printf("修改成功!\n");
            break;
        case 4:
	    printf("请输入新的地址:");
            scanf("%s",modify);
            strcpy(pcon->data[ret].addr,modify);
            printf("修改成功!\n");
            break;
        case 5:
            printf("请输入新的年龄:");
            scanf("%s",year);
            pcon->data[ret].age=year;
            printf("修改成功!\n");
            break;
        default:
            printf("修改失败!\n");
            break;
        }
    }
    else
    {
        printf("未找到所要修改的人!\n");
    }
}
void _sort_contact(Pcon pcon)
{
	PeoInfo tmp={0};
	int i=0;
	int j=0;
	int flag=0;        //表示有序
	for(i=1;i<(pcon->size)-1;i++)
	{
		flag=0;
		for(j=1;j<(pcon->size)-i-1;j++)
		{
			if(strcmp((pcon->data[j].name),(pcon->data[j+1].name))>0)

                          tmp=pcon->data[j];
			  pcon->data[j]=pcon->data[j+1];
			  pcon->data[j+1]=tmp;
			  flag=1;
		}
		if(flag==0)
			break;
	}

}
void _clear_contact(Pcon pcon)
{
	pcon->size=0;
	printf("通讯录已清空!\n");
}

以上就是C语言编程内存分配通讯录静态实现示例代码教程的详细内容,更多关于C语言实现静态通讯录的资料请关注我们其它相关文章!

(0)

相关推荐

  • C语言实现静态链表

    本文实例为大家分享了C语言实现静态链表的具体代码,供大家参考,具体内容如下 注意事项: 1.这里用k申请空间,i遍历空间. 2.静态链表是利用游标来模拟指针,把固定分配的内存分成备用链表和链表两大块,在利用自制的malloc和free函数申请释放备用空间时,实现离散存储. 3.基本操作和动态链表实际上差不多,不过一个是利用p = p->next一个是使用i = L[i].cur来实现指针的后移. 4.初始化链表时,链表只有最后一个空间的cur是0, 意味是头指针,并没有任何分配的空间.备用链表的

  • C语言之通讯录的模拟实现代码

    在C语言学习结束之际,谨以此篇文章来对C语言的学习告一段落. 纲要: 通讯录的静态版本 通讯录的动态版本 通讯录的带文件版本 因为三种实现方法除了储存形式不同,其他都基本相同,所以我们重点论述静态版本的实现,以及它们不同的储存方式. 一.通讯录的静态版本 为什么叫它为静态版本呢,因为在此部分的储存是以数组来储存的,那对于各种各样的信息,我们要拿什么数组来存放它呢?当然是结构体数组了,所以我们来定义一个结构体来表示个人信息: //采用宏的目的是方便日后修改 #define NAME_MAX 20

  • C语言模拟实现动态通讯录

    目录 1.模拟实现通讯录总体架构一览图 2.文件执行任务 3.分模块实现 测试模块 test.c 头文件 功能函数声明 contact.h 功能函数逐一实现 1.模拟实现通讯录总体架构一览图 2.文件执行任务 3.分模块实现 测试模块 test.c 1.为了更好地展示,制作一个菜单,在菜单中有 添加,删除,查找,修改,排序,清空,退出的选项. 2.因为起先要进入程序一趟,所以用do····while循环(输入选项来看具体操作,退出还是其他操作) #include "contact.h"

  • C语言编程动态内存开辟实现升级版通讯录教程示例

    目录 前言 一.存放联系人信息 二.通讯录初始化 三.增加联系人 四.销毁通讯录 后记 前言 所谓动态内存开辟的通讯录,就是我需要多少联系人,就给多少联系人,防止给定一个联系人上限,需要增加联系人无法扩容,而联系人没有上限那么多又会造成内存浪费. 本文继之前的静态通讯录作出改进,有兴趣的同学可以看看之前的文章:C语言实现静态通讯录 一.存放联系人信息 这里是用struct PeoInfodata结构体指针指向通讯录,而不再直接 struct PeoInfo data[Max] 用结构体数组定义通

  • C语言实现静态顺序表的实例详解

    C语言实现静态顺序表的实例详解 线性表 定义一张顺序表也就是在内存中开辟一段连续的存储空间,并给它一个名字进行标识.只有定义了一个顺序表,才能利用该顺序表存放数据元素,也才能对该顺序表进行各种操作. 接下来看看静态的顺序表,直接上代码: SeqList.h #define _CRT_SECURE_NO_WARNINGS 1 #ifndef __SEQLIST_H__ #define __SEQLIST_H__ #include <stdio.h> #include <stdlib.h&g

  • C语言编程内存分配通讯录静态实现示例代码教程

    实现一个通讯录: 通讯录可以用来存储1000个人的信息,每个人的信息包括:姓名.性别.年龄.电话.住址 提供方法: 1. 添加联系人信息 2. 删除指定联系人信息 3. 查找指定联系人信息 4. 修改指定联系人信息 5. 显示所有联系人信息 6. 清空所有联系人 7. 以名字排序所有联系人 首先我们采用顺序表的方式来实现一个通讯录,顺序表就是一种静态的模式.但是呢,静态的方式存在着一些明显的弊端,比如说:(1)信息少了存在空间浪费现象,信息多了存在空间不足的现象:(2)无法对信息进行保存,没有实

  • C语言编程中分配内存空间的相关函数

    C语言malloc()函数:动态分配内存空间 头文件: #include <stdlib.h> malloc() 函数用来动态地分配内存空间(如果你不了解动态内存分配,请查看:C语言动态内存分配及变量存储类别),其原型为: void* malloc (size_t size); [参数说明]size 为需要分配的内存空间的大小,以字节(Byte)计. [函数说明]malloc() 在堆区分配一块指定大小的内存空间,用来存放数据.这块内存空间在函数执行完成后不会被初始化,它们的值是未知的.如果希

  • C语言 动态内存分配详解

    C语言 动态内存分配详解 动态内存分配涉及到堆栈的概念:堆栈是两种数据结构.堆栈都是数据项按序排列的数据结构,只能在一端(称为栈顶(top))对数据项进行插入和删除. 栈(操作系统):由操作系统自动分配释放 ,存放函数的参数值,局部变量的值等.其操作方式类似于数据结构中的栈. 堆(操作系统): 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收,分配方式倒是类似于链表. \在C语言中,全局变量分配在内存中的静态存储区,非静态的局部变量(包括形参)是分配在内存的动态存储区,该存储区被

  • C语言动态内存分配函数的实现

    在C中我们开辟内存空间有两种方式 : 1.静态开辟内存 :例如: int a;int b[10]; 这种开辟内存空间的特点是 所开辟的内存是在栈中开辟的固定大小的 ,如a是4字节 ,数组b是40字节 ,并且数组在申明时必须指定其长度 , 如果是全局数组的话,内存是在编译时分配好的,如果是局部变量数组的话,运行时在栈上静态分配内存.不管是全局数组还是局部数组,它们都有一个特点,那就是数组大小是确定的,是代码中写死的.那如果我们想在程序运行时才确定一个数组的大小 , 前两种在栈上分配内存的方法显然是

  • Android NDK开发(C语言--动态内存分配)

    1.C 内存管理函数 C 语言为内存的分配和管理提供了几个函数.这些函数可以在 <stdlib.h> 头文件中找到. 序号 函数和描述 1 void calloc(int num, int size); 在内存中动态地分配 num 个长度为 size 的连续空间,并将每一个字节都初始化为 0.所以它的结果是分配了 numsize 个字节长度的内存空间,并且每个字节的值都是0. 2 void free(void *address); 该函数释放 address 所指向的内存块,释放的是动态分配的

  • C语言动态内存分配的详解

    C语言动态内存分配的详解 1.为什么使用动态内存分配 数组在使用的时候可能造成内存浪费,使用动态内存分配可以解决这个问题. 2. malloc和free C函数库提供了两个函数,malloc和free,分别用于执行动态内存分配和释放. (1)void *malloc(size_t size); malloc的参数就是需要分配的内存字节数.malloc分配一块连续的内存.如果操作系统无法向malloc提供更多的内存,malloc就返回一个NULL指针. (2)void free(void *poi

  • c语言动态内存分配知识点及实例

    c语言怎么实现动态内存分配 我们经常会预先给程序开辟好内存空间,然后进行操作. int arr[5] ; 对这个数组我们在定义的时候必须给提前开辟好空间,并且在程序执行的过程中,这个开辟的内存空间是一直存在的,除非等到这个函数执行完毕,才会将空间释放.有个问题就是这个数组在程序中无法被修改. 这些问题给我们造成了一些使用上的不方便,所以,C中提供了malloc()函数. 关于malloc()函数,这个函数它接受一个参数:就是所需的内存的字节数.然后malloc()找到可用内存中那一个大小适合的块

  • C语言编程gcc如何生成静态库.a和动态库.so示例详解

    目录 一.什么是静态库和动态库 二.gcc生成.a静态库和.so动态库 1.生成静态库(.a) 1.1编辑生成例子程序hello.h.hello.c和main.c 1.2将hello.c编译成.o文件 1.3由.o文件创建静态库 1.4在程序中使用静态库 1.5验证静态库的特点 2.生成动态库(.so) 2.1由.o文件创建动态库文件 2.2在程序中使用动态库 三.实例 1.实例1 1.1代码 1.2 静态库.a文件的生成与使用 1.3 动态库.so文件的生成与使用 2.实例2 2.1代码 2.

  • C语言实现简易通讯录(静态版本)的代码分享

    目录 一.通讯录 1.演示效果 2.完整代码 二.代码解析 1.宏定义及结构体声明 2.主菜单函数 3.主函数 4.查找函数 5.初始化联系人信息 6.添加联系人信息 7.显示所有联系人信息 8.删除指定联系人信息 9.修改联系人信息 10.查找指定联系人 11.按照姓氏对联系人信息排序 12.清空所有联系人信息 一.通讯录 1.演示效果 2.完整代码 #define _CRT_SECURE_NO_WARNINGS 1 //#include "ConTacts.h" #include

  • C语言动态内存管理malloc柔性数组示例详解

    目录 1.1为什么存在动态内存管理 1.2动态内存管理函数 1.2.1malloc 1.2.2free 1.2.3calloc 1.2.4realloc 1.3动态内存管理函数易错点 1.3.1对NULL指针的解引用操作 1.3.2对动态开辟空间的越界访问 1.3.3对非动态开辟内存使用free释放 1.3.4使用free释放一块动态开辟内存的一部分 1.3.5对同一块动态内存多次释放 1.3.6动态开辟内存忘记释放(内存泄漏) 2.1常见相关笔试题 2.2C/C++语言中的内存开辟 2.3柔性

随机推荐