如果你准备学习C++,并且有C语言的基础，我希望你能简单的过一遍知识点。

相关视频——黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难_哔哩哔哩_bilibili（1-83）

我的小站——半生瓜のblog

我知道这个视频早已经被很多人学习并且记录笔记，但是我还是想再过一遍前面的基础知识点，所以我这个笔记会非常的简洁，适合有C语言基础的小伙伴进行简单的基础知识复习，好尽快投入到C++的学习中。

在基础知识部分，好像只有头文件的引用和输入输出函数发生了变化。

头文件下加入using namespace std;

#include——>#include< iostream>

printf——>cout

scanf——>cin

C++有字符串类型string,这是C语言所不具备的。

下面就让我们开始吧！

• • Hello C++
  • • 第一个程序
    • 注释
    • 变量
    • 常量
    • 关键字
    • 标识符命名规则
  • 数据类型
  • • 整型
    • sizeof关键字
    • 实型(浮点型)
    • 字符型
    • 转义字符
    • 字符串
    • 布尔类型bool
    • 数据 输入
  • 运算符
  • • 算数运算符
    • 赋值运算符
    • 比较运算符
    • 逻辑运算符
  • 程序流程结构
  • • 选择结构
    • • if语句
      • 三目运算符
      • switch语句
    • 循环结构
    • • while循环语句
      • • 猜数字练习
      • do-while循环语句
      • • 水仙花数练习
      • for循环语句
      • 敲桌子练习
      • • 是7的倍数、各位有7、十位有7
      • 嵌套循环
      • • 打印10*10的正方形
        • 乘法口诀表练习
      • 跳转语句
      • break语句
      • continue语句
      • goto语句
  • 数组
  • • 概述
    • 一维数组
    • • 定义
      • 数组名的用途
      • 输出最重的一只小猪的体重
      • 数组元素逆置
      • 冒泡排序
    • 二维数组
    • • 数组名
      • 考试成绩统计练习
  • 函数
  • • 概述
    • 函数的定义
    • 函数的调用
    • 值传递
    • 函数的常见样式
    • 函数的声明
    • 函数的分文件编写
  • 指针
  • • 概念
    • 指针变量的定义和使用
    • 指针所占内存空间
    • 空指针
    • 野指针
    • const修饰指针
    • 指针和数组
    • 指针和函数
    • 指针、数组、函数
  • 结构体
  • • 概念
    • 定义和使用
    • 结构体数组
    • 结构体指针
    • 结构体嵌套结构体
    • 结构体做函数参数
    • 结构体中const使用场景
    • 结构体案例
  • 通讯录

#include 
using namespace std;
int main(void)
{
	cout << "Hellow world" << endl;
	system("pause");
	return 0;
}

方便自己和他人阅读,不会被程序执行。

//单行

作用:给一段指定的内存空间起名，方便操作这段内存。

语法:数据类型 变量名 = 初始值；

int a = 10;
cout << "a = "<< a << endl;

作用：用于记录程序中不可更改的数据。

C++定义常量的两种方法

1.#define宏定义

#define 常量名 常量值

通常在文件上方定义,表示一个常量。

2.const修饰的变量

const 数据类型 常量名 = 常量值

通常在变量定义之前加关键字const,修饰该变量为常量，不可修改。

示例：

#define day 7//是不可修改的值，一旦修改就会报错

const int month = 30;

作用:关键字是C++中预先保留的单词（标识符）

在定义变量或常量的时候不要使用关键字。

来源（菜鸟教程——C++ 的关键字（保留字）完整介绍 | 菜鸟教程 (runoob.com)）

作用：C++规定给标识符(变量、常量)命名时，有一套自己的规则

• 标识符不能是关键字
• 标识符只能由字母、数字、下划线组成
• 第一个字符必须为字母或者下划线
• 标识符中字母区分大小写
• (建议：给标识符命名的时候，争取做到见名知意，方便自己和他人阅读。)

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

作用：整型变量表示的是整型类型的数据。

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

作用：统计数据类型所占空间的大小。

语法：

sizeof(数据类型/变量);

示例：

#include 
using namespace std;
int main(void)
{
	cout << "int类型所占空间的大小是：" < 
实型(浮点型) 
作用：用于表示小数。
 
浮点型分为两种-单精度float-双精度double。
 
两者的区别在于有效数字的表示范围不一样。
 
 
float f1 = 3.14f;//编译器会默认把一个小数当做双精度//默认情况下输出一个小数会显示出6位有效数字//例如：下面这个f1只输出到6float f1 = 3.1234567f;
 
字符型 
作用：字符型变量用于显示单个字符。
 
语法：
 
char sb = 'a';

 
C和C++中字符型变量只占1个字节。
字符型变量并不是把所有的字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元中。
 
转义字符 
作用：用于表示一些不能显示出来的ASCII字符。
 
 
(图片来源——w3cschoolw3cschoolC语言转义字符 (biancheng.net))
 
cout << “hello worldn”<< endl;
 
字符串 
作用:用于表示一串字符串。
 
两种风格：
 
1.C风格字符串
 
要用双引号括起来
 
char 变量名[] = "字符串值";
 
char str1[] = "hello world";
 
2.C++风格字符串
 
需要加入头文件#include 
 
string 变量名 = "字符串值";
 
string st2 = "hellow world";
 
布尔类型bool 
作用:布尔类型数据代表真或假的值。
 
bool类型只有两个值：
 
true——真（1）
false——假（0）
 
bool类型占1个字节大小
 
示例：
 
bool flag = true;
 
数据 输入 
作用：用于从键盘获取数据
 
关键字：cin
 
语法：
 
cin >> 变量
 
int a = 0;cin >>a;
 
运算符 
作用:用于代码的运算。
 
 
算数运算符 
作用：用于处理四则运算
 
 
+ - * / % ++ -- 
两个整数相除结果还是整数
两个小数相除结构还是小数
两个数相除除数不可以为0
 
	前置递增++a——先让变量+1然后再进行表达式运算    
	后置递增a++——先进行表达式运算然后变量再+1    
	递减同理
 
赋值运算符 
**作用：**用于将表达式的值赋给变量。
 
 
示例：
 
int a = 1;a *=2;//意思就是就是a = a *2;
 
比较运算符 
**作用：**用于表达式的比较，并返回一个真值或假值。
 
 
示例：
 
	int a = 4;
	int b = 3;	
	cout << (a < b)< 
逻辑运算符 
作用：用于根据表达式的值返回真值或假值。
 
 
示例：
 
int a = 9;
int b = 10;
int c = 0;
cout<< !a < 
程序流程结构 
C/C++支持最基本的三大基本程序运算结构:顺序结构、选择结构、循环结构。
 
顺序结构：程序按顺序执行，不发生跳转。
选择结构：依据条件是否满足,有选择的执行相应代码。
循环结构：依据条件是否满足，循环多次指定某段代码。
 
选择结构 
if语句 
作用：执行满足条件的语句。
 
单行格式if语句
 
if(条件){	//条件满足执行的语句}
 
多行格式if语句
 
if(条件)
{   
 //条件满足执行的语句
}
else
{    
	//条件不满足执行的语句
}
 
多条件if语句
 
if(条件1)
{
    //条件1满足执行的语句
}
else if(条件2)
{
    //条件2满足执行的语句
}
......
else
{
    //都不满足执行的语句
}
 
嵌套if语句
 
if()
{
    if()
}
else
{
    
}
 
三目运算符 
**作用：**通过三目运算符实现简单的判断
 
语法：
 
表达式1？表达式2：表达式3
 
解释：
 
如果1为真，则结果为表达式2的值。
 
如果1为假，则结果为表达式3的值。
 
示例：
 
int a = 9;
int b = 10;
int c = 0;
c = a > b ? a : b;
cout << c << endl;//结果为10
 
switch语句 
**作用：**执行多条件分支语句
 
语法：
 
switch(表达式)
{
        case 结果1：
            执行语句;
            break;
        ......
        default：
            执行语句;
        	break;
}
 
循环结构 
while循环语句 
作用:满足循环条件，执行循环语句
 
语法:
 
while(循环条件){    循环语句}
 
**解释：**只要满足循环条件的结果为真，就执行循环语句。
 
猜数字练习 
#include 
#include
using namespace std;
int main(void)
{
	int num = rand() % 100;
	cout << num << endl;
	int puT = 0;
	cout << "请你猜一下这个数是多少n" << endl;
	while ((cin >> puT))
	{
		if (puT > num)
		{
			cout << "猜大了n" << endl;
		}
		else if (puT <= num / 2)
		{
			cout << "太小了n" << endl;
		}
		else if (puT >= num / 2 && puT < num)
		{
			cout << "再大一点n" << endl;
		}
		else if (num == puT)
		{
			cout << "猜对了n" << endl;
			break;
		}
	}
	system("pause");
	return 0;
}
 
do-while循环语句 
**作用：**满足循环条件，执行循环语句。
 
语法:
 
do{    
	循环语句
}while(循环条件)
 
注意:与while的区别在于do-while会先执行一次循环语句，再判断循环条件。
 
水仙花数练习 
#include 
using namespace std;
int main(void)
{
	int ge = 0;
	int shi = 0;
	int bai = 0;
	int i = 100;
	do
	{
		ge = i % 10;
		shi = (i / 10) % 10;
		bai = i / 100;
		if (i == ge * ge * ge + shi * shi * shi + bai * bai * bai)
		{
			cout << i << endl;
		}
		i++;
	} while (i < 1000);
	system("pause");
	return 0;
}
 
for循环语句 
作用:满足循环条件，执行循环语句
 
语法:
 
for(起始条件;条件表达式;末尾循环体){    循环语句}
 
示例：
 
#include
using namespace std;
int main(void)
{    
    for(int i = 0;i < 10;i++)   
    {    
        
    }    
    return 0;
}
 
敲桌子练习 
是7的倍数、各位有7、十位有7 
#include
using namespace std;
int main(void)
{	
    for (int i = 1; i < 100; i++)	
    {		
        int ge = i % 10;		
        int shi = (i /10)% 10;		
        if (i % 7 == 0 || ge == 7 || shi == 7)		
        {			
            cout << i << endl;		
        }	
    }
}
 
嵌套循环 
作用:在循环体中再嵌套一层循环，解决一些实际问题。
 
打印10*10的正方形 
#include
using namespace std;
int main(void)
{
	for (int i = 0; i < 10; i++)
	{
		for (int i = 0; i < 10; i++)
		{
			cout << "* ";
		}
		cout << endl;
	}
}
 
乘法口诀表练习 
#include
using namespace std;
int main(void)
{	
    for (int i = 1; i < 10; i++)	
    {			
        for (int j = 1; j <= i; j++)		
        {			
            cout << i <<"*"<< j<<"="<< i* j<<" ";		
        }		
        cout << endl;	
    }
    system("pause");
    return 0;
}
 
跳转语句 
break语句 
作用:用于跳出选择结构或者循环结构。
 
break使用的时机：
 
出现在switch语句中，作用是终止case并跳出swtich
出现在循环语句中，作用是跳出当前的循环语句
出现在嵌套语句中，跳出最近的内层循环语句
 
continue语句 
作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环。
 
goto语句 
作用:可以无条件跳转语句
 
语法:goto标记；
 
**解释：**如果标记的名称存在，执行到goto语句的时候，会跳转到标记的位置。
 
goto sb;......
sb:......
 
数组 
概述 
所谓数组就是一个集合，里面存放了相同类型的数据元素
 
特点1：数组中的每个数据元素都是相同的数据类型。
 
特点2：数组是由连续的内存位置组成的。
 
一维数组 
定义 
数据类型 数组名[数组长度];
数据类型 数组名[数组长度] = {值1，值2......};
数据类型 数组名[] = {值1，值2......};;
 
数组名的用途 
1.可以统计整个数组在内存中的长度
 
2.可以获取数组在内存中的首地址
 
输出最重的一只小猪的体重 
#include
using namespace std;
int main(void)
{	
    int temp = 0;	
    int Weight[5] = { 300,250,200,400,450 };	
    for (int i = 0; i < 5; i++)	
    {		
        if (Weight[i] > temp)		
        {			
            temp = Weight[i];		
        }	
    }	
    cout << "最重的小猪是" << temp << "kg";	
    return 0;
}
 
数组元素逆置 
#include
using namespace std;
int main(void)
{ 	
    int temp = 0;	
    nt nums[5] = { 1,2,3,4,5};	
    int start = 0;	
    int end = sizeof(nums)/sizeof(nums[0]) -1 ;	
    while (start < end)	
    {		
        temp = nums[start];		
        nums[start] = nums[end];		
        nums[end] = temp;		
        end--;		
        start++;	
    }	
    for (int i = 0; i < 5; i++)
    {		
        cout << nums[i];	
    }	
    return 0;
}
 
冒泡排序 
作用:最常用的排序算法，对数组内元素进行排序
 
比较相邻两个元素，如果第一个比第二个大就交换他们的位置
每一对相邻元素做同样的工作，整型完毕后，找到第一个最大值。
重复以上的步骤，每次比较次数-1，知道不需要比较
 
示例:
 
//排列这个数组{7,5,2,4,9,8,6,7,1}
#include
using namespace std;
int main(void)
{ 
	//排序的总轮数=元素个数-1
	//每轮对比的次数 = 元素个数- 排序轮数 
	int nums[9] = { 7,5,2,4,9,8,6,7,1 };
	for (int i = 0; i < 8 ; i++)
	{
		//内层循环对比
		for (int j = 0; j < 9 - i-1; j++)
		{
			//第一个数比第二个数大就交换他们两个的位置
			int temp = 0;
			if (nums[j] > nums[j + 1])
			{
				temp = nums[j+1];
				nums[j + 1] = nums[j];
				nums[j] = temp;
			}
		}
	}
	for (int i = 0; i < 9; i++)
	{
		cout << nums[i];
	}
	return 0;
}

 
二维数组 
二维数组就是在一维数组的基础上多加一个维度，就是在一维数组里面存储一维数组。
 
定义:
 
数据类型 数组名[行][列];
数据类型 数组名[行][列] = {{数据1，数据2}，{数据3，数据4}};
数据类型 数组名[行][列] = {数据1，数据2，数据3，数据4};
数据类型 数组名[][列] = {数据1，数据2，数据3，数据4};
 
建议:以上4种定义方式，利用第二种更加直观，提高代码的可读性。
 
数组名 
查看二维数组所占内存空间
获取二维数组首地址
 
考试成绩统计练习 
语文
数学
英语
甲
50
40
60
乙
20
10
30
丙
70
80
90
分别输出三个人的总成绩
 
#include
using namespace std;
int main(void)
{	
    int score[3][3] = { {60,50,40},{10,20,30},{70,80,90} };	
    //嵌套循环解决	
    for (int i = 0; i < 3; i++)
    {			
        int temp = 0;	
        for (int j = 0; j < 3; j++)		
        {			
            temp += score[i][j];		
            j++;		
        }		
        cout << temp << endl;	
    }
}
 
函数 
概述 
作用:将一段经常使用的代码封装起来，减少重复代码。
 
一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能。
 
函数的定义 
函数的几个要素
 返回值类型，函数名 ，参数，函数体语句，return表达式
 
语法：
 
返回值类型 函数名(参数列表)
{    
	函数语句;    
	return 表达式;
}
 
函数的调用 
功能：使用定义好的函数
 
语法:函数名(参数)
 
值传递 
就是函数调用时将参数值传给形参
值传递时，如果形参发生变化，并不会影响到实参
 
函数的常见样式 
无参无返、有参无返、无参有返、有参有返
 
函数的声明 
作用：告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
 
函数的声明可以有很多次，定义只能有一次。
 
//声明
int max(int a,int b);
//定义
int max(int a ,int b)
{
    return a+b;
}
 
函数的分文件编写 
作用:让代码结构更加清晰
 
就是在.h的头文件里面放函数声明，函数的定义放到.c文件里
 
指针 
概念 
指针的作用:可以通过指针间接访问内存。
 
内存编号是从0开始记录的，一般用16进制数字标识。
可以利用指针变量保存地址。
 
指针变量的定义和使用 
指针变量定义语法：数据类型+变量名
 
指针所占内存空间 
在32位操作系统下无论是什么类型的指针，都占4个字节的内存空间。
 
空指针 
空指针:指针变量指向内存中编号为0的空间
 
用途:初始化指针变量
 
注意:空指针指向的内存空间是不可以访问的
 
int* p = NULL;
 
野指针 
指针变量指向非法的内存空间。
 
const修饰指针 
const修饰指针有3种情况
 
const修饰指针—常量指针
const修饰常量—指针常量
const既修饰指针，又修饰常量、
 
const修饰的是指针，指针指向可以改，指针指向的值不可以改
    const int* p1 = &a;
const修饰的是常量，指针指向不可以改，指针指向的值可以更改
    int* const p2 = &a;
const既修饰指针，又修饰常量，指针的指向和指针指向的值都不可以改变
    const int* const p = &a;
 
指针和数组 
作用:利用指针访问数组元素
 
int arr[] = {1,2,3,4};
int* p = arr;
 
指针和函数 
作用:利用指针作函数的参数，可以修改实参的值。
 
——传(址)引用
 
指针、数组、函数 
封装一个函数，利用冒泡排序，实现对整型数组的升序排列
 
#include
using namespace std;
void PopSort(int* a,int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len-i - 1; j++)
		{
			int temp = 0;
			if (a[j] > a[j + 1])
			{
				temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}
	}
}
int main(void)
{	
	int arry[5] = { 6,2,4,8,5 };
	PopSort(arry, 5);
	for (int i = 0; i < 5; i++)
	{
		cout << arry[i];
	}
	return 0;
}
 
结构体 
概念 
​ 结构体属于用户自定义的数据类型，允许用户存储不同的数据类型。
 
定义和使用 
语法：
 
struct 结构体名称{    结构体成员列表};
 
通过结构体创建变量的方式有三种
 
struct 结构体名 变量名
struct 结构体名 变量名 = （成员1值，成员2值…)
定义结构体时顺便创建变量
 
示例：
 
struct Student
{  
	string name;  
	int age;  
	int score;
};
 
结构体数组 
作用:将自定义的结构头放入到数组中方便维护
 
语法:
 
struct 结构体名 数组名[元素个数]=  {{}，{}...{}};
 
结构体指针 
作用：通过指针访问结构体中的成员
 
利用操作符->可以通过结构体指针访问结构体属性
 
struct Student s1;
struct Student* p = &s1;
p->score = 10;
 
结构体嵌套结构体 
作用：结构体中的成员可以是另一个结构体
 
例如:每个老师辅导一个学员，一个老师的结构体中，记录一个学生的的结构体
 
结构体做函数参数 
作用:将结构体作为参数向函数中传递
 
传递方式有两种
 
同上函数参数-指针
 
值传递-无法改变实参
地址传递-可以改变实参
 
结构体中const使用场景 
作用：用const来防止误操作
 
void ChangeInformation(const struct student* stu1)
{
    加了const就无法改变该结构体内的信息
}
 
结构体案例 
每个老师带三个学生
 
#include
#include
#include
using namespace std;
struct Student
{
	string name;
	int age;
	int score;
};
struct Teacher
{
	string name;
	struct Student sArry[5];
};
void inPutInformation(struct Teacher tArry[], int len)
{
	string Name = "ABCDE";
	for (int i = 0; i < len; i++)
	{
		tArry[i].name = "Teacher_";
		tArry[i].name += Name[i];
		for (int j = 0; j < 5; j++)
		{
			tArry[i].sArry[j].name = "Student_";
			tArry[i].sArry[j].name += Name[j];
			int random = rand()% 60 +40;
			tArry[i].sArry[j].score = random;
		}
	}
}
void printInformation(struct Teacher tArry[],int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << "老师的姓名：" << tArry[i].name << endl;
		for (int j = 0; j < 5; j++)
		{
			cout << "t学生的姓名：" << tArry[i].sArry[j].name << "考试分数：" << tArry[i].sArry[j].score << endl;
		}
	}
}
int main(void)
{	
	srand((unsigned int)time(NULL));
	struct Teacher tArry[3];
	int len = sizeof(tArry) / sizeof(tArry[0]);
	inPutInformation(tArry,len);
	printInformation(tArry,len);
	system("pause");
	return 0;
}
 
创建5个人并按年龄排序
 
#include
#include
#include
using namespace std;
struct Hero
{
	string name;
	int age;
	string categories;
};
int main(void)
{	
	struct Hero heroArry[5] =
	{
		{"欣南",20,"火"},
		{"东杉",24,"木"},
		{"北淼",23,"水"},
		{"坤中",18,"土"},
		{"西昭",22,"金"},
	};
	int len = sizeof(heroArry) / sizeof(heroArry[0]);
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			int temp = 0;
			if (heroArry[j].age > heroArry[j + 1].age)
			{
				temp = heroArry[j].age;
				heroArry[j].age = heroArry[j + 1].age;
				heroArry[j + 1].age = temp;
			}
		}
	}
	for (int i = 0; i  
通讯录 
#include
#include
#include
#define MAX 1000
using namespace std;
struct Person
{
	string name;
	int age;
	string sex;
	string phone;
	string addr;
};
struct addreassbooks
{
	struct Person personarry[MAX];
	int m_Size;
};
void mainMenu()
{
	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 addPerson(addreassbooks* abs)
{
	if (abs->m_Size == MAX)
	{	
		cout << "联系人已满，无法添加" << endl;
		return;
	}
	string name;
	cout << "请输入姓名" << endl;
	cin >> name;
	abs->personarry[abs->m_Size].name = name;
	string sex;
	cout << "请输入性别" << endl;
	cin >> sex;
	abs->personarry[abs->m_Size].sex = sex;
	int age;
	cout << "请输入年龄" << endl;
	cin >> age;
	abs->personarry[abs->m_Size].age = age;
	string phone;
	cout << "请输入电话" << endl;
	cin >> phone;
	abs->personarry[abs->m_Size].phone = phone;
	string addr;
	cout << "请输入地址" << endl;
	cin >> addr;
	abs->personarry[abs->m_Size].addr = addr;
	//更新通讯录人数
	abs->m_Size++;
	cout << "添加成功" << endl;
	system("pause");
	system("cls");
}
void printPerson(addreassbooks* abs)
{
	if (abs->m_Size == 0)
	{
		cout << "当前记录为空" << endl;
	}
	else
	{
		for (int i = 0; i < abs->m_Size; i++)
		{
			cout << "姓名t" << abs->personarry[i].name << endl;
			cout << "性别t" << abs->personarry[i].sex << endl;
			cout << "年龄t" << abs->personarry[i].age << endl;
			cout << "电话t" << abs->personarry[i].phone << endl;
			cout << "地址t" << abs->personarry[i].addr << endl;
			cout << "n";
		}
	}
	system("pause");
	system("cls");
}
int checkPerson(addreassbooks* abs, string name)
{
	for (int i = 0; i < abs->m_Size; i++)
	{
		if (abs->personarry[i].name == name)
		{
			return i;
		}
	}
	return -1;
}
void deletePerson(addreassbooks* abs)
{	
	string dname;
	cout << "请输入你要删除的人名" << endl;
	cin >> dname;
	int ret = checkPerson(abs, dname);
	if (ret == -1)
	{
		cout << "查无此人" << endl;
	}
	else
	{
		for (int i = ret; i < abs->m_Size; i++)
		{
			abs->personarry[i] = abs->personarry[i + 1];
		 }
		abs->m_Size--;
		cout << "删除成功" << endl;
	}
	system("pause");
	system("cls");
}
void findPerson(addreassbooks* abs)
{
	string fname;
	cout << "请输入要查找的联系人姓名" << endl;
	cin >> fname;
	int result = checkPerson(abs, fname);
	if (result == -1)
	{
		cout << "查无此人" << endl;
	}
	else
	{
		cout << "姓名t" << abs->personarry[result].name << endl;
		cout << "性别t" << abs->personarry[result].sex << endl;
		cout << "年龄t" << abs->personarry[result].age << endl;
		cout << "电话t" << abs->personarry[result].phone << endl;
		cout << "地址t" << abs->personarry[result].addr << endl;
	}
	system("pause");
	system("cls");
}
void modifyPerson(addreassbooks* abs)
{
	string mname;
	cout << "请输入要修改的联系人姓名" << endl;
	cin >> mname;
	int result = checkPerson(abs, mname);
	if (result == -1)
	{
		cout << "查无此人" << endl;
	}
	else
	{
		string name;
		cout << "请输入姓名" << endl;
		cin >> name;
		abs->personarry[result].name = name;
		string sex;
		cout << "请输入性别" << endl;
		cin >> sex;
		abs->personarry[result].sex = sex;
		int age;
		cout << "请输入年龄" << endl;
		cin >> age;
		abs->personarry[result].age = age;
		string phone;
		cout << "请输入电话" << endl;
		cin >> phone;
		abs->personarry[result].phone = phone;
		string addr;
		cout << "请输入地址" << endl;
		cin >> addr;
		abs->personarry[result].addr = addr;	
		cout << "修改成功" << endl;
	}
	system("pause");
	system("cls");
}
void cleanPerson(addreassbooks*abs)//逻辑清空
{
	abs->m_Size = 0;
	cout << "通讯录清空成功！" << endl;
	system("pause");
	system("cls");
}
int main(void)
{

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

	int select = 0;
	while (1)
	{
		mainMenu();
		cin >> select;
		switch (select)
		{
		case 1://添加联系人
			addPerson(&abs);
			break;
		case 2://显示联系人
			printPerson(&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;
		default:
			break;
		}
	}
}