C++基础入门

helle world C++程序

#include <iostream>
using namespace std;int main() {// 输出语句cout << "hello world" << endl;system("pause");return 0;
}

变量

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

#include <iostream>
using namespace std;int main() {// 定义一个变量 int num = 10;cout << "num = " << num << endl;return 0;
}

**注意：对于内置类型：局部变量如果在声明时不初始化，他的初始化值是未定义的， 就是垃圾值，以为这可能包含任何值，看内存的情况；对于全局变量或静态变量声明时自动初始化为0 **

常量

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

• C++定义常量两种方式：
  • #define 宏常量 ： #define 常量名 常量值 （通常在文件的上方定义，表示一个常量）
  • const 修饰的变量， const 数据类型 常量名 = 常量值（通常在变量定义前加关键字const， 修饰该变量为常量， 不可修改）

#include <iostream>
using namespace std;// 定义一个宏常量
#define day 7
int main() {// 定义一个const常量const int month = 30;cout << "一个周有：" << day << "天" << endl;cout << "一个月有：" << month << "天" << endl;return 0;
}

关键字

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

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

C++的关键字如下：

提示：给变量或者常量其名称的时候，不要用C++得关键字，否则会产生歧义

标识符命名规则

作用：C++规定给标识符（变量、常量）命名时， 有一套自己的负责

• 标识符不能是关键字
• 标识符只能由字母、数字、下划线组件
• 第一个字符必须为子字母或下划线
• 标识符中字母区分大小写

建议：给标识符命名时，争取做到见名之意的效果，方便自己和他人的阅读”

数据类型

整型

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

作用： 整形变量表示的是整形类型的数据
C++中能够表示整形的类型有以下几种方式， 区别在与所占内存空间不同：

sizeof关键字

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

#include <iostream>
using namespace std;int main() {cout << "short类型所占空间" << sizeof(short) << endl;cout << "int类型所占空间" << sizeof(int) << endl;cout << "long类型所占空间" << sizeof(long) << endl;cout << "longlong类型所占空间" << sizeof(long long) << endl;return 0;
}

实型（浮点型）

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

#include <iostream>
using namespace std;int main() {// 定义一个float类型 注意： 如果数据后没有加f， C++平台默认为double类型， 加上f会变成float类型float num = 3.14f;cout << "float num = " << num << endl;double num1 = 3.14;cout << "double num1 = " << num1 << endl;// 通过运行结果我们可以发现 C++中最多只显示6为有效数字， 如果需要显示更多的有效数字，需要另外配置float num3 = 3.14159267832;cout << "float num3 = " << num3 << endl;double num4 = 3.14159267832;cout << "double num4 = " << num4 << endl;// 科学计算法来表示小数float num5 = 3e2; //  表示3 * 10^2  cout << "float num5 = " << num5 << endl;float num6 = 3e-2; // 表示3 * 0.1^2cout << "float num6 = " << num6 << endl;return 0;
}

字符型

作用： 字符型变量用于显示单个字符
语法： char ch = 'a';

• 注意1： 在显示字符型变量时，用单引号将字符括起来， 不要用双引号
• 注意2： 单引号内只能有一个字符，不可以是字符串
• C和C++中字符型变量只占用1字节
• 字符型量不是把字符本身放到内存中存储， 而是将对应的ASCII编码放入到存储单元

#include <iostream>
using namespace std;int main() {char ch = 'a';cout << ch << endl;// char所占内存大小cout << "char占的内存大小:" << sizeof(char) << endl;	 // 字符型变量常见错误// char ch2 = "b"; // 创建字符型变量的时候，要使用单引号// char ch3 = 'abcedf' // 创建字符型变量时候， 单引号只能有一个字符return 0;
}

转义字符

作用： 表示一些不能显示出来的ASCII字符
现阶段我们常用的转义字符有： \n、\\、\t

字符串型

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

• C语言字符串： char 变量名[] = "字符串值" （注意：C语言的字符串需要使用双引号括起来）
• C++语言字符串： string 变量名 = "字符串值" (注意：C++字符串需要导入头文件#include<string>)

#include <iostream>
using namespace std;
// C++使用字符串， 必须首先导入string的包
#include <string>int main() {// 创建C语言风格的字符串char str[] = "hello world";cout << "C语言风格字符串：" << str << endl;// C ++ 风格的字符串string str2 = "C++ hello world";cout << "C++语言风格字符串：" << str2 << endl;return 0;
}
### 布尔类型bool
作用 ： 布尔值类型代表真或则假的值
bool类型只有两个值：
* true：  真（本质是1）
* false： 假（本质0）
* **bool类型占一个字节的大小**```cpp
#include <iostream>
using namespace std;int main() {bool flag = true;cout << "flag = " << flag << endl;cout << "bool值所占大小: " << sizeof(bool) << endl;return 0;
}

注意： 在C++ 中非0的值都是真

数据的输入

作用： 用于从键盘获取数据
关键字： cin
语法： cin >> 变量

#include <iostream>
using namespace std;int main() {int a = 0;cout << "请输入一个int类型的值：" << endl;cin >> a;cout << "输入的值是： " << a << endl;return 0;
}

运算符

作用： 用于执行代码的运算

算术运算符

作用： 用于处理四则运算
算数运算符包含一下符号：

注意：C++中 两个整数相除的结果 依然是一个整数， 会自动将小数部分去除

两个小数也是可以相除的， 但是不可以取模（求余数%）：

#include <iostream>
using namespace std;int main() {double d1 = 3.14;double d2 = 1.1;cout << "小数相处：" << d1 / d2 << endl;// 注意： 小数是不可以求余数（%）的return 0;
}

赋值运算符

作用： 用于将表达式的值赋给变量
赋值运算符包括以下集合符号：

比较运算符

作用： 用于表达式的比较， 并返回一个真值或假值
比较运算符有以下符号：

逻辑运算符

作用： 用于根据表示式的值返回真值或假值。

程序流程结构

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

• 顺序结构：程序按照顺序执行，不发生跳转
• 选择结构： 依据条件是否满足， 有选择的执行相应功能
• 循环结构： 依据条件是否满足，循环多次执行某段代码

选择结构

if语句

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

• 单行格式if语句：if（条件）{ 条件满足执行语句 }
  
• 多行格式if语句：
  
  
• 多条件if语句：
  

三目运算符

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

switch语句

作用： 执行多条件分支语句

switch（表达式）
{case 结果1： 执行语句； break；case 结果2： 执行语句； break；.....default: 执行语句； break；}

• if 和 switch区别

  • switch缺点：判断时候只能是整形或者字符型， 不可以是一个区间
  • switch优点： 结构清晰，执行效率高

• 注意：

  • switch语句中表达式类型只能是整形或者字符型
  • case里如果没有break，那么程序会一直向下执行
  • 总结： 与if语句相比，对于多条件执判断时，switch的结构清晰，执行效率高， 缺点是switch不可以判断区间

循环结构

while循环

作用： 满足循环条件， 执行循环语句
语法：while（循环条件）{ 循环语句 }
解释：只要循环条件的结果为真，就执行循环语句

do…while循环

作用： 满足循环条件，执行循环语句
语法: do { 循环语句 } while（循环条件）
注意： 与while区别在与do…while会先执行一次循环语句， 在判断循环条件

for循环

作用： 满足循环条件， 执行循环语句
语法： for（起始表达式；条件表达式；末尾循环体）{ 循环语句 }

跳转语句

beak语句

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

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

continue 语句

作用： 在循环语句中， 跳过本次循环中余下尚未执行的语句， 继续执行下一次循环

goto语句

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

#include <iostream>
using namespace std;int main() {cout << "1" << endl;goto FLAG;cout << "2" << endl;cout << "3" << endl;FLAG :cout << "4" << endl;return 0;
}

注意：在程序中不建议使用goto语句， 以免造成程序流程混乱

数组

概述

所谓数组， 就是一个集合， 里面存放了相同类型的数据元素
特点1：数组中的每个数据元素都是相同的数据类型
特点2： 数组是由连续的内存位置组成的

一维数组

一维数组的定义

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

#include <iostream>
using namespace std;int main() {// 以为数组有三种定义方式//1. 数据类型 数组名[数组长度]int array[3];array[0] = 10;array[1] = 20;array[2] = 30;cout << "array数组元素如下：\n" << endl;for (int i = 0; i < 3; i++){cout << array[i] << endl;}// 数据类型 数组名[数组长度] = { 10， 20， 30 }int array2[3] = { 40, 50, 60 };cout << "array2数组元素如下：\n" << endl;for (int i = 0; i < 3; i++){cout << array2[i] << endl;}// 数据类型 数组名[] = { 10, 20, 30 };int array3[] = { 70, 80, 90 };cout << "array3数组元素如下：\n" << endl;for (int i = 0; i < 3; i++){cout << array3[i] << endl;}return 0;
}

注意：

• 数据类型 数组名[数组长度] = { 值1， 值2，…}，也就是上述代码中第二种申明方式，如果在初始化数据的时候， 没有全部填写完， 会用0来填补剩余数据
• 数组名的命名规范和变量名命名规范一致， 不要和变量重名
• 数组中下表是从0开始索引

一维数组的数组名

一维数组名的用途：

• 可以统计整个数组在内存中的长度
• 可以获取数组在内存中的首地址
  

二维数组

二维数组的定义方式

#include <iostream>
using namespace std;int main() {// 二维数组有四种定义方式//1. 数据类型 数组名[行数][列数]；int array[2][2];array[0][0] = 1;array[0][1] = 2;array[1][0] = 3;array[1][1] = 4;//  数据类型 数组名[行数][列数] = { {数据1,数据2}, {数据3, 数据4} };int array2[2][2] = { {1,2}, {3, 4} };// 数据类型 数组名[行数][列数] = { 数据1， 数据2， 数据3， 数据4 }int array3[2][2] = { 1, 2, 3, 4 };// 数据类型 数组名[][列数] = { 数据1， 数据2， 数据3， 数据4 }int array4[][2] = { 1, 2, 3, 4 };return 0;
}

建议： 以上4种定义方式， 利用第二种更加直观， 提高代码的可读性

二维数组的名称

• 查看二维数组所占内存空间
• 获取二维数组首地址

函数

函数的定义

函数的定义一般主要有5个步骤：

1. 函数值类型
2. 函数名
3. 参数列表
4. 函数体语句
5. return 表达式

#include <iostream>
using namespace std;int sum(int num1, int num2) {return num1 + num2;
}int main() {/*函数返回值类型 函数名（参数列表）{函数体语句return 返回语句表达式}*/return 0;
}

函数的调用

功能： 使用定义好的函数
语法：函数名（参数）

#include <iostream>
using namespace std;/*定义中的num1 和num2 称为形式参数 简称形参
*/int total(int num1, int num2) {return num1 + num2;
}int main() {int a = 10;int b = 20;// 调用时， a, b 称为实际参数， 简称实参cout << total(a, b) << endl;return 0;
}

值传递

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

#include <iostream>
using namespace std;void swap(int num1, int num2) {cout << "num1 交换前的值：" << num1 << endl;cout << "num2 交换前的值：" << num2 << endl;int temp = num1;num1 = num2;num2 = temp;cout << "num1 交换后的值：" << num1 << endl;cout << "num2 交换后的值：" << num2 << endl;
}int main() {int a = 10;int b = 20;swap(a, b);cout << "a 交换后的值：" << a << endl;cout << "b 交换后的值：" << b << endl;return 0;
}

函数的常见样式

常见的函数样式有4种：

1. 无参无返
2. 有参无返
3. 无参有返
4. 有参有返

#include <iostream>
using namespace std;// 无参无返
void test() {cout << "无参无返 test函数" << endl;
}// 有参无返
void test2(int a) {cout << "有参无返 a:" << a << endl;
}// 无参有返
int test3() {cout << "无参有返" << endl;return 2;
}// 有参有返
int test4(int a, int b) {return a + b;
}

注意：无类型无法创建变量，因为无法分配内存

函数的声明

作用：告诉编译器函数名称如何调用函数， 函数的实际主题可以单独定义。

• 函数的声明可以多次，但是函数的定义只能有一次

#include <iostream>
using namespace std;// 函数的申明（提前告诉编译器函数的存在， 可以利用函数的申明）
int sum2 (int a, int b);
// 可以申明多次
int sum2(int a, int b);int main() {return 0;
}// 函数的定义
int sum2(int a, int b) {return a + b;
}

函数的分文件编写

作用： 让代码结果更加清晰
函数分文件编写一般有4个步骤：

1. 创建后缀名.h的头文件
2. 创建后缀名.cpp的文件
3. 在头文件中写函数的声明
4. 在源文件中写函数的定义

// .h文件
#pragma once#include <iostream>
using namespace std;// 声明一个交换方法
void swap_test(int* a, int* b);// .cpp的实现文件
#include "swap.h"void swap_test(int* a, int* b) {cout << "交换之前的值a:" << *a << endl;cout << "交换之前的值b:" << *b << endl;int* temp = a;*b = *a;*a = *temp;cout << "交换之后的值a:" << *a << endl;cout << "交换之后的值b:" << *b << endl;
}// 测试文件
#include <iostream>
using namespace std;
#include "swap.h"int main() {// 调用函数int a = 10;int b = 20;swap_test(&a, &b);return 0;
}

输出结果：

指针

指针的基本概念

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

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

指针变量的定义和使用

指针变量的定义和语法： 数据类型 * 指针变量名

#include <iostream>
using namespace std;int main() {//1.定义一个指针int a = 10;// 指针定义int* p;p = &a;cout << "a的地址为：" << &a << endl;cout << "指针p为： " << p << endl;return 0;
}

结果：

指针所占的内存空间

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

#include <iostream>
using namespace std;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;return 0;
}

结果：

本次代码运行环境是在64位操作系统环境下进行的。

• 在32位操作系统下， 指针是占4个字节空间大小， 不管是什么数据类型
• 在64位操作系统下， 指针是占8个字节空间大小

空指针和野指针

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

#include <iostream>
using namespace std;int main() {// 指针变量p指向内存地址编号为0的空间int* p = NULL;// 访问空指针报错// 内存编号为0 ~ 255为系统所占用，不允许用户访问cout << *p << endl;// 野指针int* p1 = (int*)0x1100;//访问野指针报错cout << *p1 << endl;return 0;
}

总结：空指针和野指针都不是我们申请的内存空间， 因此不要访问

const修饰指针

const 修改指针有三种情况：

1. const 修饰指针： 常量指针
2. const 修饰常量： 指针常量
3. const 即修饰指针，又修饰常量

#include <iostream>
using namespace std;int main() {int a = 10;int b = 10;// const 修饰的是指针，指针指向可以改变，但是指针指向的值不可以改变const int* p = &a;p = &b; // 正确//*p = 100; // 报错// const 修饰的是常量， 指针指向不可以改变， 指针指向的值可以更改int* const p2 = &a;//p2 = &b; 错误*p2 = 100;// 正确// const 既修饰指针又修饰常量const int* const p3 = &a;//p3 = &b; 错误// *p3 = 100; 错误// const 既修饰指针又修饰常return 0;
}

总结：看const 右侧紧跟着是指针还是常量， 是指针就是常量指针， 是常量就是指正常量

指针和数组

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

#include <iostream>
using namespace std;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++;}return 0;
}

结果：

注意：数组名就是数组的首地址

指针和函数

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

#include <iostream>
using namespace std;void swap(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;swap(a, b);cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "---------------------" << endl;swap2(&a, &b);cout << "a = " << a << endl;cout << "b = " << b << endl;return 0;
}

结果：

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

结构体

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

结构体的定义和使用

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

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

#include <iostream>
using namespace std;
#include <string>// 定义一个结构体
struct Student
{// 姓名string name;// 年龄int age;// 分数int score;
} s3; // 这是第三种方式创建结构体int main() {//1. 创建一个结构体 (前面的struct 是可以省略的)struct Student s1;s1.name = "张三";s1.age = 18;s1.score = 99;cout << "姓名：" << s1.name << "年龄：" << s1.age << "分数：" << s1.score << endl;// 2. 第二种方式创建结构体Student s2 = { "李四", 19, 80 };cout << "姓名：" << s2.name << "年龄：" << s2.age << "分数：" << s2.score << endl;s3.name = "王五";s3.age = 30;s3.score = 100;cout << "姓名：" << s3.name << "年龄：" << s3.age << "分数：" << s3.score << endl;return 0;
}

结果：

注意： 在C++中结构体创建的时候， struct关键字可以省略，但是 定义的时候不能省略

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

结构体数组

作用： 将自定义的结构体放入到数组中方便维护
语法：struct 结构体名 数组名 [元素个数] = {{}, {}, {}}

#include <iostream>
using namespace std;
#include <string>// 定义一个结构体
struct Person
{string name;int age;
};int main() {// 定义一个结构体数组名Person persons[] = { {"张三", 18 }, { "李四", 50 }, { "王五", 40 } };for (size_t i = 0; i < 3; i++){cout << "姓名：" << persons[i].name << "年龄：" << persons[i].age << endl;}return 0;
}	

结果：

结构体指针

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

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

#include <iostream>
using namespace std;// 定义一个结构体
struct Person1
{string name;int age;
};int main() {// 定义一个结构体Person1 person = { "张三", 18 };// 申明一个结构体的指针Person1* p = &person;// 通过指针方法属性cout << "姓名：" << p->name << "  年龄：" << p->age << endl;return 0;
}

结果：

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

结构体嵌套结构体

作用：结构体中的成员可以是另一个结构体
例如：每个老师辅导一个学员，一个老师的结构体中， 记录一个学生的结构体

#include <iostream>
using namespace std;
#include <string>// 定义一个学生结构体
struct Student
{string name;int age;int score;
};// 定义换一个老师的结构体
struct Teacher
{int id;string name;Student stu;
};int main() {// 创建一个老师结构体Teacher teacher;teacher.id = 1;teacher.name = "王老师";Student stu = { "张三",19,20 };teacher.stu = stu;cout << "老师姓名：" << teacher.name << "  老师教导的学生：" << teacher.stu.name << endl;return 0;
}

结果：

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

结构体做函数参数

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

传递方式有两种：

• 值传递
• 地址传递

#include <iostream>
using namespace std;
#include <string>// 申明一个结构体
struct Person2
{string name;int age;
};// 值传递
void printStudent(Person2 person) {person.name = "修改名称";cout << "姓名： " << person.name << "  年龄：" << person.age << endl;
}// 指针传递
void printStudent2(Person2 *person) {person->name = "李四";cout << "姓名： " << person->name << "  年龄：" << person->age << endl;
}int main() {// 创建一个结构体Person2 person = { "张三", 19 };printStudent(person);cout << "姓名：" << person.name << "   年龄：" << person.age << endl;printStudent2(&person);cout << "姓名：" << person.name << "   年龄：" << person.age << endl;return 0;
}

结果：

结构体中的const使用场景

作用： 用const来放置

#include <iostream>
using namespace std;
#include <string>struct Person3
{string name;int age;
};// 将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudent3(const Person3* p) { // 加const防止函数体中的误操作//p->age = 100; // 操作失败，因为加了const修饰，一旦有修改操作就会报错，可以防止我们误操作cout << "姓名：" << p->name << "  年龄：" << p->age << endl;
}int main() {Person3 person = { "张三", 19 };printStudent3(&person);return 0;
}

案例：通讯管理系统

系统中主要功能如下：

• 添加联系人： 向通讯录中添加新人
• 显示联系人：显示通讯录中的所有联系人信息
• 删除联系人：按照姓名删除指定联系人信息
• 查找联系人：按照姓名查找指定联系人信息
• 修改联系人：按照姓名重新修改指定联系人
• 清空联系人：清空通讯录中所有信息
• 退出通讯录系统： 退出当前使用的通讯录

#include <iostream>
using namespace std;
#include <string>//  定义一个宏
#define MAX 1000 // 最大数// 定义联系人结构体
struct Person
{string name; //姓名// 性别： 1 男  2女int m_Sex;int m_Age;string m_Phone;string m_Addr;
};// 定义通讯录看结构体
struct Addressbooks
{Person personArray[MAX]; // 通讯录中保存的联系人数组int m_Size; // 通讯录中的人员个数
}; // 添加一个人到通讯录
void addPerson(Addressbooks * p) {if (p->m_Size == MAX){cout << "通讯录已满，无法在添加人员了" << endl;return;}else{// 姓名string name;cout << "请输入姓名：" << endl;cin >> name;p->personArray[p->m_Size].name = name;// 性别cout << "请输入性别：" << endl;cout << "男：1；女 ： 2" << endl;int gender = 0;while (true){cin >> gender;if (gender == 1 || gender == 2){p->personArray[p->m_Size].m_Sex = gender;break;}cout << "输入有误，请重新输入" << endl;}// 年龄int age;cout << "请输入年龄：" << endl;cin >> age;p->personArray[p->m_Size].m_Age = age;// 手机号string phone;cout << "请输入手机号码：" << endl;cin >> phone;p->personArray[p->m_Size].m_Phone = phone;//地址string address;cout << "请输入地址：" << endl;cin >> address;p->personArray[p->m_Size].m_Addr = address;p->m_Size += 1;cout << "添加成功" << endl;// 请按任意键继续system("pause");// 代表清屏操作system("cls");}
}// 显示联系人
void showPerson(Addressbooks* p) {if (p->m_Size == 0){cout << "您的通讯录还是空的，快去添加把！" << endl;return;}for (size_t i = 0; i < p->m_Size; i++){cout << "姓名：" << p->personArray[i].name << "   性别：" << ((p->personArray[i].m_Sex == 1) ? "男" : "女") << "   年龄：" << p->personArray[i].m_Age << "   手机号码：" << p->personArray[i].m_Phone << "   地址：" << p->personArray[i].m_Addr << endl;}// 请按任意键继续system("pause");// 代表清屏操作system("cls");
}int isExist(Addressbooks* p, string name) {int result = -1;// 根据姓名查找for (int i = 0; i < p->m_Size; i++){if (p->personArray[i].name == name){result = i;break;}}return result;
}// 删除联系人
void deletePerson(Addressbooks* p) {cout << "请输入您要删除的联系人的名称：" << endl;string name;cin >> name;int result = isExist(p, name);if (result == -1) {cout << "查无此人" << endl;return;}for (int i = result; i < p->m_Size; i++){p->personArray[i] = p->personArray[i + 1];}p->m_Size--;cout << "删除成功" << endl;system("pause");system("cls");
}void queryPerson(Addressbooks* p) {cout << "请输入您要查询人的姓名：" << endl;string name;cin >> name;int result = isExist(p, name);if (result == -1){cout << "查无此人" << endl;return;}cout << "姓名：" << p->personArray[result].name<< "   性别：" << ((p->personArray[result].m_Sex == 1) ? "男" : "女")<< "   年龄：" << p->personArray[result].m_Age<< "   手机号码：" << p->personArray[result].m_Phone<< "   地址：" << p->personArray[result].m_Addr << endl;system("pause");system("cls");
}// 显示按钮
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;
}int main() {// 创建通讯录对象Addressbooks addressbooks;// 初始化结构体变量addressbooks.m_Size = 0;while (true){showMenu();int select = 0;cout << "请输入您的选择：\n" << endl;cin >> select; switch (select){case 1:addPerson(&addressbooks);break;case 2:showPerson(&addressbooks);break;case 3:deletePerson(&addressbooks);break;case 4:queryPerson(&addressbooks);break;case 5:break;case 6:break;case 0:cout << "退出通讯录系统" << endl;return 0;default:break;}}// 请按任意键继续system("pause");return 0;
}