设计模式之适配器模式

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

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

总结

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

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