适配器是一种结构型设计模式，它能使接口不兼容的对象能够相互合作。又称封装器模式（Wrapper）。
适配器模式通过封装对象将复杂的转换过程隐藏于幕后。被封装的对象甚至察觉不到适配器的存在。例如，你可以使用一个将所有数据转换为英制单位（如英尺和英里）的适配器封装运行于米和千米单位制中的对象。
适配器不仅可以转换不同格式的数据，其还有助于采用不同接口的对象之间的合作。它的运作方式如下：
适配器实现与其中一个现有对象兼容的接口。
现有对象可以使用该接口安全地调用适配器方法。
适配器方法被调用后将以另一个对象兼容的格式和顺序将请求传递给该对象。
客户端（Client）是包含当前程序业务逻辑的类。
客户端接口（Client Interface） 描述了其他类与客户端代码合作时必须遵循的协议。
服务（Service）中有一些功能类（通常来自第三方或遗留系统）。客户端与其接口不兼容，因此无法直接调用其功能。
适配器（Adapter） 是一个可以同时与客户端和服务交互的类：它在实现客户端接口的同时封装了服务对象。适配器接受客户端通过适配器接口发起的调用，并将其转换为适用于被封装服务对象的调用。
客户端代码只需通过接口与适配器交互即可，无需与具体的适配器类耦合。因此，你可以向程序中添加新类型的适配器而无需修改已有代码。这在服务类的接口被更改或替换时很有用：你无需修改客户端代码就可以创建新的适配器类。
代码整体复杂度增加，因为你需要新增一系列接口和类。有时直接更改服务类使其与其他代码兼容会更简单。
方钉和圆孔的问题，我们要做的是让方钉适配圆孔。
适配器让方钉假扮成一个圆钉（RoundPeg），其半径等于方钉（SquarePeg）横截面对角线的一半（即能容纳方钉的最小外接圆的半径）。
// ClientInterface.h
#ifndef CLIENT_INTERFACE_H_
#define CLIENT_INTERFACE_H_
// 圆钉: 客户端接口, 在C++中定义成抽象基类
class RoundPeg {
public:
RoundPeg() {}
virtual int get_radius() = 0;
};
#endif // CLIENT_INTERFACE_H_
Adapter.h：
// Adapter.h：
#ifndef ADAPTER_H_
#define ADAPTER_H_
#include <cmath>
#include "Service.h"
#include "ClientInterface.h"
// 方钉适配器: 该适配器能让客户端将方钉放入圆孔中
class SquarePegAdapter : public RoundPeg {
public:
explicit SquarePegAdapter(SquarePeg* sp) : square_peg_(sp) {}
int get_radius() override {
return square_peg_->get_width() * sqrt(2) / 2;
}
private:
SquarePeg* square_peg_;
};
#endif // ADAPTER_H_
Service.h：
#ifndef SERVICE_H_
#define SERVICE_H_
// 方钉: 适配者类, 即和客户端不兼容的类
class SquarePeg {
public:
explicit SquarePeg(int w) : width_(w) {}
int get_width() {
return width_;
}
private:
int width_;
};
#endif // SERVICE_H_
Client.h：
#ifndef CLIENT_H_
#define CLIENT_H_
#include "ClientInterface.h"
// 圆孔: 客户端类
class RoundHole {
public:
explicit RoundHole(int r) : radius_(r) {}
int get_radius() {
return radius_;
}
bool isFit(RoundPeg* rp) {
return radius_ >= rp->get_radius();
}
private:
int radius_;
};
#endif // CLIENT_H_
main.cpp
#include <iostream>
#include "Client.h"
#include "Adapter.h"
int main() {
// 半径为10的圆孔
RoundHole* hole = new RoundHole(10);
// 半径分别为5和20的大小方钉 + 它们的适配器
SquarePeg* samll_square_peg = new SquarePeg(5);
SquarePeg* large_square_peg = new SquarePeg(20);
SquarePegAdapter* small_square_peg_adapter = new SquarePegAdapter(samll_square_peg);
SquarePegAdapter* large_square_peg_adapter = new SquarePegAdapter(large_square_peg);
// hole->isFit(samll_square_peg); // 编译报错
// hole->isFit(large_square_peg); / / 编译报错
if (hole->isFit(small_square_peg_adapter)) {
std::cout << "small square peg fits the hole" << std::endl;
} else {
std::cout << "small square peg don't fit the hole" << std::endl;
}
if (hole->isFit(large_square_peg_adapter)) {
std::cout << "large square peg fits the hole" << std::endl;
} else {
std::cout << "large square peg don't fit the hole" << std::endl;
}
}
编译运行
$g++ -g main.cpp -o adapter -std=c++11
$./adapter
small square peg fits the hole
large square peg don't fit the hole
假设，现在有现有的各种动物，都是现成的，有猫、狗。他们都有各自的方法比如说，卧倒，打滚等，但是呢，他们的接口又不一样。为了使主人去让猫、狗做动作的接口一致，就需要适配器。因为语言不通，一个喵喵喵，一个汪汪汪。
adpter.h
#include <iostream>
class DOG {
public:
void Dog_Bedding() { std::cout << "小狗子，请卧倒" << std::endl; }
void Dog_Roll() { std::cout << "小狗子，请打滚" << std::endl; }
};
class CAT {
public:
void Cat_Bedding() { std::cout << "小猫咪，请卧倒" << std::endl; }
void Cat_Roll() { std::cout << "小猫咪，请打滚" << std::endl; }
};
class Target {
public:
virtual void Bedding()=0; // 外部符号
virtual void Roll()=0;
};
class adpter_cat : public Target {
public:
adpter_cat(CAT* c) : cat_(c) {}
void Bedding() { cat_->Cat_Bedding(); }
void Roll() { cat_->Cat_Roll(); }
private:
CAT* cat_;
};
class adpter_dog : public Target {
public:
adpter_dog(DOG* d) : dog_(d) {}
void Bedding() { dog_->Dog_Bedding(); }
void Roll() { dog_->Dog_Roll(); }
private:
DOG* dog_;
};
main.cpp
// #include "Adpter_cat.h"
// #include "Adpter_dog.h"
// #include "cat.h"
// #include "dog.h"
#include "adpter.h"
int main() {
CAT* cat = new CAT();
DOG* dog = new DOG();
adpter_cat ac(cat);
adpter_dog ad(dog);
ac.Bedding();
ac.Roll();
ad.Bedding();
ad.Roll();
}
运行结果
小猫咪，请卧倒
小猫咪，请打滚
小狗子，请卧倒
小狗子，请打滚