Mathematik => Programmierung => C++



  • hallo leudz,
    ich fass mich ma kurz:

    wenn ich was (in C++) programmieren will (bTw: bin vollnoob 😃 )
    habe ich immer das problem, dass ich zwar die mittle die mir zur verfügung stehen einigermaßen beherrsche, bloß dennoch fehlt mir nahezu IMMER der ansatz,
    in form dessen, dass ich nie weiss wie ich das ganze programm/modul
    (meine aufgabe eben)

    in Anweisungen/Verarbeitungen/Zuweisungen/Schleifen
    unterbringe...oder besser gesagt:
    die aufgabe mathematisch zerlege...
    so gesehen die rein code-logik...
    gibtz dafür tuts?

    [und nu sagt mir bidde nich sowas wie "das kommt mit der zeit" oder der gleichen!]

    THX in advance!!!

    grüße Chaoz



  • Chaoz schrieb:

    gibtz dafür tuts?

    [und nu sagt mir bidde nich sowas wie "das kommt mit der zeit" oder der gleichen!]

    Was willst du? Ne Pille? Ein Buch, wie denk ich logisch?
    Das einzige was mir zu deiner Fragestellung einfällt wär ein Buch wie OOP leicht gemacht oder sowas, such mal in der Bücherdatebak des Forums.

    Wenn du kein Buch willst, weis ich nicht as du willst.

    Der rest kommt ganz von alleine 🙂



  • _EVENTUELL_ in die Richtung geht "Schule des Denkens. Vom Lösen mathematischer Probleme" von Georg Polya, Darin gehts aber mehr allgemein um Mathematische Problemloesung und was fuer Denkansaetze man dabei so verfolgt. Vielleicht mal aus der Bibliothek ausleihen oder so 🙂

    Ansonsten: nimm dir einfache Aufgaben vor, wenn die, die du momentan bearbeitest, noch zu schwer sind. Da muss man erst mal reinwachsen 🙂



  • Beispiel:
    Es soll eine Summenberechnung gebastelt werden. Angenommen die folgende, funktionierende Lösung wurde geschrieben:

    #include <iostream>
    #include <list>
    using namespace std;
    
    template<typename TIterator>
    typename iterator_traits<TIterator>::value_type summe(TIterator anfang, TIterator ende)
    {
        typename iterator_traits<TIterator>::value_type result = 0;
        for(TIterator position = anfang; position != ende; ++position)
            result += *position;
        return result;
    }
    
    int main()
    {
        int test1[] = {32, 8, 3, 7};
        cout << summe(test1, test1+4) << endl;
    
        list<double> test2;
        test2.push_back(21.5);
        test2.push_back(9);
        test2.push_back(8);
        test2.push_back(3.4);
        cout << summe(test2.begin(), test2.end()) << endl;
    }
    

    So! Schön und gut, jetzt soll es aber plötzlich möglich sein, die zu summierenden Werte vorher durch eine Operation zu verändern. Es stellt sich heraus, dass man die oben definierte Funktion "summe" als Spezialfall folgender Funktion ansehen kann:

    template<typename TIterator, typename TOperation>
    typename iterator_traits<TIterator>::value_type summe(TIterator anfang, TIterator ende, TOperation op)
    {
        typename iterator_traits<TIterator>::value_type result = 0;
        for(TIterator position = anfang; position != ende; ++position)
            result += op(*position);
        return result;
    }
    

    Das Programm mit der Spezialisierung für die oben benutzte Funktion "summe" würde dann wie folgt aussehen:

    #include <iostream>
    #include <list>
    using namespace std;
    
    template<typename TIterator, typename TOperation>
    typename iterator_traits<TIterator>::value_type summe(TIterator anfang, TIterator ende, TOperation op)
    {
        typename iterator_traits<TIterator>::value_type result = 0;
        for(TIterator position = anfang; position != ende; ++position)
            result += op(*position);
        return result;
    }
    
    struct selber
    {
        template<typename T>
        T operator()(T wert) { return wert; }
    };
    
    template<typename TIterator>
    typename iterator_traits<TIterator>::value_type summe(TIterator anfang, TIterator ende)
    {
        return summe(anfang, ende, selber());
    }
    
    int main()
    {
        //...
    }
    

    Durch die Abstraktion von "summe" kann man nun leicht z. Bsp. "quadratsumme" definieren:

    struct quadrat
    {
        template<typename T>
        T operator()(T wert) { return wert * wert; }
    };
    
    template<typename TIterator>
    typename iterator_traits<TIterator>::value_type quadratsumme(TIterator anfang, TIterator ende)
    {
        return summe(anfang, ende, quadrat());
    }
    

    So! Schön und gut, jetzt soll es aber plötzlich möglich sein, all das nicht nur mit der binären Operation + sondern mit beliebigen binären Funktionen zu tun. Es stellt sich heraus, dass man selbst die schon abstrahierte Funktion "summe" noch weiter abstrahieren und somit auch als Spezialfall ansehen kann:

    template<typename TIterator, typename TOperation, typename TBinOperation>
    typename iterator_traits<TIterator>::value_type akkumuliere(TIterator anfang, TIterator ende, TOperation op, TBinOperation binop, typename iterator_traits<TIterator>::value_type startwert)
    {
        typename iterator_traits<TIterator>::value_type result = startwert;
        for(TIterator position = anfang; position != ende; ++position)
            result = binop(result, op(*position));
        return result;
    }
    
    struct addition
    {
        template<typename T>
        T operator()(T wert1, T wert2) { return wert1 + wert2; }
    };
    
    template<typename TIterator, typename TOperation>
    typename iterator_traits<TIterator>::value_type summe(TIterator anfang, TIterator ende, TOperation op)
    {
        return akkumuliere(anfang, ende, op, addition(), 0);
    }
    

    Jetzt kann man natürlich leicht dahergehen und aus der Abstraktion "akkumuliere" die Funktion "produkt" spezialisieren:

    struct multiplikation
    {
        template<typename T>
        T operator()(T wert1, T wert2) { return wert1 * wert2; }
    };
    
    template<typename TIterator, typename TOperation>
    typename iterator_traits<TIterator>::value_type produkt(TIterator anfang, TIterator ende, TOperation op)
    {
        return akkumuliere(anfang, ende, op, multiplikation(), 1);
    }
    

    Anmerkung: Die STL bietet für grundlegende Dinge wie Grundrechenarten-Funktoren und Abstraktionen wie accumulate unter den Headern <functional> und <numeric> Implementierungen an.



  • Heilige Makkaroni. Chaoz erklärt uns, er habe Mühe, eine Problemstellung in die Codestruktur einzubetten.

    Anweisungen/Verarbeitungen/Zuweisungen/Schleifen

    Und du kommst mit templates und dergleichem. Dein Code mag gut sein, ich habe ihn mir nicht genau einverleibt. Aber er ist definitiv nichts für einen Anfänger und hilft Chaoz wohl kein Bisschen.

    @ Chaoz: Ich empfehle dir, falls du es noch nicht getan hast, aus einem Buch genau zu lernen, wie Schleifen, Anweisungen und Aussagen in C(++) funktionieren. Wenn du das verstanden hast, müsste es möglich sein, Probleme in Code zu übersetzen. Falls es dann noch nicht klick macht, bist du entweder zuwenig intelligent dazu (:-p) oder du musst dich wirklich mal mit den Grundsätzen des logischen Denkens befassen... 😉



  • Ich bin mir sicher, dass Chaoz ein wenig Verständnis für Abstraktion/Verallgemeinerung und Konkretisierung/Spezialisierung von Funktionen gewinnen würde, wenn er das Beispiel Schritt für Schritt durchgehen würde. Ob das mit den Templates bereits jetzt verstanden wird, oder erst später, spielt in dem Fall eine sekundäre Rolle. Es geht hier erstmal darum, dass man mit Hilfe einer allgemeinen Funktion mit vielen Parametern, eine speziellere mit weniger Parametern machen kann, indem man welche fixiert. Außerdem sieht man, wie die Steigerung des Grades der Verallgemeinerung die Flexibilität erhöht, weil Dinge (Daten/Funktionen) ausgelagert und in Form von Argumenten austauschbar werden.



  • Ich bleibe bei meiner Meinung. Chaoz, hat dir der Code geholfen bzw. hast du ihn verstanden? Nimmt mich jetzt mal Wunder.



  • also....
    irgendwie hab ich mir schon gedacht dass man dafür nich wirllich groß n tut oda so nutzen kann und dass es letztlich nur im logischen denken liegt (und ich glaub nich wirlklich dass ich so dumm bin ^^ )
    liegt maybe echt nur an der routine des codens!

    so und nun zu dem beispiel:

    erstma THX dass du dir so ne mühe machst...
    auch wnen ich nich wirklich weiss wie n template funzt (k, ich weiss was es is)
    kann ich dennoch sagen dass ich weiss was du meinst...naja....hmmm...
    ich glaub ich sollte doch ma irgendwelche aufgaben machen....so

    und:
    DANKE leudz, echt nett von euch so schnell und so kompetent zu antworten ;)#
    grüße chaoz



  • @bei-spieler: Und wenn man das alles geschafft hat, dann sollte man es wegwerfen und std::accumulate benutzen. 😛



  • @Jester: Hab ich schon angedeutet :p

    ich schrieb:

    Anmerkung: Die STL bietet für grundlegende Dinge wie Grundrechenarten-Funktoren und Abstraktionen wie accumulate unter den Headern <functional> und <numeric> Implementierungen an.


Log in to reply