zpr c++ quick reference

Ta strona jest tylko do odczytu. Możesz wyświetlić źródła tej strony ale nie możesz ich zmienić.
======Wzorzec Projektowy Obserwator======
Wzorzec Obserwatora (ang. The Observer Pattern) jest wzorcem projektowym służącym do obserwowania stanu obiektu.  Wzorzec ten jest pomyślany do rozwiązania sytuacji w której stan większej liczby obiektów (obserwatorów) zależy od  stanu innego obiektu (obserwowanego) - pomaga zachować spójność między nimi.
=====Diagram UML=====
{{ observer:uml_1.jpg |}}
=====Kod w C++=====
<code cpp>
//Abstrakcyjny Obserwowany
class Obserwowany {
	public:
	void dodaj(Obserwator* o) {
		/* dodaj obserwatora o do listy obserwatorow */
	}
	void powiadom(){
		/* dla każdego o w obserwatorzy wywołaj o->odswiez() */
	}
	virtual ~Obserwowany() = 0;
	private:
	std::vector<Obserwator*> obserwatorzy;
};
Subject::~Subject(){}
//Obserwowany konkretny
class ObserwowanyKonkretny : public Obserwowany {
	public:
	void podaj_stan(StanObserwowanego* stan) {
 		/* podaj stan, np. poprzez odpowiednia struktore StanObserwowanego */
	}
};
//Abstrakcyjny Obserwator
class Obserwator {
	public:
	virtual void odswiez() = 0;
	virtual ~Obserwator(){}
};
//Obserwator konkretny
class ObserwatorKonkretny : public Obserwator {
	public:
	void odswiez() {
		/* uzyskaj aktualny stan obserwowanego */
	}
};
</code>
=====Opis elementów wzorca=====
W skład wzorca wchodzą cztery elementy:
  - **Obserwowany**: Klasa abstrakcyjna dostarczająca interfejs dla dodawania i usuwania obserwatorów, oraz powiadamiania o zmianie stanu wszystkich obserwatorów z listy. Zawiera:
    * //dodaj//- dodaje obserwatora
    * //usun//- usuwa obserwatora
    * //powiadom//- powiadamia o zmianie wszystkich obserwatorow z listy poprzez wołanie metody odswież dla każdego z nich
  - **Obserwowany Konkretny**: Klasa zwraca swój wewnętrzny stan, który jest obiektem zainteresowania obserwatorów. Powiadamia także swoich obserwatorów na wypadek zmiany swojego stanu. Zawiera:
    * //podaj_stan// - zwraca aktualny stan obiektu
  - **Obserwator**: Klasa abstrakcyjna dostarczająca interfejs dla powiadamiania dla wszystkich obserwatorów. Zawiera:
    * //odswiez// - abstrakcyjna metoda która ma być nadpisana przez konkretnego obserwatora
  - **Obserwator konkretny**: Klasa pozostaję w związku z obiektem obserwowanym (ObserwowanyKonkretny) aby otrzymać/pobrać jego stan w wypadku powiadomienia o zmienie. Zawiera:
    * //odswiez// - podczas wołania tej metody (która nadpisuje metode abstrakcyjną w klasie bazowej), konkretny obserwator woła podaj_stan dla obiektu obserwowanego aby zaktualizować informację o nim
=====Typowe użycie=====
Dla przykładu weźmy dwa obiekty **A** oraz **B**, przy czym stan obiektu **A** jest zależny od stanu obiektu **B**, czyli może się zdarzyć że po zmianie stanu obiektu **B** obiekt **A** również powinien zmienić swój stan. W tym ogólnym (i prostym) przypadku można pokusić się o bezpośrednią interakcje pomiędzy obiektami poprzez utrzymanie w jednym z nich wskaźnika lub referencji na drugi. Sytuacja jednak komplikuje się kiedy:
  * do zależności dochodzi nowy obiekt
  * jeden z istniejących obiektów musi zostać zamieniony na inny (np. innej klasy)
  * musimy usunąć jeden z obiektów
Wygodnym sposobem jest utrzymywanie niezależnych obiektów współpracujących ze sobą bez wiedzy o swoim istnieniu - tak działa **Wzorzec Obserwatora**.
=====Działanie=====
Gdy zmienia się stan obiektu obserwowanego, odpowiednio powinien zmienić się stan obserwatorów. Istnieją dwa mechanizmy propagacji zmian stanu obiektu obserwowanego: [[obserwator#Powiadamianie|Powiadamianie]] oraz [[obserwator#Polling|Polling]].
====Powiadamianie====
Po zmianie swojego stanu obiekt obserwowany powiadamia obserwatorów (metoda powiadom) o tym fakcie, po czym obserwatorzy pobierają informację o zmianach wywołując metodę podaj_stan na obiekcie obserwowanym. Podczas tej procedury należy zadbać o dwa istotne fakty:
  * aby obiekt obserwowany pozostał spójny po powiadomieniu obserwatorów\\ istotne jest, aby zapewnić stabilność stanu obiektu obserwowanego przed i po powiadomieniu obserwatorów tak, aby każdy obserwator otrzymał tę samą informację o stanie obiektu obserwowanego		
  * aby uniknąć redundantnych powiadomień podczas całego procesu zmiany stanu\\ powiadamianie obserwatorów o każdej zmianie stanu obiektu obserwowanego nieraz jest niepotrzebne, zamiast tego lepszym wyjściem jest wysłanie jednego powiadomienia po całej grupie zmian jakie nastąpiły
Mechanizm ten jest prosty i oczywisty w wielu zastosowaniach, co czyni go najpowszechniejszym.
====Polling====
W tym mechanizmie, obiekt obserwowany nie powiadamia obserwatorów o zmianie swojego stanu, zamiast tego obserwatorzy odpytują obiekt obserwowany o jego stan. Plusem jest kompletna niezależność obiektu obserwowanego od obserwatorów, trzeba jednak zadbać o to aby odpytywać obiekt obserwowany w odpowiednim momencie - w szczególności nie za często aby uniknąć pustych akcji (żadne zmiany nie nastąpiły) ani nie za rzadko (zmiany mogły nastąpić kilkukrotnie).
====Interakcje====
Istnieją dwa modele interakcji pomiędzy obiektem obserwowanym a obserwatorami:
  * **Push Model**\\ W tym modelu, obiekt obserwowany podaje zmiany swojego stanu obserwatorom. Model ten może zostać użyty gdy wszyscy obserwatorzy polegają na tych samych zmianach, obserwator po prostu odbiera wszystkie dane jakie dostaje od obiektu obserwowanego. Model ten nie jest wskazany podczas przekazywania dużej ilości danych podczas gdy każdy obserwator potrzebuje innej małej porcji danych.
  * **Pull Model**\\ W tym modelu obserwatorzy sami pobierają potrzebne dane od obiektu obserwowanego. Model ten jest bardziej elastyczny, ponieważ obserwatorzy mogą pobrać tylko potrzebne dane.
zpr c++ quick reference

Narzędzia użytkownika

Narzędzia witryny

Narzędzia strony
