2-dimensionale dynamische Arrays

sheddy

Hi! Vielleicht könnt ihr mir das ja mal erklären!

Ich kenne mich eigentlich mit Zeigern aus und weiß sie auch anzuwenden!

Aber jetzt bin ich ein wenig verwirrt und erhoffe mir hier vielleicht eine gescheite Erklärung, dass auch ich es verstehe

Also es geht wie gesagt um 2-dimensionale dynamische Arrays.
Die legt man ja wie folgt an:

(Kurz-Listing)

int main(void) {
   /* Matrix ist Zeiger auf int-Zeiger */  
   int ** matrix; 

   /* Speicher reservieren für die int-Zeiger (=zeile) */
   matrix = (int **)malloc(10 * sizeof(int *));

   /* Jetzt noch Speicher reservieren für die einzelnen Spalten */    
   for(i = 0; i < zeile; i++) {
      matrix[i] = (int *)malloc(10 * sizeof(int));}

Nun mein Problem:
**matrix ist ja ein Zeiger aus einen Zeiger!

Mein problem liegt hier: matrix = (int **)malloc(10 * sizeof(int ));
Eiegntlich darf ich doch nicht völlig dereferenzieren, also beide '' vor matrix wegnehmen,oder?!
Ich möchte ja noch gar nicht auf den Inhalt zugreifen, auf den der Zeiger vom Zeiger matrix zeigt!

ich müsste doch die erste Ebene nehmen,oder?
Also (*matrix)=(int**)malloc... oder?!

Und dann erst beide '*' wegnehmen um die Spalten zu erzeugen!
Kann mir das jemand mal erläutern, warum es nicht so ist?
Gruß sdy

Du willst ein zweidimensionales Array dessen Dimensionen zur Compilezeit bekannt sind, dynamisch erzeugen.

#include <stdlib.h>
int main()
{
    #define ZEILEN 10
    #define SPALTEN 10

    int test;

    int (*matrix)[SPALTEN]; // Zeiger auf dein int matrix[ZEILEN][SPALTEN] Array!
    matrix = /*(int (*)[SPALTEN])*/ malloc (ZEILEN*SPALTEN*sizeof(int)); // In C castet man void* nicht!
    // und los gehts
    matrix[4][5] = 4711;
    test = matrix[4][5]; 
    //test == 4711;
    free(matrix);
}

mfg

Hallo sheddy,

Irgendwie liegt hier ein Missverständnis vor.
(Pointerarithmetik ist nich immer ganz leicht zu verstehen.)

Ich versuch das mal zu Erläutern!

ich müsste doch die erste Ebene nehmen,oder?
Also (*matrix)=(int**)malloc... oder?!

Achtung! Zu diesem Zeitpunkt referenziert *matrix noch garnichts!
Denn *matrix entspricht matrix[0] und diese Ebene existiert noch nicht.
Desshalb muss matrix, erst einen Speicherbereich (die erste Ebene) referenzieren, damit man auf matrix[0] oder *matrix zugreifen kann!

Der Ablauf bei mehrdimansionalen Arrays kann wiefolgt aussehen:
1. "matrix = ..." Der 1. Ebene wird Speicher zugewiesen, somit referenziert matrix auf diesen Bereich.

2. "*(matrix+i) oder matrix[i] = ..." Der 2. Dimension wird speicher zugewiesen.
Dann dritte Dimension und so weiter (mann könnte das noch weiter treiben! :))

Gruss

Leroy42

sheddy schrieb:

Mein problem liegt hier: matrix = (int **)malloc(10 * sizeof(int ));
Eiegntlich darf ich doch nicht völlig dereferenzieren, also beide '' vor matrix wegnehmen,oder?!
Ich möchte ja noch gar nicht auf den Inhalt zugreifen, auf den der Zeiger vom Zeiger matrix zeigt!

Ich glaube das Fettgedruckte ist dein Verständnisproblem.

In

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

wird nichts dereferenziert. Es wird nur der von malloc
gelieferte Wert (Adresse) auf den Typ (int **) gecastet damit
er zuweisungskompatibel zum Typ von matrix ist.

sheddy

Ich habe es verstanden!

Vielen Dank!

Gruß

Leroy42 schrieb:

In
matrix = (int **)malloc(10 * sizeof(int *));
wird nichts dereferenziert. Es wird nur der von malloc
gelieferte Wert (Adresse) auf den Typ (int **) gecastet damit
er zuweisungskompatibel zum Typ von matrix ist.

Da muss gar nix gecastet werden. Malloc muss in C nicht gecastet werden. Punkt.

Leroy42

Tim schrieb:

Da muss gar nix gecastet werden. Malloc muss in C nicht gecastet werden. Punkt.

Hast natürlich Recht1 Es ging mir nur darum, es sheddy zu erklären.

Obwohl ich auch schon in C sauber gecastet habe.