适配器模式

适配器模式（Adapter）：将一个类的接口转换成客户希望的另外一个接口。A d a p t e r 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

适用场景：

1、已经存在的类的接口不符合我们的需求；

2、创建一个可以复用的类，使得该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作；

3、在不对每一个都进行子类化以匹配它们的接口的情况下，使用一些已经存在的子类。

通用类图：

 

我们生活中常常听到的是

电源适配器，它是用于电流变换（整流）的设备。适配器的存在，就是为了将已存在的东西（接口）转换成适合我们的需要、能被我们所利用。在现实生活中，适配器更多的是作为一个中间层来实现这种转换作用。

在上面的通用类图中，Cient 类最终面对的是 Target 接口（或抽象类），它只能够使用符合这一目标标准的子类；而 Adaptee 类则是被适配的对象（也称 源角色），因为它包含specific （特殊的）操作、功能等，所以我们想要在自己的系统中使用它，将其转换成符合我们标准的类，使得 Client 类可以在透明的情况下任意选择使用 ConcreteTarget 类或是具有特殊功能的 Adatee 类。

1.以下是类的适配器模式代码：

#include <iostream>
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include "stdafx.h"
using namespace boost;

//客户端类
class Target
{
public:
	Target(){}
	virtual ~Target(){}
	
	//该接口用于适配其他类的接口函数
	virtual void requireFunc()
	{
		std::cout << "Client Func" << std::endl;
	}
};

//受适配者类
class Adaptee
{
public:
	Adaptee(){}
	virtual ~Adaptee(){}

	void func1()
	{
		std::cout << "Adaptee executed Func1" << std::endl;
	}

	void func2()
	{
		std::cout << "Adaptee executed Func2" << std::endl;
	}
};

//适配器1类
class AdapterFunc1 : public Target,private Adaptee
{
public:
	AdapterFunc1(){}
	virtual ~AdapterFunc1(){}

	void requireFunc()
	{
		//_m_ptrAdaptee->func1();
		this->func1();
	}
};

//适配器2类
class AdapterFunc2 : public Target,private Adaptee
{
protected:
public:
	AdapterFunc2(){}
	virtual ~AdapterFunc2(){}

	void requireFunc()
	{
		this->func2();
	}
};

void testAdapterOfClass()
{
	shared_ptr<AdapterFunc1> adapterFun1(new AdapterFunc1());
	shared_ptr<AdapterFunc2> adapterFun2 = make_shared<AdapterFunc2>();

	adapterFun1->requireFunc();
	adapterFun2->requireFunc();
}

上面这种实现的适配器称为类适配器，因为 Adapter 类既继承了 Adaptee （被适配类），也实现了 Target 接口（因为 Java 不支持多继承，所以这样来实现），在 Client 类中我们可以根据需要选择并创建任一种符合需求的子类，来实现具体功能。

另外一种适配器模式是对象适配器，它不是使用多继承或继承再实现的方式，而是使用直接关联，或者称为委托的方式，类图如下：

 

代码实现如下：

2.以下是对象的适配器模式:

#include "stdafx.h"
#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>

using namespace boost;

//客户端类
class Target
{
public:
	Target(){}
	virtual ~Target(){}

	//该接口用于适配其他类的接口函数
	virtual void requireFunc()
	{
		std::cout << "Client Func" << std::endl;
	}
};

//受适配者类
class Adaptee
{
public:
	Adaptee(){}
	virtual ~Adaptee(){}

	void func1()
	{
		std::cout << "Adaptee executed Func1" << std::endl;
	}

	void func2()
	{
		std::cout << "Adaptee executed Func2" << std::endl;
	}
};

//适配器1
class Adapter1 : public Target
{
private:
	shared_ptr<Adaptee> _m_ptrAdaptee;
public:
	Adapter1(shared_ptr<Adaptee> adaptee):_m_ptrAdaptee(adaptee){}
	virtual ~Adapter1(){}

	void requireFunc()
	{
		_m_ptrAdaptee->func1();
	}
};

//适配器2
class Adapter2 : public Target
{
private:
	shared_ptr<Adaptee> _m_ptrAdaptee;
public:
	Adapter2(shared_ptr<Adaptee> adaptee):_m_ptrAdaptee(adaptee){}
	virtual ~Adapter2(){}

	void requireFunc()
	{
		_m_ptrAdaptee->func2();
	}
};

void testAdapterOfObject()
{
	auto adaptee = make_shared<Adaptee>();
	auto adapter1 = make_shared<Adapter1>(adaptee);
	auto adapter2 = make_shared<Adapter2>(adaptee);
	adapter1->requireFunc();
	adapter2->requireFunc();
}