C++设计模式——Adapter适配器模式

一，适配器模式简介

适配器模式是一种结构型设计模式，用于将已有接口转换为调用者所期望的另一种接口。

适配器模式让特定的API接口可以适配多种场景。例如，现有一个名为"Reader()"的API接口只能解析txt格式的文件，给这个Reader()接口增加适配器以后，它可以同时支持xml、json、csv等格式的文件。

适配器是一个特殊的类，它可以扩展或者说转接一些特定API接口的功能，使得API接口可以被应用到更多对象或数据类型上。

适配器会将适配过程进行封装，从而隐藏适配的过程，只对外界提供被适配以后的API接口。

适配器在真实世界中的模拟：

1.USB转接头，实现typec接口转USB。

2.设备网关，让ipv4网络与ipv6网络互通。

适配器模式的主要组件：

1.目标接口(Target)：提供给外部程序的统一接口，是外部调用者(client)期望使用的接口。

2.源接口(Adaptee)：已经具备一定的功能，但是与Target不兼容的接口。它包含了client所需要的功能，但是不能被client所使用。

3.适配器(Adapter)：对源接口进行适配，使得源接口可以像目标接口一样被公共调用。适配器提供了Target的接口实现，并通过继承或组合的方式调用了Adaptee的接口。

适配器模式的优点：

1.可以实现对现有组件代码的复用。

2.使得不兼容的组件之间可以成功交互。

3.降低了各种接口之间的用法差异。

4.方便集成第三方库或者API。

适配器模式与桥接模式(Bridge Pattern)的区别：

两者的用途不同，桥接模式的用途是将接口与实现分开，适配器模式的用途是修改现有接口，从而解决兼容问题。

二，适配器模式的应用场景

在开发场景中，适配器模式的应用场景有：

1.兼容相同业务下的不同接口实现。

2.兼容不同的通信方式，比如使用适配器将UDP通信转为内部的共享内存通信。

3.处理代码中不同类之间交互时的兼容问题。

在嵌入式开发场景，经常使用的Wrapper，也是一种适配器模式。Wrapper是指将传感器等硬件或者操作系统的底层API封装成一种高级接口或者类，从而提供给上层应用去调用。

Wrapper可以隐藏底层的具体实现细节，使上层应用程序可以更加方便地使用底层接口。例如，当嵌入式设备需要读写摄像头数据时，我们可以把摄像头提供的SDK封装成一个Wrapper，从而简化了调用方式。

不推荐使用适配器的场景：

1.原有接口的变动很大的时候。

2.对接口性能要求很高的时候。

3.适配器需要适配的地方过多的时候。

三，适配器代码样例

1.UML类图

Adapter类继承了Target类并重写了Target类的request接口，Adapter类实现request接口的时候调用了Adaptee类提供的specificRequest接口。

整体上，相当于Adapter类为Adaptee类的specificRequest接口做了适配。

2.代码实现

#include <iostream>
//目标接口
class Target
{
public:virtual void request() = 0;
};
//源接口
class Adaptee
{
public:void specificRequest(){std::cout << "Adaptee specific request" << std::endl;}
};
//被适配后的源接口
class Adapter : public Target
{
public:Adapter(Adaptee* adaptee) : m_adaptee(adaptee) {}void request() override{m_adaptee->specificRequest();}
private:Adaptee* m_adaptee;
};
int main()
{Adaptee* adaptee = new Adaptee();Target* target = new Adapter(adaptee);target->request();return 0;
}

运行结果： 

Adaptee specific request

四，适配器模式的分类

1.类适配器：

类适配器以类继承的方式适配不兼容的源接口。

C++语法支持继承自多个父类（钻石继承），适配器同时继承了目标接口和源接口，从而使得源接口的函数可以被目标接口所调用。

2.对象适配器：

对象适配器以对象组合的方式适配不兼容的源接口。所谓的对象组合，是指在一个对象内部调用另一个对象的成员函数。

对象适配器中包含了源接口的实例对象，对象适配器的可扩展性更好，方便加入新的功能进行适配。

五，代码实战

Demo1:  

适配了咖啡机和榨汁机的饮料机，采用对象适配器实现。

#include <iostream>
#include <functional>class  Beverage {
public:virtual void getBeverage() = 0;
};class CoffeeMaker {
public:CoffeeMaker() = default;void Brew() {std::cout << "Brewing coffee" << std::endl;}
};class JuiceMaker {
public:JuiceMaker() = default;void Squeeze() {std::cout << "Squeezeing Juice" << std::endl;}
};class Adapter : Beverage {  
private:std::function<void()> m_request;
public:Adapter(CoffeeMaker* cm){ m_request = [cm]() { cm->Brew(); };}Adapter(JuiceMaker* jm) { m_request = [jm]() { jm->Squeeze(); }; }//对外公共接口void getBeverage() { m_request(); }
};int main() {CoffeeMaker* CM= new CoffeeMaker();Adapter coffee(CM);coffee.getBeverage();JuiceMaker* JM = new JuiceMaker();Adapter juice(JM);juice.getBeverage();return 0;
}

运行结果： 

Brewing coffee
Squeezeing Juice

Demo2: 

类适配器与对象适配器代码对比

#include <iostream>//目标接口
class Target {
public:virtual void Request() = 0;
};//源接口
class Adaptee {
public:void SpecificRequest() {std::cout << "Adaptee output." << std::endl;}
};//对象适配器
class ObjectAdapter : public Target {
public://源接口的实例化ObjectAdapter(Adaptee* adaptee) : m_adaptee(adaptee) {}void Request() override {std::cout << "From ObjectAdapter: ";m_adaptee->SpecificRequest();}
private:Adaptee* m_adaptee;
};//类适配器
//钻石继承
class ClassAdapter : public Target, private Adaptee {
public:void Request() override {std::cout << "From ClassAdapter: " ;SpecificRequest();}
};int main()
{Adaptee* adaptee = new Adaptee();ObjectAdapter* adapter_1 = new ObjectAdapter(adaptee);ClassAdapter* adapter_2 = new ClassAdapter();adapter_1->Request();adapter_2->Request();return 0;
}

运行结果：

From ObjectAdapter: Adaptee output.
From ClassAdapter: Adaptee output.

六，参考阅读

https://refactoring.guru/design-patterns/adapter

https://www.geeksforgeeks.org/adapter-pattern-c-design-patterns/