C++ 设计模式《投诉升级！从甜妹客服到校长热线》-CSDN博客

👨‍🎓 模式名称：责任链模式（CoR）

👦 故事背景：

小明的平台用户越来越多，也带来了各种奇奇怪怪的投诉：

“奶茶太甜了！😡”
“快递小哥太帅了，影响学习！🤦‍♀️”
“代办写的情书太动人，女朋友哭了😭”

以前，小明的做法是这样的👇：

#include <iostream>
#include <string>

class Complaint {
public:
    std::string type;
    Complaint(const std::string& t) : type(t) {}
};

void handleComplaint(const Complaint& c) {
    if (c.type == "service") {
        std::cout << "客服甜妹处理：安抚用户情绪～🥰" << std::endl;
    }
    else if (c.type == "delivery") {
        std::cout << "配送主管处理：教育骑手注意形象🚴‍♂️" << std::endl;
    }
    else if (c.type == "serious") {
        std::cout << "上报校长热线📞，请亲自协调！" << std::endl;
    }
    else {
        std::cout << "未知投诉类型，没人管！🤷‍♂️" << std::endl;
    }
}

int main() {
    Complaint c1("service");
    Complaint c2("serious");
    Complaint c3("unknown");

    handleComplaint(c1);
    handleComplaint(c2);
    handleComplaint(c3);
}

🔻 问题：

1、全是 if…else if…else，难维护。

2、新增一种投诉要改 handleComplaint()。

3、没法灵活决定“谁能处理，谁往后传”。

✅ 使用职责链模式的改进版

我们将“客服甜妹”、“配送主管”、“校长”都设计成独立的处理者（Handler），
他们会根据自己的职责判断是否处理，否则传给下一个。

#include <iostream>
#include <memory>
#include <string>

// 请求对象
class Complaint {
public:
    std::string type;
    Complaint(const std::string& t) : type(t) {}
};

// 抽象处理者
class Handler {
protected:
    std::shared_ptr<Handler> next;
public:
    void setNext(std::shared_ptr<Handler> n) { next = n; }
    virtual void handle(const Complaint& c) {
        if (next) next->handle(c);
        else std::cout << "😢 没人处理这个投诉：" << c.type << std::endl;
    }
    virtual ~Handler() = default;
};

// 具体处理者 1：客服甜妹
class ServiceGirlHandler : public Handler {
public:
    void handle(const Complaint& c) override {
        if (c.type == "service") {
            std::cout << "甜妹客服处理完毕：已安抚用户情绪～🥰" << std::endl;
            // ✅ 甜妹处理后不再传递
        } else {
            std::cout << "甜妹客服：这不归我管，转交主管➡️" << std::endl;
            Handler::handle(c);
        }
    }
};

// 具体处理者 2：配送主管
class DeliveryManagerHandler : public Handler {
public:
    void handle(const Complaint& c) override {
        if (c.type == "delivery") {
            std::cout << "配送主管处理完毕：教育骑手注意形象🚴‍♂️" << std::endl;
            // ✅ 已处理，链路终止
        } else {
            std::cout << "配送主管：这事我也管不了，交校长吧📞" << std::endl;
            Handler::handle(c);
        }
    }
};

// 具体处理者 3：校长热线
class PrincipalHandler : public Handler {
public:
    void handle(const Complaint& c) override {
        if (c.type == "serious") {
            std::cout << "校长亲自处理：组织调查会议🧑‍⚖️" << std::endl;
            // ✅ 终止传递
        } else {
            std::cout << "校长：这点小事不用我来管😅" << std::endl;
        }
    }
};

// 测试
int main() {
    auto sweetGirl = std::make_shared<ServiceGirlHandler>();
    auto manager = std::make_shared<DeliveryManagerHandler>();
    auto principal = std::make_shared<PrincipalHandler>();

    sweetGirl->setNext(manager);
    manager->setNext(principal);

    Complaint c1("service");
    Complaint c2("delivery");
    Complaint c3("serious");
    Complaint c4("unknown");

    std::cout << "—— 投诉 1 ——" << std::endl;
    sweetGirl->handle(c1);

    std::cout << "\n—— 投诉 2 ——" << std::endl;
    sweetGirl->handle(c2);

    std::cout << "\n—— 投诉 3 ——" << std::endl;
    sweetGirl->handle(c3);

    std::cout << "\n—— 投诉 4 ——" << std::endl;
    sweetGirl->handle(c4);
}

🧩 输出结果

—— 投诉 1 ——
甜妹客服处理完毕：已安抚用户情绪～🥰

—— 投诉 2 ——
甜妹客服：这不归我管，转交主管➡️
配送主管处理完毕：教育骑手注意形象🚴‍♂️

—— 投诉 3 ——
甜妹客服：这不归我管，转交主管➡️
配送主管：这事我也管不了，交校长吧📞
校长亲自处理：组织调查会议🧑‍⚖️

—— 投诉 4 ——
甜妹客服：这不归我管，转交主管➡️
配送主管：这事我也管不了，交校长吧📞
校长：这点小事不用我来管😅

💡 职责链的关键优势

特点	说明
🔗 解耦请求与处理者	发送方（投诉）不关心谁处理，只管发出
🧱 可扩展性强	新增处理者（如“风纪委员会”）只需接入链尾
🛑 灵活中断	任一处理者可以决定终止传递，提高效率
🧩 动态组合	链的结构可在运行时调整，不固定流程