(Boolan)C++设计模式 <十一> ——组合模式(Composite)、迭代器(Iterator)和责任链(Chain of Resposibility)
2017-08-23 21:10
911 查看
“数据结构”模式
常常有一些组建在内部具有特定的数据结构,如果让客户程序依赖这些特定的数据结构,将极大的破坏组件的复用。这时候,将这些数据结构封装在内部,在外部提供统一的接口,来实现与特定数据结构无关的访问,是一种行之有效的解决方案。典型模式Composite
Iterator
Chain of Responsibility
组合模式(Composite)
将对象组合成树形结构以表示“部分-整体”的层级结构。Compisite使得用户对单个对象和组合对象的使用具有一致性(稳定)。——《设计模式》GoF
动机
在某些软件情况下,客户代码过多地依赖于对像容器复杂的内部实现结构,对像容器内部实现结构(而非抽象接口)的变化将因其客户代码的频繁变化,带来了代码的维护性、扩展性等弊端。
#include <iostream> #include <list> #include <string> #include <algorithm> using namespace std; class Component { public: virtual void process() = 0; virtual ~Component(){} }; //树节点 class Composite : public Component{ string name; list<Component*> elements;//子节点 public: Composite(const string & s) : name(s) {} void add(Component* element) { elements.push_back(element); } void remove(Component* element){ elements.remove(element); } void process(){ //核心部分,即处理了当前节点,也处理了他的所有的子节点,动态的实现了类似迭代遍历的方法 //1. process current node处理当前节点 //2. process leaf nodes处理叶子节点 for (auto &e : elements) e->process(); //多态调用 } }; //叶子节点 class Leaf : public Component{ string name; public: Leaf(string s) : name(s) {} void process(){ //process current node } }; //客户程序 void Invoke(Component & c){ //由于之前已经遍历,此处无需手动来分别处理,对数据结构进行了封装。 //... c.process();//多态调用 //... } int main() { Composite root("root"); Composite treeNode1("treeNode1"); Composite treeNode2("treeNode2"); Composite treeNode3("treeNode3"); Composite treeNode4("treeNode4"); Leaf leat1("left1"); Leaf leat2("left2"); root.add(&treeNode1); treeNode1.add(&treeNode2); treeNode2.add(&leaf1); root.add(&treeNode3); treeNode3.add(&treeNode4); treeNode4.add(&leaf2); process(root); process(leaf2); process(treeNode3); }
Composite的UML
对于Add、Remove函数来说,放在父类还是子节点中,有一定的争议,因为如果在父类中,那么对于leaf节点来说,逻辑上就不应该有Add、Remove方法。
要点总结
Composite模式采用树形结构来实现普遍存在的对像容器,从而将“一对多”的关系转化为“一对一”的关系,使得客户代码可以一致的(复用)处理对象和对象容器,无需关心处理的是单个对象还是组合的对象容器
将“客户代码与复杂的对象容器结构”解耦是Composite的核心思想,解耦之后,客户代码将与纯粹的抽象接口——而非对像容器的内部实现结构——发生依赖,从而更能“应对变化”。
Composite模式在具体实现中,可以让父对象中的子对象反向追溯;如果父对象有频繁的遍历需求,可使用缓存技巧来改善效率。
迭代器(Iterator)
提供一种方法顺序访问一个聚合对象中的各个元素,而又不暴露(隔离变化,稳定)该对象的内部表示。——《设计模式》GoF
动机
在软件构建中,集合对象内部结构常常变化各异。但由于这些集合对像,我们希望在不暴露其内部结构的同时,可以让外部客户代码透明的访问其中包含的元素;同时这种“透明遍历”也为“同一种算法在多种集合对象上进行操作”提供了可能。
使用面向对象技术将这种遍历机制抽象为“迭代器对象”为“因对变化中的集合对象”提供了一种优雅的方式。
Iterator的UML
对于使用对象的方式来解决聚合对象的的访问问题,在现在来看,在C++来说已经过时了,现在的STL中主要采用的是泛型编程的思想。
template<typename T> class Iterator { public: virtual void first() = 0; virtual void next() = 0; virtual bool isDone() const = 0; virtual T& current() = 0; }; template<typename T> class MyCollection{ public: Iterator<T> GetIterator(){ //... } }; template<typename T> class CollectionIterator : public Iterator<T>{ MyCollection<T> mc; public: CollectionIterator(const MyCollection<T> & c): mc(c){ } void first() override { } void next() override { } bool isDone() const override{ } T& current() override{ } }; void MyAlgorithm() { MyCollection<int> mc; Iterator<int> iter= mc.GetIterator(); for (iter.first(); !iter.isDone(); iter.next()){ cout << iter.current() << endl; } }
以上是面向对象的模式迭代器的代码。面向对象的虚函数调用,是有一定的性能成本,需要间接运算,而在遍历过程来说,需要大量的重复调用,那么全都是虚函数调用,会使得性能成本倍增。基于泛型编程的模版编程方法,实在编译时依赖,但是性能相较面向对象的迭代器来说会比较低。基于运行时的多态的迭代器,在java、c#这类语言中普遍应用。
要点总结
迭代抽象:访问一个聚合对象的内容而无需暴露他的内部表示。
迭代多态:为遍历不同的集合结构提供一个统一的接口,从而支持同样的算法在不同的集合结构上进行操作。
迭代器健壮性考虑:便利的同时更改迭代器所在的集合结构,会导致问题。
责任链(Chain of Resposibility)
使多个对像都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对像连成一条链,并沿着这条链传递请求,直到有一个对象处理它为止。——《设计模式》GoF
在软件构建的过程中,一个请求可能被多个对象处理,但是每个请求在运行时只能有一个接受者,如果显示制定,将必不可少的带来请求发送者与接受者的耦合。
#include <iostream> #include <string> using namespace std; enum class RequestType { REQ_HANDLER1, REQ_HANDLER2, REQ_HANDLER3 }; //携带了请求信息 class Reqest { string description; RequestType reqType; public: Reqest(const string & desc, RequestType type) : description(desc), reqType(type) {} RequestType getReqType() const { return reqType; } const string& getDescription() const { return description; } }; //链表结构 class ChainHandler{ //自己指向自己,形成链表 ChainHandler *nextChain; void sendReqestToNextHandler(const Reqest & req) { if (nextChain != nullptr) nextChain->handle(req); } protected: //判断请求是否能被处理 virtual bool canHandleRequest(const Reqest & req) = 0; //处理请求 virtual void processRequest(const Reqest & req) = 0; public: ChainHandler() { nextChain = nullptr; } //完整的处理请求的逻辑 void setNextChain(ChainHandler *next) { nextChain = next; } void handle(const Reqest & req) { if (canHandleRequest(req)) processRequest(req); else sendReqestToNextHandler(req); } }; class Handler1 : public ChainHandler{ protected: bool canHandleRequest(const Reqest & req) override { return req.getReqType() == RequestType::REQ_HANDLER1; } void processRequest(const Reqest & req) override { cout << "Handler1 is handle reqest: " << req.getDescription() << endl; } }; class Handler2 : public ChainHandler{ protected: bool canHandleRequest(const Reqest & req) override { return req.getReqType() == RequestType::REQ_HANDLER2; } void processRequest(const Reqest & req) override { cout << "Handler2 is handle reqest: " << req.getDescription() << endl; } }; class Handler3 : public ChainHandler{ protected: bool canHandleRequest(const Reqest & req) override { return req.getReqType() == RequestType::REQ_HANDLER3; } void processRequest(const Reqest & req) override { cout << "Handler3 is handle reqest: " << req.getDescription() << endl; } }; int main(){ Handler1 h1; Handler2 h2; Handler3 h3; h1.setNex 4000 tChain(&h2); h2.setNextChain(&h3); Reqest req("process task ... ", RequestType::REQ_HANDLER3); h1.handle(req); return 0; }
Chain of Responsibility的UML
要点总结
Chain of Responsibility模式的应用场合在于“一个请求可能有多个接受者,但是最后真正接受者只有一个”,这时候请求发送者与接受者的耦合可能出现“变化脆弱”的症状,职责链的目的就是将二者解耦,从而更好的应对变化。
应用了指责连模式后,对象的指责分派将更具灵活性。我们可以在运行时动态添加/修改请求的处理指责。
如果请求传递到职责链的末尾仍得不到处理,应该有一个合理的缺省机制。这也是每一个接受者对象的责任,而不是发出请求的对象的责任。
相关文章推荐
- C++设计模式 之 “数据结构” 模式:Composite、Iterator、Chain of Resposibility
- (Boolan)C++设计模式 <一> ——设计模式简介以及面向对象设计原则
- 测试类图Head First 设计模式 (九) 迭代器与组合模式(Iterator & Composite pattern) C++实现
- (Boolan)C++设计模式 <二> ——模版方法(Template Method)
- (Boolan)C++设计模式 <三> ——策略模式(Strategy)
- Head First 设计模式 (九) 迭代器与组合模式(Iterator & Composite pattern) C++实现
- (Boolan)C++设计模式 <四> ——观察者模式(Observer)
- (Boolan)C++设计模式 <五> ——装饰模式(Decorator)
- (Boolan)C++设计模式 <六> ——桥模式(Bridge)
- (Boolan)C++设计模式 <九> ——单例模式(Singleton)和享元模式(FlyWeight)
- (Boolan)C++设计模式 <十> ——状态模式(State)和备忘录(Memento)
- (Boolan)C++设计模式 <十二> ——命令模式(Command)和访问器(Visitor)
- (Boolan)C++设计模式 <十三> ——解析器(Interpreter)
- JAVA设计模式(11) —<结构型>组合模式(Composite)
- <C/C++ 版> 设计模式 学习之 工厂模式 <2>
- <C/C++ 版> 设计模式 学习之 工厂模式 <1>
- C++设计模式--单一对象模式<Singleton>
- 【java设计模式】之 责任链(chain of resposibility)模式
- <C/C++ 版> 设计模式 学习之 策略模式
- JAVA设计模式(16) —<行为型>迭代子模式(Iterator)