Bridge 模式

Bridge 模式将抽象和行为划分开来,各自独立,但能动态的结合。在面向对象设计的基本概念中，对象这个概念实际是由属性和行为两个部分组成的，属性我们可以认为是一种静止的，是一种抽象，一般情况下，行为是包含在一个对象中，但是，在有的情况下，我们需要将这些行为也进行归类，形成一个总的行为接口，这就是桥模式的用处。

 ///////////////Abstraction.h/////////////
 #pragma once
 class AbstractionImp ;
 class Abstraction
 {
 public:
     virtual ~Abstraction();
     virtual void Operation() =  ;
 protected:
     Abstraction();
 private:
 };

 class RefinedAbstraction : public Abstraction
 {
 public:
     ~RefinedAbstraction();
     RefinedAbstraction();
     RefinedAbstraction(AbstractionImp* imp);
     void Operation();
 protected:
 private:
     AbstractionImp* _imp ;
 };

///////////////Abstraction.cpp/////////////
#include "Abstraction.h"
#include "AbstractionImp.h"
Abstraction::~Abstraction()
{

}
Abstraction::Abstraction()
{

}
void Abstraction::Operation()
{

}

RefinedAbstraction::~RefinedAbstraction()
{

}
RefinedAbstraction::RefinedAbstraction()
{

}
RefinedAbstraction::RefinedAbstraction(AbstractionImp* imp)
{
    _imp = imp ;
}
void RefinedAbstraction::Operation()
{
    _imp->Operation();
}

 ///////////////AbstractionImp.h/////////////
 #pragma once
 class AbstractionImp
 {
 public:
     virtual ~AbstractionImp();
     virtual void Operation() = ;

 protected:
     AbstractionImp();
 private:
 };

 class ConcreteAbstractionImpA : public AbstractionImp
 {
 public:
     ~ConcreteAbstractionImpA();
     ConcreteAbstractionImpA();
     void Operation();
 protected:
 private:
 };

 class ConcreteAbstractionImpB : public AbstractionImp
 {
 public:
     ~ConcreteAbstractionImpB();
     ConcreteAbstractionImpB();
     void Operation();
 protected:
 private:
 };

 ///////////////AbstractionImp.cpp/////////////
 #include "AbstractionImp.h"
 #include <iostream>
 using namespace std;
 AbstractionImp::~AbstractionImp()
 {

 }
 AbstractionImp::AbstractionImp()
 {

 }
 void AbstractionImp::Operation()
 {

 }
 ConcreteAbstractionImpA::~ConcreteAbstractionImpA()
 {

 }
 ConcreteAbstractionImpA::ConcreteAbstractionImpA()
 {

 }
 void ConcreteAbstractionImpA::Operation()
 {
     cout<<"ConcreteAbstractionImpA...."<<endl;
 }

 ConcreteAbstractionImpB::~ConcreteAbstractionImpB()
 {

 }
 ConcreteAbstractionImpB::ConcreteAbstractionImpB()
 {

 }
 void ConcreteAbstractionImpB::Operation()
 {
     cout<<"ConcreteAbstractionImpB...."<<endl;
 }

 ///////////////main.cpp/////////////
 #include "Abstraction.h"
 #include "AbstractionImp.h"
 #include <iostream>
 using namespace std ;
 int main()
 {
     AbstractionImp* impA = new ConcreteAbstractionImpA();
     Abstraction* abs = new RefinedAbstraction(impA);
     abs->Operation();
     system("pause");
     return ;
 }