设计模式--行为型模式之一--Chain of Responsibility 行为链

 

意图：

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

 

适用性：

1有多个的对象可以处理一个请求，哪个独享处理该请求运行时刻自动决定

2在不确定接受者的情况下，向多个对象中的一个提交一个请求

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

 

效果：

1降低耦合度 使得一个对象无需知道是其他哪一个对象处理请求。接收方和发送方都没有对方的明确信息，且链中对象不需知道链的结构

 

2增强了给对象指派职责的灵活性 当在对象中分派职责时，职责链给你更大的灵活性，可以通过在运行时刻对该链进行动态的增加或修改来增加或改变处理一个请求的那些职责

 

3不保证被接受

 

Chain.h

1. typedef int Topic;
2. const Topic NO_HELP_TOPIC = -1;
3. class HelpHandler
4. {
5. public:
6.     HelpHandler(HelpHandler* = 0,Topic = NO_HELP_TOPIC);
7.     virtual bool HasHelp();
8.     virtual void SetHandler(HelpHandler*,Topic);
9.     virtual void HandleHelp();
10. private:
11.     HelpHandler* _successor;
12.     Topic _topic;
14. };
16. class Widget:public HelpHandler
17. {
18. protected:
19.     Widget(Widget* parent,Topic t = NO_HELP_TOPIC);
20. private:
21.     Widget* _parent;
22. };
24. class Button: public Widget
25. {
26. public:
27.     Button(Widget* d,Topic t = NO_HELP_TOPIC);
28.     virtual void HandleHelp();
29. };
31. class Dialog:public Widget
32. {
33. public:
34.    Dialog(HelpHandler* h,Topic t =NO_HELP_TOPIC);
35.    virtual void HandleHelp();
36. };
38. class Application:public HelpHandler
39. {
40. public:
41.     Application(Topic t):HelpHandler(0,t){}
42.     virtual void HandleHelp();
43. };

 

Chain.cpp

 

 

1. #include "Chain.h"
2. #include <iostream>
3. #include <string>
4. using namespace std;
5. HelpHandler::HelpHandler(HelpHandler* h,Topic t):_successor(h),_topic(t)
6. {
7. }
9. void HelpHandler::HandleHelp()
10. {
11.     if (_successor != 0)
12.     {
13.         _successor->HandleHelp();
14.     }
15. }
17. bool HelpHandler::HasHelp()
18. {
19.     return _topic != NO_HELP_TOPIC;
20. }
22. void  HelpHandler::SetHandler(HelpHandler* h,Topic t)
23. {
24.     _successor = h;
25.     _topic = t;
26. }
27. Widget::Widget(Widget* parent,Topic t ):HelpHandler(parent,t)
28. {
29.     _parent = parent;
30. }
32. Button::Button(Widget* parent,Topic t):Widget(parent,t){}
33. void Button::HandleHelp()
34. {
35.     if (HasHelp())
36.     {
37.         cout<<"Provide Button Level Help"<<endl;
38.     }
39.     else
40.     {
41.         HelpHandler::HandleHelp();
42.     }
43. }
45. Dialog::Dialog(HelpHandler* h,Topic t):Widget(0)
46. {
47.     SetHandler(h,t);
48. }
49. void Dialog::HandleHelp()
50. {
51.     if (HasHelp())
52.     {
53.         cout<<"Provide Dialog Level Help"<<endl;
54.     }
55.     else
56.     {
57.         HelpHandler::HandleHelp();
58.     }
59. }
61. void Application::HandleHelp()
62. {
63.     cout<<"Show a list of Help topics"<<endl;
64. }

main.cpp

1. #include "Chain.h"
2. #include <iostream>
3. #include <string>
4. using namespace std;
5. int main()
6. {
7.     const Topic PRINT_TOPIC = 1;
8.     const Topic PAPER_ORIENTATION_TOPIC = 2;
9.     const Topic APPLICATION_TOPIC = 3;
10.     Application* application = new Application(APPLICATION_TOPIC);
11.     Dialog* dialog1 = new Dialog(application,PRINT_TOPIC);
12.     Button* button1 = new Button(dialog1,PAPER_ORIENTATION_TOPIC);
13.     Button* button2 = new Button(dialog1,NO_HELP_TOPIC);
14.     Dialog* dialog2 = new Dialog(application,NO_HELP_TOPIC);
15.     button1->HandleHelp();
16.     button2->HandleHelp();
17.     //button3->HandleHelp();
18.     dialog1->HandleHelp();
19.     dialog2->HandleHelp();
20.     return 0;
21. }