一，适配器模式简介
适配器模式是一种结构型设计模式，用于将已有接口转换为调用者所期望的另一种接口。
适配器模式让特定的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 JuiceDemo2:
类适配器与对象适配器代码对比
#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/
