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

小咪咪 2022-06-02 06:16 82阅读 0赞

# 一、简介    #

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

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

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

![Center][]

# 二、详解 #

## 1、代码实现    ##

（1）代码abstraction.h：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#ifndef \_ABSTRACTION\_H\_  
2.  \#define \_ABSTRACTION\_H\_  
3.    
4.  class Abstraction  
5.  \{  
6.      public:  
7.          virtual ~Abstraction();  
8.          virtual void Operation() = 0;  
9.      protected:  
10.         Abstraction();  
11.     private:  
12. \};  
13.   
14. class AbstractionImp;  
15. class RefinedAbstraction : public Abstraction  
16. \{  
17.     public:  
18.         RefinedAbstraction(AbstractionImp \*imp);  
19.         ~RefinedAbstraction();  
20.         void Operation();  
21.     protected:  
22.     private:  
23.         AbstractionImp \*\_imp;  
24. \};  
25.   
26. \#endif

（2）代码abstraction.cpp：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#include <iostream>  
2.  \#include "abstraction.h"  
3.  \#include "abstractionimp.h"  
4.  using namespace std;  
5.    
6.  Abstraction::Abstraction()  
7.  \{  
8.  \}  
9.    
10. Abstraction::~Abstraction()  
11. \{  
12. \}  
13.   
14. RefinedAbstraction::RefinedAbstraction(AbstractionImp \*imp)  
15. \{  
16.     \_imp = imp;  
17. \}  
18.   
19. RefinedAbstraction::~RefinedAbstraction()  
20. \{  
21. \}  
22.   
23. void RefinedAbstraction::Operation()  
24. \{  
25.       cout<<"\_imp->Operation() interface"<<endl;  
26.     \_imp->Operation();  
27. \}

（3）代码abstractionimp.h：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#ifndef \_ABSTRACTIONIMP\_H\_  
2.  \#define \_ABSTRACTIONIMP\_H\_  
3.    
4.  class AbstractionImp  
5.  \{  
6.      public:  
7.          virtual ~AbstractionImp();  
8.          virtual void Operation() = 0;  
9.      protected:  
10.         AbstractionImp();  
11.     private:  
12. \};  
13.   
14. class ConcreteAbstractionImpA : public AbstractionImp  
15. \{  
16.     public:  
17.         ConcreteAbstractionImpA();  
18.         ~ConcreteAbstractionImpA();  
19.         void Operation();  
20.     protected:  
21.     private:  
22. \};  
23.   
24. class ConcreteAbstractionImpB : public AbstractionImp  
25. \{  
26.     public:  
27.         ConcreteAbstractionImpB();  
28.         ~ConcreteAbstractionImpB();  
29.         void Operation();  
30.     protected:  
31.     private:  
32. \};  
33.   
34. \#endif

（4）代码abstractionimp.cpp：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#include <iostream>  
2.  \#include "abstractionimp.h"  
3.  using namespace std;  
4.    
5.  AbstractionImp::AbstractionImp()  
6.  \{  
7.        cout << "---AbstractionImp constructor" <<endl;  
8.  \}  
9.    
10. AbstractionImp::~AbstractionImp()  
11. \{  
12. \}  
13.   
14. void AbstractionImp::Operation()  
15. \{  
16.     cout << "AbstractionImp...imp..." <<endl;  
17. \}  
18.   
19. ConcreteAbstractionImpA::ConcreteAbstractionImpA()  
20. \{  
21. \}  
22.   
23. ConcreteAbstractionImpA::~ConcreteAbstractionImpA()  
24. \{  
25. \}  
26.   
27. void ConcreteAbstractionImpA::Operation()  
28. \{  
29.     cout<< "+++ConcreteAbstractionImpA..." <<endl;  
30. \}  
31.   
32. ConcreteAbstractionImpB::ConcreteAbstractionImpB()  
33. \{  
34. \}  
35.   
36. ConcreteAbstractionImpB::~ConcreteAbstractionImpB()  
37. \{  
38. \}  
39.   
40. void ConcreteAbstractionImpB::Operation()  
41. \{  
42.     cout<< "+++ConcreteAbstractionImpB..." <<endl;  
43. \}

（5）代码main.cpp：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#include <iostream>  
2.  \#include "abstraction.h"  
3.  \#include "abstractionimp.h"  
4.  using namespace std;  
5.    
6.  int main()  
7.  \{  
8.      //Bridge模式将抽象和实现分别独立实现  
9.      //实现部分ConcreteAbstractionImplementA  
10.     AbstractionImp \*imp = new ConcreteAbstractionImpA();  
11.     //抽象部分RefinedAbstractionA  
12.     Abstraction \*abs = new RefinedAbstraction(imp);  
13.     abs->Operation();  
14.       
15.     cout << "-----------------------------------------" << endl;  
16.     AbstractionImp\* imp2 = new ConcreteAbstractionImpB();  
17.     Abstraction \*abs2 = new RefinedAbstraction(imp2);  
18.     abs2->Operation();  
19.       
20.     delete abs;  
21.     delete imp;  
22.     delete abs2;  
23.     delete imp2;  
24.     return 0;  
25. \}

（6）makefile：

**\[html\]**  [view plain][]  [copy][view plain]

1.  CFLAGS = -g  
2.  DEFINED = \#-D \_VERSION  
3.  LIBS =   
4.  CC = g++  
5.  INCLUDES = -I./  
6.  OBJS= main.o abstraction.o abstractionimp.o  
7.  TARGET= main  
8.  all:$(TARGET)  
9.    
10. $(TARGET):$(OBJS)  
11.     $(CC) $(CFLAGS) -o $@ $(OBJS)  
12.   
13. .SUFFIXES:.o .h  
14. .SUFFIXES:.cpp .o  
15. .cpp.o:  
16.     $(CC) $(DEFINED) -c $(CFLAGS) -o $@ $<  
17.   
18. ok:  
19.     ./$(TARGET)  
20. clean:  
21.     rm -f $(OBJS) $(TARGET) core \*.log

## 2、运行结果 ##

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

![Center 1][]

# 三、总结    #

（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_download.csdn.net_detail_taiyang1987912_8409223]）。

**本文转自：**

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

[Center]: /images/20220602/a0bbc72ea9da46caa9b467af5eca5bb7.png
[view plain]: http://blog.csdn.net/taiyang1987912/article/details/43164747#
[Center 1]: /images/20220602/19629ddf7e784cb49c0709d70d411436.png
[http_download.csdn.net_detail_taiyang1987912_8409223]: http://download.csdn.net/detail/taiyang1987912/8409223

发表评论取消回复

表情：

评论列表（有 0 条评论，82人围观）

还没有评论，来说两句吧...

相关阅读

相关 Java与设计模式（8）：桥接模式

一、定义桥接模式（Bridge Pattern）是一种软件设计模式，它用于将抽象部分与实现部分分离，使它们可以独立地变化。该模式通过将抽象类与实现类之间建立一个桥接（B

待我称王封你为后i/ 2024年03月17日 12:49/ 0 赞/ 18 阅读

相关 C++设计模式-桥接模式

桥接模式-单一职责定义：将抽象部分(业务功能)与实现部分(平台实现)分离，使它们都可以独立地变化。 ----《设计模式》GOF 类图： ![桥接模式类图][

男娘i/ 2022年11月10日 03:58/ 0 赞/ 135 阅读

相关设计模式-桥接模式

桥接模式简介将一些关系紧密的类拆分为抽象和实现两个独立的层次结构。例子例如空调和电视机，它们都有自己的遥控器，现在让你设计类该如何设计？ 1.

我就是我/ 2022年11月03日 12:00/ 0 赞/ 209 阅读

相关设计模式:桥接模式

前言参考一：[C++设计模式 – 李建忠 – 视频][C_ _ _ _] 参考二：[桥接 - 廖雪峰的官方网站][-] | [桥接模式 - C语言中文网][- C]

「爱情、让人受尽委屈。」/ 2022年08月31日 11:25/ 0 赞/ 204 阅读

相关【C#设计模式-桥接模式】

一.桥接模式定义：桥接模式即将抽象部分与实现部分脱耦，使它们可以独立变化。 ![20160512123721609][] 抽象化(Abstraction)角色：抽

╰半橙微兮°/ 2022年08月21日 11:47/ 0 赞/ 59 阅读

相关【设计模式】桥接模式

前言 Github：[https://github.com/yihonglei/java-design-patterns][https_github.com_yihong

我就是我/ 2022年07月16日 01:27/ 0 赞/ 187 阅读

相关 golang设计模式（8）桥接模式

桥接模式意图桥接模式将抽象部分与它的实现部分分离，使它们可以独立变化。适用性以下情况适合使用桥接模式： .不希望在抽象和它的实现部分之间有一个固定的绑定关系

谁借莪１个温暖的怀抱￠/ 2022年06月07日 14:09/ 0 赞/ 76 阅读

相关设计模式C++实现（8）——桥接模式

一、简介 Bridge模式是为了解决将将抽象部份与它的实现部分分离，即将抽象（Abstraction）与实现（AbstractionImp

小咪咪/ 2022年06月02日 06:16/ 0 赞/ 83 阅读

相关设计模式 : 桥接模式

对象的继承关系是在编译时就定义好了,所以无法在运行时改变从父类继承的实现.子类的实现与它的父类有非常紧密的依赖关系.以至于父类实现中的任何变化必然会导致子类发生变

电玩女神/ 2022年05月27日 03:35/ 0 赞/ 236 阅读

相关设计模式C++实现（10）——桥接模式

软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需

男娘i/ 2022年04月24日 06:24/ 0 赞/ 136 阅读