1. 项目概述与核心价值

最近在带几个刚学完C++基础语法的实习生，发现他们普遍面临一个困境：书本上的概念都懂，比如类、继承、多态，但一到自己动手，就不知道如何把这些零散的知识点串联成一个能跑起来的、有实际意义的程序。他们最常问我的就是：“哥，有没有一个项目，能把面向对象的核心思想都练一遍，代码量适中，但结构又足够清晰？” 我每次都会毫不犹豫地推荐这个——基于多态的职工管理系统。

这绝不是一个简单的“学生作业”。在我看来，它是C++从业者从“知道”到“会用”的关键跳板。为什么这么说？因为一个合格的C++开发者，不仅要会写算法，更要懂得如何用面向对象的思想来组织代码、管理资源、设计接口。这个项目麻雀虽小，五脏俱全：它要求你定义清晰的类层次结构（普通员工、经理、老板），运用继承来复用代码，更重要的是，你必须使用多态来统一管理这些不同类型的对象。当你用基类指针数组来存储所有职工，并通过虚函数来调用他们各自不同的“显示信息”或“计算薪资”方法时，你才真正触摸到了C++面向对象编程的灵魂。

整个项目在控制台（命令行）环境下完成，这看似“简陋”，却恰恰是它的优势所在。它迫使你剥离华丽的图形界面，专注于最核心的业务逻辑和数据结构的构建。你将亲手处理文件的读写（用于保存职工数据）、实现增删改查（CRUD）功能、设计清晰的菜单交互。完成这个项目后，你会对C++中的类设计、内存管理（特别是new/delete与多态结合时的注意事项）、文件流操作以及程序的分层架构有一个非常扎实的理解。下面，我就把自己实现这个项目时的完整思路、关键代码、踩过的坑以及一些能让你代码更“工业级”的技巧，毫无保留地分享出来。

2. 系统整体设计与核心思路拆解

2.1 需求分析与类图设计

接到“职工管理系统”这个需求，第一步不是打开IDE写代码，而是拿出纸笔（或绘图工具）进行设计。核心需求很明确：管理多种类型的职工（如普通员工、经理、总监），他们有不同的属性和行为（例如，计算薪资的公式不同）。系统需要提供基本的增、删、改、查、清空、保存、加载功能。

基于此，我设计的核心类图如下（用文字描述）：

1. 抽象基类Worker：这是整个系统的基石。它定义了所有职工共有的属性和行为接口。

   • 属性：职工编号（m_Id）、姓名（m_Name）、部门编号（m_DeptId）。这些设为保护（protected）成员，便于子类访问。
   • 纯虚函数：virtual void showInfo() = 0;（显示个人信息）、virtual string getDeptName() = 0;（获取岗位名称）、virtual double calculateSalary() = 0;（计算月薪）。将这些函数声明为纯虚函数，意味着Worker是一个抽象类，不能实例化，强制所有子类必须提供自己的实现。这正是多态得以实现的关键。

2. 具体职工子类：它们继承自Worker，并实现具体的纯虚函数。

   • Employee（普通员工）：可能有固定月薪。
   • Manager（经理）：固定月薪 + 绩效奖金。
   • Boss（老板）：固定年薪。
   • 每个子类在自己的showInfo中展示独特信息，在calculateSalary中实现自己的薪资计算逻辑。

3. 管理类WorkerManager：这是系统的“大脑”或“控制器”。它不关心具体是哪种职工，只通过Worker*基类指针来操作。

   • 核心数据成员：Worker** m_EmpArray;（一个指向Worker指针的指针，动态数组）、int m_EmpNum;（当前职工数量）、int m_FileIsEmpty;（标志文件是否为空）。
   • 核心成员函数：构造函数/析构函数（负责内存初始化与释放）、Show_Menu()（显示菜单）、Add_Emp()（添加职工）、Save()（保存到文件）、Init_Emp()（从文件加载初始化数组）、Show_Emp()（显示所有职工）等所有功能函数。

设计思路的核心：WorkerManager类持有一个Worker*的数组。当添加一个Manager对象时，代码是new Manager(...)，但返回的指针被赋给了Worker*类型的数组元素。当遍历数组调用showInfo()时，由于它是虚函数，程序会自动根据指针实际指向的对象类型（Manager）来调用Manager::showInfo()。这就是多态的魔力——“一个接口，多种实现”，极大地降低了模块间的耦合度。如果你想新增一种职工类型（如Technician），只需从Worker派生新类并实现虚函数，然后在Add_Emp()的菜单里加一个选项即可，WorkerManager的其他代码几乎不用动。

2.2 文件存储格式设计

数据持久化是必须的。我选择使用文本文件（如employee.txt）来存储。设计一个清晰、易于解析的格式至关重要。

我采用的格式示例：

1 张三 1 10000 2 李四 2 15000 5000 3 王五 3 200000

• 每一行代表一个职工。
• 字段用空格隔开：这是最简单的分隔方式。
• 字段顺序：编号 姓名 部门编号 薪资参数1 [薪资参数2]
  • 部门编号：可以约定 1-普通员工，2-经理，3-老板。这样加载时可以根据这个数字来创建对应的子类对象。
  • 薪资参数：普通员工可能只有固定月薪；经理有月薪和奖金；老板有年薪。字段数量可以不同。

为什么不用二进制文件或数据库？对于这个入门项目，文本文件足够简单直观，便于调试。你可以直接打开文件查看数据是否正确。二进制文件虽然更省空间，但可读性差，且涉及内存对齐等问题，对新手不友好。数据库则引入了额外的外部依赖和学习成本。文本文件是这个阶段最合适的选择。

2.3 菜单驱动与用户交互

控制台项目需要一个清晰的菜单来引导用户。我设计了一个循环，直到用户选择退出（如输入0）。

菜单示例：

******************************************** ********* 欢迎使用职工管理系统！ ********** ******************************************** * 0. 退出管理程序 * * 1. 增加职工信息 * * 2. 显示职工信息 * * 3. 删除离职职工 * * 4. 修改职工信息 * * 5. 查找职工信息 * * 6. 按照编号排序 * * 7. 清空所有文档 * ********************************************

WorkerManager::Show_Menu()函数负责打印此菜单并返回用户的选择。主函数（main）中通过switch-case根据返回值调用WorkerManager对应的成员函数。

3. 核心模块实现与代码精讲

3.1 抽象基类Worker的实现

worker.h

#ifndef WORKER_H #define WORKER_H #include <iostream> #include <string> using namespace std; class Worker { public: // 纯虚函数，显示职工信息 virtual void showInfo() = 0; // 纯虚函数，获取岗位名称 virtual string getDeptName() = 0; // 纯虚函数，计算月薪（对于老板，则是年薪/12） virtual double calculateSalary() = 0; // 职工编号 int m_Id; // 职工姓名 string m_Name; // 部门编号 (1:普通员工, 2:经理, 3:老板) int m_DeptId; virtual ~Worker() {} // 虚析构函数，确保正确释放子类资源 }; #endif

关键点解析：

1. 头文件保护：#ifndef、#define、#endif防止头文件被重复包含。
2. 纯虚函数：= 0的语法将函数声明为纯虚函数，使Worker成为抽象类。任何派生类都必须覆盖这些函数，否则也无法实例化。
3. 虚析构函数：这是极其重要且容易被新手忽略的一点。当通过基类指针（Worker*）删除一个派生类对象时，如果基类析构函数不是虚函数，则只会调用基类的析构函数，导致派生类独有的部分资源（如动态内存）泄漏。声明为virtual ~Worker() {}后，删除时会先调用派生类析构函数，再调用基类析构函数，确保资源完全释放。

3.2 具体职工子类的实现

以Manager类为例：manager.h

#ifndef MANAGER_H #define MANAGER_H #include "worker.h" class Manager : public Worker { public: Manager(int id, string name, double salary, double bonus); virtual void showInfo() override; virtual string getDeptName() override; virtual double calculateSalary() override; private: double m_Salary; // 固定月薪 double m_Bonus; // 绩效奖金 }; #endif

manager.cpp

#include "manager.h" Manager::Manager(int id, string name, double salary, double bonus) { this->m_Id = id; this->m_Name = name; this->m_DeptId = 2; // 部门编号固定为2，代表经理 this->m_Salary = salary; this->m_Bonus = bonus; } void Manager::showInfo() { cout << "职工编号: " << this->m_Id << " \t职工姓名: " << this->m_Name << " \t岗位: " << this->getDeptName() << " \t固定月薪: " << this->m_Salary << " \t绩效奖金: " << this->m_Bonus << " \t月总收入: " << this->calculateSalary() << endl; } string Manager::getDeptName() { return string("经理"); } double Manager::calculateSalary() { return m_Salary + m_Bonus; // 经理月薪 = 固定月薪 + 奖金 }

实现要点：

1. 构造函数初始化列表：在真正的项目中，更推荐使用成员初始化列表来初始化m_Id,m_Name等，效率更高。这里为了清晰，使用了this指针赋值。
2. override关键字（C++11）：这是一个非常好的习惯。它明确告诉编译器这个函数是重写基类的虚函数。如果拼写错误或函数签名不匹配，编译器会报错，帮助你在编译期就发现错误，而不是运行时出现意料之外的行为。
3. getDeptName()返回string：这里返回了一个临时string对象。在性能要求极高的场景下，可以考虑返回const char*或引用，但对此项目而言，清晰和安全性更重要。

Employee和Boss类的实现类似，区别在于属性和calculateSalary的逻辑。例如，Boss的calculateSalary()可能是返回m_YearSalary / 12。

3.3 核心管理类WorkerManager的实现

这是代码量最大的部分，我们拆解几个最关键的函数。

3.3.1 构造函数与析构函数

workermanager.cpp(部分)

WorkerManager::WorkerManager() { // 初始化属性 this->m_EmpNum = 0; this->m_EmpArray = NULL; this->m_FileIsEmpty = true; // 程序启动时，首先尝试从文件读取数据 ifstream ifs; ifs.open(FILENAME, ios::in); if (!ifs.is_open()) { // 文件不存在 cout << "文件不存在，即将创建新文件。" << endl; ifs.close(); return; } // 文件存在，但可能为空 char ch; ifs >> ch; if (ifs.eof()) { // 文件为空 cout << "文件为空！" << endl; this->m_FileIsEmpty = true; ifs.close(); return; } // 文件存在且有数据 this->m_FileIsEmpty = false; this->Init_Emp(); // 调用初始化函数，读取数据到内存 ifs.close(); } WorkerManager::~WorkerManager() { // 释放堆区每一个职工对象 if (this->m_EmpArray != NULL) { for (int i = 0; i < this->m_EmpNum; i++) { if (this->m_EmpArray[i] != NULL) { delete this->m_EmpArray[i]; this->m_EmpArray[i] = NULL; // 避免野指针 } } // 释放堆区数组指针 delete[] this->m_EmpArray; this->m_EmpArray = NULL; this->m_EmpNum = 0; } }

内存管理精讲：

• 构造函数：负责初始化状态并加载已有数据。注意检查文件是否为空（ifs.eof()）的逻辑，这决定了后续菜单是否显示“文件为空，请添加职工”的提示。
• 析构函数：这是体现C++程序员功底的地方。必须先释放数组中的每个对象，再释放数组本身。顺序反了会导致内存泄漏。释放每个对象后，立即将指针置为NULL是个好习惯，可以防止后续误用。最后，将数组指针和计数器归零。

3.3.2 添加职工功能 Add_Emp()

void WorkerManager::Add_Emp() { cout << "请输入需要添加的职工数量： "; int addNum = 0; cin >> addNum; if (addNum <= 0) { cout << "输入有误！" << endl; return; } // 计算新空间大小 = 原大小 + 新增大小 int newSize = this->m_EmpNum + addNum; // 开辟新空间 Worker** newSpace = new Worker*[newSize]; // 将原空间下内容，拷贝到新空间下 if (this->m_EmpArray != NULL) { for (int i = 0; i < this->m_EmpNum; i++) { newSpace[i] = this->m_EmpArray[i]; } } // 批量添加新数据 for (int i = 0; i < addNum; i++) { int id; string name; int dSelect; double salary, bonus, yearSalary; cout << "请输入第 " << i + 1 << " 个新职工编号："; cin >> id; // 这里应该添加一个判断编号是否重复的函数，此处省略... cout << "请输入第 " << i + 1 << " 个新职工姓名："; cin >> name; cout << "请选择该职工的岗位(1-普通职工, 2-经理, 3-老板)："; cin >> dSelect; Worker* worker = NULL; switch (dSelect) { case 1: cout << "请输入固定月薪："; cin >> salary; worker = new Employee(id, name, salary); break; case 2: cout << "请输入固定月薪："; cin >> salary; cout << "请输入绩效奖金："; cin >> bonus; worker = new Manager(id, name, salary, bonus); break; case 3: cout << "请输入年薪："; cin >> yearSalary; worker = new Boss(id, name, yearSalary); break; default: cout << "选择错误！" << endl; i--; // 本次输入无效，回退 continue; } // 将新创建的职工指针，存入新空间的后半部分 newSpace[this->m_EmpNum + i] = worker; } // 释放原有空间 delete[] this->m_EmpArray; // 更改新空间的指向 this->m_EmpArray = newSpace; // 更新职工人数 this->m_EmpNum = newSize; // 更新文件不为空的标志 this->m_FileIsEmpty = false; // 提示添加成功 cout << "成功添加 " << addNum << " 名新职工！" << endl; // 添加成功后，自动保存到文件 this->Save(); }

动态数组扩容详解： 这是本项目的一个核心算法。C++原生数组大小固定，我们需要手动模拟“动态数组”。

1. 计算新大小：newSize = oldSize + addNum。
2. 开辟新数组：new Worker*[newSize]。注意，这里创建的是指针数组，每个元素将来存放的是指向Worker派生类对象的指针。
3. 迁移旧数据：将旧数组中所有有效指针（m_EmpArray[i]）复制到新数组的前半部分。这里复制的是指针值（地址），对象本身还在堆区原位置，没有发生拷贝，效率很高。
4. 添加新数据：在用户交互环节，根据选择new出具体的子类对象（Employee,Manager,Boss），并将返回的指针存入新数组的后半部分。这里发生了多态的核心应用：Worker* worker = new Manager(...)。
5. 释放旧数组，指向新数组：delete[] m_EmpArray释放的是指针数组本身，而不是数组里的对象。对象由析构函数统一释放。最后更新指针和计数器。
6. 自动保存：添加完成后立即调用Save()，确保数据持久化。这是一个良好的用户体验设计。

3.3.3 保存到文件功能 Save()

void WorkerManager::Save() { ofstream ofs; ofs.open(FILENAME, ios::out | ios::trunc); // 以写入和截断模式打开 if (!ofs.is_open()) { cout << "文件保存失败！" << endl; return; } for (int i = 0; i < this->m_EmpNum; i++) { // 利用多态，获取每个职工的信息字符串（这里需要设计一个返回格式化字符串的虚函数） // 或者，更直接地，根据类型写入不同数量的字段 // 这里采用一种简单方法：先写入公共部分，再根据类型写入特有部分 ofs << this->m_EmpArray[i]->m_Id << " " << this->m_EmpArray[i]->m_Name << " " << this->m_EmpArray[i]->m_DeptId << " "; // 根据部门ID，决定如何写入薪资数据 if (this->m_EmpArray[i]->m_DeptId == 1) { // Employee Employee* emp = dynamic_cast<Employee*>(this->m_EmpArray[i]); ofs << emp->getSalary() << endl; // 假设Employee有getSalary方法 } else if (this->m_EmpArray[i]->m_DeptId == 2) { // Manager Manager* mgr = dynamic_cast<Manager*>(this->m_EmpArray[i]); ofs << mgr->getFixedSalary() << " " << mgr->getBonus() << endl; } else if (this->m_EmpArray[i]->m_DeptId == 3) { // Boss Boss* boss = dynamic_cast<Boss*>(this->m_EmpArray[i]); ofs << boss->getYearSalary() << endl; } } ofs.close(); cout << "数据已成功保存至文件！" << endl; }

文件操作与类型转换：

1. 打开模式：ios::out | ios::trunc表示写入，如果文件存在则清空内容。这符合“保存”的语义，用最新内存数据覆盖旧文件。
2. dynamic_cast：这是运行时类型识别（RTTI）的一部分。在保存时，我们知道基类指针实际指向的对象类型（通过m_DeptId判断），需要使用dynamic_cast安全地向下转型，以访问子类特有的成员函数（如getBonus()）。如果转型失败（指针不指向目标类型或其派生类），dynamic_cast会返回nullptr。这是一种“反多态”的操作，但在序列化（保存）这种需要知道确切类型的场景下是必要的。在纯粹的“使用”对象时（如showInfo），我们应避免使用dynamic_cast，以保持多态的纯粹性。

3.3.4 显示所有职工 Show_Emp()

void WorkerManager::Show_Emp() { if (this->m_FileIsEmpty) { cout << "文件不存在或记录为空！" << endl; return; } cout << "当前系统职工数量为：" << this->m_EmpNum << endl; cout << "----------------------------------------" << endl; for (int i = 0; i < this->m_EmpNum; i++) { // 多态调用：数组元素是Worker*，但实际调用的是子类重写的showInfo() this->m_EmpArray[i]->showInfo(); } cout << "----------------------------------------" << endl; }

多态的完美体现：这是整个系统最优雅的部分。m_EmpArray[i]是Worker*类型，我们直接调用showInfo()。编译器看到这是虚函数调用，会在运行时查找对象的虚函数表（vtable），从而调用到实际对象类型（Employee、Manager或Boss）的showInfo方法。WorkerManager完全不需要知道它管理的是什么具体类型的职工，它只和Worker接口打交道。这就是面向对象设计中著名的“依赖倒置原则”和“开闭原则”的简单体现。

4. 进阶优化与工业级技巧

完成基础功能后，你的代码已经可以运行了。但如果想让这个项目更扎实、更像一个“工业级”的雏形，以下几个优化点是必须考虑的。

4.1 使用智能指针管理内存

原始代码中大量使用new/delete，在复杂的逻辑分支或异常发生时，极易导致内存泄漏。现代C++（C++11及以上）强烈推荐使用智能指针。

改造方案： 将WorkerManager中的Worker** m_EmpArray;替换为std::vector<std::unique_ptr<Worker>> m_EmpArray;。

优势：

1. 自动内存管理：unique_ptr在离开作用域时会自动释放其指向的对象，你无需在析构函数中手动delete。
2. 异常安全：即使在中途抛出异常，已分配的unique_ptr也能保证被正确释放。
3. 简化代码：添加职工时，使用m_EmpArray.push_back(std::make_unique<Manager>(id, name, salary, bonus));。释放时，只需清空vector或让其自然析构。
4. 避免浅拷贝问题：unique_ptr禁止拷贝，避免了意外的指针复制导致的双重释放问题。

注意：使用vector<unique_ptr<Worker>>后，原来的动态数组扩容逻辑（new Worker*[newSize]和手动拷贝）可以完全被vector的push_back和自动扩容机制替代，代码会简洁安全得多。

4.2 输入验证与异常处理

目前的代码对用户输入几乎没有验证，这是不安全的。

需要加强的验证点：

1. 职工编号唯一性：在Add_Emp()和Mod_Emp()中，添加前应遍历现有数组，检查输入的ID是否已存在。
2. 输入类型检查：当程序期待一个整数（如ID、部门选择），用户却输入了字符串，会导致cin进入错误状态，后续所有输入都会失败。需要使用cin.clear()和cin.ignore()来清除错误状态和无效输入。
3. 文件操作异常：文件打开、读写可能失败。可以使用if (!ifs.good())或if (ofs.fail())进行检查，并给出明确提示。

示例（检查编号唯一性）：

bool WorkerManager::isIdExist(int id) { for (int i = 0; i < m_EmpNum; ++i) { if (m_EmpArray[i]->m_Id == id) { return true; } } return false; } // 在添加职工时调用 if (isIdExist(id)) { cout << "编号 " << id << " 已存在，请重新输入！" << endl; i--; // 回退本次循环 continue; }

4.3 使用STL容器替代原生数组

如前所述，使用std::vector是更好的选择。除此之外，对于需要根据ID快速查找职工的操作（如删除、修改、查找），可以使用std::map<int, Worker*>或std::unordered_map，将职工ID作为键，指针作为值。这样可以将查找时间复杂度从O(n)降低到O(log n)或平均O(1)。

权衡：map提高了查找效率，但牺牲了遍历显示时的顺序（除非使用有序map）。你需要根据最频繁的操作来决定数据结构。对于小型系统，vector足矣；如果职工数量可能很大，且查找操作频繁，map是更优解。

4.4 模块化与头文件管理

随着类增多，将所有声明和定义都放在一起会变得混乱。良好的实践是：

• 每个类一个头文件（.h）和一个源文件（.cpp）：如worker.h,worker.cpp,employee.h,employee.cpp等。
• 在头文件中使用前向声明：如果A.h只用到B类的指针或引用，可以在A.h中写class B;，而不必#include "B.h"，只在A.cpp中包含B.h。这能减少编译依赖，加快编译速度。
• 管理类WorkerManager：它的头文件需要包含所有职工子类的头文件，因为要在Add_Emp中new它们。但可以通过工厂模式来解耦，让WorkerManager只依赖Worker.h和一个“职工工厂”，由工厂来负责创建具体对象。

5. 常见问题排查与调试心得

在实际编写和教学过程中，我总结了新手最容易遇到的几个“坑”。

5.1 多态失效：虚函数表（vtable）相关问题

• 问题现象：通过基类指针调用函数，但始终执行的是基类的版本，而不是派生类的。
• 可能原因与排查：
  1. 函数没有声明为virtual：这是最常见的原因。确保基类中希望被重写的函数有virtual关键字，且派生类中函数签名完全一致（返回类型、函数名、参数列表）。使用override关键字可以帮助编译器检查。
  2. 通过对象直接调用，而非指针或引用：Worker w = Manager(...); w.showInfo();这里会发生“对象切片”，w只是一个Worker对象，丢失了Manager的部分，自然调用Worker::showInfo。多态必须通过指针或引用来实现。
  3. 构造函数/析构函数中调用虚函数：在构造函数和析构函数中，对象的类型被视为当前正在构造/析构的类，而不是最终的派生类。因此，在这里调用虚函数不会发生多态，调用的是当前类的版本。应避免这样做。

5.2 内存泄漏与双重释放

• 问题现象：程序运行一段时间后内存占用持续增长；或在退出时崩溃（特别是重复加载保存文件后）。
• 排查与解决：
  1. new/delete不配对：确保每一个new都有对应的delete。在WorkerManager的析构函数中，必须循环delete每个职工对象，再delete[]数组。
  2. 浅拷贝问题：如果自定义了拷贝构造函数或赋值运算符，并且只是简单拷贝了指针，那么两个对象会指向同一块内存，析构时会被delete两次，导致未定义行为。解决方案：遵循“三法则”（C++11后是“五法则”），需要管理资源的类，应正确定义拷贝构造、拷贝赋值、移动构造、移动赋值和析构函数。或者，更简单的方法是禁用拷贝（将函数声明为=delete）并使用智能指针。
  3. 异常导致内存泄漏：在new和delete之间如果发生异常，delete可能不会被执行。使用智能指针可以完美解决此问题。

5.3 文件读写数据错乱

• 问题现象：保存后再加载，数据显示乱码、错位或程序崩溃。
• 排查步骤：
  1. 检查文件打开模式：保存用ios::out | ios::trunc，加载用ios::in。确保文件流对象在操作前已成功打开（is_open()）。
  2. 检查数据格式一致性：保存时字段间用空格分隔，加载时也要用>>操作符按相同顺序读取。>>操作符会跳过空白字符，适合这种简单格式。
  3. 处理读取失败：在加载循环中，使用while (ifs >> id >> name >> deptId)这样的方式，将读取操作作为条件。如果读取失败（如格式错误或到文件尾），循环会自动终止，避免读取无效数据。
  4. 类型匹配：确保从文件读取的数据类型与变量类型匹配。例如，string类型的姓名不能用一个int变量去接。
  5. 手动查看文件：出问题时，第一件事是打开生成的文本文件，肉眼检查格式是否正确，数据是否完整。

5.4 控制台输入“卡住”或跳过

• 问题现象：在连续使用cin >>和getline()时，后面的getline()会直接读到空行。
• 原因与解决：cin >>读取数字或单词后，会在输入缓冲区留下换行符\n。接下来的getline()看到\n就认为读到了一行空内容。
• 解决方案：在cin >>之后、getline()之前，使用cin.ignore(numeric_limits<streamsize>::max(), '\n');来清空输入缓冲区中直到换行符的所有内容。numeric_limits<streamsize>::max()表示一个非常大的数，确保清空所有残留。

这个项目虽然不大，但它像一面镜子，能清晰地照出一个C++初学者对核心概念的理解程度。从类设计、内存管理到文件IO和多态的应用，每一个环节都值得反复琢磨。我建议你在实现基本功能后，不要就此停止。尝试用智能指针重构它，尝试加入异常处理，尝试用STL容器优化数据结构，甚至尝试为其编写简单的单元测试。这个过程遇到的每一个问题，解决的每一个bug，都会让你对C++的理解更深一层。编程没有捷径，就是这样一个项目接着一个项目，一行代码接着一行代码，积累出来的手感与经验。当你能够流畅地完成这个系统，并理解其中每一个设计抉择时，恭喜你，你的C++面向对象编程，算是真正入门了。