Undefinierter Integer [gelöst]



  • @wob
    In dem geposteten Beispiel sucht er aber nicht gezielt nach Keys/Strings. Daher schien mir die unordered_map unpassend.
    Kann man aber genauso nehmen. In dem Beispiel machts aber funktional keinen Unterschied. Und die Performance vom vector dürfte bei nur 4 Einträgen besser sein, selbst wenn man nach Keys sucht 😉



  • @It0101 Nur noch eine kleine Anmerkung: wenn die Größe zur compile time feststeht und sich nicht ändern soll, würde ich eher std::array empfehlen. Ist dann auch das genaue Equivalent zu dem verwendeten C-Style Array.



  • @Unterfliege sagte in Undefinierter Integer [gelöst]:

    @It0101 Nur noch eine kleine Anmerkung: wenn die Größe zur compile time feststeht und sich nicht ändern soll, würde ich eher std::array empfehlen. Ist dann auch das genaue Equivalent zu dem verwendeten C-Style Array.

    Das sind Details. In der Praxis hab ich noch nie einen passenden Anwendungsfall für std::array gehabt, weil die meisten Sachen in der Serverentwicklung konfigurierbar sind. Daher ist es für Anfänger wesentlich wichtiger, std::vector zu beherrschen.



  • @It0101 sagte in Undefinierter Integer [gelöst]:

    In dem geposteten Beispiel sucht er aber nicht gezielt nach Keys/Strings. Daher schien mir die unordered_map unpassend.

    Naja, das hatte ich anders verstanden. Vordefinierten Kategorien sollen Werte zugewiesen werden - und diese Werte können fehlen.

    Das passt doch exakt zur map: ich muss nachgucken, ob es einen vordef. Wert gibt (map.find) und diesen, wenn vorhanden, dann zuweisen.

    Kann aber natürlich sein, dass das Problem anders gelagert ist. Die "was ist schneller"-Diskussion möchte ich nicht mitführen, weil man hier die für das Problem logisch richtige Datenstruktur wählen sollte.



  • Auf den ersten Blick, denke ich auch, dass std::map besser geeignet ist. Ich würde es gerne nach folgendem Muster benutzen.

    #include <map>
    #include <string>
    #include <iostream>
    
    int main()
    {
        int x;
        int y;
        std::map <std::string, std::map<int,int>> test= {"test",{1,x+y}};
        return 0;
    }
    

    Dabei ist der string der Name der Kategorie, der erste Integer der Wert und der zweite Integer die Formel, nach der gerechnet werden soll. Kann das so theoretisch überhaupt funktionieren und wie initalisiere ich diese Map richtig?



  • @Richard_Wunsch So wie du das jetzt hast, wird als Wert der inneren Map das Ergebnis von x + y gespeichert. Das ist in dem Fall aber sogar, da x und y nicht initialisiert sind, undefiniert.
    Um die Formel zu speichern, musst du eine Funktion in der Map speichern. Das machst du wahlweise über Funktionspointer bzw. std::function. Wahlweise könntest du das wohl auch über Funktoren hinbekommen.
    Verwenden denn alle Formeln nur x und y oder auch noch andere Parameter?

    Oder wiederum verstehe ich dich komplett falsch und die willst die Formel einfach als String speichern, um sie auszugeben?



  • @Unterfliege Ok, initalisieren habe ich gelöst. Waren ein paar Klammern zu wenig...

    #include <map>
    #include <string>
    #include <iostream>
    
    int foo (int x, int y){
        return (x+y);
    }
    
    int main(){
        std::map <std::string, std::map <int,int>> test = {{"test",{{1,foo(1,1)}}}};
    }
    

    Das eigentliche Ziel ist es, einen Werte (erster integer) einzulesen, einer vordefinierten Kategorie zuzuweisen (string) und dann in die Rechnung (zweiter integer) mit einzubinden. Also quasi so etwas: ["Kategorie"] = [x+y] - [eingelesener Wert]

    Edit: Wichtig dabei ist, dass wenn kein Wert eingelesen wird, die gesamte Kategorie undefiniert bleibt.



  • @Richard_Wunsch sagte in 3d map initialisieren:

    Das eigentliche Ziel ist es,

    Habe die Erklärung leider nicht verstanden.

    Jetzt hast du eine Datenstruktur, die so aussieht:

    "Kategorie" => ( 1 => 2)

    Insbesondere ist mir die innere map von int auf int nicht klar. Damit speicherst du eine Zuordnung von Zahlen auf Zahlen, also hier in deinem Beispiel von 1 auf 2. D.h. das "foo" wird nicht in der map gespeichert, sondern nur das Ergebnis von foo.



  • Ah ja, das macht natürlich Sinn. Danke für die Veranschaulichung!

    #include <map>
    #include <string>
    #include <iostream>
    
    int foo (int x, int y){
        return (x+y);
    }
    
    int main()
    {
        int y;
        std::cin >> y;
        std::map <std::string, int> test = {{"test", foo(1,2)-y}};
    
    }
    

    So ist es jetzt aber "Kategorie" => Rechnung - eingegebener Wert, richtig?



  • @Richard_Wunsch Jein.
    Jetzt ist es:
    "Kategorie" => Ergebnis
    Aus deinem Ergebnis kannst du aber natürlich nicht mehr ursprüngliche Eingabe und deine Formel ableiten. Ich weiß natürlich nicht, ob das dein Ziel ist.


Anmelden zum Antworten