适配器模式

适配器模式：

将一个类的接口，转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间。

下面先看一个简单的适配例子：

#include <iostream>
#include <string>
#include <vector>
#include <sstream>
using namespace std;

/*定义鸭子接口*/
class Duck{
public:
	virtual void quack() = 0;
	virtual void fly() = 0;
};

/*绿头鸭*/
class MallardDuck :public Duck{
public:
	void quack(){
		cout << "Quack" << endl;
	}
	void fly(){
		cout << "I'm flying" << endl;
	}
};

/*定义火鸡接口*/
class Turkey{
public:
	virtual void gobble() = 0;
	virtual void fly() = 0;
};

/*定义野火鸡*/
class WildTurkey :public Turkey{
public:
	void gobble(){
		cout << "Gobble gobble" << endl;
	}
	void fly(){
		cout << "I'm flying a short distance" << endl;
	}
};


/*现在如果缺鸭子对象，而想让火鸡来填充，因为接口不同，因此需要提供适配器*/
class TurkeyAdapter :public Duck{
private:
	Turkey *turkey;
public:
	TurkeyAdapter(Turkey *_turkey) :turkey(_turkey){}
	void quack(){
		turkey->gobble();
	}
	void fly(){
		for (int i = 0; i < 5; i++)   //火鸡飞的距离较短，重复5次
			turkey->fly();
	}
};


/*测试鸭子，传入一个鸭子对象*/
void testDuck(Duck *duck){
	duck->quack();
	duck->fly();
}

int main()
{
	MallardDuck *duck = new MallardDuck();   //创建一个鸭子对象
	WildTurkey *turkey = new WildTurkey();   //创建一个火鸡对象
	Duck *turkeyAdapter = new TurkeyAdapter(turkey);   //将火鸡包装进一个火鸡适配器中

	/*测试火鸡*/
	cout << "The Turkey says ..." << endl;
	turkey->gobble();
	turkey->fly();

	/*测试鸭子*/
	cout << "The Duck says ..." << endl;
	testDuck(duck);

	/*测试假装鸭子的火鸡*/
	cout << "The TurkeyAdapter says ..." << endl;
	testDuck(turkeyAdapter);  //此处传入的是适配器
	return 0;
}

下面来看类图：

优点：被适配的任何子类，都可以搭配适配器使用。

适配器包含两种：“对象”适配器和“类”适配器。

前面的例子及类图都是“对象”适配器。

对象适配器和类适配器的差别：

类适配器继承类Target和Adaptee，而对象适配器利用组合的方式将请求传送个被适配者。（即一个是组合，一个是继承）

两者优点：

对象适配器：优点是不仅可以适配某个类，也可以适配该类的任何子类，弹性好。

类适配器：优点是不需要重新实现我的整个被适配者，必要的时候，也可以覆盖被适配者的行为，效率高（仅仅需要一个类适配器，不需要适配器和一个被适配者）。

装饰者模式和适配器模式的区别：

1）关于新职责：适配器也可以在转换时增加新的职责，但主要目的不在此。装饰者模式主要是给被装饰者增加新的职责。

2）关于原接口：适配器模式是用新接口来调用原接口，原接口对新系统是不可见或者不可用。装饰者原封不动的使用原接口，系统对装饰的对象也通过原接口来完成使用。

3）关于包裹对象：适配器知道被适配者的详细情况，装饰者只知道其接口是什么，至于其具体类，只有在运行期才知道。