(原创)composite模式和bridge模式是天生的好朋友
composite模式的意图是:将对象组合成树形结构以表示“部分-整体”的层次结构。composite使得用户对单个对象和组合对象的使用具有一致性。它的类图如下:
composite模式的实现分为透明的composite模式和安全的composite模式,二者的差别是添加、删除和获取子节点的行为放到基类还是放到复合节点类中。透明的则放到基类中,但是这些行为对于不可再分的叶子节点来说是无意义的,对于存在子节点的复合节点才有意义。但是透明的组合模式具有更好的一致性和可读性,一般都建议用透明的组合模式,在基类中提供这些行为的空的虚方法,只在复合节点中重写这些虚方法。
透明的组合模式的简单实现如下:
#include <vector> #include <iostream> #include <memory> using namespace std; struct Component { Component() { } virtual ~Component() { } virtual void Add(std::shared_ptr<Component>) { } virtual void Operate() { } }; struct Leaf : Component { void Operate() override { cout << "Leaf" << endl; } }; struct OtherLeaf : Component { void Operate() override { cout << "OtherLeaf" << endl; } }; struct Composite : Component { void Add(std::shared_ptr<Component> child) override { m_children.push_back(child); } void Operate() override { cout << "Composite" << endl; for (auto child : m_children) { child->Operate(); } } private: vector<std::shared_ptr<Component>> m_children; };
bridge模式的意图是:将抽象部分与它的实现部分分离,使它们都可以独立地变化。它的类图如下:
桥接模式的实现比较简单,桥的两边是两个独立的继承体系,桥的左边是抽象部分的继承体系,桥的右边是实现部分的继承体系,这两个继承体系之前通过一座桥来关联,当抽象部分需要实现部分的某种实现时,在外面指定具体实现类即可。桥接模式充分的解耦了抽象与实现,使得他们都可以独立的变化,增强了灵活性和可扩展性。桥接模式的实现中,设置某个实现时,有两种方法,一种是由外面选择是哪种实现,一种由派生类选择时哪种实现,由外面选择的方式降低了两边的耦合性,但是需要知道更多的细节,当扩展新的实现时不得不修改,而派生类自己选择则增强了耦合性,即抽象的派生类需要知道实现的派生类,但是它能适应扩展,扩展一个新抽象时,不用修改代码,只在派生类自己选择就行了,封装了变化。至于如何选择看自己的选择了,我个人觉得派生类中选择更好,可以封装变化。
桥接模式的简单实现如下:
#include <iostream> #include <memory> using namespace std; struct Implementation { virtual void Operate() = 0; ~Implementation(){} }; struct DerivedImplement1 : Implementation { void Operate() override { cout << "do DerivedImplement1" << endl; } }; struct DerivedImplement2 : Implementation { void Operate() override { cout << "do DerivedImplement2" << endl; } }; struct Abstraction { void SetImplementation(std::shared_ptr<Implementation> impl) { m_impl = impl; } virtual void Operate() { if (m_impl!=nullptr) m_impl->Operate(); } ~Abstraction(){} protected: std::shared_ptr<Implementation> m_impl; }; struct DerivedAbstraction1 : Abstraction { }; struct DerivedAbstraction2 : Abstraction { }; void TestBridge() { std::shared_ptr<Abstraction> abstract1 = std::make_shared<DerivedAbstraction1>(); std::shared_ptr<Abstraction> abstract2 = std::make_shared<DerivedAbstraction2>(); std::shared_ptr<Implementation> impl1 = std::make_shared<DerivedImplement1>(); std::shared_ptr<Implementation> impl2 = std::make_shared<DerivedImplement2>(); abstract1->SetImplementation(impl2); abstract2->SetImplementation(impl1); abstract1->Operate(); abstract2->Operate(); }
介绍了两个的模式的实现之后再来看看为什么他们是天生的好朋友,compostite主要封装了对象结构的变化,它可能有很多叶子节点或者复合嵌套节点,我们可以以统一的方式去访问这些对象,这很方便。然而当这些对象具有一些不同的行为的时候,事情就变得有趣了,因为节点类型不同对应的行为也不同,这个行为是属于另外一个继承体系,如何将两个继承体系绑定起来,为每个composite模式中节点指定一个行为呢?如果通过工厂来选择的话,则工厂需要根据节点类型来选择对应的行为,这能解决问题但是当节点类型增加时就要修改工厂类,无法做到“开放封闭”。解决这个问题的关键是如何满足两个继承体系独立的变化,这时候通过桥接模式就能很好的解决这个问题。composite属于“桥”左边的抽象部分的继承体系,其行为对应“桥”右边的继承体系,通过指定抽象部分的某个具体派生类对应的某个具体实现就能实现,就能实现抽象和实现的解耦了。
将组合模式和桥接模式结合起来的类图如下:
具体实现如下:
#include <vector> #include <iostream> #include <memory> using namespace std; #include "Bridge.hpp" struct Component { Component() { } virtual ~Component() { } virtual void Add(std::shared_ptr<Component> child) { } virtual void Operate() { if (m_impl) m_impl->Operate(); } virtual void SetImplementation() { } protected: std::shared_ptr<Implementation> m_impl; }; struct Leaf : Component { void Operate() override { cout << "Leaf" << endl; Component::Operate(); } void SetImplementation() override { m_impl = std::make_shared<DerivedImplement1>(); } }; struct OtherLeaf : Component { void Operate() override { cout << "OtherLeaf" << endl; Component::Operate(); } void SetImplementation() override { m_impl = std::make_shared<DerivedImplement2>(); } }; struct Composite : Component { void Add(std::shared_ptr<Component> child) override { m_children.push_back(child); } void Operate() override { cout << "Composite" << endl; for (auto child : m_children) { child->Operate(); } } void SetImplementation() override { for (auto child : m_children) { child->SetImplementation(); } } private: vector<std::shared_ptr<Component>> m_children; }; void TestComposite() { std::shared_ptr<Component> root = std::make_shared<Composite>(); std::shared_ptr<Component> leaf = std::make_shared<Leaf>(); std::shared_ptr<Component> otherLeaf = std::make_shared<OtherLeaf>(); root->Add(leaf); root->Add(otherLeaf); root->SetImplementation(); root->Operate(); }
可以看到composite模式代表了抽象部分的继承体系,如果要给这个变化的继承体系增加行为,则需要对应一个实现部分的继承体系,而桥接模式刚好就可以将连个继承体系通过一座“桥”关联起来,让这两个继承体系独立变化,二者结合起来非常自然,所以说他们天生就是一对好朋友。
如果你觉得这篇文章对你有用,可以点一下推荐,谢谢。
c++11 boost技术交流群:296561497,欢迎大家来交流技术。
posted on 2014-04-11 15:04 qicosmos(江南) 阅读(2521) 评论(5) 编辑 收藏 举报