零基础入门C++：通讯录管理系统实战详解头文件、命名空间、结构体、数组、指针、函数、输入输出、成员初始化、字符串校验、线性查找、删除搬移、逻辑清空、栈堆内存、异常输入与现代C++优化实践

🗺️ C++ 通讯录知识思维导图

🧱 一、头文件、命名空间、宏定义和数据模型

📌 1.1 原始代码

#include <iostream>
using namespace std;
#include <string>
#define MAX 99
#include <limits>

struct Person
{
string m_Name;//姓名

int m_Sex = 0;//性别->1男 2女

int m_Age = 0;//年龄

string m_Phone;//电话

string m_Addr;//住址
};//联系人

struct AddressBooks
{
struct Person personArr[MAX];//通讯录中保存的联系人数组

int m_Size = 0;//通讯录中当前记录联系人个数

};//通讯录

🧩 1.2 头文件的作用

#include 会把标准库中已经声明好的功能引入当前源文件。

using namespace std; 对入门示例较方便，但头文件或大型项目通常推荐明确书写 std::，这样更容易判断名称来自哪里。

📏 1.3 宏定义与常量

#define MAX 99

预处理阶段会把后续代码中的 MAX 替换成 99。它决定了联系人数组的容量。

宏只是文本替换，没有明确的数据类型，也不受普通 C++ 作用域规则约束。现代 C++ 更推荐类型安全的常量：

#include <cstddef>

// constexpr 表示该值可以在编译期确定。
// std::size_t 是专门表示大小、数量和下标的无符号整数类型。
constexpr std::size_t MAX_CONTACTS = 99;

👤 1.4 Person 联系人结构体

struct 可以把多个有关联的数据组合为一个新类型。一个 Person 对象同时包含姓名、性别、年龄、电话和住址。

m_Sex = 0 和 m_Age = 0 是成员默认初始化。创建 Person 对象时，如果没有另外指定数值，这两个成员会先得到 0。

电话使用 string 而不是整数具有几个好处：

• 电话号码不参与数学计算。

• 字符串可以保留开头的 0。

• 可以直接检查长度和每个字符。

• 不会受到整数最大值的限制。

m_ 是一种常见的成员变量命名前缀，不是 C++ 强制语法。

📚 1.5 AddressBooks 通讯录结构体

personArr 是由多个 Person 对象组成的固定数组，m_Size 表示数组前部有多少个位置属于有效联系人。

例如，m_Size == 3 表示 personArr[0]、personArr[1] 和 personArr[2] 有效。剩余位置虽然已经存在，但不属于当前通讯录记录。

🆕 1.6 更明确的数据模型示例

#include <array>
#include <cstddef>
#include <string>

// enum class 创建作用域明确的枚举，避免用任意整数表示性别。
enum class Sex
{
Unknown = 0,
Male = 1,
Female = 2
};

struct PersonModern
{
std::string name; // 保存姓名。
Sex sex = Sex::Unknown; // 使用枚举表达有限的合法选项。
int age = 0; // 默认年龄为 0，后续仍需业务校验。
std::string phone; // 电话号码按文本保存。
std::string address; // 保存完整地址。
};

constexpr std::size_t MAX_CONTACTS = 99;

struct AddressBookModern
{
// std::array 仍是固定容量，但提供 size()、begin()、end() 等标准接口。
std::array<PersonModern, MAX_CONTACTS> people{};

// size 表示 people 中有效联系人的数量。
std::size_t size = 0;
};

➕ 二、添加联系人、函数封装、指针和异常输入

📌 2.1 原始代码

void addPerson(AddressBooks * ads) {//1.添加联系人
//判断通讯录是否已满 满了->不添加
if (ads->m_Size == MAX)
{
cout << "通讯录已满,无法添加!!!" << endl;
return;
}
else
{//添加具体联系人
//姓名
string name;
cout << "请输入姓名:" << endl;
cin >> name;
ads->personArr[ads->m_Size].m_Name = name;

//性别
cout << "请输入性别:" << endl;
cout << "输入1是男" << endl;
cout << "输入2是女" << endl;
int sex = 0;
while (true) {
//输入1或2可以退出循环<-因为输入的是正确值
//输入有误->重新输入
cin >> sex;//输入string会死循环一直显示"输入有误,请重新输入哦"->用cin读取int整数的地方输入非数字都会死循环
//输入int整形都同理

if (cin.fail()) {//处理输入类型错误—输入非数字
cin.clear();//清除cin错误状态
cin.ignore(numeric_limits<streamsize>::max(), '\\n');//清空缓冲区所有残留错误字符->直到遇到换行符
cout << "输入有误,请输入1或2!" << endl;
continue;
}

if (sex == 1 || sex == 2) {
ads->personArr[ads->m_Size].m_Sex = sex;
break;
}
cout << "输入有误,请重新输入哦" << endl;
}

//年龄
cout << "请输入年龄:" << endl;
int age = 0;
while (true) {
cin >> age;

if (cin.fail()) {//处理输入类型错误—输入非数字
cin.clear();//清除cin错误状态
cin.ignore(numeric_limits<streamsize>::max(), '\\n');//清空缓冲区所有残留错误字符->直到遇到换行符
cout << "输入有误,请输入一个数字!" << endl;
continue;
}

if (age > 0 && age < 120) {
ads->personArr[ads->m_Size].m_Age = age;
break;
}
cout << "输入有误,请重新输入一个正常年龄哦" << endl;
}

//电话
cout << "请输入联系电话:" << endl;
string phone;
while (true) {
cin >> phone;
if (phone.size() != 11) {//判断长度
cout << "输入的电话号码必须为11位的阿拉伯数字!!!" << endl;
continue;
}
//phone是string->判断数字
bool phoneAllNum = true;
for (char c : phone) {
if (c < '0' || c > '9' ) {
phoneAllNum = false;
break;
}
}
if (!phoneAllNum) {
cout << "输入的电话号码必须为阿拉伯数字!!!" << endl;
continue;
}
ads->personArr[ads->m_Size].m_Phone = phone;
break;
}

//住址
cout << "请输入家庭地址:" << endl;
string address;
cin >> address;
ads->personArr[ads->m_Size].m_Addr = address;

//更新通讯录人数
ads->m_Size++;

cout << "添加联系人成功" << endl;

system("pause");//请按任意键继续
system("cls");//清屏操作
//闭环
}
}

👉 2.2 函数、参数与指针

void addPerson(AddressBooks * ads) 定义了一个没有返回值的函数。参数 ads 是一个指向 AddressBooks 对象的指针。

因为 ads 是指针，所以使用 ads->m_Size 和 ads->personArr 访问它所指向对象的成员。表达式：

ads->m_Size

等价于：

(*ads).m_Size

函数取得原通讯录对象的地址，因此在函数中写入成员会直接影响调用者持有的通讯录，而不是只修改一份临时副本。

⌨️ 2.3 cin.fail()、clear() 与 ignore()

向 int 变量输入字母时，cin 无法完成类型转换，并进入失败状态。失败状态没有清除前，之后的读取会继续失败。

恢复过程包含两个独立动作：

#include <iostream>
#include <limits>

int value = 0;
std::cin >> value;

if (std::cin.fail())
{
// 第一步：清除 failbit 等错误状态，让输入流重新可用。
std::cin.clear();

// 第二步：丢弃当前输入行中尚未处理的错误字符。
// numeric_limits<streamsize>::max() 表示允许忽略的最大字符数量。
std::cin.ignore(
std::numeric_limits<std::streamsize>::max(),
'\\n'
);
}

只调用 clear() 会留下导致失败的字符；只调用 ignore() 而不恢复状态，输入流仍然不可用。因此两者通常配合使用。

🔤 2.4 字符串长度和字符数字判断

phone.size() 返回字符串包含的字符数量。号码长度通过后，源码再检查每个字符是否位于 '0' 到 '9' 之间。

字符在底层具有整数编码，数字字符的编码连续排列，所以可以使用：

c < '0' || c > '9'

判断字符是否不属于十进制数字。

一个更接近标准库风格的独立验证函数如下：

#include <algorithm>
#include <string>

bool isPhoneValid(const std::string& phone)
{
// 中国大陆手机号码在这个示例中按 11 位文本处理。
if (phone.size() != 11)
{
return false;
}

// all_of 要求字符串中的每个字符都满足判断条件。
return std::all_of(
phone.begin(),
phone.end(),
[](char c)
{
// 明确限制为 ASCII 数字，避免其他字符通过。
return c >= '0' && c <= '9';
}
);
}

这里的 11 位数字仅是示例规则，不代表号码真实存在，也没有检查开头数字或具体号段。

🧰 2.5 可复用的整数输入函数

#include <iostream>
#include <limits>
#include <string>

bool readInt(const std::string& prompt, int& result)
{
// 输出调用者提供的提示文字。
std::cout << prompt;

// 尝试把用户输入转换并写入 result。
if (std::cin >> result)
{
// 读取成功。
return true;
}

// 清除输入流的错误状态。
std::cin.clear();

// 丢弃当前行剩余内容，避免同一错误文本再次影响读取。
std::cin.ignore(
std::numeric_limits<std::streamsize>::max(),
'\\n'
);

// 返回 false，让调用者知道本次输入没有得到有效整数。
return false;
}

这个函数把重复出现的输入恢复代码集中到一处，减少添加联系人、修改联系人和菜单输入之间的重复。

👀 三、显示联系人与标准输出

📌 3.1 原始代码

//2.显示所有联系人
void showPerson(AddressBooks * ads) {
//判断通讯录中人数是否为0->0 提示记录为空 ->不为0 显示记录的联系人信息
if (ads->m_Size == 0) {
cout << "记录为空,请先添加联系人" << endl;
}
else {
for (int i = 0;i < ads->m_Size;i++) {
cout << "姓名:" << ads->personArr[i].m_Name << "\\t";//\\t转义字符->Tab 水平制表符
cout << "性别:" << (ads->personArr[i].m_Sex==1 ? "男" : "女" )<< "\\t";
cout << "年龄:" << ads->personArr[i].m_Age << "\\t";
cout << "电话:" << ads->personArr[i].m_Phone << "\\t";
cout << "住址:" << ads->personArr[i].m_Addr << endl;
}
}

system("pause");//按任意键继续
system("cls");//清屏
}

🖨️ 3.2 cout、<<、endl 和转义字符

cout 是标准输出流，<< 把右侧数据发送到输出流。多个 << 可以连续拼接字符串、整数和其他可输出类型。

endl 会输出换行并刷新输出缓冲区。如果只需要换行，通常可以使用 '\\n'，减少不必要的刷新。

\\t 表示水平制表符。它会移动到下一个制表位置，但不同终端的显示宽度可能不同，因此不适合严格对齐复杂表格。

🔒 3.3 使用只读引用

显示函数不需要修改通讯录，可以使用 const 引用表达“只读”意图：

#include <iostream>

void showPersonModern(const AddressBooks& ads)
{
// const 引用不会复制整个通讯录，也不允许函数修改 ads。
for (int i = 0; i < ads.m_Size; ++i)
{
const Person& person = ads.personArr[i];

// '\\n' 只负责换行，不强制刷新输出缓冲区。
std::cout
<< "姓名:" << person.m_Name << '\\t'
<< "性别:" << (person.m_Sex == 1 ? "男" : "女") << '\\t'
<< "年龄:" << person.m_Age << '\\t'
<< "电话:" << person.m_Phone << '\\t'
<< "住址:" << person.m_Addr << '\\n';
}
}

引用使用 . 访问成员，指针使用 -> 访问成员。

🔎 四、线性查找、返回值与 -1 哨兵

📌 4.1 原始代码

//监测联系人是否存在->存在 返回联系人所在数组中的具体位置->不存在 返回-1
int isExist(AddressBooks* ads, string name) {//参数:1->通讯录 2->对比姓名
for (int i = 0;i < ads->m_Size;i++) {
if (ads->personArr[i].m_Name == name) {
return i;//找到了->返回此人在数组中的下标编号
}
}
return -1;//遍历结束未找到->返回-1
}

🧭 4.2 线性查找思想

该函数从第一个有效联系人开始逐项比较姓名。找到后返回数组下标，全部检查完仍未匹配则返回 -1。

数组合法下标从 0 开始，因此 -1 不会与合法位置冲突，可以作为“未找到”的哨兵值。

当联系人数量为 n 时：

• 最好情况：第一个联系人匹配，比较 1 次。

• 最坏情况：最后一个联系人匹配或不存在，比较 n 次。

• 时间复杂度：O(n)。

• 额外空间复杂度：O(1)。

如果存在重名联系人，该函数只返回第一个匹配项。删除、查找和修改功能因此也只会处理第一个同名联系人。

🆕 4.3 使用 std::optional 表达查找结果

#include <cstddef>
#include <optional>
#include <string>

std::optional<std::size_t> findPersonIndex(
const AddressBooks& ads,
const std::string& name
)
{
// 只检查通讯录中的有效联系人。
for (std::size_t i = 0;
i < static_cast<std::size_t>(ads.m_Size);
++i)
{
if (ads.personArr[i].m_Name == name)
{
// optional 内含一个有效下标，表示查找成功。
return i;
}
}

// nullopt 明确表达“没有结果”，不再依赖 -1。
return std::nullopt;
}

std::optional 从 C++17 开始提供。它能明确区分“有一个下标”和“没有下标”。

🗑️ 五、删除联系人与数组元素前移

📌 5.1 原始代码

//3.删除指定联系人
void deletePerson(AddressBooks* ads) {
cout << "请输入您要删除的联系人" << endl;

string name;
cin >> name;

int ret = isExist(ads, name);//ret=-1 ->未查到 ret!=-1 ->查到->删

if (ret != -1) {//查到此人->删除
for (int i = ret;i < ads->m_Size – 1;i++) {
ads->personArr[i] = ads->personArr[i + 1];//数据前移
}
ads->m_Size–;//更新通讯录的人数
cout << "删除成功" << endl;
}
else {
cout << "查无此人" << endl;
}

system("pause");
system("cls");
}

📦 5.2 删除搬移的内存模型

固定数组中的元素连续排列。删除中间元素后，为了保持有效联系人仍位于数组前部，需要把删除位置之后的元素依次向前复制一格。

假设联系人依次为：

下标： 0 1 2 3
数据： Alice Bob Carol David

删除下标 1 后，Carol 被复制到下标 1，David 被复制到下标 2，最后把 m_Size 从 4 减为 3。

底层数组最后一个位置可能仍保留一份旧对象，但它已经位于有效区间之外，程序不会再把它当作联系人。

删除循环的终点是 ads->m_Size – 1。这样最后一次赋值读取的是原有效区间中的最后一个元素，不会访问 personArr[m_Size]。

🧰 5.3 使用 std::vector::erase

#include <algorithm>
#include <string>
#include <vector>

bool deleteByName(
std::vector<Person>& people,
const std::string& name
)
{
// find_if 返回第一个姓名匹配的联系人位置。
const auto position = std::find_if(
people.begin(),
people.end(),
[&name](const Person& person)
{
return person.m_Name == name;
}
);

if (position == people.end())
{
// 到达 end() 表示没有找到联系人。
return false;
}

// erase 删除当前位置，并由 vector 维护后续搬移和元素数量。
people.erase(position);
return true;
}

vector 仍然需要搬移后续元素，但它会自动维护长度，不再需要手工更新 m_Size。

🪪 六、查找结果展示

📌 6.1 原始代码

//4.查找指定联系人信息
void findPerson(AddressBooks* ads) {
cout << "请输入您要查找的联系人" << endl;
string name;
cin >> name;

//判断指定的联系人是否存在通讯录中
int ret = isExist(ads, name);

if (ret != -1) {//找到联系人
cout << "姓名:" << ads->personArr[ret].m_Name << "\\t";
cout << "性别:" << (ads->personArr[ret].m_Sex== 1 ? "男" : "女")<< "\\t";
cout << "年龄:" << ads->personArr[ret].m_Age << "\\t";
cout << "电话:" << ads->personArr[ret].m_Phone << "\\t";
cout << "住址:" << ads->personArr[ret].m_Addr << endl;

}
else {//未找到联系人
cout << "查无此人" << endl;
}

//任意键按下后 清屏
system("pause");
system("cls");
}

查找函数复用了 isExist。这样姓名匹配逻辑只维护一份，删除、查找和修改可以共享同一个约定。

得到下标 ret 后，程序通过 personArr[ret] 定位联系人，再读取各成员。

🔗 6.2 返回只读联系人指针

#include <string>

const Person* findPersonPointer(
const AddressBooks& ads,
const std::string& name
)
{
for (int i = 0; i < ads.m_Size; ++i)
{
if (ads.personArr[i].m_Name == name)
{
// 返回数组中现有对象的地址，不复制整个 Person。
return &ads.personArr[i];
}
}

// 空指针表示没有找到联系人。
return nullptr;
}

调用者必须先判断结果是否为 nullptr。返回 const Person* 表示可以读取联系人，但不能通过该指针修改联系人。

✏️ 七、修改联系人与重复验证逻辑

📌 7.1 原始代码

//5.修改指定联系人信息
void modifyPerson(AddressBooks* ads) {
cout << "请输入您要修改的联系人" << endl;
string name;
cin >> name;
int ret = isExist(ads, name);

if (ret != -1) {//找到指定联系人
//姓名
string newName;
cout << "请输入姓名" << "\\t";
cin >> newName;
ads->personArr[ret].m_Name = newName;

//性别
int newSex = 0;
cout << "请输入性别" << endl;
cout << "1—男" << endl;
cout << "2—女" << endl;
while (true) {
cin >> newSex;

if (cin.fail()) {//处理输入类型错误—输入非数字
cin.clear();//清除cin错误状态
cin.ignore(numeric_limits<streamsize>::max(), '\\n');//清空缓冲区所有残留错误字符->直到遇到换行符
cout << "输入有误,请输入1或2!" << endl;
continue;
}

if (newSex == 1 || newSex == 2) {
ads->personArr[ret].m_Sex = newSex;//输入正确->退出循环输入
break;
}
cout << "输入错误,请重新输入" << endl;
}

//年龄
cout << "请输入年龄:" << endl;
int newAge = 0;
while (true) {
cin >> newAge;

if (cin.fail()) {//处理输入类型错误—输入非数字
cin.clear();//清除cin错误状态
cin.ignore(numeric_limits<streamsize>::max(), '\\n');//清空缓冲区所有残留错误字符->直到遇到换行符
cout << "输入有误,请输入合理数字!" << endl;
continue;
}

if (newAge > 0 && newAge < 120) {
ads->personArr[ret].m_Age = newAge;
break;
}
cout << "输入错误,请重新输入" << endl;
}

//电话
cout << "请输入联系电话:" << endl;
string newPhone;
while (true) {
cin >> newPhone;
if (newPhone.size() != 11) {
cout << "电话号码必须为11位阿拉伯数字,请重新输入:" << endl;
continue;
}
bool phoneAllNum = true;
for (char c : newPhone) {
if (c < '0' || c > '9') {
phoneAllNum = false;
break;
}
}
if (!phoneAllNum) {
cout << "电话号码必须为阿拉伯数字,请重新输入:" << endl;
continue;
}
ads->personArr[ret].m_Phone = newPhone;
break;
}

//住址
cout << "请输入家庭住址" << endl;
string newAddress;
cin >> newAddress;
ads->personArr[ret].m_Addr = newAddress;

cout << "修改成功!" << endl;
}
else {//未找到联系人
cout << "x查无此人x" << endl;
}

system("pause");
system("cls");
}

♻️ 7.2 修改与添加共享的规则

修改联系人与添加联系人使用相同的字段规则：

• 性别只能使用约定值。

• 年龄必须大于 0 且小于 120。

• 电话必须是 11 位数字。

• 姓名和地址使用字符串保存。

当前代码分别实现了两套验证逻辑。规则变化时需要同时修改两处，容易出现不一致。更好的做法是把字段验证提取为函数。

🧪 7.3 独立字段验证函数

#include <string>

bool isSexValid(int sex)
{
// 现有业务规则只接受 1 和 2。
return sex == 1 || sex == 2;
}

bool isAgeValid(int age)
{
// 年龄必须处于源码规定的开区间 (0, 120)。
return age > 0 && age < 120;
}

bool isPhoneValidSimple(const std::string& phone)
{
// 长度必须恰好为 11。
if (phone.size() != 11)
{
return false;
}

for (char c : phone)
{
// 发现任意非 ASCII 数字字符时，号码无效。
if (c < '0' || c > '9')
{
return false;
}
}

// 所有规则均通过。
return true;
}

🏠 7.4 使用 getline 读取带空格文本

#include <iostream>
#include <limits>
#include <string>

std::string readWholeLine(const std::string& prompt)
{
std::cout << prompt;

// 如果前面使用过 operator>>，先丢弃当前行剩余的换行符。
std::cin.ignore(
std::numeric_limits<std::streamsize>::max(),
'\\n'
);

std::string value;

// getline 会读取到换行符为止，文本中间的空格会被保留。
std::getline(std::cin, value);

return value;
}

实际项目中应统一设计输入方式，避免在多个地方随意混用 >> 和 getline，否则容易多丢弃一行或读到空字符串。

🧹 八、逻辑清空与二次确认

📌 8.1 原始代码

//6.清空联系人
void clearPerson(AddressBooks* ads) {
ads->m_Size = 0;//将记录的联系人数量置0:逻辑清空->数据还在 只是访问不到
cout << "通讯录已清空" << endl;
}

//6,1清空冷静
void clearAgain(AddressBooks* ads) {
int clearFlag = 0;
cout << "确认清空所有联系人吗？输入1确认，输入其他数字取消" << endl;
while (true) {
cin >> clearFlag;

if (cin.fail()) {
cin.clear();
cin.ignore(numeric_limits<streamsize>::max(), '\\n');
cout << "确认清空所有联系人吗？输入1确认，输入其他数字取消" << endl;
continue;
}

if (clearFlag==1)
{
clearPerson(ads);
break;
}
else {
cout << "退出清空" << endl;
break;
}
}

system("pause");
system("cls");
}

🧠 8.2 什么是逻辑清空

clearPerson 只把 m_Size 设为 0。之后显示、查找、删除和修改功能都认为通讯录没有有效联系人。

数组中的 Person 对象并没有立即销毁或覆盖。后续添加联系人时，程序会从 personArr[0] 开始写入，新数据逐步覆盖旧数据。

因此，这种清空属于“逻辑清空”，不适合需要可靠擦除敏感信息的场景。

🧽 8.3 同时重置有效对象

void clearAndReset(AddressBooks& ads)
{
// 先把当前有效区间中的联系人替换成默认 Person 对象。
for (int i = 0; i < ads.m_Size; ++i)
{
ads.personArr[i] = Person{};
}

// 再把有效联系人数量归零。
ads.m_Size = 0;
}

这会清空 C++ 对象当前持有的字符串，但不应把它理解为密码学意义上的安全擦除。标准字符串的内部容量和内存管理实现可能仍保留历史数据。

使用 std::vector<Person> 时，可以调用 clear() 销毁所有有效元素并把容器大小变为零，但容器保留的容量也不一定立即归还给操作系统。

🖥️ 九、菜单显示、地址传递与平台相关命令

📌 9.1 原始代码

void showMenu() {//菜单界面
cout << " –==/=====================\\\\==–" << endl;
cout << "-=/=/=======================\\\\=\\\\=-" << endl;
cout << "\\\\/\\\\/| 1.Add Contacts |\\\\/\\\\/" << endl;
cout << "/\\\\/\\\\| 2.Show Contacts |/\\\\/\\\\" << endl;
cout << "\\\\/\\\\/| 3.Delete Contacts |\\\\/\\\\/" << endl;
cout << "****| 4.Find Contacts |****" << endl;
cout << "/\\\\/\\\\| 5.Change Contacts |/\\\\/\\\\" << endl;
cout << "\\\\/\\\\/| 6.Clear Contacts |\\\\/\\\\/" << endl;
cout << "/\\\\/\\\\| 0.Exit Address Books |/\\\\/\\\\" << endl;
cout << "-=\\\\=\\\\=======================/=/=-" << endl;
cout << " –==\\\\=====================/==–" << endl;
}

int main() {

// 将通讯录对象分配到堆以避免占用过多栈空间
//AddressBooks* ads = new AddressBooks();//创建通讯录结构体变量在堆上 new->堆
AddressBooks ads;

ads.m_Size = 0;//初始化通讯录中当前人员个数

int select = 0;//创建用户选择输入的变量

while (true) {
showMenu(); //菜单调用

cin >> select;

if (cin.fail()) {
cin.clear();
cin.ignore(numeric_limits<streamsize>::max(), '\\n');

cout << "输入无效,请输入0~6之间的数字!" << endl;
system("pause");
system("cls");
continue;
}

switch (select) {//switch中两个case之间代码太多->报错->加上{}括起来就行
case 1: //1.添加联系人
addPerson(&ads);//利用地址传递->可以修饰实参
break;
case 2: //2.显示联系人
showPerson(&ads);
break;
case 3: //3.删除联系人
//{
// cout << "请输入删除联系人的姓名:" << endl;
// string name;
// cin >> name;

// if (isExist(&ads, name) == -1) {
// cout << "查无此人" << endl;
// }
// else {
// cout << "找到此人" << endl;
// }
//}
deletePerson(&ads);
break;
case 4: //4.查找联系人
findPerson(&ads);
break;
case 5: //5.修改联系人
modifyPerson(&ads);
break;
case 6: //6.清空联系人
//cout << "将会清空所有联系人,请谨慎操作" << endl;
//system("pause");
//clearPerson(&ads);

clearAgain(&ads);
break;
case 0: //退出系统
cout << "welcome next time" << endl;
system("pause");
//delete ads; // 释放堆上资源
return 0;
break;
default:
cout << "输入无效,请输入0~6之间的数字!" << endl;
system("pause");
system("cls");
break;
}
}

// 万一循环以外到达这里，释放资源
//delete ads;
//栈内存系统自动回收

system("pause");
return 0;
}

以上代码按要求只保留原有菜单和调度内容，不展开相关流程控制语法。

🪄 9.2 反斜杠转义

反斜杠 \\ 在字符串中用于引入转义序列。若要实际输出一个反斜杠，需要在字符串字面量中写成 \\\\。

#include <iostream>

int main()
{
// 字符串中的 \\\\ 最终输出一个反斜杠。
std::cout << "C:\\\\Contacts\\\\data.txt\\n";

// \\t 输出水平制表符，\\n 输出换行符。
std::cout << "姓名\\t电话\\n";
}

📍 9.3 地址运算符与地址传递

主函数创建的是栈对象：

AddressBooks ads;

调用添加函数时：

addPerson(&ads);

&ads 取得对象地址，类型为 AddressBooks*，与函数参数类型匹配。函数得到地址后可以修改原对象，所以原注释写作：

//利用地址传递->可以修饰实参

这里的“修饰实参”更准确地说是“修改调用者传入的原对象”。

**补充说明：**原注释 //switch中两个case之间代码太多->报错->加上{}括起来就行 保持不变。准确地说，问题通常不是代码数量太多，而是多个标签共享同一作用域时，程序可能跳过局部变量的初始化。花括号建立独立作用域后可以解决这一类问题。这里不进一步展开相应语法。

🪟 9.4 system("pause") 和 system("cls")

system 会把字符串交给操作系统的命令解释器执行：

• system("pause") 调用 Windows 的 pause 命令。

• system("cls") 调用 Windows 的 cls 命令。

• Linux 和 macOS 通常没有这两个命令。

• 启动外部命令解释器还会带来额外开销。

• 不应把不可信的用户输入直接拼接到 system 参数中，否则可能出现命令注入。

可以使用标准输入实现简单等待：

#include <iostream>
#include <limits>

void waitForEnter()
{
// 丢弃当前输入行剩余内容。
std::cin.ignore(
std::numeric_limits<std::streamsize>::max(),
'\\n'
);

// 提示用户按回车继续。
std::cout << "按回车键继续…";

// 等待读取一个字符，用户按回车后继续。
std::cin.get();
}

标准 C++ 没有统一的清屏接口。跨平台程序通常选择不清屏、使用专门的终端库，或者由界面层针对不同平台实现。

🧠 十、栈、堆、new、delete 与 RAII

📚 10.1 栈对象

源码实际采用：

AddressBooks ads;

它是具有自动存储期的局部对象。离开 main 的作用域时，系统会自动调用其析构过程，无须手工 delete。

AddressBooks 内部的 Person 数组也属于该对象的一部分。每个 Person 中的 string 会自动管理自己的动态资源。

🗄️ 10.2 堆对象

注释中提供了另一种写法：

//AddressBooks* ads = new AddressBooks();//创建通讯录结构体变量在堆上 new->堆

如果启用它，new AddressBooks() 会在自由存储区创建对象并返回地址。传统写法必须在所有退出路径上执行：

delete ads;

否则对象占用的资源不会按预期释放。程序存在多个提前退出点时，手工维护 delete 很容易遗漏。

固定容量为 99 的当前结构体通常不需要为了避免栈空间而改用手工 new。是否放在栈上应结合对象大小、平台栈限制、生命周期和所有权设计判断。

🛡️ 10.3 RAII

RAII 的核心是让资源生命周期绑定到对象生命周期。对象构造时获得资源，析构时自动释放资源。

需要动态创建对象时，可以使用智能指针：

#include <memory>

int main()
{
// make_unique 在堆上创建 AddressBooks，并把所有权交给 unique_ptr。
auto ads = std::make_unique<AddressBooks>();

// unique_ptr 支持与普通指针相同的 -> 成员访问形式。
ads->m_Size = 0;

// 无须手工 delete。
// main 结束时，unique_ptr 自动销毁 AddressBooks。
return 0;
}

不过当前程序直接创建栈对象更简单：

int main()
{
// 栈对象会自动销毁，是这里更直接的选择。
AddressBooks ads{};

// 使用值初始化后，成员默认值会生效。
return 0;
}

🚀 十一、现代 C++ 综合优化方向

🧭 11.1 优化原则

现代化不意味着一次性推翻原程序，而是逐步减少容易出错的手工管理：

🧰 11.2 使用 std::vector 的通讯录模型

#include <string>
#include <vector>

enum class Sex
{
Unknown = 0,
Male = 1,
Female = 2
};

struct Contact
{
std::string name; // 姓名。
Sex sex = Sex::Unknown; // 性别使用枚举表达。
int age = 0; // 年龄。
std::string phone; // 电话按字符串保存。
std::string address; // 地址可以包含空格。
};

class AddressBook
{
public:
bool add(Contact contact)
{
// 如果仍希望保留 99 人上限，可以在类内部统一检查。
if (contacts_.size() >= MAX_CONTACTS)
{
return false;
}

// move 允许字符串内部资源在适当情况下直接转移。
contacts_.push_back(std::move(contact));
return true;
}

std::size_t size() const
{
// vector 自动记录当前元素数量。
return contacts_.size();
}

const std::vector<Contact>& contacts() const
{
// 返回只读引用，避免复制整个联系人集合。
return contacts_;
}

private:
static constexpr std::size_t MAX_CONTACTS = 99;

// vector 管理元素存储、析构和当前长度。
std::vector<Contact> contacts_;
};

这段代码属于拓展示例，不替换原程序。对零基础学习者而言，先理解原代码中的结构体、数组、有效长度和地址传递，再学习标准容器会更清晰。

📊 十二、全部核心知识汇总

🔄 原有写法与拓展写法对比

📏 1. 宏定义与 constexpr

原有写法：

#define MAX 99

拓展写法：

#include <cstddef>

// constexpr 定义具有明确类型的编译期常量。
constexpr std::size_t MAX_CONTACTS = 99;

// 常量受 C++ 作用域约束，也不会进行无类型的文本替换。
Person personArr[MAX_CONTACTS];

👤 2. 整数性别与 enum class

原有写法：

int m_Sex = 0;//性别->1男 2女

拓展写法：

// 枚举列出了性别字段允许表达的业务状态。
enum class Sex
{
Unknown = 0,
Male = 1,
Female = 2
};

struct PersonModern
{
std::string name; // 保存联系人姓名。
Sex sex = Sex::Unknown; // 默认值表示尚未选择。
int age = 0; // 保存联系人年龄。
std::string phone; // 电话号码使用字符串保存。
std::string address; // 保存家庭地址。
};

原写法允许把 10、100 等任意整数赋给性别字段。enum class 把允许的状态集中定义，能更准确地表达业务含义。

Sex sexFromNumber(int value)
{
// 把输入数字转换为业务枚举。
if (value == 1)
{
return Sex::Male;
}

if (value == 2)
{
return Sex::Female;
}

// 其他数字统一视为未知状态。
return Sex::Unknown;
}

📦 3. 固定数组与 std::vector

原有写法：

struct AddressBooks
{
struct Person personArr[MAX];//通讯录中保存的联系人数组

int m_Size = 0;//通讯录中当前记录联系人个数

};//通讯录

拓展写法：

#include <vector>

struct AddressBookModern
{
// vector 自动管理存储空间和有效元素数量。
std::vector<Person> people;
};

添加联系人时的对比：

// 原有写法需要手工确定写入位置。
ads->personArr[ads->m_Size] = person;

// 原有写法需要手工更新有效联系人数量。
ads->m_Size++;

// vector 把联系人添加到末尾，并自动更新 size()。
ads.people.push_back(person);

// 不再需要单独维护 m_Size。
std::cout << "当前人数：" << ads.people.size() << '\\n';

如果业务仍要求最多保存 99 人，可以继续保留上限：

constexpr std::size_t MAX_CONTACTS = 99;

bool addPersonModern(
AddressBookModern& ads,
const Person& person
)
{
// 即使使用 vector，也可以保留业务容量限制。
if (ads.people.size() >= MAX_CONTACTS)
{
return false;
}

// vector 自动完成存储和人数更新。
ads.people.push_back(person);
return true;
}

👉 4. 指针参数与引用参数

原有写法：

void addPerson(AddressBooks * ads) {//1.添加联系人

原有调用：

addPerson(&ads);//利用地址传递->可以修饰实参

拓展写法：

// 引用参数直接代表调用者传入的通讯录对象。
// 引用不能为空，函数内部也不需要使用 ->。
void addPersonModern(AddressBooks& ads)
{
// 使用点运算符访问引用对象的成员。
ads.m_Size++;
}

调用时不再取地址：

AddressBooks ads;

// 直接传入对象即可，函数仍能修改原对象。
addPersonModern(ads);

只需要读取通讯录时，使用 const 引用：

// const 表示函数不能修改通讯录。
// 引用避免复制整个 AddressBooks 对象。
void showPersonModern(const AddressBooks& ads)
{
std::cout << "联系人数量：" << ads.m_Size << '\\n';
}

⌨️ 5. 重复输入处理与通用输入函数

原有写法：

if (cin.fail()) {//处理输入类型错误—输入非数字
cin.clear();//清除cin错误状态
cin.ignore(numeric_limits<streamsize>::max(), '\\n');//清空缓冲区所有残留错误字符->直到遇到换行符
cout << "输入有误,请输入一个数字!" << endl;
continue;
}

原程序在性别、年龄、清空确认和菜单输入中多次出现相似代码。可以把它提取为通用函数：

#include <iostream>
#include <limits>
#include <string>

bool readInt(const std::string& prompt, int& result)
{
// 显示本次输入的提示文字。
std::cout << prompt;

// 尝试读取整数。
if (std::cin >> result)
{
return true;
}

// 清除输入流的错误状态。
std::cin.clear();

// 丢弃本行残留的非法字符。
std::cin.ignore(
std::numeric_limits<std::streamsize>::max(),
'\\n'
);

// 返回 false，表示没有获得有效整数。
return false;
}

年龄输入可以复用该函数：

int age = 0;

// readInt 负责类型检查，后面的表达式负责业务范围检查。
if (!readInt("请输入年龄：", age) ||
age <= 0 ||
age >= 120)
{
std::cout << "请输入一个正常年龄\\n";
}

这样修改输入恢复规则时只需要维护一处。

📱 6. 手工检查手机号与标准算法

原有写法：

if (phone.size() != 11) {//判断长度
cout << "输入的电话号码必须为11位的阿拉伯数字!!!" << endl;
continue;
}
//phone是string->判断数字
bool phoneAllNum = true;
for (char c : phone) {
if (c < '0' || c > '9' ) {
phoneAllNum = false;
break;
}
}

拓展写法：

#include <algorithm>
#include <string>

bool isPhoneValid(const std::string& phone)
{
// 第一项规则：字符串长度必须为 11。
if (phone.size() != 11)
{
return false;
}

// 第二项规则：所有字符都必须是 ASCII 数字。
return std::all_of(
phone.begin(),
phone.end(),
[](char c)
{
return c >= '0' && c <= '9';
}
);
}

调用示例：

std::string phone;
std::cin >> phone;

if (!isPhoneValid(phone))
{
std::cout << "电话号码必须是11位阿拉伯数字\\n";
}

🔍 7. -1 哨兵与 std::optional

原有写法：

//监测联系人是否存在->存在 返回联系人所在数组中的具体位置->不存在 返回-1
int isExist(AddressBooks* ads, string name) {//参数:1->通讯录 2->对比姓名
for (int i = 0;i < ads->m_Size;i++) {
if (ads->personArr[i].m_Name == name) {
return i;//找到了->返回此人在数组中的下标编号
}
}
return -1;//遍历结束未找到->返回-1
}

拓展写法：

#include <cstddef>
#include <optional>
#include <string>

std::optional<std::size_t> findPersonIndex(
const AddressBookModern& ads,
const std::string& name
)
{
for (std::size_t i = 0; i < ads.people.size(); ++i)
{
if (ads.people[i].m_Name == name)
{
// optional 中保存有效数组下标。
return i;
}
}

// nullopt 明确表示没有找到联系人。
return std::nullopt;
}

使用结果：

const auto position = findPersonIndex(ads, name);

if (position.has_value())
{
// value() 取得 optional 中保存的下标。
const Person& person = ads.people[position.value()];
std::cout << person.m_Name << '\\n';
}

🗑️ 8. 手工删除搬移与 vector::erase

原有写法：

if (ret != -1) {//查到此人->删除
for (int i = ret;i < ads->m_Size – 1;i++) {
ads->personArr[i] = ads->personArr[i + 1];//数据前移
}
ads->m_Size–;//更新通讯录的人数
cout << "删除成功" << endl;
}

拓展写法：

#include <algorithm>
#include <string>

bool deletePersonModern(
AddressBookModern& ads,
const std::string& name
)
{
// 查找第一个姓名匹配的联系人。
const auto position = std::find_if(
ads.people.begin(),
ads.people.end(),
[&name](const Person& person)
{
return person.m_Name == name;
}
);

// end() 表示没有找到。
if (position == ads.people.end())
{
return false;
}

// erase 负责删除元素、搬移后续元素并更新容器大小。
ads.people.erase(position);
return true;
}

vector::erase 并没有消除搬移成本，但减少了手工维护边界和人数时出现错误的可能。

🧹 9. 逻辑清空与容器清空

原有写法：

//6.清空联系人
void clearPerson(AddressBooks* ads) {
ads->m_Size = 0;//将记录的联系人数量置0:逻辑清空->数据还在 只是访问不到
cout << "通讯录已清空" << endl;
}

拓展写法：

void clearPersonModern(AddressBookModern& ads)
{
// clear 销毁 vector 中的所有有效联系人。
// vector 的 size() 会自动变成 0。
ads.people.clear();

std::cout << "通讯录已清空\\n";
}

🧠 10. 裸 new/delete 与 RAII

原有注释写法：

// 将通讯录对象分配到堆以避免占用过多栈空间
//AddressBooks* ads = new AddressBooks();//创建通讯录结构体变量在堆上 new->堆

对应释放代码：

//delete ads; // 释放堆上资源

智能指针拓展写法：

#include <memory>

int main()
{
// make_unique 在堆上创建对象。
// unique_ptr 独占该对象的所有权。
auto ads = std::make_unique<AddressBooks>();

// 使用方式与普通指针相似。
ads->m_Size = 0;

// 函数结束时自动销毁对象，不需要手工 delete。
return 0;
}

当前通讯录更简单的写法仍然是栈对象：

int main()
{
// AddressBooks 自动初始化，并在作用域结束时自动销毁。
AddressBooks ads{};

// 不需要 new，也不需要 delete。
return 0;
}

🪟 11. system 命令与可移植等待

原有写法：

system("pause");//请按任意键继续
system("cls");//清屏操作

拓展写法：

#include <iostream>
#include <limits>

void waitForEnter()
{
// 清理当前输入行剩余内容。
std::cin.ignore(
std::numeric_limits<std::streamsize>::max(),
'\\n'
);

std::cout << "按回车键继续…";

// 等待用户按下回车。
std::cin.get();
}

标准 C++ 没有统一的清屏函数。跨平台程序可以选择不清屏，或者由独立界面层调用平台专用接口。

📊 原有代码与拓展写法总表

✅ 十四、学习结论

这份通讯录程序虽然规模不大，却把数据建模、函数封装、指针传递、输入状态恢复、字符串校验、线性查找、数组删除、逻辑清空和内存生命周期串联在了同一个项目中。

学习时应重点建立以下认识：