C语言：通讯录程序设计（多功能）

竹等寒

已于 2023-01-01 14:05:36 修改

阅读量1.9k

点赞数 3

分类专栏： C语言文章标签： c语言开发语言

于 2022-12-31 14:17:00 首次发布

本文链接：https://blog.csdn.net/weixin_60521036/article/details/128504591

版权

C语言专栏收录该内容

41 篇文章 4 订阅

订阅专栏

回顾我的代码shi

通讯录程序设计

通讯录程序设计

作者前言：该通讯录作品是我大一的C语言结课作业，代码像shi山一样，之所以拿出来是想回忆一下我当时的想法和想结合一下我现在所学看能否有一些更新颖的想法碰撞出来，同时也会发出没有修改过的源代码。

注意：该代码是按照我们学校的机房的台式电脑配置来写的，如果是在自己的手提电脑上很大概率会出现界面混乱的情况。
总共69个函数（其中可能有一些没啥用，所以大家图个乐，运行一下也可以，主要是我记录一下我的顿悟过程，总结反思一下）

主函数

程序中的主函数结构（使用了四个函数）

while(1)
	{
	Reflush_Main(); //清屏后刷新联系人信息
	ShowMeun(); //打印主菜单
	Choice_Fun_num(Function_Meun_num); //选择菜单功能
	Realize_Function(choice_num); //实现选择后的功能
	}

解释：

第一个函数是清屏然后刷新联系人信息，因为在C语言程序中，我没有使用其他工具做界面，只使用了我们常用的黑窗口直接手动打印界面，又因为我需要做的是一个联系人信息实时修改的效果，我按下确定键之后联系人信息能够直接在信息窗口得到修改效果。
第二个函数是打印主菜单，其实不难，就是定位有点难。函数里面的定位使用到的函数是SetPosition(x,y); 该函数不是导入头函数里面直接用的，是自己写出来的一个函数，我也是在网上扒到的代码。然后通过这个函数定位自己需要的地方慢慢打印出自己需要的菜单功能即可。
第三个函数选择菜单功能，这个功能就纯纯的为后面实现功能而做的，因为choice_num是一个全局变量（现在看来是毫无意义），然后在函数里面可以直接给这个变量进行操作赋值。但是在做这个函数的时候我第一次感受到了
第四个函数通过在第三个函数将choice_num进行赋值之后判断选择的是哪一个功能然后实现对应的功能效果。

遇到的困难

首先我在写程序过程中遇到的必然是学校机房在单独将菜单清除再重新打印的时候会发生乱码的现象，这个原因我到现在还不明白，因为进入程序他不会乱，只有在我开始进行输入输出的时候就一下子乱了，所以我最后也是想到了要不直接将所有打印出来的都清掉重新打印，然后就有了现在这个刷屏这函数，所以也让我后面在写添加联系人和修改联系人的时候想到了我能让用户看到实时修改的效果。
多说一句：置顶功能是模仿微信的置顶功能，因为我是通过微信置顶功能想要看看我自己能不能进行实现出来。这个功能是我比较引以为豪的。算法也就是用的链表。
后面功能就不做进一步介绍了，因为我也忘得差不多了。

补充标注说明（一定要看）

上面提到会乱，我在这里修改一下，因为是窗口大小问题，宽度不够导致的排版问题。
需要要把窗口宽度改为130才行
步骤1：鼠标右键单击窗口上方
在这里插入图片描述
步骤二：进入默认值那里
步骤三：将宽度改为130或者以上

这样就可以保证我的代码不会乱了。

重点来了，文件夹安放位置

只需要新建一个文件夹即可，放在D盘位置，直接放在D盘下，不要放进其他D盘里面文件夹，或者你可以找到我代码里面的地址进行修改存放位置
存放一个名字叫Contact_D的文件夹
在该文件夹里面存放txt文件，名字随便起，但是里面存放的联系人也有规范
比如下面的：一定要按照这种格式来存放（比较死板）

在这里插入图片描述

效果展示截图

在这里插入图片描述

必须先导入自己存放的联系人信息也就是文件夹里面的txt文件
这时候就可以直接选择浏览联系人了，这个功能可以关闭或者开启，开启就是实时显示。
增删查改就不展示了，展示一个置顶功能

选择1才开始选择置顶功能，因为我要给用户一个返回上一级的机会。

进入之后选择1鼠标会自动跳到（1），让你置顶联系人的序号，这时候不用怕忘记了哪个，因为我在选择浏览联系人功能的时候，我的下方可以实时观看到联系人信息（除非关闭了浏览联系人这个功能）

后面就是可以选择置顶谁就选择谁的序号即可。
保存通讯录功能是保存在你在D盘下新建的Contact_D 那个文件夹里面，也就是你导入的那个txt文件进行修改保存下来的，还是在那个txt文件下修改而已。

结语

其他功能有待大家自己探索，我写了很多功能，就不展示了，我觉得蛮有趣的一个程序，虽然像屎山一样的代码，但还是有很多地方值得自己自豪的地方。

程序源代码

因为当时我以为不可以分开文件写，所以全部代码只写到了一个文件里面，所以比较繁杂，不过对于新手来说刚好，不用学习如何分开头文件源文件这些。

#include<stdio.h>
#include<windows.h>
#include<stdlib.h> 
#include<string.h>
#include<conio.h>
#include<direct.h>
#include<stdbool.h>
#include<io.h>
#include<math.h>
 
#define PF(format,...) printf(#format,##__VA_ARGS__) 
#define P 1 //控制界面的Y坐标，会影响整个界面 
#define Interface_X 68 //欢迎坐标
#define Fix_X_coord 56 //打印功能信息 X 坐标，也是全部打印信息都会随着这个改变而改变，后面的X坐标的宏定义都会跟这个有关 

//文件名和地址
#define Direc_Locate "D:/Contact_D/"
char *to_search="D:/Contact_D/*.txt"; //欲查找的文件，支持通配符 ,找文件夹的地址
char Friend_Contact_txt[20] = "  "; //不用宏定义，因为向让用户来选择文件进行导入和操作  = "D:/Contact_D/woding.txt"
int File_num;//接收文件数量 
char *New_Friend_Contact_txt = "D:/Contact_D/new_contacts.txt"; //用户直接新建联系人的时候要导出的新的文件 
char Ordinal[20] = " ";
//功能菜单区域 
#define PF_Function_Line PF(*--------------------------------------*)
#define Function_Meun_num 9//菜单个数 
#define Function_Infor_num P+3+Function_Meun_num //该坐标是 “请选择功能 ” 的区域Y坐标，会随着上面菜单个数增加而增加，修改的一般也是菜单个数 


//浏览联系人打印区域 
#define PF_ContactInfor_Line PF(*---------------------------------------------------------------------------------------------*)
#define PF_Contact_Divid_Line PF(-----------------------------------------------------------------------------------------------)
#define PF_Contact_line 30 //联系人框架线条开始打印的 X 坐标 
#define PF_Contact_Start_Y Function_Infor_num + 3//打印信息区域 Y坐标 ,是 | 打印开始的坐标 
#define PF_Contact_Ordinal_X Fix_X_coord-25//
#define Name_X  Fix_X_coord-20 //姓名 X 坐标 
#define Origin_X Name_X+13//籍贯 X 坐标 
#define Phone_num1_X Origin_X+24 //电话 1 X 坐标 
#define Phone_num2_X Phone_num1_X+15//电话 2 X 坐标 
#define Mailbox_X Phone_num2_X+15 //邮箱 X 坐标 
int Contact_num = -1;//联系人数量 ，不能宏定义，因为文件中联系人数量是随时改变的,-1是因为表头不是信息，而是表头内容 

//全局变量
/*选择功能*/
char choice_num;
char recive_enter;//接收回车键或者其他多余按键 
int File_index = 0;//记录每一个文件的下标 
bool Init_open = false;//如果没有进入导入文件数据，需要创建一个表头 ，不然用户直接创建新的联系人就会没有表头提示哪些是什么信息 
bool Import_open = false;//导入数据的开关 
bool Browse_open = false;//用户是否要浏览的开关，点一次开启浏览，再点一次关闭浏览 
bool Save_open = false;//导出开关 
bool NEW_Contact_Link = false;//直接新建联系表的开关， 

/*文件名单链表*/
struct File_Infor{
	char filename[100];
	int index;
	struct File_Infor *next;
};
struct File_Infor *fnameclub = NULL;//存放文件名的单链表头 

//联系人信息 
typedef struct _Contact{
	char Ordinal[5];//序号 
	char Name[15];//姓名 
	char Origin[20];//地址 
	char Phone_num1[15];//电话1 
	char Phone_num2[15];//电话2 
	char Mailbox[25];//邮箱 
	struct _Contact *next;//节点 
}Contact, *LinkContact;
Contact *Friend = NULL;//初始化链表的时候会开辟一个带头的链表，存放表头内容 


//辅助功能函数 
/************************************/ 

void SetPosition(int, int);
void Limit_Contact_capacity(char *Contact_detail, int num, int x, int y);//限制空间大小 
bool Judge_chinese_and_English(char *Contact_detail);
bool Judge_chinese(char *Contact_detail);//判断是否全为中文字符 
bool Judge_num(char *Contact_detail);//判断字符串是否全为数字
bool Judge_Mailbox(char *Contact_detail);//判断邮箱是否正确，邮箱有三个部分组成 
void ShowFrame();
void ShowMeun(); 
void ClearMeun();
void Reflush_Main();
void Choice_Fun_num();
void Release_Contact(LinkContact *Friend); 

/******************************/ 


//功能 1
/***************************************/ 

void Function_one();
void Import_date(LinkContact *,FILE*);//把文件数据导入顺序表 
void Import_date_TWO(LinkContact *Friend, FILE *fp);
void PutIn_to_Singlelink(char *filename, struct File_Infor **fnameclub); 
int  Save_Allfilename_return_nums(struct File_Infor **fnameclub, char *);//寻找文件目录下多少个文件 
void PF_filename(struct File_Infor **fnameclub, int File_num);
char *Find_Filename(struct File_Infor *, char);
void Choice_TXT(char *Friend_Contact_txt);
void Release_Filename(struct File_Infor **fnameclub);

/***********************/ 

//功能 2
/*********************************/ 

void Function_two();
void Show_Input_Contact(); 
bool OR_Input_Contact();//判断是否进入新建联系人
bool Judge_re_Phone(LinkContact, char*);//判断电话号码是否重复 
bool Judge_re_Mailbox(LinkContact,char*);//判断邮箱是否重复 
void Init_Contact(LinkContact *);//如果没有导入的话就是需要创建一个新表 
void Add_Contact(LinkContact *);
void Input_Contact_detail_Name(LinkContact temp);
void Input_Contact_detail_Origin(LinkContact temp);
void Input_Contact_detail_Phone_num1(LinkContact temp);
void Input_Contact_detail_Phone_num2(LinkContact temp);
void Input_Contact_detail_Mailbox(LinkContact temp); 
void Input_Contact(LinkContact *);//链表表尾，输入新的联系人信息  
void Add_Contact_special_Ordinal(LinkContact *, char*);
void Input_Contact_special_Ordinal(LinkContact *,char*);
/*******************************/ 

//功能 3
/**************************************/ 

void Function_three();
void Browse_Contact(LinkContact);
void PF_STRUCT_Contact(LinkContact, int);//把联系人结构体输出 

/**************************************/ 

//功能 4
/*****************************************/ 

void Function_four();
void Show_SearchMeun();
void Search_Contact();//包含多种搜索功能 
LinkContact Find_Contact_Ordinal(LinkContact,  char *);//按照序号搜索 ，返回对应的结构体地址 
LinkContact Find_Contact_Name(LinkContact, char *);//按照名字搜索 
LinkContact Find_Contact_Origin(LinkContact,  char *);//按照籍贯地址搜索 

/*****************************************/ 


//功能 5
/****************************************/ 

void Function_fine();
void Show_ReviseMeun();
bool OR_Revise_Contact();//判断是否进入修改联系人信息
void Revise_Contact();//修改信息
void Revise_Name(LinkContact*, char *ch);
void Revise_Origin(LinkContact*, char *ch);
void Revise_Phone_num1(LinkContact*, char *ch);
void Revise_Phone_num2(LinkContact*, char *ch);
void Revise_Mailbox(LinkContact*, char *ch);

/***************************************/ 

//功能 6
/*********************************/ 

void Function_six();
void Delete_Contact_Choice();//删除信息
void Delete_in_bulk();//循环批量删除 
void Destroy_LinkContact_1(LinkContact *Friend, char *);
void To_sort_again(LinkContact *Friend, char *);//再次对序号进行排序 
 
/**********************************/ 

//功能 7
/*****************************************/ 

void Function_seven();
void Save_Contact(LinkContact *Friend, FILE *fp);//保存链表数据到文件中 

/*****************************************/ 

//功能 8
void Function_eight(); 
void Love_Choice();
void Love_in_bulk();
void Love_Contact(LinkContact *Friend, char *num); 
void To_Love_sort_again(LinkContact *Friend, char *Ordinal);

//退出功能 
/****************************************/ 

void Function_end();
void Show_EndFrame();
void Show_EndMeun();
/********************************************/ 

//功能实现结构
void Realize_Function(char);



int main(void)
{
	system("mode con cols=160 lines=300 ");//控制终端大小
	system("cls");
	SetPosition(Fix_X_coord, Function_Infor_num);
	PF(食用提醒->保证导入的文件是用ANSI编码。(*￣︶￣)！);
	SetPosition(Fix_X_coord, Function_Infor_num+2);
	PF((*^▽^*)望使用愉快！);
	SetPosition(Fix_X_coord, Function_Infor_num+4);
	system("pause");
	while(1)
	{
	Reflush_Main(); 
	ShowMeun(); 
	Choice_Fun_num(Function_Meun_num);
	Realize_Function(choice_num); 
	} 
	
	return 0;
 } 


/*-------------------------------------------------辅助 功能--------------------------------------------------------*/ 

void SetPosition(int x, int y)//光标定位 
{
	HANDLE winHandle;//句柄
	COORD pos = {x, y};
	winHandle = GetStdHandle(STD_OUTPUT_HANDLE);
	//设置光标的坐标 
	SetConsoleCursorPosition(winHandle, pos);	
 } 
 
void Release_Contact(LinkContact *Friend)//释放动态分配内存的链表 
{
	LinkContact temp;
	while((*Friend) != NULL)
	{
		temp = *Friend;
		*Friend = (*Friend)->next;
		free(temp);
	 } 
	 //(*fnameclub) = NULL;//把链表指向NUll，以便于再次初始化对保存的文件名进行操作 
	 
} 

/*用来判断输入的大小，XY是坐标表示在哪输入的地方，划重点了，
第一个参数必须必须是数组，或者说有空间的内存，不能直接char* ,
必错，已经经历过来的 */ 
void Limit_Contact_capacity(char *Contact_detail, int num, int x, int y) 
{
	char ch[50]; 
	int i = 0;
//	SetPosition(x, y);
//printf("                         ");
	SetPosition(x, y);
	ch[i] = getch();//单个字符的输进去
	
	while(ch[i] == '\n' || ch[i] == '\r' || ch[i] == 8)//针对用户直接就输入回车的 
	{
		SetPosition(x, y);
		printf(" ");
		SetPosition(x, y);
		ch[i] = getch();
	}
	putchar(ch[i]);
	while(1)
	{
		i++;
		if(i>=num) //因为从0 开始，所以到了11个的时候，也就是第十二个，直接把第十二个赋值为\0 
		{
			ch[i] = '\0';//转换成字符串,不能是i+1去转换，因为会出现乱码。不信你试试 
			break;
		 } 
		ch[i] = getch();//单个字符的输进去,即输即出函数是getche 
		if(ch[i] == '\n' || ch[i] == '\r')
		{
			ch[i] = '\0';//转换成字符串 
			break;//遇到回车键就退出录入
		}
		putchar(ch[i]);
		if(ch[i] == 8 && i>0)
	{
		while(1)
		{
			//ch[i] = ' ';
			i--;
			SetPosition(x+i, y);
			printf(" ");
			SetPosition(x+i, y);
			if(i <= 0) break;
			ch[i] = getch();//单个字符的输进去,即输即出函数是getche 
			if(ch[i] != 8) 
			{
				putchar(ch[i]);
				break;
			}	
		}
		fflush(stdin);
		i--;
	}
		
	} 
	strcpy(Contact_detail, ch); 
	
}

bool Judge_chinese_and_English(char *Contact_detail)
{
	/*
	|| (Contact_detail[i] > 0 && Contact_detail[i] < 65) || (Contact_detail[i] > 90 && Contact_detail[i] < 97)
			 || (Contact_detail[i] > 122 && Contact_detail[i] < 128)
	
	*/
	
	//范围128——255是中文
	int i; 
	for(i = 0; i < strlen(Contact_detail) ;i++) 
	{//这个范围内是中文字符之外的字符，如果条件为真，就代表含有不是中文的东西 
		if ((!(Contact_detail[i] > 64 && Contact_detail[i] < 91) && !(Contact_detail[i] > 96 && Contact_detail[i] < 123)) 
			&& (Contact_detail[i] > 33 && Contact_detail[i] < 127) || Contact_detail[i] == ' ') return false;
	 } 
	 return true;
} 

bool Judge_chinese(char *Contact_detail)//判断是否全为中文 
{
	//范围128——255是中文
	int i;
	for(i = 0; i < strlen(Contact_detail) ;i++)
	{//这个范围内是中文字符之外的字符，如果条件为真，就代表含有不是中文的东西 
		if (Contact_detail[i] > 33 && Contact_detail[i] < 127|| Contact_detail[i] == ' ')
		{
			return false;//但凡有一个不是中文就返回错[0x4e00,0x9fa5]
		}
	 } 
	 return true; 
 } 

bool Judge_num(char *Contact_detail)
{
	int i;
	
	for(i = 0; i < strlen(Contact_detail); i++)
	{
		if(Contact_detail[i]-'0' < 0 || Contact_detail[i]-'0' > 9|| Contact_detail[i] == ' ') return false; 
	}
	if(strlen(Contact_detail) < 5) return false;//最短不能短过5位 
	return true;
}



bool Judge_Mailbox(char *Contact_detail)
{
	//邮箱有三个部分，第一部分随便，第二部分是@符号，第四部分是必须含有.com，还有就是不能含有中文符号 
	//所以三部分都必须有，两部分单独拿出来对比
	int i, j;
	int open = -1;
	//如果没有非法字符，就继续判断是否符合邮箱的字符
	for(i = 0; i < strlen(Contact_detail) ;i++)
	{
	if((Contact_detail[i]-'0'<0||Contact_detail[i]-'0'>9)&&(Contact_detail[i]<64||Contact_detail[i]>90)&&
	Contact_detail[i] != '.'&&Contact_detail[i] != '_'&&Contact_detail[i] != '-'&&Contact_detail[i] != '@'
	&&(Contact_detail[i]<97||Contact_detail[i]>122) || Contact_detail[i] == ' ') return false;
	//这个大判断语句是判断是否为符合的符号,就是起码先判断是不是能用的符号 
	}
	for(i = 0; i < strlen(Contact_detail) ;i++)
	{
		if(Contact_detail[i] == '@'&&i!=0)
		{
			i++;
			if(Contact_detail[i]=='.') return false;
			for(;Contact_detail[i];i++)
			{
				if(Contact_detail[i]=='.')
				{
					for(j = i+1; j < strlen(Contact_detail); j++)
					{
						if((Contact_detail[j]-'0'< 0||Contact_detail[j]-'0'>9)&&(Contact_detail[j]<64||Contact_detail[j]>90)&&
						Contact_detail[i] != '.' &&	Contact_detail[j] != '_'&&Contact_detail[j] != '-'
						&&(Contact_detail[j]<97||Contact_detail[j]>122) || Contact_detail[j] == ' ') return false;
						
					}
//					if(Contact_detail[i+1] == 'c' && Contact_detail[i+2] == 'o' && Contact_detail[i+3] == 'm') if( j==strlen(Contact_detail) )
					 return true;
				}
				//else return false;
				
			}
		}
	} 
	return false;//如果没通过上面的重重难关，就代表不行，错误格式 
	 
}

void Reflush_Main()
{
	system("cls");
	if(Browse_open == true) Browse_Contact(Friend);	
	ShowFrame();
}

void ShowFrame()
{
 	SetPosition(Interface_X, P);
 	PF(*￥欢迎界面￥*);
 	SetPosition(Fix_X_coord-1, P+1);
 	PF_Function_Line;
 	SetPosition(Fix_X_coord, Function_Infor_num-1);
 	PF(--------------------------------------);
 	SetPosition(Fix_X_coord, Function_Infor_num);
 	printf("->请输入："); 
 	int i;
 	for(i = P; i < Function_Infor_num; i++)
 	{
 		SetPosition(Fix_X_coord-1, i+2);
 		PF(|);
 		SetPosition(Fix_X_coord+38, i+2);
 		PF(|);
	 }
	SetPosition(Fix_X_coord-1, Function_Infor_num+1);
 	PF_Function_Line;
}

void ShowMeun()
{
	SetPosition(Fix_X_coord, P+2);
 	PF(（1）导入通讯录文件);
 	SetPosition(Fix_X_coord, P+3);
 	PF(（2）新建联系人);
 	SetPosition(Fix_X_coord, P+4);
 	PF(（3）浏览联系人(开/关));
 	SetPosition(Fix_X_coord, P+5);
 	PF(（4）搜索联系人);
 	SetPosition(Fix_X_coord, P+6);
 	PF(（5）修改联系人);
 	SetPosition(Fix_X_coord, P+7);
 	PF(（6）删除联系人);
 	SetPosition(Fix_X_coord, P+8);
 	PF(（7）保存通讯录);
 	SetPosition(Fix_X_coord, P+9);
 	PF(（8）置顶联系人);
 	SetPosition(Fix_X_coord, P+10);
 	PF(（9）退出程序);
}

void ClearMeun()
{
	int i;
	for(i = 0; i < Function_Meun_num; i++)
	{
		SetPosition(Fix_X_coord, P+2+i);
		printf("                                      ");
	}
	 
}

void Choice_Fun_num(int Meun_num)
{
	SetPosition(Fix_X_coord+10, Function_Infor_num);
	printf(" ");
	SetPosition(Fix_X_coord+10, Function_Infor_num);
	choice_num = getchar();
	char ch;
	while(1)
	{
		while(choice_num == '\n')//针对用户直接就输入回车的 
		{
			SetPosition(Fix_X_coord, Function_Infor_num);
			printf("                                      ");
			SetPosition(Fix_X_coord, Function_Infor_num);
			printf("->请输入：");
			choice_num = getchar();
		}
		recive_enter = getchar();//接收空格键 
		if(choice_num-'0' > 0 && choice_num-'0' <= Meun_num && recive_enter == '\n')
		{
			SetPosition(Fix_X_coord, Function_Infor_num);
			printf("                                      ");
			SetPosition(Fix_X_coord, Function_Infor_num);
			printf("->请输入：%c", choice_num);
		 	break;
		 }
		fflush(stdin);//清空缓冲区 
		SetPosition(Fix_X_coord, Function_Infor_num);
		printf("                                      ");
		SetPosition(Fix_X_coord, Function_Infor_num);
		printf("->输入有误：");
		choice_num = getchar();
	}
	
}

void Realize_Function(char choice_num)
{
	switch(choice_num)
	{
		case '1':
			//还未导出但是导入了数据就不能选择文件 
			if(Save_open == false && Import_open == true || NEW_Contact_Link == true && Save_open == false) 
			{
			system("cls");
			SetPosition(Fix_X_coord, Function_Infor_num);
			PF(未导出文件！);
			SetPosition(Fix_X_coord, Function_Infor_num+1);
			system("pause");
			}
			else
			{
				Function_one();
			 } 
			break;
		case '2':
			while(OR_Input_Contact())
			{
				Function_two(); 
			} 
			break;
		case '3':
			if(Friend!=NULL) Function_three();
			else{
				system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(通讯录为空！);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");
			}
			break;
		case '4':
			if(Friend!=NULL)Function_four();
			else{
				system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(通讯录为空！);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");
			}
			break;
		case '5':
			if(Friend!=NULL)
		{
			while(OR_Revise_Contact())Function_fine();
		}	 
		else{
			system("cls");
			SetPosition(Fix_X_coord, Function_Infor_num);
			PF(通讯录为空！);
			SetPosition(Fix_X_coord, Function_Infor_num+1);
			system("pause");
			}
			break;
		case '6':
			if(Friend!=NULL)Function_six();
		else
		{
			system("cls");
			SetPosition(Fix_X_coord, Function_Infor_num);
			PF(通讯录为空！);
			SetPosition(Fix_X_coord, Function_Infor_num+1);
			system("pause");
		}
			break;
		case '7':
			if(Friend!=NULL) Function_seven();
			else
			{
				system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(通讯录为空！);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");
			}
			break;
		case '8':
			if(Friend!=NULL) Function_eight();
			else
			{
				system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(通讯录为空！);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");
			}
			break;
		case '9':
			Function_end();
			break;
	}
}

/*-----------------------------------------------------------------------------------------------------------------*/




/*---------------------------------------------------功能 1--------------------------------------------------------*/ 

void Function_one()
{
	Save_open = false;//因为进来之前有一个判断一个是在未导出且导入文件了的是不会进来，所以只要能进来，立马把 导出开关关掉，代表已经换文件了。 
	char ch;
	system("cls");
	if(Browse_open == true) Browse_Contact(Friend);
	ClearMeun();
	ShowFrame(); 
	Choice_TXT(Friend_Contact_txt);
//	if(Save_open == true && Import_open == true)//先判断是否换文件了，因为要把之前导入的通讯录链表清空 
//	{
//		Save_open = false;//代表已经导出且换了通讯录文件了 ，立马关掉导出开关 
//		if(Friend != NULL) 
//	{
//		Release_Contact(&Friend); 
//	} 
//	}
	//注意File_num 不用置为0，因为每次进入都会变，是用搜索文件名的时候返回给他的个数，所以每次搜索都会随着文静个数变化
	if(choice_num-'0' != File_num+1) 
	{
	FILE *fp = NULL;
	fp = fopen(Friend_Contact_txt,"r");
	if(fp==NULL) exit(1);
	Import_date(&Friend, fp);
	//Import_date_TWO(&Friend, fp);
	fclose(fp);
	system("cls");
	SetPosition(Fix_X_coord, Function_Infor_num);
	PF(导入成功);
	SetPosition(Fix_X_coord, Function_Infor_num+1);
	system("pause");
	system("cls");
	Import_open = true; //表示导入数据了
	} 
	
	 
	 
}

int Save_Allfilename_return_nums(struct File_Infor **fnameclub,char *to_search)//保存目录所有文件名到单链表中 ，并返回文件数量
{
	int i = 1;
	long handle; //用于查找的句柄
	struct _finddata_t fileinfo; //文件信息的结构体 
	handle=_findfirst(to_search,&fileinfo); //第一次查找 ，to_search是寻找的文件夹目录 
	if(-1==handle) return -1;
	PutIn_to_Singlelink(fileinfo.name, fnameclub); 
	while(!_findnext(handle,&fileinfo)) //循环查找其他符合的文件，知道找不到其他的为止 
	{ 
		PutIn_to_Singlelink(fileinfo.name, fnameclub);
		i++;
	} 
	return i;
} 

void PutIn_to_Singlelink(char *filename, struct File_Infor **fnameclub)//把文件名放到单链表中，尾插法 
{
	struct File_Infor *new_name = NULL; //分配新空间存放文件名 
	struct File_Infor *temp = NULL;
	new_name = (struct File_Infor*)malloc(sizeof(struct File_Infor));
	if(new_name == NULL)
	{
		PF(申请空间失败\n);
		exit(1); 
	}
	if(*fnameclub == NULL)
	{
		*fnameclub = new_name;
		new_name->next = NULL;
		strcpy(new_name->filename, filename);//把文件名录入单链表
		new_name->index = ++File_index;//记录该文件的下标 ，这里是第一个，，因为初始下标为0，所以先自加 
	}
	else //尾插法 
	{
		//尾插法 **********************
		temp = *fnameclub;
		while(temp->next != NULL)
		{
			temp = temp->next; 
		} 
		temp->next = new_name;
		new_name->next = NULL;
		/*****************************/ 
		strcpy(new_name->filename, filename);//把文件名录入单链表
		new_name->index = ++File_index;//记录该文件的下标 
		
	}
}

void PF_filename(struct File_Infor **fnameclub, int File_num)//打印文件名 和选项框架 
{
	int i = 0;
	struct File_Infor *temp;
	temp = *fnameclub;
	SetPosition(Fix_X_coord, P+2);
	PF(文件序号：); 
	while(i<File_num)
	{
		if(temp != NULL)
		{
			SetPosition(Fix_X_coord, P+2+i+1);
			PF(%d：%s,temp->index, temp->filename);
			temp = temp->next;
			i++;
		}
		else break;
			
	}
	SetPosition(Fix_X_coord, P+2+i+1);
	PF(%d：退出选择,File_num+1);
	File_index = 0;//至为零 ，方便后面刷新界面的时候后再次打印文件名，就不会变成追加的序号，而是重新开始；因为这个是全局变量 
}

void Release_Filename(struct File_Infor **fnameclub)//释放动态分配内存的链表 
{
	struct File_Infor *temp;
	while((*fnameclub) != NULL)
	{
		temp = *fnameclub;
		*fnameclub = (*fnameclub)->next;
		free(temp);
	 } 
	 //(*fnameclub) = NULL;//把链表指向NUll，以便于再次初始化对保存的文件名进行操作 
	
} 

char *Find_Filename(struct File_Infor *fnameclub,char choice_num)
{
	
	while(fnameclub!=NULL)
	{
		if(fnameclub->index == choice_num-'0') break;
		fnameclub = fnameclub->next;
	}
	return fnameclub->filename;
 } 
 
void Choice_TXT(char *Friend_Contact_txt)
{
	char *ch;
	if(fnameclub!=NULL) Release_Filename(&fnameclub); //每次搜索文件目录之前把之前残留着的文件名链表信息，然后才能进行对目录再次进行搜索 
	File_num = Save_Allfilename_return_nums(&fnameclub,to_search);
	PF_filename(&fnameclub,File_num);
	Choice_Fun_num(File_num+1);//加一是因为要额外加一个退出选择文件功能 ，因为用户想要直接新建联系人的话可以不用导入 
	//下面是把文件前缀和文件名拼起来，造出一个完整的文件路径
	if(choice_num-'0' != File_num+1)//判断是否选择了退出选择文件，没选才进入，选了就不进入，直接返回到功能实现那边进行退出选择功能 
	{
		ch = Find_Filename(fnameclub,choice_num);
		strcpy(Friend_Contact_txt,Direc_Locate);
		strcat(Friend_Contact_txt, ch);
	}
	
	
}

void Import_date(LinkContact *Friend, FILE *fp)
{
	//需要写两种导入模式，一种是直接导入结构体，另一种是按照一个一个字符的读进去
	 
	/*第一种*/ 
	char ch; 
	int i = 0;
	 Add_Contact(Friend); //无论是否为空，为空就先加一个，否则也要加一个新空间，不然下面就是不能读进去 
	LinkContact temp = (*Friend);
	 while(temp->next != NULL) temp = temp->next;//先找到尾部进行录入，因为不一定就是新导入数据
	while(1)
	{
		//fread(temp, sizeof(Contact),1,fp);
		fscanf(fp,"%s%s%s%s%s%s", temp->Ordinal,temp->Name,temp->Origin,temp->Phone_num1,temp->Phone_num2,temp->Mailbox);
	
	//导入的时候下面的形式是错误的，文件读取的时候，不需要格式，只要是字符或者整型就行，不需要加-15之类
	//下面的形式，这些只是在写进去的时候排版需要用到而已 
//		fscanf(fp,"%-4s", temp->Ordinal);
//		fscanf(fp,"%-15s", temp->Name);
//		fscanf(fp,"%-15s", temp->Origin);
//		fscanf(fp,"%-15s", temp->Phone_num1);
//		fscanf(fp,"%-15s", temp->Phone_num2);
//		fscanf(fp,"%-30s", temp->Mailbox);
		ch = fgetc(fp); //吃掉文件中的回车键  
		if(feof(fp)) break;//单独拿出来，防止后面继续开辟空间 
		Add_Contact(Friend);//增加空间  if(temp->next == NULL) 
		temp = temp->next; 
	}

	//因为结构体里面还有一个是节点，也会把他录进去，所以会再次创建多一个空间，所以要把最后一个销毁掉，同时也要把空间数量减一，也就是联系人减一 
	//所以在这个需要把最后一个空间销毁掉
	char tail[5];
	itoa(Contact_num, tail, 10);
	Destroy_LinkContact_1(Friend, tail);//第一个销毁函数是指定销毁哪个位置上的空间 
	Contact_num--;

	/*第二种*/
	//直接单个字符或者字符串进行导入
//	char ch;
//	while(!feof(fp))
//	{
//		ch = fgetc(fp);
//		if(ch == ' ')
//		{
//			
//		 } 
//	 } 

//*******************************不用第二种了，这一种已经完全搞定了，上面这种更快捷方便，直接读取字符串************************************** 






} 

void Import_date_TWO(LinkContact *Friend, FILE *fp)
{
	//需要写两种导入模式，一种是直接导入结构体，另一种是按照一个一个字符的读进去
	 
	/*第一种*/ 
	char ch; 
	int i = 0;
	 Add_Contact(Friend); //无论是否为空，为空就先加一个，否则也要加一个新空间，不然下面就是不能读进去 
	LinkContact temp = (*Friend);
	//temp = temp->next; 
	while(!feof(fp))
	{
		
		//fscanf(fp,"%s%s%s%s%s%s", temp->Ordinal,temp->Name,temp->Origin,temp->Phone_num1,temp->Phone_num2,temp->Mailbox);
		i = 0;
		while(!feof(fp))
		{
			//ch = fgetc(fp);
			fscanf(fp, "%c", &ch);
			if(ch != ' ' && ch != '\r' && ch != '\n')
			{
				temp->Ordinal[i] = ch;
				i++;
			 } 
			 if(ch == ' ' && i != 0)
			{
				temp->Ordinal[i] = '\0';
				break;
			}
			
		}
		
		i = 0;
		while(!feof(fp))
		{
			fscanf(fp, "%c", &ch);
			if(ch != ' ' && ch != '\r' && ch != '\n')
			{
				temp->Name[i] = ch;
				i++;
			}
			if(ch == ' ' && i != 0)
			{
				temp->Name[i] = '\0';
				break;
			}
			
		}
		
		i = 0;
		while(!feof(fp))
		{
			fscanf(fp, "%c", &temp->Origin[i]);
			if(temp->Origin[i] != ' ' && temp->Origin[i] != '\r' && temp->Origin[i] != '\n')
			{
				//temp->Origin[i] = ch;
				i++;
			}
			if(temp->Origin[i] == ' ' && i != 0)
			{
				temp->Origin[i] = '\0';
				break;
			}
			
		}
		
		i = 0;
		while(!feof(fp))
		{
			ch = fgetc(fp);
			if(ch != ' ' && ch != '\r' && ch != '\n')
			{
				temp->Phone_num1[i] = ch;
				i++;
			}
			if(ch == ' ' && i != 0)
			{
				temp->Phone_num1[i] = '\0';
				break;
			}
			
		}
		
		i = 0;
		while(!feof(fp))
		{
			ch = fgetc(fp);
			if(ch != ' ' && ch != '\r' && ch != '\n')
			{
			temp->Phone_num2[i] = ch;
			i++;
			}
			if(ch == ' ' && i != 0)
			{
				temp->Phone_num2[i] = '\0';
				break;
			}
		}
		
		i = 0;
		while(!feof(fp))
		{
			ch = fgetc(fp);
			if(ch != ' ' && ch != '\r' && ch != '\n')
			{
				temp->Mailbox[i] = ch;
				i++;
			}
			
			if(ch == ' ' && i != 0)
			{
				temp->Mailbox[i] = '\0';
				break;
			}
			
		}
		
			while(!feof(fp))
		{
			ch = fgetc(fp);
			if(ch == '\r' || ch == '\n') 
			{
				//temp = temp->next;
				break;
			}
		
		}
		//ch = fgetc(fp); //吃掉文件中的回车键  
		//if(feof(fp)) break;//单独拿出来，防止后面继续开辟空间 
		Add_Contact(Friend);//增加空间  if(temp->next == NULL) 
		temp = temp->next; 
	}

	//因为结构体里面还有一个是节点，也会把他录进去，所以会再次创建多一个空间，所以要把最后一个销毁掉，同时也要把空间数量减一，也就是联系人减一 
	//所以在这个需要把最后一个空间销毁掉
	char tail[5];
	itoa(Contact_num, tail, 10);
	Destroy_LinkContact_1(Friend, tail);//第一个销毁函数是指定销毁哪个位置上的空间 
	Contact_num--;

} 

/*-----------------------------------------------------------------------------------------------------------------*/




/*-------------------------------------------------功能 2--------------------------------------------------------*/ 
void Function_two()
{
	Reflush_Main();
	if(Import_open == false && NEW_Contact_Link == false)//代表没有导入数据，需要直接创建表头
	{
		Init_Contact(&Friend);
		Add_Contact(&Friend);//先添加一个空间
		Input_Contact(&Friend);//输入信息
		NEW_Contact_Link = true;//要把开关打开，因为如果不打开就会造成新建新的联系表且还能导入文件数据 
	}
	else if(choice_num == '1')
	{
		Add_Contact(&Friend);//先添加一个空间Contact_num
		/* 
		这个是另一种存入方式，就是直接把用户输入的位置传进来改成字符串，再用，也可以直接用Input_Contact尾插函数 
		itoa(Contact_num, ch, 10); 
		Input_Contact_special_Ordinal(&Friend, ch); 
		*/ 
		Input_Contact(&Friend);//输入信息 
		//找到新空间进行赋值
	}
	else if(choice_num == '2')
	{
		Add_Contact_special_Ordinal(&Friend, Ordinal);
		Input_Contact_special_Ordinal(&Friend, Ordinal);
	}
	
	system("cls");
	SetPosition(Fix_X_coord, Function_Infor_num);
	PF(添加成功);
	SetPosition(Fix_X_coord, Function_Infor_num+1);
	system("pause");	
	
	
}

void Show_Input_Contact()
{
	SetPosition(Fix_X_coord, P+2);
 	PF(↓选择新建模式↓);
	SetPosition(Fix_X_coord, P+4);
 	PF(（1）直接新建联系人（至尾部）);
 	SetPosition(Fix_X_coord, P+6);
 	PF(（2）新建|输入要插入的位置->);
 	SetPosition(Fix_X_coord, P+8);
 	PF(（3）返回);
}

bool OR_Input_Contact()
{
	LinkContact temp = Friend;//待会用来搜索是否有这号联系人 
	char end[5];//用来存放尾部序号的字符串，然后方便和用户想要插入的空间位置进行比较 
	Reflush_Main();
	Show_Input_Contact(); 
 	Choice_Fun_num(3);
 	switch(choice_num)
	 {
	 	case '1':
	 		return true;
	 	case '2':
	 		if(Friend)
	 		{
	 			while(!Judge_num(Ordinal))
	 		{
	 			Limit_Contact_capacity(Ordinal, 3,Fix_X_coord+sizeof("（2）新建|输入要插入的位置->"), P+6);
	 			itoa(Contact_num+1, end,10);//先对用户输入的位置进行转换 
	 			if(strcmp(end,Ordinal) == 0)
				 {
				 	break;
				 }
	 			if(Find_Contact_Ordinal(Friend, Ordinal)) break;
	 			else
	 			{
	 				system("cls");
					SetPosition(Fix_X_coord, Function_Infor_num);
					PF(不能插入该位置！);
					SetPosition(Fix_X_coord, Function_Infor_num+1);
					system("pause");
	 				Reflush_Main();
					Show_Input_Contact(); 
				 }
			 }
			 }
			 else
			{
				system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(通讯录为空！);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");
				return false;	
			}
	 		return true;
	 	case '3':
	 		return false;
	  } 
}

bool Judge_re_Phone(LinkContact Friend, char*put_infor) 
{
	LinkContact temp = Friend;
	
	while(Friend)
	{
		if(strcmp(put_infor, Friend->Phone_num1) == 0 || strcmp(put_infor, Friend->Phone_num2) == 0)
		{
			Friend = temp;
			return false;
		}
		Friend = Friend->next;
	 } 
	 Friend = temp;
	 return true;
 } 
 
bool Judge_re_Mailbox(LinkContact Friend, char*put_infor)
{
	LinkContact temp = Friend;
	
	while(Friend)
	{
		if(strcmp(put_infor, Friend->Mailbox) == 0)
		{
			Friend = temp;
			return false;
		}
		Friend = Friend->next;
	 } 
	 Friend = temp;
	 return true;
 }  

void Init_Contact(LinkContact *Friend)// 把链表初始化 开辟一个表头 ，就是如果没有导入文件直接添加文件的话就要初始化表头 
{
	LinkContact temp = NULL;
	if((*Friend) == NULL)
	{
		(*Friend) = (LinkContact)malloc(sizeof(Contact));
		(*Friend)->next = NULL;
		if((*Friend) == NULL) 
		{
			system("cls"); 
			PF(申请空间失败！); 
			exit(1); 
		}
		temp = (*Friend);
		strcpy(temp->Ordinal, "#");
		strcpy(temp->Name,"姓名"); 
		strcpy(temp->Origin,"籍贯"); 
		strcpy(temp->Phone_num1,"电话1"); 
		strcpy(temp->Phone_num2,"电话2"); 
		strcpy(temp->Mailbox,"邮箱"); 
		Contact_num++;
	 }
	 
} 

void Add_Contact(LinkContact *Friend)//仅仅只是开辟一个新空间，并连起来，没有作任何赋值 
{
	LinkContact temp = (*Friend);
	LinkContact new_Contact;
	char ch[5];
	if((*Friend) == NULL)  
	{
		(*Friend) = (LinkContact)malloc(sizeof(Contact));
		Contact_num++;
		(*Friend)->next = NULL;
		if((*Friend) == NULL) 
		{
			system("cls");
			PF(申请空间失败！);
			exit(1); 
		}
	}
	else
	{
		while(temp->next != NULL) temp = temp->next;//搜索链表尾部 
		new_Contact = (LinkContact)malloc(sizeof(Contact));
		Contact_num++;
		new_Contact->next = NULL;//新空间的尾部
		temp->next = new_Contact;
		itoa(Contact_num, ch, 10);//第一个参数是十进制序数，所以第三个参数就是10进制，第二个参数就是字符数组，把Contact_num 转化为字符串后赋值给ch 
		strcpy(new_Contact->Ordinal,ch);
		strcpy(new_Contact->Origin,"（空）");
		strcpy(new_Contact->Name,"（空）");
		strcpy(new_Contact->Phone_num1,"0");
		strcpy(new_Contact->Phone_num2,"0");
		strcpy(new_Contact->Mailbox,"（空）");
		
	}
	
}

void Add_Contact_special_Ordinal(LinkContact *Friend, char *ch)
{
	LinkContact temp = (*Friend);
	LinkContact cur = (*Friend);
	LinkContact pre = NULL;
	LinkContact new_Contact;
	char Ordinal[5];//存放序号，进行序号移动 
	int record_num = 0;//记录链表节点移动到哪个序号上面了，后面要把下标全部变成字符串，然后移动序号下标 ,0是因为表头不算 
	if((*Friend) == NULL)  
	{
		(*Friend) = (LinkContact)malloc(sizeof(Contact));
		Contact_num++;
		(*Friend)->next = NULL;
		if((*Friend) == NULL) 
		{
			system("cls");
			PF(申请空间失败！);
			exit(1); 
		}
	}
	else
	{
		//cur = cur->next;//表头一定不是要插入的地方，表头不是联系人信息 
		while(cur) 
		{	if(strcmp(cur->Ordinal, ch) == 0) break;//进来首先判断一个头部是否是符合位置要求，下面再把当前位置移动 
			pre = cur;
			cur = cur->next;
			record_num++;//下一个节点下标 
		}
		if(cur == NULL)//用户要插入尾部 
		{
			new_Contact = (LinkContact)malloc(sizeof(Contact));
			Contact_num++;
			pre->next = new_Contact;
			new_Contact->next = NULL;
		}
//		if(cur->next==NULL)//表示要插入的是最后一位联系人的前面 
//		{
//			new_Contact = (LinkContact)malloc(sizeof(Contact));
//			Contact_num++;
//			cur->next = new_Contact; 
//			new_Contact->next = NULL;//新空间的尾部
//			record_num++;//下一个节点下标 
//		}
		else
		{
			new_Contact = (LinkContact)malloc(sizeof(Contact));
			Contact_num++;
			pre->next = new_Contact;
			new_Contact->next = cur;
		}
		
		strcpy(new_Contact->Origin,"（空）");
		strcpy(new_Contact->Name,"（空）");
		strcpy(new_Contact->Phone_num1,"0");
		strcpy(new_Contact->Phone_num2,"0");
		strcpy(new_Contact->Mailbox,"（空）");
		
		//需要移动序号位置后需要移动
		//record_num--;
		cur = new_Contact;
		while(cur)
		{
			if(cur->next == NULL) //判断尾部 
			{
				//为什么不用record_num++,因为这是判断尾部，肯定是下面的进行了操作才返回上来 
				itoa(record_num, Ordinal, 10);//左边是十进制数，所以第三个参数是10，中间是把数字转化字符串后赋值过去的字符串空间 
				strcpy(cur->Ordinal, Ordinal);//进行复制
				break;
			}
			itoa(record_num, Ordinal, 10);//左边是十进制数，所以第三个参数是10，中间是把数字转化字符串后赋值过去的字符串空间 
			strcpy(cur->Ordinal, Ordinal);//进行复制
			cur = cur->next;//移动到下一个节点空间 
			record_num++;
		}
		
		
	}	
 } 

void Input_Contact_special_Ordinal(LinkContact *Friend, char *ch)
{
	int i;
	//char ch[10]; 
	char to_copy[50]; //用来临时存放录入字符串，需要进行判断重复操作才能把该字符串录入 
	LinkContact temp = (*Friend);
	LinkContact serch_temp = (*Friend);
	
	while(temp->next)
	{
		if(strcmp(temp->Ordinal,ch) == 0) break; 
		temp = temp->next;
	}
	
//	SetPosition(Fix_X_coord, P+2);
// 	PF(↓新建联系人↓（不允许中途退出）);
//上面这两个不用在这放，因为在Input_Contact_detail_Name函数中就包含了这个刷新部分 
	//itoa(Contact_num, ch, 10);//第一个参数是十进制序数，所以第三个参数就是10进制，第二个参数就是字符数组，把Contact_num 转化为字符串后赋值给ch 
	
	strcpy(temp->Ordinal,ch);
	/*如果你是直接Add_Contact和该函数配合使用，如果没有复制过去，
	会出现乱码，不知道为什么 ，所以不管怎样，加上就是了，
	反正即使你配合Add_Contact_special_Ordinal一起使用也不会出错，照样正常运行 
	*/ 
	while(1)
	{
	Reflush_Main();
	Input_Contact_detail_Name(temp);//保留原有的新建联系人信息 ，下面的同理 
 	SetPosition(Fix_X_coord, P+4);
	 PF(姓名：);Limit_Contact_capacity(temp->Name, 14, Fix_X_coord+strlen("姓名："),P+4);//原本是15个字符，但是最后一个字符空间是用来存放\0，所以限制是14个 
	 while(Judge_chinese_and_English(temp->Name))
   {
   	Reflush_Main();
   	Input_Contact_detail_Origin(temp); 
	SetPosition(Fix_X_coord, P+5);
 	PF(籍贯：);Limit_Contact_capacity(temp->Origin, 14, Fix_X_coord+strlen("籍贯："),P+5);
 	while(Judge_chinese(temp->Origin)) 
	{
	Reflush_Main();	
	Input_Contact_detail_Phone_num1(temp); 	
	//电话需要额外加一个函数急需判断是否全为数字 
	SetPosition(Fix_X_coord, P+6);
 	PF(电话1：);Limit_Contact_capacity(to_copy, 11, Fix_X_coord+strlen("电话2："),P+6);
 	if(Judge_re_Phone(serch_temp, to_copy))
 	{
 		strcpy(temp->Phone_num1, to_copy);//没有重复就把号码赋值过去  	
 		while(Judge_num(temp->Phone_num1))//首先判断上次输入的号码是否全为数字，不是就返回faluse,是就返回true 
 	{
 		Reflush_Main();	
 		Input_Contact_detail_Phone_num2(temp); 
 		SetPosition(Fix_X_coord, P+7);
	 	PF((按E/e不填)电话2：);Limit_Contact_capacity(to_copy, 11, Fix_X_coord+strlen("(按E/e不填)电话2："),P+7);
	 	if(Judge_re_Phone(serch_temp, to_copy))
 	{
 		if(strcmp(to_copy, "E")==0 || strcmp(to_copy, "e")==0) strcpy(temp->Phone_num2, "（无）");
	 	else strcpy(temp->Phone_num2, to_copy);//没有重复就把号码赋值过去 
	 	while(Judge_num(temp->Phone_num2) || strcmp(temp->Phone_num2, "（无）") == 0)
 		{
 			//邮箱有三个组成部分，也需要一个函数进行分别判断 
 			Reflush_Main();
 			Input_Contact_detail_Mailbox(temp);
			SetPosition(Fix_X_coord, P+8);
			PF(邮箱：);Limit_Contact_capacity(to_copy, 20, Fix_X_coord+strlen("邮箱："),P+8); 
			if(Judge_re_Mailbox(serch_temp, to_copy)) 
			{
				strcpy(temp->Mailbox, to_copy);//没有重复就把邮箱赋值过去
				while(Judge_Mailbox(temp->Mailbox)) return;//如果没有中文符号且邮箱格式正确就直接返回函数，录入完毕
				system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(邮箱输入有误);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");
			}
			else
			{
				system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(邮箱重复！);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");
			 } 
			
 		}
 	
		 	system("cls");
			SetPosition(Fix_X_coord, Function_Infor_num);
			PF(电话号码输入有误);
			SetPosition(Fix_X_coord, Function_Infor_num+1);
			system("pause");
 	}
 	else
	 {
	 		system("cls");
			SetPosition(Fix_X_coord, Function_Infor_num);
			PF(电话号码重复！);
			SetPosition(Fix_X_coord, Function_Infor_num+1);
			system("pause");
	  } 
 	
	 	
	 }
	 	system("cls");
		SetPosition(Fix_X_coord, Function_Infor_num);
		PF(电话号码输入有误);
		SetPosition(Fix_X_coord, Function_Infor_num+1);
		system("pause");
 	}
 	else 
 	{
 		system("cls");
		SetPosition(Fix_X_coord, Function_Infor_num);
		PF(电话号码重复！);
		SetPosition(Fix_X_coord, Function_Infor_num+1);
		system("pause");
	 }
	} 
 	system("cls");
	SetPosition(Fix_X_coord, Function_Infor_num);
	PF(籍贯输入有误);
	SetPosition(Fix_X_coord, Function_Infor_num+1);
	system("pause");
	}
	system("cls");
	SetPosition(Fix_X_coord, Function_Infor_num);
	PF(姓名输入有误);
	SetPosition(Fix_X_coord, Function_Infor_num+1);
	system("pause");	
	} 
		
 } 

void Input_Contact(LinkContact *Friend)  
{
	int i;
	char ch[10];
	char to_copy[50]; //用来临时存放录入字符串，需要进行判断重复操作才能把该字符串录入 
	LinkContact temp = (*Friend);
	LinkContact serch_temp = (*Friend);
	while(temp->next)
	{
		temp = temp->next;
	}
	
//	SetPosition(Fix_X_coord, P+2);
// 	PF(↓新建联系人↓（不允许中途退出）);
//上面这两个不用在这放，因为在Input_Contact_detail_Name函数中就包含了这个刷新部分  

//因为这个函数是在尾部插入，在添加联系人到链表的时候已经把序号导进去了，所以这里不用继续导一遍 
//	itoa(Contact_num, ch, 10);//第一个参数是十进制序数，所以第三个参数就是10进制，第二个参数就是字符数组，把Contact_num 转化为字符串后赋值给ch 
//	strcpy(temp->Ordinal,ch);

	while(1)
	{
	Reflush_Main();
	Input_Contact_detail_Name(temp);//保留原有的新建联系人信息 ，下面的同理 
 	SetPosition(Fix_X_coord, P+4);
	 PF(姓名：);Limit_Contact_capacity(temp->Name, 14, Fix_X_coord+strlen("姓名："),P+4);//原本是15个字符，但是最后一个字符空间是用来存放\0，所以限制是14个 
	 while(Judge_chinese_and_English(temp->Name))
   {
   	Reflush_Main();
   	Input_Contact_detail_Origin(temp); 
	SetPosition(Fix_X_coord, P+5);
 	PF(籍贯：);Limit_Contact_capacity(temp->Origin, 14, Fix_X_coord+strlen("籍贯："),P+5);
 	while(Judge_chinese(temp->Origin)) 
	{
	Reflush_Main();	
	Input_Contact_detail_Phone_num1(temp); 	
	//电话需要额外加一个函数急需判断是否全为数字 temp->Phone_num1
	SetPosition(Fix_X_coord, P+6);
 	PF(电话1：);Limit_Contact_capacity(to_copy, 11, Fix_X_coord+strlen("电话1："),P+6);
 	if(Judge_re_Phone(serch_temp, to_copy))
 	{
 		strcpy(temp->Phone_num1, to_copy);//没有重复就把号码赋值过去 
 		while(Judge_num(temp->Phone_num1))//首先判断上次输入的号码是否全为数字，不是就返回faluse,是就返回true 
 	{
 		Reflush_Main();
 		Input_Contact_detail_Phone_num2(temp); 
 		SetPosition(Fix_X_coord, P+7);
	 	PF((按E/e不填)电话2：);Limit_Contact_capacity(to_copy, 11, Fix_X_coord+strlen("(按E/e不填)电话2："),P+7);
	 	if(Judge_re_Phone(serch_temp, to_copy))
	 	{	
	 		if(strcmp(to_copy, "E")==0 || strcmp(to_copy, "e")==0) strcpy(temp->Phone_num2, "（无）");
	 		else strcpy(temp->Phone_num2, to_copy);//没有重复就把号码赋值过去 
	 		while(Judge_num(temp->Phone_num2) || strcmp(temp->Phone_num2, "（无）") == 0)
 		{//首先判断上次输入的号码是否全为数字，不是就返回faluse,是就返回true 
 		
 			//邮箱有三个组成部分，也需要一个函数进行分别判断 
 			Reflush_Main();
 			Input_Contact_detail_Mailbox(temp);
			SetPosition(Fix_X_coord, P+8);
			PF(邮箱：);Limit_Contact_capacity(to_copy, 21, Fix_X_coord+strlen("邮箱："),P+8); 
			if(Judge_re_Mailbox(serch_temp, to_copy)) 
			{
				strcpy(temp->Mailbox, to_copy);//没有重复就把邮箱赋值过去 
				while(Judge_Mailbox(temp->Mailbox)) return;//如果没有中文符号且邮箱格式正确就直接返回函数，录入完毕
				system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(邮箱输入有误);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");
			}
			else
			{
				system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(邮箱重复！);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");
			}
			
 		}
 	
		 	system("cls");
			SetPosition(Fix_X_coord, Function_Infor_num);
			PF(电话号码输入有误);
			SetPosition(Fix_X_coord, Function_Infor_num+1);
			system("pause");
		 }
		 else
		 {
		 	system("cls");
			SetPosition(Fix_X_coord, Function_Infor_num);
			PF(电话号码重复！);
			SetPosition(Fix_X_coord, Function_Infor_num+1);
			system("pause");
		  } 
	 	
	 }
	 	system("cls");
		SetPosition(Fix_X_coord, Function_Infor_num);
		PF(电话号码输入有误);
		SetPosition(Fix_X_coord, Function_Infor_num+1);
		system("pause");
	 }
	 else
	 {
	 	system("cls");
		SetPosition(Fix_X_coord, Function_Infor_num);
		PF(电话号码重复！);
		SetPosition(Fix_X_coord, Function_Infor_num+1);
		system("pause");
	  } 
 	
	 	
	} 
 	system("cls");
	SetPosition(Fix_X_coord, Function_Infor_num);
	PF(籍贯输入有误);
	SetPosition(Fix_X_coord, Function_Infor_num+1);
	system("pause");
	}
	system("cls");
	SetPosition(Fix_X_coord, Function_Infor_num);
	PF(姓名输入有误);
	SetPosition(Fix_X_coord, Function_Infor_num+1);
	system("pause");	
	} 
	
 } 

void Input_Contact_detail_Name(LinkContact temp)
{
	
	system("cls");
	if(Browse_open == true) Browse_Contact(Friend);	
	ShowFrame(); 
	SetPosition(Fix_X_coord, P+2);
	PF(↓新建联系人↓);
	SetPosition(Fix_X_coord, P+4);	
} 

void Input_Contact_detail_Origin(LinkContact temp)
{
	
	system("cls");
	if(Browse_open == true) Browse_Contact(Friend);	
	ShowFrame(); 
 	SetPosition(Fix_X_coord, P+2);
 	PF(↓新建联系人↓);
 	SetPosition(Fix_X_coord, P+4);
 	PF(姓名：%s,temp->Name);	
}

void Input_Contact_detail_Phone_num1(LinkContact temp)
{
	
	system("cls");
	if(Browse_open == true) Browse_Contact(Friend);	
	ShowFrame(); 
 	SetPosition(Fix_X_coord, P+2);
 	PF(↓新建联系人↓);
 	SetPosition(Fix_X_coord, P+4);
 	PF(姓名：%s,temp->Name);
 	SetPosition(Fix_X_coord, P+5);
 	PF(籍贯：%s, temp->Origin);	
}

void Input_Contact_detail_Phone_num2(LinkContact temp)
{
	
	system("cls");
	ShowFrame(); 
	if(Browse_open == true) Browse_Contact(Friend);	
	SetPosition(Fix_X_coord, P+2);
	PF(↓新建联系人↓);
	SetPosition(Fix_X_coord, P+4);
	PF(姓名：%s,temp->Name);
	SetPosition(Fix_X_coord, P+5);
	PF(籍贯：%s, temp->Origin);
	SetPosition(Fix_X_coord, P+6);
	PF(电话1：%s, temp->Phone_num1);	
}

void Input_Contact_detail_Mailbox(LinkContact temp)
{
	
	system("cls");
	ShowFrame(); 
	if(Browse_open == true) Browse_Contact(Friend);	
	SetPosition(Fix_X_coord, P+2);
	PF(↓新建联系人↓);
	SetPosition(Fix_X_coord, P+4);
	PF(姓名：%s,temp->Name);
	SetPosition(Fix_X_coord, P+5);
	PF(籍贯：%s, temp->Origin);
	SetPosition(Fix_X_coord, P+6);
	PF(电话1：%s, temp->Phone_num1);	
	SetPosition(Fix_X_coord, P+7);
	PF((按E/e不填)电话2：%s, temp->Phone_num2);	
}

/*-----------------------------------------------------------------------------------------------------------------*/






/*-------------------------------------------------功能 3--------------------------------------------------------*/ 
void Function_three()
{
	if(Browse_open == false) Browse_open = true;
	else  Browse_open = false;
	
	//打印通讯录 
	if(Browse_open == true) Browse_Contact(Friend);
}

void Browse_Contact(LinkContact Friend)
{
	int i,j;
  if(Friend!=NULL)
  {
		SetPosition(PF_Contact_line, PF_Contact_Start_Y-1);
 		PF_ContactInfor_Line;
	 for(i = 0,j = 0;Friend != NULL; j++,i+=2)
	{
		SetPosition(PF_Contact_Ordinal_X-1, PF_Contact_Start_Y+i);
	 	PF(|%s, Friend->Ordinal);
		SetPosition(Name_X-1, PF_Contact_Start_Y+i);
	 	PF(|%s, Friend->Name);
	    SetPosition(Origin_X-1, PF_Contact_Start_Y+i);
	 	PF(|%s, Friend->Origin);
	 	SetPosition(Phone_num1_X-1, PF_Contact_Start_Y+i);
	 	PF(|%s, Friend->Phone_num1); 
	 	SetPosition(Phone_num2_X-1, PF_Contact_Start_Y+i);
	 	PF(|%s, Friend->Phone_num2);   
	 	SetPosition(Mailbox_X-1, PF_Contact_Start_Y+i);
	 	PF(|%s, Friend->Mailbox);  
	 	SetPosition(Mailbox_X+21, PF_Contact_Start_Y+i);
	 	PF(|);
	 	
	 	SetPosition(PF_Contact_line, PF_Contact_Start_Y+i+1);
	 	PF_Contact_Divid_Line;
	 	Friend = Friend->next;
	}
		SetPosition(PF_Contact_line, PF_Contact_Start_Y+i-1);
 		PF_ContactInfor_Line;
   } 
	
}

/*-----------------------------------------------------------------------------------------------------------------*/





/*-------------------------------------------------功能 4--------------------------------------------------------*/ 
void Function_four()
{
	while(1)//循环不能放在外面，只能放在这个函数里面，不然会导致不能循环重复查询  -----具体原因有待考察，没找到原因 
	{   
		Reflush_Main();
		Show_SearchMeun();
		Search_Contact();
		if(choice_num == '4') break;//选择四是代表用户退出 
	} 
		
	
	
}

void Show_SearchMeun()
{
	SetPosition(Fix_X_coord, P+2);
 	PF(（1）序号搜索->);
 	SetPosition(Fix_X_coord, P+4);
 	PF(（2）姓名搜索->);
 	SetPosition(Fix_X_coord, P+6);
 	PF(（3）籍贯搜索->);
 	SetPosition(Fix_X_coord, P+8);
 	PF(（4）返回);
 	SetPosition(Fix_X_coord, P+9);	
 } 

void PF_STRUCT_Contact(LinkContact Friend,int Y)//找到联系人单个打印出来 ，第一个参数是结构体，只打印传进来的那个结构体 
{

 	
	SetPosition(PF_Contact_line, Y);
 	PF_ContactInfor_Line;
 	
	SetPosition(PF_Contact_Ordinal_X-1, Y+1);
 	PF(|%s, Friend->Ordinal);
	SetPosition(Name_X-1, Y+1);
 	PF(|%s, Friend->Name);
    SetPosition(Origin_X-1, Y+1);
 	PF(|%s, Friend->Origin);
 	SetPosition(Phone_num1_X-1, Y+1);
 	PF(|%s, Friend->Phone_num1); 
 	SetPosition(Phone_num2_X-1, Y+1);
 	PF(|%s, Friend->Phone_num2);   
 	SetPosition(Mailbox_X-1, Y+1);
 	PF(|%s, Friend->Mailbox);  
 	SetPosition(Mailbox_X+21, Y+1);
 	PF(|);
 	
 	SetPosition(PF_Contact_line, Y+2);
 	PF_ContactInfor_Line;
}

void Search_Contact()
{
	bool success_open = false;//如果找到了信息就变为true，没找到就是false  
	LinkContact temp = Friend;
	int i = 0;
	char ch[30];//搜索对应字符串 
	
 	Choice_Fun_num(4);
 	//如果浏览开关是开的，那么在搜索函数中要暂时把显示全部联系人的信息屏蔽掉 ，不然会和搜索到的联系人打印信息重复 
 	int open = -1;
 	if(Browse_open == true)
	{
		open = 1;//代表进来过，待会出去函数后要把开关打开 
	  	Browse_open = false;
	} 
	  
	 
 	switch(choice_num)
 	{
 		case '1':
 			Limit_Contact_capacity(ch,3,Fix_X_coord + sizeof("（1）序号搜索->"), P+2);
 			if(Find_Contact_Ordinal(Friend, ch))
			{
				success_open = true;
			 	Reflush_Main(); 
				Show_SearchMeun();
			 	SetPosition(Phone_num1_X-10, PF_Contact_Start_Y-1);
			 	PF(已为您找到如下联系人信息);
				PF_STRUCT_Contact(Find_Contact_Ordinal(Friend, ch), PF_Contact_Start_Y);
			}
 			break;
 		case '2':
 			Limit_Contact_capacity(ch,14,Fix_X_coord + sizeof("（2）姓名搜索->"), P+4);
 			Reflush_Main(); 
			Show_SearchMeun();
		 	SetPosition(Phone_num1_X-10, PF_Contact_Start_Y-1);
		 	PF(已为您找到如下联系人信息);
		 	
		 	//PF_STRUCT_Contact(Find_Contact_Name(Friend, ch), PF_Contact_Start_Y);
		 	 
		 	while(temp != NULL)
			{
				if(Find_Contact_Name(temp, ch)) 
				{
					success_open = true;//表明找到了 
					PF_STRUCT_Contact(temp = Find_Contact_Name(temp, ch), PF_Contact_Start_Y+i);
					i+=2;
				} 
				
				
				temp = temp->next;
			}
 			break;
		case '3':
			Limit_Contact_capacity(ch,14,Fix_X_coord + sizeof("（3）籍贯搜索->"), P+6);
			Reflush_Main(); 
			Show_SearchMeun();
		 	SetPosition(Phone_num1_X-10, PF_Contact_Start_Y-1);
		 	PF(已为您找到如下联系人信息);
			while(temp != NULL)
			{
				if(Find_Contact_Origin(temp, ch)) 
				{
					success_open = true;//表明找到了 
					PF_STRUCT_Contact(temp = Find_Contact_Origin(temp, ch), PF_Contact_Start_Y+i);
					i+=2;
				} 
				temp = temp->next;
			}
 			break;
		case '4':
			if(open==1)	Browse_open = true;//同理也是出去前先打开 
			//如果open为1，代表进来的时候浏览开关是开着的，那么出去之前就要打开 
			return; 
 			break;	 	
	 }
	 
	 
	 
	if(success_open == false)
	{
		system("cls");
		SetPosition(Fix_X_coord, Function_Infor_num);
		PF(查无此人);
		SetPosition(Fix_X_coord, Function_Infor_num+1);
		system("pause");
	 }else
	 {
	 	SetPosition(PF_Contact_line, PF_Contact_Start_Y+i+3);
		system("pause"); 
	 }
	if(open==1)	Browse_open = true;//如果open为1，代表进来的时候浏览开关是开着的，那么出去之前就要打开 
	
}

LinkContact Find_Contact_Ordinal(LinkContact Friend, char *ch)
{
	Friend = Friend->next;//首空间肯定不是信息，是表头 
	 while(Friend!=NULL)
	{
		if(strcmp(Friend->Ordinal, ch)==0) return Friend;
	  	Friend = Friend->next;
	}
	return 0;
 } 

LinkContact Find_Contact_Name(LinkContact Friend, char *ch)
{
	//Friend = Friend->next;//首空间肯定不是信息，是表头 
	 while(Friend!=NULL)
	{
		if(strcmp(Friend->Name, ch)==0) return Friend;
	  	Friend = Friend->next;
	}
	return 0;
 } 

LinkContact Find_Contact_Origin(LinkContact Friend, char *ch)
{
	//Friend = Friend->next;//首空间肯定不是信息，是表头 
	 while(Friend!=NULL)
	{
		if(strcmp(Friend->Origin, ch)==0) return Friend;
	  	Friend = Friend->next;
	}
	return 0;
 } 

/*-----------------------------------------------------------------------------------------------------------------*/





/*-------------------------------------------------功能 5--------------------------------------------------------*/

void Function_fine()
{
	Revise_Contact(); 
 } 

bool OR_Revise_Contact()
{
	Reflush_Main();
	SetPosition(Fix_X_coord, P+3);
 	PF(（1）选择输入修改联系人的序号);
 	SetPosition(Fix_X_coord, P+5);
 	PF(（2）返回);
 	Choice_Fun_num(2);
 	if(choice_num == '1') return true;
 	else return false;
 } 

void Show_ReviseMeun()
{ 
 	SetPosition(Fix_X_coord, P+2);
 	PF(↓选择修改对应的信息↓);
 	SetPosition(Fix_X_coord, P+3);
 	PF(（1）姓名：);
 	SetPosition(Fix_X_coord, P+4);
 	PF(（2）籍贯：);
 	SetPosition(Fix_X_coord, P+5);
 	PF(（3）电话1：);
 	SetPosition(Fix_X_coord, P+6);
 	PF(（4）电话2：);
 	SetPosition(Fix_X_coord, P+7);
 	PF(（5）邮箱：);
 	SetPosition(Fix_X_coord, P+9);
 	PF(（6）保存|返回);
}

void Revise_Contact()
{
	
	
	bool ins = true;//表示 可以进去继续修改信息 
	//LinkContact To_Revise = NULL;//用来村阿芳 
	Limit_Contact_capacity(Ordinal, 3,Fix_X_coord+strlen("（1）选择输入修改联系人的序号 "), P+3);
	if(Find_Contact_Ordinal(Friend,Ordinal))
	{
	while(ins == true)
	{
	Reflush_Main();
	Show_ReviseMeun(); 
 	Choice_Fun_num(6);
 	switch(choice_num)
	{
		case '1':
			Revise_Name(&Friend,Ordinal);
			break; 
		case '2': 
			Revise_Origin(&Friend,Ordinal);
			break;
		case '3': 
			Revise_Phone_num1(&Friend,Ordinal);
			break;
		case '4': 
			Revise_Phone_num2(&Friend,Ordinal);
			break;
		case '5': 
			Revise_Mailbox(&Friend,Ordinal);
			break;	
		case '6': 
			ins = false;//表示要退出了，就要把ins关掉 
			break;				
	} 	
	}
		
	 }
	 else
	 {
	 	system("cls");
		SetPosition(Fix_X_coord, Function_Infor_num);
		PF(查无此人！);
		SetPosition(Fix_X_coord, Function_Infor_num+1);
		system("pause");
	  } 
	
}

void Revise_Name(LinkContact*Friend, char *ch)
{
	LinkContact temp = (*Friend);
	temp = temp->next;//因为联系人一定会有表头这个东西存在，所以表头不用搜索 
	while(temp)
	{
		if(strcmp(temp->Ordinal, ch) == 0) break;
		else temp = temp->next; 
	}
	while(1)
	{
		Reflush_Main();
		Show_ReviseMeun();
		SetPosition(Fix_X_coord, P+3);
	 	PF(（1）姓名：);Limit_Contact_capacity(temp->Name, 14, Fix_X_coord+strlen("（1）姓名："),P+3);
	 	if(Judge_chinese_and_English(temp->Name)) break;
	 	else
	 	{
	 		system("cls");
			SetPosition(Fix_X_coord, Function_Infor_num);
			PF(姓名输入有误);
			SetPosition(Fix_X_coord, Function_Infor_num+1);
			system("pause");	
		 }
	}
}

void Revise_Origin(LinkContact*Friend, char *ch)
{
	LinkContact temp = (*Friend);
	temp = temp->next;//因为联系人一定会有表头这个东西存在，所以表头不用搜索 
	while(temp)
	{
		if(strcmp(temp->Ordinal, ch) == 0) break;
		else temp = temp->next;  
	}
	while(1)
	{
		Reflush_Main();
		Show_ReviseMeun();
		SetPosition(Fix_X_coord, P+4);
	 	PF(（2）籍贯：);Limit_Contact_capacity(temp->Origin, 14, Fix_X_coord+strlen("（2）籍贯："),P+4);
	 	if(Judge_chinese(temp->Origin)) break;
	 	else
	 	{
	 		system("cls");
			SetPosition(Fix_X_coord, Function_Infor_num);
			PF(籍贯输入有误);
			SetPosition(Fix_X_coord, Function_Infor_num+1);
			system("pause");	
		 }
	}
}

void Revise_Phone_num1(LinkContact*Friend, char *ch)
{
	char to_copy[30]; 
	LinkContact temp = (*Friend);
	LinkContact search_temp = (*Friend);
	temp = temp->next;//因为联系人一定会有表头这个东西存在，所以表头不用搜索 
	while(temp)
	{
		if(strcmp(temp->Ordinal, ch) == 0) break; 
		else temp = temp->next; 
	}
	while(1)
	{
		Reflush_Main();
		Show_ReviseMeun();
		SetPosition(Fix_X_coord, P+5);
	 	PF(（3）电话1：);Limit_Contact_capacity(to_copy, 11, Fix_X_coord+strlen("（3）电话1："),P+5);
	 	if(Judge_re_Phone(search_temp, to_copy))
		 {
		 	strcpy(temp->Phone_num1, to_copy);
		 	if(Judge_num(temp->Phone_num1)) break;
		 	else
		 	{
		 		system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(电话号码输入有误);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");	
			 }
		  }
		  else
		  {
		  		system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(电话号码重复！);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");
		   } 
	 	
	}
}

void Revise_Phone_num2(LinkContact*Friend, char *ch)
{
	char to_copy[50];
	LinkContact temp = (*Friend);
	LinkContact search_temp = (*Friend);
	temp = temp->next;//因为联系人一定会有表头这个东西存在，所以表头不用搜索 
	while(temp)
	{
		if(strcmp(temp->Ordinal, ch) == 0) break; 
		else temp = temp->next; 
	}
	while(1)
	{
		
		Reflush_Main();
		Show_ReviseMeun();
		SetPosition(Fix_X_coord, P+6);
	 	PF(（4）电话2：);Limit_Contact_capacity(to_copy, 11, Fix_X_coord+strlen("（4）电话2："),P+6);
	 	if(Judge_re_Phone(search_temp, to_copy))
		 {
		 	strcpy(temp->Phone_num2, to_copy);
		 	if(Judge_num(temp->Phone_num2)) break;
		 	else
		 	{
		 		system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(电话号码输入有误);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");	
			 }
		}
		else
		  {
		  		system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(电话号码重复！);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");
		   } 
	 	
	}
}

void Revise_Mailbox(LinkContact*Friend, char *ch)
{
	char to_copy[50];
	LinkContact temp = (*Friend);
	LinkContact search_temp = (*Friend);
	temp = temp->next;//因为联系人一定会有表头这个东西存在，所以表头不用搜索 
	while(temp)
	{
		if(strcmp(temp->Ordinal, ch) == 0)
		{
			
			break; 
		 } 
		temp = temp->next; 
	}
	while(1)
	{
		Reflush_Main();
		Show_ReviseMeun();
		SetPosition(Fix_X_coord, P+7);
	 	PF(（5）邮箱：); Limit_Contact_capacity(to_copy, 20, Fix_X_coord+strlen("（5）邮箱："),P+7);
	 	if(Judge_re_Mailbox(search_temp, to_copy))
	 	{
	 		strcpy(temp->Mailbox, to_copy);
	 		if(Judge_Mailbox(temp->Mailbox)) break;
		 	 else
		 	{
		 		system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(邮箱输入有误);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");	
			 }
		 }
		 else
		 {
		 		system("cls");
				SetPosition(Fix_X_coord, Function_Infor_num);
				PF(邮箱输入重复！);
				SetPosition(Fix_X_coord, Function_Infor_num+1);
				system("pause");
		  } 
		 
	}
}

/*-----------------------------------------------------------------------------------------------------------------*/





/*-------------------------------------------------功能 6--------------------------------------------------------*/

void Function_six()
{
	Reflush_Main();
	Delete_Contact_Choice();
}

void Delete_in_bulk()//循环批量删除 
{
	int num = 5;//没有代表意义，测试用的数据，表示删除5号，
	int i; 
	char temp[5];//临时字符空间 
	while(1)// 要在这里用循环是因为要实现当用户输入0的时候会退出批量删除 
	{
	if(Friend->next == NULL)
	{
		system("cls");
		SetPosition(Fix_X_coord, Function_Infor_num);
		PF(联系人已全部删除！通讯录为空！);
		SetPosition(Fix_X_coord, Function_Infor_num+1);
		system("pause");
		if(Friend != NULL) 
		{
			Release_Contact(&Friend); 
		} 
		NEW_Contact_Link = false;//立马关掉 
		Contact_num = -1; 
		//因为全部删除掉了，所以把表头也删除掉，下次用户可能继续新建，那就要重新进行初始化，又或者用户要录入数据 
		break;
	}
	Reflush_Main();//先想想这个放在哪 
	SetPosition(Fix_X_coord, P+3);
 	PF(（1）输入删除联系人的序号 (0退出));
 	SetPosition(Fix_X_coord, P+5);
 	PF(（2）返回);
 	Limit_Contact_capacity(Ordinal, 2,Fix_X_coord+sizeof("（1）输入删除联系人的序号 (0退出) "), P+3);
	if(strcmp(Ordinal, "0") == 0) break;
 	for(i = 0; i < strlen(Ordinal); i++)
	{
		if(Ordinal[i]-'0' < 0 || Ordinal[i]-'0' > 9|| Ordinal[i] == ' ')
		{
			i = -1;
			break;
		 }  
	}
 	 
	if(i!=-1)
	{
		Destroy_LinkContact_1(&Friend, Ordinal);//判断字符串是否全为数字)
		Contact_num--;//联系人数量减一 
		//需要一个函数在删除后将联系人序号重新排序一下
		itoa(Contact_num+1, temp, 10); 
		if(strcmp(temp, Ordinal)!=0) To_sort_again(&Friend, Ordinal);//如果删除的不是最后一个就要再次对序号进行排序  
	} 
	else
	{
		system("cls");
		SetPosition(Fix_X_coord, Function_Infor_num);
		PF(请输入数字！);
		SetPosition(Fix_X_coord, Function_Infor_num+1);
		system("pause");
	}
	}
} 

void Delete_Contact_Choice()
{
	SetPosition(Fix_X_coord, P+3);
 	PF(（1）输入删除联系人的序号);
 	SetPosition(Fix_X_coord, P+5);
 	PF(（2）返回);
 	Choice_Fun_num(2);
 	switch(choice_num)
	{	
		case '1':
			Delete_in_bulk();//批量删除 
			break; 
		case '2': 
			break; 			
	} 
 } 

void Destroy_LinkContact_1(LinkContact *Friend, char *num)
{
	LinkContact cur = (*Friend),  pre = NULL;
	pre = cur;
	cur = cur->next;
	while(1)
	{
		//需要考虑头尾部分
		if(cur->next == NULL && strcmp(cur->Ordinal, num) == 0) //尾部部分判断 ,若到尾部且不是要找到的序号，就代表没有找到，那就直接退出 
		{
			pre->next = NULL;
			free(cur);//释放尾部
			break; 
		}
		else if(cur->next == NULL) 
		{
			system("cls");
			SetPosition(Fix_X_coord, Function_Infor_num);
			PF(没有找到对应的联系人！);
			SetPosition(Fix_X_coord, Function_Infor_num+1);
			system("pause");
			break;
		 } 
		if(strcmp(cur->Ordinal, num) == 0)
		{
			pre->next = cur->next;
			free(cur);//释放尾部
			break;
		}
		pre = cur;
		cur = cur->next;
	}
	
}

void To_sort_again(LinkContact *Friend, char *Ordinal)//再次对序号进行排序,必须保证传进来的数字字符串序号是存在的 
{
	LinkContact temp = (*Friend);
	temp = temp->next;//因为表头不是联系人信息，所以要先移动一步 
	int num = 1;
	char ch[5];
	while(temp)
	{
		itoa(num, ch, 10);
		if(strcmp(ch,Ordinal) == 0) break;
		temp = temp->next;
		num++;
	} 
	while(temp)//不用管是否是删除的是最后一个，因为在进来之前已经判断过一次，为了节省要循环的次数就直接在进入这个函数之前先行判断了 
	{
		itoa(num, ch, 10);
		strcpy(temp->Ordinal, ch);
		temp = temp->next;
		num++;
	}
	 
}
/*-----------------------------------------------------------------------------------------------------------------*/





/*-------------------------------------------------功能 7--------------------------------------------------------*/

void Function_seven()
{
	FILE *fp;
	//如果说没有导入数据直接录入，代表用户想要自己新疆一个联系表，所以导出的文静也是新的
	if(NEW_Contact_Link == true) 
	{
		fp = fopen(New_Friend_Contact_txt, "w");
		NEW_Contact_Link = false;//立马关掉 
	}
	
	//否则的话就是继续保存在当前文件中 
	if(Import_open == true) 
	{
		fp = fopen(Friend_Contact_txt, "w");
		Import_open = false;//立马关掉 
	}
	if(Friend!=NULL) Save_Contact(&Friend, fp); //链表不能为空 
	fclose(fp);
	Save_open = true; // 表示已经导出
	system("cls");
	SetPosition(Fix_X_coord, Function_Infor_num);
	PF(导出成功！);
	SetPosition(Fix_X_coord, Function_Infor_num+1);
	system("pause");
	Contact_num = -1;//联系人数量置为空 
	if(Friend != NULL) 
	{
		Release_Contact(&Friend); 
	} 
}

void Save_Contact(LinkContact *Friend, FILE *fp)
{
	//同样写两个方法去保存，
	//第一种是直接保存结构体，第二种是一个字符一个字符的保存 
	LinkContact temp = (*Friend);
	while(temp != NULL)
	{
//		fwrite(temp, sizeof(Contact)-sizeof(LinkContact), 1, fp);  
		//很关键，因为结构体里面有节点，也会把节点录进去，所以一定要减了节点这个空间才能完成想要录入的信息 
		//但是因为fwrite出现会出现乱码的原因就不用了，直接用fscanf 
		fprintf(fp,"%-5s%-15s%-15s%-15s%-15s%-30s", temp->Ordinal,temp->Name,temp->Origin,temp->Phone_num1,temp->Phone_num2,temp->Mailbox);
		fprintf(fp,"\n");
		temp = temp->next;
	 } 
}

/*-----------------------------------------------------------------------------------------------------------------*/

/*-------------------------------------------------功能 8--------------------------------------------------------*/

void Function_eight()
{
	Reflush_Main();
	Love_Choice();
}
 
void Love_Choice()
{
	SetPosition(Fix_X_coord, P+3);
 	PF(（1）输入置顶联系人的序号);
 	SetPosition(Fix_X_coord, P+5);
 	PF(（2）返回);
 	Choice_Fun_num(2);
 	switch(choice_num)
	{	
		case '1':
			Love_in_bulk();//循环置顶 
			break; 
		case '2': 
			break; 			
	} 
 } 

void Love_in_bulk()
{
	int i, j;
	char ch[5];
	int O_num[3], sum = 0;
	int num_index = 0;
	while(1)// 要在这里用循环是因为要实现当用户输入0的时候会退出批量删除 
	{
	sum = 0;
	Reflush_Main();//先想想这个放在哪 
	SetPosition(Fix_X_coord, P+3);
 	PF(（1）输入置顶联系人的序号 (0退出));
 	SetPosition(Fix_X_coord, P+5);
 	PF(（2）返回);
 	Limit_Contact_capacity(Ordinal, 3,Fix_X_coord+sizeof("（1）输入置顶联系人的序号 (0退出) "), P+3);
 	if(strcmp(Ordinal, "0") == 0) break; 
 	for(i = 0; i < strlen(Ordinal); i++)
	{
		if(Ordinal[i]-'0' < 0 || Ordinal[i]-'0' > 9 || Ordinal[i] == ' ')
		{
			i = -1;
			break;
		 }  
	}
 	
 	
	if(i!=-1)
	{
		for(j = 0; j < strlen(Ordinal); j++)
	 	{
	 		O_num[j] = Ordinal[j]-'0';
	 		sum += O_num[j]*pow(10, strlen(Ordinal)-j-1);
		}
		if(sum <= Contact_num)
		{
			Love_Contact(&Friend, Ordinal); 
			To_Love_sort_again(&Friend, Ordinal);//如果删除的不是最后一个就要再次对序号进行排序  
		}
		else
		{
			system("cls");
			SetPosition(Fix_X_coord, Function_Infor_num);
			PF(请输入正确的序号！);
			SetPosition(Fix_X_coord, Function_Infor_num+1);
			system("pause");
		}
		
	}
	else
	{
		system("cls");
		SetPosition(Fix_X_coord, Function_Infor_num);
		PF(请输入正确的序号！);
		SetPosition(Fix_X_coord, Function_Infor_num+1);
		system("pause");
	}
 }
}

void Love_Contact(LinkContact *Friend, char *num)
{
	LinkContact pre, cur = (*Friend);
	LinkContact H;
	while(cur)
	{
		if(strcmp(cur->Ordinal, num)==0) break;
		pre = cur;
		cur = cur->next;
	}
	pre->next = NULL;
	H = cur;
	while(cur->next)
	{
		cur = cur->next;
	}
	cur->next = (*Friend)->next;
	(*Friend)->next = H;
}

void To_Love_sort_again(LinkContact *Friend, char *Ordinal)//再次对序号进行排序,必须保证传进来的数字字符串序号是存在的 
{
	LinkContact temp = (*Friend);
	temp = temp->next;//因为表头不是联系人信息，所以要先移动一步 
	int num = 1;
	char ch[5];
	while(temp)//不用管是否是删除的是最后一个，因为在进来之前已经判断过一次，为了节省要循环的次数就直接在进入这个函数之前先行判断了 
	{
		itoa(num, ch, 10);
		strcpy(temp->Ordinal, ch);
		temp = temp->next;
		num++;
	}
	 
}

/*-----------------------------------------------------------------------------------------------------------------*/


/*-------------------------------------------------退出功能--------------------------------------------------------*/
void Function_end()
{
	if(Friend != NULL) 
	{
		Release_Contact(&Friend); 
	} 
	Release_Filename(&fnameclub);
	system("cls");
	Show_EndFrame();
	Show_EndMeun(); 
	SetPosition(Fix_X_coord-1, Function_Infor_num+3);
	system("pause");
	exit(0);
}

void Show_EndFrame()
{
	SetPosition(Interface_X, P);
 	PF(*￥退出程序￥*);
 	SetPosition(Fix_X_coord-1, P+1);
 	PF_Function_Line;
 	SetPosition(Fix_X_coord, Function_Infor_num-1);
 	PF(--------------------------------------);
 	SetPosition(Fix_X_coord, Function_Infor_num);
 	printf("          (*￣︶￣)感谢使用！"); 
 	int i;
 	for(i = P; i < Function_Infor_num; i++)
 	{
 		SetPosition(Fix_X_coord-1, i+2);
 		PF(|);
 		SetPosition(Fix_X_coord+38, i+2);
 		PF(|);
	 }
	SetPosition(Fix_X_coord-1, Function_Infor_num+1);
 	PF_Function_Line;
}

void Show_EndMeun()
{
	SetPosition(Fix_X_coord+7, P+2);
 	PF(\t作品名：C 通 讯 录);
// 	SetPosition(Fix_X_coord, P+3);
// 	PF(（2）新建联系人);
 	SetPosition(Fix_X_coord, P+4);
 	PF(作者：Jackson.Wu);
// 	SetPosition(Fix_X_coord, P+5);
// 	PF(（4）搜索联系人);
 	SetPosition(Fix_X_coord, P+7);
 	PF(联系方式：## 1433223 ##);
// 	SetPosition(Fix_X_coord, P+7);
// 	PF(（6）删除联系人);
 	SetPosition(Fix_X_coord, P+10);
 	PF(Copyright 2022 Jackson.Wu );
// 	SetPosition(Fix_X_coord, P+9);
// 	PF(（8）退出程序);
}

/*-----------------------------------------------------------------------------------------------------------------*/

竹等寒

关注

3
点赞
踩
15

收藏

觉得还不错? 一键收藏
打赏
0
评论
C语言：通讯录程序设计（多功能）

作者前言：该通讯录作品是我大一的C语言结课作业，代码像shi山一样，之所以拿出来是想回忆一下我当时的想法和想结合一下我现在所学看能否有一些更新颖的想法碰撞出来，同时也会发出没有修改过的源代码。解释：首先我在写程序过程中遇到的必然是学校机房在单独将菜单清除再重新打印的时候会发生乱码的现象，这个原因我到现在还不明白，因为进入程序他不会乱，只有在我开始进行输入输出的时候就一下子乱了，所以我最后也是想到了要不直接将所有打印出来的都清掉重新打印，然后就有了现在这个刷屏这函数，所以也让我后面在写添加联系人和修改联系人
复制链接

扫一扫