定义：

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

　　是一种递归操作，要注意所有接收者都无法处理请求的情况。

结构图： 

 

 

 

 

代码

//Handler类，定义一个处理请求的接口

class Handler
{

provite：

　　Handler* pHandler;
public:

　　//设置继任者
　　static  SetNext(Handler* pHandler)
　　{

　　　　this.pHandler = pHandler;

　　}

　　//声明处理请求的方法

　　static  HandlePequest(int irequest) = 0;

 

 }

//ConcreteHandler类，具体处理者，如果能处理则处理，如果不能则转发给后继者

 

class ConcreteHandlerA : Handler
{

 

 

public:

 

　　//具体处理请求的方法

 

　　static  HandlePequest(int irequest)

　　{

　　　　if(0 < irequest <10)

　　　　{

　　　　　　。。。;//处理请求

　　　　}

　　　　elseif ( pHandler ！= NULL )

　　　　{

　　　　　　pHandler.HandlePequest(irequest);//下一继任者处理

　　　　}

　　}

 

 }

 

class ConcreteHandlerB : Handler
{

 

public:

 

　　//具体处理请求的方法

 

　　static  HandlePequest(int irequest)

 

　　{

 

　　　　if(10 < irequest <20)

 

　　　　{

 

　　　　　　。。。;//处理请求

 

　　　　}

 

　　　　elseif ( pHandler ！= NULL )

 

　　　　{

 

　　　　　　pHandler.HandlePequest(irequest);//下一继任者处理

 

　　　　}

 

　　}

 

 }

 

//客户端

 

Handler* A = new ConcreteHandlerA();

 

Handler* B = new ConcreteHandlerB();

A.SetNext(B);

 int irequest = 15;

A.HandlePequest(irequest);

 

使用时机：

　　如果有多个对象可以处理同一个请求，但是具体由哪个对象处理是由运行时刻动态决定的，这种对象就可以使用职责链模式，把处理请求的对象实现成职责对象，然后构造链，当请求在这个链中传递的时候，会根据运行状态判断。

 

优点：

1、可以简化对象的互相连接，降低耦合度；

2、可以随时随地增加或修改请求结构，增加了给对象指派职责的灵活性；同时也可以随时增加修改处理对象。

 

缺点：

1、产生很多细粒度的对象：因为功能处理都分散到了单独的职责对象中，每个对象功能单一，要把整个流程处理完，需要很多的职责对象，会产生大量的细粒度职责对象。

 

2、不一定能处理：每个职责对象都只负责自己的部分，这样就可以出现某个请求，即使把整个链走完，都没有职责对象处理它。这就需要提供默认处理，并且注意构造链的有效性。