编辑“︁C++ 适配器模式实现”︁

{{DISPLAYTITLE:C++适配器模式实现}}  
'''适配器模式'''（Adapter Pattern）是[[设计模式]]中的一种结构型模式，用于解决接口不兼容的问题。该模式通过将一个类的接口转换成客户端期望的另一个接口，使原本因接口不匹配而无法一起工作的类能够协同工作。  

== 概述 ==  
适配器模式分为两种实现方式：  
* '''类适配器'''：通过多重继承实现（C++支持）。  
* '''对象适配器'''：通过组合实现（更常用）。  

核心角色：  
* '''Target'''：客户端期望的接口。  
* '''Adaptee'''：需要被适配的现有类。  
* '''Adapter'''：适配器类，将Adaptee的接口转换为Target的接口。  

== 类适配器实现 ==  
通过继承Adaptee并实现Target接口。  

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

// Target接口  
class Target {  
public:  
    virtual void request() const {  
        std::cout << "Target: 标准请求\n";  
    }  
};  

// Adaptee（需要适配的类）  
class Adaptee {  
public:  
    void specificRequest() const {  
        std::cout << "Adaptee: 特殊请求\n";  
    }  
};  

// Adapter（通过继承Adaptee实现Target）  
class Adapter : public Target, private Adaptee {  
public:  
    void request() const override {  
        specificRequest(); // 调用Adaptee的方法  
    }  
};  

int main() {  
    Target* target = new Adapter();  
    target->request(); // 输出：Adaptee: 特殊请求  
    delete target;  
    return 0;  
}  
</syntaxhighlight>  

=== 输出 ===  
<pre>  
Adaptee: 特殊请求  
</pre>  

== 对象适配器实现 ==  
通过组合Adaptee对象实现（更灵活，推荐）。  

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

// Target接口  
class Target {  
public:  
    virtual void request() const {  
        std::cout << "Target: 标准请求\n";  
    }  
};  

// Adaptee  
class Adaptee {  
public:  
    void specificRequest() const {  
        std::cout << "Adaptee: 特殊请求\n";  
    }  
};  

// Adapter（通过组合Adaptee）  
class Adapter : public Target {  
private:  
    Adaptee* adaptee;  
public:  
    Adapter(Adaptee* a) : adaptee(a) {}  
    void request() const override {  
        adaptee->specificRequest();  
    }  
};  

int main() {  
    Adaptee* adaptee = new Adaptee();  
    Target* target = new Adapter(adaptee);  
    target->request(); // 输出：Adaptee: 特殊请求  
    delete target;  
    delete adaptee;  
    return 0;  
}  
</syntaxhighlight>  

=== 输出 ===  
<pre>  
Adaptee: 特殊请求  
</pre>  

== 实际应用案例 ==  
'''场景'''：第三方支付接口与系统现有接口不兼容。  

<mermaid>  
classDiagram  
    class PaymentSystem {  
        <<interface>>  
        +processPayment()  
    }  
    class ThirdPartyPayment {  
        +makePayment()  
    }  
    class PaymentAdapter {  
        -ThirdPartyPayment* tpp  
        +processPayment()  
    }  
    PaymentSystem <|-- PaymentAdapter  
    PaymentAdapter o-- ThirdPartyPayment  
</mermaid>  

<syntaxhighlight lang="cpp">  
// 现有系统接口  
class PaymentSystem {  
public:  
    virtual void processPayment(float amount) = 0;  
};  

// 第三方支付类（不兼容接口）  
class ThirdPartyPayment {  
public:  
    void makePayment(float amount, const std::string& currency) {  
        std::cout << "Paid " << amount << " " << currency << " via ThirdParty\n";  
    }  
};  

// 适配器  
class PaymentAdapter : public PaymentSystem {  
private:  
    ThirdPartyPayment* tpp;  
public:  
    PaymentAdapter(ThirdPartyPayment* t) : tpp(t) {}  
    void processPayment(float amount) override {  
        tpp->makePayment(amount, "USD"); // 固定货币为USD  
    }  
};  

int main() {  
    ThirdPartyPayment* tpp = new ThirdPartyPayment();  
    PaymentSystem* ps = new PaymentAdapter(tpp);  
    ps->processPayment(100.0f); // 输出：Paid 100 USD via ThirdParty  
    delete ps;  
    delete tpp;  
    return 0;  
}  
</syntaxhighlight>  

== 适配器模式 vs 其他模式 ==  
* '''桥接模式'''：分离抽象与实现，而适配器是解决接口不匹配。  
* '''装饰器模式'''：动态添加功能，适配器是接口转换。  

== 数学表达 ==  
适配器模式可形式化为：  
<math>  
\text{Adapter} = f(\text{Adaptee}) \rightarrow \text{Target}  
</math>  

== 总结 ==  
适配器模式是解决接口兼容性的有效工具，尤其适用于：  
* 集成第三方库。  
* 复用遗留代码。  
* 统一多个类的接口。  

{{Stub|designpattern}}

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 设计模式]]