结构型 适配器模式

适配器模式(Adapter Pattern)：将一个类的接口转换成客户希望的另外一个接口，两个不兼容的接口之间的桥梁。（改变目标对象的接口了）

适配器模式

​ 增加一个中间接口，对目标接口和使用接口做一定的适配。

​ 例如：18V的接口，通过适配器实际调成220V

使用场景：

​ 一般使用在遗留代码的系统中。

​ 适配遗留代码和现在代码。

参考：C++实现设计模式——适配器(Adapter)模式_yxh_1_的博客-CSDN博客_c++ 适配器

代码demo:

如：把220v的电压适配到不同的电压去使用：

#include <iostream>
#include <string.h>
using namespace std;

//适配器的作用，使我们要用的接口满足目标使用接口
//例如：我们的电压通常使220v,但实际产品，有18v,22v等各种不同的电压，我们在用的时候，需要把220v通过适配转成满足的目标产品要求

//定义我们的220v电压接口 
class Current220v{
public:
	//基本的业务接口，如充电，放电等
	void charge(int i) {//相关业务等
		cout<<"use "<<i <<" v !"<<endl; 
	} 
};

//定义一个适配器，把220v的电压适配成不同的电压， 类似变压器的功能
class Adapter : public Current220v
{
	//适配 变成不同的电压接口
public:
	void use18v() {
		Current220v::charge(18);//这里其实使相关的业务，调用基类的业务接口，设置参数，调用基类接口
	}

	void use22v(){
		Current220v::charge(22);
	}

	void use220v(){
		Current220v::charge(220);
	}

	void useOtherV(){
		cout<<"use other v"<<endl;
	}
};

//定义一个基类，供使用的其他产品使用   使用客户提供的统一接口
class baseProduct{
public:
	baseProduct() {
		ad = new Adapter();
	}

	virtual ~baseProduct(){
		if(ad != nullptr)
		{
			delete ad;
			ad = nullptr;
		}
	}
public:
	virtual void use_voltage() = 0;
	Adapter * getAdaptor() { return ad;}
private:
	Adapter * ad;
};


//不同的产品 18v的产品
class useCurrent18v:public baseProduct
{
public:
    void use_voltage() override
    {
        baseProduct::getAdaptor()->use18v();
    }
};

//不同的产品 18v的产品
class useCurrent22v:public baseProduct
{
public:
    void use_voltage() override
    {
        baseProduct::getAdaptor()->use22v();
    }

};

//不同的产品 220v的产品
class useCurrent220v:public baseProduct
{
public:
    void use_voltage() override
    {
        baseProduct::getAdaptor()->use220v();
    }
};

void testuse18v(){
	useCurrent18v * use_18v = new useCurrent18v();
	use_18v->use_voltage();
	delete use_18v;
	use_18v = nullptr;
}

void testuse22v(){
	useCurrent22v * use_22v = new useCurrent22v();
	use_22v->use_voltage();
	delete use_22v;
	use_22v = nullptr;
}

void testuse220v(){
	useCurrent220v * use_220v = new useCurrent220v();
	use_220v->use_voltage();
	delete use_220v;
	use_220v = nullptr;
}

int main()
{
	//当不同的产品使用时 直接定义类，使用适配器统一接口
	testuse18v();
	testuse22v();
	testuse220v();
    return 0;
}

用不同的类型去使用适配不同的接口，或者而用虚基类来调用

#include <iostream>
#include <string.h>
using namespace std;

//适配器模式
//可以作为升级api，升级版本接口使用
//参考网址：https://blog.csdn.net/yxh_1_/article/details/116085949

//1:可以通过版本类型决定,适配器选择的版本的接口，感觉类似于桥接了
//2:可以通过继承的方式，使用最新的接口

enum VersionType{
    VersionOne,
    VersionTwo,
    VersionThree
};

class old_one_api{
    
    void use_api()
    {
        cout<<" one version api"<<endl;
    }
};

class old_two_api{
    void use_api()
    {
        cout<<" two version api"<<endl;
    }
};

class old_three_api{
    void use_api()
    {
        cout<<" three version api"<<endl;
    }
};

class adapter : public old_one_api, public old_two_api, public old_three_api
{
public:
    void use_version_api_by_type()
    {
        switch(m_type)
        {
            case VersionOne: old_one_api::use_api(); break;
            case VersionTwo: old_two_api::use_api(); break;
            case VersionThree: old_three_api::use_api(); break;
        }
        return;
    }

    void set_version_type(VersionType type)
    {
        m_type = type;
    }
public:
    VersionType m_type;
};

int main()
{
    //通过适配器 分别使用不同的版本
    adapter * ad = new adapter();
    //使用第一个版本：
    ad->set_version_type(VersionOne);
    ad->use_version_api_by_type();
    //使用第儿个版本：
    ad->set_version_type(VersionTwo);
    ad->use_version_api_by_type();
    //使用第三个版本：
    ad->set_version_type(VersionThree);
    ad->use_version_api_by_type();
    delete ad;
    return 0;
}