结构型设计---适配器模式

适配器

定义：

提供给客户（暂定为client）的接口（接口类定为target）不能满足功能。

但是客户端的内容不希望变化，通过重写target， 完成功能迁移-》适配。

引入一个适配者类和适配器类。其中适配者类为clien类的子类，

通过适配者引入适配器完成新功能。保持对外提供的类的接口不变化。

优点：

1、解耦、对外透明、灵活性好。通过配置文件可以灵活引入。

2、一个适配者可以引入多个适配器。灵活。

对象适配器：

 

类适配器：

 

两个实现Demo

demo1：

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

using namespace std;


int main(int argc, char *argv[])
{
    Adaptee* adaptee = new Adaptee();
    //不改变Target 重写Target
    Target* tar = new Adapter(adaptee);

    tar->requst();

}

///
//    Adapter.h
//
///

#ifndef __ADAPTER_H__
#define __ADAPTER_H__

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

class Adapter : public Target{

//不改变原接口的前提，重写方法
    public:
        Adapter(Adaptee* adaptee){};
        virtual ~Adapter(){};

        virtual void requst();

    private:
        Adaptee* m_padaptee;
};



#endif

/
//Adapter.cpp
//


#include "Adapter.h"

Adapater::Adapter(Adaptee* adaptee){
       m_adaptee = adaptee;
}

Adapter::~Adapter(){};
void Adapter::request(){
    //通过适配者方法，引入适配器的方法实现
    m_adaptee->specifiRequest();
}

//
//Adaptee.h


#ifndef __ADAPTEE_H__
#define __ADAPTEE_H__

class Adaptee {

    Adaptee(){
    };
    virtual ~Adaptee(){
    };

    void sepcifiRequest();

};

#endif

demo2

#ifndef __ADAPTER_PATTERN_H
#define __ADAPTER_PATTERN_H

#include <iostream>
#include <string.h>
#include <mutex>

using namespace std;

//目标者类

class Target{
public:
    Target(){};
    virtual ~Target(){};
    virtual void pathPlanning() = 0; //纯虚函数
private:

};

//适配器类1 适配器完成新功能1

class Adapteeone
{
    Adapteeone(){
    };
    ~Adapteeone(){};
    void onetest1(){
    printf("onetest1\n");
    }

}

//适配器类2 适配器完成功能2 

class Adapteetwo
{
    Adapteetwo(){};
    ~Adaptetwto(){};
    void twotest2(){
    printf("twptest2\n");
    }
    
}

//通过适配者类完成适配器功能和目标功能的链接。
class Adapter : public Target{
    public:

    Adapter(){
        //完成适配器的初始化，或者直接以参数形式初始化
        adapteeone = new Adapterone();
        daptertwo = new Adaptertwo();

    };
    
    virtual ~Adapter(){};
    
    void pathPlanning(){
        //狸猫换太子
        adapteeone->onetest1();
        adapteetwo->twotest2();

    }

    private:
    Adapteeone* adapteeone;
    Adapteetwo* adapteewtwo;

}


#endif

///
//main.cpp
//
///

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

int main()
{
    //在创建目标类的时候进行替换重新的适配器
    Target* tar = new Adapter();
    
    tar->pathPlanning();
    delete tar;
    return 0;

    
}