设计模式：Bridge（桥接）模式

Bridge模式：桥接模式

模式概述：

低耦合和高内聚一直是面向对象设计所追求的重要目标。

耦合性：也称块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块的独立性则越差。模块间耦合高低取决于模块间

接口的复杂性、调用的方式及传递的信息

内聚性：又称块内联系。指模块的功能强度的度量，即一个模块内部各个元素彼此结合的紧密程度的度量。若一个模块内各元素（语名之间、程序段之间）联系的越紧密，则它的内聚性就越高。

所谓高内聚是指一个软件模块是由相关性很强的代码组成，只负责一项任务，也就是常说的单一责任原则。

耦合：一个软件结构内不同模块之间互连程度的度量。

对于低耦合，粗浅的理解是：一个完整的系统，模块与模块之间，尽可能的使其独立存在。也就是说，让每个模块，尽可能的独立完成某个特定的子功能。模块与模块之间的接

口，尽量的少而简单。如果某两个模块间的关系比较复杂的话，最好首先考虑进一步的模块划分。这样有利于修改和组合。

而桥接模式的目的就是为了将一组实现与另一组使用它们的对象分离。实现解耦。解耦是指让各种事物相互独立的行事，或者至少明确的声明之间的关系。

Bridge 的关键特征：

意图：将一组实现与另一组使用它们的对象分离。

问题：一个抽象类的派生类必须使用多个实现，但是不能出现类数量爆炸性增长。

解决方案：为所有实现定义一个接口，供抽象类的所有派生类使用。Abstraction为要实现的对象定义接口。Impmentor为具体实现类定义接口。Abstraction的派生类使用Impmentor的派生类。却无需知道自己具体使用哪一个ConcreteImplementor。

实现：

Bridge.h

#ifndef BRIDEG_H
#define BRIDEG_H

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

	virtual void OperationImpl() = 0;
};

class ConcreateImplementorA: public Implementor
{
public:
	ConcreateImplementorA(){}
	virtual ~ConcreateImplementorA(){}

	virtual void OperationImpl();
};


class ConcreateImplementorB: public Implementor
{
public:
	ConcreateImplementorB(){}

	virtual ~ConcreateImplementorB(){}

	virtual void OperationImpl();
};

class Abstraction
{
public:
	Abstraction(Implementor* pImplementor);
	virtual ~Abstraction();

	 void Operation();

protected:
	Implementor* m_pImplementor;
};

class RefinedAbstraction:public Abstraction
{
public:
	RefinedAbstraction(Implementor* imple);

	RefinedAbstraction();
    ~RefinedAbstraction();
};
#endif

Bridge.cpp

#include "Bridge.h"
#include <iostream>
using namespace std;

void ConcreateImplementorA::OperationImpl()
{
	std::cout << "Implementation by ConcreateImplementorA\n";
}

void ConcreateImplementorB::OperationImpl()
{
	std::cout << "Implementation by ConcreateImplementorB\n";
}

Abstraction::Abstraction(Implementor* pImplementor): m_pImplementor(pImplementor)
{
}

Abstraction::~Abstraction()
{
	delete m_pImplementor;
	m_pImplementor = NULL;
}

void Abstraction::Operation()
{
	m_pImplementor->OperationImpl();
}

RefinedAbstraction::RefinedAbstraction(Implementor* imple) :Abstraction(imple)
{

}
RefinedAbstraction::~RefinedAbstraction()
{

}

Main.cpp

#include "Bridge.h"
#include <stdlib.h>

int main()
{
	ConcreateImplementorA *pImplA = new ConcreateImplementorA();

	Abstraction *pAbstraction1 = new RefinedAbstraction(pImplA);

	pAbstraction1->Operation();

	ConcreateImplementorB *pImplB = new ConcreateImplementorB();

	Abstraction *pAbstraction2 = new RefinedAbstraction(pImplB);
	pAbstraction2->Operation();

	delete pAbstraction1;
	delete pAbstraction2;

	system("pause");

	return 0;
}

总结：

Bridge模式需要遵循如下应对变化的基本策略：

1.招到变化并封装之。

2.优先使用对象聚集而不是类继承。