c++设计模式2：命令行模式

这是我在c++思考第二卷见到的例子
如下(做了一些改正)；
dev c++编程环境

1. #include <cstdlib>
2. #include <iostream>
3. #include <ctime>
4. #include <vector>
5. #include <memory>
7. using namespace std;
9. class Task
10. {
11. public:
12.     virtual void operation()=0;        
13. };
15. class TaskRunner
16. {
17. public:
18.    static void add(Task& t) {Tasks.push_back(&t);}
19.    static void run()
20.    {
21.         vector<Task*>::iterator itr = Tasks.begin();
22.         while(itr!=Tasks.end())
23.            (*itr++)->operation();      
24.    }    
25. private:  
26.    static std::vector<Task*> Tasks;
27.    TaskRunner(){}
28.    TaskRunner& operator=(TaskRunner&);
29.    TaskRunner(const TaskRunner&);
30.    static std::auto_ptr<TaskRunner> tr;
31. };
33. std::auto_ptr<TaskRunner> TaskRunner::tr;
34. vector<Task*> TaskRunner::Tasks;
36. class EventSimulator
37. {
38. public:
39.    EventSimulator(): creation(clock())
40.    {
41.        delay = CLOCKS_PER_SEC/4*(rand()%20 +1);
42.        cout<<"delay = "<<delay <<endl;                 
43.    }   
44.    bool fired()
45.    {
46.        return clock()>creation + delay;
47.    }          
48. private:
49.    clock_t creation;
50.    clock_t delay;       
51. };
53. class Button
54. {
55. public:
56.    Button(string name): pressed(false),id(name){}
57.    void press(){pressed = true;}         
58.    bool isPressed()
59.    {
60.       if(e.fired())press();
61.       return pressed;   
62.    }
63.    friend ostream&
64.    operator<<(ostream& os, const Button& b)
65.    {return os<<b.id;}  
66. private:
67.    bool pressed; 
68.    string id;
69.    EventSimulator e;
70. };
72. class CheckButton:public Task
73. {
74. public:
75.    CheckButton(Button& b):button(b), handled(false){}
76.    void operation()
77.    {
78.       if(button.isPressed() && !handled)
79.           cout<<button<<"pressed."<<endl;    
80.        handled = true;
81.    }         
82. private:
83.    Button&  button;
84.    bool handled;          
85. };
87. void procedure1()
88. {
89.      TaskRunner::run();    
90. }
92. void procedure2()
93. {
94.      TaskRunner::run();
95. }
97. void procedure3()
98. {
99.      TaskRunner::run();    
100. }
102. int main(int argc, char *argv[])
103. {
104.     srand(time(0));
105.     Button b1("button 1"), b2("button 2"), b3("button 3");
106.     CheckButton cb1(b1), cb2(b2), cb3(b3);
107.     TaskRunner::add(cb1);
108.     TaskRunner::add(cb2);
109.     TaskRunner::add(cb3);
110.     cout<<"Control-C to exit."<<endl;
111.    
112.     while(true)
113.     {
114.        procedure1();
115.        procedure2();
116.        procedure3();
117.     }
119.     system("PAUSE");
120.     return EXIT_SUCCESS;
121. }

命令模式是携带行为模式的信使

其特点就是向函数或者对象传递一个想要的动作

一个命令模式简单的例子就是
class A;
class a1 : A
class a2 : A
class a3 : A
...

class B
{
    list<A> alist...
}

在操作的时候
B::.....

个人感觉就是
在处理操作的时候发送一个泛化的命令函数过去,由具体的对象的具体处理函数执行之

当然类B可以做成一个单态模式

感觉还对这个模式不是很....