Ich möchte das Observerpattern einsetzen, allerdings reicht es mir nicht aus, "genotified" zu werden. Ich brauche den Zeiger auf das Objekt, damit ich entsprechend reagieren kann. Trotzdem soll mein Observer-Pattern generisch sein, damit ich nicht jedes Mal Code erzeugen muss, nur weil der Observer jetzt anders ist.

Meine Idee war jetzt folgende:

class IObservable {
   public:
      virtual ~IObservable() {}

      void attach (Observer* pObserver) {
         observers.push_back(pObserver);
		}

      void notify() {   
			 for (size_t i=0; i<observers.size(); ++i) {
				observers[i]->update(this);
			 }
         }
   private:
      std::vector<Observer*> observers;
};

Dazu der Observer:

class Observer {
	public:
	    virtual ~Observer() {}
	    virtual void update(void* pSubject) = 0;
};

Ich habe mich dabei versucht, an Java zu orientieren. Dort wird der Updatemethode zum einen das Observable-Objekt übergeben und zum anderen ein "Object" als Argument. Das versuche ich mit dem void-Zeiger nachzubilden, da es in C++ ja keine "OberBasisklasse" gibt.

Frage Nr. 1) Hat wer andere Ideen, die besser sind als meine?

Frage Nr. 2) Ist meine Idee überhaupt realisierbar? Mein Programm läuft genau solange gut, wie ich nicht versuche, einen Downcast durchzuführen:

Geht:

cout<<"Observer::Update aufgerufen"<<pSubject<<endl;

Geht nicht (stürzt dann an einer ganz anderen Stelle im Objekt ab)

cout<<"Observer::Update aufgerufen "<<static_cast<I2DGeometry*>(pSubject)->getPosition().x<<endl;

Danke für's Zuhören

Ansonsten könntest du dir vielleicht auch mal Boost.Function anschauen. Gibts übrigens auch als std::tr1::function (TR1) und std::function (C++0x). Siehe auch hier...

Daraus ein template zu machen ist nur bedingt sinnvoll, außer man leitet von IObserver ab.

template <class ObserverType>
public TObserver : IObserver 
{
  TObserver(ObserverType* observerThis);
}

void YourManagerClass::RegisterObserver<class ObserverType>(ObserverType* observeThis)
{
  // std::vector< IObserver* > notifiers;
  notifiers.push_back(TObserver<ObserverType>(observerThis);
}

void YourManagerClass::notifiy();
{
 for_each(notifiers, note)
 {
   // Spätestens hier gibts einen cast
   note->YourBaseClassFunction(this);
 }
}

Wenn überhaupt brauchst dafür einen reinterpret_cast.

Ne, void* castet man mit static_cast .

template <typename Observable>
class IObservable
{
   public:
      virtual ~IObservable() {}

      void attach (Observer* pObserver) {
         observers.push_back(pObserver);
        }

      void notify() {   
             for (size_t i=0; i<observers.size(); ++i) {
                observers[i]->update(static_cast<Obserable>(this));
             }
         }
   private:
      std::vector<Observer*> observers;
};

class DasDingDasObserviertWerdenSoll : public IObserable<DasDingDasObserviertWerdenSoll>
{
  //...
};

In C++ gibt es mehr Möglichkeiten als in Java, weswegen ich einfach den signal/slot-Mechanismus anschauen würde. Dieser kann auf Methoden verweisen, nicht auf ganze Klassen. Das macht alles etwas dynamischer.

Eine Dynamik in dem Sinne, dass die Observable-Klasse allgemein bleiben soll, aber man trotzdem einen Zeiger übergibt, geht so nicht, da muss man eben eine Spezialisierung bauen.

#ifndef OBSERVABLE
#define OBSERVABLE

#include <vector>

// General Observable for different Observers and their needs 

template<typename Observer> 
class Observable 
{ 
private:
	typedef typename Observer ObserverType;

	typedef std::vector<ObserverType*> Observers; 
	typedef typename Observers::iterator ObserversIt;     
	Observers observers; 

protected: 
	Observers& getObservers() {return observers;} 

public: 
	void AddObserver(ObserverType& newObserver) {observers.push_back(&newObserver);} 

	void notifyAll() 
	{ 
		for(ObserversIt it = observers.begin(); it != observers.end(); ++it) 
			notify(*it); // nebenbei noch Template Method Pattern angewendet; das hat aber nix mit C++ Templates zu tun
	} 

	virtual void notify(ObserverType*) = 0; 

	virtual ~Observable() {} 
}; 

#endif

#ifndef PUSHOBSERVER
#define PUSHOBSERVER

// PushObserver - a specific observer which gets notification of source 

class PushObservable; 

class PushObserver 
{ 
public:
	virtual void onNotification(PushObservable* source) = 0; 
};

#endif

#ifndef PUSHOBSERVABLE
#define PUSHOBSERVABLE

#include "Observable.hpp"
#include "PushObserver.hpp"

// PushObservable: A specific Observable which publishes the source 

class PushObservable : public Observable<PushObserver> 
{ 
public: 
	/*virtual*/ void notify(PushObserver* observer) 
	{ 
		observer->onNotification(this); 
	} 
};

#endif

Edit: So, ist jetzt auch kompilierbar.

Jetzt kann jeder Erbe vom Observable sich selbst aussuchen, was er dem jeweiligen Observer mitgibt. Aber ob das so wichtig ist... weiß ich nicht. Jedenfalls sind signal/slots deutlich kürzer und eleganter imo.