设计模式C++实现（8）—

本文主要是介绍设计模式C++实现（8）——桥接模式，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一、简介

Bridge模式是为了解决将将抽象部份与它的实现部分分离，即将抽象（Abstraction）与实现（AbstractionImp）分离，使得二者可以独立地变化，从而尽可能地提高系统模块内部的内聚(Cohesion)、尽可能降低模块间的耦合(Coupling)。

Bridge桥接模式号称设计模式中最难理解的模式之一，关键就是这个抽象和实现的分离非常让人奇怪，大部分人刚看到这个定义的时候都会认为实现就是继承自抽象，那怎么可能将他们分离呢。它也是也是 OO 开发与设计中经常会用到的模式之一，使用组合（委托）的方式将抽象和实现彻底地解耦，这样的好处是抽象和实现可以分别独立地变化，系统的耦合性也得到了很好的降低。

如下图是Bridge模式的结构图，其中系统被分为两个相对独立的部分，左边是抽象部分，右边是实现部分。这两个部分可以互相独立地进行修改，例如当需要从Abstraction派生一个具体子类RefinedAbstractionB时候，不需要添加和修改ConcreteAbstractionImpA和ConcreteAbstractionImpB；当Operation的操作由于算法或逻辑改变只需在右边添加一个具体化子类ConcreteAbstractionImpC，其他的都不用改变。

二、详解

1、代码实现

（1）代码abstraction.h：

[html]  view plain  copy 
 #ifndef _ABSTRACTION_H_  
 #define _ABSTRACTION_H_  
   
 class Abstraction  
 {  
     public:  
         virtual ~Abstraction();  
         virtual void Operation() = 0;  
     protected:  
         Abstraction();  
     private:  
 };  
   
 class AbstractionImp;  
 class RefinedAbstraction : public Abstraction  
 {  
     public:  
         RefinedAbstraction(AbstractionImp *imp);  
         ~RefinedAbstraction();  
         void Operation();  
     protected:  
     private:  
         AbstractionImp *_imp;  
 };  
   
 #endif  

（2）代码abstraction.cpp：

[html]  view plain  copy 
 #include <iostream>  
 #include "abstraction.h"  
 #include "abstractionimp.h"  
 using namespace std;  
   
 Abstraction::Abstraction()  
 {  
 }  
   
 Abstraction::~Abstraction()  
 {  
 }  
   
 RefinedAbstraction::RefinedAbstraction(AbstractionImp *imp)  
 {  
     _imp = imp;  
 }  
   
 RefinedAbstraction::~RefinedAbstraction()  
 {  
 }  
   
 void RefinedAbstraction::Operation()  
 {  
       cout<<"_imp->Operation() interface"<<endl;  
     _imp->Operation();  
 }  

（3）代码abstractionimp.h：

[html]  view plain  copy 
 #ifndef _ABSTRACTIONIMP_H_  
 #define _ABSTRACTIONIMP_H_  
   
 class AbstractionImp  
 {  
     public:  
         virtual ~AbstractionImp();  
         virtual void Operation() = 0;  
     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:  
 };  
   
 #endif  

（4）代码abstractionimp.cpp：

[html]  view plain  copy 
 #include <iostream>  
 #include "abstractionimp.h"  
 using namespace std;  
   
 AbstractionImp::AbstractionImp()  
 {  
       cout << "---AbstractionImp constructor" <<endl;  
 }  
   
 AbstractionImp::~AbstractionImp()  
 {  
 }  
   
 void AbstractionImp::Operation()  
 {  
     cout << "AbstractionImp...imp..." <<endl;  
 }  
   
 ConcreteAbstractionImpA::ConcreteAbstractionImpA()  
 {  
 }  
   
 ConcreteAbstractionImpA::~ConcreteAbstractionImpA()  
 {  
 }  
   
 void ConcreteAbstractionImpA::Operation()  
 {  
     cout<< "+++ConcreteAbstractionImpA..." <<endl;  
 }  
   
 ConcreteAbstractionImpB::ConcreteAbstractionImpB()  
 {  
 }  
   
 ConcreteAbstractionImpB::~ConcreteAbstractionImpB()  
 {  
 }  
   
 void ConcreteAbstractionImpB::Operation()  
 {  
     cout<< "+++ConcreteAbstractionImpB..." <<endl;  
 }  

（5）代码main.cpp：

[html]  view plain  copy 
 #include <iostream>  
 #include "abstraction.h"  
 #include "abstractionimp.h"  
 using namespace std;  
   
 int main()  
 {  
     //Bridge模式将抽象和实现分别独立实现  
     //实现部分ConcreteAbstractionImplementA  
     AbstractionImp *imp = new ConcreteAbstractionImpA();  
     //抽象部分RefinedAbstractionA  
     Abstraction *abs = new RefinedAbstraction(imp);  
     abs->Operation();  
       
     cout << "-----------------------------------------" << endl;  
     AbstractionImp* imp2 = new ConcreteAbstractionImpB();  
     Abstraction *abs2 = new RefinedAbstraction(imp2);  
     abs2->Operation();  
       
     delete abs;  
     delete imp;  
     delete abs2;  
     delete imp2;  
     return 0;  
 }  

（6）makefile：

[html]  view plain  copy 
 CFLAGS = -g  
 DEFINED = #-D _VERSION  
 LIBS =   
 CC = g++  
 INCLUDES = -I./  
 OBJS= main.o abstraction.o abstractionimp.o  
 TARGET= main  
 all:$(TARGET)  
   
 $(TARGET):$(OBJS)  
     $(CC) $(CFLAGS) -o $@ $(OBJS)  
   
 .SUFFIXES:.o .h  
 .SUFFIXES:.cpp .o  
 .cpp.o:  
     $(CC) $(DEFINED) -c $(CFLAGS) -o $@ $<  
   
 ok:  
     ./$(TARGET)  
 clean:  
     rm -f $(OBJS) $(TARGET) core *.log  

2、运行结果

（Centos6.3系统中运行结果：）

三、总结

（1）GoF 在说明 Bridge 模式时，在意图中指出 Bridge 模式“将抽象部分与它的实现部分分离，使得它们可以独立地变化”。这句话很简单，但是也很复杂，连 Bruce Eckel 在他的大作《Thinking in Patterns》中说“Bridge 模式是 GoF 所讲述得最不好(Poorly-described)的模式”。原因就在于 GoF 的那句话中的“实现”该怎么去理解：“实现”特别是和“抽象”放在一起的时候，我们“默认”的理解是“实现”就是“抽象”的具体子类的实现，但是这里 GoF 所谓的“实现”的含义不是指抽象基类的具体子类对抽象基类中虚函数(接口)的实现，是和继承结合在一起的。而这里的“实现”的含义指的是怎么去实现用户的需求,并且指的是通过组合(委托)的方式实现的,因此这里的实现不是指的继承基类、实现基类接口,而是指的是通过对象组合实现用户的需求。理解了这一点也就理解了Bridge 模式，理解了 Bridge 模式。

（2）Bridge的实现方式其实和Builde十分的相近，可以这么说：本质上是一样的，只是封装的东西不一样罢了。两者的实现都有如下的共同点：1、都抽象出来一个基类，这个基类里面定义了共有的一些行为，形成接口函数（对接口编程而不是对实现编程），这个接口函数在Buildier中是BuildePart函数在Bridge中是Operation函数。2、都聚合一个基类的指针，如Builder模式中Director类聚合了一个Builder基类的指针，Brige模式中Abstraction类聚合了一个AbstractionImp基类的指针（优先采用聚合而不是继承）。3、都把对这个类的使用封装在一个函数中，在Bridge中是封装在Director::Construct函数中，因为装配不同部分的过程是一致的，在Bridge模式中则是封装在Abstraction::Operation函数中，在这个函数中调用对应的AbstractionImplmp::Operation函数。就两个模式而言，Builder封装了不同的生成组成部分的方式，Bridge封装了不同的实现方式。

（3）源码已经打包上传到csdn上可登录下载（http://download.csdn.net/detail/taiyang1987912/8409223）。

本文转自：

http://blog.csdn.net/taiyang1987912/article/details/43164747

这篇关于设计模式C++实现（8）——桥接模式的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！