ich möchte eine Funktionalität wie die des Observer Patterns in C++ nachbauen, allerdings ohne Vererbung!!

Wenn ich Pointer auf Methoden verwenden würde, müsste ich doch die Klasse, auf die der Pointer zeigt, kennen.

Beispiel:

class B;

typedef int (B::*funptr) (int);

Ich schreibe eine Wiederverwendbare Klasse und kann heute nicht sagen, welche Klassen meine Klasse in 5 Jahren verwenden werden. Deshalb kann ich diese Variante nicht nehmen.

Ich möchte im wesentlichen eine Methode Subcribe anbieten, die einen generischen Methodenzeiger als Parameter erwartet. Benutzer meiner Klasse können sich über diese Methode bei meiner Klasse regristrieren. Wenn in meiner Klasse Informationen verfügbar sind, möchte ich diesen Methodenzeiger aufrufen, damit der jeweilige Benutzer weiß, dass Informationen vorhanden sind.

Hat jemand eine Idee wie ich es machen könnte?

Hat jemand eine Idee wie ich es machen könnte?

boost.function bietet dir alles was du dazu brauchst.

Ich muss ja eine Subscribe Methode anbieten, bei der sich der Benutzer anmeldet. Als Parameter muss er mir einen Zeiger auf seine Notify-Methode übergeben.
Wenn ich nun Daten empfange, rufe ich einfach seinen Pointer auf und er kann innerhalb seiner Notify-Methode die Daten bei mir abholen.

Die Benutzer-Klasse kann total unterschiedlich sein. Z.B. Heute gibt es eine Klasse X morgen eine Klasse Y und in 3 Jahren eine Klasse Z, die diese Subscribe Methode benutzen wollen.

In dem Tutorial von boost::function gibt es diese Variante:

struct X {
  int foo(int);
};

boost::function<int (X*, int)> f;

f = &X::foo; <-- Ausprägung

X x;
f(&x, 5);

bekomme ich also als Paramter meiner Subcribe-Methode ein ausgeprägtes f (s.o.) übergeben und kann nun einfach f aufrufen?

Wie würde dann die Signatur meiner Subscribe-Methode aussehen?

void MyClass::Subscribe(boost::function<????>)

An dieser Stelle darf kein Klassenname stehen.

Bitte klär mich auf Hume

boost::function1<void, TypDesErstenParameters> f;
f = boost::bind(&Klasse::Memberfunction, ZeigerAufDieInstanz, _1);
f(parameter);

aber wie du eben beschrieben hast,

boost::bind(&Klasse::....

kann es nicht gehen, da ich &Klasse nicht angeben kann, da ich gar nicht weiß, welche Klassen meine Klasse benutzen werden.

Ich glaub ich steh gerade auf der Leitung...

Kann man nicht das "fertige" f (also nach dem bind) als parameter in meiner Methode übergeben? also z.B.

boost::function1<void, TypDesErstenParameters> f;
f = boost::bind(&Klasse::Memberfunction, ZeigerAufDieInstanz, _1);

TestKlasse.Subscribe(f);

und in der Subscribe Methode:

f();

Ja so sollte es gehen mit der Übergabe.

Noch mal zur Erläuterung:
Benutzer:

class CBenutzer
{
   CBenutzer();
   void update();

   CServer myServer;
};

CBenutzer::CBenutzer()
{
    boost::function1<void, void> f;
    f = boost::bind(&CBenutzer::update, this, _1);

    myServer.Subscribe(f);

}

Server:

CServer::Subscribe(????)
{
   store(f);
   if(gotData)
   {
      f();
   }
}

Was muss ich an der Stelle mit den Fragezeichen angeben, damit ich das Boost::Function Template übergeben kann?

Für eine Funktion ohne Parameter nimmt man boost::function0.

Und Subscribe muss dann natürlich so aussehen:

CServer::Subscribe(const boost::function0<void>& f)

Genau das ist es doch, was ich die ganze Zeit von Dir hören wollte

Ich biete in meiner Klasse also eine Methode Subscribe mit der Signatur:

CServer::Subscribe(const boost::function0<void>& f)

an.

Die Leute, die meine Subscribe- Methode benutzen wollen, müssen boost::function0 ausprägen und mir geben.

Wenn ich Daten für die Personen habe, rufe ich einfach deren boost::functions auf und sie wissen bescheid, dass sie sich ihre daten abholen können.