C++ 大话设计之《桥接模式》（优缺点，设计原理，常用场景）

桥接模式是一种结构型设计模式。

---

优点：

• 可以将抽象和实现分离，使它们可以独立地变化。
• 可以提高类的可扩展性。
• 可以在运行时切换实现。

缺点：

• 桥接模式可能会增加系统的复杂性。
• 在使用桥接模式时，需要仔细设计抽象层和实现层的接口，以避免在未来修改接口时带来的问题。

满足的设计原理：

• 单一职责原则：桥接模式通过定义抽象层和实现层来实现单一职责原则。抽象层负责定义抽象接口，而实现层负责实现具体的功能。这样，当需要修改抽象层或实现层时，只需修改相应的类即可，而无需修改其他类。
• 开闭原则：桥接模式通过定义抽象层来实现开闭原则。当需要添加新的实现时，只需定义新的实现类并实现抽象层的接口即可。这样，客户端代码无需修改，就可以使用新的实现。
• 合成复用原则：桥接模式通过使用组合来实现合成复用原则。抽象层包含一个指向实现层对象的引用，而不是继承实现层的类。这样，当需要更换实现时，只需更换具体的实现类即可，而无需修改抽象层的代码。

使用情况：

• 当您希望避免抽象和实现之间的永久绑定时。
• 当您希望在多个维度上扩展一个类时。
• 当您希望在运行时切换实现时。
• 桥接模式通过定义一个抽象层来实现抽象和实现之间的解耦。抽象层定义了一个接口，用于访问实现层的对象。客户端代码只需依赖于抽象层，就可以访问实现层的对象。这样，当需要更换实现时，只需更换具体的实现类即可，而无需修改客户端代码。

开发中常用场景：

• 跨平台应用程序：桥接模式可以用于创建跨平台应用程序。例如，您可以定义一个抽象层，用于定义窗口、按钮和文本框等控件的抽象接口。然后，您可以定义多个实现层类，分别实现不同平台上的控件。这样，客户端代码只需依赖于抽象层，就可以在不同平台上创建控件。
• 数据库访问：桥接模式可以用于封装数据库访问。例如，您可以定义一个抽象层，用于定义连接、命令和数据读取器等对象的抽象接口。然后，您可以定义多个实现层类，分别实现不同数据库的访问。这样，客户端代码只需依赖于抽象层，就可以访问不同的数据库。
• 图形绘制：桥接模式可以用于封装图形绘制。例如，您可以定义一个抽象层，用于定义线条、矩形和圆形等图形对象的抽象接口。然后，您可以定义多个实现层类，分别实现不同绘图库的绘制。这样，客户端代码只需依赖于抽象层，就可以使用不同的绘图库。
• 桥接模式是一种结构型设计模式，它将抽象部分与实现部分分离，使它们可以独立地变化。桥接模式通过提供一个抽象层来实现这一点，该抽象层定义了一个接口，用于访问实现层的对象。

类图：

代码： 

#include "iostream"
#include "string"
#include <vector>
#include <mutex>

using namespace std;

class Implementor
{
public:
	virtual void OperationImpl()=0;
	virtual ~Implementor(){}
};

class ConcreteImplementorA:public Implementor
{
public:
	void OperationImpl()
	{
		cout << "ConcreteImplementorA operationImpl" << endl;
	};
	
};

class ConcreteImplementorB :public Implementor
{
public:
	void OperationImpl()
	{
		cout << "ConcreteImplementorB operationImpl" << endl;
	};

};

class Abstraction
{
public:
	virtual ~Abstraction(){};
	Abstraction(Implementor*implementor):implementor_(implementor){};
	virtual void operation()
	{
		implementor_->OperationImpl();
	}

private:
	Implementor *implementor_;
};

class RefinedAbstraction :public Abstraction
{
public:
	RefinedAbstraction(Implementor*implementor):Abstraction(implementor){}
	void operation()
	{
		cout<<"RefinedAbstraction operation"<<endl;
		Abstraction::operation();
	}

};

int main()
{
	Implementor*implementorA=new ConcreteImplementorA();
	Abstraction*abstractionA=new RefinedAbstraction(implementorA);
	abstractionA->operation();

	delete implementorA;
	delete abstractionA;

	return 0;
}