【C++复习】指针、结构体、应用——通讯录管理系统

14天阅读挑战赛

一、指针

1.1 指针的定义和使用

指针的作用：可以通过指针间接访问内存.

• 内存编号是从0开始记录的，一般是十六进制数字表示
• 可以利用指针变量保存地址

指针的定义：

• 指针定义的语法：数据类型 * 指针变量名（p）

// 定义指针
int * p;

• 让指针记录变量 a 的地址

// 记录变量的地址
int a = 10;
p = &a;

• p 和 &a 输出结果均为 a 的地址

使用指针：

• 可以通过解引用的方式来找到指针指向的内存
• 指针前加 * 代表解引用，找到指针指向的内存中的数据，可以对其进行读取和修改

// 使用指针对数据进行读取和修改
*p = 1000;
cout << a <<endl;	// a = 1000
cout << *p <<endl; 	// *p = 1000

完整示例代码：

int main(){
	
	// 指针的定义
	int a = 10;
	int * p;
	
	// 指针的赋值
	p = &a;				// 指针p指向变量a的地址
	cout << &a <<endl;	// 输出a的地址
	cout << p <<endl;	// 输出a的地址

	cout << *p <<endl;	// 对p解引用，输出a的值10
	*p = 1000;			// 对指针指向的内存进行修改，即将改为1000
	cout << *p <<endl;	// 输出1000
	cout << a <<endl;	// 输出1000

	system("pause");
	return 0;
}

1.2 指针所占的内存空间

指针也是种数据类型，那么这种数据类型占用多少内存空间？

在32位操作系统下，占用4个字节空间（x86）；
在64位操作系统下，占用8个字节空间（x64）；

• 对于变量的内存，我们可以使用 sizeof() 函数

	cout << sizeof(int *) <<endl;		// 4
	cout << sizeof(char *) <<endl;		// 4
	cout << sizeof(float *) <<endl;		// 4
	cout << sizeof(double *) <<endl;	// 4

完整示例代码：

int main(){

	int a =10;
	int * p;
	p = &a;

	cout << *p <<endl;
	cout << sizeof(p) <<endl;
	cout << sizeof(char *) <<endl;
	cout << sizeof(float *) <<endl;
	cout << sizeof(double *) <<endl;

	system("pause");
	return 0;
}

1.3 空指针和野指针

空指针：指针变量指向内存中编号为 0 的空间
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的

• 指针变量的初始化：

int * p = NULL;

• 空指针内存不可以访问

*p = 100;
// 报错：写入访问权限冲突

• 完整示例代码：

int main(){

	// 指针变量p指向内存地址编号为0的空间
	int * p = NULL;

	// 访问空指针报错
	// 内存编号0~255为系统占用内存，不允许用户访问
	*p = 100;
}

野指针：指针变量指向非法的内存空间

• 完整示例代码：

int main(){
	// 指针变量p指向内存地址编号为0x1100的空间
	int * p = (int *)0x1100;
	
	// 访问野指针报错
	cout << *p <<endl;
	
	system("pause");
	return 0;
}

1.4 const修饰指针

const修饰指针有三种情况：

• const修饰指针：常量指针
• const修饰常量：指针常量
• const既修饰指针，又修饰常量

const修饰指针： 常量指针

• 当const修饰指针，指针的指向可以更改，但是指针指向的值不能修改

int a = 10;
int b = 10;
const int * p1 = &a;
	
p1 = &b;		// 正确
*p1 = 100;		// 报错

const修饰常量： 指针常量

• 当const修饰常量，指针的指向不能修改，但是指针指向的值可以更改

int * const p2 = &a;
*p2 = 20;			// 正确
p2 = &b;			// 报错

const同时修饰指针和常量

• 当const同时修饰指针和常量，指针的指向和指针指向的值都不能修改

const int * const p3 = &a;
*p3 = 20;			// 报错
p3 = &b;			// 报错

完整示例代码：

int main(){

	int a = 10;
	int b = 10;

	// const修饰指针，指针指向可以改，指针指向的值不能改
	// 常量指针
	const int * p1 = &a;
	p1 = &b;			// 正确
	*p1 = 100;			// 报错

	// const修饰常量，指针指向不能改，指针指向的值可以改
	// 指针常量
	int * const p2 = &a;
	p2 = &b;			// 报错
	*p2 = 100;			// 正确

	// const同时修饰指针和常量，指针的指向和指向的值都不能改
	const int * const p3 = &a;
	p3 = &b;			// 报错
	*p3 = 100;			// 报错

	system("pause");
	return 0; 
}

1.5 指针和数组

作用：
利用指针访问数组中的元素

完整示例代码：

int main(){
	

	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };

	int * p = arr;  //指向数组的指针

	cout << "第一个元素： " << arr[0] << endl;
	cout << "指针访问第一个元素： " << *p << endl;

	for (int i = 0; i < 10; i++){
		//利用指针遍历数组
		cout << *p << endl;
		p++;
	}

	system("pause");
	return 0;
}

1.6 指针和函数

作用：
利用指针作函数参数，可以修改实参的值.

完整示例代码：

//值传递
void swap1(int a ,int b)
{
	int temp = a;
	a = b; 
	b = temp;
}
//地址传递
void swap2(int * p1, int *p2){
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main() {

	int a = 10;
	int b = 20;
	swap1(a, b); // 值传递不会改变实参
	swap2(&a, &b); //地址传递会改变实参

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	system("pause");
	return 0;
}

总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递.

1.7 指针配合数组和函数案例

案例一
案例描述：
封装一个函数，利用冒泡排序，实现对整型数组的升序排序
例如数组：int arr[10] = { 4,3,6,9,1,2,10,8,7,5 }
代码示例：

//冒泡排序函数
void bubbleSort(int * arr, int len)  //int * arr 也可以写为int arr[]{
	for (int i = 0; i < len - 1; i++){
		for (int j = 0; j < len - 1 - i; j++){
			if (arr[j] > arr[j + 1]){
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

//打印数组函数
void printArray(int arr[], int len){
	for (int i = 0; i < len; i++){
		cout << arr[i] << endl;
	}
}

int main() {

	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	int len = sizeof(arr) / sizeof(int);

	bubbleSort(arr, len);
	printArray(arr, len);

	system("pause");
	return 0;
}

总结：当数组名传入到函数作为参数时，被退化为指向首元素的指针

二、结构体

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

2.1 结构体的定义和使用

语法：struct 结构体名 { 结构体成员列表 }；

通过结构体创建变量的方式有三种：

• struct 结构体名 变量名
• struct 结构体名 变量名 = { 成员1值 ， 成员2值…}
• 定义结构体时顺便创建变量

示例：

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
}stu3; //结构体变量创建方式3 


int main() {

	//结构体变量创建方式1
	struct student stu1; //struct 关键字可以省略

	stu1.name = "张三";
	stu1.age = 18;
	stu1.score = 100;
	
	cout << "姓名：" << stu1.name << " 年龄：" << stu1.age  << " 分数：" << stu1.score << endl;

	//结构体变量创建方式2
	struct student stu2 = { "李四",19,60 };

	cout << "姓名：" << stu2.name << " 年龄：" << stu2.age  << " 分数：" << stu2.score << endl;


	stu3.name = "王五";
	stu3.age = 18;
	stu3.score = 80;
	

	cout << "姓名：" << stu3.name << " 年龄：" << stu3.age  << " 分数：" << stu3.score << endl;

	system("pause");

	return 0;
}

总结1： 定义结构体时的关键字是struct，不可省略
总结2： 创建结构体变量时，关键字struct可以省略
总结3： 结构体变量利用操作符 ‘’.‘’ 访问成员

2.2 结构体数组

作用： 将自定义的结构体放入到数组中方便维护

语法： struct 结构体名 数组名[元素个数] = { {} , {} , ... {} }

示例：

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
}

int main() {
	
	//结构体数组
	struct student arr[3]=
	{
		{"张三",18,80 },
		{"李四",19,60 },
		{"王五",20,70 }
	};

	for (int i = 0; i < 3; i++)
	{
		cout << "姓名：" << arr[i].name << " 年龄：" << arr[i].age << " 分数：" << arr[i].score << endl;
	}

	system("pause");

	return 0;
}

2.3 结构体指针

作用： 通过指针访问结构体中的成员

• 利用操作符 -> 可以通过结构体指针访问结构体属性

示例：

//结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};


int main() {
	
	struct student stu = { "张三",18,100, };
	
	struct student * p = &stu;
	
	p->score = 80; //指针通过 -> 操作符可以访问成员

	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
	
	system("pause");

	return 0;
}

总结：结构体指针可以通过 -> 操作符 来访问结构体中的成员

2.4 结构体嵌套结构体

作用： 结构体中的成员可以是另一个结构体

例如： 每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体

示例：

//学生结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};

//教师结构体定义
struct teacher
{
    //成员列表
	int id; //职工编号
	string name;  //教师姓名
	int age;   //教师年龄
	struct student stu; //子结构体 学生
};


int main() {

	struct teacher t1;
	t1.id = 10000;
	t1.name = "老王";
	t1.age = 40;

	t1.stu.name = "张三";
	t1.stu.age = 18;
	t1.stu.score = 100;

	cout << "教师 职工编号： " << t1.id << " 姓名： " << t1.name << " 年龄： " << t1.age << endl;
	
	cout << "辅导学员 姓名： " << t1.stu.name << " 年龄：" << t1.stu.age << " 考试分数： " << t1.stu.score << endl;

	system("pause");

	return 0;
}

总结： 在结构体中可以定义另一个结构体作为成员，用来解决实际问题

2.5 结构体做函数参数

作用： 将结构体作为参数向函数中传递

传递方式有两种：

• 值传递
• 地址传递

示例：

//学生结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};

//值传递
void printStudent(student stu )
{
	stu.age = 28;
	cout << "子函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;
}

//地址传递
void printStudent2(student *stu)
{
	stu->age = 28;
	cout << "子函数中 姓名：" << stu->name << " 年龄： " << stu->age  << " 分数：" << stu->score << endl;
}

int main() {

	student stu = { "张三",18,100};
	//值传递
	printStudent(stu);
	cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age << " 分数：" << stu.score << endl;

	cout << endl;

	//地址传递
	printStudent2(&stu);
	cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age  << " 分数：" << stu.score << endl;

	system("pause");

	return 0;
}

总结： 如果不想修改主函数中的数据，用值传递，反之用地址传递

2.6 结构体中const使用场景

作用： 用const来防止误操作

示例：

//学生结构体定义
struct student
{
	//成员列表
	string name;  //姓名
	int age;      //年龄
	int score;    //分数
};

//const使用场景
void printStudent(const student *stu) //加const防止函数体中的误操作
{
	//stu->age = 100; //操作失败，因为加了const修饰
	cout << "姓名：" << stu->name << " 年龄：" << stu->age << " 分数：" << stu->score << endl;

}

int main() {

	student stu = { "张三",18,100 };

	printStudent(&stu);

	system("pause");

	return 0;
}

2.7 结构体案例

案例一：
案例描述：

学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下：
设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员.
学生的成员有姓名、考试分数、创建数组存放3名老师，通过函数给每个老师及所带的学生赋值.
最终打印出老师数据以及老师所带的学生数据.

学生的结构体：

struct Student
{
	string name;
	int score;
};

老师的结构体：

struct Teacher
{
	string name;
	Student sArray[5];
};

赋值函数：

void allocateSpace(Teacher tArray[] , int len)
{
	string tName = "教师";
	string sName = "学生";
	string nameSeed = "ABCDE";
	for (int i = 0; i < len; i++)
	{
		tArray[i].name = tName + nameSeed[i];
		
		for (int j = 0; j < 5; j++)
		{
			tArray[i].sArray[j].name = sName + nameSeed[j];
			tArray[i].sArray[j].score = rand() % 61 + 40;
		}
	}
}

打印：

void printTeachers(Teacher tArray[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << tArray[i].name << endl;
		for (int j = 0; j < 5; j++)
		{
			cout << "\t姓名：" << tArray[i].sArray[j].name << " 分数：" << tArray[i].sArray[j].score << endl;
		}
	}
}

示例完整代码：

struct Student
{
	string name;
	int score;
};
struct Teacher
{
	string name;
	Student sArray[5];
};

void allocateSpace(Teacher tArray[] , int len)
{
	string tName = "教师";
	string sName = "学生";
	string nameSeed = "ABCDE";
	for (int i = 0; i < len; i++)
	{
		tArray[i].name = tName + nameSeed[i];
		
		for (int j = 0; j < 5; j++)
		{
			tArray[i].sArray[j].name = sName + nameSeed[j];
			tArray[i].sArray[j].score = rand() % 61 + 40;
		}
	}
}

void printTeachers(Teacher tArray[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << tArray[i].name << endl;
		for (int j = 0; j < 5; j++)
		{
			cout << "\t姓名：" << tArray[i].sArray[j].name << " 分数：" << tArray[i].sArray[j].score << endl;
		}
	}
}

int main() {

	srand((unsigned int)time(NULL)); //随机数种子 头文件 #include <ctime>

	Teacher tArray[3]; //老师数组

	int len = sizeof(tArray) / sizeof(Teacher);
	allocateSpace(tArray, len); //创建数据
	printTeachers(tArray, len); //打印数据
	
	system("pause");
	return 0;
}

案例二：

案例描述：

设计一个英雄的结构体，包括成员姓名，年龄，性别;创建结构体数组，数组中存放5名英雄。

通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。

五名英雄信息如下：

		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},

示例完整代码：

//英雄结构体
struct hero
{
	string name;
	int age;
	string sex;
};
//冒泡排序
void bubbleSort(hero arr[] , int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (arr[j].age > arr[j + 1].age)
			{
				hero temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
//打印数组
void printHeros(hero arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << "姓名： " << arr[i].name << " 性别： " << arr[i].sex << " 年龄： " << arr[i].age << endl;
	}
}

int main() {

	struct hero arr[5] =
	{
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},
	};

	int len = sizeof(arr) / sizeof(hero); //获取数组元素个数

	bubbleSort(arr, len); //排序

	printHeros(arr, len); //打印

	system("pause");

	return 0;
}

三、通讯录管理系统

3.1 系统需求介绍

通讯录是一个记录亲人、好友信息的工具.

系统需要实现的功能如下：

• 添加联系人：向通讯录中添加新人（信息包括：姓名、性别、年龄、联系电话、家庭住址）最多记录1000人；
• 显示联系人：显示通讯录中所有联系人信息；
• 删除联系人：按照姓名进行删除指定联系人；
• 查找联系人：按照姓名查看指定联系人信息；
• 修改联系人：按照姓名重新修改指定联系人；
• 清空联系人：清空通讯录中所有信息；
• 推出通讯录：退出当前使用的通讯录；

对于该系统，我们先创建我们新的C++项目，命名为：通讯录管理系统.
我用的是 Dev-C++:

3.2 实现菜单功能

功能描述：
用户选择功能的界面.

步骤：

• 封装函数显示该界面，如 void showMenu()；
• 在 main 函数中调用封装好的函数.

功能实现代码：

// 功能零：显示菜单
void showMenu(){
	cout << "_______________________" <<endl;
	cout << "-----通讯录管理系统-----" <<endl;
	cout << "-----1、添加联系人------" <<endl;
	cout << "-----2、显示联系人------" <<endl;
	cout << "-----3、删除联系人------" <<endl;
	cout << "-----4、查找联系人------" <<endl;
	cout << "-----5、修改联系人------" <<endl;
	cout << "-----6、清空联系人------" <<endl;
	cout << "-----0、退出通讯录------" <<endl;
	cout << "------------------------" <<endl;
}

测试结果：

3.3 退出功能实现

功能描述：
退出通讯录系统

思路：
根据用户不同的选择，进入不同的功能，可以选择 switch 分支结构，将整个架构进行搭建.
当用户选择 0 时，执行退出，选择其他先不做操作，也不会退出程序.

功能实现代码：

// 主函数中直接实现退出
int main(){

	int select = 0;

	while(true){
		showMenu();
		cin >> select;
		switch(select){
			case 1:
				break;
			case 2:
				break;
			case 3:
				break;
			case 4:
				break;
			case 5:
				break;
			case 6:
				break;
			case 0:
				cout << "欢迎下次使用！" <<endl;
				system("pause");
				return 0;
				break;
			default:
				break;
		}
	}
	system("pause");
	return 0;
}

测试结果：

3.4 添加联系人

功能描述：
实现添加联系人功能，联系人上限为1000人，联系人信息包括：姓名、性别、年龄、联系电话、家庭住址.
步骤：

• 设计联系人结构体；
• 设计通讯录结构体；
• main 函数中创建通讯录；
• 封装添加联系人函数；
• 测试添加联系人函数.

功能实现代码：
设计联系人结构体：

# include<string>
struct Person{
	string m_Name;			// 姓名
	int m_Sex;				// 性别
	int m_Age;				// 年龄
	string m_Phone;			// 电话号码
	string m_Address;		// 地址
};

设计通讯录结构体：

# define MAX 1000

struct AddressList{
	struct Person personArray[MAX];		// 通讯录中保存联系人的数组
	int m_Size;							// 通讯录已有人数
};

添加联系人函数：

// 功能1：添加联系人
void addPerson(AddressList * abs){
	// 判断通讯录是否为满
	if(abs->m_Size==MAX){
		cout << "通讯录已满，无法添加！" <<endl;
	}
	else{
		// 添加具体联系人
		// 姓名
		string name;
		cout << "请输入添加联系人的姓名：" <<endl;
		cin >> name;
		abs->personArray[abs->m_Size].m_Name = name;
		
		// 性别
		int sex = 0;
		cout << "请输入添加联系人的性别：" <<endl;
		cout << "1 --- 男" <<endl;
		cout << "2 --- 女" <<endl;
		while(true){
			// 如果输入的是1或者2，退出循环
			// 如果为其他，则重新输入
			cin >> sex;
			if(sex==1||sex==2){
				abs->personArray[abs->m_Size].m_Sex = sex;
				break;
			}
			cout << "输入有误，请重新输入！" <<endl;
		}
		
		// 年龄
		int age = 0;
		cout << "请输入添加联系人的年龄：" <<endl;
		cin >> age;
		abs->personArray[abs->m_Size].m_Age = age;
		
		// 电话
		string phone;
		cout << "请输入添加联系人的联系电话：" <<endl;
		cin >> phone;
		abs->personArray[abs->m_Size].m_Phone = phone;
		
		// 地址
		string address;
		cout << "请输入添加联系人的地址：" <<endl;
		cin >> address;
		abs->personArray[abs->m_Size].m_Address = address;	
		
		// 更新通讯录人数
		abs->m_Size++;
		cout << "添加联系人成功！" <<endl;	
		
		system("pause");	// 按任意键继续
		system("cls");		// 清屏
	}
}

测试结果：

3.5 显示联系人

功能描述：
显示通讯录中已有的联系人信息.

步骤：

• 封装显示联系人函数
• 测试显示联系功能

功能实现代码：

// 功能2：显示联系人
void showPerson(AddressList * abs){
	// 判断通讯录中的人数是否为0，如果为0，提示通讯录为空
	// 如果不为0，显示记录的联系人信息
	if(abs->m_Size==0){
		cout << "当前通讯录为空！" <<endl;
	}
	else{
		for(int i=0;i<abs->m_Size;i++){
			cout << "姓名：" << abs->personArray[i].m_Name <<endl;
			cout << "性别：" << abs->personArray[i].m_Sex <<endl;
			cout << "年龄：" << abs->personArray[i].m_Age <<endl;
			cout << "电话：" << abs->personArray[i].m_Phone <<endl;
			cout << "住址：" << abs->personArray[i].m_Address <<endl;
			
		}
	}
	
	system("pause");
	system("cls");
}

3.6 删除联系人

功能描述：
按照姓名进行删除指定联系人.

步骤：

• 封装检测联系人是否存在的函数；
• 封装删除联系人函数.
• 测试删除联系人函数

功能实现代码：

// 预备功能：判断联系人是否存在
int isExit(AddressList * abs, string name){
	for(int i=0;i<abs->m_Size;i++){
		if(abs->personArray[i].m_Name==name){
			return i;
		}
	}
	
	return -1;
}

// 功能3：删除联系人
void deletePerson(AddressList * abs){
	string name;
	cout << "请输入要删除的联系人姓名：" <<endl;
	cin >> name;
	
	int ret = isExist(abs, name);
	if(ret != -1){
		for(int i=ret;i<abs->m_Size;i++){
			abs->personArray[i] = abs->personArray[i+1];
		}
		abs->m_Size--;
		cout << "删除成功！" <<endl;
	}
	else{
		cout << "查无此人！" <<endl;
	}
	
	system("pause");
	system("cls");
}

3.7 查找联系人

功能描述：
按照姓名查看指定联系人信息.

步骤：

• 封装查找联系人函数；
• 测试查找指定联系人.

功能实现代码：

// 功能4：查找联系人
void findPerson(AddressList * abs){
	string name;
	cout << "请输入需要查找的联系人姓名：" <<endl;
	cin >> name;
	
	int ret = isExist(abs, name);
	if(ret!=-1){
		cout << "姓名：" << abs->personArray[ret].m_Name <<endl;
		cout << "性别：" << abs->personArray[ret].m_Sex <<endl;
		cout << "年龄：" << abs->personArray[ret].m_Age <<endl;
		cout << "电话：" << abs->personArray[ret].m_Phone <<endl;
		cout << "地址：" << abs->personArray[ret].m_Address <<endl;
	}
	else{
		cout << "查无此人！" <<endl
	}
	
	system("pause");
	system("cls");
}

3.8 修改联系人

功能描述：
按照姓名重新修改指定联系人.

步骤：

• 封装修改联系人函数；
• 测试修改联系人函数.

功能实现代码：

// 功能5：修改联系人
void modifyPerson(AddressList * abs){
	string name;
	cout << "请输入要修改联系人的姓名：" <<endl;
	cin >> name;
	
	int ret = isExist(abs, name);
	if(ret!=-1){
		string name;
		cout << "请输入修改后的姓名：" <<endl;
		cin >> name;
		abs->personArray[ret].m_Name = name;
		
		int sex = 0;
		cout << "请输入修改后的性别：" <<endl;
		cout << "1 --- 男" <<endl;
		cout << "2 --- 女" <<endl;
		
	}
}

测试结果：

3.9 清空通讯录

功能描述：
清空通讯录中所有信息.
步骤：

• 封装清空联系人函数
• 测试清空联系人

功能实现代码：

// 功能6：清空通讯录
void cleanPerson(AddressList * abs){
	abs->m_Size = 0;
	cout << "通讯录已清空！" <<endl;
	system("pause");
	system("cls");
}

测试结果：

3.10 完整实现

完整代码：

# include<iostream>
# include<string>
using namespace std;

# define MAX 1000

struct Person{				// 联系人结构体
	string m_Name;			// 姓名
	int m_Sex;				// 性别
	int m_Age;				// 年龄
	string m_Phone;			// 电话号码
	string m_Address;		// 地址
};

struct AddressList{						// 通讯录结构体
	struct Person personArray[MAX];		// 通讯录中保存联系人的数组
	int m_Size;							// 通讯录已有人数
};

// 功能零：显示菜单
void showMenu(){
	cout << "______________________________" <<endl;
	cout << "|-----  通讯录管理系统  -----|" <<endl;
	cout << "------------------------------" <<endl;
	cout << "|-----  1、添加联系人  ------|" <<endl;
	cout << "|-----  2、显示联系人  ------|" <<endl;
	cout << "|-----  3、删除联系人  ------|" <<endl;
	cout << "|-----  4、查找联系人  ------|" <<endl;
	cout << "|-----  5、修改联系人  ------|" <<endl;
	cout << "|-----  6、清空联系人  ------|" <<endl;
	cout << "|-----  0、退出通讯录  ------|" <<endl;
	cout << "|----------------------------|" <<endl;
}

// 功能1：添加联系人
void addPerson(AddressList * abs){
	// 判断通讯录是否为满
	if(abs->m_Size==MAX){
		cout << "通讯录已满，无法添加！" <<endl;
	}
	else{
		// 添加具体联系人
		// 姓名
		string name;
		cout << "请输入添加联系人的姓名：" <<endl;
		cin >> name;
		abs->personArray[abs->m_Size].m_Name = name;
		
		// 性别
		int sex = 0;
		cout << "请输入添加联系人的性别：" <<endl;
		cout << "1 --- 男" <<endl;
		cout << "2 --- 女" <<endl;
		while(true){
			// 如果输入的是1或者2，退出循环
			// 如果为其他，则重新输入
			cin >> sex;
			if(sex==1||sex==2){
				abs->personArray[abs->m_Size].m_Sex = sex;
				break;
			}
			cout << "输入有误，请重新输入！" <<endl;
		}
		
		// 年龄
		int age = 0;
		cout << "请输入添加联系人的年龄：" <<endl;
		cin >> age;
		abs->personArray[abs->m_Size].m_Age = age;
		
		// 电话
		string phone;
		cout << "请输入添加联系人的联系电话：" <<endl;
		cin >> phone;
		abs->personArray[abs->m_Size].m_Phone = phone;
		
		// 地址
		string address;
		cout << "请输入添加联系人的地址：" <<endl;
		cin >> address;
		abs->personArray[abs->m_Size].m_Address = address;	
		
		// 更新通讯录人数
		abs->m_Size++;
		cout << "添加联系人成功！" <<endl;	
		
		system("pause");	// 按任意键继续
		system("cls");		// 清屏
	}
}

// 功能2：显示联系人
void showPerson(AddressList * abs){
	// 判断通讯录中的人数是否为0，如果为0，提示通讯录为空
	// 如果不为0，显示记录的联系人信息
	if(abs->m_Size==0){
		cout << "当前通讯录为空！" <<endl;
	}
	else{
		for(int i=0;i<abs->m_Size;i++){
			cout << "姓名：" << abs->personArray[i].m_Name <<endl;
			cout << "性别：" << abs->personArray[i].m_Sex <<endl;
			cout << "年龄：" << abs->personArray[i].m_Age <<endl;
			cout << "电话：" << abs->personArray[i].m_Phone <<endl;
			cout << "住址：" << abs->personArray[i].m_Address <<endl;
			
		}
	}
	
	system("pause");
	system("cls");
}

// 预备功能：判断查询人员是否存在
int isExist(AddressList * abs, string name){
	for(int i=0;i<abs->m_Size;i++){
		if(abs->personArray[i].m_Name==name){
			return i;
		}
	}
	
	return -1;
}

// 功能3：删除联系人
void deletePerson(AddressList * abs){
	string name;
	cout << "请输入要删除的联系人姓名：" <<endl;
	cin >> name;
	
	int ret = isExist(abs, name);
	if(ret != -1){
		for(int i=ret;i<abs->m_Size;i++){
			abs->personArray[i] = abs->personArray[i+1];
		}
		abs->m_Size--;
		cout << "删除成功！" <<endl;
	}
	else{
		cout << "查无此人！" <<endl;
	}
	
	system("pause");
	system("cls");
}

// 功能4：查找联系人
void findPerson(AddressList * abs){
	string name;
	cout << "请输入需要查找的联系人姓名：" <<endl;
	cin >> name;
	
	int ret = isExist(abs, name);
	if(ret!=-1){
		cout << "姓名：" << abs->personArray[ret].m_Name <<endl;
		cout << "性别：" << abs->personArray[ret].m_Sex <<endl;
		cout << "年龄：" << abs->personArray[ret].m_Age <<endl;
		cout << "电话：" << abs->personArray[ret].m_Phone <<endl;
		cout << "地址：" << abs->personArray[ret].m_Address <<endl;
	}
	else{
		cout << "查无此人！" <<endl;
	}
	
	system("pause");
	system("cls");
}

// 功能5：修改联系人
void modifyPerson(AddressList * abs){
	string name;
	cout << "请输入要修改联系人的姓名：" <<endl;
	cin >> name;
	
	int ret = isExist(abs, name);
	if(ret!=-1){
		string name;
		cout << "请输入修改后的姓名：" <<endl;
		cin >> name;
		abs->personArray[ret].m_Name = name;
		
		int sex = 0;
		cout << "请输入修改后的性别：" <<endl;
		cout << "1 --- 男" <<endl;
		cout << "2 --- 女" <<endl;
		
	}
}

// 功能6：清空通讯录
void cleanPerson(AddressList * abs){
	abs->m_Size = 0;
	cout << "通讯录已清空！" <<endl;
	system("pause");
	system("cls");
}

int main(){

	// 创建通讯录结构体变量
	AddressList abs;
	// 初始化通讯录中的当前人员
	abs.m_Size = 0;
	
	int select = 0;

	while(true){
		showMenu();
		cin >> select;
		switch(select){
			case 1:
				// 添加联系人
				addPerson(&abs);
				break;
			case 2:
				// 显示联系人
				showPerson(&abs);
				break;
			case 3:
				// 删除联系人
				deletePerson(&abs);
				break;
			case 4:
				// 查找联系人
				findPerson(&abs);
				break;
			case 5:
				// 修改联系人
				modifyPerson(&abs);
				break;
			case 6:
				// 清空通讯录
				cleanPerson(&abs);
				break;
			case 0:
				// 退出程序
				cout << "欢迎下次使用！" <<endl;
				system("pause");
				return 0;
				break;
			default:
				break;
		}
	}
	
	system("pause");
	return 0;
}