Command模式

最新推荐文章于 2024-11-04 10:42:34 发布
原创 最新推荐文章于 2024-11-04 10:42:34 发布 · 102 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C #C++ #C# #UP

1,接受者作为命令实现类的一个成员(组合的思想),command类的execute方法,执行接受者要执行的动作.

2,一个简单的实例:

#include <iostream>
#include <cassert>
#include <memory>
using namespace std;

/*********************Command对象基类************************/
class Command
{
public:
    virtual ~Command() = 0;
	virtual void execute() const = 0;
};
Command::~Command() {}

/***********具体Command类,封装一个接受者和其行为**********/
class Light //接受者
{
	public: Light() {}
	public: void on() const
	{
		std::cout << "Light is on" << std::endl;
	}
	public: void off() const
	{
		std::cout << "Light is off" << std::endl;
	}
};


class LightOnCommand : public Command
{
public:
    explicit LightOnCommand( const Light* light ) :
		_light( light )
    {
        assert( light );
	}
	void execute() const
	{
		_light->on();
	}
private:
    const Light* _light;
};

class LightOffCommand : public Command
{
public:
    explicit LightOffCommand( const Light* light ) :
		_light( light )
    {
        assert( light );
	}
	public: void execute() const
	{
		_light->off();
	}
private:
    const Light* _light;
};

class GarageDoor
{
public:
    GarageDoor() {}
	void up() const
	{
		cout << "Garage Door is Open" << endl;
	}
	void down() const
	{
		cout << "Garage Door is Closed" << endl;
	}
	void stop() const
	{
		cout << "Garage Door is Stopped" << endl;
	}
	void lightOn() const
	{
		cout << "Garage light is on" << endl;
	}
	void lightOff() const {
		cout << "Garage light is off" << endl;
	}
};

class GarageDoorOpenCommand : public Command
{
public:
    explicit GarageDoorOpenCommand( const GarageDoor* garageDoor) :
		_garageDoor( garageDoor )
    {
        assert( garageDoor );
	}
	void execute() const
	{
		_garageDoor->up();
	}
private:
    const GarageDoor* _garageDoor;
};

/******************控制类************************/
class SimpleRemoteControl
{
public:
    SimpleRemoteControl() :
		_slot( 0 )
    {}
	public: void setCommand( const Command* command )
	{
	    assert( command );
		_slot = command;
	}
	public: void buttonWasPressed() const
	{
	    assert( _slot );
		_slot->execute();
	}
private:
    const Command* _slot;
};

int main()
{
	auto_ptr< SimpleRemoteControl > remote( new SimpleRemoteControl() );
	auto_ptr< Light > light( new Light() );
	auto_ptr< GarageDoor > garageDoor( new GarageDoor() );
	auto_ptr< LightOnCommand > lightOn( new LightOnCommand( light.get() ) );
	auto_ptr< GarageDoorOpenCommand > garageOpen( new GarageDoorOpenCommand(garageDoor.get() ) );

	remote->setCommand( lightOn.get() );
	remote->buttonWasPressed();
	remote->setCommand( garageOpen.get() );
	remote->buttonWasPressed();
    return 0;
}


3,遥控器实例:

#include <iostream>
#include <cassert>
#include <memory>
#include <sstream>
#include <typeinfo>
using namespace std;

/*********************Command对象基类************************/
class Command
{
protected:
    Command() {}
public:
    virtual ~Command() = 0;
	virtual void execute() const = 0;
private:
    Command( const Command& ); // Disable copy constructor
	void operator=( const Command& ); // Disable assignment operator
};
Command::~Command() {}

/**************特殊的空类**********************/
class NoCommand : public Command
{
public:
    void execute() const {}
};

/***************接受者及其命令对象***************/
class CeilingFan
{
public:
    explicit CeilingFan( const string location ) :
		_level( LOW ), _location( location )
    {}
	void high() const
	{
		_level = HIGH;
		cout << _location.c_str() << " ceiling fan is on high" << endl;
	}
	void medium() const
	{
		_level = MEDIUM;
		cout << _location.c_str() << " ceiling fan is on medium" << endl;
	}
	public: void low() const
	{
		_level = LOW;
		cout << _location.c_str() << " ceiling fan is on low" << endl;
	}
	void off() const
	{
		_level = 0;
		cout << _location.c_str() << " ceiling fan is off" << endl;
	}
	int getSpeed() const
	{
		return _level;
	}
public:
    static const int HIGH = 2;
	static const int MEDIUM = 1;
	static const int LOW = 0;
private:
    mutable int _level;
	string _location;
};

class CeilingFanOnCommand : public Command
{
public:
    explicit CeilingFanOnCommand( const CeilingFan* ceilingFan ) :
		_ceilingFan( ceilingFan )
    {
        assert( ceilingFan );
	}
	void execute() const
	{
		_ceilingFan->high();
	}
private:
    const CeilingFan* _ceilingFan;
};

class CeilingFanOffCommand : public Command
{
public:
    explicit CeilingFanOffCommand( const CeilingFan* ceilingFan ) :
		_ceilingFan( ceilingFan )
    {
        assert( ceilingFan );
	}
	void execute() const
	{
		_ceilingFan->off();
	}
private:
    const CeilingFan* _ceilingFan;
};

class GarageDoor
{
public:
    explicit GarageDoor( const string location ) :
		_location( location )
    {}
 	void up() const
 	{
		cout << _location.c_str() << " Door is Up" << endl;
	}
	void down() const
	{
		cout << _location.c_str() << " Door is Down" << endl;
	}
	void stop() const
	{
		cout << _location.c_str() << " Door is Stopped" << endl;
	}
	void lightOn() const
	{
		cout << _location.c_str() << " light is on" << endl;
	}
	void lightOff() const
	{
		cout << _location.c_str() << " light is off" << endl;
	}
private:
    string _location;
};

class GarageDoorUpCommand : public Command
{
public:
    explicit GarageDoorUpCommand( const GarageDoor* garageDoor ) :
		_garageDoor( garageDoor )
    {
        assert( garageDoor );
	}
	public: void execute() const {
		_garageDoor->up();
	}
private:
    const GarageDoor* _garageDoor;
};

class GarageDoorDownCommand : public Command
{
public:
    explicit GarageDoorDownCommand( const GarageDoor* garageDoor ) :
		_garageDoor( garageDoor )
    {
        assert( garageDoor );
	}
	void execute() const
	{
		_garageDoor->down();
	}
private:
    const GarageDoor* _garageDoor;
};


class Hottub
{
public:
    Hottub() :
		_on( false ), _temperature( 0 )
    {}
	void on() const
	{
		_on = true;
	}
	void off() const
	{
		_on = false;
	}
	void bubblesOn() const
	{
		if (_on)
		{
			cout << "Hottub is bubbling!" << endl;
		}
	}
	void bubblesOff() const
	{
		if (_on) {
			cout << "Hottub is not bubbling" << endl;
		}
	}
	void jetsOn() const
	{
		if (_on) {
			cout << "Hottub jets are on" << endl;
		}
	}
	void jetsOff() const
	{
		if (_on)
		{
			cout << "Hottub jets are off" << endl;
		}
	}
	void setTemperature( int temperature )
	{
	    assert( temperature >= 0 );
		_temperature = temperature;
	}
	void heat() const
	{
		_temperature = 105;
		cout << "Hottub is heating to a steaming 105 degrees" << endl;
	}
	void cool() const
	{
		_temperature = 98;
		cout << "Hottub is cooling to 98 degrees" << endl;
	}
private:
    mutable bool _on;
	mutable int _temperature;
};

class HottubOnCommand : public Command
{
public:
    explicit HottubOnCommand( const Hottub* hottub ) :
		_hottub( hottub )
    {
        assert( hottub );
	}
	public: void execute() const
	{
		_hottub->on();
		_hottub->heat();
		_hottub->bubblesOn();
	}
private:
    const Hottub* _hottub;
};

class HottubOffCommand : public Command
{
public:
    explicit HottubOffCommand( const Hottub* hottub ) :
		_hottub( hottub )
    {
        assert( hottub );
	}
	public: void execute() const
	{
		_hottub->cool();
		_hottub->off();
	}
private: const Hottub* _hottub;
};

class Light
{
public:
    explicit Light( const string location) :
		_location( location )
    {}
	void on() const
	{
		cout << _location.c_str() << " light is on" << endl;
	}
	public: void off() const
	{
		cout << _location.c_str() << " light is off" << endl;
	}
private: string _location;
};

class LightOnCommand : public Command
{
public:
    explicit LightOnCommand( const Light* light ) :
		_light( light )
    {
        assert( light );
	}
	void execute() const
	{
		_light->on();
	}
private:
    const Light* _light;
};

class LightOffCommand : public Command
{
public:
    explicit LightOffCommand( const Light* light  ) :
		_light( light )
    {
        assert( light );
	}
	public: void execute() const
	{
		_light->off();
	}
private:
    const Light* _light;
};

class LivingroomLightOnCommand : public Command
{
public:
    explicit LivingroomLightOnCommand( const Light* light ) :
		_light( light )
    {
        assert( light );
	}
	void execute() const
	{
		_light->on();
	}
private:
    const Light* _light;
};

class LivingroomLightOffCommand : public Command
{
public:
    explicit LivingroomLightOffCommand( const Light* light ) :
		_light( light )
    {
        assert( light );
	}
	void execute() const {
		_light->off();
	}
private:
    const Light* _light;
};

class Stereo
{
public:
    explicit Stereo( string location ) :
		_location( location )
    {}
	void on() const
	{
		cout << _location.c_str() << " stereo is on" << endl;
	}
	void off() const
	{
		cout << _location.c_str() << " stereo is off" << endl;
	}
	void setCD() const
	{
		cout << _location.c_str() << " stereo is set for CD input" << endl;
	}
 	void setDVD() const
 	{
		cout << _location.c_str() << " stereo is set for DVD input" << endl;
	}
	void setRadio() const
	{
		cout << _location.c_str() << " stereo is set for Radio" << endl;
	}
	void setVolume(int volume) const
	{
	    assert(volume > 0 && volume < 12);
		// code to set the volume
		// valid range: 1-11 (after all 11 is better than 10, right?)
		cout << _location.c_str() << " Stereo volume set to " << volume << endl;
	}
	private: string _location;
};

class StereoOnWithCDCommand : public Command
{
public:
    explicit StereoOnWithCDCommand( const Stereo* stereo ) :
		_stereo( stereo )
    {
        assert( stereo );
	}
	void execute() const
	{
		_stereo->on();
		_stereo->setCD();
		_stereo->setVolume(11);
	}
private:
    const Stereo* _stereo;
};

class StereoOffCommand : public Command
{
public:
    explicit StereoOffCommand( const Stereo* stereo ) :
		_stereo( stereo )
    {
        assert( stereo );
	}
	void execute() const
	{
		_stereo->off();
	}
private: const Stereo* _stereo;
};


class RemoteControl
{
public:
    RemoteControl()
	{
		_noCommand = new NoCommand();
		for( int i = 0; i < SLOTS; i++ )
		{
			_onCommands[i]  = _noCommand;
			_offCommands[i] = _noCommand;
		}
	}
	~RemoteControl()
	{
		delete _noCommand;
	}
	void setCommand( int slot, Command* onCommand, Command* offCommand )
	{
	    assert( slot <= SLOTS );
	    assert( onCommand );
	    assert ( offCommand );
		_onCommands[slot] = onCommand;
		_offCommands[slot] = offCommand;
	}
	void onButtonWasPushed( int slot ) const
	{
	    assert( slot <= SLOTS );
		_onCommands[slot]->execute();
	}
	void offButtonWasPushed( int slot ) const
	{
	    assert( slot <= SLOTS );
		_offCommands[slot]->execute();
	}
	string toString() const
	{
		stringstream value;
		value << "\n------ Remote Control -------\n" << endl;
		for( int i = 0; i < SLOTS; i++ )
		{
			value << "[slot " << i << "] ";
			value << typeid( *_onCommands[i] ).name();
			value << "    ";
			value << typeid( *_offCommands[i] ).name();
			value << endl;
		}
		return value.str();
	}

private:
    RemoteControl( const RemoteControl& ); // Disable copy constructor
	void operator=( const RemoteControl& ); // Disable assignment operator
private:
    static const int SLOTS = 7;
	Command* _onCommands[SLOTS];
	Command* _offCommands[SLOTS];
	Command* _noCommand;
};

int main()
{
    auto_ptr< RemoteControl > remoteControl(
		new RemoteControl() );

	auto_ptr< Light > livingRoomLight(
		new Light( "Living Room" ) );
	auto_ptr< Light > kitchenLight(
		new Light( "Kitchen" ) );
	auto_ptr< CeilingFan > ceilingFan(
		new CeilingFan( "Living Room" ) );
	auto_ptr< GarageDoor > garageDoor(
		new GarageDoor( "Garage" ) );
	auto_ptr< Stereo > stereo(
		new Stereo( "Living Room" ) );

	auto_ptr< LightOnCommand > livingRoomLightOn(
		new LightOnCommand( livingRoomLight.get() ) );
	auto_ptr< LightOffCommand > livingRoomLightOff(
		new LightOffCommand( livingRoomLight.get() ) );
	auto_ptr< LightOnCommand > kitchenLightOn(
		new LightOnCommand( kitchenLight.get() ) );
	auto_ptr< LightOffCommand > kitchenLightOff(
		new LightOffCommand( kitchenLight.get() ) );

	auto_ptr< CeilingFanOnCommand > ceilingFanOn(
		new CeilingFanOnCommand( ceilingFan.get() ) );
	auto_ptr< CeilingFanOffCommand > ceilingFanOff(
		new CeilingFanOffCommand( ceilingFan.get() ) );

	auto_ptr< GarageDoorUpCommand > garageDoorUp(
		new GarageDoorUpCommand( garageDoor.get() ) );
	auto_ptr< GarageDoorDownCommand > garageDoorDown(
		new GarageDoorDownCommand( garageDoor.get() ) );

	auto_ptr< StereoOnWithCDCommand > stereoOnWithCD(
		new StereoOnWithCDCommand( stereo.get() ) );
	auto_ptr< StereoOffCommand > stereoOff(
		new StereoOffCommand( stereo.get() ) );

	remoteControl->setCommand( 0, livingRoomLightOn.get(), livingRoomLightOff.get() );
	remoteControl->setCommand( 1, kitchenLightOn.get(), kitchenLightOff.get() );
	remoteControl->setCommand( 2, ceilingFanOn.get(), ceilingFanOff.get() );
	remoteControl->setCommand( 3, stereoOnWithCD.get(), stereoOff.get() );
	remoteControl->setCommand( 4, garageDoorUp.get(), garageDoorDown.get() );

	cout << remoteControl->toString() << endl;

	remoteControl->onButtonWasPushed( 0 );
	remoteControl->offButtonWasPushed( 0 );
	remoteControl->onButtonWasPushed( 1 );
	remoteControl->offButtonWasPushed( 1 );
	remoteControl->onButtonWasPushed( 2 );
	remoteControl->offButtonWasPushed( 2 );
	remoteControl->onButtonWasPushed( 3 );
	remoteControl->offButtonWasPushed( 3 );
	remoteControl->onButtonWasPushed( 4 );
	remoteControl->offButtonWasPushed( 4 );
    return 0;
}


4,增加了unco()方法的实例

#include <iostream>
#include <cassert>
#include <memory>
#include <sstream>
#include <typeinfo>
using namespace std;

/*********************Command对象基类************************/
class Command
{
protected:
    Command() {}
public:
    virtual ~Command() = 0;
	virtual void execute() const = 0;
	virtual void undo() const = 0;
private:
    Command( const Command& ); // Disable copy constructor
	void operator=( const Command& ); // Disable assignment operator
};
Command::~Command() {}

/**************特殊的空类**********************/
class NoCommand : public Command
{
public:
    void execute() const {}
    void undo() const {};
};

/***************接受者及其命令对象***************/
class CeilingFan
{
public:
    explicit CeilingFan( string location ) :
		_speed( OFF ), _location( location )
    {}
  	void high() const
  	{
		_speed = HIGH;
		cout << _location.c_str() << " ceiling fan is on high" << endl;
	}
 	void medium() const
 	{
		_speed = MEDIUM;
		cout << _location.c_str() << " ceiling fan is on medium" << endl;
	}
 	void low() const
 	{
		_speed = LOW;
		cout << _location.c_str() << " ceiling fan is on low" << endl;
	}
 	void off() const
 	{
		_speed = OFF;
		cout << _location.c_str() << " ceiling fan is off" << endl;
	}
 	int getSpeed() const
 	{
		return _speed;
	}
public:
    static const int HIGH = 3;
    static const int MEDIUM = 2;
    static const int LOW = 1;
    static const int OFF = 0;
private:
	mutable int _speed;
	string _location;
};

class CeilingFanHighCommand : public Command
{
public:
    explicit CeilingFanHighCommand( const CeilingFan* ceilingFan ) :
		_ceilingFan( ceilingFan )
    {
        assert( ceilingFan );
		_prevSpeed = _ceilingFan->getSpeed();
	}
 	void execute() const
 	{
		_prevSpeed = _ceilingFan->getSpeed();
		_ceilingFan->high();
	}
    void undo() const
 	{
		if( _prevSpeed == CeilingFan::HIGH )
		{
			_ceilingFan->high();
		}
		else if( _prevSpeed == CeilingFan::MEDIUM )
		{
			_ceilingFan->medium();
		}
		else if( _prevSpeed == CeilingFan::LOW )
		{
			_ceilingFan->low();
		}
		else if( _prevSpeed == CeilingFan::OFF )
		{
			_ceilingFan->off();
		}
	}
private:
    const CeilingFan* _ceilingFan;
    mutable int _prevSpeed;
};

class CeilingFanMediumCommand : public Command
{
public:
    explicit CeilingFanMediumCommand( const CeilingFan* ceilingFan ) :
		_ceilingFan( ceilingFan )
    {
        assert( ceilingFan );
		_prevSpeed = _ceilingFan->getSpeed();
	}
 	void execute() const
 	{
		_prevSpeed = _ceilingFan->getSpeed();
		_ceilingFan->medium();
	}
 	void undo() const
 	{
		if( _prevSpeed == CeilingFan::HIGH )
		{
			_ceilingFan->high();
		}
		else if( _prevSpeed == CeilingFan::MEDIUM )
		{
			_ceilingFan->medium();
		}
		else if( _prevSpeed == CeilingFan::LOW )
		{
			_ceilingFan->low();
		}
		else if( _prevSpeed == CeilingFan::OFF )
		{
			_ceilingFan->off();
		}
	}
private:
    const CeilingFan* _ceilingFan;
    mutable int _prevSpeed;
};

class CeilingFanLowCommand : public Command
{
public:
    explicit CeilingFanLowCommand( const CeilingFan* ceilingFan ) :
		_ceilingFan( ceilingFan )
    {
        assert( ceilingFan );
		_prevSpeed = _ceilingFan->getSpeed();
	}
 	void execute() const
 	{
		_prevSpeed = _ceilingFan->getSpeed();
		_ceilingFan->low();
	}
 	void undo() const
 	{
		if( _prevSpeed == CeilingFan::HIGH )
		{
			_ceilingFan->high();
		}
		else if( _prevSpeed == CeilingFan::MEDIUM )
		{
			_ceilingFan->medium();
		}
		else if( _prevSpeed == CeilingFan::LOW )
		{
			_ceilingFan->low();
		}
		else if( _prevSpeed == CeilingFan::OFF )
		{
			_ceilingFan->off();
		}
	}
private:
    const CeilingFan* _ceilingFan;
	mutable int _prevSpeed;
};

class CeilingFanOffCommand :public Command
{

private:
    const CeilingFan* _ceilingFan;
    mutable int _prevSpeed;
public:
    explicit CeilingFanOffCommand( const CeilingFan* ceilingFan ) :
		_ceilingFan( ceilingFan )
    {
        assert( ceilingFan );
		_prevSpeed = _ceilingFan->getSpeed();
	}
	void execute() const
	{
		_prevSpeed = _ceilingFan->getSpeed();
		_ceilingFan->off();
	}
	void undo() const
	{
		if( _prevSpeed == CeilingFan::HIGH )
		{
			_ceilingFan->high();
		}
		else if( _prevSpeed == CeilingFan::MEDIUM )
		{
			_ceilingFan->medium();
		}
		else if( _prevSpeed == CeilingFan::LOW )
		{
			_ceilingFan->low();
		}
		else if( _prevSpeed == CeilingFan::OFF )
		{
			_ceilingFan->off();
		}
	}
};

class Light
{
public:
    explicit Light( const string location ) :
		_location( location ), _level( 0 )
    {}
	void on() const
	{
		_level = 100;
		cout << _location.c_str() << " light is on" << endl;
	}
	void off() const
	{
		_level = 0;
		cout << _location.c_str() << " light is off" << endl;
	}
	void dim( int level ) const
	{
		_level = level;
		if( _level == 0 )
		{
			off();
		}
		else
		{
			cout << "Light is dimmed to " << _level << "%" << endl;
		}
	}
	int getLevel() const
	{
		return _level;
	}

private:
    string _location;
	mutable int _level;
};

class LightOnCommand : public Command
{
public:
    explicit LightOnCommand( const Light* light) :
		_light(light)
    {
        assert(light);
	}
	void execute() const
	{
		_light->on();
	}
	void undo() const
	{
		_light->off();
	}
private:
    const Light* _light;
};

class LightOffCommand : public Command
{
public:
    explicit LightOffCommand( const Light* light ) :
		_light( light )
    {
		assert( light );
	}
	public: void execute() const
	{
		_light->off();
	}
	public: void undo() const
	{
		_light->on();
	}
private:
    const Light* _light;
};

class DimmerLightOnCommand : public Command
{
public:
    explicit DimmerLightOnCommand( const Light* light ) :
		_light( light )
    {
        assert( light );
		_prevLevel = _light->getLevel();
	}
	void execute() const
	{
		_prevLevel = _light->getLevel();
		_light->dim( 75 );
	}
	void undo() const
	{
		_light->dim( _prevLevel );
	}
private:
    const Light* _light;
	mutable int _prevLevel;
};

class DimmerLightOffCommand : public Command
{
public:
    explicit DimmerLightOffCommand( const Light* light ) :
		_light( light )
    {
        assert( light );
		_prevLevel = _light->getLevel();
	}
	void execute() const
	{
		_prevLevel = _light->getLevel();
		_light->off();
	}
	void undo() const
	{
		_light->dim( _prevLevel );
	}

private:
    const Light* _light;
	mutable int _prevLevel;
};

class RemoteControlWithUndo
{
public:
    RemoteControlWithUndo()
    {
		_noCommand = new NoCommand();
		for( int i = 0; i < SLOTS; i++ )
		{
			_onCommands[i] = _noCommand;
			_offCommands[i] = _noCommand;
		}
		_undoCommand = _noCommand;
	}
	~RemoteControlWithUndo()
	{
		delete _noCommand;
	}
	void setCommand( int slot, Command* onCommand, Command* offCommand )
	{
	    assert( slot <= SLOTS );
	    assert( onCommand );
	    assert( offCommand );
		_onCommands[slot]  = onCommand;
		_offCommands[slot] = offCommand;
	}
	void onButtonWasPushed( int slot ) const
	{
	    assert( slot <= SLOTS );
		_onCommands[slot]->execute();
		_undoCommand = _onCommands[slot];
	}
	void offButtonWasPushed( int slot ) const
	{
	    assert( slot <= SLOTS );
		_offCommands[slot]->execute();
		_undoCommand = _offCommands[slot];
	}
	void undoButtonWasPushed() const
	{
		_undoCommand->undo();
	}
	string toString() const
	{
		stringstream value;
		value << endl << "------ Remote Control -------" << endl;
		for( int i = 0; i < SLOTS; i++ )
		{
			value << "[slot " << i << "] ";
			value << typeid( *_onCommands[i] ).name();
			value << "    ";
			value << typeid( *_offCommands[i] ).name();
			value << endl;
		}
		value << "[undo] " << typeid( *_undoCommand ).name() << endl;
		return value.str();
	}
private:
    static const int SLOTS = 7;
    Command* _onCommands[SLOTS];
    Command* _offCommands[SLOTS];
    Command* _noCommand;
    mutable Command* _undoCommand;
};
int main()
{
    auto_ptr< RemoteControlWithUndo > remoteControl( new RemoteControlWithUndo() );
	auto_ptr< Light > livingRoomLight( new Light( "Living Room" ) );
	auto_ptr< LightOnCommand > livingRoomLightOn( new LightOnCommand( livingRoomLight.get() ) );
	auto_ptr< LightOffCommand > livingRoomLightOff( new LightOffCommand( livingRoomLight.get() ) );

    remoteControl->setCommand( 0, livingRoomLightOn.get(), livingRoomLightOff.get() );
	remoteControl->onButtonWasPushed( 0 );
	remoteControl->offButtonWasPushed( 0 );
	remoteControl->onButtonWasPushed( 0 );
	cout << remoteControl->toString() << endl;
	remoteControl->undoButtonWasPushed();

    auto_ptr< CeilingFan > ceilingFan( new CeilingFan( "Living Room" ) );
	auto_ptr< CeilingFanMediumCommand > ceilingFanMedium( new CeilingFanMediumCommand( ceilingFan.get() ) );
	auto_ptr< CeilingFanHighCommand > ceilingFanHigh( new CeilingFanHighCommand( ceilingFan.get() ) );
	auto_ptr< CeilingFanOffCommand > ceilingFanOff( new CeilingFanOffCommand( ceilingFan.get() ) );

    remoteControl->setCommand( 0, ceilingFanMedium.get(), ceilingFanOff.get() );
	remoteControl->setCommand( 1, ceilingFanHigh.get(), ceilingFanOff.get() );

	remoteControl->onButtonWasPushed( 0 );
	remoteControl->offButtonWasPushed( 0 );
	cout << remoteControl->toString() << endl;
	remoteControl->undoButtonWasPushed();

	remoteControl->onButtonWasPushed( 1 );
	cout << remoteControl->toString() << endl;
	remoteControl->undoButtonWasPushed();

    return 0;
}
java command模式_java设计模式——command 模式
weixin_36185512的博客
02-23 1533
意图：将一个请求封装为一个对象，从而可用不同的请求对客户进行参数化；对请求排队或记录日志，以及支持可撤销的操作动机：将”发出请求的对象”和”接收与执行这些请求的对象”分隔开来。效果：1)、command模式将调用操作的对象和实现该操作的对象解耦2)、可以将多个命令装配成一个复合命令，复合命令是Composite模式的一个实例3)、增加新的command很容易，无需改变已有的类适用性：1)、抽象出待...
Colyseus Command 模式详解
maply的博客
12-28 1337
Colyseus 的 `Command` 模式是一个用于封装客户端命令并在服务器端处理它们的设计模式。它为复杂的游戏逻辑和多人交互提供了清晰、可扩展的解决方案。`Command` 机制主要用于在游戏中执行一系列操作，同时将这些操作的逻辑集中管理，从而提高代码的可维护性和模块化。
Command 模式
stepMore的博客
12-28 991
Command 模式 一个类在进行工作时会调用自己或是其他类的方法，虽然调用结果会反映在对象的状态中，但并不会留下工作的历史记录。 这时，如果我们有一个类，用来表示“请进行这项工作”的“命令”就会方便很多。每一项想做的工作就不再是“方法的调用”这种动态处理了，而是一个表示命令的类的实例，即可以用“物”来表示。要想管理工作的历史记录，只需管理这些实例的集合即可，而且还可以随时再次执行过去的命令，或是...
【Command模式】C++设计模式——命令模式
不负AC不负卿的博客
08-10 1851
C++命令模式，Command设计模式，本文以通俗易懂的例子引入命令模式的探讨，同时对该模式进行总结和代码展示，同时带大家分析了之前GoF的命令模式与当今使用的函数对象的区别
命令模式（Command）
QQ657205470的博客
11-04 1369
意图：将一个请求封装为一个对象，从而使得可以用不同的请求对客户进行参数化;对请求排队或记录请求日志，以及支持可撤销的操作。
Kotlin~Command模式
Hynson的学习笔记
07-08 962
命令模式的结果就是接收方的执行结果，但为了以命令的形式设计，引入额外类型增加理解上的困难。不过这也是设计模式的通病，抽象必然会增加额外的类，代码抽离肯定会比聚合更加难理解。
c语言command,command模式(c 语言实现)
weixin_29085151的博客
05-19 1507
command 模式：把“做菜的厨师”和“一道菜的名字”封装起来，对外看起来就是“一道菜的名字”。然后“这道菜”就可以“被写在菜单上”，供顾客点餐。下面是c语言的实现代码：#include #include //命令接口struct command_interface{int (*on)(void);int (*off)(void);};typedef int (*plight_method)(v...
Java设计模式 -16- 命令模式（Command 模式）
Android系统工程师--小馬佩德罗
07-06 1428
Java设计模式 -16- 命令模式（Command 模式）前言命令模式的定义与特点优点:缺点：命令模式的结构与实现1. 模式的结构2. 模式的实现命令模式的应用实例命令模式的应用场景命令模式的扩展 前言 行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。 行为型模式分为类行为模式和对象行为模式，前者采用继承机制来在类间分派行为，后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低，满
命令模式（Command模式）详解
傅红雪的专栏
03-18 9636
在软件开发系统中，常常出现“方法的请求者”与“方法的实现者”之间存在紧密的耦合关系。这不利于软件功能的扩展与维护。例如，想对行为进行“撤销、重做、记录”等处理都很不方便，因此“如何将方法的请求者与方法的实现者解耦？”变得很重要，命令模式能很好地解决这个问题。 在现实生活中，这样的例子也很多，例如，电视机遥控器（命令发送者）通过按钮（具体命令）来遥控电视机（命令接收者），还有计算机键盘上的“功能键...
C＃中Command模式的实现
04-11
Command模式是一种行为设计模式，它将请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。在C#编程中，利用.NET框架的特性，如委托和泛型，我们可以...
设计模式学习之Command模式共8页.pdf.zip
10-31
Command模式是一种行为设计模式，它将请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。在软件工程中，这种模式扮演着非常重要的角色，尤其是在需要...
Unity 【Content Size Fitter】- 聊天气泡自动适配Text文本框大小
当代野生程序猿
02-25 6447
通常在展示人物对话的时候文本的长度是不定的，因此会需要动态的调整对话内容文本框的背景图片的大小，这里以如下这种气泡框的对话为例： 实现该需求涉及到的内容包括Content Size Fitter组件的使用、2D Sprite工具包的使用。 Content Size Fitter组件用于Text文本框，如图所示，我们将Horzontal Fit设为Preferred Size，当我们调整Text文本框中的内容时，其大小会自动进行调整。 注意Rect Transform中Pivot轴心点的设置
新唐NUC972 Linux（一）：USB烧写linux出厂镜像
小破孩的博客
02-20 3707
USB烧写出厂镜像 文章目录USB烧写出厂镜像前言一、硬件连接二、安装驱动三、烧写linux程序四、运行程序 前言 今天开始进军linux，学了那么久单片机，也摸得七七八八，至少点个灯还是会的。本人之所以买酷客的linux开发板主要是便宜，资料也算齐全，虽然没有原子那么好，不过也够了，找那么多借口，其实就是qiong。今天先从USB烧录官方提供的linux相关程序到芯片开始吧。 一、硬件连接 1、连接电源线 2、RS232转USB，需要安装CH340驱动，用于在电脑串口超级终端中查看调试信息。 3、U
WeChall CTF Writeup（一）
weixin_43211186的博客
02-25 1778
以下题目标题组成： [Score] [Title] [Author] 文章目录0x01 1 Training: Get Sourced by Gizmore0x02 1 Training: Stegano I by Gizmore0x03 1 Training: Crypto - Caesar I by Gizmore0x04 1 Training: WWW-Robots by Gizmore0x05 1 Training: ASCII by Gizmore 0x01 1 Training: Get Sou
C语言每日一练——第126天：佩奇借书问题
热门推荐
Edison's 小宇宙
02-25 2万+
史上最强借书方案问题讲解（代码详解+思路分析+动图演示+特性总结）
CS5261与CS5265功能应用|CS5261替代RTD2171|CS5265替代RTD2172
qq1659747718的博客
02-25 1525
CS5261可以完全替代兼容停产RTD2171,CS5265可以完全替代兼容RTD2172，芯片单价低，整体方案设计简单，整体BOM成本较RTD2171、RTD2172低。
Hello Kafka（八）——Confluent Kafka简介
天山老妖
02-24 9545
一、Confluent Kafka简介 1、Confluent Kafka简介 2014年，Kafka的创始人Jay Kreps、NahaNarkhede和饶军离开LinkedIn创立Confluent公司，专注于提供基于Kafka的企业级流处理解决方案，并发布了Confluent Kafka。Confluent Kafka分为开源版和企业版，企业版收费。 2、Confluent Kafka特性 Confluent Kafka开源版特性如下： （1）Confluent Kafka Connecto
command模式
最新发布
09-09
Command模式即命令模式，是一种行为设计模式，它将请求封装为一个对象，使得请求的发送者和接收者之间解耦，还能支持撤销操作，并且可以被存储、记录、序列化、排队、日志等，为系统提供更大的灵活性[^1]。 命令模式的原理基于将请求封装成对象。其核心组件包括： - Command（命令）：定义了执行请求的接口。 - ConcreteCommand（具体命令）：实现了命令接口，负责调用请求的接收者来执行请求。 - Receiver（接收者）：知道如何实施与执行一个请求相关的操作。 - Invoker（调用者）：要求命令执行请求的对象。 - Client（客户端）：创建具体命令对象并设置其接收者 [^2]。 命令模式的使用场景如下： - 需要将请求发送者和请求接收者解耦：命令模式允许请求发送者和接收者独立变化，互不影响。 - 需要支持命令的排队、记录请求日志、撤销操作等功能：命令模式可以轻松地扩展这些功能。 - 需要将一组操作组合在一起形成一个命令：命令模式可以将多个操作封装成一个命令对象 [^2]。 以下是一个简单的Java代码示例来展示命令模式： ```java // 命令接口 interface Command { void execute(); } // 接收者类 class LinuxSystem { public void cd() { System.out.println("执行cd命令"); } public void ls() { System.out.println("执行ls命令"); } } // 具体命令类：Cd命令 class CdCommand implements Command { private LinuxSystem receiver; public CdCommand(LinuxSystem receiver) { this.receiver = receiver; } @Override public void execute() { receiver.cd(); } } // 具体命令类：Ls命令 class LsCommand implements Command { private LinuxSystem receiver; public LsCommand(LinuxSystem receiver) { this.receiver = receiver; } @Override public void execute() { receiver.ls(); } } // 调用者类 class Invoker { private Command command; public void setCommand(Command command) { this.command = command; } public void executeCommand() { command.execute(); } } // 客户端类 public class Client { public static void main(String[] args) { // 创建接收者 LinuxSystem receiver = new LinuxSystem(); // 创建具体命令 Command cdCommand = new CdCommand(receiver); Command lsCommand = new LsCommand(receiver); // 创建调用者 Invoker invoker = new Invoker(); // 设置并执行命令 invoker.setCommand(cdCommand); invoker.executeCommand(); invoker.setCommand(lsCommand); invoker.executeCommand(); } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值