Wie definieren Sie einen 2D-array in C++ und STL-ohne memory-manipulation?

Es gibt mehrere Möglichkeiten zum definieren einer 2D-array in C++ und STL-ohne memory-manipulation, und die folgenden codes zeigen zwei verschiedenen Methoden:

int main () 
{
    /**************
        1   2   3
        4   5   6
    ***************/
    //Method 1
    const int ROW = 2;
    const int COL = 3;
    int array1[ROW][COL];
    for(int i=0; i<ROW; i++)
        for(int j=0; j<COL; j++)
            array1[i][j] = i*COL+j+1;

    //Method 2
    typedef vector<vector<int> > ARRAY; 
    ARRAY array2;
    vector<int> rowvector;
    for(int i=0; i<ROW; i++)
    {
        rowvector.clear();
        for(int j=0; j<COL; j++)
            rowvector.push_back(i*COL+j+1);
        array2.push_back(rowvector);
    }
    return 0;
}

Meine Frage ist: gibt es andere Möglichkeiten zum definieren des 2D-array? Welche die effizienteste ist? Danke!

int **arr2D ;
Gutes tutorial über arrays in C++
Wenn Ihr array konstanter Größe verwenden Sie Methode 1. Wenn Ihr array hat eine bestimmte Größe zur Laufzeit verwenden Sie Methode 2. Weitere, weniger nützliche Methoden für 2d-arrays sind std::array<std::array<int, COL>, ROW> und boost mehrdimensionale arrays.

InformationsquelleAutor feelfree | 2012-10-11

  1. 4

    gibt es andere Möglichkeiten zum definieren des 2D-array?

    Nicht ohne Manipulation Speicher explizit (malloc/free). Wenn Sie statische reservierten Arrays (1. B.) ordnen Sie den Raum zur compile-Zeit, so können Sie nicht mehr hinzufügen, Zeilen oder Spalten zur Laufzeit.

    Dem zweiten Beispiel verwendet std::vector versteckt, dass Sie die dynamische Speicherverwaltung . Auf diese Weise können Sie schließlich fügen Sie mehrere Zeilen oder Spalten zur Laufzeit.

    Wenn Sie nicht brauchen, um dynamisch ändern Sie die array-dimension, dann die erste Lösung ist die einfachere und schnellere (auch wenn ich denke, dass std::vector Implementierung ist schnell genug, um vergleichbar zu statischen array, eleganter und mehr Objekt-orientiert).

    Wenn Sie müssen, ändern Sie die array-dimension zur Laufzeit verwenden std::vector, weil es erspart Ihnen den Umgang direkt mit malloc und free.

    also entweder sollte man wissen, die Größe der Kompilierung und Verwendung std::array oder wählen Sie zwischen std::vector und new/malloc. Wenn nur gab es eine Größe unveränderlich std:array dass nicht brauchen, um zu wissen, die Größe im Voraus, die verwendet werden könnte für viele Anwendungen wie die Bilder, die ich bekommen über Netzwerk, ich kann nicht wissen, die Größe, aber wenn die Größe bekannt ist, brauche ich nicht die zusätzliche Komplexität von std::vector

    InformationsquelleAutor Heisenbug

  2. 16

    In C++11 verwenden std::array:

      std::array<std::array<int,3>,2> a {{
    {{1,2,3}},
    {{4,5,6}}
 }};

    Einige Verwendung:

      a[0][2] = 13;

    InformationsquelleAutor PiotrNycz

  3. 7

    Eine sehr effiziente Methode zum definieren von arrays ist die dynamische Zuordnung, mit der new und delete Betreiber. Hier ist ein Beispiel:

    int **arr=new int*[ROW];
for( int i=0; i<ROW; ++i ) {
  arr[i] = new int[COL];
  for( int j=0; j<COL; ++j ) {
    arr[i][j] = some_val;
  }
}

    Der große Vorteil dieses Ansatzes ist, dass, wenn Sie nicht mehr brauchen, der Speicher, das array verwendet, können Sie einfach löschen. Hier ist ein Beispiel für das löschen eines 2D-array:

    for( int i=0; i<ROW; ++i ) {
  delete[] arr[i];
}
delete[] arr;

    InformationsquelleAutor Rontogiannis Aristofanis

  4. 6

    Ein häufiges Muster ist, welche die 2D-array innerhalb einer Klasse, bietet die entsprechende Schnittstelle. In diesem Fall kann man auch auf andere interne Repräsentationen, wie zum Beispiel einen einzigen Vektor von rows*cols Elemente. Die Schnittstelle (in der Regel operator()(int,int) Karte die Koordinaten aus dem Anrufer um eine position in der linearen Vektor.

    Der Vorteil ist, dass Sie die dynamische Zuordnung, aber eine einzelne Zuweisung (im Gegensatz zu den std::vector<std::vector<int>> wo jeder Vektor erwerben müssen es eigene Speicher) und in einem block bietet die Lokalität der Daten.

    InformationsquelleAutor David Rodríguez - dribeas

  5. 6

    Gibt es eine Menge von trade-offs hier.

    Wenn Sie erklären, eine C-Format 2D-array int array[height][width], dann bekommen Sie wirklich einen zusammenhängenden block im Speicher. Der compiler wandelt Indizes, um Ihre 1D-Adresse

    array[row][col] == *(array + row * width + col)
    • Vorteile: cache-Kohärenz. Der gesamte Speicher ist in der gleichen Stelle.
    • Nachteile: Sie müssen ein multiplizieren für jeden Indizierung. Umweg schneller sein.

    Wenn Sie eine vector von vectors, dann jede Zeile wird separat zugeordnet. Die äußeren vector speichert Zeiger auf die innere vectors. Die Indizierung wird eine Dereferenzierung, gefolgt von einer Zugabe: 

    array[row][col] == *(*(array + row) + col)
    • Vorteile: Dereferenzierung kann schneller sein als die Multiplikation.
    • Nachteile: nicht cache-kohärent, da jede Zeile wird separat zugeordnet (es sei denn, die Umsetzung optimiert für vector<vector>).

    Wenn Leistung wirklich wichtig ist, müssen Sie zu testen und herauszufinden, welche ist schneller auf Ihre Daten.

    sind Sie sicher, dass über die cache-Kohärenz? sind Sie sicher, dass jede Zeile zugeordnet ist, die separat?
    Ich denke, die STL-Implementierung könnte eine Optimierung für vector von vector.

    InformationsquelleAutor japreiss

  6. 4

    Zu erklären, ein 2D-array mit std::vector Sie können diese Art der Konstruktion:

    vector<vector<int> >  matrix( n, vector<int>(m, -1) );

    Dieser erstellt ein 2D array matrix Größe n durch m mit allen Elementen initialisiert, um -1.

    Es ist im Grunde eine Verschachtelung der "initialisieren mit n Gegenstände von Wert val" Konstruktor:

    vector (size_type n, const value_type& val,
                 const allocator_type& alloc = allocator_type());

    (Konstruktor-definition kopiert von hier)

    InformationsquelleAutor MatthewD

  7. 0

    Wenn Sie wissen, die Elemente, bevor die hand, dann könnte man nur tun

    int arr[3][3] = {{1,2, 3}, {4, 5, 6}};

    Dies sollte effizienter sein, als methode1 und methode2.Verwenden von vector-Sie sind nicht Speicher-manipulation selbst, sondern die vector-Implementierung wird wahrscheinlich eines dynamisch reservierten Arrays.

    InformationsquelleAutor kkg

Schreibe einen Kommentar