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.優先使用物件聚集而不是類繼承。