c++常见设计模式之适配器模式

🕗 发布于 2025-01-21 10:49 设计模式适配器模式 c++

基础介绍

适配器模式作为c++中常见的设计模式模式之一，是一种结构型设计模式。那适配器模式用于解决什么问题呢？答案是将一个类的接口转换成客户期待的另一个接口。适配器让原本不兼容不能一起工作的类可以协同工作。

典型原理

应该如何理解适配器模式呢？假设目前已经存在一个类，该类提供了某个功能A，现在由于需求的需要，需要新设计一个类，该类需要使用到已有类的功能A，但是新的需求与老的类提供的接口不一致，这种情况下就需要使用到适配器模式了。

实现适配器模式：继承+组合。通过这两种形式来实现适配器模式，涉及3个类：适配器类，新的接口类，已有的接口类。适配器类与新的接口类是继承关系；适配器类与已有的接口类是组合关系。具体的示例如下所示：

//新的支付接口
class ModernPayProcessor
{
    public:
        virtual void ProcessPay(double amount)=0;//纯虚函数 新的支付接口
        ....
}

//旧的支付接口
class oldPayProcessor
{
    public:
        //老的支付接口
        void processLegacyPayment(int amount, std::string currency) 
        {
            //具体的支付处理
        }

}

//适配器类
class Adaptor:public ModernPayProcessor
{
    private:
        oldPayProcessor* oldPaySystem;  //老的支付类
    public:
        Adaptor(oldPayProcessor* p):oldPaySystem(p);  //适配器类的构造函数
        void ProcessPay(double amount)  //必须实现这个纯虚函数，否则会编译报错
        {
            //转换数据类型，以实现旧的支付接口的调用
            int number = static_cast<int>(amout);
            oldPaySystem->processLegacyPayment(number, "USD");  //这个老接口与新接口相比，名称不一样，而且参数也不一样，非常典型。
        }
}

//使用实例
int main()
{
    oldPayProcessor old;  //旧的支付对象
    Adaptor adaptor(&old);  //新的适配器类
    
    adaptor.ProcessPay(13.14);
    return 0;
}

通过上面的例子可以很清楚的看明白适配器模式是如何实现的，以及适配器模式的含义。

适配器模式的多种应用

适配模式除了上面的实现方式，还有很多复杂的应用。

多接口适配

上面的例子是一个旧类的接口的适配，适配器模式还支持多个旧类的接口适配，如下例所示：

// 多个旧接口
class LegacyPrinter {
public:
    void printDocument(const std::string& doc) {
        std::cout << "Legacy Printer: " << doc << std::endl;
    }
};

class LegacyScanner {
public:
    std::string scanDocument() {
        return "Scanned content from legacy scanner";
    }
};

// 新的多功能设备接口
class ModernOfficeDevice {
public:
    virtual void print(const std::string& doc) = 0;
    virtual std::string scan() = 0;
    virtual ~ModernOfficeDevice() = default;
};

// 多功能适配器
class OfficeDeviceAdapter : public ModernOfficeDevice {
private:
    LegacyPrinter* printer;
    LegacyScanner* scanner;

public:
    OfficeDeviceAdapter(LegacyPrinter* p, LegacyScanner* s) 
        : printer(p), scanner(s) {}

    void print(const std::string& doc) override {
        printer->printDocument(doc);
    }

    std::string scan() override {
        return scanner->scanDocument();
    }
};

双向适配器

// 接口A
class InterfaceA {
public:
    virtual void operationA() = 0;
    virtual ~InterfaceA() = default;
};

// 接口B
class InterfaceB {
public:
    virtual void operationB() = 0;
    virtual ~InterfaceB() = default;
};

// 双向适配器
class BidirectionalAdapter : public InterfaceA, public InterfaceB {
private:
    InterfaceA* a;
    InterfaceB* b;

public:
    BidirectionalAdapter(InterfaceA* a_ptr, InterfaceB* b_ptr) 
        : a(a_ptr), b(b_ptr) {}

    // A -> B 适配
    void operationA() override {
        b->operationB();
    }

    // B -> A 适配
    void operationB() override {
        a->operationA();
    }
};

更加具体的例子：

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

// 国内支付系统接口
class DomesticPayment {
public:
    virtual void payInCNY(double amount) = 0;
    virtual double getBalanceInCNY() = 0;
    virtual ~DomesticPayment() = default;
};

// 国际支付系统接口
class InternationalPayment {
public:
    virtual void payInUSD(double amount) = 0;
    virtual double getBalanceInUSD() = 0;
    virtual ~InternationalPayment() = default;
};

// 具体的国内支付实现
class AliPay : public DomesticPayment {
private:
    double balance = 1000.0;  // 初始余额

public:
    void payInCNY(double amount) override {
        std::cout << "使用支付宝支付 " << amount << " CNY" << std::endl;
        balance -= amount;
    }

    double getBalanceInCNY() override {
        return balance;
    }
};

// 具体的国际支付实现
class PayPal : public InternationalPayment {
private:
    double balance = 150.0;  // 初始余额

public:
    void payInUSD(double amount) override {
        std::cout << "Using PayPal to pay " << amount << " USD" << std::endl;
        balance -= amount;
    }

    double getBalanceInUSD() override {
        return balance;
    }
};

// 双向支付适配器
class PaymentAdapter : 
    public DomesticPayment, 
    public InternationalPayment {
private:
    std::shared_ptr<DomesticPayment> domesticPayment;
    std::shared_ptr<InternationalPayment> internationalPayment;
    const double USD_TO_CNY_RATE = 7.2;  // 汇率

public:
    PaymentAdapter(
        std::shared_ptr<DomesticPayment> domestic,
        std::shared_ptr<InternationalPayment> international
    ) : domesticPayment(domestic), 
        internationalPayment(international) {}

    // DomesticPayment 接口实现
    void payInCNY(double amount) override {
        std::cout << "适配器: 转换人民币支付请求" << std::endl;
        double usdAmount = amount / USD_TO_CNY_RATE;
        internationalPayment->payInUSD(usdAmount);
    }

    double getBalanceInCNY() override {
        double usdBalance = internationalPayment->getBalanceInUSD();
        return usdBalance * USD_TO_CNY_RATE;
    }

    // InternationalPayment 接口实现
    void payInUSD(double amount) override {
        std::cout << "Adapter: Converting USD payment request" << std::endl;
        double cnyAmount = amount * USD_TO_CNY_RATE;
        domesticPayment->payInCNY(cnyAmount);
    }

    double getBalanceInUSD() override {
        double cnyBalance = domesticPayment->getBalanceInCNY();
        return cnyBalance / USD_TO_CNY_RATE;
    }
};

// 客户端代码
void testPaymentSystems() {
    // 创建支付系统实例
    auto alipay = std::make_shared<AliPay>();
    auto paypal = std::make_shared<PayPal>();
    
    // 创建适配器
    PaymentAdapter adapter(alipay, paypal);
    
    std::cout << "\n=== 测试人民币支付接口 ===\n";
    adapter.payInCNY(100.0);
    std::cout << "人民币余额: " << adapter.getBalanceInCNY() << " CNY\n";
    
    std::cout << "\n=== Testing USD payment interface ===\n";
    adapter.payInUSD(20.0);
    std::cout << "USD balance: " << adapter.getBalanceInUSD() << " USD\n";
}

int main() {
    testPaymentSystems();
    return 0;
}

双向适配设计原则

// 保持接口清晰分离
class InterfaceA {
    virtual void methodA() = 0;
};

class InterfaceB {
    virtual void methodB() = 0;
};

class TwoWayAdapter : public InterfaceA, public InterfaceB {
    // 实现两个接口
};

class TwoWayAdapter {
private:
    // 封装转换逻辑
    void convertAToB() {
        // 转换逻辑
    }
    
    void convertBToA() {
        // 转换逻辑
    }
};

原文地址：https://blog.csdn.net/iqanchao/article/details/145261799

免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Mysql基于gtid的主从同步配置实验
下一篇：kafka 学习笔记3-传统部署Kraft模式集群——筑梦之路

[操作系统] 进程的调度
CPU内有多个寄存器，每个寄存器作用都不同寄存器就是CPU内部的临时空间，存放正在运行的进程的临时数据寄存器不包含寄存器内的数据，寄存器只是临时空间！比如说当计算1 + 1时，两个1单独存放在不同的寄
阅读更多2025-01-21
MS81878运算放大器可P2P兼容OPA188/ADA4077-1
其工作电压可以在单电源下从4V到36V或者双电源下从±2V到±18V。可兼容OPA188/OPA2188/OPA4188/ADA4077-1/ADA4077-2/ADA4077-4。该器件具有宽工作电
阅读更多2025-01-21
Trimble三维激光扫描-地下公共设施维护的新途径【沪敖3D】
通过使用三维激光扫描技术，改变了地下公共设施未来维护和维修工作的方式，显著提高了效率！
阅读更多2025-01-21
LeetCode hot 力扣热题100 排序链表
对拆分后的两部分链表分别递归调用 sortList，直到链表被拆分为单个节点（此时链表自然是有序的）。• 最终 [2 -> 4] 和 [1 -> 3] 合并为 [1 -> 2 -&g
阅读更多2025-01-21
第一讲方程组的几何解释——以列向量线性组合的角度看方程组
第一讲方程组的几何解释——以列向量线性组合的角度看方程组
阅读更多2025-01-21
AI刷题-病毒在封闭空间中的传播时间
以后我想试着一篇博客就写一道题解，尽可能的地把题解思路讲清楚（ps：因为我昨天看之前写的题解的时候有点云里雾里，这就违背我写题解的初衷了）
阅读更多2025-01-21
网络编程 | UDP组播通信
组播是介于单播与广播之间，在一个局域网内，将某些主机添加到组中，并设置一个组地址。将数据发送到组播地址时，加入到该组的所有主机都能接收到数据。组播是主机间一对多的通信模式，组播是一种允许一个或多个组
阅读更多2025-01-21
创建第一个GUI程序
Python 是一种非常强大的编程语言。它自带了内置的 tkinter 模块。我们只需几行代码（准确来说是四行）就可以构建出我们的第一个 Python 图形用户界面（GUI）。
阅读更多2025-01-21
PT8M2302 触控 A/D 型 8-Bit MCU
PT8M2302 是一款可多次编程（MTP）A/D 型 8 位 MCU，其包括 2K*16bit MTP ROM、256*8bit SRAM、ADC、PWM、Touch 等功能，具有高性能精简指令集、
阅读更多2025-01-21
记一次虚机上传过慢问题排查
最近线上虚机有个特殊的用户反馈，用户反馈虚机从A服务器下载文件特别慢，于是scpA服务器数据到本地client，发现只有几十K的流量。当时第一反应怀疑是虚机负载压力比较大，但是查看虚机IO以及负载都很
阅读更多2025-01-21