设计模式（13）——职责链 Chain Of Responsibility

目录：

设计模式学习笔记首页

设计模式（1）——抽象工厂 AbstractFactory

设计模式（2）——生成器 Builder

设计模式（3）——工厂方法 Factory Method

设计模式（4）——原型 Prototype

设计模式（5）——单例 Singleton

设计模式（6）——适配器 Adapter

设计模式（7）——桥接 Bridge

设计模式（8）——组合 Composite

设计模式（9）——装饰 Decorator

设计模式（10）——外观 Facade

设计模式（11）——享元 Flyweight

设计模式（12）——代理 Proxy

设计模式（13）——职责链 Chain Of Responsibility

设计模式（14）——命令 Command

设计模式（15）——解释器 Interpreter

设计模式（16）——迭代器 Itera
4000
tor

设计模式（17）——中介者 Mediator

设计模式（18）——备忘录 Memento

设计模式（19）——观察者 Observer

设计模式（20）——状态 State

设计模式（21）——策略 Strategy

设计模式（22）——模板方法 Template Method

设计模式（23）——访问者 Visitor

十三、Chain Of Responsibility （职责链，对象行为模式）

1. 意图：

  使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

2. 适用：

有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。

你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。

可处理一个请求的对象集合应被动态指定。

3. 类图：

4. 例：

  c++ 的异常处理就是一种职责链的模式，当程序出现异常的时候，就会一层一层往外抛，直到异常被处理。我们可以动态地添加异常处理代码，去处理异常。

5. C++实现：

先编写一个父类或接口

Handle

，

has-a

后继节点Handle对象

private Handle* _succ;

编写初始化后继节点代码：

2.1 通过构造函数

Handle(Handle* succ){this->_succ = succ;}

2.2 编写Set函数

void SetSuccessor(Handle* succ){_succ = succ;}

2.3 编写处理请求（职责）方法

HandleRequest();

2.4 编写一些子类或实现类如 ConcreteHandleA、ConcreteHandleB等，调用相关初始化后继节点方法，实现职责链（链表）

Handle.h

//Handle.h
#pragma once
class Handle {
public:
virtual ~Handle();
virtual void HandleRequest() = 0;
void SetSuccessor(Handle* succ);
Handle* GetSuccessor();
protected:
Handle();
Handle(Handle* succ);
private:
Handle* _succ;
};

class ConcreteHandleA : public Handle {
public:
ConcreteHandleA();
~ConcreteHandleA();
ConcreteHandleA(Handle* succ);
void HandleRequest();
protected:
private:
};

class ConcreteHandleB : public Handle {
public:
ConcreteHandleB();
~ConcreteHandleB();
ConcreteHandleB(Handle* succ);
void HandleRequest();
protected:
private:
};

Handle.cpp

//Handle.cpp
#include "Handle.h"
#include <iostream>
using namespace::std;

Handle::Handle() {
_succ = 0;
}
Handle::Handle(Handle* succ) {
_succ = succ;
}
Handle::~Handle() {
delete _succ;
}
void Handle::SetSuccessor(Handle* succ) {
_succ = succ;
}
void Handle::HandleRequest() {}
Handle* Handle::GetSuccessor(){
return _succ;
}

ConcreteHandleA::ConcreteHandleA() {}
ConcreteHandleA::ConcreteHandleA(Handle* succ) : Handle(succ){}
ConcreteHandleA::~ConcreteHandleA() {}

void ConcreteHandleA::HandleRequest() {
if (this->GetSuccessor() != 0) {
cout << "ConcreteHandleA 我把处理权给后继节点......" << endl;
this->GetSuccessor()->HandleRequest();
}
else {
cout << "ConcreteHandleA 没有后继节点了，我必须自己处理......" << endl;
}
}

ConcreteHandleB::ConcreteHandleB() {}
ConcreteHandleB::ConcreteHandleB(Handle* succ) : Handle(succ) {}
ConcreteHandleB::~ConcreteHandleB() {}
void ConcreteHandleB::HandleRequest() {
if (this->GetSuccessor() != 0) {
cout << "ConcreteHandleB 我把处理权给后继节点......" << endl;
this->GetSuccessor()->HandleRequest();
}
else {
cout << "ConcreteHandleB 没有后继了，我必须自己处理......" << endl;
}
}

main.cpp

// main.cpp
#include "Handle.h"
#include <iostream>

using namespace::std;

int main(int argc, char* argv[]) {
Handle* h1 = new ConcreteHandleA();
Handle* h2 = new ConcreteHandleB();
h1->SetSuccessor(h2);
h1->HandleRequest();
return 0;
}