10天极简C++入门：从环境搭建到实战通讯录系统

1. 项目概述：为什么是C++，为什么是10天？

如果你点开这篇文章，大概率是想在短时间内，对C++这门“古老”又“强大”的编程语言建立一个清晰、可用的认知。在这个Python、JavaScript大行其道的时代，为什么还要学C++？答案很简单：掌控力。当你需要榨干硬件的每一分性能，当你需要理解操作系统、数据库、游戏引擎的底层运作，当你面对的是自动驾驶、高频交易、工业控制这类对实时性和可靠性要求极高的场景时，C++依然是无可替代的王者。它不像Python那样“开箱即用”，但正是这种“不省心”，让你能清晰地知道每一个字节的去向，每一次内存的分配。

“10天学会”听起来像是个噱头，但这里的“学会”有明确的定义：不是成为专家，而是建立一条从零到能写、能读、能调试简单C++程序的清晰路径，并理解其核心思想。这10天，我们将避开学院派冗长的理论铺垫，采用“问题驱动，代码先行”的极简模式。每一天聚焦一个核心主题，通过解决一个具体的小问题来掌握相关语法和概念，最终串联起一个完整的知识骨架。我们的目标不是覆盖C++标准库的每一个角落，而是让你在10天后，拿到一段C++代码不再发怵，想实现一个小功能时知道该从哪里入手。

2. 极简学习路径设计与环境搭建

2.1 10天学习地图：从“Hello World”到小型项目

一个有效的学习路径必须目标明确、节奏紧凑。下面是我们设计的10天极简学习地图，每一天都承上启下，确保你在动手实践中稳步前进：

第1天：破冰仪式——第一个C++程序与环境认知

• 核心目标：成功运行“Hello, World!”，理解编译、链接的基本过程。
• 实操任务：安装编译器（如MinGW-w64或MSVC），配置一个极简的编辑环境（推荐VSCode），编写并运行第一个程序。
• 避坑点：重点解决环境变量配置、编译器路径识别等新手最常见的问题。

第2天：数据的容器——变量、基本数据类型与运算符

• 核心目标：理解C++如何存储和操作整数、浮点数、字符和布尔值。
• 实操任务：编写一个简单的单位转换器（如华氏度转摄氏度）或小型计算器。
• 关键概念：int,double,char,bool, 算术/关系/逻辑运算符，变量的声明与初始化。

第3天：流程的舵手——条件判断与循环控制

• 核心目标：掌握程序分支与重复执行的能力。
• 实操任务：实现一个猜数字游戏，或一个简单的命令行菜单系统。
• 关键概念：if/else if/else,switch,for循环,while循环,do...while循环。

第4天：代码的模块化——函数与初识作用域

• 核心目标：学会将代码块封装成可复用的函数，理解局部与全局变量的区别。
• 实操任务：重构前几天的代码，将计算、判断等逻辑抽取为独立函数。
• 关键概念：函数声明与定义，参数传递（值传递），返回值，局部/全局作用域。

第5天：数据的集合——数组与字符串

• 核心目标：学习处理同类型数据的集合和文本数据。
• 实操任务：实现一个学生成绩统计程序（计算平均分、最高分），或一个简单的字符串反转、查找工具。
• 关键概念：静态数组，C风格字符串（字符数组），std::string的基本使用。

第6天：内存的探针——指针与引用

• 核心目标：理解C++最核心也最令人困惑的概念之一——内存地址的直接操作。
• 实操任务：通过指针操作数组元素，实现一个利用引用交换两个变量值的函数。
• 关键概念：指针的定义、取地址(&)、解引用(*)，引用的定义与使用，指针与数组的关系。

第7天：自定义的蓝图——结构体与枚举

• 核心目标：学会创建复合数据类型，更好地组织数据。
• 实操任务：定义一个Student结构体来管理学生信息（姓名、学号、成绩），并编写函数进行输入输出和简单查询。
• 关键概念：struct定义，成员访问(.)，enum class（强类型枚举）。

第8天：面向对象的初体验——类与对象的基本概念

• 核心目标：理解封装思想，学会定义简单的类。
• 实操任务：将第7天的Student结构体升级为Student类，加入成员函数（方法）来封装数据操作。
• 关键概念：类的定义，public/private访问控制，构造函数，成员函数。

第9天：资源的管家——动态内存管理入门

• 核心目标：理解运行时分配内存的必要性，并安全地使用它。
• 实操任务：使用new和delete动态创建对象数组，并体会内存泄漏的风险。
• 关键概念：new/delete运算符，动态数组，内存泄漏的基本概念。

第10天：综合实战——一个小型通讯录管理程序

• 核心目标：综合运用前9天的知识，完成一个具备增删改查功能的命令行程序。
• 实操任务：设计Contact类，使用动态数组或std::vector（初步引入）管理联系人列表，实现通过命令行交互的完整功能。
• 核心价值：将分散的知识点串联成解决实际问题的能力，建立初步的工程感。

环境搭建极简建议：对于绝对新手，在Windows下，我强烈推荐使用MSYS2 + MinGW-w64 + VSCode的组合。MSYS2提供了一个优秀的包管理环境，可以一键安装GCC编译器（pacman -S mingw-w64-ucrt-x86_64-gcc），避免了手动配置环境变量的诸多麻烦。VSCode安装C/C++扩展后，智能感知和调试功能对新手极其友好。记住，第一天的主要目标就是让环境跑起来，不要陷入IDE复杂配置的泥潭。

2.2 工具选型：轻量至上，拒绝臃肿

工欲善其事，必先利其器。但对于10天极简入门，我们的原则是“工具为学习服务，而非学习工具本身”。

1. 编译器（Compiler）：这是将你的C++代码翻译成机器指令的核心工具。

   • GCC (MinGW-w64)：开源、跨平台，是Linux/macOS上的默认选择，在Windows上通过MSYS2或MinGW-w64项目获得。它标准兼容性好，生态丰富。
   • MSVC (Microsoft Visual C++)：Windows原生编译器，与Visual Studio深度集成。如果你确定只在Windows环境学习，并且不排斥稍大的安装包，它是最稳定、调试体验最好的选择。
   • 选择建议：追求轻量、跨平台概念，选MinGW-w64。追求在Windows上最省事、最强的调试，可以下载Visual Studio Build Tools或Visual Studio Community（只选C++桌面开发组件）。

2. 代码编辑器（Editor）：

   • Visual Studio Code (VSCode)：当前的首选。轻量、免费、插件生态极其强大。安装C/C++扩展包后，代码补全、跳转定义、静态检查、调试功能一应俱全。通过简单的tasks.json和launch.json配置，就能实现一键编译运行调试，非常适合学习。
   • CLion：JetBrains出品，专业的C/C++ IDE，智能提示、重构、集成调试能力顶尖。但它是付费软件（对学生免费），且相对较重。对于10天入门，VSCode完全足够。
   • 记事本/Notepad++：极简之选，但你需要完全在命令行手动编译(g++ your_code.cpp -o program)。这有助于你理解编译过程，但会降低初期的学习流畅度。

3. 调试器（Debugger）：

   • GDB / LLDB：分别是GCC和Clang编译器套件中的命令行调试器，功能强大但需要学习命令。
   • 集成调试器：VSCode和Visual Studio的图形化调试界面是新手福音。你可以设置断点、逐行执行、查看变量值的变化，直观地理解程序运行流程，这是学习过程中不可或缺的环节。

我的个人建议是：Windows用户用MSYS2安装MinGW-w64 GCC+VSCode；macOS用户用Homebrew安装GCC或直接使用Clang+VSCode；Linux用户直接用系统包管理器安装g+++VSCode。这个组合在保证功能完整的前提下，最为轻量和通用。

3. 核心语法精讲与避坑指南

3.1 指针与引用：理解“地址”与“别名”

这是C++新手的第一道分水岭。很多人在这里绕晕了。让我们用最生活化的方式来理解：

• 变量：就像一个房子，里面住着数据（值）。
• 指针：就是一个写着这个房子地址的纸条。你拿着这个纸条（指针），就能找到那个房子（变量）。
• 引用：就是这个房子的一个别名、外号。你叫这个外号，和叫它本来的名字，指的是同一个房子。

int house = 42; // 一栋房子，门牌号是42 int* address_note = &house; // 一张纸条，上面写着房子的地址（&是取地址符） int& nickname = house; // 给这栋房子起个别名叫nickname *address_note = 100; // 根据纸条找到房子，把里面的值改成100（*是解引用符） nickname = 200; // 通过别名直接修改房子里的值 // 现在，house的值是200，因为address_note和nickname操作的是同一个房子。

关键区别与避坑点：

1. 指针可以为空（nullptr），引用必须绑定到一个已有对象。引用从一出生就必须代表某个东西，而指针可以暂时不指向任何地方。
2. 指针可以改变指向，引用一旦绑定就不能改变。纸条可以撕掉重写一个新地址，但外号一旦给了这栋房子，就不能再用来叫别的房子。
3. 操作语法不同：指针需要用*来访问它指向的对象，引用则直接当原变量使用。
4. 常见坑：未初始化指针和悬空指针。

   int* p; // 危险！指针p未初始化，里面是垃圾地址 *p = 5; // 灾难：向一个未知的内存地址写入数据，可能导致程序崩溃 int* q = new int(10); // q指向堆上分配的一个整数 delete q; // 释放内存 // 此时q是一个“悬空指针”，它指向的内存已被系统回收 *q = 20; // 危险！操作已释放的内存，行为未定义 q = nullptr; // 好习惯：释放后立即置空，避免误用

实操心得：初学阶段，在函数参数传递时，优先考虑使用“常量引用”（const T&）。它既避免了大型对象值传递的拷贝开销，又像值传递一样安全（因为const保证了数据不会被意外修改）。当函数确实需要修改传入的参数时，再考虑使用非常量引用或指针。

3.2 内存管理：从“栈”与“堆”说起

C++让你直接管理内存，这是其威力的来源，也是复杂性的根源。你必须清楚两个关键区域：

• 栈（Stack）：由编译器自动管理。函数内的局部变量、函数参数等都存放在这里。当函数执行结束时，这些内存会被自动回收。分配和回收速度极快，但容量有限。

  void func() { int x = 10; // x在栈上分配 std::string name = "Alice"; // name对象本身在栈上，其数据可能在内部分配堆内存 } // 函数结束，x和name被自动销毁（调用析构函数）

• 堆（Heap）：也叫自由存储区，由程序员手动管理。使用new运算符申请，delete运算符释放。容量大（受限于系统物理内存），但分配速度慢，且管理不当会导致内存泄漏或非法访问。

  int* p = new int; // 在堆上分配一个int大小的内存，地址赋给p *p = 42; delete p; // 必须手动释放！否则这块内存将永远无法被程序再次使用（内存泄漏） p = nullptr; // 好习惯：释放后置空 int* arr = new int[100]; // 在堆上分配一个包含100个int的数组 // ... 使用 arr ... delete[] arr; // 释放数组必须用 delete[]， 而不是 delete arr = nullptr;

现代C++的救星：智能指针手动管理new/delete极易出错。C++11引入了智能指针，它们将裸指针包装成对象，利用RAII（资源获取即初始化）技术，在智能指针对象生命周期结束时自动释放内存。

• std::unique_ptr<T>：独占所有权的指针。同一时间只能有一个unique_ptr指向一个对象。当unique_ptr被销毁（如离开作用域），它指向的对象也会被自动删除。无法被复制，只能被移动（std::move）。

  #include <memory> std::unique_ptr<int> up(new int(30)); // auto up = std::make_unique<int>(30); // C++14后更好的方式 // 当up离开作用域，int(30)会被自动delete。

• std::shared_ptr<T>：共享所有权的指针。通过引用计数跟踪有多少个shared_ptr指向同一对象。当最后一个shared_ptr被销毁时，对象才会被删除。可以被复制。

  std::shared_ptr<int> sp1 = std::make_shared<int>(40); { std::shared_ptr<int> sp2 = sp1; // 引用计数+1 // sp1和sp2指向同一个int } // sp2离开作用域，引用计数-1 // sp1离开作用域，引用计数变为0，内存被释放

核心建议：在入门后期，一旦开始涉及动态内存分配，立刻习惯使用std::unique_ptr和std::make_unique（C++14）。这能避免绝大多数因忘记delete导致的内存泄漏问题。std::shared_ptr用于更复杂的共享所有权场景，但需注意循环引用问题（可用std::weak_ptr解决）。

3.3 面向对象编程（OOP）核心三要素

OOP不是C++的全部，但是其重要组成部分。理解这三个概念，才能写出易于管理和扩展的代码。

1. 封装（Encapsulation）：将数据（属性）和操作数据的方法（函数）捆绑在一起，形成一个“类”。同时，对外隐藏内部实现细节，只暴露必要的接口。

   • 目的：提高安全性（防止数据被随意篡改）、简化调用（使用者无需关心内部逻辑）、易于维护（内部修改不影响外部使用）。

   class BankAccount { private: // 对外隐藏，无法直接访问 double balance; std::string password; public: // 对外公开的接口 BankAccount(double initBalance, const std::string& pwd) : balance(initBalance), password(pwd) {} bool withdraw(double amount, const std::string& inputPwd) { if (inputPwd != password) return false; if (amount > balance) return false; balance -= amount; return true; } double getBalance() const { return balance; } // const成员函数，承诺不修改对象状态 }; // 使用者只能通过deposit、withdraw、getBalance来操作账户，不知道密码如何验证、余额如何存储。

2. 继承（Inheritance）：允许一个类（派生类/子类）基于另一个类（基类/父类）来创建，获得其属性和方法，并可以添加或覆盖它们。

   • 目的：实现代码复用，建立“是一个（is-a）”的关系层次。

   class Shape { // 基类 public: virtual double area() const = 0; // 纯虚函数，使Shape成为抽象类 virtual ~Shape() {} // 虚析构函数，确保正确释放派生类对象 }; class Circle : public Shape { // 派生类，公有继承 private: double radius; public: Circle(double r) : radius(r) {} double area() const override { // 重写（覆盖）虚函数 return 3.14159 * radius * radius; } }; // Circle “是一个” Shape，它必须实现area()方法。

3. 多态（Polymorphism）：指通过基类的指针或引用调用虚函数时，实际执行的是派生类中重写的版本。

   • 目的：实现接口统一，运行时动态绑定，提高代码的扩展性和灵活性。

   void printArea(const Shape& shape) { std::cout << "Area: " << shape.area() << std::endl; } int main() { Circle c(5.0); // Rectangle r(4.0, 6.0); // 假设有另一个派生类Rectangle printArea(c); // 传入Circle，调用Circle::area() // printArea(r); // 传入Rectangle，调用Rectangle::area() // printArea函数无需修改，就能处理任何Shape的派生类，这就是多态的魅力。 }

注意事项：

• 慎用继承，优先组合：除非确实是“is-a”关系，否则优先考虑将一个类作为另一个类的成员（组合），而非继承。滥用继承会导致脆弱的基类问题。
• 基类析构函数应为虚函数：如果类可能被继承，并且会通过基类指针来删除派生类对象，那么基类的析构函数必须是虚函数，否则会导致派生类部分资源泄漏。
• 明确重写使用override关键字：C++11引入override，明确表示此函数是重写基类的虚函数。如果拼写错误或签名不匹配，编译器会报错，这是一个重要的安全特性。

4. 实战：构建一个极简通讯录管理系统

让我们用第10天的综合实战来串联核心知识。这个程序将使用面向对象思想，并涉及基本的I/O、数据结构和管理逻辑。

4.1 需求分析与类设计

我们需要一个能存储联系人（姓名、电话号码）的程序，并支持以下功能：

1. 添加联系人
2. 显示所有联系人
3. 根据姓名查找联系人
4. 删除联系人
5. 退出程序

类设计：

• Contact类：代表单个联系人。
• AddressBook类：管理一个Contact的集合，并提供增删改查接口。
• main函数：提供命令行交互界面，驱动AddressBook对象。

4.2 代码实现与逐行解析

contact.h (头文件，声明类)

#ifndef CONTACT_H // 头文件守卫，防止重复包含 #define CONTACT_H #include <string> class Contact { private: std::string name; std::string phoneNumber; public: // 构造函数 Contact(const std::string& name = "", const std::string& phone = ""); // Getter 和 Setter (提供对私有成员的访问接口) std::string getName() const; void setName(const std::string& name); std::string getPhoneNumber() const; void setPhoneNumber(const std::string& phone); // 显示联系人信息 void display() const; }; #endif // CONTACT_H

contact.cpp (源文件，实现类方法)

#include "contact.h" #include <iostream> // 构造函数初始化列表 Contact::Contact(const std::string& name, const std::string& phone) : name(name), phoneNumber(phone) { // 成员初始化列表是更高效的初始化方式 } std::string Contact::getName() const { return name; } void Contact::setName(const std::string& name) { this->name = name; // 使用this指针区分同名的成员变量和参数 } std::string Contact::getPhoneNumber() const { return phoneNumber; } void Contact::setPhoneNumber(const std::string& phone) { phoneNumber = phone; } void Contact::display() const { std::cout << "Name: " << name << "\tPhone: " << phoneNumber << std::endl; }

addressbook.h

#ifndef ADDRESSBOOK_H #define ADDRESSBOOK_H #include "contact.h" #include <vector> // 使用标准库的vector动态数组，比原生数组更安全方便 class AddressBook { private: std::vector<Contact> contacts; // 使用vector存储Contact对象 public: void addContact(const Contact& contact); void displayAll() const; // 查找联系人，返回其在vector中的索引，未找到返回-1 int findContactByName(const std::string& name) const; bool deleteContactByName(const std::string& name); }; #endif

addressbook.cpp

#include "addressbook.h" #include <iostream> void AddressBook::addContact(const Contact& contact) { contacts.push_back(contact); // vector的push_back方法在尾部添加元素 std::cout << "Contact added successfully." << std::endl; } void AddressBook::displayAll() const { if (contacts.empty()) { std::cout << "Address book is empty." << std::endl; return; } std::cout << "\n--- All Contacts ---" << std::endl; // 范围for循环 (C++11)，遍历容器更简洁 for (const auto& contact : contacts) { contact.display(); } std::cout << "-------------------\n" << std::endl; } int AddressBook::findContactByName(const std::string& name) const { for (size_t i = 0; i < contacts.size(); ++i) { if (contacts[i].getName() == name) { return static_cast<int>(i); // 找到，返回索引 } } return -1; // 未找到 } bool AddressBook::deleteContactByName(const std::string& name) { int index = findContactByName(name); if (index != -1) { // vector的erase方法，传入迭代器位置删除元素 contacts.erase(contacts.begin() + index); std::cout << "Contact deleted successfully." << std::endl; return true; } else { std::cout << "Contact not found." << std::endl; return false; } }

main.cpp (程序入口与用户交互)

#include "addressbook.h" #include <iostream> #include <limits> // 用于清理输入缓冲区 void showMenu() { std::cout << "\n=== Address Book Manager ===" << std::endl; std::cout << "1. Add Contact" << std::endl; std::cout << "2. Display All Contacts" << std::endl; std::cout << "3. Find Contact by Name" << std::endl; std::cout << "4. Delete Contact by Name" << std::endl; std::cout << "5. Exit" << std::endl; std::cout << "===========================" << std::endl; std::cout << "Enter your choice (1-5): "; } // 辅助函数：清空输入缓冲区，避免后续的getline读到残留的换行符 void clearInputBuffer() { std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); } int main() { AddressBook myBook; int choice = 0; std::string name, phone; do { showMenu(); std::cin >> choice; clearInputBuffer(); // 清除数字输入后的换行符 switch (choice) { case 1: { std::cout << "Enter name: "; std::getline(std::cin, name); // 使用getline读取可能包含空格的名字 std::cout << "Enter phone number: "; std::getline(std::cin, phone); myBook.addContact(Contact(name, phone)); break; } case 2: myBook.displayAll(); break; case 3: { std::cout << "Enter name to find: "; std::getline(std::cin, name); int index = myBook.findContactByName(name); if (index != -1) { std::cout << "Contact found." << std::endl; // 这里可以扩展为显示详细信息 } else { std::cout << "Contact not found." << std::endl; } break; } case 4: { std::cout << "Enter name to delete: "; std::getline(std::cin, name); myBook.deleteContactByName(name); break; } case 5: std::cout << "Exiting program. Goodbye!" << std::endl; break; default: std::cout << "Invalid choice! Please enter 1-5." << std::endl; } } while (choice != 5); return 0; }

4.3 编译与运行

假设你的文件结构如下：

your_project/ ├── contact.h ├── contact.cpp ├── addressbook.h ├── addressbook.cpp └── main.cpp

在命令行中，进入该目录，使用GCC编译：

g++ -std=c++11 main.cpp contact.cpp addressbook.cpp -o addressbook.exe

• -std=c++11：指定使用C++11标准，确保auto和范围for循环可用。
• -o addressbook.exe：指定输出的可执行文件名。

运行程序：

./addressbook.exe # Linux/macOS addressbook.exe # Windows

5. 常见问题与深度排查指南

学习C++的过程就是与编译器错误和运行时Bug斗争的过程。以下是新手最常遇到的几类问题及其解决方法。

5.1 编译期错误：读懂编译器的“天书”

编译器报错信息往往冗长晦涩。关键是抓住第一个错误和错误位置（行号）。

1. 语法错误（Syntax Error）：最常见，比如缺少分号、括号不匹配、关键字拼写错误。

   • 示例：error: expected ‘;’ before ‘}’ token
   • 排查：检查错误行及上一行，确认语句是否以分号结束。使用代码编辑器的括号高亮功能。

2. 类型不匹配（Type Mismatch）：

   • 示例：error: cannot convert ‘std::string’ to ‘int’ in assignment
   • 排查：检查赋值语句左右两边的数据类型是否兼容。注意char、char*和std::string的区别。

3. 未定义引用（Undefined Reference）：链接错误，通常意味着函数声明了但没定义，或者定义了但编译时没链接到对应的源文件。

   • 示例：undefined reference toContact::display()'`
   • 排查：
     • 确认函数签名（返回值、函数名、参数列表）在头文件(.h)和源文件(.cpp)中完全一致。
     • 确认所有必要的.cpp文件都加入了编译命令。比如上面的例子，你必须编译contact.cpp。

4. 头文件重复包含（Redefinition）：

   • 示例：error: redefinition of ‘class Contact’
   • 排查：确保每个头文件都使用了头文件守卫（#ifndef ... #define ... #endif）或#pragma once（非标准但广泛支持）。

5.2 运行时错误与调试技巧

程序编译通过了，但运行起来崩溃或结果不对。

1. 段错误（Segmentation Fault）：访问了不属于你的内存。90%的原因是指针问题。

   • 可能原因：
     • 解引用空指针（int* p = nullptr; *p = 5;）。
     • 解引用未初始化的指针（野指针）。
     • 数组访问越界（int arr[5]; arr[10] = 1;）。
     • 使用已释放的内存（悬空指针）。
   • 调试：使用调试器（GDB或IDE集成调试）在崩溃前设置断点，单步执行，观察指针的值和访问的内存地址。

2. 逻辑错误（Logic Error）：程序能运行，但结果不符合预期。

   • 示例：循环条件写反，变量初始化错误，算法逻辑有误。
   • 调试：
     • 打印调试法：在关键位置插入std::cout，输出变量的中间值。
     • 橡皮鸭调试法：向一个假想的对象（或真实的同事）一行行解释你的代码，往往在解释过程中就能发现问题。
     • 使用调试器观察：这是最强大的方法。设置观察点（watchpoint），查看变量在每一步的变化。

3. 内存泄漏（Memory Leak）：程序持续运行后，占用内存越来越多。

   • 排查：对于简单的程序，确保每个new都有对应的delete，每个new[]都有对应的delete[]。更佳实践是使用智能指针std::unique_ptr，从根本上避免泄漏。复杂项目可以使用Valgrind（Linux）或Visual Studio Diagnostic Tools等专业工具检测。

5.3 初学阶段的高频“坑点”速查表

问题现象	可能原因	解决方案
控制台输出一闪而过	程序执行完毕，控制台窗口自动关闭	在main函数return前加system(“pause”)(Windows)或cin.get()；或在IDE中配置“运行后暂停控制台”。
使用std::cin >>后，std::getline不等待输入	cin >>留下换行符在缓冲区，被getline直接读取	在cin >>后使用cin.ignore()清空缓冲区。
字符串比较总是失败	使用了==比较C风格字符串（char*）	比较char*应使用strcmp()；或直接使用std::string，它重载了==。
修改函数内的参数，外部变量没变	参数是值传递（pass-by-value），函数内修改的是副本	若需修改外部变量，使用引用传递（int&）或指针传递（int*）。
类成员函数无法修改成员变量	成员函数被声明为const	移除函数声明后的const关键字，或将要修改的成员变量用mutable修饰（慎用）。
vector下标访问崩溃	访问了超出size()范围的索引	使用at(index)会进行边界检查并抛出异常；访问前用if (index < vec.size())判断。
循环无限执行或一次都不执行	循环条件（i < N）或更新语句（i++）写错	仔细检查循环三要素：初始化、条件、更新。用调试器单步跟踪。

掌握C++是一个螺旋上升的过程。这10天的旅程，旨在为你打下坚实的地基，建立正确的思维模型。不要指望一次就精通所有细节，尤其是模板、元编程、移动语义等高级主题。最好的学习方式是反复练习，并尝试阅读优秀的开源代码。从这个小通讯录程序出发，你可以尝试添加更多功能（如文件存储、按号码查找、修改联系人），在实践中不断巩固和拓展。记住，编程是门手艺，唯手熟尔。当你第一次用C++写出一个运行流畅的小工具，或是解决了一个棘手的性能问题时，那种对计算机系统的深层掌控感，将是其他语言难以给予的独特回报。