C++ 适配器模式实现

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

概述

适配器模式分为两种实现方式：

• 类适配器：通过多重继承实现（C++支持）。
• 对象适配器：通过组合实现（更常用）。

核心角色：

• Target：客户端期望的接口。
• Adaptee：需要被适配的现有类。
• Adapter：适配器类，将Adaptee的接口转换为Target的接口。

类适配器实现

通过继承Adaptee并实现Target接口。

  
#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;  
}

输出

  
Adaptee: 特殊请求  

对象适配器实现

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

  
#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;  
}

输出

  
Adaptee: 特殊请求  

实际应用案例

场景：第三方支付接口与系统现有接口不兼容。

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

  
// 现有系统接口  
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;  
}

适配器模式 vs 其他模式

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

数学表达

适配器模式可形式化为： $\text{Adapter}=f(\text{Adaptee})\to \text{Target}$

总结

适配器模式是解决接口兼容性的有效工具，尤其适用于：

• 集成第三方库。
• 复用遗留代码。
• 统一多个类的接口。