零基础学C++——黑马程序员课程笔记（C++基础语法入门篇）

封面来自互联网侵删
视频地址：点击访问
（我这里开发工具选用VSstudio）

此笔记有三个系列：

1. C++基础语法入门篇
2. C++核心编程篇 点击查看
3. C++提高编程篇
   

C++初识

变量

作用：给一段指定的内存空间起名，方便操作这段内存
语法：数据类型 变量名 = 初始值;

常量

作用：用于记录程序中不可更改的数[C++定义常量两种方式
1.#define宏常量：# define 常量名 常量值
通常在文件上方定义，表示一个常量
2.const修饰的变量：const 数据类型 常量名 = 常量值
通常在变是定义前加关键字const，修饰该变量为常量，不可修改

关键字

作用：关键字是C++中预先保留的单词（标识符）
在定义变量或者常量时候，不要用关键字

标识符命名规则

作用：C++规定给标识符(变量、常量)
命名时，有—套自己的规则
■标识符不能是关键字
■标识符只能由字母、数字、下划线组成
■第一个字符必须为字母或下划线
■标识符中字母区分大小写

数据类型

C++规定在创建一个变量或者常量时，必须要指定出相应的数据类型，否则无法给变量分配内存

整型

C++中能够表示整型的类型有以下几种方式，区别在于所占内存空间不同:

sizeof关键字

作用：利用sizeof关键字可以统计数据类型所占内存大小
语法：sizeof(数据类型/变量)

实型（浮点型float/double）

作用：用于表示小数
浮点型变量分为两种:
1.单精度float
2.双精度double
两者的区别在于表示的有效数字范围不同：

默认情况下输出一个小数，会显示出6位有效数字

#include <iostream>
using namespace std;

int main() {
	
	 float f1 = 3.14f;//后边加float是因为小数一般默认为double形式
	 double d1 = 3.14;
	 cout << "f1 = " << f1 << endl;
	 cout << "d1 = " << d1 << endl;

	 //科学计数法
	 float f2 = 3e2;//3 * 10^2
	 float f3 = 3e-2;//3 * 0.1 ^ 2;
	 cout << "f2 = " << f2 << endl;
	 cout << "f3 = " << f3 << endl;

	return 0;

}

结果：

字符型(char)

作用：字符型变量用于显示单个字符
语法：char ch = ‘a’;
注意
1.在显示字符型变量时，用单引号将字符括起来，不要用双引号注意
2.单引号内只能有一个字符，不可以是字符串

• C和C++中字符型变量只占用1个字节。
• 字符型变星并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元

转义字符

作用:用于表示—些不能显示出来的ASCII字符
常用的转义字符：\n \\ \t

#include <iostream>
using namespace std;

int main() {
	
	 cout << "aa\thello world" << endl;
	 cout << "aaaa\thello world" << endl;
	 cout << "aaaaaa\thello world" << endl;
	
	return 0;

}

结果：

字符串(string)

作用：用于表示一串字符工两种风格

• C风格字符串：char 变量名[ ] = “字符串值”
• C++风格字符串：string 变量名 = "字符串值”(使用时要使用头文件#include < string>)

布尔类型（bool）

作用：布尔数据类型代表真或假的值
bool类型只有两个值:

• true —真（本质是1)
• false —假(本质是0)
  bool类型占1个字节大小
  (bool类型只要不是0都代表真)(bool类型只要不是0都代表真)

运算符

算术运算符

两个小数不可以做取模运算(只有整型变量可以进行取模运算)

赋值运算符

比较运算符

逻辑运算符

程序流程结构

C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构

选择结构

if语句

作用：执行满足条件的语句if语句的三种形式

• 单行格式if语句
• 多行格式if语句
• 多条件的if语句

案例（三只小猪称体重）

#include <iostream>
using namespace std;
/*有三只小猪ABC，请分别输入三只小猪的体重，并且判断哪只小猪最重*/
int main() {
	
	int a, b, c = 0;
	cout << "依次输入三只小猪的体重"<<endl;
	cin >> a; cin >> b;cin >> c;
	char t = 'a';//记录小猪的名字
	cout << t;
	int num = 0;//记录小猪体重
	if (a < b) {
		t = 'b';
		num = b;
	}if (t < c) {
		t = 'c';
	}
	cout << "三只小猪中最重的是"<<t;
	return 0;

}

三目运算符

作用：通过三目运算符实现简单的判断
语法：表达式1 ? 表达式2 ：表达式3
解释：
如果表达式1的值为真，执行表达式2，并返回表达式2的结果;
如果表达式1的值为假，执行表达式3，并返回表达式3的结果。

switch语句

• switch缺点，判断时候只能是整型或者字符型，不可以是一个区间
• switch优点，结构清晰，执行效率高|Ⅰ
• switch语句中表达式类型只能是整型或者字符型
• case里如果没有break，那么程序会—直向下执行

循环结构

while循环语句

案例（三只小猪称体重）

#include <iostream>
using namespace std;
//time系统时间头文件
#include <ctime>

/*案例描述:系统随机生成一个1到100之间的数字，玩家进行猜测，如果猜错，
提示玩家数字过大或过小，如果猜对恭喜玩家胜利，并且退出游戏。
*/

int main() {

	//添加随机种子，利用当前系统时间生成随机数，防止每次随机数都一样
	srand((unsigned int)time(NULL));
	int num = rand() % 100 + 1;

	int val = 0;//玩家猜测的数字
	while (true) {
		cout << "请玩家输入你猜测的数字" << endl;
		cin >> val;
		if (num > val) {
			cout << "猜测的数字偏小" << endl;
		}
		else if (num < val) {
			cout << "猜测的数字偏大" << endl;
		}
		else {
			cout << "猜对了" << endl;
			break;
		}
	}
	return 0;

}

结果：

do…while循环语句

案例（水仙花数）

#include <iostream>
using namespace std;


/*案例描述:水仙花数是指一个3位数，它的每个位上的数字的3次幂之和等于它本身例如:1^3+5^3+ 3^3=153
请利用do...while语句，求出所有3位数中的水仙花数
*/

int main() {

	int num = 100;
	do {
		int bai = num / 100;
		int shi = num % 100 / 10;
		int ge = num % 10;
		int sum = bai * bai * bai + shi * shi * shi + ge * ge * ge;
		if (sum == num) {
			cout << num << endl;
		}
		num++;
	} while (num < 1000);

	return 0;

}

结果：

for循环语句

案例（敲桌子）

#include <iostream>
using namespace std;


/*案例描述:从1开始数倒数字100，如果数字个位含有7，或者数字十位含有7，或者该数字是7的倍数
我们打印敲桌子，其余数字直接打印输出。

*/

int main() {

	for (int i = 1; i <= 100; i++) {
		if (i % 10 == 7 || i / 10 == 7 || i % 7 == 0) {
			cout << "敲桌子"<<endl;
		}
		else {
			cout << i << endl;
		}
	}

	return 0;

}

结果：

嵌套循环

案例（乘法口诀表）

#include <iostream>
using namespace std;


/*
乘法口诀表
*/

int main() {

	for (int i = 1; i < 10; i++) {
		for (int t = 1; t <= i; t++) {
			cout << t << "×" << i << "=" << t * i<<"\t";
			
		}cout << endl;
	}

	return 0;

}

结果：

跳转语句

break语句

作用：用于跳出选择结构或者循环结构break使用的时机

• 出现在switch条件语句中，作用是终止case并跳出switch
• 出现在循环语句中，作用是跳出当前的循环语句
• 出现在嵌套循环中，跳出最近的内层循环语句

continue语句

goto语句

作用：可以无条件跳转语句
语法：goto 标记；
解释：如果标记的名称存在，执行到goto语句时，会跳转到标记的位置
不建议使用

#include <iostream>
using namespace std;

int main() {

	cout << "1.XXXXX." << endl;
	cout << "2.XXXXX." << endl;
	cout << "3.XXXXX." << endl;
	goto FLAG;
	cout << "4.XXXXX." << endl;
	cout << "5.XXXXX." << endl;
	FLAG:
	cout << "6.XXXXX." << endl;
	cout << "7.XXXXX." << endl;

	return 0;

}

结果：

数组

所谓数组，就是一个集合，里面存放了相同类型的数据元素

• 特点1∶数组中的每个数据元素都是相同的数据类型
• 特点2：数组是由连续的内存空间组成的

一维数组

定义方式

一维数组有三种定义方式：

数组名

—维数组名称的用途:
1.可以统计整个数组在内存中的长度
2.可以获取数组在内存中的首地址
arr = 100；错误，数组名是常量，不可以赋值，但每次重新运行都会重新分配内存，所以运行同一个程序每次得到的数组的首地址不一定相同

#include <iostream>
using namespace std;

int main() {

	int arr[] = { 1,2,3,4 };
	cout << "数组首地址："<<arr << endl;
	cout << "数组第一个元素地址：" << arr[0] << endl;
	cout << sizeof(arr) << endl;

	return 0;

}

两次运行结果：

案例（五只小猪称体重）

#include <iostream>
using namespace std;

/*
在一个数组中记录了五只小猪的体重，
如: int arr[5] = {300,350,200,400,250}; 找出并打印最重的小猪体重。
*/

int main() {

	int arr[5] = { 300,350,200,400,250 };
	int temp = arr[0];//记录每两个比较的比较重的一方的体重
	for (int i = 1; i < 5; i++) {
		if (temp < arr[i]) {
			temp = arr[i];
		}
	}
	cout << "最重的小猪体重是：" << temp << endl;

	return 0;

}

结果：

案例（）

int length = sizeof(arr) / sizeof(arr[0]);//数组长度

#include <iostream>
using namespace std;

/*
案例描述:请声明一个5个元素的数组，并且将元素逆置.
(如原数组元素为:1,3,2,5,4;逆置后输出结果为:4,5,2,3,1);

*/

int main() {

	int arr[5] = { 1,3,2,5,4 };
	int temp = 0;//辅助元素交换
	int length = sizeof(arr)/sizeof(arr[0]);//数组长度
	//cout << length << endl;
	for (int i = 0; i <= length/2; i++) {
		temp = arr[i];
		int end = length - i;
		arr[i] = arr[length-1 - i];
		arr[length-1 - i] = temp;
	}
	cout << "逆置后数组为：";
	for (int n = 0; n < length; n++) {
		cout << arr[n] << " ";
	}
	
	return 0;

}

结果：

冒泡排序

作用：最常用的排序算法，对数组内元素进行排序
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值。
3.重复以上的步骤，每次比较次数-1，直到不需要比较

#include <iostream>
using namespace std;

/*
案例描述:请声明一个5个元素的数组，并且将元素逆置.
(如原数组元素为:1,3,2,5,4;逆置后输出结果为:4,5,2,3,1);

*/

int main() {

	int arr[ ] = {4,2,8,0,5,7,1,3,9};
	int temp = 0;//辅助元素交换
	int length = sizeof(arr)/sizeof(arr[0]);//数组长度
	cout << "初始数组为：";
	for (int n = 0; n < length; n++) {
		cout << arr[n] << " ";
	}cout << endl;

	for (int i = 0; i < length-1 ; i++) {
		for (int n = 0; n < length -i-1; n++) {
			temp = arr[n];
			if (arr[n] > arr[n+1]) {
				arr[n] = arr[n + 1];
				arr[n + 1] = temp;
			}

		}
		
	}
	cout << "排序后数组为：";
	for (int n = 0; n < length; n++) {
		cout << arr[n] << " ";
	}
	
	return 0;

}

结果：

二维数组

二维数组定义的四种方式:
1.数据类型数组名[行数][列数]；
2.数据类型数组名[行数][列数]={ {数据1，数据2}，{数据3，数据4 }};
3.数据类型数组名[行数][列数]={数据1，数据2，数据3，数据4};
4.数据类型数组名[ ][列数]={数据1，数据2，数据3，数据4};
建议:以上4种定义方式，利用第二种更加直观，提高代码的可读性
可以省去行数，但不可以省去列数

函数

函数定义里小括号内称为形参，函数调用时传入的参数称为实参

值传递

• 所谓值传递，就是函数调用时实参将数值传入给形参
• 值传递时，如果形参发生改变，并不会影响实参

常见样式

常见的函数样式有4种
1.无参无返
2.有参无返
3.无参有返
4.有参有返

函数声明

• 作用：告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
• 函数的声明可以多次，但是函数的定义只能有一次

函数的分文件编写

作用：让代码结构更加清晰函数分文件编写
一般有4个步骤
1.创建后缀名为.h的头文件
2.创建后缀名为.cpp的源文件
3.在头文件中写函数的声明
4.在源文件中写函数的定义

指针

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

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

指针的定义和使用

#include <iostream>
using namespace std;

/*
*/

int main() {
	//定义指针
	int a = 10;
	int* p = &a;
	cout << "a的地址：" << &a << endl;
	cout << "指针p为：" << p << endl;

	//使用指针
	//可以通过解引用的方式来找到指针指向的内存
	//指针前加*代表解引用，找到指针指向的内存中的数据
	cout << "a=" << a << endl;
	cout << "*p=" << *p << endl;
	return 0;
}

结果：

指针所占内存空间

#include <iostream>
using namespace std;

/*
*/

int main() {
	//定义指针
	int a = 10;
	int* p = &a;
	
	cout << "指针p所占内存：" << sizeof(p) << endl;//sizrof(int*)

	
	return 0;
}

结果：

1. 在32位操作系统下，无论什么类型的指针都占4字节（X86）
2. 在64位操作系统下，无论什么类型的指针都占8字节（X64）

空指针和野指针

空指针

空指针：指针变量指向内存中编号为0的空间
用途：初始化指针变量
注意：空指针指向的内存是不可以访问的
0~255之间的内存编号是系统占用的，我们没有权限访问

野指针

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

const修饰指针

const修饰指针有三种情况：

1. const修饰指针——常量指针
   const int *p = 10;
   指针的指向可以改，但是指针指向的值不可以改
2. const修饰常量——指针常量
   int * const p = 10;
   指针的指向不可以改，但指针指向的值可以改
3. const即修饰指针，又修饰常量
   const int * const p = 10;
   指针的指向不可以改，指针指向的值不可以改

指针和数组

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

#include <iostream>
using namespace std;

/*
*/

int main() {
	int arr[] = { 1,2,3,4 };
	int* p = arr;
	for (int i = 0; i < 4; i++) {
		cout << "  " << *p ;
		p++;
	}


	return 0;
}

结果：

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

指针、数组、函数

案例（函数实现冒泡）

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

#include <iostream>
using namespace std;

/*
封装一个函数，利用冒泡排序，实现对整型数组的升序排序
*/
void sort(int length, int* arr);
int main() {
	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	int length = sizeof(arr) / sizeof(int);
	sort(length, arr);
	for (int i = 0; i < 10; i++) {
		cout << arr[i] << " ";
	}
	return 0;
}
void sort(int length,int *arr) {
	for (int i = 0; i < length - 1; i++) {
		for (int n = 0; n < length-i - 1; n++) {
			if (arr[n] > arr[n + 1]) {
				int temp = arr[n];
				arr[n] = arr[n + 1];
				arr[n + 1] = temp;
			}
		}
	}
}

结果：

结构体

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

结构体的定义和使用

语法:struct 结构体名 {结构体成员列表};
通过结构体创建变量的方式有三种:

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

定义结构体时的关键字是struct，不可省略:
创建结构体变量时，关键字struct可以省略

结构体指针

const在结构体的使用

案例一

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

#include <iostream>
using namespace std;
#include <string>
struct Student {
	string sName;
	int Score;
};
struct Teacher {
	string tName;
	struct Student sArr[5];
};

//给老师赋值
void write(int len, struct Teacher tArr[]) {
	string seed = "ABCDE";
	for (int i = 0; i < len; i++) {
		tArr[i].tName = "teacher_";
		tArr[i].tName += seed[i];
		for (int j = 0; j < 5; j++) {
			tArr[i].sArr[j].sName = "student_";
			tArr[i].sArr[j].sName += seed[j];
			tArr[i].sArr[j].Score = 60;
		}
	}
}
//打印
void printshow(int len, struct Teacher tArr[])
{
	for (int i = 0; i < len; i++) {
		cout << "老师名字：" << tArr[i].tName << endl;
		for(int j = 0; j < len; j++) {
			cout << "学生名字：" << tArr[i].sArr[j].sName 
				<<"  考试分数："<< tArr[i].sArr[j].Score << endl;
		}
	}
}
int main() {
	struct Teacher tArr[3];
	int len = sizeof(tArr) / sizeof(tArr[0]);
	write(len, tArr);
	printshow(len, tArr);
	return 0;
}

结果：

案例二

设计一个英雄的结构体，包括成员姓名，年龄，性别;创建结构体数组，数组中存放5名英雄。通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。

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

struct Yingxiong {
	string name;
	int age;
	string sex;
};
void sort(int len,struct Yingxiong arr[]) {
	for (int i = 0; i < len - 1;i++) {
		for (int n = 0; n < len - i - 1; n++) {
			if (arr[n].age > arr[n + 1].age) {
				Yingxiong temp = arr[n];
				arr[n] = arr[n + 1];
				arr[n + 1] = temp;
			}
		}
	}
}
void show(int len, struct Yingxiong arr[]) {
	for (int i = 0; i < len; i++) {
		cout << arr[i].name << "\t" << arr[i].age << "\t" << arr[i].sex<<endl;
	}
}
int main() {
	struct Yingxiong arr[5] =
	{
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},
	};
	int len = sizeof(arr) / sizeof(arr[0]);
	sort(len, arr);
	show(len, arr);
	return 0;
}

结果：


这里交换时，是根据年龄判断大小然后互换的是整个结构体，如果只互换年龄就会导致人名和年龄以及性别不匹配的问题。

通讯录管理系统

(可以根据自己的喜欢增加系统功能)

系统需求

通讯录是一个可以记录亲人、好友信息的工具。
本教程主要利用C++来实现一个通讯录管理系统系统中需要实现的功能如下:

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

添加联系人

添加联系人实现步骤:

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

删除联系人

根据姓名查找删除联系人
功能描述:按照姓名进行删除指定联系人
删除联系人实现步骤:

• 封装枪测联系人是否存在
• 封装删除联系人函数
• 测试删除联系人功能

封装检测联系人是否存在
设计思路:
删除联系人前，我们需要先判断用户输入的联系人是否存在，如果存在删除，不存在提示用户没有要删除的联系人。因此我们可以把检测联系人是否存在封装成一个函数中，如果存在，返回联系人在通讯录中的位置，不存在返回-1

重点

1. -
2. 点击任意键进行清屏
   
3. 删除联系人操作实质上：下一个数据覆盖前一个数据

源代码

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

#define MAX 1000
//联系人结构体
struct Person {
	string m_Name;//姓名
	string m_Sex;//性别
	int m_age;//年龄
	string m_Phone;//电话
	string m_Addr;//地址
};
// 通讯录结构体
struct Addressbooks {
	struct Person personArray[MAX];
	int m_Size;//通讯录中人数
};
//菜单
void showMenu() {
	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;
}
//添加联系人
void addPersion(Addressbooks *abs) {
	//通讯录是否已经满了
	if (abs->m_Size == MAX) {
		cout << "通讯录已满，无法添加！" << endl;
		return;
	}else {
		string name;
		cout << "请输入姓名：" << endl;
		cin >> name;
		abs->personArray[abs->m_Size].m_Name = name;

		string sex;
		cout << "请输入性别：" << endl;
		cin >> sex;
		abs->personArray[abs->m_Size].m_Sex = sex;

		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_Addr = address;
		
		//更新通讯录
		abs->m_Size++;
		
		cout << "添加成功！" << endl;
		//system("pause");
		//system("cls");
	}
	system("pause");
	system("cls");
}
void showPerson(Addressbooks* abs) {
	if (abs->m_Size == 0) {
		cout << "记录为空！" << endl;
	}
	else {
		cout << "姓名\t性别\t年龄\t电话\t地址" << endl;
		for(int i = 0;i < abs->m_Size;i++){//小心溢出
			
			cout << abs->personArray[i].m_Name
				<<"\t" << abs->personArray[i].m_Sex 
				<< "\t" << abs->personArray[i].m_age 
				<< "\t" << abs->personArray[i].m_Phone 
				<< "\t" << abs->personArray[i].m_Addr 
				<<endl;
		}
		
	}
		system("pause");
		system("cls");
}
//检测联系人是否存在，如果存在，返回联系人数组所在的具体位置，不存在返回-1
int isExit(Addressbooks* abs, string name) {
	for (int i = 0; i < abs->m_Size; i++) {
		if (abs->personArray[i].m_Name == name) {
			return i;
		}
		
	}
	return -1;
}
//删除联系人
void deletePerson(Addressbooks* abs ) {
	cout << "输入您想要删除的联系人：" << endl;
	string name;
	cin >> name;
	//判断这个人是否存在
	int ret = isExit(abs, name);
	if (ret == -1) {
		cout << "查无此人" << endl;
	}
	else {
		for (int i = ret; i < abs->m_Size; i++) {
			//数据前移
			abs->personArray[i] = abs->personArray[i + 1];
		}
		abs->m_Size--;//更新人数
		cout << "删除成功" << endl;
	}
	system("pause");
	system("cls");
}
//查找联系人
void searchPerson(Addressbooks* abs) {
	cout << "请输入您需要查找的联系人：" << endl;
	string name;
	cin >> name;
	int ret = isExit(abs, name);
	if (ret == -1) {
		cout << "查无此人" << endl;
	}
	else {
		cout << "姓名\t性别\t年龄\t电话\t地址" << endl;
		cout << abs->personArray[ret].m_Name
			<< "\t" << abs->personArray[ret].m_Sex
			<< "\t" << abs->personArray[ret].m_age
			<< "\t" << abs->personArray[ret].m_Phone
			<< "\t" << abs->personArray[ret].m_Addr
			<< endl;
	}
	system("pause");
	system("cls");
}
//修改联系人
void alterPerson(Addressbooks* abs) {
	cout << "请输入您需要修改的联系人：" << endl;
	string name;
	cin >> name;
	int ret = isExit(abs, name);
	if (ret == -1) {
		cout << "查无此人" << endl;
	}
	else {
		cout << "修改前的信息：" << endl;
		cout << "姓名\t性别\t年龄\t电话\t地址" << endl;
		cout << abs->personArray[ret].m_Name
			<< "\t" << abs->personArray[ret].m_Sex
			<< "\t" << abs->personArray[ret].m_age
			<< "\t" << abs->personArray[ret].m_Phone
			<< "\t" << abs->personArray[ret].m_Addr
			<< endl;
		cout << "选择您想要修改当前人的信息（姓名/性别/年龄/电话/地址）：";
		string num;
		cin >> num;
		if (num == "姓名") {
			cout << "请输入新的" << num << "信息:";
			string name1;
			cin >> name1;
			abs->personArray[ret].m_Name = name1;
		}if (num == "性别") {
			cout << "请输入新的" << num << "信息:";
			string sex1;
			cin >> sex1;
			abs->personArray[ret].m_Sex = sex1;
		}if (num == "年龄") {
			cout << "请输入新的" << num << "信息:";
			int age1;
			cin >> age1;
			abs->personArray[ret].m_age = age1;
		}if (num == "电话") {
			cout << "请输入新的" << num << "信息:";
			string phone1;
			cin >> phone1;
			abs->personArray[ret].m_Phone = phone1;
		}if (num == "地址") {
			cout << "请输入新的" << num << "信息:";
			string address1;
			cin >> address1;
			abs->personArray[ret].m_Addr = address1;
		}
		cout << "修改后的信息：" << endl;
		cout << "姓名\t性别\t年龄\t电话\t地址" << endl;
		cout << abs->personArray[ret].m_Name
			<< "\t" << abs->personArray[ret].m_Sex
			<< "\t" << abs->personArray[ret].m_age
			<< "\t" << abs->personArray[ret].m_Phone
			<< "\t" << abs->personArray[ret].m_Addr
			<< endl;
		cout << "修改成功！" << endl;
	}
	system("pause");
	system("cls");
}
//清空联系人
void cleanPerson(Addressbooks* abs) {
	abs->m_Size = 0;
	cout << "通讯录已清空！" << endl;
	system("pause");
	system("cls");
}
int main() {
	//创建通讯录
	Addressbooks abs;
	abs.m_Size = 0;
	
	while (true) {
		showMenu();
		int select = 0;//记录用户的输入
		cin >> select;
		switch (select) {
			case 1: //添加联系人
				addPersion(&abs);//利用地址传递可以修饰实参
				break;
			case 2: //显示联系人
				showPerson(&abs);
				break;
			case 3: //删除联系人
				deletePerson(&abs);
				break;
			case 4: //查找联系人
				searchPerson(&abs);
				break;
			case 5: //修改联系人
				alterPerson(&abs);
				break;
			case 6: //清空联系人
				cleanPerson(&abs);
				break;
			case 0:	//退出通讯录
				cout << "欢迎下次使用" << endl;
				exit(0);
				break;
			default:
				cout << "请根据提示选择正确的操作" << endl;
				break;
		}
	}
	
	
	return 0;
}

结果：

运行程序，当前通讯录中没有数据




现在向通讯录中添加三个联系人：
显示联系人：

查找联系人：

修改联系人：

删除联系人并查看：


清空联系人并显示：


退出通讯录：