1. 项目概述：为什么用标准C++写购物系统？

如果你在搜索引擎里搜过“C++项目”，大概率会看到一堆“学生管理系统”、“图书管理系统”的教程，千篇一律，索然无味。今天咱们来点不一样的：用标准C++，不依赖任何图形界面库，从零手搓一个购物系统。这听起来可能有点“复古”，毕竟现在做个Web商城有Spring Boot，做个桌面应用有Qt，谁还用黑乎乎的终端呢？

但恰恰是这种“复古”，才是深入理解C++核心威力的绝佳路径。这个项目不是为了做出一个能上线的电商平台，而是一个深度理解面向对象设计、数据持久化、STL容器与算法、以及程序架构的综合性沙盘。当你用std::map管理商品库存，用std::vector和算法处理订单排序，用文件流实现数据的“掉电保存”，再用纯面向对象的思想去设计用户、商品、购物车、订单这些实体时，你会发现，那些在面试八股文里死记硬背的“封装、继承、多态”、“STL原理”、“内存管理”，突然就变得鲜活、具体，并且可被掌控。

这个项目适合谁？首先是正在学习C++，苦于理论无法联系实际的同学。其次是准备面试，需要有一个能体现综合能力的项目来充实简历的求职者。最后，甚至是那些已经工作，但想回头夯实C++基础，体验“用简单工具解决复杂问题”乐趣的老手。我们将完全使用C++标准库，在VS Code或Visual Studio中配置好C++环境，一步步构建出一个功能完整、逻辑清晰、代码优雅的购物系统核心引擎。

2. 核心架构与类设计思路拆解

一个购物系统，无论前端多么花哨，其核心后端逻辑无非是围绕几个实体展开：用户(User)、商品(Product)、购物车(ShoppingCart)、订单(Order)。我们的设计将严格遵循面向对象的原则，做到高内聚、低耦合。

2.1 实体类设计：从现实到代码的映射

首先，我们需要定义系统的基石——实体类。每个类都应该职责单一，并且通过成员变量和成员函数完整地描述其状态和行为。

Product（商品类）：这是系统的核心资产。我们需要用std::string来存储商品ID、名称、描述；用double存储价格；用int存储库存数量。为了便于管理和查找，商品ID应具有唯一性。此外，一个常被忽略但至关重要的设计是：是否将商品类别设计为枚举或另一个类？这里我们可以先使用std::string简单表示，后期再重构为Category类以支持更复杂的分类树。

// Product.h #ifndef PRODUCT_H #define PRODUCT_H #include <string> class Product { private: std::string id; // 商品唯一标识，如 "P1001" std::string name; // 商品名称 std::string description; // 商品描述 double price; // 单价 int stock; // 库存数量 std::string category; // 商品类别 public: // 构造函数 Product(const std::string& id, const std::string& name, double price, int stock, const std::string& desc = "", const std::string& cat = "General"); // Getter 和 Setter std::string getId() const { return id; } std::string getName() const { return name; } double getPrice() const { return price; } int getStock() const { return stock; } void setStock(int newStock) { stock = newStock; } // 库存是关键可变属性 // 显示商品信息 void display() const; // 核心业务逻辑：减少库存 bool reduceStock(int quantity); }; #endif

User（用户类）：用户分为普通用户和管理员。这里我们可以利用继承来体现“是一个”的关系。基类User包含公共属性如用户名、密码、用户ID。派生类Customer可以拥有自己的购物车（这里我们先关联一个购物车ID），而Admin则拥有管理权限。注意，密码在存储时绝不能是明文，即使是学习项目，我们也应引入简单的哈希处理（如MD5或SHA-1，这里为简化先使用明文，但会预留接口）。

// User.h #ifndef USER_H #define USER_H #include <string> class User { protected: std::string userId; std::string username; std::string passwordHash; // 理想情况下应存储哈希值 std::string role; // "Customer" 或 "Admin" public: User(const std::string& uid, const std::string& uname, const std::string& pwd, const std::string& r); virtual ~User() = default; bool authenticate(const std::string& inputPassword) const; // 密码验证 std::string getRole() const { return role; } std::string getUsername() const { return username; } // 纯虚函数，用于多态显示用户信息 virtual void displayInfo() const = 0; }; class Customer : public User { private: std::string cartId; // 关联的购物车ID public: Customer(const std::string& uid, const std::string& uname, const std::string& pwd); void setCartId(const std::string& cid) { cartId = cid; } std::string getCartId() const { return cartId; } void displayInfo() const override; }; class Admin : public User { public: Admin(const std::string& uid, const std::string& uname, const std::string& pwd); void displayInfo() const override; // 可以添加管理员特有方法，如审核商品、查看所有订单等 }; #endif

设计心得：在初期，很多人喜欢把购物车直接作为Customer的一个成员对象。这虽然直观，但不利于数据持久化（序列化整个用户对象会包含购物车，不够灵活）。我们这里采用“关联ID”的方式，用户和购物车是松耦合的，通过ID在系统里查找。这更贴近数据库的设计思想，也为未来扩展成客户端-服务器模式打下基础。

2.2 核心管理类设计：数据管理的枢纽

实体类定义好了，谁来管理它们？我们需要一个或多个“管理器”类，它们通常采用单例模式（Singleton）或静态类的方式，作为全局的数据访问点和业务逻辑协调中心。

ProductManager（商品管理器）：这是系统的核心数据中心。我们使用std::map<std::string, Product>来存储商品，键是商品ID，值是商品对象。std::map基于红黑树实现，在按ID查找、插入、删除操作上具有O(log n)的时间复杂度，非常合适。管理器需要提供商品的增、删、改、查（CRUD）接口，以及库存更新、列表展示等功能。

// ProductManager.h #ifndef PRODUCT_MANAGER_H #define PRODUCT_MANAGER_H #include <map> #include <vector> #include <string> #include "Product.h" class ProductManager { private: std::map<std::string, Product> products; // 商品库 static ProductManager* instance; // 单例指针 ProductManager() {} // 私有构造函数 public: // 删除拷贝构造和赋值操作，确保单例唯一性 ProductManager(const ProductManager&) = delete; ProductManager& operator=(const ProductManager&) = delete; // 获取单例实例 static ProductManager* getInstance(); // 核心CRUD操作 bool addProduct(const Product& prod); bool removeProduct(const std::string& productId); Product* findProduct(const std::string& productId); // 返回指针，便于修改 std::vector<Product> getAllProducts() const; // 库存管理 bool updateStock(const std::string& productId, int delta); // 数据持久化 bool loadFromFile(const std::string& filename); bool saveToFile(const std::string& filename) const; }; #endif

Order 与 OrderManager（订单管理）：订单是购物行为的最终产物。一个Order类应包含订单ID、所属用户ID、下单时间、订单状态（枚举：待付款、待发货、已发货、已完成等）、以及最重要的——订单项列表。这里可以用std::vector<OrderItem>来存储，OrderItem是一个包含商品ID、购买数量、成交单价的结构体。OrderManager则管理所有订单，提供创建订单、查询用户订单、更新订单状态等功能。订单数据同样需要文件持久化。

ShoppingCart（购物车类）：购物车是临时存储用户购买意向的地方。它应该与用户关联（通过用户ID或购物车ID），内部使用std::map<std::string, int>来存储商品ID和对应的购买数量。它需要提供添加商品、移除商品、修改数量、清空、计算总价以及最终生成订单的方法。

2.3 数据持久化设计：让数据“记住”自己

基于文件的数据持久化是本项目的关键挑战之一。我们不能让程序关闭后所有数据清零。这里有两种主流思路：

1. 文本格式（如CSV、JSON）：可读性好，易于调试和手动修改。可以使用nlohmann/json这样的第三方库来处理JSON，但为了体现“标准C++”，我们选择自己实现简单的文本格式。
2. 二进制格式：读写速度快，文件体积小，但可读性差，版本兼容性需要仔细处理。

对于学习项目，我推荐使用一种简单的自定义文本格式。例如，存储商品时，每行代表一个商品，字段用特定分隔符（如竖线|）隔开：

P1001|iPhone 15|A powerful smartphone.|7999.99|100|Electronics P1002|Coffee Mug|A nice mug for your coffee.|29.99|500|Home

读写时，使用std::ifstream和std::ofstream配合std::getline和字符串分割函数（如std::string::find和substr）即可实现。

避坑指南：文件IO是错误的高发区。务必在每次打开文件后检查是否成功(if (!file.is_open()))。读写过程中要注意处理异常，确保即使程序崩溃，已保存的数据也是完整的。一个常见的技巧是：先写入一个临时文件，写入成功后再用std::rename替换旧文件，这可以避免在写入过程中断电导致原文件损坏。

3. 核心功能模块的详细实现

有了清晰的架构设计，我们就可以开始动手编码了。我们将分模块实现，每个模块都力求健壮、可测试。

3.1 ProductManager的实现：商品库的引擎

让我们深入ProductManager.cpp，看看单例模式和std::map如何协同工作。

// ProductManager.cpp #include "ProductManager.h" #include <fstream> #include <sstream> #include <iostream> // 初始化静态成员变量 ProductManager* ProductManager::instance = nullptr; ProductManager* ProductManager::getInstance() { if (instance == nullptr) { instance = new ProductManager(); } return instance; } bool ProductManager::addProduct(const Product& prod) { // 1. 检查ID是否已存在 auto it = products.find(prod.getId()); if (it != products.end()) { std::cerr << "错误：商品ID '" << prod.getId() << "' 已存在！" << std::endl; return false; } // 2. 插入商品 // std::map 的 insert 方法返回一个pair<iterator, bool> auto ret = products.insert({prod.getId(), prod}); return ret.second; // 插入成功返回true } Product* ProductManager::findProduct(const std::string& productId) { auto it = products.find(productId); if (it != products.end()) { return &(it->second); // 返回指向Product的指针，允许修改 } return nullptr; // 未找到返回空指针 } bool ProductManager::updateStock(const std::string& productId, int delta) { Product* pProd = findProduct(productId); if (pProd == nullptr) { std::cerr << "错误：更新库存失败，商品ID '" << productId << "' 不存在。" << std::endl; return false; } int newStock = pProd->getStock() + delta; if (newStock < 0) { std::cerr << "错误：库存不足！商品 '" << pProd->getName() << "' 当前库存为 " << pProd->getStock() << "，无法减少 " << -delta << "。" << std::endl; return false; } pProd->setStock(newStock); std::cout << "商品 '" << pProd->getName() << "' 库存更新为: " << newStock << std::endl; return true; }

文件持久化实现：

bool ProductManager::saveToFile(const std::string& filename) const { std::ofstream outFile(filename); if (!outFile.is_open()) { std::cerr << "错误：无法打开文件 '" << filename << "' 进行写入。" << std::endl; return false; } // 遍历map，将每个商品写入文件 for (const auto& pair : products) { const Product& p = pair.second; // 使用‘|’作为分隔符，注意处理字段内可能包含分隔符的情况（本例简单处理） outFile << p.getId() << "|" << p.getName() << "|" << p.getPrice() << "|" << p.getStock() << "\n"; // 简化为核心字段 } outFile.close(); return true; } bool ProductManager::loadFromFile(const std::string& filename) { std::ifstream inFile(filename); if (!inFile.is_open()) { std::cerr << "提示：数据文件 '" << filename << "' 不存在，将创建新文件。" << std::endl; return false; // 文件不存在不是错误，只是首次运行 } products.clear(); // 加载前清空现有数据 std::string line; while (std::getline(inFile, line)) { std::istringstream iss(line); std::string id, name, priceStr, stockStr; // 使用getline配合分隔符进行分割 if (std::getline(iss, id, '|') && std::getline(iss, name, '|') && std::getline(iss, priceStr, '|') && std::getline(iss, stockStr)) { try { double price = std::stod(priceStr); int stock = std::stoi(stockStr); Product prod(id, name, price, stock); products[id] = prod; // 使用下标操作符直接插入或覆盖 } catch (const std::invalid_argument& e) { std::cerr << "警告：解析行 '" << line << "' 时遇到无效数据，已跳过。" << std::endl; continue; } } } inFile.close(); std::cout << "从文件加载了 " << products.size() << " 个商品。" << std::endl; return true; }

实操心得：在loadFromFile中，我使用了std::istringstream和std::getline来分割字符串，这是一种比手动查找find更清晰的方式。异常处理std::stod和std::stoi的转换至关重要，它能防止格式错误的文件内容导致整个程序崩溃。此外，在保存和加载的格式上必须严格一致，一个更好的做法是在文件首行加入一个版本号，便于未来格式升级时做兼容性判断。

3.2 购物车与订单的联动实现

购物车是临时状态，而订单是永久记录。它们的交互是业务逻辑的核心。

ShoppingCart的关键方法：

// ShoppingCart.h 片段 class ShoppingCart { private: std::string cartId; std::string userId; std::map<std::string, int> items; // productId -> quantity public: // 添加商品到购物车 bool addItem(const std::string& productId, int quantity, ProductManager* pm) { Product* prod = pm->findProduct(productId); if (!prod) { std::cout << "商品不存在！" << std::endl; return false; } if (prod->getStock() < quantity) { std::cout << "商品库存不足！" << std::endl; return false; } items[productId] += quantity; // 如果已存在，则增加数量 std::cout << "已添加 " << quantity << " 件 '" << prod->getName() << "' 到购物车。" << std::endl; return true; } // 生成订单 Order checkout(const std::string& orderId, ProductManager* pm) { std::vector<OrderItem> orderItems; double totalAmount = 0.0; for (const auto& pair : items) { const std::string& pid = pair.first; int qty = pair.second; Product* prod = pm->findProduct(pid); if (prod && prod->reduceStock(qty)) { // 尝试扣减库存 OrderItem item{pid, prod->getName(), qty, prod->getPrice()}; orderItems.push_back(item); totalAmount += item.unitPrice * qty; } else { // 库存扣减失败，生成订单失败或部分失败，需要回滚（简化处理，这里抛出异常或返回空订单） std::cerr << "生成订单失败，商品 '" << pid << "' 库存不足或不存在。" << std::endl; // 实际项目中应进行事务回滚 return Order(); // 返回一个无效订单 } } // 所有库存扣减成功，创建订单 Order newOrder(orderId, this->userId, orderItems, totalAmount); this->clear(); // 清空购物车 return newOrder; } };

Order类的设计：

// Order.h #ifndef ORDER_H #define ORDER_H #include <string> #include <vector> #include <chrono> struct OrderItem { std::string productId; std::string productName; int quantity; double unitPrice; double getSubTotal() const { return quantity * unitPrice; } }; enum class OrderStatus { PENDING, PAID, SHIPPED, DELIVERED, CANCELLED }; class Order { private: std::string orderId; std::string userId; std::chrono::system_clock::time_point createTime; OrderStatus status; std::vector<OrderItem> items; double totalAmount; public: Order(const std::string& oid, const std::string& uid, const std::vector<OrderItem>& its, double total); void displayOrderDetails() const; bool updateStatus(OrderStatus newStatus); // ... 其他getter方法 }; #endif

关键逻辑解析：checkout方法是整个购物流程的事务核心。它必须保证原子性：要么所有商品的库存扣减都成功，然后生成订单、清空购物车；要么有任何一步失败，整个操作回滚，库存状态不变。我们上面的简化实现中，如果中间失败，会打印错误并返回一个无效订单，但之前成功扣减的库存并没有回滚。在一个严谨的系统里，这需要引入更复杂的事务机制，例如先将库存预扣（锁定），全部成功后再实际扣减。作为学习项目，我们至少要有这个意识，并在代码注释中明确指出这里的简化处理。

3.3 用户界面与主程序循环

尽管是控制台程序，一个清晰的用户界面依然重要。我们可以设计一个简单的菜单驱动界面。

// main.cpp 主循环框架 #include <iostream> #include <limits> #include "ProductManager.h" #include "UserManager.h" // 假设有一个管理用户的UserManager #include "ShoppingCart.h" void displayMainMenu() { std::cout << "\n===== 购物系统主菜单 =====\n"; std::cout << "1. 浏览商品\n"; std::cout << "2. 搜索商品\n"; std::cout << "3. 登录/注册\n"; std::cout << "4. 查看购物车\n"; std::cout << "5. 查看我的订单\n"; std::cout << "6. 管理员入口\n"; std::cout << "0. 退出系统\n"; std::cout << "请选择操作: "; } void handleCustomerMenu(User* currentUser) { // 根据当前用户显示客户菜单 int choice; ShoppingCart* cart = getCartForUser(currentUser->getUserId()); // 获取用户购物车 do { // ... 显示客户菜单选项 std::cin >> choice; switch(choice) { case 1: browseProducts(); break; case 2: addToCart(cart); break; // 需要商品ID和数量 case 3: cart->viewCart(); break; case 4: checkout(cart); break; // 生成订单 // ... } } while(choice != 0); } int main() { // 初始化管理器，加载数据 ProductManager* pm = ProductManager::getInstance(); pm->loadFromFile("products.dat"); UserManager* um = UserManager::getInstance(); um->loadFromFile("users.dat"); int mainChoice; User* currentUser = nullptr; do { displayMainMenu(); while(!(std::cin >> mainChoice)) { // 处理非数字输入 std::cin.clear(); std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); std::cout << "输入无效，请重新输入数字: "; } switch(mainChoice) { case 1: pm->displayAllProducts(); break; case 3: currentUser = loginOrRegister(um); break; case 0: std::cout << "感谢使用，正在保存数据...\n"; pm->saveToFile("products.dat"); um->saveToFile("users.dat"); break; default: if (currentUser) { // 根据用户角色跳转到不同菜单 if (currentUser->getRole() == "Customer") { handleCustomerMenu(currentUser); } else if (currentUser->getRole() == "Admin") { handleAdminMenu(currentUser); } } else { std::cout << "请先登录！\n"; } } } while(mainChoice != 0); // 清理单例实例（可选，程序结束OS会回收） delete ProductManager::getInstance(); delete UserManager::getInstance(); return 0; }

界面设计技巧：控制台程序要注重用户体验。每次显示菜单后清屏（system("cls")或system("clear")）可以让界面更清爽，但要注意跨平台兼容性。更重要的是健壮的输入处理。上面的代码片段中，while(!(std::cin >> mainChoice))用于处理用户输入字母等非数字情况，防止程序进入死循环。这是一个非常实用的小技巧。

4. 高级特性与优化探索

当基础功能实现后，我们可以引入一些更高级的C++特性和设计模式，让项目代码质量再上一个台阶。

4.1 使用智能指针管理资源

在我们的管理器中，目前存储的是对象副本（如std::map<std::string, Product>）。如果Product对象很大，或者我们希望在多处共享同一商品对象（例如，购物车项和订单项都引用同一个商品），使用原始指针或裸对象拷贝就不太合适，容易引发内存管理问题。

我们可以使用std::shared_ptr<Product>来管理商品对象。这样，ProductManager持有商品的所有权，购物车和订单只需持有std::weak_ptr<Product>或std::shared_ptr<Product>的引用即可，无需担心对象生命周期。

// 修改后的ProductManager class ProductManager { private: std::map<std::string, std::shared_ptr<Product>> products; // ... public: std::shared_ptr<Product> findProduct(const std::string& productId) { auto it = products.find(productId); return (it != products.end()) ? it->second : nullptr; } }; // 在ShoppingCart中 class ShoppingCart { private: std::map<std::string, std::pair<std::weak_ptr<Product>, int>> items; // weak_ptr避免循环引用 // 添加商品时 bool addItem(const std::string& productId, int quantity, ProductManager* pm) { std::shared_ptr<Product> prod = pm->findProduct(productId); if (!prod) return false; // 使用weak_ptr存储，不影响Product的引用计数 items[productId] = std::make_pair(std::weak_ptr<Product>(prod), quantity); return true; } };

4.2 引入工厂模式创建对象

当对象创建逻辑比较复杂，或者我们希望根据不同的条件创建不同的派生类对象时，工厂模式非常有用。例如，在我们的文件加载过程中，读取一行数据后，需要根据字段数量或类型标识来创建不同的对象（虽然目前只有Product，但未来可能有DigitalProduct,PhysicalProduct等）。

// ProductFactory.h class ProductFactory { public: static std::unique_ptr<Product> createProduct(const std::string& type, const std::string& id, const std::string& name, double price, int stock) { if (type == "General") { return std::make_unique<Product>(id, name, price, stock); } // else if (type == "Digital") { ... } else { return nullptr; } } }; // 在ProductManager::loadFromFile中 // 解析出type字段后 std::unique_ptr<Product> prod = ProductFactory::createProduct(type, id, name, price, stock); if (prod) { products[id] = std::move(prod); // 存入shared_ptr的map可能需要转换 }

4.3 利用STL算法提升代码表现力

C++标准库的<algorithm>头文件提供了强大的工具。例如，在实现商品搜索功能时，我们不再需要手写循环。

// 在ProductManager中实现按名称搜索 std::vector<std::shared_ptr<Product>> ProductManager::searchProductsByName(const std::string& keyword) const { std::vector<std::shared_ptr<Product>> results; // 使用std::copy_if算法 std::copy_if(products.begin(), products.end(), std::back_inserter(results), [&keyword](const auto& pair) { const auto& prod = pair.second; // 大小写不敏感搜索（简单示例，实际可用std::transform） std::string lowerName = prod->getName(); std::string lowerKeyword = keyword; std::transform(lowerName.begin(), lowerName.end(), lowerName.begin(), ::tolower); std::transform(lowerKeyword.begin(), lowerKeyword.end(), lowerKeyword.begin(), ::tolower); return lowerName.find(lowerKeyword) != std::string::npos; }); return results; } // 对商品按价格排序 std::vector<std::shared_ptr<Product>> ProductManager::getProductsSortedByPrice(bool ascending) const { std::vector<std::shared_ptr<Product>> sortedList; for (const auto& pair : products) { sortedList.push_back(pair.second); } std::sort(sortedList.begin(), sortedList.end(), [ascending](const std::shared_ptr<Product>& a, const std::shared_ptr<Product>& b) { return ascending ? (a->getPrice() < b->getPrice()) : (a->getPrice() > b->getPrice()); }); return sortedList; }

性能与设计权衡：使用std::copy_if和std::sort配合Lambda表达式，代码非常简洁且意图明确。但需要注意，每次搜索或排序都创建了一个新的vector并复制了shared_ptr，这会有一定的开销。如果商品数量巨大（比如超过10万），频繁操作可能需要考虑更高效的数据结构（如维护一个按价格排序的std::multimap视图）或索引。但对于学习项目和小规模数据，这种清晰性优先的做法是完全可接受的。

5. 项目构建、调试与常见问题排查

5.1 使用CMake管理项目

为了让项目结构更清晰，并且便于在不同平台和编译器下构建，强烈建议使用CMake。

# CMakeLists.txt cmake_minimum_required(VERSION 3.10) project(ShoppingSystem VERSION 1.0 LANGUAGES CXX) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) # 包含头文件目录 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include) # 添加可执行文件 add_executable(ShoppingSystem src/main.cpp src/Product.cpp src/ProductManager.cpp src/User.cpp src/Customer.cpp src/Admin.cpp src/UserManager.cpp src/ShoppingCart.cpp src/Order.cpp src/OrderManager.cpp ) # 如果使用到了线程库等，可以在这里链接 # target_link_libraries(ShoppingSystem Threads::Threads)

将头文件放在include/目录，源文件放在src/目录，然后在项目根目录执行：

mkdir build && cd build cmake .. make

即可生成可执行文件。

5.2 VS Code配置C++开发环境

对于使用VS Code的同学，确保安装了C/C++扩展（ms-vscode.cpptools）。然后配置tasks.json用于构建，launch.json用于调试。

.vscode/tasks.json示例（用于调用CMake和Make）：

{ "version": "2.0.0", "tasks": [ { "label": "build with cmake", "type": "shell", "command": "cd ${workspaceFolder}/build && cmake .. && make", "group": { "kind": "build", "isDefault": true }, "problemMatcher": ["$gcc"] } ] }

.vscode/launch.json示例：

{ "version": "0.2.0", "configurations": [ { "name": "(gdb) Launch", "type": "cppdbg", "request": "launch", "program": "${workspaceFolder}/build/ShoppingSystem", "args": [], "stopAtEntry": false, "cwd": "${workspaceFolder}", "environment": [], "externalConsole": false, "MIMode": "gdb", "setupCommands": [ { "description": "Enable pretty-printing for gdb", "text": "-enable-pretty-printing", "ignoreFailures": true } ], "preLaunchTask": "build with cmake" } ] }

5.3 常见编译与运行时问题排查表

在开发过程中，你几乎一定会遇到下面这些问题。这里提供一个速查表：

5.4 内存泄漏检查

即使使用了智能指针，错误的循环引用（两个shared_ptr互相指向）也会导致内存泄漏。可以使用工具如Valgrind（Linux/Mac）或Visual Studio的内存诊断工具来检查。

在代码中，要特别注意：

• 优先使用std::unique_ptr表达独占所有权。
• 当需要共享所有权时再用std::shared_ptr。
• 可能存在循环引用时，将其中一个指针改为std::weak_ptr。
• 对于观察者，使用原始指针或std::weak_ptr，而不是std::shared_ptr。

6. 项目扩展方向与个人心得

完成基础版本后，这个购物系统可以作为一个强大的试验场，尝试更多有趣的方向：

1. 引入数据库：将文件持久化替换为SQLite或MySQL。学习使用C++的数据库接口（如SQLiteCpp、mysql-connector-c++）。
2. 网络通信：将系统改造成客户端-服务器模式。服务器端管理所有数据，客户端通过网络Socket（如Boost.Asio或原生Socket）发送请求。这是理解网络编程的绝佳练习。
3. 设计模式实践：除了工厂模式，还可以引入观察者模式（当商品价格变化时通知关注该商品的用户）、策略模式（支持不同的折扣计算策略，如满减、打折、优惠券）、命令模式（将用户操作封装成命令对象，支持撤销/重做）等。
4. 单元测试：使用Google Test或Catch2为你的核心类（如ProductManager、ShoppingCart::checkout）编写单元测试，保证代码质量。
5. 图形界面：使用Qt或ImGUI为你的系统加上一个图形前端，理解MVC（模型-视图-控制器）架构如何将业务逻辑与界面分离。

我个人在实现这个项目中最深的体会是：设计优于编码。在动手写第一行代码之前，花足够的时间在纸上或绘图工具上梳理类之间的关系、数据的流动、异常的处理，远比后期重构要高效得多。另一个教训是关于错误处理的，最初我很多函数只是简单地返回bool，后来发现根本不知道失败的具体原因。于是逐步改为返回包含错误码和信息的Result对象，或者至少提供日志输出，这对调试和用户体验至关重要。

最后，不要追求一次完美。先从最简单的版本开始，让它能跑起来（比如只有商品浏览和添加到购物车），然后像搭积木一样，一个一个功能地迭代添加（用户登录、订单生成、文件保存……）。每完成一个阶段，就编译测试一次。这种小步快跑的方式，能给你持续的正向反馈，也是应对复杂软件项目最有效的方法。这个用标准C++打造的购物系统，就像一把瑞士军刀，看似简单，但每实现一个功能，都让你对C++这门语言的理解更深一分。