Vector nach bedarf erzeugen und benennen



  • Hi,

    Variablennamen können nicht zur Laufzeit erstellt werden.
    Mein Ansatz wäre entweder ein vector aus vectoren, also vector<vector<int> > (wichtig: Leerzeichen nicht vergessen, sonst wirds als >>-Operator interpretiert).

    Falls du unbedingt Variablennamen haben möchtest, kannst du die vectoren mit einem string, der quasi dein Vectorname ist, in einer map speichern.
    Der string wäre dann der map-key, mit dem du auf den vector zugreifen kannst.

    Das könnte dann z.B. so aussehen:

    map<string,vector<int> > vectormap; //map erzeugen
    vectormap["vector1"] = {1,2,3,4};   //ersten vector einfügen und mit Werten befüllen
    int i = vectormap["vector1"][2];    //Wert an Indexposition 2 von "vector1" auslesen
    

    Es ist aber nur ein String, kein Variablenname. vector1[2] funktioniert nicht.

    Ich arbeite sehr gerne mit maps und für so etwas eignen sie sich gut.

    Viele Grüße
    Cherup



  • C++Developer2000 schrieb:

    Hi, ich möchte immer 4 zahlen in einen vector packen und danach einen neuen erstellen,

    Warum?



  • Furble Wurble schrieb:

    Da std::array<int, 4> elendig zu tippen ist, wählst Du auch noch einen "catchy" Namen dafür:
    using ivec4=std::array<int, 4>;

    Ich bin eben verdammt schlau und benutze deshalb copy+paste wenn ich kein typedef kreire. 😉



  • EOP schrieb:

    Furble Wurble schrieb:

    Da std::array<int, 4> elendig zu tippen ist, wählst Du auch noch einen "catchy" Namen dafür:
    using ivec4=std::array<int, 4>;

    Ich bin eben verdammt schlau und benutze deshalb copy+paste wenn ich kein typedef kreire. 😉

    Du Fuchs! 😉



  • Danke für eure Antworten

    wenn ich jetzt einen vector in einem vector mache, was bringt mir das, steh grad aufm schlauch



  • Es bringt Dir, dass Du dann mehrere Vectoren mit dynamischen "Namen" (=Indices) hast - genau das, was Du haben wolltest!?



  • Da du keine Variablenname erzeugen kannst, musst du den vector ja irgendwo speichern, damit du später drauf zugreifen kannst. Das wäre sonst wie eine Liste in einem GROßEN Archiv und keiner weiß wo sie liegt 😉
    Also speicherst du die erzeugten vectoren in einem anderen Container, eben einem vector oder einer map.
    Dadurch kannst du so viele vectoren erzeugen oder auch entfernen, wie du willst, der "speicher"-vector wächst einfach mit.
    Also genau das, was du möchtest.



  • Cherup schrieb:

    Mein Ansatz wäre entweder ein vector aus vectoren, also vector<vector<int> > (wichtig: Leerzeichen nicht vergessen, sonst wirds als >>-Operator interpretiert)

    Das Leerzeichen ist seit C++11 nicht mehr nötig und einigen Compilern haben es auch schon davor akzeptiert.



  • hmm, hast recht. Ich hatte es mir angewöhnt, weil mein Compiler dabei immer gemotzt hat. Gut zu wissen 😃



  • Vielleicht brauchst du eine Struktur/Klasse, welche 4 int-Member enthält. Dann kannst du Instanzen davon in einen vector packen.



  • Warum dafür eine eigene Klasse schreiben?
    Dann braucht man auch wieder get/set-Methoden um die Werte zu setzen und auszulesen.
    Je nachdem, wofür man die vectoren mit den 4 Werten benutzen will, muss/kann/sollte man dann weitere Methoden wie eine swap-Funktionen schreiben oder Operatoren überladen.
    vectoren haben das schon alles.
    Viel zu viel unnötiger Aufwand. Und man hat ebenfalls keine "dynamischen" Variablennamen.



  • Wenn es immer nur 4 werte pro einheit sind ist eine struct in Kombination mit einem vector/map die perfekte wahl.



  • und warum kein vector?
    Wie schon gesagt, man muss sehr viel an zusätzlichen Funktionen schreiben.
    Außerdem muss man dann entweder 4 get-methoden schreiben um die Werte auszulesen (sehr umständlich bei der späteren Benutzung) oder eine get-Funktion, die die Werte mit einem vector zurückgibt (da kann man die Werte auch gleich in einem vector speichern oder aber man macht die ints öffentlich, was dem Konzept der Datenkapselung widerspricht und eigentlich nie eine gute Idee ist.
    Abgesehen davon muss man auch eine mögliche Erweiterung auf größere vectoren in Betracht ziehen. Eine Klasse mit 4 ints ist einfach gar nicht anpassungsfähig.
    Man mus ja nicht das Rad neu erfinden...

    Nenn mir bitte einen vernünftigen Grund statt eines vectors eine Klasse/struct zu nutzen, ich kann mir beim besten Willen keinen vorstellen.



  • Cherup schrieb:

    Dann braucht man auch wieder get/set-Methoden um die Werte zu setzen und auszulesen.

    Nein, die braucht man nicht!



  • Gut,wenn man die ints öffentlich hält braucht man sie natürlich nicht. Von öffentlichen variablen halte ich aber nicht viel.
    Ich sehe trotzdem noch keinen Vorteil darin eine eigene Klasse zu schreiben statt einen vector zu nutzen, nur um 4 int-variablen zu speichern.

    Die Diskusion geht auch grade etwas am eigentlichen Thema vorbei. Die Frage war ja, wie man zur Laufzeit Variablennamen erzeugt und das geht nicht.

    Was jetzt die beste Vorgehenweise ist hängt von der Problemstellung ab.



  • Cherup schrieb:

    Da du keine Variablenname erzeugen kannst, musst du den vector ja irgendwo speichern, damit du später drauf zugreifen kannst. Das wäre sonst wie eine Liste in einem GROßEN Archiv und keiner weiß wo sie liegt 😉
    Also speicherst du die erzeugten vectoren in einem anderen Container, eben einem vector oder einer map.
    Dadurch kannst du so viele vectoren erzeugen oder auch entfernen, wie du willst, der "speicher"-vector wächst einfach mit.
    Also genau das, was du möchtest.

    Also quasi

    vector<vector<int> > Vektorenspeicher{};
    

    Nur wie spreche ich den an, weil

    Vektorenspeicher.push_back(vector<int> Vektor1);
    

    funktioniert nicht



  • zum einfügen z.B. so:

    vector<vector<int>> vectorSpeicher;
    
    //vorher erstellter vector:
    vector<int> tempvec = {1,2,3,4};   //tempvec erzeugen und mit Werten füllen
    vectorSpeicher.push_back(tempvec); //tempvec dem Speicher hinzufügen
    tempvec = {5,6,7,8};               //tempvec mit neuen Werten befüllen
    vectorSpeicher.push_back(tempvec); //und wieder dem Speicher hinzufügen
    
    //oder direkt:
    vectorSpeicher.push_back({1,2,3,4});
    vectorSpeicher.push_back({5,6,7,8});
    

    Das Auslesen ist auch simpel:

    int i = vectorSpeicher[0][2]; //i bekommt den Wert 3
    

    Viele Grüße
    Cherup



  • Cherup schrieb:

    Gut,wenn man die ints öffentlich hält braucht man sie natürlich nicht. Von öffentlichen variablen halte ich aber nicht viel.
    Ich sehe trotzdem noch keinen Vorteil darin eine eigene Klasse zu schreiben statt einen vector zu nutzen, nur um 4 int-variablen zu speichern.

    Wenn diese 4 Werte eine logische Struktur bilden, dann lohnt sich meist eine Klasse. Vor allem will man gerade dann gewöhnlich auch nicht auf die einzelnen Werte zugreifen, sodnern die logische innerere Struktur verändern bzw. eine Operationen darauf/damit ausführen.
    Und damit hat man ganz schnell eine Klasse bzw. deren Verantwortlichkeit.

    Cherup schrieb:

    Die Diskusion geht auch grade etwas am eigentlichen Thema vorbei. Die Frage war ja, wie man zur Laufzeit Variablennamen erzeugt und das geht nicht.

    Richtig.

    Cherup schrieb:

    Was jetzt die beste Vorgehenweise ist hängt von der Problemstellung ab.

    Auch wieder richtig.



  • Das beste wäre jetzt zu wissen, was der TE vor hat 😉



  • Ja das wäre gut 🙂

    Wenn Operationen mit/auf den Werten durchgeführt werden sollen, dann macht eine Klasse wirklich sinn, da stimme ich zu.
    Ich hatte es so verstanden, das bloß beliebig oft 4 Werte gespeichert werden sollen, da macht eine Klasse für mich keinen Sinn.


Anmelden zum Antworten