C++ 设计模式-》适配器（Adapter）

文件 “F_DesignMode_Adapter_Test.h”

#ifndef F_DESIGN_MODE_ADAPTER_20171016_KJASHD_H_
#define F_DESIGN_MODE_ADAPTER_20171016_KJASHD_H_

/*
设计模式: Adapter适配器模式
http://blog.csdn.net/chenxun_2010/article/details/48383571

1. 作用：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作.
2. 分为 类适配器模式 和 对象适配器模式。
3. 系统的数据和行为都正确，但接口不符时，我们应该考虑使用适配器，目的是使控制范围之外的一个原有对象与某个接口匹配。
4. 适配器模式主要应用于希望复用一些现存的类，但是接口又与复用环境要求不一致的情况.
5. 想使用一个已经存在的类，但如果它的接口，也就是它的方法和你的要求不相同时，就应该考虑用适配器模式.
6. 比如购买的第三方开发组件，该组件接口与我们自己系统的接口不相同，或者由于某种原因无法直接调用该组件，可以考虑适配器.
*/

#if 1
//对象适配器模式
/*

例
在STL中就用到了适配器模式。
STL实现了一种数据结构，称为双端队列（deque），支持前后两段的插入与删除。
STL实现栈和队列时，没有从头开始定义它们，而是直接使用双端队列实现的。
队列用到了它的后端插入，前端删除。
而栈用到了它的后端插入，后端删除。
假设栈和队列都是一种顺序容器，有两种操作：压入和弹出。

Deque: 被适配的类(目标类, 供应商提供的类)
Sequence: 目标类(用户使用的类, 用来实现自己想要的操作)
Stack 和 Queue: 适配器(将Deque的操作, 封装修改后, 提供给Sqquence)
*/

//双端序列: 被适配的类(目标类, 供应商提供的类)
class Deque
{
public:
    void push_back(const int & nT);
    void push_front(const int & nT);

    void pop_back();
    void pop_front();
};

//目标类(用户使用的类, 用来实现自己想要的操作)
class Sequence
{
public:
    virtual void pop() = 0;
    virtual void push(const int & nT) = 0;
};

//适配器(将Deque的操作, 封装修改后, 提供给Sqquence)
//Stack: 先进后出, 后进先出
class Stack: public Sequence
{
public:
    void pop();
    void push(const int & nT);

private:
    Deque m_cDeque;
};

//适配器(将Deque的操作, 封装修改后, 提供给Sqquence)
//Queue: 先进先出, 后进后出
class Queue: public Sequence
{
public:
    void pop();
    void push(const int & nT);

private:
    Deque m_cDeque;
};

#endif

#endif//F_DESIGN_MODE_ADAPTER_20171016_KJASHD_H_

文件 “F_DesignMode_Adapter_Test.cpp”

#include "stdafx.h"
#include "F_DesignMode_Adapter.h"


void Deque::push_back(const int & nT)
{
    TRACE("Deque: push_back(%d)\n", nT);
}

void Deque::push_front(const int & nT)
{
    TRACE("Deque: push_front(%d)\n", nT);
}

void Deque::pop_back()
{
    TRACE("Deque: pop_back\n");
}

void Deque::pop_front()
{
    TRACE("Deque: pop_front\n");
}

void Stack::pop()
{
    TRACE("Stack: pop\n");
    m_cDeque.pop_back();
}

void Stack::push(const int & nT)
{
    TRACE("Stack: push(%d)\n", nT);

    m_cDeque.push_back(nT);
}

void Queue::pop()
{
    TRACE("Queue: pop\n");
    m_cDeque.pop_front();
}

void Queue::push(const int & nT)
{
    TRACE("Queue: push(%d)\n", nT);
    m_cDeque.push_front(nT);
}

测试文件 “F_DesignMode_Adapter_Test.h”

#ifndef F_DESIGN_MODE_ADAPTER_TEST_20171016_KJASHD_H_
#define F_DESIGN_MODE_ADAPTER_TEST_20171016_KJASHD_H_

#include "F_DesignMode_Adapter.h"

void F_DesignMode_Adapter_Test()
{
    Sequence *pQueue = new Queue;
    pQueue->push(5);
    pQueue->pop();

    delete pQueue;
    pQueue = NULL;

    Sequence *pStack= new Stack;
    pStack->push(5);
    pStack->pop();

    delete pStack;
    pStack = NULL;
}

#endif//F_DESIGN_MODE_ADAPTER_TEST_20171016_KJASHD_H_