Ich experimentiere gerade etwas herum, versuch(t)e eine Art einfaches Event-System zu implementieren, frei nach dem Observer-Pattern, wobei die Observer dem Observable einen Methodenzeiger für das Callback mitgeben. Das funktionierte, bis eine abgeleitete Klasse zum Observer wurde und plötzlich die Zeiger nicht mehr stimmten... Das fiel mir auf, als ich in der abgeleiteten Klasse falsche Werte in Variablen der Basisklasse hatte. Die Klassenhierarchie sieht so aus:

+-----------+    +-----------+ 
| SomeBase  |    | Observer  |
+-----------+    +-----------+ 
| int val   |    +-----------+ 
+-----------+          ^
       ^               |
       |               |
       +-------|-------+
               |
        +-----------+ 
        | SomeClass |
        +-----------+ 
        | OnEvent() |
        +-----------+

Hier nun eine vereinfachte Darstellung meines Codes, der die wesentliche Hierarchie wiedergbit:

// Interface für Klassen, die Events empfangen
struct Observer
{
	// Die Methoden sind beliebig und in den abgeleiteten Klassen definiert
};

// Basisklasse in irgendeiner Hierarchie
struct SomeBase
{
	SomeBase(int v): val(v) { std::cout << "SomeBase Ctor: " << val << std::endl; }
	int val;
};

typedef void (Observer::*pEventHandler)();
typedef Observer* pObserver;

// Eine konkrete Klasse, die vom SomeBase erbt und das Observer-Interface "implementiert"
struct SomeClass: public SomeBase, public Observer
{
	SomeClass(int v): SomeBase(v) 
	{
		// Der this-Zeiger verschiebt sich zwischen den Hierarchien
		// um 4 Byte, also der Größe von SomeBase
		std::cout << "(Observer*)this: " << (Observer*) this << std::endl; 
		std::cout << "(SomeBase*)this: " << (SomeBase*)this << std::endl;
		std::cout << "this: " << this << std::endl;
	}

	// Diese Methode wird vom Observable aufgerufen, sobald ein Event ausgelöst wird
	void OnEvent() 
	{ 
		// Auf die Variable kann nur in der Some*-Hierarchie zugegriffen werden
		std::cout << "OnEvent() val: " << val << std::endl;

		// Bei Aufruf über die Observer-Hierarchie ist der Wert 4 Byte davor zu finden:
		int* p = &val;
		std::cout << "OnEvent() val-1: " << *(p-1) << std::endl; // 1337
	}
};

int main()
{
	SomeClass c(1337);
	c.OnEvent();

	// Das Observable würde einen Zeiger auf den Observer und einen Methodenzeiger übernehmen
	pObserver o = &c;
	pEventHandler e = (pEventHandler)&SomeClass::OnEvent;

	(o->*e)(); // val wird 4 Byte zu spät gelesen, da der Aufruf über einen Observer-Zeiger erfolgt

	return 0;
}

Die Ausgabe sieht z.B. so aus:

SomeBase Ctor: 1337
(Observer*)this: 002AFD10
(SomeBase*)this: 002AFD0C
this: 002AFD0C
OnEvent() val: 1337
OnEvent() val-1: -858993460
OnEvent() val: -858993460
OnEvent() val-1: 1337

Das alles betrachtet, fällt über den Observer-Hierarchiepfad das SomeBase-Objekt quasi raus, liegt aber natürlich im Speicher. Darauf lässt sich jedoch nicht korrekt zugreifen, stattdessen wird von einer anderen Speicherstelle gelesen (bzw. die selbe, relativ zum Objekt) - denn wenn man Observer ein int verpasst, wird genau dieses ausgegeben. Die wird da jeweils der Weg zum int gefunden? Und warum ist das so? In der Observer-Hierarche arbeite ich letztlich mit einem unvollständigen Objekt - und ich hab sehr lange gebraucht um das herauszufinden (bzw. den obigen Code zu isolieren).

Was für Möglichkeiten habe ich nun? Ich könnte Observer in SomeBase implementieren, auch wenn das ein wenig der Logik widerspricht. Oder ich erzeuge ein Objekt das parallel zu SomeClass exisitiert und nur die Events empfängt, ...aber bestimmt kann man es ganz anders besser machen

Ich freue mich auf eure Antworten!

MfG,
Meisterfrickler

Im folgenden ein paar Änderungen, wie ich es machen würde. Es bleibt Deine Aufgabe sie zu verstehen:

#include <iostream>
using namespace std;

// Interface für Klassen, die Events empfangen
struct Observer
{
	virtual void OnEvent() = 0; 
	// !!!!! Die Methoden sind beliebig und in den abgeleiteten Klassen definiert !!!?????? >>Quatsch<<
};

....

int main()
{
	SomeClass c(1337);
	c.OnEvent();

	// Das Observable würde einen Zeiger auf den Observer und einen Methodenzeiger übernehmen
	pObserver o = &c;

	//!!!pEventHandler e = (pEventHandler)&SomeClass::OnEvent;
	//!!!(o->*e)(); // val wird 4 Byte zu spät gelesen, da der Aufruf über einen Observer-Zeiger erfolgt
         //?? wie kommst Du auf dieses Zeug?

	o->OnEvent();

	return 0;
}

Grüsse

Drehleiter schrieb:

// !!!!! Die Methoden sind beliebig und in den abgeleiteten Klassen definiert !!!?????? >>Quatsch<<

Im Observer-Interface hatte ich auch erst eine virtuelle Methode, aber die Events, auf die ich reagieren will, kommen von GUI-Elementen. Angenommen ich habe 5 Buttons, deren Events ich alle in einer Klasse behandeln möchte - dazu könnte ich jetzt im Interface maximal eine "OnButtonEvent"-Methode einführen, die dann für alle Buttons aufgerufen wird. In der Implementierung dieser Methode müsste ich irgendwie herausfinden, welcher Button das Event ausgelöst hat und dann ggf. eine weitere Methode aufrufen, die das Event dann tatsächlich behandelt. Indem ich beliebige Methoden an die Events knüpfen kann, umgehe ich diese beiden Probleme (falls man das so machen kann, das möchte ich mir ja lieber noch absegnen lassen...).

Drehleiter schrieb:

//?? wie kommst Du auf dieses Zeug?

Verstehe die Frage nicht wirklich. Der Fehler trat halt auf und dann habe ich ihn zurückverfolgt. Sagen wir, es hat sich so ergeben!

Ich sehe es so:

"Observer" ist das Interface, über dass du auf die Objekte zugreifen willst, also musst Du ihm auch eien adequate Schnittstelle geben. Wenn "Observer" keine Schnittstelle hat, dann braucht man es auch nicht!

Im Observer-Interface hatte ich auch erst eine virtuelle Methode, aber die Events, auf die ich reagieren will, kommen von GUI-Elementen. Angenommen ich habe 5 Buttons, deren Events ich alle in einer Klasse behandeln möchte - dazu könnte ich jetzt im Interface maximal eine "OnButtonEvent"-Methode einführen, die dann für alle Buttons aufgerufen wird. In der Implementierung dieser Methode müsste ich irgendwie herausfinden, welcher Button das Event ausgelöst hat und dann ggf. eine weitere Methode aufrufen, die das Event dann tatsächlich behandelt.

Klingt für mich richtig.

Indem ich beliebige Methoden an die Events knüpfen kann, umgehe ich diese beiden Probleme (falls man das so machen kann, das möchte ich mir ja lieber noch absegnen lassen...).

Geht auch, indem die Interface-Funktion einen entsprechenden Funktionspointer als Argument akzeptiert.

Grüsse

PS:
Es gibt noch eine Lösung die bestimmt nicht Standard-Konform ist(geht mit VC++).
Vertausche die Riehenfolge der Ableitungen:

struct SomeClass: public Observer, public SomeBase

und hier zeigt sich aus das Problem: Der Zusammenhang zwischen der Adresse des Objektes und der Basisklasse ist nicht eindeutig.

"Observer" ist das Interface, über dass du auf die Objekte zugreifen willst, also musst Du ihm auch eien adequate Schnittstelle geben. Wenn "Observer" keine Schnittstelle hat, dann braucht man es auch nicht!

Naja, es hat eine "dynamische Schnittstelle" ;). Und ich brauche es bei diesem Ansatz, um die Observer auf nen gemeinsamen Nenner zu bringen...

Drehleiter schrieb:

Geht auch, indem die Interface-Funktion einen entsprechenden Funktionspointer als Argument akzeptiert.

Das würde aber zu den gleichen Problemen führen, weil er Aufruf wieder über die Observer-Hierarchie geschieht.

Aber das alles ist jetzt hinfällig geworden! Ein kluger Kopf hat mir verraten, wie man es besser machen kann: Mit Funktionsobjekten. Das Observable bekommt den Observer nicht mehr direkt übergeben, sondern ein Funktionsobjekt, das den Aufruf der Memberfunktion kapselt. Das bringt den unschätzbaren Vorteil mit sich, dass jede beliebige Klasse Events empfangen kann und dabei nicht einmal ein bestimmtes Interface implementiern muss. Sogar freie Funktionen lassen sich so als Event-Handler benutzen.

Auf den ursprünglichen Code angewandt sieht das z.B. so aus:

SomeClass c(1337);

	boost::function<void ()> f = boost::bind(&SomeClass::OnEvent, &c);
	f();

Sehr geil!