转自：http://blog.csdn.net/fly542/article/details/6720217
原来对bridge模式理解不是很深入，感觉和build模式很相似，今天又看了四人帮的关于bridge模式的描述，有些新的理解
先来说下适用性
1、不想抽象和实现之间有一个固定的绑定关系。（因为程序在运行时实现部分可以被选择或者切换）。
2、类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。这时bridge模式使你可以对不同的抽象接口和实现部分进行组合，并分别对他们进行扩充。（常用）
3、对一个抽象的实现部分的修改应对客户不产生影响，即客户的代码不必重新编译。
4、你想对客户完全以藏抽象的实现部分。在c++中，类的表示在类接口中是可见的。
5、在多个对象间共享实现（可能是引用计数）， 但同时要求客户并不知道这一点。
还有一种方式没理解，书上是这么说的：正如在意图一节的类图中所示的那样，有许多类要生成。这样一种类层次结构说明你必须将一个对象分解城两个部分。这种层次结构为“嵌套的普化”（nestd generalizations）***
结构图如下
示例代码如下
- #include <QtCore/QCoreApplication>
- #include <iostream>
- class Implementor;
- // 维护一个Implementor类的指针
- class Abstraction
- {
- public:
- Abstraction(Implementor* pImplementor);
- virtual ~Abstraction();
- void Operation();
- protected:
- Implementor* m_pImplementor;
- };
- // 为实现Abstraction定义的抽象基类,定义了实现的接口函数
- class Implementor
- {
- public:
- Implementor(){}
- virtual ~Implementor(){}
- virtual void OperationImpl() = 0;
- };
- // 继承自Implementor,是Implementor的不同实现之一
- class ConcreateImplementorA
- : public Implementor
- {
- public:
- ConcreateImplementorA(){}
- virtual ~ConcreateImplementorA(){}
- virtual void OperationImpl();
- };
- // 继承自Implementor,是Implementor的不同实现之一
- class ConcreateImplementorB
- : public Implementor
- {
- public:
- ConcreateImplementorB(){}
- virtual ~ConcreateImplementorB(){}
- virtual void OperationImpl();
- };
- 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()
- {
- }
- void Abstraction::Operation()
- {
- m_pImplementor->OperationImpl();
- }
- template <typename deleteType>
- inline void deleteObject(const deleteType * obj)
- {
- delete obj;
- obj = 0;
- }
- int main(int argc, char *argv[])
- {
- QCoreApplication a(argc, argv);
- ConcreateImplementorA *pImplA = new ConcreateImplementorA();
- Abstraction *pAbstraction1 = new Abstraction(pImplA);
- pAbstraction1->Operation();
- ConcreateImplementorB *pImplB = new ConcreateImplementorB();
- Abstraction *pAbstraction2 = new Abstraction(pImplB);
- pAbstraction2->Operation();
- deleteObject(pImplB);
- deleteObject(pAbstraction2);
- deleteObject(pImplA);
- deleteObject(pAbstraction1);
- return a.exec();
- }
因为Adapter中包含了一个Adaptee对象，这是一个聚合或者组合的关系。而且也是在Adapter的request方法中调用了Adaptee对象中的方法，从这个角度而言，Adapter模式和Bridge模式是非常类似的。
但是，他们之间有本质的区别：
1. 在Adapter模式中，Adaptee本身往往已经是一个具体的、已经存在的类。在Bridge模式中，Implementor则是一个抽象类或者接口；
2. 在Adapter模式中，Adapter类也是一个具体的类。在Bridge模式中，Abstraction则是一个抽象类；
3. 在Adapter模式中，Adapter类派生于一个抽象类/接口(客户程序所期望的)。在Bridge模式中，Abstraction类则不存在这样的情况。
4. 最本质同时也是最重要的区别是，它们的意图是不同的。