Wzorce projektowe (20)

Polecenie.

Polecenie to wzorzec obiektowy. Jego celem jest traktowanie określonego zadania jako obiektu.

Klasy

class Command{/*
klasa abstrakcyjna deklarująca interfejs dla wykonania operacji - metoda execute()
*/};

class ConcreteCommand: public Command{/*
implementuje metodę execute(), tworzy połączenie między odbiorcą a operacją
*/};

class Invoker{/*
klasa pośrednika, przesyła zadanie do Command
*/};

class Receiver{/*
klasa odbiorcy, wie jak wykonać zadanie
*/};

class Client{/*
tworzy ConcreteCommand, któremu ustawia odbiorcę
*/};

Etapy działania

1. Klient tworzy obiekt klasy Receiver.
2. Tworzy ConcreteCommand przekazując mu Receiver’a.
3. Tworzy pośrednika – obiekt klasy Invoker.
4. Wywołuje metodę pośrednika przekazując jej obiekt ConcreteCommand.
5. Pośrednik wykonuje polecenie i umieszcza obiekt, który otrzymał, na liście wykonanych operacji.

Konsekwencje

Zalety:

• oddzielenie operacji od obiektów, na których jest wykonywana,
• polecenia są reprezentowane jako obiekty, dzięki czemu mogą być parametryzowane w zależnosci od rodzaju odbiorcy, a także umieszczane w kolejkach i dziennikach,
• wzorzec stosowany m.in. przy historii poleceń i operacji cofnij,
• łatwo dodawać nowe polecenia.

Wady:

• wadą jest, że każde polecenie wymaga dodatkowej pamięci na zapamiętanie stanu swojego obiektu.

Przykład

#include <vector>
#include <iostream>
#include <string>
using namespace std;

///abstrakcyjna command
class Order
{
  public:
    virtual void execute()=0;
};


///klasa odbiorcy
class StockTrade
{
  public:
    void buy()
    {
      cout<<"you want to buy stocks"<<endl;
    }

    void sell()
    {
      cout<<"you want to sell stocks"<<endl;
    }
};

///Invoker
class Agent
{
  public:
    Agent()
    {
    }

    void placeOrder(Order* order)
    {
      ordersQueque.push_back(order);
      order->execute();
    }

  private:
    vector<Order*> ordersQueque;
};


///concreete command
class BuyStockOrder: public Order
{
  public:
    BuyStockOrder(StockTrade* st)
    {
      stock=st;
    }

    void execute()
    {
      stock->buy();
    }

  private:
    StockTrade* stock;
};


///concreete command
class SellStockOrder:public Order
{
  public:
    SellStockOrder(StockTrade* st)
    {
      stock=st;
    }

    void execute()
    {
      stock->sell();
    }

  private:
    StockTrade * stock;
};


///Client

int main(int argc, const char *argv[])
{
  StockTrade stock;
  BuyStockOrder buy(&stock);
  SellStockOrder sell(&stock);
  
  Agent agent;

  agent.placeOrder(&buy);
  agent.placeOrder(&sell);
}

część 21