Wie deklariere ich ein 2D-Array mit new?
Für ein "normales" Array würde ich:
int* ary = new int[Size]
aber
int** ary = new int[sizeY][sizeX]
a) funktioniert nicht / kompiliert und b) erreicht nicht was:
int ary[sizeY][sizeX]
tut.
c++
arrays
multidimensional-array
dynamic-allocation
user20844
quelle
quelle
Antworten:
Ein dynamisches 2D-Array ist im Grunde ein Array von Zeigern auf Arrays . Sie können es mit einer Schleife wie folgt initialisieren:
Das Obige für
colCount= 5
undrowCount = 4
würde Folgendes ergeben:quelle
new
ist, auf dem Heap erstellt wird und mit der Zuordnung aufgehoben werden muss.delete
Denken Sie daran und löschen Sie diesen Speicher aus dem Heap, wenn Sie damit fertig sind, um Lecks zu vermeiden.T (*ptr)[M] = new T[N][M];
ist die richtige Lösung… Keine Anzahl von Arrays von Zeigern wird jemals die gleiche sein wie ein Array von Arrays…sollte sein:
und dann aufräumen wäre:
EDIT: Wie Dietrich Epp in den Kommentaren betonte, ist dies nicht gerade eine leichte Lösung. Ein alternativer Ansatz wäre die Verwendung eines großen Speicherblocks:
quelle
i*sizeX+j
? Wenn ich mich richtig erinnere, sollte es bei der Hauptreihenfolge Zeile * numColumns + col sein.Obwohl diese beliebte Antwort Ihnen die gewünschte Indizierungssyntax liefert, ist sie doppelt ineffizient: groß und langsam, sowohl räumlich als auch zeitlich. Es gibt einen besseren Weg.
Warum diese Antwort groß und langsam ist
Die vorgeschlagene Lösung besteht darin, ein dynamisches Array von Zeigern zu erstellen und dann jeden Zeiger mit einem eigenen, unabhängigen dynamischen Array zu initialisieren. Der Vorteil dieses Ansatzes besteht darin, dass Sie die gewohnte Indizierungssyntax erhalten. Wenn Sie also den Wert der Matrix an Position x, y ermitteln möchten, sagen Sie:
Dies funktioniert, weil Matrix [x] einen Zeiger auf ein Array zurückgibt, das dann mit [y] indiziert wird. Brechen sie ab:
Praktisch, ja? Wir mögen unsere [x] [y] -Syntax.
Die Lösung hat jedoch einen großen Nachteil : Sie ist sowohl fett als auch langsam.
Warum?
Der Grund, warum es sowohl fett als auch langsam ist, ist tatsächlich der gleiche. Jede "Zeile" in der Matrix ist ein separat zugewiesenes dynamisches Array. Eine Heap-Zuordnung ist sowohl zeitlich als auch räumlich teuer. Der Allokator benötigt Zeit, um die Zuordnung vorzunehmen, und führt manchmal O (n) -Algorithmen aus, um dies zu tun. Und der Allokator "füllt" jedes Ihrer Zeilenarrays mit zusätzlichen Bytes für die Buchhaltung und Ausrichtung auf. Dieser zusätzliche Platz kostet ... na ja ... zusätzlichen Platz. Der Deallocator wird auch zusätzliche Zeit in Anspruch, wenn Sie die Zuordnung der Matrix aufheben, wodurch jede einzelne Zeilenzuordnung sorgfältig . Bringt mich ins Schwitzen, wenn ich nur daran denke.
Es gibt noch einen anderen Grund, warum es langsam ist. Diese getrennten Zuordnungen neigen dazu, in diskontinuierlichen Teilen des Gedächtnisses zu leben. Eine Zeile befindet sich möglicherweise an der Adresse 1.000, eine andere an der Adresse 100.000 - Sie haben die Idee. Dies bedeutet, dass Sie beim Durchqueren der Matrix wie eine wilde Person durch die Erinnerung springen. Dies führt tendenziell zu Cache-Fehlern, die Ihre Verarbeitungszeit erheblich verlangsamen.
Wenn Sie also unbedingt Ihre niedliche [x] [y] Indizierungssyntax haben müssen, verwenden Sie diese Lösung. Wenn Sie Schnelligkeit und Kleinheit wünschen (und wenn Sie sich nicht für diese interessieren, warum arbeiten Sie in C ++?), Benötigen Sie eine andere Lösung.
Eine andere Lösung
Die bessere Lösung besteht darin, Ihre gesamte Matrix als ein einziges dynamisches Array zuzuweisen und dann (leicht) eine eigene clevere Indizierungsmathematik zu verwenden, um auf Zellen zuzugreifen. Die Indizierungsmathematik ist nur sehr wenig klug; Nein, es ist überhaupt nicht klug: Es ist offensichtlich.
Mit dieser
index()
Funktion (von der ich mir vorstelle, dass sie Mitglied einer Klasse ist, weil sie diem_width
Ihrer Matrix kennen muss) können Sie auf Zellen in Ihrem Matrix-Array zugreifen. Das Matrixarray wird wie folgt zugeordnet:Das Äquivalent dazu in der langsamen, fetten Lösung:
... ist das in der schnellen, kleinen Lösung:
Traurig, ich weiß. Aber du wirst dich daran gewöhnen. Und Ihre CPU wird es Ihnen danken.
quelle
class Matrix { int* array; int m_width; public: Matrix( int w, int h ) : m_width( w ), array( new int[ w * h ] ) {} ~Matrix() { delete[] array; } int at( int x, int y ) const { return array[ index( x, y ) ]; } protected: int index( int x, int y ) const { return x + m_width * y; } };
Wenn Sie diesen Code korrigieren, ist dies möglicherweise sinnvoll und gibt Aufschluss über die obige Antwort.#define ROW_COL_TO_INDEX(row, col, num_cols) (row*num_cols + col)
Dann können Sie es als verwenden.int COLS = 4; A[ ROW_COL_TO_INDEX(r, c, COLS) ] = 75;
Der Overhead wirkt sich wirklich aus, wenn wir Matrixmultiplikationen durchführen, die für Strassens Algorithmus die Komplexität O (n ^ 3) oder O (n ^ 2.81) haben .a[x][y]
, was Sie tatsächlich tun, ist*(*(a + x) + y)
: zwei Ergänzungen und zwei Speicherabrufe. Mita[index(x, y)]
, das tun , was man eigentlich sind*(a + x + w*y)
: zwei Zugaben, eine Multiplikation und ein Speicher holen. Letzteres ist aus den in dieser Antwort genannten Gründen oft vorzuziehen (dh es lohnt sich, den zusätzlichen Speicherabruf mit einer Multiplikation zu tauschen, insbesondere weil die Daten nicht fragmentiert sind und Sie daher keinen Cache verpassen).In C ++ 11 ist Folgendes möglich:
Auf diese Weise wird der Speicher nicht initialisiert. Um es zu initialisieren, gehen Sie stattdessen folgendermaßen vor:
Beispielprogramm (kompilieren mit "g ++ -std = c ++ 11"):
Ausgabe:
quelle
using arr2d = double(*)[2]; arr2d array = new double[M][N];
double (*)[M][N]
oderdouble(*)[][N]
mit M, wobei N konstante Ausdrücke sind.Ich gehe von Ihrem statischen Array-Beispiel aus, dass Sie ein rechteckiges Array und kein gezacktes wollen. Sie können Folgendes verwenden:
Dann können Sie auf folgende Elemente zugreifen:
Vergessen Sie nicht, delete [] zu verwenden
ary
.quelle
Es gibt zwei allgemeine Techniken, die ich in C ++ 11 und höher empfehlen würde, eine für die Dimensionen der Kompilierungszeit und eine für die Laufzeit. Bei beiden Antworten wird davon ausgegangen, dass Sie einheitliche, zweidimensionale Arrays (keine gezackten) wünschen.
Zeitdimensionen kompilieren
Verwenden Sie ein
std::array
vonstd::array
und verwenden Sie es dannnew
, um es auf den Haufen zu legen:Dies funktioniert wiederum nur, wenn die Größen der Dimensionen zur Kompilierungszeit bekannt sind.
Laufzeitdimensionen
Der beste Weg, um ein zweidimensionales Array mit Größen zu erstellen, die nur zur Laufzeit bekannt sind, besteht darin, es in eine Klasse zu packen. Die Klasse weist ein 1d-Array zu und überlastet es dann
operator []
es , um die Indizierung für die erste Dimension bereitzustellen. Dies funktioniert, weil in C ++ ein 2D-Array Zeilenmajor ist:(Entnommen aus http://eli.thegreenplace.net/2015/memory-layout-of-multi-dimensional-arrays/ )
Eine zusammenhängende Speicherfolge ist aus Leistungsgründen gut und auch leicht zu bereinigen. Hier ist eine Beispielklasse, die viele nützliche Methoden auslässt, aber die Grundidee zeigt:
Also erstellen wir ein Array mit
std::make_unique<int[]>(rows * columns)
Einträgen. Wir überladen,operator []
wodurch die Zeile für uns indiziert wird. Es gibt einint *
Zeichen zurück, das auf den Anfang der Zeile zeigt, das dann wie gewohnt für die Spalte dereferenziert werden kann. Beachten Sie, dass dasmake_unique
erste Mal in C ++ 14 ausgeliefert wird, Sie es jedoch bei Bedarf in C ++ 11 mehrfach ausfüllen können.Es ist auch üblich, dass diese Arten von Strukturen ebenfalls überlastet
operator()
werden:Technisch habe ich hier nicht verwendet
new
, aber es ist trivial, vonstd::unique_ptr<int[]>
zu zu wechselnint *
undnew
/ zu verwendendelete
.quelle
std::array
vonstd::array
s :std::array<std::array<int, columns> rows>
.asserts
Debug-Builds zur Überprüfung von Speicherzugriffen usw. Diese Ergänzungen erleichtern und erleichtern die Arbeit im Allgemeinen.make_unique
stattnew/delete
.Diese Frage hat mich nervt - es ist ein häufig genug auftretendes Problem, dass es bereits eine gute Lösung geben sollte, etwas Besseres als der Vektorvektor oder das Rollen Ihrer eigenen Array-Indizierung.
Wenn in C ++ etwas vorhanden sein sollte, dies aber nicht ist, sollten Sie zunächst nach boost.org suchen . Dort fand ich die Boost Multidimensional Array Library ,
multi_array
. Es enthält sogar einemulti_array_ref
Klasse, mit der Sie Ihren eigenen eindimensionalen Array-Puffer umschließen können.quelle
auto
Schlüsselwort. Ich bin überrascht, dass sie nicht versucht haben, 2D-Arrays in Angriff zu nehmen, zumal Boost bereits den Weg gezeigt hat.Warum nicht STL: vector verwenden? So einfach, und Sie müssen den Vektor nicht löschen.
Sie können die 'Arrays' auch initialisieren. Geben Sie einfach einen Standardwert ein
Quelle: Wie erstelle ich 2, 3 (oder mehr) dimensionale Arrays in C / C ++?
quelle
Ein 2D-Array ist im Grunde ein 1D-Array von Zeigern, wobei jeder Zeiger auf ein 1D-Array zeigt, das die tatsächlichen Daten enthält.
Hier ist N Zeile und M Spalte.
dynamische Zuordnung
füllen
drucken
kostenlos
quelle
Wie ordne ich ein zusammenhängendes mehrdimensionales Array in GNU C ++ zu? Es gibt eine GNU-Erweiterung, mit der die "Standard" -Syntax funktioniert.
Es scheint, dass das Problem vom Operator new [] kommt. Stellen Sie sicher, dass Sie stattdessen den Operator new verwenden:
Und das ist alles: Sie erhalten ein C-kompatibles mehrdimensionales Array ...
quelle
double (*in)[m][n] = (double (*)[m][n])new double[k*m*n];
funktioniert auch nicht. Ich erhalte C2057- und C2540-Fehler,n
da diese zur Kompilierungszeit nicht bekannt sind. Ich verstehe nicht, warum ich das nicht kann, weil der Speicher richtig zugewiesen ist und es nur Zeiger sind , um diesen Speicher bequem zu handhaben. (VS 2010)gcc
mich getäuscht, als ich dies schrieb: Die Lieferung-std=c++11
reicht nicht aus, um die strikte Standardkonformität einzuschalten,-pedantic-errors
ist ebenfalls erforderlich. Akzeptiert ohne das spätere Flaggcc
die Besetzung gerne, obwohl sie tatsächlich nicht dem C ++ - Standard entspricht. Nach dem, was ich jetzt weiß, kann ich nur raten, auf C zurückzugreifen, wenn ich Dinge mache, die stark von mehrdimensionalen Arrays abhängen. C99 ist in dieser Hinsicht viel leistungsfähiger als selbst C ++ 17.typedef ist dein Freund
Nachdem ich viele der anderen Antworten durchgesehen hatte, stellte ich fest, dass eine tiefere Erklärung angebracht ist, da viele der anderen Antworten entweder unter Leistungsproblemen leiden oder Sie dazu zwingen, ungewöhnliche oder lästige Syntax zu verwenden, um das Array zu deklarieren oder auf das Array zuzugreifen Elemente (oder alle oben genannten).
Bei dieser Antwort wird zunächst davon ausgegangen, dass Sie die Dimensionen des Arrays zur Kompilierungszeit kennen. Wenn Sie dies tun, ist dies die beste Lösung, da beide die beste Leistung bieten Verwendung der Standard-Array-Syntax für den Zugriff auf die Array-Elemente ermöglicht .
Der Grund für die beste Leistung liegt darin, dass alle Arrays als zusammenhängender Speicherblock zugewiesen werden, was bedeutet, dass Sie wahrscheinlich weniger Seitenfehler und eine bessere räumliche Lokalität haben. Das Zuweisen in einer Schleife kann dazu führen, dass die einzelnen Arrays auf mehreren nicht zusammenhängenden Seiten im virtuellen Speicherbereich verstreut sind, da die Zuordnungsschleife (möglicherweise mehrmals) durch andere Threads oder Prozesse unterbrochen werden kann oder einfach aufgrund des Ermessens der Allokator füllt kleine, leere Speicherblöcke aus, die zufällig verfügbar sind.
Die anderen Vorteile sind eine einfache Deklarationssyntax und eine Standard-Array-Zugriffssyntax.
In C ++ mit new:
Oder C-Stil mit Calloc:
quelle
Dieses Problem hat mich 15 Jahre lang beschäftigt, und alle angebotenen Lösungen waren für mich nicht zufriedenstellend. Wie erstellt man ein dynamisches mehrdimensionales Array zusammenhängend im Speicher? Heute habe ich endlich die Antwort gefunden. Mit dem folgenden Code können Sie genau das tun:
Wenn Sie das Programm mit den Werten sizeX = 20 und sizeY = 15 aufrufen, lautet die Ausgabe wie folgt:
Wie Sie sehen können, liegt das mehrdimensionale Array zusammenhängend im Speicher, und keine zwei Speicheradressen überlappen sich. Selbst die Routine zum Freigeben des Arrays ist einfacher als die Standardmethode zum dynamischen Zuweisen von Speicher für jede einzelne Spalte (oder Zeile, je nachdem, wie Sie das Array anzeigen). Da das Array im Wesentlichen aus zwei linearen Arrays besteht, müssen (und können) nur diese beiden freigegeben werden.
Diese Methode kann mit demselben Konzept um mehr als zwei Dimensionen erweitert werden. Ich werde es hier nicht tun, aber wenn Sie die Idee dahinter haben, ist es eine einfache Aufgabe.
Ich hoffe, dieser Code wird Ihnen genauso helfen, wie er mir geholfen hat.
quelle
array2d[i] = buffer + i * sizeX
. Dies hilft also in geringem Maße, aber im Code, der das Array verwendet, kann der Compiler nicht einfach Zeiger inkrementieren, um das Array zu scannen.make_unique<int[]>(sizeX*sizeY)
den zusammenhängenden Speichermake_unique<int*[]>(sizeX)
einrichten und den Speicher für die Zeiger einrichten (die auf die gleiche Weise zugewiesen werden sollten, wie Sie sie zeigen). Dies befreit Sie von der Notwendigkeit,delete[]
am Ende zweimal anzurufen .temp
? In Anbetracht der Vorteile (Continuos 2d-Array mit unbekannten Dimensionen zur Kompilierungszeit) bin ich mir nicht sicher, ob es mir wichtig ist, dass es baumelt. Ich habe nicht verstanden, was @PeterCordes bedeutetextra layer of indirection
, was ist das? Warum die Klammerarray2d[i] = (temp + i * sizeX)
;Der Zweck dieser Antwort besteht nicht darin, etwas Neues hinzuzufügen, das die anderen noch nicht behandelt haben, sondern die Antwort von @Kevin Loney zu erweitern.
Sie können die Lightweight-Deklaration verwenden:
und die Zugriffssyntax lautet:
Dies ist jedoch für die meisten umständlich und kann zu Verwirrung führen. Sie können ein Makro also wie folgt definieren:
Jetzt können Sie mit der sehr ähnlichen Syntax auf das Array zugreifen
ary(i, j) // means ary[i][j]
. Dies hat den Vorteil, einfach und schön zu sein, und gleichzeitig ist die Verwendung von Ausdrücken anstelle der Indizes einfacher und weniger verwirrend.Um beispielsweise auf ary [2 + 5] [3 + 8] zuzugreifen, können Sie
ary(2+5, 3+8)
anstelle des komplex aussehenden schreiben ,ary[(2+5)*SizeY + (3+8)]
dh es werden Klammern gespeichert und die Lesbarkeit verbessert.Vorsichtsmaßnahmen:
SizeY
muss es mit demselben Namen übergeben werden (oder stattdessen als globale Variable deklariert werden).Wenn Sie das Array in mehreren Funktionen verwenden müssen, können Sie SizeY auch wie folgt als weiteren Parameter in die Makrodefinition einfügen:
Du hast die Idee. Natürlich wird dies zu lang, um nützlich zu sein, aber es kann immer noch die Verwechslung von + und * verhindern.
Dies wird definitiv nicht empfohlen und wird von den meisten erfahrenen Benutzern als schlechte Praxis verurteilt, aber ich konnte nicht widerstehen, es wegen seiner Eleganz zu teilen.
Bearbeiten:
Wenn Sie eine tragbare Lösung wünschen, die für eine beliebige Anzahl von Arrays funktioniert, können Sie diese Syntax verwenden:
Anschließend können Sie mithilfe der Zugriffssyntax ein beliebiges Array mit einer beliebigen Größe an den Aufruf weitergeben:
PS: Ich habe diese getestet und die gleiche Syntax funktioniert (sowohl als l-Wert als auch als r-Wert) auf g ++ 14- und g ++ 11-Compilern.
quelle
Versuchen Sie Folgendes:
quelle
Hier habe ich zwei Möglichkeiten. Der erste zeigt das Konzept eines Arrays von Arrays oder eines Zeigers von Zeigern. Ich bevorzuge die zweite, weil die Adressen zusammenhängend sind, wie Sie auf dem Bild sehen können.
quelle
Wenn Ihr Projekt CLI (Common Language Runtime Support) ist , dann:
Sie können die Array-Klasse verwenden, nicht die, die Sie beim Schreiben erhalten:
Mit anderen Worten, nicht die nicht verwaltete Array-Klasse, die Sie erhalten, wenn Sie den Standard-Namespace verwenden und den Array-Header einschließen, nicht die nicht verwaltete Array-Klasse, die im Standard-Namespace und im Array-Header definiert ist, sondern das verwaltete Klassenarray der CLI.
Mit dieser Klasse können Sie ein Array mit einem beliebigen Rang erstellen .
Der folgende Code erstellt ein neues zweidimensionales Array aus 2 Zeilen und 3 Spalten vom Typ int, und ich nenne es "arr":
Jetzt können Sie auf Elemente im Array zugreifen, indem Sie sie benennen und nur eine quadratische Klammer schreiben. Fügen Sie
[]
in ihnen die Zeile und Spalte hinzu und trennen Sie sie durch das Komma,
.Der folgende Code greift auf ein Element in der 2. Zeile und 1. Spalte des Arrays zu, das ich bereits im vorherigen Code oben erstellt habe:
Wenn Sie nur diese Zeile schreiben, lesen Sie den Wert in dieser Zelle, dh Sie erhalten den Wert in dieser Zelle, aber wenn Sie den gleichen Wert hinzufügen
=
, schreiben Sie den Wert in diese Zelle, dh legen Sie den Wert in dieser Zelle fest. Sie können die Operatoren + =, - =, * = und / = natürlich auch nur für Zahlen verwenden (int, float, double, __int16, __int32, __int64 usw.), aber Sie wissen es sicher bereits.Wenn Ihr Projekt keine CLI ist, können Sie die nicht verwaltete Array-Klasse des Standard-Namespace verwenden, wenn Sie dies
#include <array>
natürlich tun , aber das Problem ist, dass sich diese Array-Klasse vom CLI-Array unterscheidet. Das Erstellen eines Arrays dieses Typs entspricht der CLI, außer dass Sie das^
Vorzeichen und dasgcnew
Schlüsselwort entfernen müssen . Leider gibt der zweite int-Parameter in den<>
Klammern die Länge (dh die Größe) des Arrays an, nicht seinen Rang!Es gibt keine Möglichkeit, den Rang in dieser Art von Array anzugeben. Der Rang ist nur die Funktion des CLI-Arrays . .
Das std-Array verhält sich wie ein normales Array in c ++, das Sie beispielsweise mit dem Zeiger definieren
int*
und dann:new int[size]
oder ohne Zeiger:,int arr[size]
aber im Gegensatz zum normalen Array des c ++ bietet das std-Array Funktionen, die Sie mit den Elementen des Arrays verwenden können. wie Füllen, Beginnen, Beenden, Größe usw., aber normales Array bietet nichts .Trotzdem sind Standard-Arrays eindimensionale Arrays, wie die normalen C ++ - Arrays. Aber dank der Lösungen, die die anderen Leute vorschlagen, wie Sie das normale eindimensionale C ++ - Array in ein zweidimensionales Array verwandeln können, können wir dieselben Ideen an das Standardarray anpassen, z. B. können wir nach der Idee von Mehrdad Afshari den folgenden Code schreiben:
Diese Codezeile erstellt ein "jugged array" , ein eindimensionales Array, das jede seiner Zellen ist oder auf ein anderes eindimensionales Array zeigt.
Wenn alle eindimensionalen Arrays in einem eindimensionalen Array in ihrer Länge / Größe gleich sind, können Sie die Variable array2d als echtes zweidimensionales Array behandeln. Außerdem können Sie die speziellen Methoden zum Behandeln von Zeilen oder Spalten verwenden, je nachdem, wie Sie sie anzeigen Beachten Sie, dass im Standard-Array dieses Standard-Array unterstützt wird.
Sie können auch die Lösung von Kevin Loney verwenden:
Wenn Sie jedoch ein Standardarray verwenden, muss der Code anders aussehen:
Und haben immer noch die einzigartigen Funktionen des Standard-Arrays.
Beachten Sie, dass Sie weiterhin über die
[]
Klammern auf die Elemente des Standardarrays zugreifen können und dieat
Funktion nicht aufrufen müssen. Sie können auch eine neue int-Variable definieren und zuweisen, die die Gesamtzahl der Elemente im std-Array berechnet und beibehält und deren Wert verwendet, anstatt ihn zu wiederholensizeX*sizeY
Sie können Ihre eigene generische Klasse für zweidimensionale Arrays definieren und den Konstruktor der zweidimensionalen Array-Klasse so definieren, dass zwei Ganzzahlen empfangen werden, um die Anzahl der Zeilen und Spalten im neuen zweidimensionalen Array anzugeben, und die Funktion get abrufen, die zwei Parameter für Ganzzahlen empfängt die auf ein Element im zweidimensionalen Array zugreifen und dessen Wert zurückgeben und eine Funktion festlegen, die drei Parameter empfängt, wobei die beiden ersten Ganzzahlen sind, die die Zeile und Spalte im zweidimensionalen Array angeben, und der dritte Parameter der neue Wert des Element. Der Typ hängt von dem Typ ab, den Sie in der generischen Klasse ausgewählt haben.
Sie können all dies implementieren, indem Sie entweder das normale c ++ - Array (Zeiger oder ohne) oder das std-Array verwenden und eine der Ideen verwenden, die andere vorgeschlagen haben, und die Verwendung wie das cli-Array oder wie die beiden vereinfachen Dimensionsarray, das Sie in C # definieren, zuweisen und verwenden können.
quelle
Definieren Sie das Array zunächst mit Zeigern (Zeile 1):
quelle
Das folgende Beispiel kann helfen,
quelle
Wenn Sie ein 2d-Array von Ganzzahlen möchten, deren Elemente nacheinander im Speicher zugewiesen werden, müssen Sie es wie folgt deklarieren
Dabei können Sie anstelle von x eine beliebige Dimension schreiben, aber n muss an zwei Stellen gleich sein. Beispiel
muss drucken 6.
quelle
Ich habe Ihnen eine Lösung hinterlassen, die in bestimmten Fällen für mich am besten funktioniert. Besonders wenn man [die Größe von?] Eine Dimension des Arrays kennt. Sehr nützlich für ein Array von Zeichen, zum Beispiel, wenn wir ein Array mit unterschiedlicher Größe von Zeichenfeldern benötigen [20].
Der Schlüssel sind die Klammern in der Array-Deklaration.
quelle
Ich habe dieses nicht elegante, aber SCHNELLE, EINFACHE und ARBEITSSYSTEM verwendet. Ich verstehe nicht, warum dies nicht funktionieren kann, da das System nur dann ein großes Array erstellen und auf Teile zugreifen kann, wenn es nicht in Teile geschnitten wird:
quelle
Ich weiß nicht genau, ob die folgende Antwort nicht gegeben wurde, aber ich habe beschlossen, der Zuweisung von 2D-Arrays einige lokale Optimierungen hinzuzufügen (z. B. wird eine quadratische Matrix nur durch eine Zuordnung erstellt):
int** mat = new int*[n]; mat[0] = new int [n * n];
Das Löschen erfolgt jedoch aufgrund der Linearität der obigen Zuordnung folgendermaßen:
delete [] mat[0]; delete [] mat;
quelle
Dynamisches Deklarieren von 2D-Arrays:
Im obigen Code haben wir nun einen Doppelzeiger genommen, ihm einen dynamischen Speicher zugewiesen und einen Wert für die Spalten angegeben. Hier ist der zugewiesene Speicher nur für die Spalten, jetzt für die Zeilen benötigen wir nur eine for-Schleife und weisen dem Wert für jede Zeile einen dynamischen Speicher zu. Jetzt können wir den Zeiger genauso verwenden, wie wir ein 2D-Array verwenden. Im obigen Beispiel haben wir dann unserem 2D-Array (Zeiger) Zufallszahlen zugewiesen. Es dreht sich alles um DMA des 2D-Arrays.
quelle
Ich verwende dies beim Erstellen eines dynamischen Arrays. Wenn Sie eine Klasse oder eine Struktur haben. Und das funktioniert. Beispiel:
quelle