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

最新推荐文章于 2022-05-31 17:14:03 发布
最新推荐文章于 2022-05-31 17:14:03 发布
阅读量176 收藏
点赞数
分类专栏： C++ 设计模式 文章标签： 设计模式 命令模式


一、简介

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

         Command 模式的典型结构图为：

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

二、详解

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

（1）代码reveiver.h：

[html]  view plain  copy
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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系统中运行结果：）

      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://blog.csdn.net/taiyang1987912/article/details/43567077







路痴的旅行
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Makefile 静态模式——$(objects): %.o: %.c、$<
aijia7039的博客
03-15 2543
静态模式 最近看Makefile，正常依赖没什么问题，但是遇到一些特殊的符号就有点不明白了，例如：$(objects): %.o: %.c、$<之类的。最近看了篇文章写的不错，贴出来供大家分享。 静态模式可以更加容易地定义多目标的规则，可以让我们的规则变得更加的有弹性和灵活。我们还是先来看一下语法： <targets ...>: <target-patter...
设计模式之command模式
06-03 1553
command 模式：在客户和服务之间增加了一个中间层，使得双方相互独立。即，将命令的发送和接收分离。而对服务端和客户段可见的只是中间层提供的接口。command 模式就是面向接口的模式。中间层将客户端欲调用的所有请求封装成类，客户端一改往日的直接调用命令为调用中间层命令类的对象，从而对客户端屏蔽了所有命令的细节。此法能有效降低耦合度(模块之间的联系程度)。当中间层命令代码改变时无需修改客户端代码
Makefile知识点分析
yjlyyj的博客
05-31 341
Makefile详细介绍
23种设计模式之十九（行为模式）Command模式
乌托邦
02-10 978
一、简介       Command命令模式 Factory 模式是为了解决两类问题： 二、详解 1、代码实现 （1）代码product.h： 2、运行结果 （Centos6.3系统中运行结果：） 三、总结 （1） （4）源码已经打包上传到csdn上可登录下载。
命令模式最简单实现
02-19
命令模式，最简单的实现命令模式，没有对需求的负责理解，只针对模式本身。最纯粹的体现命令模式的特点
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar )
06-13
*5.6 C＋＋处理字符串的方法——字符串类与字符串变量 5.6.1 字符串变量的定义和引用 5.6.2 字符串变量的运算 5.6.3 字符串数组 5.6.4 字符串运算举例 习题 第6章 指针 6.1 指针的概念 6.2 变量与指针 6.2.1 定义...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
*5.6 C＋＋处理字符串的方法——字符串类与字符串变量 5.6.1 字符串变量的定义和引用 5.6.2 字符串变量的运算 5.6.3 字符串数组 5.6.4 字符串运算举例 习题 第6章 指针 6.1 指针的概念 6.2 变量与指针 6.2.1 定义...
C++MFC教程
05-21
Visual C++MFC入门教程 目录 +-- 第一章 VC入门 |------ 1.1 如何学好VC |------ 1.2 理解Windows消息机制 |------ 1.3 利用Visual C++/MFC开发Windows程序的优势 |------ 1.4 利用MFC进行开发的通用方法介绍 |----...
c++语言程序设计（第三版）
12-09
12.2 C＋＋异常处理的实现 12.3 异常处理中的构造与析构 12.4 小结 习题 第13章 MFC库与Windows程序开发概述 13.1 Windows的编程模式 13.2 MFC库简介 13.3 使用VisualC＋＋开发Windows程序的步骤 13.4 小结 习题 ...
Command模式
KangRoger的专栏
08-12 1434
在开发中，有时需要向对象发送请求，但是不知道请求的接受者是谁，被请求的操作是什么。这时可以使用command模式。Command模式将请求封装到一个对象（Command）中，并将请求的接受者存放到具体的ConcreteCommand类中的Receiveer中。这样实现了操作的对象和操作的具体实现之间的解耦。
Makefile中的宏定义必须采用 $(CC)和 $(CFLAGS)么？
weixin_34100227的博客
12-05 2741
如题： In particular, the macro CC is the C compiler to use, and CFLAGS is the list of flags to pass to the compilation command. 验证如下，Makefile原有内容 CC=gccCFLAGS=-I. hellomake: hell...
23种设计模式之八（结构型模式）Decorator模式
乌托邦
02-02 884
一、简介         Factory 模式是为了解决两类问题： 二、详解 1、代码实现 （1）代码product.h： 2、运行结果 （Centos6.3系统中运行结果：） 四、总结 （1）Factory 模式在实际开发中应用非常广泛，面向对象的系统经常面临着对象创建问题：要创建的类实在是太多了，而 Factory 提供的创建对象的接口封装（
行为模式之Command（命令模式） | C++
qq_38801934的博客
12-11 165
一、学前思考 1.命令模式可以应用到撤回和反撤回功能的使用 2.个人理解：命令模式就是把请求的执行请求的行为隔离 二、行为模式之Command（命令模式） 1.动机 将行为实现着和行为请求者解耦，因为在诸如对行为进行“记录、撤销/反撤销（undo/redo）、事物”等处理中这种无法抵御变化的紧耦合是合适的。 2.模式定义 将一个请求（行为）封装为一个对象，从而使你可用不同的请求对客户进行参数化；对...
Makefile 使用方法
AI.PLAY
01-30 2358
Framebuffer驱动 为什么要用frambuffer 如果我们的系统要用GUI（图形界面接口），比如minigui，MicroWindows.这时LCD设备驱动程序就应该编写成frambuffer接口，而不是编写成仅仅操作底层的LCD控制器接口。 什么是frambuffer设备 frambuffer设备层是对图像设备的一种抽象，它代表了视频硬件的帧缓........................
命令模式(我的理解)
baggio785的专栏
05-23 2067
前言第一章：通常的命令模式第二章：简化的命令模式第三章：其他要说的内容前言以下是我对命令模式的理解。可能和很多其他文章讲述的不太一样。经过我理解加工的。供大家参考！学艺不精，并且写的比较仓促，还请大家指教。通常的命令模式：1．1通常命令模式有一下几个角色调用者：（命令的执行者）生成有序的命令队列按顺序执行命令操作提供撤销命令操作记录已经操作的命令抽象命令：抽象的命令接口具体命令：具体的命令。由三个
设计模式之 command
Not_Plain的专栏
07-11 535
常见设计模式的解析和实现(C++)之十四-Command模式 作用:<br />将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤消的操作.<br /><br />UML结构图:<br /><br /><br />解析:<br />Comnand模式的思想是把命令封装在一个类中,就是这里的Command基类,同时把接收对象也封装在一个类中就是这里的Receiver类中,由调用这个命令的类也就是这里的Invoker类来调用.其实,如果弄清楚了Command
c++实现适配器设计模式
最新发布
08-24
适配器设计模式是一种结构型设计模式，它用于将一个类的接口转换为客户端所期望的另一个接口。在C语言中，可以通过以下步骤来实现适配器设计模式： 1. 首先，定义目标接口（Target Interface），这是客户端期望的接口。它可以是一个抽象基类或者一个纯虚函数。 ```c // 目标接口 typedef struct { void (*request)(void); } TargetInterface; ``` 2. 接下来，实现需要适配的类（Adaptee Class）。这个类拥有与目标接口不同的接口。 ```c // 需要适配的类 typedef struct { void (*specificRequest)(void); } AdapteeClass; void specificRequestImpl(void) { // 执行特定的操作 } ``` 3. 创建适配器类（Adapter Class），该类继承或包含目标接口，并将其方法委托给适配的类。 ```c // 适配器类 typedef struct { TargetInterface targetInterface; AdapteeClass* adaptee;} AdapterClass; void requestImpl(void) { AdapterClass* adapter = (AdapterClass*)this; adapter->adaptee->specificRequest(); } TargetInterface* createAdapter(AdapteeClass* adaptee) { AdapterClass* adapter = (AdapterClass*)malloc(sizeof(AdapterClass)); adapter->targetInterface.request = requestImpl; adapter->adaptee = adaptee; return &(adapter->targetInterface); } ``` 4. 最后，客户端可以通过目标接口来使用适配器。 ```c int main() { AdapteeClass adaptee; adaptee.specificRequest = specificRequestImpl; TargetInterface* adapter = createAdapter(&adaptee); adapter->request(); return 0; } ``` 上述代码演示了适配器设计模式的简单实现。通过适配器类的创建和使用，客户端可以通过目标接口调用适配的类的方法，实现了将两个不兼容接口之间的适配。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值