定义：将抽象部分与它的实现部分分享，使它们都可以独立地变化。
可以分析变化的各类，将不变的框架使用抽象类定义出来，然后再将变化的内容使用具体的子类来分别实现。这样面向客户的只是一个抽象类，这种方式可以较好的避免为抽象类中现有接口添加新的实现所速写的影响，缩小了变化带来的影响。
组成：
1.抽象角色（Abstraction）：它定义了抽象类的接口而且维护着一个指向实现(Implementor)角色的引用。
2.精确抽象（RefinedAbstraction）角色：实现并扩充由抽象角色定义的接口。
3.实现（Implementor）角色：给出了实现类的接口，这里的接口与抽象角色中的接口可以不一致。
4.具体实现(ConcreteImplementor)角色：给出了实现角色定义接口的具体实现。
//抽象角色
class Abstraction{

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

 void Operation()
{
   pImplementor->OperationImpl();
}

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 main()
{
   Implementor* pImplementor = new ConcreateImplementorA();
   Abstraction* pAbstraction = new Abstraction(pImplementor);
  pAbstraction.Operation();
   delete *pImplementor;
  delete *pAbstraction ;
}
//感觉桥梁模式主要也是一个抽象类，然后抽象类中的方法是由它维护着的另一个抽象类指针所调用的接口方法。具体调用哪个方法要看实例化哪个派生类的指针才行。