C++设计模式代码重构实录:将混乱代码变为艺术品

如果你的目标是把技术水平拉起来，也想在简历上增加一些真正能说得出口的内容，可以趁这段时间做几个C++ 实战项目。既能把底层功底练扎实，也能让春招、考研复试、社招面试里遇到的技术问题更从容，有需要的朋友可以移步文末查看训练营相关介绍。

原始代码展示

#include<iostream>
#include<string>
#include<vector>
#include<fstream>

usingnamespacestd;

voidprocessOrder(conststring& orderId, constvector<string>& items){
// 验证订单
if (orderId.empty()) {
cout << "订单ID不能为空" << endl;
return;
    }

// 计算总价
double totalPrice = 0.0;
for (constauto& item : items) {
if (item == "book") {
            totalPrice += 50.0;
        } elseif (item == "pen") {
            totalPrice += 10.0;
        } elseif (item == "notebook") {
            totalPrice += 20.0;
        }
    }

// 生成订单文件
ofstream orderFile("order_" + orderId + ".txt");
if (orderFile.is_open()) {
        orderFile << "订单ID: " << orderId << endl;
        orderFile << "商品列表: ";
for (constauto& item : items) {
            orderFile << item << " ";
        }
        orderFile << endl;
        orderFile << "总价: " << totalPrice << endl;
        orderFile.close();
cout << "订单文件生成成功" << endl;
    } else {
cout << "无法创建订单文件" << endl;
    }

// 发送通知
cout << "订单已处理，通知客户" << endl;
}

intmain(){
vector<string> items = {"book", "pen", "notebook"};
    processOrder("20260203001", items);
return 0;
}

问题分析

这段代码存在以下主要问题：

1. 单一职责原则违反：processOrder函数承担了验证订单、计算总价、生成文件和发送通知等多个职责，导致函数过于庞大复杂。

2. 紧耦合：函数内部直接依赖于具体的商品定价逻辑和文件操作方式，难以进行单元测试和扩展。

3. 可扩展性差：当新增商品类型时，需要修改processOrder函数中的条件判断，违反了开闭原则。

4. 代码重复：如果系统中存在多个类似的订单处理逻辑，会导致大量重复代码。

5. 错误处理不完善：函数中的错误处理比较简单，缺乏统一的错误处理机制。

重构方案设计

设计思路

针对上述问题，我们将采用以下重构策略：

1. 单一职责原则：将订单处理的不同职责拆分到不同的类中。
2. 策略模式：将商品定价逻辑封装到策略类中，实现运行时切换。
3. 工厂模式：根据不同的订单类型创建不同的订单处理器。
4. 观察者模式：实现订单处理完成后的通知机制。

重构阶段规划

1. 第一阶段：职责拆分，将订单处理的不同功能拆分到不同的类中。
2. 第二阶段：应用策略模式，将商品定价逻辑抽象为策略接口。
3. 第三阶段：应用工厂模式，实现订单处理器的动态创建。
4. 第四阶段：应用观察者模式，实现订单处理完成后的通知机制。
5. 第五阶段：代码优化与测试，确保重构后的代码功能正确且性能良好。

重构实施

第一阶段：职责拆分

将订单处理的不同职责拆分到不同的类中：

// 订单验证器
classOrderValidator {
public:
boolvalidate(conststring& orderId){
if (orderId.empty()) {
cout << "订单ID不能为空" << endl;
returnfalse;
        }
returntrue;
    }
};

// 价格计算器
classPriceCalculator {
public:
doublecalculate(constvector<string>& items){
double totalPrice = 0.0;
for (constauto& item : items) {
if (item == "book") {
                totalPrice += 50.0;
            } elseif (item == "pen") {
                totalPrice += 10.0;
            } elseif (item == "notebook") {
                totalPrice += 20.0;
            }
        }
return totalPrice;
    }
};

// 订单文件生成器
classOrderFileGenerator {
public:
boolgenerate(conststring& orderId, constvector<string>& items, double totalPrice){
ofstream orderFile("order_" + orderId + ".txt");
if (orderFile.is_open()) {
            orderFile << "订单ID: " << orderId << endl;
            orderFile << "商品列表: ";
for (constauto& item : items) {
                orderFile << item << " ";
            }
            orderFile << endl;
            orderFile << "总价: " << totalPrice << endl;
            orderFile.close();
cout << "订单文件生成成功" << endl;
return true;
        } else {
cout << "无法创建订单文件" << endl;
return false;
        }
    }
};

// 通知发送器
classNotificationSender {
public:
voidsend(conststring& orderId){
cout << "订单" << orderId << "已处理，通知客户" << endl;
    }
};

// 订单处理器
classOrderProcessor {
private:
    OrderValidator validator;
    PriceCalculator calculator;
    OrderFileGenerator fileGenerator;
    NotificationSender sender;

public:
voidprocess(conststring& orderId, constvector<string>& items){
if (!validator.validate(orderId)) {
return;
        }

double totalPrice = calculator.calculate(items);

if (!fileGenerator.generate(orderId, items, totalPrice)) {
return;
        }

        sender.send(orderId);
    }
};

intmain(){
vector<string> items = {"book", "pen", "notebook"};
    OrderProcessor processor;
    processor.process("20260203001", items);
return 0;
}

重构效果：将原来的单一函数拆分为多个类，每个类只负责一个职责，符合单一职责原则，提高了代码的可读性和可维护性。

第二阶段：应用策略模式

将商品定价逻辑抽象为策略接口，实现运行时切换：

// 定价策略接口
classPricingStrategy {
public:
virtualdoublecalculatePrice(conststring& item)= 0;
virtual ~PricingStrategy() = default;
};

// 图书定价策略
classBookPricingStrategy :public PricingStrategy {
public:
doublecalculatePrice(conststring& item)override{
return 50.0;
    }
};

// 笔定价策略
classPenPricingStrategy :public PricingStrategy {
public:
doublecalculatePrice(conststring& item)override{
return 10.0;
    }
};

// 笔记本定价策略
classNotebookPricingStrategy :public PricingStrategy {
public:
doublecalculatePrice(conststring& item)override{
return 20.0;
    }
};

// 价格计算器
classPriceCalculator {
private:
map<string, unique_ptr<PricingStrategy>> strategies;

public:
    PriceCalculator() {
        strategies["book"] = make_unique<BookPricingStrategy>();
        strategies["pen"] = make_unique<PenPricingStrategy>();
        strategies["notebook"] = make_unique<NotebookPricingStrategy>();
    }

doublecalculate(constvector<string>& items){
double totalPrice = 0.0;
for (constauto& item : items) {
if (strategies.find(item) != strategies.end()) {
                totalPrice += strategies[item]->calculatePrice(item);
            }
        }
return totalPrice;
    }
};

重构效果：将商品定价逻辑封装到策略类中，当新增商品类型时，只需新增对应的策略类，无需修改价格计算器的代码，符合开闭原则，提高了代码的可扩展性。

第三阶段：应用工厂模式

实现订单处理器的动态创建：

// 订单处理器接口
classOrderProcessor {
public:
virtualvoidprocess(conststring& orderId, constvector<string>& items)= 0;
virtual ~OrderProcessor() = default;
};

// 普通订单处理器
classNormalOrderProcessor :public OrderProcessor {
private:
    OrderValidator validator;
    PriceCalculator calculator;
    OrderFileGenerator fileGenerator;
    NotificationSender sender;

public:
voidprocess(conststring& orderId, constvector<string>& items)override{
if (!validator.validate(orderId)) {
return;
        }

double totalPrice = calculator.calculate(items);

if (!fileGenerator.generate(orderId, items, totalPrice)) {
return;
        }

        sender.send(orderId);
    }
};

// 加急订单处理器
classExpressOrderProcessor :public OrderProcessor {
private:
    OrderValidator validator;
    PriceCalculator calculator;
    OrderFileGenerator fileGenerator;
    NotificationSender sender;

public:
voidprocess(conststring& orderId, constvector<string>& items)override{
if (!validator.validate(orderId)) {
return;
        }

double totalPrice = calculator.calculate(items) * 1.2; // 加急订单加价20%

if (!fileGenerator.generate(orderId, items, totalPrice)) {
return;
        }

        sender.send(orderId + " (加急)");
    }
};

// 订单处理器工厂
classOrderProcessorFactory {
public:
staticunique_ptr<OrderProcessor> createProcessor(conststring& orderType){
if (orderType == "normal") {
return make_unique<NormalOrderProcessor>();
        } elseif (orderType == "express") {
return make_unique<ExpressOrderProcessor>();
        }
return nullptr;
    }
};

intmain(){
vector<string> items = {"book", "pen", "notebook"};

// 创建普通订单处理器
auto normalProcessor = OrderProcessorFactory::createProcessor("normal");
if (normalProcessor) {
        normalProcessor->process("20260203001", items);
    }

// 创建加急订单处理器
auto expressProcessor = OrderProcessorFactory::createProcessor("express");
if (expressProcessor) {
        expressProcessor->process("20260203002", items);
    }

return 0;
}

重构效果：通过工厂模式实现了订单处理器的动态创建，客户端代码无需知道具体的处理器实现类，只需通过工厂类获取处理器实例，降低了客户端与具体实现的耦合度，提高了代码的可扩展性。

第四阶段：应用观察者模式

实现订单处理完成后的通知机制：

// 观察者接口
classOrderObserver {
public:
virtualvoidonOrderProcessed(conststring& orderId)= 0;
virtual ~OrderObserver() = default;
};

// 邮件通知观察者
classEmailNotificationObserver :public OrderObserver {
public:
voidonOrderProcessed(conststring& orderId)override{
cout << "发送邮件通知：订单" << orderId << "已处理" << endl;
    }
};

// 短信通知观察者
classSMSNotificationObserver :public OrderObserver {
public:
voidonOrderProcessed(conststring& orderId)override{
cout << "发送短信通知：订单" << orderId << "已处理" << endl;
    }
};

// 订单处理器接口
classOrderProcessor {
public:
virtualvoidprocess(conststring& orderId, constvector<string>& items)= 0;
virtualvoidaddObserver(unique_ptr<OrderObserver> observer)= 0;
virtual ~OrderProcessor() = default;
};

// 普通订单处理器
classNormalOrderProcessor :public OrderProcessor {
private:
    OrderValidator validator;
    PriceCalculator calculator;
    OrderFileGenerator fileGenerator;
vector<unique_ptr<OrderObserver>> observers;

public:
voidprocess(conststring& orderId, constvector<string>& items)override{
if (!validator.validate(orderId)) {
return;
        }

double totalPrice = calculator.calculate(items);

if (!fileGenerator.generate(orderId, items, totalPrice)) {
return;
        }

// 通知所有观察者
for (constauto& observer : observers) {
            observer->onOrderProcessed(orderId);
        }
    }

voidaddObserver(unique_ptr<OrderObserver> observer)override{
        observers.push_back(move(observer));
    }
};

intmain(){
vector<string> items = {"book", "pen", "notebook"};

// 创建普通订单处理器
auto normalProcessor = OrderProcessorFactory::createProcessor("normal");
if (normalProcessor) {
// 添加观察者
        normalProcessor->addObserver(make_unique<EmailNotificationObserver>());
        normalProcessor->addObserver(make_unique<SMSNotificationObserver>());

        normalProcessor->process("20260203001", items);
    }

return 0;
}

重构效果：通过观察者模式实现了订单处理完成后的通知机制，当新增通知方式时，只需新增对应的观察者类，无需修改订单处理器的代码，符合开闭原则，提高了代码的可扩展性。

C++ 校招 / 社招跳槽逆袭！从0到1打造高含金量项目，导师1v1辅导，助你斩获大厂offer！

很多同学准备校招时最焦虑的问题就是：“简历没项目，怎么打动面试官？”

为了解决这个痛点，我们推出了 C++项目实战训练营

在这里，你可以：

• 系统学习 C++ 进阶知识
• 自选项目，从 0 到 1 实战造轮子
• 导师一对一指导，代码逐行 Review
• 拿到能写进简历的项目成果，秋招直接加分！

我们不只是教你写代码，更带你走一遍完整的项目流程： 从需求分析、架构设计、编译调试，到版本管理、测试发布，全流程掌握！

项目配套资料齐全，遇到问题还有导师帮你答疑，不怕卡壳！

📌 想了解具体项目可以看这篇：新上线了几个好项目或直接添加vx（cppmiao24）了解详情～

项目准备好了，你只差一次出发。

相信我，这些项目绝对能够让你进步巨大！下面是其中某三个项目的说明文档

训练营适用人群：

• 备战春招和秋招的应届生，科班非科班均可，
• 工作 3 年以内，想跳槽的社招同学
• 如果你有以下困扰，欢迎联系我们，我们愿意为你提供帮助和支持
• 不知道该复习哪些内容，如何开始复习。
• 对面试考察重点不清楚，复习效率低下。
• 缺乏有含金量的实战项目经验。
• 想要提升自己的实战能力，提升做项目及解决问题的能力
• 对算法题无从下手，缺乏解题思路和常见解题模板。
• 自控力不足，难以专注于系统复习。
• 希望获得大厂的内推机会。
• 独自备战校招社招感到孤单，想要找到学习伙伴。

不适合人群：

• 缺乏耐心和毅力，急于求成的人
• 对编程逻辑思维基础薄弱，且不愿努力提升的人
• 只想快速获得成果而不注重基础学习的人