proggen.org

Yoghurt hat geschrieben:Ich hoffe ich hab dich jetzt richtig verstanden.
Du willst ein Event in eine Queue schieben und das Event dann an einer anderen Stelle verarbeiten, oder?

Yoghurt hat geschrieben:Du könntest zum Beispiel das Event als Objekt betrachten.
Dann machst du dir eine (abstrakte) Event-Klasse [...]

Yoghurt hat geschrieben:[...] und um die Funktion des Events zu bestimmen leitest du entweder davon ab oder übergibst sie in Form eines anderen Objekts.
Die Modeldaten können dann ja beim anstoßen der Verarbeitung des Events mitgegeben werde.

Glocke hat geschrieben:Wie genau meinste das? Von meinem Basis-Event leite ich speziellere Events ab.

Glocke hat geschrieben:Hi, in einer MVC-artigen Anwendung möchte ich vom Controller an das Model einige Daten und eine "Arbeitsanweisung" schicken. Jedoch möchte ich keine Model-Methode aufrufen,

Glocke hat geschrieben:

Code: Alles auswählen

typedef unsigned char EventID;
extern const EventID NO_EVENT = 0;

struct Event {
    EventID event_id;
};

Nun habe ich folgendes "Problem": Ich will weitere Events vom Basisevent ableiten im Sinne

Code: Alles auswählen

extern const EventID DO_FOO = 1;

struct Foo: Event {
    int data;
    Foo() { this->event_id = DO_FOO; }
};

Damit kann ich Foo als Event in mein EventPipe geben und auf der anderen Seite (in Form eines allgemeinen Events) rausholen. Allerdings muss ich dann (wenn ich auf meine Daten zugreifen will) das Event in seine richtige Form casten. Dazu verwende ich diese "event_id":

Code: Alles auswählen

if (unknown_event.event_id == DO_FOO) {
    Foo* known_event = (Foo*)unknown_event; // hab es nicht getestet (das ganze an der stelle noch ein gedankenexperiment^^)
    // handle known event
}

So und jetzt (wie immer am Ende meiner Posts xD) meine Frage: Wie mach ich das "richtig"?

Xin hat geschrieben:Punkt 1: Du gibst Event einen Konstruktor, der die Initialisierung von event_id verlangt, also muss jede Ableitung Event initialisieren.

Xin hat geschrieben:Punkt 2: Wieso void*? Wieso ist das Model noch unbekannt? Oder ist es eigentlich ein struct BaseModel *, das Du noch nicht definiert hast.

Xin hat geschrieben:Pack die Konstante noch static in den Namensraum, damit Du mit den Ids nicht den globalen Namensraum belegst.

namespace eventids {
    const EventID foobar = 13;
}

Glocke hat geschrieben:

Xin hat geschrieben:Punkt 1: Du gibst Event einen Konstruktor, der die Initialisierung von event_id verlangt, also muss jede Ableitung Event initialisieren.

Also so, wie ich es oben hatte, dass jede Ableitung von Event die entsprechende EventID sich selber gibt?

Glocke hat geschrieben:

Xin hat geschrieben:Pack die Konstante noch static in den Namensraum, damit Du mit den Ids nicht den globalen Namensraum belegst.

Also im Sinne

Code: Alles auswählen

namespace eventids {
    const EventID foobar = 13;
}

mit this->event_id = eventids::foobar im Konstruktor - also so vom Prinzip her?

struct Foo : public Event {
    static Event const MyId = 1;
    int data;
    Foo() : Event( MyId ) {}
};

Xin hat geschrieben:Die Id ist kein Zeiger und bedarf keiner virtuellen Funktionen.

#include <iostream>
#include <queue>
#include <string.h>

typedef unsigned char EventID;

namespace eventid {
    extern const EventID BASE  = 0;
    extern const EventID LOGIN = 1;
}

struct Event {
    EventID event_id;
    Event(EventID event_id): event_id(event_id) {}
};

struct Login: Event {
    char username[255];
    Login(): Event(eventid::LOGIN) {}
};
    
class EventPipe {
    protected:
        std::queue<Event*> events;
   
    public:
        EventPipe() {}
        ~EventPipe() {}
        void push(Event* event) {
            this->events.push(event);
        }
        Event* pop() {
            while (this->events.empty()) {}
            Event* tmp = this->events.front();
            this->events.pop();
            return tmp;
        }
};

int main() {
    // Sender
    EventPipe* pipe = new EventPipe();
    Login* login = new Login();
    memcpy(login->username, "Glocke", 7);
    pipe->push(login);
    
    // Empfänger
    Event* next_event = pipe->pop();
    if (next_event->event_id == eventid::LOGIN) {
        Login* next_login = (Login*)next_event;
        std::cout << "Das Event war ein Login mit username=" << next_login->username << std::endl;
    }
}