C++适配器模式之可插入适配器的实现模式和方法

捕鲸叉2024-11-21 19:53

可插入适配器与Adaptee的窄接口

在C++适配器模式中，可插入适配器（Pluggable Adapter）是指适配器类的设计允许在运行时动态地插入不同的Adaptee对象，从而使适配器具有灵活性和可扩展性。这种设计使得适配器不仅限于适配一个特定的Adaptee，而是可以适配多个不同的Adaptee。

Adaptee的窄接口（Narrow Interface）是指Adaptee提供的接口只包含有限的方法，这些方法可能不足以满足客户端的需求。适配器的工作就是将这些有限的方法适配成客户端所期望的更丰富的接口。

可插入适配器的实现方式

可插入适配器有以下几种实现方式：

  1. 对象适配器模式（Object Adapter）：适配器持有Adaptee实例的引用。
  2. 类适配器模式（Class Adapter）：适配器通过多重继承同时继承目标接口和Adaptee。
  3. 双适配器模式（Two-Way Adapter）：适配器可以同时作为Adaptee和Target接口的适配器。

下面分别介绍这三种实现方式，并给出UML图和C++代码示例。

1. 对象适配器模式（Object Adapter）

UML 类图
+-------------------+           +-------------------+
|      Target       |           |      Adapter      |
|-------------------|           |-------------------|
| + request()       |<----------|>+ request()       |
+-------------------+           |-------------------|
                                  | - adaptee: Adaptee|
                                  |-------------------|
                                  | + request()       |
                                  |-------------------|
                                  | + doSomething()   |
                                  +-------------------+
                                        |
                                        |
                                        V
                                  +-------------------+
                                  |      Adaptee      |
                                  |-------------------|
                                  | + doSomething()   |
                                  +-------------------+
C++ 代码示例
cpp 复制代码 
#include <iostream>

// Target 接口
class Target {
public:
    virtual void request() const = 0;
};

// Adaptee 类
class Adaptee {
public:
    void doSomething() const {
        std::cout << "Adaptee: Doing something." << std::endl;
    }
};

// Adapter 类
class Adapter : public Target {
private:
    Adaptee* adaptee;

public:
    Adapter(Adaptee* adaptee) : adaptee(adaptee) {}

    void request() const override {
        adaptee->doSomething();
    }
};

// 客户端代码
int main() {
    Adaptee* adaptee = new Adaptee();
    Target* adapter = new Adapter(adaptee);

    adapter->request(); // 调用适配器的方法

    delete adaptee;
    delete adapter;

    return 0;
}

2. 类适配器模式（Class Adapter）

UML 类图
+-------------------+           +-------------------+
|      Target       |           |      Adapter      |
|-------------------|           |-------------------|
| + request()       |<----------|>+ request()       |
+-------------------+           |-------------------|
                                  | + doSomething()   |
                                  |-------------------|
                                  +-------------------+
                                        ^
                                        |
                                        |
                                  +-------------------+
                                  |      Adaptee      |
                                  |-------------------|
                                  | + doSomething()   |
                                  +-------------------+
C++ 代码示例
cpp 复制代码 
#include <iostream>

// Target 接口
class Target {
public:
    virtual void request() const = 0;
};

// Adaptee 类
class Adaptee {
public:
    void doSomething() const {
        std::cout << "Adaptee: Doing something." << std::endl;
    }
};

// Adapter 类
class Adapter : public Target, private Adaptee {
public:
    void request() const override {
        doSomething();
    }
};

// 客户端代码
int main() {
    Target* adapter = new Adapter();

    adapter->request(); // 调用适配器的方法

    delete adapter;

    return 0;
}

3. 双适配器模式（Two-Way Adapter）

UML 类图
+-------------------+           +-------------------+
|      Target       |           |      Adapter      |
|-------------------|           |-------------------|
| + request()       |<----------|>+ request()       |
+-------------------+           |-------------------|
                                  | + doSomething()   |
                                  |-------------------|
                                  +-------------------+
                                        ^
                                        |
                                        |
                                  +-------------------+
                                  |      Adaptee      |
                                  |-------------------|
                                  | + doSomething()   |
                                  +-------------------+
C++ 代码示例
cpp 复制代码 
#include <iostream>

// Target 接口
class Target {
public:
    virtual void request() const = 0;
};

// Adaptee 接口
class Adaptee {
public:
    virtual void doSomething() const = 0;
};

// 具体的 Adaptee 类
class ConcreteAdaptee : public Adaptee {
public:
    void doSomething() const override {
        std::cout << "ConcreteAdaptee: Doing something." << std::endl;
    }
};

// Adapter 类
class Adapter : public Target, public Adaptee {
private:
    ConcreteAdaptee* adaptee;

public:
    Adapter(ConcreteAdaptee* adaptee) : adaptee(adaptee) {}

    void request() const override {
        adaptee->doSomething();
    }

    void doSomething() const override {
        adaptee->doSomething();
    }
};

// 客户端代码
int main() {
    ConcreteAdaptee* adaptee = new ConcreteAdaptee();
    Adapter* adapter = new Adapter(adaptee);

    adapter->request(); // 调用适配器的方法
    adapter->doSomething(); // 调用 Adaptee 的方法

    delete adaptee;
    delete adapter;

    return 0;
}

总结

可插入适配器和Adaptee的窄接口是适配器模式的两个重要概念。通过对象适配器、类适配器和双适配器这三种实现方式，适配器可以灵活地适配不同的Adaptee对象，解决接口不兼容的问题。这些实现方式各有优缺点，选择哪种方式取决于具体的需求和设计考虑。

在窄接口实现中，可以通过抽象实现、使用代理对象和参数化适配器方式来实现适配器模式。下面分别说明这三种方式，并给出相应的UML图和C++代码示例。

1. 抽象实现（Abstract Implementation）

抽象实现通过定义一个抽象基类来提供Adaptee的窄接口，然后具体的Adaptee实现类从这个抽象基类继承。适配器类可以持有这个抽象基类的引用，从而在运行时适配不同的具体实现。

UML 类图
+-------------------+           +-------------------+           +-------------------+
|      Target       |           |      Adapter      |           |      Adaptee1     |
|-------------------|           |-------------------|           |-------------------|
| + request()       |<----------|>+ request()       |<----------|>+ doSomething()   |
+-------------------+           |-------------------|           +-------------------+
                                  | - adaptee: Adaptee|
                                  |-------------------|
                                  +-------------------+
                                        ^
                                        |
                                        |
                                  +-------------------+           +-------------------+
                                  |  AbstractAdaptee  |           |      Adaptee2     |
                                  |-------------------|           |-------------------|
                                  | + doSomething()   |<----------|>+ doSomething()   |
                                  +-------------------+           +-------------------+
C++ 代码示例
cpp 复制代码 
#include <iostream>

// Target 接口
class Target {
public:
    virtual void request() const = 0;
};

// 抽象的 Adaptee 基类
class AbstractAdaptee {
public:
    virtual void doSomething() const = 0;
};

// 具体的 Adaptee 实现类 1
class Adaptee1 : public AbstractAdaptee {
public:
    void doSomething() const override {
        std::cout << "Adaptee1: Doing something." << std::endl;
    }
};

// 具体的 Adaptee 实现类 2
class Adaptee2 : public AbstractAdaptee {
public:
    void doSomething() const override {
        std::cout << "Adaptee2: Doing something." << std::endl;
    }
};

// Adapter 类
class Adapter : public Target {
private:
    AbstractAdaptee* adaptee;

public:
    Adapter(AbstractAdaptee* adaptee) : adaptee(adaptee) {}

    void request() const override {
        adaptee->doSomething();
    }
};

// 客户端代码
int main() {
    AbstractAdaptee* adaptee1 = new Adaptee1();
    AbstractAdaptee* adaptee2 = new Adaptee2();

    Target* adapter1 = new Adapter(adaptee1);
    Target* adapter2 = new Adapter(adaptee2);

    adapter1->request(); // 调用适配器的方法
    adapter2->request(); // 调用适配器的方法

    delete adaptee1;
    delete adaptee2;
    delete adapter1;
    delete adapter2;

    return 0;
}

2. 使用代理对象（Proxy Object）

代理对象是通过创建一个代理类来间接访问Adaptee的方法。适配器类持有这个代理对象的引用，并通过代理对象来调用Adaptee的方法。这种方式可以提供额外的控制和功能，比如访问控制、缓存等。

UML 类图
+-------------------+           +-------------------+           +-------------------+
|      Target       |           |      Adapter      |           |      Proxy        |
|-------------------|           |-------------------|           |-------------------|
| + request()       |<----------|>+ request()       |<----------|>+ doSomething()   |
+-------------------+           |-------------------|           +-------------------+
                                  | - proxy: Proxy    |
                                  |-------------------|
                                  +-------------------+
                                        ^
                                        |
                                        |
                                  +-------------------+           +-------------------+
                                  |      Proxy        |           |      Adaptee      |
                                  |-------------------|           |-------------------|
                                  | + doSomething()   |<----------|>+ doSomething()   |
                                  +-------------------+           +-------------------+
C++ 代码示例
cpp 复制代码 
#include <iostream>

// Target 接口
class Target {
public:
    virtual void request() const = 0;
};

// Adaptee 类
class Adaptee {
public:
    void doSomething() const {
        std::cout << "Adaptee: Doing something." << std::endl;
    }
};

// Proxy 类
class Proxy {
private:
    Adaptee* adaptee;

public:
    Proxy(Adaptee* adaptee) : adaptee(adaptee) {}

    void doSomething() const {
        std::cout << "Proxy: Before calling Adaptee." << std::endl;
        adaptee->doSomething();
        std::cout << "Proxy: After calling Adaptee." << std::endl;
    }
};

// Adapter 类
class Adapter : public Target {
private:
    Proxy* proxy;

public:
    Adapter(Proxy* proxy) : proxy(proxy) {}

    void request() const override {
        proxy->doSomething();
    }
};

// 客户端代码
int main() {
    Adaptee* adaptee = new Adaptee();
    Proxy* proxy = new Proxy(adaptee);
    Target* adapter = new Adapter(proxy);

    adapter->request(); // 调用适配器的方法

    delete adaptee;
    delete proxy;
    delete adapter;

    return 0;
}

3. 参数化适配器（Parameterized Adapter）

参数化适配器通过将Adaptee的方法参数化，使得适配器可以在运行时传递不同的参数来调用Adaptee的方法。这种方式可以增强适配器的灵活性。

UML 类图
+-------------------+           +-------------------+
|      Target       |           |      Adapter      |
|-------------------|           |-------------------|
| + request()       |<----------|>+ request()       |
+-------------------+           |-------------------|
                                  | - adaptee: Adaptee|
                                  |-------------------|
                                  +-------------------+
                                        ^
                                        |
                                        |
                                  +-------------------+
                                  |      Adaptee      |
                                  |-------------------|
                                  | + doSomething(int)|
                                  +-------------------+
C++ 代码示例
cpp 复制代码 
#include <iostream>

// Target 接口
class Target {
public:
    virtual void request() const = 0;
};

// Adaptee 类
class Adaptee {
public:
    void doSomething(int param) const {
        std::cout << "Adaptee: Doing something with parameter " << param << "." << std::endl;
    }
};

// Adapter 类
class Adapter : public Target {
private:
    Adaptee* adaptee;
    int param;

public:
    Adapter(Adaptee* adaptee, int param) : adaptee(adaptee), param(param) {}

    void request() const override {
        adaptee->doSomething(param);
    }
};

// 客户端代码
int main() {
    Adaptee* adaptee = new Adaptee();
    Target* adapter = new Adapter(adaptee, 42);

    adapter->request(); // 调用适配器的方法

    delete adaptee;
    delete adapter;

    return 0;
}

总结

这三种方式都可以在窄接口实现中使用，根据具体的需求选择不同的实现方式。抽象实现提供了灵活的适配能力，代理对象提供了额外的控制和功能，参数化适配器增强了适配器的灵活性。每种方式都有其适用的场景，选择合适的方式可以提高代码的可维护性和扩展性。

相关推荐
捕鲸叉7 分钟前
C++创建型模式之生成器模式
开发语言·c++·建造者模式
sxtyjty15 分钟前
人机打怪小游戏（非常人机）
c++
oioihoii22 分钟前
单例模式详解
c++·单例模式·c#·大学必学
ZVAyIVqt0UFji25 分钟前
Reactflow图形库结合Dagre算法实现函数资源关系图
开发语言·前端·javascript·ecmascript
ikkkkkkkl27 分钟前
深述C++模板类
开发语言·c++
网安_秋刀鱼28 分钟前
PHP代码审计 --MVC模型开发框架&rce示例
开发语言·web安全·网络安全·php·mvc·1024程序员节
威威猫的栗子39 分钟前
Python Turtle绘图：重现汤姆劈树的经典瞬间
开发语言·python
沙度灬42 分钟前
python之sklearn--鸢尾花数据集之数据降维(PCA主成分分析)
开发语言·python·sklearn
Theodore_10221 小时前
7 设计模式原则之合成复用原则
java·开发语言·jvm·设计模式·java-ee·合成复用原则
枫__________1 小时前
kotlin 协程 job的cancel与cancelAndJoin区别
android·开发语言·kotlin
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04机器人持续学习基准LIBERO系列10——文件结构05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO0704 - matlab m_map地学绘图工具基础函数 - 设置网格08玄机平台应急响应—webshell查杀09RAG 实践- Ollama+RagFlow 部署本地知识库10小米路由器简单救砖