设计模式C++实现（9）——命令模式

- 日理万妓 2022-06-02 08:00 246阅读 0赞

# 一、简介    #

Command命令模式为了解决的问题是：当系统请求繁多复杂时，将请求封装到一个对象（Command）中，并将请求的接受者存放到具体的ConcreteCommand类（Receiver）中，从而实现调用操作的对象和操作的具体实现者之间的解耦。

Command 模式的典型结构图为：

![Center][]

Command模式结构图中，将请求的接收者（处理者）放到Command的具体子类ConcreteCommand中，当请求到来时（Invoker 发出Invoke消息激活Command对象），ConcreteCommand将处理请求交给Receiver对象进行处理。

# 二、详解 #

## 1、正常对象参数传递调用    ##

（1）代码reveiver.h：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#ifndef \_RECEIVER\_H\_  
2.  \#define \_RECEIVER\_H\_  
3.    
4.  class Receiver  
5.  \{  
6.        public:  
7.            Receiver();  
8.            ~Receiver();  
9.            void Action();  
10.       protected:  
11.       private:  
12. \};  
13.   
14. \#endif

（2）代码reveiver.cpp：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#include <iostream>  
2.  \#include "receiver.h"  
3.  using namespace std;  
4.    
5.  Receiver::Receiver()  
6.  \{  
7.  \}  
8.    
9.  Receiver::~Receiver()  
10. \{  
11. \}  
12.   
13. void Receiver::Action()  
14. \{  
15.        cout<<"---Receiver::Action---"<<endl;  
16. \}

（3）代码invoker.h：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#ifndef \_INVOKER\_H\_  
2.  \#define \_INVOKER\_H\_  
3.    
4.  class Command;  
5.  class Invoker  
6.  \{  
7.        public:  
8.            Invoker(Command \*cmd);  
9.            ~Invoker();  
10.           void InvokeFunc();  
11.       protected:  
12.       private:  
13.           Command \*\_cmd;  
14. \};  
15.   
16. \#endif

（4）代码invoker.cpp：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#include <iostream>  
2.  \#include "invoker.h"  
3.  \#include "command.h"  
4.  using namespace std;  
5.    
6.  Invoker::Invoker(Command \*cmd)  
7.  \{  
8.      \_cmd = cmd;  
9.  \}  
10.   
11. Invoker::~Invoker()  
12. \{  
13. \}  
14.   
15. void Invoker::InvokeFunc()  
16. \{  
17.       cout<<"Invoker::InvokeFunc"<<endl;  
18.       \_cmd->Excute();  
19. \}

（5）代码command.h：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#ifndef \_COMMAND\_H\_  
2.  \#define \_COMMAND\_H\_  
3.    
4.  class Receiver;  
5.  class Command  
6.  \{  
7.        public:  
8.            virtual ~Command();  
9.            virtual void Excute() = 0;  
10.       protected:  
11.           Command();  
12.       private:  
13. \};  
14. class ConcreteCommand : public Command  
15. \{  
16.       public:  
17.           ConcreteCommand(Receiver \*rev);  
18.           ~ConcreteCommand();  
19.           void Excute();  
20.       protected:  
21.       private:  
22.           Receiver \*\_rev;  
23. \};  
24.   
25. \#endif

（6）代码command.cpp：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#include <iostream>  
2.  \#include "command.h"  
3.  \#include "receiver.h"  
4.  using namespace std;  
5.    
6.  Command::Command()  
7.  \{  
8.  \}  
9.    
10. Command::~Command()  
11. \{  
12. \}  
13.   
14. ConcreteCommand::ConcreteCommand(Receiver \*rev)  
15. \{  
16.       \_rev = rev;  
17. \}  
18.   
19. ConcreteCommand::~ConcreteCommand()  
20. \{  
21. \}  
22.   
23. void ConcreteCommand::Excute()  
24. \{  
25.       cout<<"ConcreteCommand::Excute"<<endl;  
26.       \_rev->Action();  
27. \}

（7）代码main.cpp：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#include <iostream>  
2.  \#include "receiver.h"  
3.  \#include "invoker.h"  
4.  \#include "command.h"  
5.  using namespace std;  
6.    
7.  int main()  
8.  \{  
9.        //创建具体命令对象cmd并设定它的接收者rev  
10.       Receiver \*rev = new Receiver();  
11.       Command \*cmd = new ConcreteCommand(rev);  
12.       //请求绑定命令  
13.       Invoker \*inv = new Invoker(cmd);  
14.       inv->InvokeFunc();  
15.   
16.           delete inv;  
17.           delete cmd;  
18.           delete rev;  
19.       return 0;  
20. \}

（8）代码makefile：

**\[html\]**  [view plain][]  [copy][view plain]

1.  CFLAGS = -g  
2.  DEFINED = \#-D \_VERSION  
3.  LIBS =   
4.  CC = g++  
5.  INCLUDES = -I./  
6.  OBJS= main.o receiver.o command.o invoker.o  
7.  TARGET= main  
8.  all:$(TARGET)  
9.    
10. $(TARGET):$(OBJS)  
11.     $(CC) $(CFLAGS) -o $@ $(OBJS)  
12.   
13. .SUFFIXES:.o .h  
14. .SUFFIXES:.cpp .o  
15. .cpp.o:  
16.     $(CC) $(DEFINED) -c $(CFLAGS) -o $@ $<  
17.   
18. ok:  
19.     ./$(TARGET)  
20. clean:  
21.     rm -f $(OBJS) $(TARGET) core \*.log

## 2、函数地址回调机制调用 ##

（1）代码receiver.h：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#ifndef \_RECEIVER\_H\_  
2.  \#define \_RECEIVER\_H\_  
3.    
4.  class Receiver  
5.  \{  
6.        public:  
7.            Receiver();  
8.            ~Receiver();  
9.            void Action();  
10.       protected:  
11.       private:  
12. \};  
13.   
14. \#endif

（2）代码receiver.cpp：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#include <iostream>  
2.  \#include "receiver.h"  
3.  using namespace std;  
4.    
5.  Receiver::Receiver()  
6.  \{  
7.  \}  
8.    
9.  Receiver::~Receiver()  
10. \{  
11. \}  
12.   
13. void Receiver::Action()  
14. \{  
15.        cout<<"---Receiver::Action---"<<endl;  
16. \}

（3）代码command.h：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#ifndef \_COMMAND\_H\_  
2.  \#define \_COMMAND\_H\_  
3.    
4.  class Command  
5.  \{  
6.        public:  
7.            virtual ~Command()\{\};  
8.            virtual void Excute() = 0;  
9.        protected:  
10.           Command()\{\};  
11.       private:  
12. \};  
13.   
14. template <class T>  
15. class SimpleCommand : public Command  
16. \{  
17.       public:  
18.           typedef void (T::\*ActionFunc)();  
19.           SimpleCommand(T \*rev, ActionFunc act) \{  
20.               \_rev = rev;  
21.               \_act = act;  
22.           \}  
23.           virtual void Excute() \{  
24.               (\_rev->\*\_act)();     //回调调用方式  
25.           \}  
26.           ~SimpleCommand() \{  
27.               delete \_rev;  
28.           \}  
29.       protected:  
30.       private:  
31.           T \*\_rev;  
32.           ActionFunc \_act;  
33. \};  
34.   
35. \#endif

（4）代码main.cpp：

**\[html\]**  [view plain][]  [copy][view plain]

1.  \#include <iostream>  
2.  \#include "command.h"  
3.  \#include "receiver.h"  
4.  using namespace std;  
5.    
6.  int main()  
7.  \{  
8.        Receiver \*rev = new Receiver();  
9.        Command \*cmd = new SimpleCommand<Receiver>(rev, &Receiver::Action);  
10.       cmd->Excute();  
11.         
12.       delete cmd;  
13.       return 0;  
14. \}

（4）makefile：

**\[html\]**  [view plain][]  [copy][view plain]

1.  CFLAGS = -g  
2.  DEFINED = \#-D \_VERSION  
3.  LIBS =   
4.  CC = g++  
5.  INCLUDES = -I./  
6.  OBJS= main.o receiver.o  
7.  TARGET= main  
8.  all:$(TARGET)  
9.    
10. $(TARGET):$(OBJS)  
11.     $(CC) $(CFLAGS) -o $@ $(OBJS)  
12.   
13. .SUFFIXES:.o .h  
14. .SUFFIXES:.cpp .o  
15. .cpp.o:  
16.     $(CC) $(DEFINED) -c $(CFLAGS) -o $@ $<  
17.   
18. ok:  
19.     ./$(TARGET)  
20. clean:  
21.     rm -f $(OBJS) $(TARGET) core \*.log

##     ##

## 3、运行结果 ##

（Centos6.3系统中运行结果：）

![Center 1][]

Command模式的实现和思想都很简单，其关键就是将一个请求封装到一个类（Command）中，再提供处理对象（Receiver），最后Command命令由Invoker激活。

在上述2中用到 C++中的类成员函数指针，将请求接收者的处理抽象出来作为参数传给Command对象，实际也就是回调的机制（Callback）来实现这一点，即将处理操作方法地址（在对象内部）通过参数传递给Command对象，Command在适当的时候（Invoke激活的时候）再调用该函数。

# 三、总结    #

（1）Command模式关键就是提供一个抽象的Command类，并将执行操作封装到Command类接口中，Command类中一般就是只是一些接口的集合，并不包含任何的数据属性。

（2）Command模式将调用操作的对象和知道如何实现该操作的对象解耦，在上述结构图中Invoker对象根本就不知道具体的是那个对象在处理Excute操作（当然要知道是Command类别的对象，也仅此而已）。  
（3）在Command要增加新的处理对象很容易，可以通过创建新的继承自Command的子类来实现这一点。

（4）Command模式可以和Memento模式结合起来，支持取消的操作。

（5）源码已经打包上传到csdn上可登录下载（[http://download.csdn.net/detail/taiyang1987912/8437165][http_download.csdn.net_detail_taiyang1987912_8437165]）。

**本文转自：**

**http://blog.csdn.net/taiyang1987912/article/details/43567077**

[Center]: /images/20220602/e47d3fa26d87499dabf068e9a5d15541.png
[view plain]: http://blog.csdn.net/taiyang1987912/article/details/43567077#
[Center 1]: /images/20220602/858a14dae6f2463a96b790fb37a77603.png
[http_download.csdn.net_detail_taiyang1987912_8437165]: http://download.csdn.net/detail/taiyang1987912/8437165

发表评论取消回复

表情：

评论列表（有 0 条评论，246人围观）

还没有评论，来说两句吧...

相关阅读

相关 c++设计模式之命令模式

什么是命令模式？在GOF的《设计模式:可复用面向对象软件的基础》一书中对命令模式是这样说的：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记

﹏ヽ暗。殇╰゛Y/ 2023年06月28日 11:22/ 0 赞/ 67 阅读

相关 C++设计模式-命令模式

命令模式-行为变化模式定义：将一个请求（行为）封装为一个将对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。----《

叁歲伎倆/ 2022年11月10日 05:42/ 0 赞/ 158 阅读

相关 C++设计模式命令模式(服务员命令厨师)

文章目录 1. 基础知识 2. 逻辑代码 3. 应用 3.1 服务员命令厨师上菜 1. 基础知识命令模式（Command Patt

╰半橙微兮°/ 2022年08月28日 05:39/ 0 赞/ 201 阅读

相关【C#设计模式-命令模式】

一.定义：命令模式是将一类对象的功能操作进行抽象，一般来说，这些对象有相同的方法，所以这类对象有着类似的操作，我们通过抽象，就可以定义出一个命令对象，通过这样的方式，用户程序

清疚/ 2022年08月21日 13:55/ 0 赞/ 157 阅读

相关设计模式C++实现（9）——命令模式

一、简介 Command命令模式为了解决的问题是：当系统请求繁多复杂时，将请求封装到一个对象（Command）中，并将请求的接受者存放到

- 日理万妓/ 2022年06月02日 08:00/ 0 赞/ 247 阅读

相关设计模式C++实现（9）——享元模式

软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需

爱被打了一巴掌/ 2022年04月24日 06:24/ 0 赞/ 256 阅读

相关设计模式9-适配器模式

什么是适配器在设计模式中，适配器模式（英语：adapter pattern）有时候也称包装样式或者包装(wrapper)。将一个类的接口转接成用户所期待的。一个适配使得

今天药忘吃喽~/ 2022年04月12日 08:55/ 0 赞/ 190 阅读

相关 [设计模式][c++] 命令模式(command)

class Command : public eastl::intrusive_list_node { NON_COPYABLE

喜欢ヅ旅行/ 2022年04月06日 09:09/ 0 赞/ 286 阅读

相关 [C++实现设计模式(9)] : 命令模式

文章目录情景描述命令模式的定义命令模式的应用命令模式的优点

Myth丶恋晨/ 2022年01月23日 20:15/ 0 赞/ 293 阅读

相关 C#设计模式之11：命令模式

C\设计模式之11：命令模式命令模式命令模式用来解决一些复杂业务逻辑的时候会很有用，比如，你的一个方法中到处充斥着if else 这种结构的时候，用命令模式来解

落日映苍穹つ/ 2021年12月16日 23:21/ 0 赞/ 342 阅读