编辑“︁C++ 委托模式”︁（章节）

= C++委托模式 =

'''委托模式'''（Delegation Pattern）是C++中一种重要的设计模式，它允许一个对象（委托者）将某些操作或责任转发给另一个对象（委托对象）来处理。这种模式常用于实现松耦合、代码复用和动态行为配置。

== 基本概念 ==

在委托模式中：
* '''委托者'''（Delegator）：持有对委托对象的引用，并将部分工作委托给它
* '''委托对象'''（Delegate）：实际执行特定功能的对象
* '''接口'''（可选）：定义委托者与委托对象之间的契约

委托模式与继承不同——它通过'''组合'''而非'''继承'''来实现功能扩展，符合"'''优先使用对象组合而非类继承'''"的设计原则。

== 简单示例 ==

以下是一个基本的委托模式实现：

<syntaxhighlight lang="cpp">
#include <iostream>
#include <memory>

// 委托接口
class PrinterDelegate {
public:
    virtual ~PrinterDelegate() = default;
    virtual void print(const std::string& text) = 0;
};

// 具体委托类
class ConsolePrinter : public PrinterDelegate {
public:
    void print(const std::string& text) override {
        std::cout << "Console Output: " << text << std::endl;
    }
};

// 委托者类
class Printer {
private:
    std::unique_ptr<PrinterDelegate> delegate;
public:
    // 设置委托对象
    void setDelegate(std::unique_ptr<PrinterDelegate> newDelegate) {
        delegate = std::move(newDelegate);
    }
    
    // 使用委托对象
    void print(const std::string& text) {
        if (delegate) {
            delegate->print(text);
        } else {
            std::cerr << "No delegate set!" << std::endl;
        }
    }
};

int main() {
    Printer printer;
    printer.setDelegate(std::make_unique<ConsolePrinter>());
    printer.print("Hello, Delegation Pattern!");
    
    return 0;
}
</syntaxhighlight>

'''输出结果：'''
<pre>
Console Output: Hello, Delegation Pattern!
</pre>

== 委托模式的优势 ==

1. '''灵活性'''：运行时可以更换委托对象
2. '''解耦'''：委托者不需要知道委托对象的具体实现
3. '''可扩展性'''：可以轻松添加新的委托类
4. '''单一职责'''：每个类只关注自己的功能

== 高级应用：函数对象委托 ==

C++11及以后版本可以使用std::function实现更灵活的委托：

<syntaxhighlight lang="cpp">
#include <iostream>
#include <functional>

class Button {
private:
    std::function<void()> onClickHandler;
public:
    void setOnClick(std::function<void()> handler) {
        onClickHandler = handler;
    }
    
    void click() {
        if (onClickHandler) {
            onClickHandler();
        }
    }
};

int main() {
    Button btn;
    
    // 使用lambda表达式作为委托
    btn.setOnClick([]() {
        std::cout << "Button clicked!" << std::endl;
    });
    
    btn.click();
    
    return 0;
}
</syntaxhighlight>

'''输出结果：'''
<pre>
Button clicked!
</pre>

== 实际应用案例 ==

=== GUI事件处理 ===
在图形用户界面(GUI)框架中，委托模式广泛用于事件处理：

<mermaid>
classDiagram
    class Button {
        +setOnClick(handler: function)
        +click()
        -onClickHandler: function
    }
    
    class UserInterface {
        +onButtonClick()
    }
    
    Button --> UserInterface : 委托事件处理
</mermaid>

=== 插件架构 ===
委托模式可用于实现插件系统，主程序将特定功能委托给插件：

<syntaxhighlight lang="cpp">
// 插件接口
class Plugin {
public:
    virtual ~Plugin() = default;
    virtual void execute() = 0;
};

// 主程序
class Application {
private:
    std::vector<std::unique_ptr<Plugin>> plugins;
public:
    void addPlugin(std::unique_ptr<Plugin> plugin) {
        plugins.push_back(std::move(plugin));
    }
    
    void run() {
        for (auto& plugin : plugins) {
            plugin->execute();
        }
    }
};
</syntaxhighlight>

== 委托模式与观察者模式的区别 ==

虽然两者都涉及对象间的交互，但有重要区别：

{| class="wikitable"
|-
! 特性 !! 委托模式 !! 观察者模式
|-
| 关系类型 || 一对一 || 一对多
|-
| 方向性 || 单向（委托者→委托对象） || 双向（主体通知观察者）
|-
| 绑定时机 || 通常在运行时 || 通常在编译时或运行时
|-
| 使用场景 || 功能扩展、策略选择 || 事件通知、状态变化
|}

== 数学表示 ==

委托关系可以形式化表示为：

<math>
\text{Delegate}(d, x) \equiv d(x) \quad \text{其中} \quad d \in D, x \in X
</math>

其中：
* <math>D</math> 是所有可能的委托对象集合
* <math>X</math> 是输入参数空间
* <math>d(x)</math> 表示委托对象<math>d</math>处理输入<math>x</math>

== 最佳实践 ==

1. '''明确接口'''：定义清晰的委托接口
2. '''资源管理'''：使用智能指针管理委托对象生命周期
3. '''空委托检查'''：使用前检查委托对象是否有效
4. '''文档说明'''：明确记录委托的契约和预期行为
5. '''避免过度委托'''：不要将核心逻辑过度分解

== 常见陷阱 ==

* 循环委托导致无限递归
* 忘记设置委托对象导致空指针异常
* 委托链过长降低代码可读性
* 委托对象生命周期管理不当

== 总结 ==

C++委托模式是一种强大的设计技术，它通过对象组合提供了比继承更灵活的功能扩展方式。合理使用委托模式可以创建出松耦合、可维护且易于扩展的代码结构。无论是简单的策略模式实现，还是复杂的插件架构，委托模式都能提供优雅的解决方案。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 高级主题]]