Zweidimensionale dynamische Arrays und ihre Zeiger (int *)

egens

Hallo Leute,

ich beschäftige mich gerade mit dem Thema Zweidimensional dynamische Arrays.
Ich habe da aber ein Verständnisproblem.

Wenn man z.B. n Zeilen und . Spalten haben möchte, wird als erstes der Speicher mit folgendem Code für die Zeile alloziert:

matrix = malloc(zeile * sizeof(int *));

Danach wird in einer Schleife der Speicher für die Spalten alloziert:

matrix[i] = malloc(spalte * sizeof(int));

Zweiters ist kann ich ja noch nachvollziehe.
Was aber hat es mit dem (int auf sich? Nun sind mir "normale" Zeiger jetzt nicht mehr fremd, aber das kann ich gerade nicht nachvollziehen.

Soweit ich jetzt erfahren konnte ist das wohl ein Zeiger der auf einen int zeigt.
Aber was genau heißt das? Was genau Zeigt auf int? Wie wird das gespeichert?
Ich habe versucht mir das irgendwie zusammenzureimen.
Berichtig mich wenn ich falsch liege.

Ich versuche mal bildlich dazustellen was ich mir überlegt habe.

matrix ---->int---->int---->int----> usw. ---->
             |       |       |  
             |       |       |
             |       |       |
            int     int     int

Soll heißen, matrix zeigt erst auf einen Speicherbereich der Größe von n int.
Anzusprechen mit

matrix[i]

Und jedes dieser int ist wiederum ein Zeiger, der dazu verwendet wird um im diesen Beispiel auf die Spalte zu zeigen.
Was ich mir ungefär so vorstellen würde.

int[i]

Was dann halt im Ergebnis

matrix[i][j]

bedeuten würde.

Aber wie funktioniert das? Wie müsste das im Speicher aussehen?
Wieder meine Überlegung

Zeile             Spalte 1          Spalte 2          Spalte 3          Spalte 4
+---+---+---+---+ +---+---+---+---+ +---+---+---+---+ +---+---+---+---+ +---+---+---+---+
|int|int|int|int| |int|int|int|int| |int|int|int|int| |int|int|int|int| |int|int|int|int|
+---+---+---+---+ +---+---+---+---+ +---+---+---+---+ +---+---+---+---+ +---+---+---+---+
  |   |   |   |_____^                 ^                 ^                 ^
  |   |   |___________________________|                 |                 |
  |   |_________________________________________________|                 |
  |_______________________________________________________________________|

Lange Reder kurzer Sinn: (int sorgt dafür, dass jedes int der Zeile ein Zeiger wird, dem, bei der Reservierung des Speichers für die Spalten, die jeweilige Adresse für diese zugewiesen wird.
Ich hoffe, dass ich meine Überlegungen verständlich rübergebracht habe und dass ihr mir da evtl. auf Sprünge helfen könnt.

Danke schon einmal im voraus.

dot

egens schrieb:

Lange Reder kurzer Sinn: (int sorgt dafür, dass jedes int der Zeile ein Zeiger wird, dem, bei der Reservierung des Speichers für die Spalten, die jeweilige Adresse für diese zugewiesen wird.

Exakt. Es sei aber gesagt dass es effizienter ist wenn du einfach ein normales int Array mit Zeilen * Spalten Elementen anlegst und deine 2D Indices dann in dieses umrechnest.

egens

Danke schon einmal für dein Antwort.
Wie meinst du das genau?
So ??

int matrix[][]

und dann?

Ich muss dazu sagen, ich beschäftige mich erst seit kurzem mit C und bin halt gerade beim Thema dynamische Speicherreservierung angekommen.

Nicht ganz.
Der erste Index ist kein int sondern ein int*.

Soll heißen, matrix zeigt erst auf einen Speicherbereich der Größe von n int*.
matrix[i]
Und jedes dieser int* ist wiederum ein Zeiger, der dazu verwendet wird um im diesen Beispiel auf die Spalte zu zeigen.
Was ich mir ungefär so vorstellen würde.
int[i]

Zeile             Spalte 1          Spalte 2          Spalte 3          Spalte 4
+----+----+----+----+ +---+---+---+---+ +---+---+---+---+ +---+---+---+---+ +---+---+---+---+
|int*|int*|int*|int*| |int|int|int|int| |int|int|int|int| |int|int|int|int| |int|int|int|int|
+----+----+----+----+ +---+---+---+---+ +---+---+---+---+ +---+---+---+---+ +---+---+---+---+
  |___|___|___|_________^                 ^                 ^                 ^
      |___|___|___________________________|                 |                 |
          |___|_____________________________________________|                 |
              |_______________________________________________________________|

Du darfst das ganze aber nicht mit einem statischen 2D-Array verwechseln.
int matrix[4][5]; wird genauso angesprochen, matrix ist da aber nur ein einfacher Zeiger auf ein Bereich von int (also ein int*)

egens

Danke Dirk...

So hatte ich das eigentlich auch meint, aber du hast recht, man darf wohl bei der Programmierung die kleine aber feinen Unteschiede nicht einfach auser Acht lassen.
Gerade da int* etwas anderes ist als int.

Ich habe ebenso für die gute Erklärung zu danken.
Hatte neulich das gleiche Problem.

Man hat gemerkt das du das Richtige gemeint hast.
(Dieser Satz ist irgendwie aus meinem ersten Post rausgeflogen )

scimansix

dot schrieb:

Es sei aber gesagt dass es effizienter ist wenn du einfach ein normales int Array mit Zeilen * Spalten Elementen anlegst und deine 2D Indices dann in dieses umrechnest.

Das kommt ganz darauf an, was man damit machen möchte. Wenn man zum Beispiel oft Zeilen tauscht, ist es effizienter, Speicher für die Zeilen einzeln zu reservieren, weil dann beim Zeilentausch nur noch zwei Pointer neu gesetzt werden müssen.