【设计模式】其它经典模式-委托模式（Delegate Pattern）

委托模式（Delegate Pattern）（C++ 示例）

委托模式是一种对象组合设计模式，核心思想是将特定任务的责任转移给另一个对象（委托对象）。这种模式解除了调用者和执行者之间的耦合，增强了代码的灵活性和复用性。

核心概念

1. 委托方 (Invoker)：发起操作请求的对象
2. 委托接口 (Delegate Interface)：定义执行操作的标准接口
3. 委托对象 (Delegate)：实际执行操作的对象

---

C++ 实现方式及示例

方式 1：基于接口的委托（面向对象风格）

#include <iostream>

// 1. 定义委托接口
class IDelegate {
public:
    virtual void handleTask(const std::string& task) = 0;
    virtual ~IDelegate() = default;
};

// 2. 具体委托实现
class ConcreteDelegateA : public IDelegate {
public:
    void handleTask(const std::string& task) override {
        std::cout << "[DelegateA] Processing: " << task 
                  << " (Specialized handling)\n";
    }
};

class ConcreteDelegateB : public IDelegate {
public:
    void handleTask(const std::string& task) override {
        std::cout << "[DelegateB] Processing: " << task 
                  << " (Optimized approach)\n";
    }
};

// 3. 委托方（使用委托对象）
class TaskMaster {
    IDelegate* delegate_;  // 委托对象指针
public:
    explicit TaskMaster(IDelegate* delegate) : delegate_(delegate) {}
    
    void setDelegate(IDelegate* delegate) {
        delegate_ = delegate;
    }
    
    void executeTask(const std::string& task) {
        if(delegate_) {
            delegate_->handleTask(task);
        } else {
            std::cout << "No delegate assigned!\n";
        }
    }
};

// 使用示例
int main() {
    ConcreteDelegateA delegateA;
    ConcreteDelegateB delegateB;
    
    TaskMaster master(&delegateA);
    master.executeTask("Data Parsing"); 
    // 输出: [DelegateA] Processing: Data Parsing...
    
    master.setDelegate(&delegateB);
    master.executeTask("Image Rendering"); 
    // 输出: [DelegateB] Processing: Image Rendering...
}

方式 2：使用 std::function（函数式风格，C++11+）

#include <iostream>
#include <functional>

class TaskMaster {
    std::function<void(const std::string&)> delegate_;
public:
    void setDelegate(std::function<void(const std::string&)> delegate) {
        delegate_ = delegate;
    }
    
    void executeTask(const std::string& task) {
        if(delegate_) {
            delegate_(task);
        } else {
            std::cout << "No delegate assigned!\n";
        }
    }
};

// 使用示例
int main() {
    TaskMaster master;
    
    // 使用lambda表达式
    master.setDelegate([](const std::string& task) {
        std::cout << "[Lambda] Fast processing: " << task << "\n";
    });
    master.executeTask("Network Request"); 
    // 输出: [Lambda] Fast processing: Network Request
    
    // 使用普通函数
    auto customHandler = [](const std::string& task) {
        std::cout << "[Custom] Specialized: " << task << "\n";
    };
    master.setDelegate(customHandler);
    master.executeTask("Database Query");
    // 输出: [Custom] Specialized: Database Query
}

---

关键特点与优势

1. 解耦 (Decoupling)
   委托方无需知道具体实现细节，只需关注接口

   // 委托方代码保持稳定
   void executeTask(const std::string& task) {
       delegate_->handleTask(task); // 无需关心具体实现
   }
   

2. 运行时切换 (Runtime Switching)
   可动态更换委托对象

   master.setDelegate(&delegateB); // 运行时切换处理逻辑
   

3. 扩展性 (Extensibility)
   新增委托类型不影响现有代码

   class NewDelegate : public IDelegate {...} // 新增实现
   

4. 代码复用 (Reusability)
   相同委托可被多个委托方使用

---

适用场景

1. 需要动态切换算法或策略
2. 实现事件处理系统（如GUI事件）
3. 替代多重继承的场景
4. 实现回调机制
5. 需要隔离核心逻辑和具体实现

---

与类似模式对比

模式	区别
策略模式	侧重算法族互换
代理模式	控制原对象的访问
观察者模式	一对多的通知机制

委托模式更强调任务传递而非状态变化通知

---

最佳实践建议

1. 优先使用 std::function（C++11+）
   更灵活，支持函数对象/lambda/成员函数

   // 绑定成员函数示例
   class Worker {
   public:
       void doWork(const std::string& task) { ... }
   };
   
   Worker w;
   master.setDelegate(std::bind(&Worker::doWork, &w, std::placeholders::_1));
   

2. 管理委托对象生命周期

   • 使用智能指针避免内存泄漏

   std::shared_ptr<IDelegate> delegate = 
        std::make_shared<ConcreteDelegateA>();
   

3. 空委托处理

   void executeTask(const std::string& task) {
       if(delegate_) delegate_(task);
       else /* 默认处理或报错 */;
   }
   

4. 接口最小化原则

   // 好的委托接口
   class IExecutor {
   public:
       virtual void execute(const std::string&) = 0;
   };
   
   // 而不是
   class IBadDelegate {
   public:
       virtual void save() = 0;
       virtual void load() = 0;
       virtual void process() = 0; // 职责过多
   };
   

---

实际应用案例

GUI 事件处理

class Button {
    std::function<void()> onClick_;
public:
    void setClickHandler(std::function<void()> handler) {
        onClick_ = handler;
    }
    
    void click() {
        if(onClick_) onClick_();
    }
};

// 使用
Button loginBtn;
loginBtn.setClickHandler([] {
    std::cout << "Login logic executed\n";
    // 验证凭证等操作
});

异步任务处理

class Downloader {
    std::function<void(int)> progressDelegate_;
public:
    void setProgressHandler(std::function<void(int)> handler) {
        progressDelegate_ = handler;
    }
    
    void download() {
        for(int i=0; i<=100; i+=10) {
            // 模拟下载进度
            if(progressDelegate_) progressDelegate_(i);
        }
    }
};

// 使用
Downloader dl;
dl.setProgressHandler([](int progress) {
    std::cout << "Download progress: " << progress << "%\n";
});
dl.download();

推荐阅读

• C++专栏
• 设计模式专栏