适配器模式Adapter

定义：

将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

分为类适配器模式和对象适配器模式。

优点：

1.屏蔽了具体的实现方式，实现了依赖倒转。

2.可以把不统一的接口封装起来，使之成为统一的接口。

3.把本来不方便适用的接口转换成统一的接口。

使用场景：

在以下各种情况下使用适配器模式：

1．系统需要使用现有的类，而此类的接口不符合系统的需要。

2．想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作。这些源类不一定有很复杂的接口。

3．（对对象适配器而言）在设计里，需要改变多个已有子类的接口，如果使用类的适配器模式，就要针对每一个子类做一个适配器，而这不太实际。

系统的数据和行为都正确，但接口不符时，我们应该考虑使用适配器，目的是使控制范围之外的一个原有对象与某个接口匹配。

适配器模式主要应用于希望复用一些现存的类，但是接口又与复用环境要求不一致的情况。

想使用一个已经存在的类，但如果它的接口，也就是它的方法和你的要求不相同时，就应该考虑用适配器模式。

两个类所做的事情相同或相似，但是具有不同的接口时要使用它。

对象适配器模式：

客户端需要调用Request方法，而Adaptee没有该方法，为了使客户端能够使用Adaptee类，需要提供一个包装（Wrapper）类Adapter。这个包装类包装了一个Adaptee的实例，从而将客户端与Adaptee衔接起来。由于Adapter与Adaptee是委派关系，这决定了这个适配器模式是对象的。

类模式适配器：

Adaptee类没有Request方法，而客户期待这个方法。为了使客户能够使用Adaptee类，提供一个中间环节，即类Adapter类，Adapter类实现了Target接口，并继承自Adaptee，Adapter类的Request方法重新封装了Adaptee的SpecificRequest方法，实现了适配的目的。因为Adapter与Adaptee是继承的关系，所以这决定了这个适配器模式是类的。

类适配器有以下特点：

1. 由于Adapter直接继承自Adaptee类，所以，在Adapter类中可以对Adaptee类的方法进行重定义；
2. 如果在Adaptee中添加了一个抽象方法，那么Adapter也要进行相应的改动，这样就带来高耦合；
3. 如果Adaptee还有其它子类，而在Adapter中想调用Adaptee其它子类的方法时，使用类适配器是无法做到的。

对象适配器有以下特点：

1. 有的时候，你会发现，不是很容易去构造一个Adaptee类型的对象；
2. 当Adaptee中添加新的抽象方法时，Adapter类不需要做任何调整，也能正确的进行动作；
3. 可以使用多肽的方式在Adapter类中调用Adaptee类子类的方法。

类适配器采用“多继承”的实现方式，带来了不良的高耦合，所以一般不推荐使用。对象适配器采用“对象组合”的方式，更符合松耦合精神。

由于对象适配器的耦合度比较低，所以在很多的书中都建议使用对象适配器。在我们实际项目中，也是如此，能使用对象组合的方式，就不使用多继承的方式。

#include <iostream>
using namespace std;

//目标接口类，客户需要的接口
class Target
{
public:
    Target(){}
    virtual ~Target(){}
    virtual void Request()//定义标准接口
    {
        cout << "Target::Request()" << endl;
    }
};

//需要适配的类
class Adaptee
{
public:
    Adaptee(){}
    ~Adaptee(){}
    void SpecificRequest()
    {
        cout << "Adaptee::SpecificRequest()" << endl;
    }
};

//类模式，适配器类，通过public继承获得接口继承的效果，通过private继承获得实现继承的效果
class Adapter:public Target,private Adaptee
{
public:
    Adapter(){}
    ~Adapter(){}
    virtual void Request()//实现Target定义的Request接口
    {
        cout << "Adapter::Request()" << endl;
        this->SpecificRequest();
        cout << "----------------------------" <<endl;
    }
};

//对象模式，适配器类，继承Target类，采用组合的方式实现Adaptee的复用
class Adapter1:public Target
{
public:
    Adapter1(Adaptee* adaptee):_adaptee(adaptee){}
    Adapter1():_adaptee(new Adaptee()){}
    ~Adapter1(){}
    virtual void Request()//实现Target定义的Request接口
    {
        cout << "Adapter1::Request()" << endl;
        this->_adaptee->SpecificRequest();
    }
private:
    Adaptee* _adaptee;//内部包装一个Adaptee对象，把源接口转换为目标接口
};

int main()//客户端代码
{
    //类模式Adapter
    Target* pTarget = new Adapter();
    pTarget->Request();

    //对象模式Adapter1
    Adaptee* ade = new Adaptee();
    Target* pTarget1= new Adapter1(ade);
    pTarget1->Request();

    //对象模式Adapter2
    Target* pTarget2 = new Adapter1();
    pTarget2->Request();

    return 0;
}

列举一个c++ STL中的适配器例子，这只是简单模型，想要深入请看STL源码剖析

这里target：Sequence

adaptee是：deque

而被实现的适配器是queue和stack

#include <iostream>
using namespace std;

//双端队列
class Deque//目标
{
public:
	void push_back(int x) { cout << "Deque push_back" << endl; }
	void push_front(int x) { cout << "Deque push_front" << endl; }
	void pop_back() { cout << "Deque pop_back" << endl; }
	void pop_front() { cout << "Deque pop_front" << endl; }
};
//顺序容器
class Sequence//源
{
public:
	virtual void push(int x) = 0;
	virtual void pop() = 0;
};
//栈
class Stack : public Sequence
{//适配器
public:
	void push(int x) { deque.push_back(x); }
	void pop() { deque.pop_back(); }
private:
	Deque deque; //双端队列
};
//队列
class Queue : public Sequence
{//适配器
public:
	void push(int x) { deque.push_back(x); }
	void pop() { deque.pop_front(); }
private:
	Deque deque; //双端队列
};
int main()
{
	Sequence *s1 = new Stack();
	Sequence *s2 = new Queue();
	s1->push(1); s1->pop();
	s2->push(1); s2->pop();
	delete s1; delete s2;
	return 0;
}