design_pattern_command

最新推荐文章于 2016-05-18 16:09:13 发布
最新推荐文章于 2016-05-18 16:09:13 发布
阅读量421 收藏
点赞数
分类专栏： Design Pattern C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhucai4/article/details/44131751
版权

This post implements the command pattern in the book <Head First Design Patterns>. TheCommand Pattern encapsulates a request as an object, thereby, letting you parametrize other objects with different requests, queue or log requests, and support undoable operations.

The command object encapsulates a request by binding together a set of actions on a specific receiver. To achieve this, it packages the actions and the receiver up into an object that exposes just one method,execute(). When called, execute() causes the actions to be invoked on the receiver. From the outside, no other objects really know what actions get performed on what receiver. They just know that if they call theexecute() method, their request will be served.

A command is a method call wrapped in an object. Commands are an object-oriented replacement for callbacks. The basic procedure for command pattern is

  1. Define a Command interface with a method signature like execute().
  2. Create one or more derived classes that encapsulate some subsetof the following: a "receiver" object, the method to invoke, the arguments to pass.
  3. Instantiate a Command object for each deferred execution request.
  4. Pass the Command object from the creator (aka sender) to the invoker (aka receiver).
  5. The invoker decides when to execute().

Let's implement the example in the book. First we define vendor's classes.

class Light{
private:
    std::string location;

public:
    Light(const std::string location_): location(location_){}

    void on() const{
		std::cout << location.c_str() << " light is on" << std::endl;
	}
	void off() const {
		std::cout << location.c_str() << " light is off" << std::endl;
	}
};

class TV{
private:
    mutable int channel;
	std::string location;

public:
    TV(const std::string location_):channel(0), location(location_){}

	void on() const{
		std::cout << location.c_str() << " TV is on" << std::endl;
	}
	void off() const{
		std::cout << location.c_str() << " TV is off" << std::endl;
	}
	void setInputChannel(){
		channel = 3;
		std::cout << location.c_str() << " Channel is set for VCR" << std::endl;
	}
};

class Stereo{
private:
    std::string location;

public:
    Stereo(std::string location):location(location_){}

	void on() const {
		std::cout << location.c_str() << " stereo is on" << std::endl;
	}

	void off() const {
		std::cout << location.c_str() << " stereo is off" << std::endl;
	}

	void setCD() const {
		std::cout << location.c_str() << " stereo is set for CD input" << std::endl;
	}

 	void setDVD() const {
		std::cout << location.c_str() << " stereo is set for DVD input" << std::endl;
	}

	void setRadio() const {
		std::cout << location.c_str() << " stereo is set for Radio" << std::endl;
	}

	void setVolume(int volume) const {
		// code to set the volume
		// valid range: 1-11 (after all 11 is better than 10, right?)
		std::cout << location.c_str() << " Stereo volume set to " << volume << std::endl;
	}
};

class Hottub{
private:
    mutable bool on;
	mutable int temperature;

public:
    Hottub():on(false), temperature(0){}

	void hottubon() const { on = true; }
	void hottuboff() const { on = false; }

	void bubblesOn() const {
		if(on){
			std::cout << "Hottub is bubbling!" << std::endl;
		}
	}

	void bubblesOff() const {
		if(on){
			std::cout << "Hottub is not bubbling" << std::endl;
		}
	}

	void jetsOn() const {
		if(on){
			std::cout << "Hottub jets are on" << std::endl;
		}
	}

	void jetsOff() const {
		if(on) {
			std::cout << "Hottub jets are off" << std::endl;
		}
	}

	void setTemperature(int temperature_) {
		temperature = temperature_;
	}

	void heat() const {
        temperature = 105;
		std::cout << "Hottub is heating to a steaming 105 degrees" << std::endl;
	}

	void cool() const {
		temperature = 98;
		std::cout << "Hottub is cooling to 98 degrees" << std::endl;
	}
};

class GarageDoor {
private:
    std::string location;

public:
    GarageDoor(const std::string location_):location(location_) {}

 	void up() const {
		std::cout << location.c_str() << " Door is Up" << std::endl;
	}

	void down() const {
		std::cout << location.c_str() << " Door is Down" << std::endl;
	}

	void stop() const {
		std::cout << location.c_str() << " Door is Stopped" << std::endl;
	}

	void lightOn() const {
		std::cout << location.c_str() << " light is on" << std::endl;
	}

	void lightOff() const {
		std::cout << location.c_str() << " light is off" << std::endl;
	}
};

class CeilingFan {
private:
    mutable int level;
	std::string location;

public:
    static const int HIGH = 2;
	static const int MEDIUM = 1;
	static const int LOW = 0;

    CeilingFan(const std::string location_):level(LOW), location(location_) {}

	void high() const {
		level = HIGH;
		std::cout << location.c_str() << " ceiling fan is on high" << std::endl;
	}

	void medium() const {
		level = MEDIUM;
		std::cout << location.c_str() << " ceiling fan is on medium" << std::endl;
	}
	public: void low() const {
		level = LOW;
		std::cout << location.c_str() << " ceiling fan is on low" << std::endl;
	}
	public: void off() const {
		level = 0;
		std::cout << location.c_str() << " ceiling fan is off" << std::endl;
	}
	public: int getSpeed() const {
		return level;
	}
};
Then we define command process 

class Command {
public:
    virtual void execute() const = 0;
};

class LightOnCommand : public Command {
private:
    const Light* light;

public:
    LightOnCommand(const Light* light_) : light(light_){}

	void execute() const {
		light->on();
	}

	~LightOnCommand(){
        delete light;
        light = NULL;
	}
};

class LightOffCommand : public Command {
private:
    const Light* light;

public:
    LightOffCommand(const Light* light_) : light(light_){}

	void execute() const {
		light->off();
	}

	~LightOffCommand(){
        delete light;
        light = NULL;
	}
};

class LivingroomLightOnCommand : public Command {
private:
    const Light* light;

public:
    LivingroomLightOnCommand(const Light* light_):light(light_){}

	void execute() const {
		light->on();
	}

	~LivingroomLightOnCommand(){
        delete light;
        light = NULL;
	}
};

class LivingroomLightOffCommand : public Command {
private:
    const Light* light;

public:
    LivingroomLightOffCommand(const Light* light_):light(light_){}

	void execute() const {
		light->off();
	}

	~LivingroomLightOffCommand(){
        delete light;
        light = NULL;
	}
};

class NoCommand : public Command{
public:
    void execute() const {};
};

The remote control class is given by

class RemoteControl {
private:
    static const int SLOTS = 7;
    Command* onCommands[SLOTS];
	Command* offCommands[SLOTS];
	Command* noCommand;

	RemoteControl(const RemoteControl& );  // Disable copy constructor
	void operator=(const RemoteControl& ); // Disable assignment operator

public:
    RemoteControl() {
		noCommand = new NoCommand();
		for(int i = 0; i < SLOTS; i++) {
			onCommands[i]  = noCommand;
			offCommands[i] = noCommand;
		}
	}

	~RemoteControl() {
	    for(int i = 0; i < SLOTS; i++) {
			delete onCommands[i];
			delete offCommands[i];
			onCommands[i] = NULL;
			offCommands[i] = NULL;
		}
		delete noCommand;
		noCommand = NULL;
	}

	void setCommand(int slot, Command* onCommand, Command* offCommand){
		onCommands[slot] = onCommand;
		offCommands[slot] = offCommand;
	}

	void onButtonWasPushed(int slot) const {
		onCommands[slot]->execute();
	}

	void offButtonWasPushed(int slot) const {
		offCommands[slot]->execute();
	}

	void toString() const {
		std::cout << "\n------ Remote Control -------\n" << std::endl;
		for( int i = 0; i < SLOTS; i++ ) {
			std::cout << "[slot " << i << "] ";
			std::cout << typeid( *onCommands[i] ).name();
			std::cout << "    ";
			std::cout << typeid( *offCommands[i] ).name();
			std::cout << std::endl;
		}
	}
};

The main function is 

#include <iostream>
#include <typeinfo>
#include <./vendor.hpp>
#include <./command.hpp>
#include <./remotecontrol.hpp>
using namespace std;

int main()
{
    RemoteControl* rc = new RemoteControl();

    Light* livingRoomLight = new Light("Living Room");
	Light* kitchenLight = new Light("Kitchen");

	LightOnCommand* livingRoomLightOn = new LightOnCommand(livingRoomLight);
    LightOffCommand* livingRoomLightOff = new LightOffCommand(livingRoomLight);
	LightOnCommand* kitchenLightOn = new LightOnCommand(kitchenLight);
	LightOffCommand* kitchenLightOff = new LightOffCommand(kitchenLight);

	rc->setCommand( 0, livingRoomLightOn, livingRoomLightOff);
	rc->setCommand( 1, kitchenLightOn, kitchenLightOff);

	rc->onButtonWasPushed(0);
	rc->offButtonWasPushed(0);
	rc->onButtonWasPushed(1);
	rc->offButtonWasPushed(1);

	delete rc;

    return 0;
}



zhucai4
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Command-Design-Pattern
05-14
2017-2018设计原则 专案3 项目定义 使用我们在课堂上介绍的一种（或可能多种）设计模式解决软件开发问题。 您的问题应该与以前的项目不同。 去做 工作说明：使用100-200个字详细地写出您的问题定义。...
《Design Patterns》Command.积跬步系列
Is-Me-HL
03-09 103
Command：命令模式 先代码 package h.l.demo.command; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; import java.util.List; /** * 用来声明执行操作的接口 */ abstract class Command ...
COMMAND 模式
aitinuo1702的博客
06-18 137
COMMAND 模式 ——《敏捷软件开发 原则、模式与实践（c#版）》第21章 描述 COMMAND模式是最简单、最优雅的模式之一。 如图1-1所示，COMMAND模式简单的几乎可笑。该模式仅由一个具有唯一方法的接口组成，这似乎很荒谬？代码1-1 给出了图1-1对应的代码。 图1-1 COMMAND 模式 代码清单 1-1 Command...
Design Patterns-Command Pattern（译）
weixin_34212189的博客
05-18 80
原文连接译者 smallclover希望对大家有所帮助。谢谢！(●'◡'●) 设计模式-命令模式 命令模式是一种数据驱动的设计模式，属于行为型模式这一类。命令模式会将一个请求包装成一个对象并以命令的方式传递给调用者对象。调用者对象会寻找合适的并且能够处理该命令的对象，然后把该命令传递给相应的对象处理。 实现 我们创建了一个Order接口，...
《JAVA与模式》之命令模式
weixin_30832143的博客
06-01 122
在阎宏博士的《JAVA与模式》一书中开头是这样描述命令（Command）模式的： 　　命令模式属于对象的行为模式。命令模式又称为行动(Action)模式或交易(Transaction)模式。 　　命令模式把一个请求或者操作封装到一个对象中。命令模式允许系统使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。 命令模式的结构 　　命令模式是对命令的封装。命...
Design Pattern Command 命令设计模式
靖空间
07-27 1465
本设计模式就是利用不同的类包起不同的命令，达到使用什么命令就实现什么操作。 也可以进一步利用map和自己喜欢的命令词对接起来。 一个执行类实际上已经包含了所有需要的操作了，如： class SuperMaker { public: string makeCar() { return "Car"; } string makePlane() { return "Plane";
go-design-pattern
03-07
去设计模式简单工厂模式（Simple Factory Pattern） ➜ simple_factory (main) ✗ go test -v * .go=== RUN TestCacheFactory_Createredis data: v1mem data: m1--- PASS: TestCacheFactory_Create (0.00s)PASSok ...
design-pattern-java.pdf
04-08
命令模式-Command Pattern 请求发送者与接收者解耦——命令模式（一） 请求发送者与接收者解耦——命令模式（二） 请求发送者与接收者解耦——命令模式（三） 请求发送者与接收者解耦——命令模式（四） 请求发送者...
CoreJava-DesignPattern
05-31
CoreJava-DesignPattern 创意设计模式 -- Abstract Factory - Done -- Builder - Done -- Factory Method -- Object Pool -- Prototype - Done -- Singleton - Done 结构设计模式 -- Adapter -- Bridge -- ...
design_patterns:我最常见的设计模式示例
05-14
然后，将此类与最终接收方绑定（关联），然后将Concrete Command方法映射到相应的最终接收方方法。 策略模式定义了一系列算法，将每个算法封装在一起，并使它们可互换 我们通过提取与普通代码不同的内容来实现此...
design_pattern_singleton
海边的八达通
03-08 517
The Singleton Pattern ensures a class has only one instance, and provides a global point of access to it. What is our motivation to use it? In nearly every application, there is a need to have an
design_pattern_derivative_payoff
海边的八达通
03-21 506
In the option pricing framework, the first component which always changes is option's payoff.  Therefore, we need to  encapsulation the payoff class. First of all, we define an abstract PayOff class,
design_pattern_derivative_randomnumber
海边的八达通
03-22 500
We have implemented payoff, option, statistics class. In our calculation for option price, we have used gsl library to generate random numbers, gsl is a high quality numerical library, however,  to pr
design_pattern_derivative_statistics
海边的八达通
03-22 476
Our monte carlo rounte  lacks any indication of the simulation’s convergence. We could make the routine return standard error, or a convergence table, or simply have it return the value for every sing
design_pattern_factory
海边的八达通
03-04 449
This post implements design pattern factory in . The factory design pattern has three levels, simple factory, factory method, abstract factory method. In OOP terminology, a factory is a class for crea
design_pattern_observer
海边的八达通
03-04 425
This post implements observer pattern in . Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all of its dependents are notified and updated aut
design_pattern_strategy
海边的八达通
03-04 404
This post implement strategy pattern, described in . The class structure is as follows class FlyBehavior{ public: virtual void fly() = 0; }; class FlyWithWings : public FlyBehavior{ public:
design_pattern_derivative_option
海边的八达通
03-22 395
If we consider option as a whole, the basic components are expiration and payoff. We want to define a Vanilla Option class which has as data members a PayOff object and a double to represent expiry. H
DESIGN_CONFIG
最新发布
11-14
根据提供的引用内容，DESIGN_CONFIG应该是一个配置文件，用于存放DC（Design Compiler）的一些配置信息。其中包括SYN_ROOT_PATH和CONFIG_PATH两个路径的设置。SYN_ROOT_PATH是总的设计路径，而CONFIG_PATH则是放置DC...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值