Bridge（桥）模式

背景：
在软件组件设计中，如果责任划分不清晰，使用继承得到结果往往是随着需求发生变化，子类膨胀，同时充斥着代码，这个时候关键是划清责任。
由于某些类型固有的实现逻辑，使得它们具有两个变化的维度，乃至多个维度的变化。
实现方法：
将抽象部分（业务功能）与实现部分（平台实现）分离，使得它们可以独立变化。
应用于：
Bridge模式的应用一般在“两个非常强的变化维度”，有时一个类也多于两个变化维度，这时候用Bridge的扩展模式。
缺点：
Bridge模式有时候类似于多继承方案，但是多继承方案往往违背单一职责（即一个类只有一个变化的原因），复用性比较差。Bridge模式是比多继承方案更好的解决方法。
优点：Bridge模式使用“对象间的组合关系”解耦合了抽象和实现之间固有的绑定关系，使得抽象和实现可以沿着各自维度的变化，即“子类化”它们。

代码实现如下：
Realise.h

#pragma once
class Realise {
public:
	virtual ~Realise();
	virtual void operation() = 0;
protected:
	Realise();
};
class RealiseAbstractionA :public Realise {
public:
	virtual void operation();
	RealiseAbstractionA();
	~RealiseAbstractionA();
};
class RealiseAbstractionB :public Realise {
public:
	virtual void operation();
	RealiseAbstractionB();
	~RealiseAbstractionB();
};

Realise.cpp

#include"Realise.h"
#include
using namespace std;
Realise::Realise() {

}
Realise::~Realise() {

}
RealiseAbstractionA::RealiseAbstractionA() {

}
RealiseAbstractionA::~RealiseAbstractionA() {

}
void RealiseAbstractionA::operation() {
	cout << "实现抽象A实现" << endl;
}
RealiseAbstractionB::RealiseAbstractionB() {

}
RealiseAbstractionB::~RealiseAbstractionB() {

}
void RealiseAbstractionB::operation() {
	cout << "实现抽象B实现" << endl;
}

Abstracion.h

#pragma once
class Realise;
class Abstraction {
public:
	virtual void operation() = 0;
	virtual ~Abstraction();
protected:
	Abstraction();
};
class RedefinedAbstraction : public Abstraction {
public:
	RedefinedAbstraction(Realise* realise);
	void operation();
	~RedefinedAbstraction();
private:
	Realise* realise;
};

Abstraction.cpp

#include"Abstract.h"
#include"Realise.h"
#include
using namespace std;

Abstraction::Abstraction() {

}
Abstraction::~Abstraction() {

}
RedefinedAbstraction::RedefinedAbstraction(Realise* realise) {
	this->realise = realise;
}
RedefinedAbstraction::~RedefinedAbstraction() {

}
void RedefinedAbstraction::operation() {
	realise->operation();
}

Main.cpp

#include"Abstract.h"
#include"Realise.h"
#include

int main() {
	Realise* realA = new RealiseAbstractionA();
	Abstraction* ab = new RedefinedAbstraction(realA);
	ab->operation();
	Realise* realB = new RealiseAbstractionB();
	Abstraction* abs = new RedefinedAbstraction(realB);
	abs->operation();
	return 0;
}

运行结果图