Mehrere Variadic Template Arguments



  • Ich habe folgende Klasse:

    https://pastebin.com/pBLbyBqC

    Die Funktionalität der Klasse soll folgende sein:

    Man kann sich mit einer Funktion und einer Priority registrieren. Danach kann man sich auch jederzeit wieder entfernen.

    Nun kann die DelegateChain mit Call aufgerufen werden. Die registrierten Funktionen werden geordnet nach ihrer Priority aufgerufen. Falls eine der Funktionen true zurückgibt wird der Call unterbrochen und true zurückgegeben. Sonst wird die Schleife bis zum Ende durchgeführt und es wird false zurückgegeben.

    Ich will der Klasse DelegateChain eine statische Funktion "CompoundCall" hinzufügen, der man 2 oder mehr DelegateChain Objekte und die dazugehörigen Parameter übergeben kann. Alle bei diesen DelegateChains registrierten Objekte werden dann aufgerufen, allerdings werden die Funktionen geordnet nach Priority verflochten.

    Jetzt zu meiner Frage:

    Ich komme aber nicht drauf wie ich eine Funktion "CompoundCall" erzeugen kann die alle Parameter annehmen kann und korrekt weiterleitet. Was wäre hier die beste Vorgehensweise?

    Die Motivation für das ganze ist dass ich solche DelegateChains für verschiedene Events habe die in einem Spiel auftreten können und dann von verschiedenen Buffs und Komponenten gehandled werden können. Nun will ich aber dass die Events für DealDamage und TakeDamage so verflochten werden dass je nach Priority ein TakeDamage Handler zwischen zwei DealDamage Handlern aufgerufen werden kann.

    EDIT:

    Habs schon:

    template <typename ... FirstParameterTypes, typename ... SecondParameterTypes>
    	static bool CompoundCall(DelegateChain<FirstParameterTypes...> FirstChain, FirstParameterTypes... FirstParameters, DelegateChain<SecondParameterTypes...> SecondChain, SecondParameterTypes... SecondParameters) {
    		// ...
    	}
    

  • Mod

    Entsprechende Threads mit "gelöst" markieren.



  • void Unregister(UObject* Target) {
            for (auto Iterator = Delegates.begin(); Iterator != Delegates.end();) {
                auto OldIterator = Iterator++;
                if (OldIterator->Target == Target) {
                    Delegates.erase(OldIterator);
                }
            }
            return;
        }
    

    Das wird so nicht funktionieren, weil die Iteratoren nach dem Aufruf von erase() alle invalide sind.

    Benutze den Iterator, der dir erase() zurückgibt.


  • Mod

    ()function; schrieb:

    void Unregister(UObject* Target) {
            for (auto Iterator = Delegates.begin(); Iterator != Delegates.end();) {
                auto OldIterator = Iterator++;
                if (OldIterator->Target == Target) {
                    Delegates.erase(OldIterator);
                }
            }
            return;
        }
    

    Das wird so nicht funktionieren, weil die Iteratoren nach dem Aufruf von erase() alle invalide sind.

    Benutze den Iterator, der dir erase() zurückgibt.

    std::list-Iteratoren sind stabil. Ob die Containerwahl eine Gute ist, kann man nat. diskutieren.

    struct Delegate {
            Delegate(UObject* Target, int32 Priority, FunctionType Function) {
                this->Target = Target;
                this->Priority = Priority;
                this->Function = Function;
            }
            UObject* Target;
            int32 Priority;
            FunctionType Function;
        };
    

    Wozu extra Target? Das steckt ja schon im Function-Argument mit drin.


Anmelden zum Antworten