【设计模式学习笔记】组合模式与桥接模式案例详解（C++实现）

2023-02-08 352

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 【设计模式学习笔记】组合模式与桥接模式案例详解（C++实现）

一、组合模式

1. 什么是组合模式

Composite Pattern，组合模式，是一种结构型模式。

组合模式将对象组合成树形结构以表示“整体-部分”的层次结构，并使得用户对单个对象和组合对象的使用具有一致性。

组合模式构造了一个树形的对象结构，并且通过一个属性对象可以可以访问整棵树的对象。

组合模式的三种角色：

Component：抽象角色，代表树形结构的抽象结点，它定义了所有实现类的统一接口（属性、方法、行为），并提供了访问和管理子结点的接口；简言之，Component定义了Leaf和Composite共同的操作接口，比如增加子结点，删除子结点等行为，是一个抽象基类。
Leaf：叶子结点，叶子结点中没有子结点，类似于树中的叶子结点，或文件系统中的文件。
Composite ：枝结点，可以存储子结点，并实现子结点的操作，类似于文件系统的文件夹。

2. 组合模式案例

首先定义一个抽象类，为Leaf和Composite提供统一接口，假设要做一个文件系统，文件夹（Composite）中可以放入文件和文件夹，文件（Leaf）中不可以放入任何子结点。

1. class Component
2. {
3. public:
4.  virtual void display() = 0; //显示当前文件或文件夹名称
5.  virtual void add(Component* node) = 0; //在当前文件夹增加一个文件或文件夹
6.  virtual void remove(Component* node) = 0; //在当前文件夹删除一个文件或文件夹
7.  virtual vector<Component*>* get_child() = 0; //获取文件夹下属文件或文件夹
8. };

定义一个文件类，文件中不可加入子结点

1. class Leaf : public Component
2. {
3. private:
4.  string name;
5. public:
6.  Leaf(string name)
7.  {
8.    this->name = name;
9.  }
10.   virtual void display()
11.   {
12.     cout << "Leaf: " << this->name << endl;
13.   }
14.   virtual void add(Component* node)
15.   {
16.     cout << "叶子结点，无法加入" << endl;
17.   }
18.   virtual void remove(Component* node)
19.   {
20.     cout << "叶子结点，无此操作" << endl;
21.   }
22.   virtual vector<Component*>* get_child()
23.   {
24.     cout << "叶子结点，无子结点" << endl;
25.     return NULL;
26.   }
27. };

定义一个文件夹类，可以加入问价或文件夹

1. class Composite : public Component
2. {
3. private:
4.  string name;
5.  vector<Component*>* vec;
6. public:
7.  Composite(string name)
8.  {
9.    this->name = name;
10.     vec = new vector<Component*>;
11.   }
12.   ~Composite()
13.   {
14.     if (vec != NULL)
15.     {
16.       delete vec;
17.       vec = NULL;
18.     }
19.   }
20.   virtual void display()
21.   {
22.     cout << "Composite: " << this->name << endl;
23.   }
24.   virtual void add(Component* node)
25.   {
26.     vec->push_back(node);
27.   }
28.   virtual void remove(Component* node)
29.   {
30.     for (vector<Component*>::iterator it = vec->begin(); it != vec->end(); it++)
31.     {
32.       if (*it == node)
33.       {
34.         vec->erase(it);
35.       }
36.     }
37.   }
38.   virtual vector<Component*>* get_child()
39.   {
40.     cout << "*" << this->name << " child: " << "*\n";
41.     for (vector<Component*>::iterator it = vec->begin(); it != vec->end(); it++)
42.     {
43.       (*it)->display();
44.     }
45.     return vec;
46.   }
47. };

客户端操作

1. int main()
2. {
3.  Component* root = NULL;
4.  Leaf* l1 = NULL;
5.  Leaf* l2 = NULL;
6.  Composite* dir = NULL;
7. 
8.  root = new Composite("/root");
9.  l1 = new Leaf("1.cpp");
10.   l2 = new Leaf("2.cpp");
11.   dir = new Composite("/home");
12. 
13.   root->add(dir);
14.   dir->add(l1);
15.   dir->add(l2);
16. 
17.   cout << "============" << endl;
18.   root->display();
19.   root->get_child();
20.   dir->get_child();
21.   cout << "============" << endl;
22. 
23.   delete dir;
24.   delete l2;
25.   delete l1;
26.   delete root;
27. 
28.   system("pause");
29.   return 0;
30. }

二、桥接模式

1. 什么是桥接模式

Bridge Pattern，桥接模式，是一种结构型设计模式。

桥接模式基于类的最小设计原则，通过使用封装，聚合以及继承等行为来让不同的类承担不同的责任。它的主要特点是把抽象（abstraction）与行为实现（implementation）分离开来，从而可以保持各部分的独立性以及应对它们的功能扩展。

也就是说，通过桥接模式可以实现抽象部分与实现部分的解耦合，使得抽象和实现都可以独立的发生变化，当通过继承不能实现开闭原则的时候，就可以考虑桥接模式。比如，图形和颜色，把图形设计一个抽象类，颜色设计一个抽象类，然后根据需要的图形去实现图形类，并根据需要的颜色实现颜色类，通过两个抽象类就可以实现颜色和图形的组合。

Abstractions：抽象类接口，包含了一个对行为实现类Implementor的引用，也就是说二者具有关联关系。
Refined Abstraction：抽象类接口的实现类，实现了Abstractions中定义的接口，并可以调用Implementor中的方法（包含了Implementor的引用）。
Implementor：行为实现类接口，定义了一系列操作。
Concretelmp lementor：具体实现类，实现了Implementor中的操作。

2. 桥接模式案例

实现对不同图形上不同颜色，首先定义两个抽象类，颜色类和图形类

1. class Color
2. {
3. public:
4.  virtual void get_color() = 0;
5. };
6. 
7. class Graph
8. {
9. protected:
10.   Color* mGraphColor;
11. public:
12.   Graph(Color* mGraphColor)
13.   {
14.     this->mGraphColor = mGraphColor;
15.   }
16.   virtual void smear_color() = 0; //给图形上色
17. };

定义三个具体的颜色

1. class Red : public Color
2. {
3. public:
4.  virtual void get_color()
5.  {
6.    cout << "红色" << endl;
7.  }
8. };
9. 
10. class Blue : public Color
11. {
12. public:
13.   virtual void get_color()
14.   {
15.     cout << "蓝色" << endl;
16.   }
17. };
18. 
19. class Yellow : public Color
20. {
21. public:
22.   virtual void get_color()
23.   {
24.     cout << "黄色" << endl;
25.   }
26. };

实现具体的图形

1. class Circle : public Graph
2. {
3. public:
4.  Circle(Color* mGraphColor) : Graph(mGraphColor) {};
5.  virtual void smear_color()
6.  {
7.    cout << "圆形 + ";
8.    mGraphColor->get_color();
9.  }
10. };
11. 
12. class Triangle : public Graph
13. {
14. public:
15.   Triangle(Color* mGraphColor) : Graph(mGraphColor) {};
16.   virtual void smear_color()
17.   {
18.     cout << "三角形 + ";
19.     mGraphColor->get_color();
20.   }
21. };

客户端操作，为图形上色

1. int main()
2. {
3.  Color* m_color = NULL;
4. 
5.  m_color = new Red;
6.  Circle* m_circle = new Circle(m_color);
7.  m_circle->smear_color();
8. 
9.  delete m_color;
10.   m_color = new Blue;
11.   Triangle* m_triangle = new Triangle(m_color);
12.   m_triangle->smear_color();
13. 
14.   delete m_color;
15.   delete m_triangle;
16.   delete m_circle;
17. 
18.   system("pause");
19.   return 0;
20. }

【设计模式学习笔记】组合模式与桥接模式案例详解（C++实现）

一、组合模式

1. 什么是组合模式

2. 组合模式案例

二、桥接模式

1. 什么是桥接模式

2. 桥接模式案例

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【设计模式学习笔记】组合模式与桥接模式案例详解（C++实现）

一、组合模式

1. 什么是组合模式

2. 组合模式案例

二、桥接模式

1. 什么是桥接模式

2. 桥接模式案例

热门文章

最新文章

相关课程

相关电子书

相关实验场景