设计模式C++实现(8)——桥接模式

2024-06-18 16:32

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


一、简介

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

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

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


二、详解

1、代码实现

(1)代码abstraction.h:

[html]  view plain  copy
  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
  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
  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
  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
  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
  1. CFLAGS = -g  
  2. DEFINED = #-D _VERSION  
  3. LIBS =   
  4. CC = g++  
  5. INCLUDES = -I./  
  6. OBJSmain.o abstraction.o abstractionimp.o  
  7. TARGETmain  
  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系统中运行结果:)


三、总结

(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)——桥接模式的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1072520

相关文章

C#借助Spire.XLS for .NET实现在Excel中添加文档属性

《C#借助Spire.XLSfor.NET实现在Excel中添加文档属性》在日常的数据处理和项目管理中,Excel文档扮演着举足轻重的角色,本文将深入探讨如何在C#中借助强大的第三方库Spire.... 目录为什么需要程序化添加Excel文档属性使用Spire.XLS for .NET库实现文档属性管理Sp

C++ move 的作用详解及陷阱最佳实践

《C++move的作用详解及陷阱最佳实践》文章详细介绍了C++中的`std::move`函数的作用,包括为什么需要它、它的本质、典型使用场景、以及一些常见陷阱和最佳实践,感兴趣的朋友跟随小编一起看... 目录C++ move 的作用详解一、一句话总结二、为什么需要 move?C++98/03 的痛点⚡C++

Python+FFmpeg实现视频自动化处理的完整指南

《Python+FFmpeg实现视频自动化处理的完整指南》本文总结了一套在Python中使用subprocess.run调用FFmpeg进行视频自动化处理的解决方案,涵盖了跨平台硬件加速、中间素材处理... 目录一、 跨平台硬件加速:统一接口设计1. 核心映射逻辑2. python 实现代码二、 中间素材处

Java数组动态扩容的实现示例

《Java数组动态扩容的实现示例》本文主要介绍了Java数组动态扩容的实现示例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录1 问题2 方法3 结语1 问题实现动态的给数组添加元素效果,实现对数组扩容,原始数组使用静态分配

Python实现快速扫描目标主机的开放端口和服务

《Python实现快速扫描目标主机的开放端口和服务》这篇文章主要为大家详细介绍了如何使用Python编写一个功能强大的端口扫描器脚本,实现快速扫描目标主机的开放端口和服务,感兴趣的小伙伴可以了解下... 目录功能介绍场景应用1. 网络安全审计2. 系统管理维护3. 网络故障排查4. 合规性检查报错处理1.

Python轻松实现Word到Markdown的转换

《Python轻松实现Word到Markdown的转换》在文档管理、内容发布等场景中,将Word转换为Markdown格式是常见需求,本文将介绍如何使用FreeSpire.DocforPython实现... 目录一、工具简介二、核心转换实现1. 基础单文件转换2. 批量转换Word文件三、工具特性分析优点局

Springboot3统一返回类设计全过程(从问题到实现)

《Springboot3统一返回类设计全过程(从问题到实现)》文章介绍了如何在SpringBoot3中设计一个统一返回类,以实现前后端接口返回格式的一致性,该类包含状态码、描述信息、业务数据和时间戳,... 目录Spring Boot 3 统一返回类设计:从问题到实现一、核心需求:统一返回类要解决什么问题?

详解C++ 存储二进制数据容器的几种方法

《详解C++存储二进制数据容器的几种方法》本文主要介绍了详解C++存储二进制数据容器,包括std::vector、std::array、std::string、std::bitset和std::ve... 目录1.std::vector<uint8_t>(最常用)特点:适用场景:示例:2.std::arra

C++构造函数中explicit详解

《C++构造函数中explicit详解》explicit关键字用于修饰单参数构造函数或可以看作单参数的构造函数,阻止编译器进行隐式类型转换或拷贝初始化,本文就来介绍explicit的使用,感兴趣的可以... 目录1. 什么是explicit2. 隐式转换的问题3.explicit的使用示例基本用法多参数构造

Java使用Spire.Doc for Java实现Word自动化插入图片

《Java使用Spire.DocforJava实现Word自动化插入图片》在日常工作中,Word文档是不可或缺的工具,而图片作为信息传达的重要载体,其在文档中的插入与布局显得尤为关键,下面我们就来... 目录1. Spire.Doc for Java库介绍与安装2. 使用特定的环绕方式插入图片3. 在指定位