Vector mit mehreren Einträgen
-
hr4rjuku schrieb:
gibt es bei std::tuple nen limit von einträgen?
Wenn dein Compiler C++11 bzw. Variadic Templates kann dann gibt es kein Limit.
-
nwp3 schrieb:
hr4rjuku schrieb:
gibt es bei std::tuple nen limit von einträgen?
Wenn dein Compiler C++11 bzw. Variadic Templates kann dann gibt es kein Limit.
Natürlich gibt es ein Limit, nämlich 1024.
tupleist hier völlig Fehl am Platz, was der TE will ist ein zweidimensionales Array.
-
Arcoth schrieb:
nwp3 schrieb:
hr4rjuku schrieb:
gibt es bei std::tuple nen limit von einträgen?
Wenn dein Compiler C++11 bzw. Variadic Templates kann dann gibt es kein Limit.
Natürlich gibt es ein Limit, nämlich 1024.
tupleist hier völlig Fehl am Platz, was der TE will ist ein zweidimensionales Array.Ja genau nur will ich ein zweidimensionales Array mit einem Vektor verwalten.
-
hr4rjuku schrieb:
Ja genau nur will ich ein zweidimensionales Array mit einem Vektor verwalten.
Das meinte er auch.
std::vector< std::vector<int>>ist die Lösung
-
[Rewind] schrieb:
std::vector< std::vector<int>>ist die LösungIch würde eher einen 1D-Vector nehmen und Indizes abbilden, ausser man ändert sehr oft eine Dimension.
-
std::vector<int> vec;
dann mit vec.push_back(1,5,3,5,4,9,5,8);
würde das so funktionieren?=
-
hr4rjuku4141 schrieb:
dann mit vec.push_back(1,5,3,5,4,9,5,8);
würde das so funktionieren?=
Nein, wie du leicht durch Ausprobieren hättest feststellen können.
std::vector<int> vec = {1,5,3,5,4,9,5,8};
-
Den Vorschlag von Nexus habe ich trotzdem nicht ganz verstanden. Es geht ja nicht um
{1,5,3,5,4,9,5,8}sondern{{1,5,3,5,4,9,5,8}, {1,2,3}, {...}, ...}. Der Ansatz mit Indizes und nur einemvectorwäre auch für mich neu.
-
[Rewind] schrieb:
Der Ansatz mit Indizes und nur einem
vectorwäre auch für mich neu.Der vector<vector> ist eine Liste von Listen, kein 2D-Array. Daher braucht man das nur aeusserst selten. Beim vector<vector> kann schliesslich jeder der inneren Vectoren eine andere (und veraenderliche) Groesse haben. Das heisst, der vector<vector> muss kreuz und quer im Speicher verteilt liegen, da jeder der inneren Vectoren dynamisch Speicher holt. Wenn man diese Faehigkeit gar nicht nutzt, dann verschenkt man sowohl die Lokalitaet der Daten und man faengt sich noch eine zusaetzliche Indirektion ein.
Wenn die Groesse der inneren Felder bei allen Feldern gleich ist, sind daher zwei Techniken ueblich:
1. Die innere Dimension ist eine Compilezeitkonstante: vector<array>
2. Die innere Dimension ist variabel: Wrapper um 1D-vector, der die Indizes korrekt umrechnet.
-
SeppJ schrieb:
Das heisst, der vector<vector> muss kreuz und quer im Speicher verteilt liegen, da jeder der inneren Vectoren dynamisch Speicher holt.
Bei std::vector ist es doch garantiert, dass für alle Elemente des Vektors ein zusammenhängender Speicherbereich allokiert wird, und zwar unabhängig vom Inhaltstyp. Das würde wiederum heißen, dass bei Änderung der Größe eines einzigen inneren Vektors alle inneren oder zumindest alle nachfolgenden Vektoren verschoben werden würden, was sehr sehr teuer wäre.
-
[Rewind] schrieb:
Bei std::vector ist es doch garantiert, dass für alle Elemente des Vektors ein zusammenhängender Speicherbereich allokiert wird, und zwar unabhängig vom Inhaltstyp. Das würde wiederum heißen, dass bei Änderung der Größe eines einzigen inneren Vektors alle inneren oder zumindest alle nachfolgenden Vektoren verschoben werden würden, was sehr sehr teuer wäre.
Die Elemente sind aber nicht im vector drin. Jeder vector hat immer dieselbe Größe (sizeof vector<typ>) und enthält einen Zeiger auf einen variabel großen zusammenhängenden Speicherbereich. Deshalb ist der Zugriff bei einem vector<vector> auch teurer, weil man 2 mal springen muss und das ohne allocator das Prefetching futsch macht.
Der Vorteil ist aber, dass man einen vector ganz billig herumkopieren kann, weil er dafür den Inhalt nicht anfassen muss.
-
[Rewind] schrieb:
SeppJ schrieb:
Das heisst, der vector<vector> muss kreuz und quer im Speicher verteilt liegen, da jeder der inneren Vectoren dynamisch Speicher holt.
Bei std::vector ist es doch garantiert, dass für alle Elemente des Vektors ein zusammenhängender Speicherbereich allokiert wird.
Die Elemente sind bei vector<vector> aber Vectoren! Das heisst, du hast lauter Vectoren, die ihre Verwaltungsdaten schoen hintereinander stehen haben. Aber der von ihnen verwaltete Speicher ist ganz woanders.
Dieses Bildchen sollte ich wirklich mal irgendwo speichern, viel zu oft musste ich das schon malen
:3x2-int-Array: vector<int> foo(2*3); ------- | foo | ------- | | ein foo-interner Zeiger v ------------------------------------------------------- | foo[0] | foo[1] | foo[2] | foo[3] | foo[4] | foo[5] | Alle Elemente sind int ------------------------------------------------------- vector<array<int, 2>> foo(3); ------- | foo | ------- | | ein foo-interner Zeiger v | foo[0] | foo[1] | foo[2] | Diese Elemente sind array<int, 2>, sie bestehen aus... ------------------------------------------------------------------------- | foo[0][0] | foo[0][1] | foo[1][0] | foo[1][1] | foo[2][0] | foo[2][1] | ...diesen ints ------------------------------------------------------------------------- vector<vector<int>> foo(vector<int>(2), 3); ------- | foo | ------- | | ein foo-interner Zeiger v ---------------------------- | foo[0] | foo[1] | foo[2] | Dies sind vector<int> ---------------------------- | | | | | | foo[2]-interner Zeiger | | | | | v | | ------------------------- | | | foo[2][0] | foo[2][1] | Dies sind ints | | ------------------------- | | | | foo[1]-interner Zeiger | | | v | ------------------------- | | foo[1][0] | foo[1][1] | Dies sind ints | ------------------------- | | foo[0]-interner Zeiger | v ------------------------- | foo[0][0] | foo[0][1] | Dies sind ints -------------------------
-
nwp3 schrieb:
Der Vorteil ist aber, dass man einen vector ganz billig herumkopieren kann, weil er dafür den Inhalt nicht anfassen muss.
Der vector macht aber schon eine tiefe Kopie, das ist daher schon teuer. Du meinst wohl Verschieben. Das kannst du einen vector<typ> aber immer, egal was typ ist.
-
ja, ich meinte verschieben. Herumbewegen.
