设计模式之结构型模式

结构型模式（隔离变化，封装变化：对象之间的解耦）

适配器模式：

适配器作用：
一个接口不能使用是，采用另外一个接口
适配器定义：
将一个类的接口转换成客户希望的另外一个接口这样使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
分类：
类适配器：原理:类适配器用多重继承实现，并且提供适配后的接口。
对象适配器:对象适配器是将需要适配的对象进行包装然后提供适配后的接口。
两者区别：
对象适配器构造的时候将具体需要适配的适配对象传入，这样便可以根据传入不同的对象，从而对该对象进行适配。
类适配器无法选择对象，他是对在整个类进行适配，也就是把所有的三相插口全部转换为两相的，而不是针对某一个。

#include <iostream>

using namespace std;

// 手机电压 5v
class current5V
{
public:
	virtual void use5v() = 0;
	
};


// 家庭用电  220v
class current220v
{
public:
	void use220v()
	{
		cout << "使用 220v 电压" << endl;
	}
	
};

class Adapte  : public current220v, public current5V
{
public:
		void use5v()
		{
			cout << "正在讲220v转成5v" << end;
			use220v();
			cout << "以转成5V" << endl;
		}
};


int main()
{
	current5V *p = new Adapte();
	
	p->use5v();
	
	
	current220v *p2 = new current220v();
	
	
	p2->use220v();
	
	
	
	return 0;
}
// 适配器，将 220v 电压转换成 5v
class Adapte : public current5V
{
public:
	Adapte (current220v *c220v)
	{
		this->c220v = c220v;
	}
public:
	void use5v()   // 要用的电压是 5v
	{
		// 实际用的 220v , 要进行转换成 5v		
		c220v->use220v();
		cout << "将220v 电压 转换成 5v 使用" << endl;
		
	}
private:
	current220v *c220v;
};

int main4()
{
	current220v *c220v = new current220v;
	current5V *c5v = new Adapte(c220v);
	c5v->use5v();


    return 0;
}

外观模式：

外观模式定义：
提供了一个统一的接口，用来访问子系统的一群接口。外观定义了一个高层接口，让子系统更容易使用。
外观模式作用：
简化你的类的接口，将一系列的复杂的过程封装到内部，对外值提供最简单的接口。
角色：
Facade（外观角色）：在客户端可以调用它的方法，在外观角色中可以知道相关的（一个或者多个）子系统的功能和责任。
SubSystem（仔细用角色）：在软件系统中可以有一个或者多个子系统角色，每一个子系统可以不是一个单独的类，而是一个类的集合，它实现子系统的功能。

#include <iostream>
using namespace std;

class Carmera {
public:
	void turnOn() {
		cout << "相机启动" << endl;
	}
	void turnOff() {
		cout << "相机关闭" << endl;
	}
};

class Light {
public:
	void turnOn() {
		cout << "照明灯开启" << endl;
	}
	void turnOff() {
		cout << "照明灯关闭" << endl;
	}
};
class Sensor {
public:
	void active() {
		cout << "传感器启动" << endl;
	}
	void deactive() {
		cout << "传感器关闭" << endl;
	}
};

class Alarm {
public:
	void active() {
		cout << "报警器启动" << endl;
	}
	void deactive() {
		cout << " 报警器关闭" << endl;
	}
};

class SecuritFacade {
public:
	SecuritFacade() {
		Carmera* m_pCarmera = new Carmera;
		Light* m_pPLight = new Light;
		Sensor* m_pSensor = new Sensor;
		Alarm* m_pAlaram = new Alarm;
	}
	void active() {
		m_pCarmera->turnOn();
		m_pPLight->turnOn();
		m_pSensor->active();
		m_pAlaram->active();
	}
	void deactive() {
		m_pCarmera->turnOff();
		m_pPLight->turnOff();
		m_pSensor->deactive();
		m_pAlaram->deactive();
	}
private:
	Carmera* m_pCarmera;
	Light* m_pPLight ;
	Sensor* m_pSensor ;
	Alarm* m_pAlaram ;
};
//LOD
int main() {
	SecuritFacade facade;
	

	cout << "-----------启动系统" << endl;
	facade.active();
	//
	cout << "----------关闭系统" << endl;
	facade.deactive();
	system("pause");
	return 0;
}

代理模式：（适用于智能指针）
定义：为其他对象在客户端和目标对象之间起到中介的作用。
角色：
Subject：抽象角色。声明真实对象和代理对象的共同接口。
Proxy：代理角色。代理对象与真实对象实现实现相同的接口，所以它能够在任何时刻都能够代理真实对象。
RealSubject：真实角色。它代表着真实对象，是我们最终要引用的对象。

#include <iostream>

using namespace std;

class Subject
{
public:
    virtual void saleBook() = 0;
};

class BookStore : public Subject
{
public:
    void saleBook()
    {
        cout << "书店买书" << endl;
        count++;
    }
private:
    string book[100];
    int count = 0;
};

class BookStore2 : public Subject
{
public:
    void saleBook()
    {
        cout << "书店买书" << endl;
        count++;
    }
private:
    string book[200];
    int count = 0;
};


class TaoBao : public Subject
{
public:

    TaoBao(Subject *s)
    {
        this->s = s;
    }

    void saleBook()
    {
        discount();
        s->saleBook();
    }

    void discount()
    { 
        cout << "打五折" << endl; 
    }

    Subject *s;
};


class JD : public Subject
{
public:

    JD(Subject *s)
    {
        this->s = s;
    }

    void saleBook()
    {
        discount();
        s->saleBook();
    }

    void discount()
    { 
        cout << "打四折" << endl; 
    }

    Subject *s;
};



int main()
{
    // BookStore *b = new BookStore();
    // b->saleBook();

    BookStore *b  =new BookStore();
    Subject *s  = new TaoBao(b);
    Subject *s2 = new Subject(b);
    s->saleBook();
    s2->saleBook();
    
    return 0;
}

包装模式：
定义：
以透明的方式来动态扩展对象的功能，也是继承关系的一种代替方案。（合成复用原则：组合大于继承）
角色：
Component：抽象组件（可以是抽象类或者接口），被装饰的原始对象。
ConcreteComponent：具体实现类，被装饰的具体对象。
Decorator：抽象装饰者，职责就是为了装饰我们的组件对象，内部一定要有一个指向组件对象的引用。
ConcreteDecoratorA/B：装饰者具体实现类，只对抽象装饰者做出具体实现。
桥接模式：
定义：将抽象部分与它实现部分分离，使它们都可以独立的变化。
作用：一维扩展用继承，多维扩展用桥接。
角色：
Abstraction：抽象部分
RefinedAbstraction：优化的抽象部分
Implementor：实现部分
ConcreteImplementor/ConcreteImplementorB：实现部分的具体实现。
适用场景：
一个类存在两个独立变化的维度，且这两个维度都需要进行扩展。
对于那些不希望使用继承或因为多层次继承导致系统类的个数几句增加的系统，桥接模式尤为适用。

#include <iostream>
using namespace std;
//
//class Computer {
//public:
//	void run();
//};
//
//class HpWindows7 :public Computer {
//
//};
//class HpWindow8 :public Computer {
//
//};
//
//class HpWindowsX :public Computer {
//
//};

class IOS {
public:
	IOS(){}
	virtual ~IOS()
	{

	}
	virtual void run() = 0;
};

class CWindows :public IOS {
public:
	virtual void run() {
		cout << "Windows 正在运行" << endl;
	}
};

class CLinux :public IOS {
public:
	virtual void run() {
		cout << "Linux 正在运行" << endl;
	}
};

class IComputer {
public:
	virtual void Install(IOS *pOS) = 0;
};

class CLenvo :public IComputer {
public:
	virtual void Install(IOS *pOS) {
		cout << "Lenvo正在安装操作系统" << endl;
		pOS->run();
	}
};

class CDell :public IComputer {
public:
	virtual void Install(IOS *pOS) {
		cout << "Dell正在安装操作系统" << endl;
		pOS->run();
	}
};

class CAcer:public IComputer
{
public:
public:
	virtual void Install(IOS *pOS) {
		cout << "Acer正在安装操作系统" << endl;
		pOS->run();
	}

private:

};





int main(void) {
	IOS* pWindows = new CWindows;
	IOS* pLinux = new CLinux;

	IComputer* pLenvo = new CLenvo;
	pLenvo->Install(pWindows);
	system("pause");
	return 0;
}

桥接模式和包装模式
装饰模式是适应新需求的不断增加的一种模式。
桥接模式是适应多个维度变化的一种模式。