C++ Bridge 设计模式

C++ Bridge 设计模式

 

Bridge模式是应用最广泛也是我个人比较喜欢的一个C++设计模式之一。

Bridge模式意图：降低抽象和实现之间的耦合。

面向对象系统设计和分析中最重要的一点就是：高内聚，低耦合。Bridge模式使得抽象和实现能够相对独立。

 

 

Bridge模式结构图：

 

        

             

 

Bridge模式的关键在于Abstraction的派生类中维护了一个纸箱Implementor类的指针。

让Implentor的派生类来去实现。从而实现了抽象和实现的相对独立。

 

参考代码：

 

 #pragma once
 //Abstraction.h
 class Abstraction
 {
 public:
     Abstraction(void){};
     virtual ~Abstraction(void){};

     virtual void Operation() = 0;
 };

 

 

 #pragma once
 //Implementor.h
 class Implementor
 {
 public:
     Implementor(void){};
     virtual ~Implementor(void){};

     virtual void OperationImp() = 0;
 };

 

 

 

 #pragma once

 //ConcreteImplementorA.h
 #include "implementor.h"

 class ConcreteImplementorA :
     public Implementor
 {
 public:
     ConcreteImplementorA(void);
     ~ConcreteImplementorA(void);

     void OperationImp();
 };

 

 #pragma once

 //ConcreteImplementorB.h
 #include "implementor.h"

 class ConcreteImplementorB :
     public Implementor
 {
 public:
     ConcreteImplementorB(void);
     ~ConcreteImplementorB(void);

     void OperationImp();
 };

 

 

 #pragma once

 //RefinedAbstraction.h
 #include "abstraction.h"
 #include "Implementor.h"

 class Implementor;

 class RefinedAbstraction :
     public Abstraction
 {
 public:
     RefinedAbstraction(void);
     RefinedAbstraction(Implementor *imp);
     ~RefinedAbstraction(void);

     void Operation();

 private:
     Implementor *m_imp;

 };

 

 #include <iostream>
 #include "ConcreteImplementorA.h"

 using namespace std;

 //ConcreteImplementonA.cpp
 ConcreteImplementorA::ConcreteImplementorA(void)
 {
 }

 ConcreteImplementorA::~ConcreteImplementorA(void)
 {
 }

 void ConcreteImplementorA::OperationImp()
 {
     cout << "Hi, I am in ConcreteImplementorA" << endl;
 }

 

 

 #include <iostream>
 #include "ConcreteImplementorB.h"

 using namespace std;


 //ConcreteImplementorB.cpp
 ConcreteImplementorB::ConcreteImplementorB(void)
 {
 }

 ConcreteImplementorB::~ConcreteImplementorB(void)
 {
 }

 void ConcreteImplementorB::OperationImp()
 {
     cout << "Hi, I am in ConcreteImplementorB" << endl;
 }

 

 

 #include <iostream>
 #include "RefinedAbstraction.h"

 using namespace std;

 //RefinedAbstraction.cpp
 RefinedAbstraction::RefinedAbstraction(void)
 {
     m_imp = NULL;

 }

 RefinedAbstraction::~RefinedAbstraction(void)
 {
 }

 RefinedAbstraction::RefinedAbstraction(Implementor *imp)
 {
     m_imp = imp;
 }

 void RefinedAbstraction::Operation()
 {
     m_imp->OperationImp();
 }

 

 #include "Abstraction.h"
 #include "ConcreteImplementorA.h"
 #include "ConcreteImplementorB.h"
 #include "RefinedAbstraction.h"


 //main.cpp
 int main()
 {

     ConcreteImplementorA *pImpA = new ConcreteImplementorA;
     ConcreteImplementorB *pImpB = new ConcreteImplementorB;
     Abstraction *objA = new RefinedAbstraction(pImpA);
     Abstraction *objB = new RefinedAbstraction(pImpB);

     objA->Operation();
     objB->Operation();

 }

 

 

 

我个人 非常欣赏也非常推崇Bridge模式。