设计模式之行为模式-命令，迭代器，中介者，观察者，模板方法

来源：互联网发布：zbrush mac破解版编辑：程序博客网时间：2024/06/05 04:43

目录[-]

1 命令模式

2 迭代器模式

3 中介者模式

4 观察者模式

5 模板方法模式

1 命令模式

对每个执行请求进行封装。

01interface Command {
02        void execute();
03    };
04    class OpenCommand : Command {
05        void execute() {
06            // open file
07        }
08    }
09    class CloseCommand : Command {
10        void execute() {
11            // close file
12        }
13    }
14    // 菜单项实体与执行过程的解耦
15    class MenuItem {
16        string  m_caption;
17        Command m_command;
18         
19        void on_clicked() {
20            m_command.execute();
21        }
22    };
23    // 复合命令
24    class CompositeCommand : Command {
25        OpenCommand  m_openCmd;
26        CloseCommand m_closeCmd;
27         
28        void execute() {
29            m_openCmd.execute();
30            // write file ...
31            m_closeCmd.execute();
32        }
33    }

2 迭代器模式

顺序访问容器对象中的各个元素，同时不暴露容器的内部实现。

1std::list<int>  lst;
2    std::list<int>::iterator iter = lst.begin();
3    while( iter != lst.end() ) {
4        printf("%d\n", *iter);
5        ++iter;
6    }

3 中介者模式

    用一个中介对象，封装其他一系列对象的交互操作，减少这些其他对象间操作的耦合依赖。

   示例：
       1. 按钮点击后，在文本框中显示消息。
       2. 按钮与文本框没有直接耦合依赖，按钮通过中介窗口传递消息。

01// 中介接口
02    interface Mediator {
03        void button_clicked();
04    }
05    class Button {
06        Mediator  m_mediator;
07 
08        // 按钮的点击事件，通知中介者进行处理
09        void on_click() {
10            m_mediator.button_clicked();
11        }
12    }
13    class TextBox {
14        void setText(string text) { ... }
15    }
16    class Window : Mediator {
17        Button  m_button;
18        TextBox m_textbox;
19         
20        void init() {
21            m_button.m_mediator = this;
22        }
23        // 按钮通过窗口将事件消息传递给
24        void button_clicked() {
25            m_textbox.setText("button clicked");
26        }
27    }

4 观察者模式

   对象间的一对多依赖关系，一个对象状态发生改变，其他依赖其的对象会立即得到通知。
   另称为订阅-发布模式。

01class Observer {
02        void update(int state);
03    }
04     
05    class Subject {
06        vector<Observer> m_obsList;
07        int              m_state;
08         
09        void addObserver(Observer obs) {
10            m_obsList.add(obs);
11        }
12         
13        void changeState(int state) {
14            m_state = state;
15            for(i = 0; i < m_obsList.size(); ++i) {
16                m_obsList[i].update(state);
17            }
18        }
19    }

5 模板方法模式

定义一个固定的算法或执行过程骨架，执行或算法的详细过程在子类中实现。

view source
print?
01class Storage {
02    public:
03        // 对外公共接口，实现用于向目标存储单元写入数据的骨架过程
04        void saveData(char[] data) {
05            this.open();
06            this.write(data);
07            this.close();
08        }
09    protected:   
10        // 由具体的存储单位实现
11        void open() {}
12        void write(char[] data) {}
13        void close() {}
14    }
15     
16    // 文件存储单元
17    class FileStorage : Storage {
18        void open() {
19            // open file ...
20        }
21        void write(char[] data) {
22            // write data to file
23        }
24        void close() {
25            // close file
26        }
27    }
28     
29    // 数据库存储单元
30    class DBStorage : Storage {
31        void open() {
32            // open db connection ...
33        }
34        void write(char[] data) {
35            // insert data to db table
36        }
37        void close() {
38            // close db connection
39        }
40    };

0 0