设计模式之适配器模式

适配器模式将一个类的接口，转换为客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间。适配器模式分为对象适配器和类适配器，对象适配器是通过对象的组合来实现，即适配器继承自抽象目标类，并在适配器中加入一个被适配对象的指针或引用，这样重写抽象目标类接口时，就能利用被适配对象的指针或引用在接口里面加入其对应的动作。对象适配器的类图如下：

下面通过一个具体的实例来说明对象适配器的使用：通过适配器，将火鸡对象传入适配器，使其能传入需要鸭子对象引用的接口。

对应的类图如下：

具体程序如下：

#include "stdafx.h"
#include <iostream>
#include <memory>
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:
	shared_ptr<Turkey> turkey;

public:
	TurkeyAdapter(shared_ptr<Turkey> turkey) {
		this->turkey = turkey;
	}
	void quack() {
		turkey->gobble();
	}
	void fly() {
		for(int i=0; i < 5; i++) {
			turkey->fly();
		}
	}
};

void testDuck(shared_ptr<Duck> duck) {
	duck->quack();
	duck->fly();
}
int _tmain(int argc, _TCHAR* argv[])
{
	shared_ptr<Duck> duck=shared_ptr<Duck>(new MallardDuck());
	shared_ptr<WildTurkey> turkey =shared_ptr<WildTurkey>(new WildTurkey());
	shared_ptr<Duck> turkeyAdapter = shared_ptr<Duck>(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;
}

程序运行结果如下：

类适配器是通过多重继承实现的，适配器需要同时继承自目标类和被适配类。类图如下：

类适配器只需要一个适配器对象就能实现适配功能，不需要再引入一个被具体适配的对象，这是它的优点。但是它只能适配一个具体的类不能在适配这个类的子类，而对象适配不同，它可以适配被适配类的所有子类，所以对象适配器相对更有弹性些。

下面是类适配器的具体程序：

#include "stdafx.h"
#include <iostream>
#include <memory>
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 TurkeyClassAdapter:public WildTurkey,public Duck
{
public:
	void quack() {
			gobble();
	}
	void Duck::fly() {
		for(int i=0; i < 5; i++) {
			WildTurkey::fly();
		}
	}
};
void testDuck(shared_ptr<Duck> duck) {
	duck->quack();
	duck->fly();
}
int _tmain(int argc, _TCHAR* argv[])
{
	cout<<"The TurkeyClassAdapter says..."<<endl;
	shared_ptr<Duck> myAdpter=shared_ptr<TurkeyClassAdapter>(new TurkeyClassAdapter);
	testDuck(myAdpter);
	return 0;
}

运行结果如下：