Wzorzec obserwator C++/Qt

Często się zdarza że programiści napotykają problem we współczesnych programu posiadające interfejs użytkownika (GUI), muszą reagować na zmiany danych w kilku różnych miejscach jednocześnie. Do sytuacji takiej może dojść wtedy gdy pracujemy na tych samych danych, które możemy edytować w kilku miejscach jednocześnie np. wykresy obrazujące takie same dane. Zmiana wartości na jednym wykresie implikuje zmianę wartości na pozostałych wykresach.

W przypadku kiedy mamy do czynienia z kilkoma obiektami możemy wykorzystać mechanizm sygnałów i slotów w Qt, jednak jeżeli jednak liczba obserwowanych obiektów, które się zmieniają nie jest zdefiniowana lub dotyczy znacznej grupy obiektów możemy zbudować osobną klasę zwaną Obserwatorem mającą na celu powiadamianie obiektów o występujących zmianach.

Pomimo że istnieje wiele różnych implementacji tego samego wzorca mają one elementy wspólne takie jak:

Wszystkie z obiektów można podzielić na dwie osobne grupy wydawców i klas pełniących rolę obserwatorów
Każda z implementacji zakłada że jest jeden obiekt, które informuje inne obiekty o zmianach
Mechanizm wysyłania informacji do pozostałych klas jest zdefiniowany w całości w klasie bazowej wydawcy.

Zalety i wady

Zalety:

Luźna zależność między obiektem obserwującym i obserwowanym. Ponieważ nie wiedzą one wiele o sobie nawzajem, mogą być niezależnie rozszerzane i rozbudowywane bez wpływu na drugą stronę.
Relacja między obiektem obserwowanym a obserwatorem tworzona jest podczas wykonywania programu i może być dynamicznie zmieniana.
Możliwość zablokowania klientowi drogi do bezpośredniego korzystania ze złożonego systemu, jeśli jest to konieczne.

Wady:

Obserwatorzy nie znają innych obserwatorów, co w pewnych sytuacjach może wywołać trudne do znalezienia skutki uboczne.
Zastosowanie

Wzorzec Obserwatora sprawdza się wszędzie tam, gdzie stan jednego obiektu uzależniony jest od stanu drugiego obiektu.

Implementacja

//Obserwator:
class Obserwator {
public:
    virtual void update() = 0;
};
//Obserwowany:

class Obserwowany {
protected:
    std::list <Obserwator*> obserwatorzy;
public:
    void dodaj(Obserwator *o) {
        obserwatorzy.push_back (o);
    }
    void usun(Obserwator *o) {
        obserwatorzy.remove (o);
    }
 
    void powiadom () {
        std::list<Obserwator *>::iterator it;
        for (it = obserwatorzy.begin(); it != obserwatorzy.end(); it++) {
            (*it)->update ();
        }
    }
};

Obserwowany Konkretny:

Dziedziczenie wielokrotne dostępne w C++ jest często używane w wzorcu Obserwatora

class Miod {
protected:
    int ilosc;
public:
    Miod (int q) {
        ilosc = q;
    }
 
    int pobierzIlosc () {
        return ilosc;
    }
 
    void ustawIlosc (int q) {
        ilosc = q;
    }
};
 
class ObserwowanyMiod : public Obserwowany, public Miod {
    std::string stan;
public:
    ObserwowanyMiod (int q) : Miod(q) {
    }
 
    std::string pobierzStan () {
        return stan;
    }
 
    void ustawStan (const std::string& s) {
        stan = s;
        std::cout << "Stan: " << stan << std::endl;
        powiadom();
    }
};

Obserwator Konkretny:

class ObserwatorMis : public Obserwator {
protected:
    int misId;
    ObserwowanyMiod *miod;
public:
    ObserwatorMis (ObserwowanyMiod *h, int id) {
        miod = h;
        misId = id;
    }
    void update () {
        std::string stan = miod->pobierzStan();
        if (!stan.compare ("Sa ludzie blisko miodu")) {
            std::cout << "Mis" << misId << ": Czekam w ukryciu" << std::endl;
        } else if (!stan.compare ("Nie ma ludzi blisko miodu")) {
            std::cout << "Mis" << misId << ": Kradne miod" << std::endl;
            miod->ustawIlosc(miod->pobierzIlosc()-1);
        } else if (!stan.compare ("Ida ludzie")) {
            std::cout << "Mis" << misId << ": Uciekam" << std::endl;
        }
    }
};

Przykład użycia:

int main() {
    ObserwowanyMiod miod (5);
    Obserwator *mis1 = new ObserwatorMis(&miod, 1);
    Obserwator *mis2 = new ObserwatorMis(&miod, 2);
 
    miod.dodaj(mis1);
    miod.dodaj(mis2);
 
    std::cout << "Ilosc miodu: " << miod.pobierzIlosc() << std::endl;
 
    miod.ustawStan("Sa ludzie blisko miodu");
    miod.ustawStan("Nie ma ludzi blisko miodu");
    miod.ustawStan("Ida ludzie");
 
    std::cout << "Ilosc miodu: " << miod.pobierzIlosc() << std::endl;
    delete mis1;
    delete mis2;
    return 0;
}

Wzorzec Adapter C++/Qt

Zastosowanie

Adapter inaczej nazywany Nakładką (ang. wrapper) to strukturalny wzorzec projektowy, którego zadaniem jest stworzenie spójnego interfejsu dla dwóch niekompatybilnych klas. Adapter przekształca interfejs jednej z klas na interfejs drugiej.

Adapter

Wskazówki praktyczne

Aby stworzyć wspólny interfejs warto zaimplementować klasę z metodami wirtualnymi która będzie częścią wspólną dla niewspółbieżnych klas. Adapter jest używany w przypadku gdy chcemy przysłonić już istniejące interfejsy jednym wspólnym, a nie możemy tego zrobić np. w sytuacji używania bibliotek zewnętrznych do których mamy tylko API. Autorzy często przytaczają przykład różnych wejść (HDMI, VGA) które mają takie same zadania ale różne interfejsy, a klient ma obsługiwać takie same metody (wyświetl, odepnij).

Zalety i wady

Zalety

  • Umożliwia współprace klas których wykorzystanie byłoby utrudnione ze względu na brak spójnych interfejsów.
  • Bardziej przejrzysty kod

Wady:

  • Wymagane jest dziedzicznie co powoduje przyrost plików z klasami (jeżeli stosujemy adapter klasowy)
  • Adapter klasowy jest mniej elastyczny niż Adapter obiektowy np. po dodaniu w naszym przykładzie getScreenShot(), zakrywanie metod wirtualnych jest bezsensowne w przypadku Mp3Player
#include <QDebug>
#include <QString>

class Player
{
    public:
        virtual void play(){}
        virtual void stop(){}
};

class FlashPlayer: public Player
{
    public:
        void play(){ qDebug() << "Play flash file"; }
        void stop(){ qDebug() << "Stop flash file"; }
};

// This is liblary and we cannot change implementatnion
class Mp3Player
{
    public:
        void playSound(){ qDebug() << "Play mp3 file"; }
        void stopSound(){ qDebug() << "Stop mp3 file"; }
};

/* Adapter */
class Mp3Adapter : public Mp3Player, public Player
{
public:
    void play(){playSound();}
    void stop(){stopSound();}

};

int main()
{
    Player *flash = new FlashPlayer();
    //  Player *mp3 = new Mp3Player();  // Błąd !!!
      Player *mp3 = new Mp3Adapter();

    QList <Player *> listPlayers{flash,mp3};

    foreach(Player *play, listPlayers)
        play->play();


    foreach(Player *play, listPlayers)
        play->stop();

    qDeleteAll(listPlayers);

    return 0;
}

Wyjście programu:

Play flash file
Play mp3 file
Stop flash file
Stop mp3 file