"array" aus Funktionen



  • Mmh ... ich schätze, weil ich im Moment auf dem Schlauch stehe. Kann sein, das es mir morgen oder später noch einfällt, im Moment habe ich aber keine Vorstellung, wie ich eine Funktion einer Funktion übergebe und wie ich sie dort aufrufen kann?


  • Mod

    lemon03 schrieb:

    Mmh ... ich schätze, weil ich im Moment auf dem Schlauch stehe. Kann sein, das es mir morgen oder später noch einfällt, im Moment habe ich aber keine Vorstellung, wie ich eine Funktion einer Funktion übergebe und wie ich sie dort aufrufen kann?

    Mit Funktionszeigern? Also dem Mittel, um das sich dieser Thread dreht?

    Besser wäre natürlich ein Template oder eventuell std::function, damit man flexibler bleibt in dem, was man als Funktion übergeben kann.



  • Da sich der Aufruf hier in einer relativ engen Schleife befindet hätte std::function möglicherweise einen merkbaren Overhead.
    Wenn nix dagegen spricht würde ich also eher nen Funktionszeiger nehmen oder aus der Funktion ein Template machen.

    Wobei... die Funktionen machen ja doch einiges. Da wird ja viel gerechnet u.a. mit Winkelfunktionen. Wird also vermutlich doch keinen grossen Unterschied machen.

    @lemon03
    Statt dem Array mit Datentyp T[4] macht du nen Funktionsparemter mit Datentyp T. Und rufst den dann einfach wie ne Funktion auf. Wie du es jetzt schon mit callPlasma.calc_plasma[plasma_idx] machst.



  • Ist zwar OT, trotzdem möchte ich auf std::hypot hinweisen. Eine Funktion, die leider ein Schattendasein fristet... 😞



  • Gut ok, danke. Muss mich noch ein wenig einlesen in die Vorschläge 😉



  • Habe es mal mit einem Funktionszeiger versucht.

    int formel_1(int a, int b){
    
        return a*b;
    }
    
    int formel_2(int a, int b){
    
        return a/b;
    }
    
    void calc_(int (*formel)(int, int))
    {
        int a = 40, b = 8;
        int ergebnis = formel (a, b);
        std::cout << ergebnis << '\n';
    }
    
    void aufruf_(int (*formel)(int, int))
    {
        formel = &formel_1;
        formel = &formel_2;
    
        calc_(formel_1);
        calc_(formel_2);
    
    }
    
    int main()
    {
    
        int (*formel)(int, int) = 0; // Anlegen eines Funktionszeigers, Initialisierung mit 0
    
        aufruf_(formel);
    
    }
    

    Wäre der soweit in Ordnung oder kann man das besser formulieren?



  • Was soll jetzt die aufruf_ Funktion und der Funktionspointer dort als Parameter? Ansonsten sieht das dann schon OK aus. Angewandt auf deinen Code würde deine showPlasmaScroller Funktion statt dem size_t plasma_idx Parameter dann einfach einen Funktionspointer nehmen und diese Funktion aufrufen.



  • Ich wollte das Beispiel eben näher bei meinem aktuellen Einsatzzweck schreiben. Und calc_() soll nicht in der main aufgerufen werden, sondern in einer weiteren Funktion.

    Mit Funktionspointer kann ich jetzt aber nichts anfangen. Ist ein Zeiger nicht ein Pointer bzw?



  • Ja Zeiger = Pointer. Jedenfalls ist der Parameter in der aufruf_ Funktion ziemlich sinnlos. Du übergibst von der main Funktion einen Zeiger der aber auf 0 zeigt, dann schreibst nacheinander die Adressen von zwei Funktionen da rein, nutzt den Pointer aber nie. So würde die Funktion genau das gleiche tun:

    void aufruf_()
    {
        calc_(formel_1);
        calc_(formel_2);
    }
    


  • Ok, dann ist aber nur hier überflüssig:?

    void aufruf_(int (*formel)(int, int))
    {
        //formel = &formel_1;
        //formel = &formel_2;
    
        calc_(formel_1);
        calc_(formel_2);
    
    }
    
    int main(){
    
        int (*formel)(int, int) = 0; // Anlegen eines Funktionszeigers, Initialisierung mit 0
    
        aufruf_(formel);
    
    }
    


  • Der ganze Parameter und die Variable in der main Funktion kann weg.



  • Ah, also?

    int formel_1(int a, int b)
    {
    
        return a*b;
    }
    
    int formel_2(int a, int b)
    {
    
        return a/b;
    }
    
    void calc_(int (*formel)(int, int))
    {
        int a = 40, b = 3;
        int ergebnis = formel (a, b);
        std::cout << ergebnis << '\n';
    }
    
    void aufruf_()
    {
    
        calc_(formel_1);
        calc_(formel_2);
    
    }
    
    int main(){
    
        aufruf_();
    
    }
    

    Aber bzw und beschwert sich der Compiler über die ungenutzte Variable 'formel'?

    EDIT: geändert



  • Uh, wenn das jetzt stimmt, ist mir das direkt ein wenig unheimlich, wie einfach das am Ende ist 😉



  • Ja stimmt. Eigentlich sind Funktionspointer auch nicht so kompliziert, außer der etwas merkwürdigen Syntax und wenn man sich mit dem Konzept angefreundet hat, dass man Funktionen als Parameter an andere Funktionen übergibt.



  • Jupp, danke vielmals 🙂 Wieder was gelernt.


  • Mod

    Und nun siehst du, wieso man nach dem fragt, was man erreichen möchte, nicht nach dem, wie man denkt, wie man zum Ziel kommt.



  • Amen 😉



  • Äh ... sorry, meinte natürlich danke 😉 War wohl gestern im falschen Film.


Anmelden zum Antworten