Multidimensionale vectoren in C++

Ik ben net begonnen met het leren van C++. Ik probeerde de syntaxis voor multidimensionale arrays en vectoren te begrijpen toen ik behoorlijk in de war raakte. Ik begrijp hoe ik multidimensionale arrays initialiseer. Het lijkt eenvoudig: rijen gevolgd door kolommen. Vectoren zijn echter een beetje uitdagender. Moet ik ze op dezelfde manier initialiseren of maak ik een vector van vectoren?

Antwoord 1, autoriteit 100%

Als u C++11 kunt gebruiken, kunnen multidimensionale arrays en vectoren van vectoren op een vergelijkbare manier worden geïnitialiseerd.

int a1[3][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
std::vector<std::vector<int>> a2 = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };

Er zijn echter verschillen die moeten worden begrepen om toegang te krijgen tot de elementen zonder ongedefinieerd gedrag tegen te komen.

Voor een multidimensionale array moet het geheugen voor de elementen van de array aaneengesloten worden toegewezen. Voor een vector van vector zal het geheugen voor de elementen hoogstwaarschijnlijk onsamenhangend zijn.

Geheugen voor a1:

a1[0][0]    a1[1][0]    a1[2][0]
|           |           |
v           v           v
+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+

Geheugen voor a2(waarschijnlijk):

a2[0][0]
|
v
+---+---+---+
|   |   |   |
+---+---+---+
a2[1][0]
|
v
+---+---+---+
|   |   |   |
+---+---+---+
a2[2][0]
|
v
+---+---+---+
|   |   |   |
+---+---+---+

Het is ook mogelijk om een vector van vectoren te definiëren waarin het aantal kolommen niet hetzelfde is voor elke rij.

std::vector<std::vector<int>> a2 = { {1, 2, 3}, {4, 5}, {6, 7, 8, 9} };

In een multidimensionale array is het aantal kolommen gegarandeerd hetzelfde voor elke rij.

Gezien de bovenstaande multidimensionale array a1, zal a1[1][2]een geldig element zijn en a1[2][3]zal een ongeldig element zijn. In het geval van een vector van vectoren, met gebruikmaking van de bovenstaande regel, is a2[1][2]geen geldig element en is a2[2][3]een geldig element.

Antwoord 2, autoriteit 91%

declareer een multidimensionale vector:

vector<vector<int>> test(4,vector<int>(20));

Hierdoor ontstaat een 2D-vector van 4 X 20. Natuurlijk, aangezien het vectoren zijn die naar behoefte kunnen worden gewijzigd. De indexering is hetzelfde als een array test[3][19].

Antwoord 3, autoriteit 15%

Voor geïnteresseerde lezers heeft Boost een MultiArray-bibliotheek die speciaal voor dit probleem is ontworpen. Het beweert efficiënter te zijn dan std::vector<std::vector<...>>en de interface is C++ STL-vriendelijk.

#include "boost/multi_array.hpp"
int main () {
  // Create a 3D array that is 3 x 4 x 2
  boost::multi_array<double, 3>  A(boost::extents[3][4][2]);
  // Assignment
  A[0][0][0] = 1.0;
  // Dereference
  std::cout<<A[0][0][0];
return 0;
}

Lees hier