bridge模式主要用于将抽象和行为进行解耦，使两者可以独立变化。
主要应用在以下场合：
- 存在相对并列的子类属性。
- 存在概念上的交叉。
- 可变性。
如果不使用bridge模式，抽象和行为的多种组合将导致子类爆炸问题。使用bridege模式，我们
设计两个接口：抽象接口和行为接口，在抽象接口里面保存行为接口的指针，通过设置不同的
行为实现类，使对象程序不同行为。
代码：
// 维护一个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()
{
delete m_pImplementor;
m_pImplementor = NULL;
}

void Abstraction::Operation()
{
m_pImplementor->OperationImpl();
}
----------------------------------------------------------------------
client调用：
        ConcreateImplementorA *pImplA = new ConcreateImplementorA();
Abstraction *pAbstraction1 = new Abstraction(pImplA);
pAbstraction1->Operation();

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