设计模式之适配器模式

在上篇博文中，我们系统地讲述了策略模式，策略模式整体来说应该比较简单，其思想也是很容易弄懂，今天我们再来学习下另外一个模式——适配器模式，适配器模式的定义：适配器模式将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。怎么来讲呢，其实理解它也不难，这个模式有点类似我们日常生活中的“翻译”角色，一般都有一个充当适配功能的角色，再明白一点就是：就是与笔记本电源适配器、手机充电器有点类似，好了，说了这些，下面试试几个有意思的代码吧，代码如下：

1）翻译实例

#ifndef __ADPATER__H
#define __ADPATER__H

#include <iostream>
#include <boost/smart_ptr.hpp>
using namespace std;
using namespace boost;

class Translator
{
public:
virtual void speaker() = 0;
};

class ChineseTranslator : public Translator
{
public:
void speaker()
{
cout<<"chinese speaker hello"<<endl;
}
};
class JapanTranslator : public Translator
{
public:
void speaker()
{
cout<<"Japan speaker hello"<<endl;
}
};
class AmericanTranslator : public Translator
{
public:
void speaker()
{
cout<<"American speaker hello"<<endl;
}
};
template<class T>
class Speaker
{
public:
Speaker()
{
adeptee = shared_ptr<T>(new T());
}
void speaker()
{
adeptee->speaker();
}
private:
shared_ptr<T> adeptee;
};
#endif
#include "Adapter.h"

int main()
{
Speaker<ChineseTranslator> chineseTranslator;
Speaker<JapanTranslator> japanTranslator;
Speaker<AmericanTranslator> usTranslator;

chineseTranslator.speaker();
japanTranslator.speaker();
usTranslator.speaker();
}

在目标对象中，有一个被称之为“翻译者”的对象，目标对象所有的操作都是以这个翻译者对象基础，写到这里，突然感觉感觉适配器模式有点像之前所说的策略模式，确实有点像，在这里要注意区分，在策略模式里是由用户选择算法，而在适配器里面不存在用户选算法的过程，而是将目标对象转为适配器对象的相关操作，好了，接下来，我们就来实现几个简单的算法题吧，（用两个stack来模拟一个队列和用两个队列来模拟一个stack），代码如下：

1）两个stack模拟一个queue

#ifndef __STACK_QUEUE__H
#define __STACK_QUEUE__H

#include <iostream>
#include <vector>
#include <stack>

using namespace std;

template<class T>
class StackQueue
{
public:
StackQueue()
{
}
~StackQueue(){}

int size() const
{
return front.size() + end.size();
}

void enQueue(const T& element)
{
end.push(element);
}

T deQueue()
{
if(front.size() > 0)
{
T elem = front.top();
front.pop();
return elem;
}
else
{
while(end.size()>0)
{
front.push(end.top());
end.pop();
}
T elem = front.top();
front.pop();
return elem;
}
}
void showAll()
{
while(size() > 0)
{
cout<<deQueue()<<" ";
}
cout<<endl;
}
private:
stack<T> front;
stack<T> end;
};
#endif
#include "StackQueue.h"

int main()
{
StackQueue<int> stackQueue;
for(int i=1;i<=10;i++)
stackQueue.enQueue(i);
cout<<stackQueue.deQueue()<<endl;
cout<<stackQueue.deQueue()<<endl;

stackQueue.enQueue(100);
stackQueue.enQueue(200);

stackQueue.showAll();
return 0;
}

测试结果：

1

2

3 4 5 6 7 8 9 10 100 200

2）两个队列模拟一个栈

#ifndef __QUEUE_STACK__H
#define __QUEUE_STACK__H

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

template<class T>
class QueueStack
{
public:
QueueStack(){}
~QueueStack(){}
int size()
{
return front.size() + end.size();
}
void push(T element)
{
while(end.size() > 0)
{
front.push(end.front());
end.pop();
}
front.push(element);
}

T pop()
{
T elem;
while(front.size() > 1)
{
end.push(front.front());
front.pop();
}

if(front.size()==1)
{
elem = front.front();
front.pop();
}

while(end.size() > 0)
{
front.push(end.front());
end.pop();
}
return elem;
}

void showAll()
{
while(size() > 0)
{
cout<<pop()<<" ";
}
cout<<endl;
}

private:
queue<T> front;
queue<T> end;
};
#endif
#include "QueueStack.h"

int main()
{
QueueStack<int> queueStack;
for(int i=1;i<10;i++)
queueStack.push(i);

cout<<queueStack.pop()<<endl;
cout<<queueStack.pop()<<endl;

queueStack.push(100);
queueStack.push(200);
queueStack.showAll();
return 0;
}

测试结果：

9

8

200 100 7 6 5 4 3 2 1

总结

本篇博文主要分析了下设计模式中的适配器模式，这种模式其实就类似与一个转接口，所有的操作都会被其封装的目标对象代替之，这种模式最大的好处就是很好的实现了封装思想，并且在文章的后半部分我们实现了两个案例，都是比较简单的，其思想就采用了适配器模式，这部分内容还是很简单的，但是如果运用到实际的开发项目中，还得好好的思考下，好了，本篇博文到此结束，下篇博文我们继续分析设计模式之单例模式。

如果需要，请注明转载，多谢