Echt ey!



  • volkard schrieb:

    Ich sehe jetzt nicht, was an der einen oder anderen Version einfacher wäre. Was liefe denn performater?

    Nur eine von beiden Varianten lief überhaupt mal. Was soll dann diese Frage?

    Wahrscheinlich wäre hier ein Template besser gewesen, aber so etwas ist den pikfeinen Herren Programmierern natürlich auf gar keinen Fall zuzumuten. Da müsste man C++ verstehen, wo kommen wir da hin?



  • Was der Bauer nicht kennt, frisst er nicht.

    Und C++11 kennt er definitiv nicht. :p



  • std::function als Parameter ist fast immer suboptimal. Die Loesung die schon seit C++98 die Beste ist sind Templates.


  • Mod

    Arcoth schrieb:

    Die Loesung die schon seit C++98 die Beste ist sind Templates.

    Das ist doch Hexenwerk. Und bestimmt 50x langsamer als ein Zeiger!



  • SeppJ schrieb:

    Arcoth schrieb:

    Die Loesung die schon seit C++98 die Beste ist sind Templates.

    Das ist doch Hexenwerk. Und bestimmt 50x langsamer als ein Zeiger!

    Da muss doch bei jedem Aufruf der Compiler gestartet werden, um Code zu generieren. Das ist dann bestimmt 100x langsamer.



  • Arcoth schrieb:

    std::function als Parameter ist fast immer suboptimal. Die Loesung die schon seit C++98 die Beste ist sind Templates.

    Und Templates sind sogar viel einfacher als Funktionzeiger.
    Wohingegen std::function überhaupt nicht einfacher ist.
    Also nicht so gut, wenn man mit aller Gewalt überall C++11 reinkloppen will, und sogar hier weint, wenn manche Leute da gewisse Ressentiments haben.



  • Was der Bauer nicht kennt, das frisst er nicht.
    Ich kann mich da auch nicht ganz von frei sprechen.
    Würde ich lamdas & co nicht kennen, würde ich den Tipp zwar gerne annehmen, aber hätte trotzdem 1h gebraucht, um mich da erstmal rein zu lesen.



  • Einfach klasse, wie widerstandslos Ihr Klaus82s Moderngehüpfe fresst.

    Klaus82 schrieb:

    Person1: "Oh, das ist toll. Aber die Funktion soll zwei Parameter haben."
    Ich: "Dann machst du aus std::function<double(double)> fn eben std::function<double(double,double)> fn und änderst entsprechend hier und dort .."
    Person1: "Das ist ja einfach!"
    Ich: "C++11" halt.
    Echt ey!

    Person1: "Oh, das ist toll. Aber die Funktion soll zwei Parameter haben."
    Ich: "Dann machst du aus double fn(double) eben double fn(double,double) und änderst entsprechend hier und dort .."
    Person1: "Das ist ja einfach!"
    Ich: "C++" halt.
    Echt ey!

    Person1: "Oh, das ist toll. Aber die Funktion soll zwei Parameter haben."
    Arcoth: "Dann machst du aus FN fn eben FN fn und änderst entsprechend hier und dort nichts.."
    Person1: "Das ist ja einfach!"
    Arcoth: "C++" halt.
    Echt ey!

    #include <iostream>
    #include <cmath>
    #include <functional>
    using namespace std;
    
    //Was im Internet steht
    //double sin(double)
    double foo1(double (*fn)(double)){
    	return fn(3.14);
    }
    //Schon recht einfach. Stern davor und Klammern drum.
    
    //Was im Buch steht
    //double sin(double)
    double foo2(double fn(double)){
    	return fn(3.14);
    }
    //Nix tun.
    
    //Threadersteller
    //double sin(double)
    double foo3(std::function<double(double)> fn){
    	return fn(3.14);
    }
    //Bezeichner wegmachen und std::funktion<> drum,
    //den Bezeichner dann dahinter.
    //Also bei Weitem die komplizierteste Lösung.
    //Und dann kommt ja noch...
    
    //Arcoth
    //double sin(double)
    template<typename FN>
    double foo4(FN fn){
    	return fn(3.14);
    }
    
    int main(){
    	cout<<foo1(sin)<<'\n';
    	cout<<foo2(sin)<<'\n';
    
    	//...dieser Hammer.
    	cout<<foo3(static_cast<double(*)(double)>(sin))<<'\n';
    
    	//Leider auch
    	cout<<foo4(static_cast<double(*)(double)>(sin))<<'\n';
    }
    

    Schwierig, zu sehen, was die beste Lösung ist.
    Aber einfach, zu sehen, was die schlechteste ist: std::function.
    Echt ey!



  • std::function hat einen guten Einsatzort: Polymorphe interfaces die beliebige Funktionen/Funktoren einer Signatur übernehmen sollen.



  • @volkard
    3 und 4 kannst du auch mit nem Lambda aufrufen.
    (1 und 2 IIRC auch, aber da wäre das lambda länger als einfach nur "sin" zu schreiben)

    @otze
    Virtuelle Interfaces, wenn man es abspeichern muss, DLL interfaces - gibt viele Anwendungen wo std::function angebracht ist.



  • //Leider auch
        cout<<foo4(static_cast<double(*)(double)>(sin))<<'\n';
    

    Moment, moment. Das geht kürzer.

    cout<< foo4<double(double)>(sin) <<'\n';
    

Anmelden zum Antworten