Adapter(适配器）-类对象结构型模式

1.意图

将一个类接口转换成客户希望的另外一个接口。Adapter模式使那些原本不能一起工作的类，可以一起工作。

2.别名

包装器 Wrapper.

3.动机

一个应用可能会有一些类具有不同的接口，并且这些接口互不兼容，可以专门定义一个类，用来适配互不兼容的类。

4.适用性

• 你想使用一个已经存在的类，而它的接口不符合你的需求。
• 你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类协同工作。
• 你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。

5.结构

6.代码实例

1.对象适配器

class Adaptee
{
public:
    void SpecificRequest();
};

class Target
{
public:
    virtual void Request()=;
    virtual void Initilaize()=;
};

#include "Target.h"
#include <memory>
class Adaptee;

class Adapter : public Target
{
public:
    void Request();
    void Initilaize();
    std::shared_ptr<Adaptee> m_pAdaptee;
};

#include <iostream>
#include "Adaptee.h"

void Adaptee::SpecificRequest()
{
    std::cout << "SpecificRequest" << std::endl;
}

#include "Adaptee.h"
#include "Adapter.h"

void Adapter::Request()
{
    m_pAdaptee->SpecificRequest();
}

void Adapter::Initilaize()
{
    m_pAdaptee = std::shared_ptr<Adaptee>(new Adaptee);
}

#include "Adapter.h"

int main()
{
    std::shared_ptr<Adapter> pAdapter(new Adapter);
    std::shared_ptr<Target> pTarget = std::dynamic_pointer_cast<Target>(pAdapter);
    pTarget->Initilaize();
    pTarget->Request();

    while();
}

测试结果：

2.类适配器

#include "Target.h"
#include "Adaptee.h"

class AdapterClass : public Target,private Adaptee
{
public :
    void Request();
    void Initilaize();
};

以上代码为类适配器，公有继承Target，私有继承Adaptee，即只继承Adaptee的实现，不继承其接口。

#include "AdapterClass.h"

void AdapterClass:: Request()
{
    SpecificRequest();
}
void  AdapterClass::Initilaize()
{
}

以上为类适配器的实现，在Request中调用Adaptee的SpecifiRequest。

#include "Adapter.h"

int main()
{
    std::shared_ptr<Adapter> pAdapter(new Adapter);
    //std::shared_ptr<Target> pTarget = std::dynamic_pointer_cast<Target>(pAdapter);
    //pTarget->Initilaize();
    pAdapter->Request();

    while();
}

测试代码，直接调用Adapter的Request从而能够达到目的。

7.效果

类适配器：

• 用一个具体的Adapter类对Adaptee和Target进行匹配。结果是当我们想要匹配一个类以及所有它的子类时，类Adapter将不能工作。
• 使得Adapter可以重定义Adaptee的部分行为，因为Adapter是Adaptee的一个子类。
• 仅仅引入了一个对象，并不需要额外的指针以间接得到Adaptee.

对象适配器：

• 允许一个Adapter同时与多个Adaptee同时工作。
• 使得重定义Adaptee的行为比较困难。