Echt ey!



  • Langsam geht es mir echt auf die Nerven, warum ich bei uns in der Gruppe immer solchen Widerstand erfahre bzgl. modernem C++11 erfahre.

    Ich: "Was hast du eigentlich vor?"
    Person1: "Ich will eine Funktion als Parameter übergeben."
    Ich: "Dann nimm doch einfach std::function und ..."
    Person2: "Du und ein C++11 Kram, musst du damit immer anfangen?"
    Ich: "Äh, wie sonst?" o O ( mit Funktor wollte ich gar nicht anfangen )
    Person2: "Laut google geht das mit Funktionspointern."
    Ich: "Aha."

    <--> Diskussion beendet <-->

    1h später.

    Ich zu allein gelassener Person1: "Und, laufen deine Funktionspointer?"
    Person1: "Nein."
    Ich tippe ein paar Zeilen Code mit std::function , die eine Lambda Funktion übernimmt und schließlich ein std::function Objekt als Parameter einer Funktion übernimmt.

    -> Läuft

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

    Echt ey!



  • Passt ein bisschen zum Thema:

    http://en.wikiquote.org/wiki/Howard_H._Aiken schrieb:

    Don't worry about people stealing your ideas. If your ideas are any good, you'll have to ram them down people's throats.

    Ich weiß nicht, woher dieser Widerstand immer kommt. Es scheint fast so, als wären etwa 20% der Menschen für und 20% gegen jegliche Fortschritte. Der Rest läuft je nach Laune mit einer der beiden Seiten mit.

    Dieselben Diskussionen wiederholen sich immer wieder mit anderen Themen. Früher hat man sich die Köpfe darüber eingeschlagen, ob strukturierte Programmierung sinnvoll ist. Die richtige Seite hat irgendwann gewonnen und jetzt diskutiert darüber niemand mehr.

    Ich schlage dafür Aiken's Law vor: "Je offensichtlicher die Vorteile einer Verbesserung sind, desto erbitterter ist der Widerstand."



  • TyRoXx schrieb:

    Dieselben Diskussionen wiederholen sich immer wieder mit anderen Themen. Früher hat man sich die Köpfe darüber eingeschlagen, ob strukturierte Programmierung sinnvoll ist. Die richtige Seite hat irgendwann gewonnen und jetzt diskutiert darüber niemand mehr.

    Das glaubst aber auch nur Du. Die Strukturierte Programmierung ist fein auf dem absteigenden Ast, wird aber noch von den meisten geheiligt.



  • Klaus82 schrieb:

    Langsam geht es mir echt auf die Nerven, warum ich bei uns in der Gruppe immer solchen Widerstand erfahre bzgl. modernem C++11 erfahre.

    Ich: "Was hast du eigentlich vor?"
    Person1: "Ich will eine Funktion als Parameter übergeben."
    Ich: "Dann nimm doch einfach std::function und ..."
    Person2: "Du und ein C++11 Kram, musst du damit immer anfangen?"
    Ich: "Äh, wie sonst?" o O ( mit Funktor wollte ich gar nicht anfangen )
    Person2: "Laut google geht das mit Funktionspointern."
    Ich: "Aha."

    <--> Diskussion beendet <-->

    1h später.

    Ich zu allein gelassener Person1: "Und, laufen deine Funktionspointer?"
    Person1: "Nein."
    Ich tippe ein paar Zeilen Code mit std::function , die eine Lambda Funktion übernimmt und schließlich ein std::function Objekt als Parameter einer Funktion übernimmt.

    -> Läuft

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

    Echt ey!

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



  • 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';
    

Log in to reply