Ein Zeiger auf ein mehrdimensionales Feld

[Martin (Gast)]

Hi Leute!

Ich bin gerade dabei, mich in die Welt der Zeiger einzuarbeiten.
Wie man z.B. die Adresse eines Feldes, einer Struktur oder einer 
Varibale einem Zeiger zuweisen kann, hab ich, glaub ich, ganz gut 
verstanden ;-)

Dann ist mir eingefallen, was tut man, wenn man ein mehrdimensionales 
Feld hat und darauf einen Zeiger richten möchte? Wie kriegt man das mit 
den verschiedenen Indexen hin?
Ich weiß, dass ein mehrdimensionales Feld an sich eh schon einen Zeiger 
darstellt, aber mir lässt diese Frage zur Zeit keine Ruhe.

Z.B.
uint8_t matrix[3][4][8][10];

uint8_t *matrix_z;

Ich möchte gerne den Zeiger matrix_z auf das mehrdimensionale Feld
matrix zeigen lassen. Dies habe ich folgendermaßen realisiert.

matrix_z=(uint8_t *) matrix;


Wenn ich auf das Feld matrix zugreife, um ein Element zu lesen, dann 
schaffe ich das folgendermaßen: z.B. x=matrix[0][2][4][3];

Wenn ich matrix_z verwenden möchte, dann kann ich dies nur mit einem 
Index tun: z.B. x=matrix_z[10];


Wie kann ich dem Zeiger matrix_z mehrere Indexe beibringen, sodass ich
ihn genauso ansprechen kann wie matrix?
Es würde mich sehr freuen, wenn ihr mir kompetent zur Seite stehen 
könntet.
Vielen Dank im Voraus.

LG

Martin

[Klaus W. (mfgkw)]

Mit einem Zeiger vom Typ uint8_t* kannst du in der Tat
nur noch mit einem Index auf die Elemente zugreifen.
Die restliche Arithmetik musst du dir dann manuell
bauen (zur Übersicht mit etwas weniger Elementen):

// Feld mit 4 Dimensionen 2 * 3 * 4 * 5
uint8_t matrix[2][3][4][5] =
     {
        {
           {
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
           },
           {
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
           },
           {
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
           },
        },
        {
           {
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
           },
           {
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
           },
           {
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
           },
        },
     };

uint8_t *matrix_z = &matrix[0][0][0][0]; // Zeiger auf erstes Element


// Zugriff auf matrix[i][j][k][l]:
uint8_t i = 1, j = 2, k = 3, l = 4;
uint8_t tmp;

tmp = matrix[i][j][k][l];
tmp = matrix_z[3*4*5*i + 4*5*j + 5*k + l];
tmp = matrix_z[((i*3 + j)*4 + k)*5 + l];

Ein ganz anderer Ansatz wäre, Zwischenfelder zu bauen mit
Zeigern auf das jeweils nächste Zwischenfeld:

uint8_t matrix[2][3][4][5] =
     {
        {
           {
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
           },
           {
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
           },
           {
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
           },
        },
        {
           {
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
           },
           {
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
           },
           {
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
              {
                 1, 1, 1, 1, 1
              },
           },
        },
     };

uint8_t *matrix_m00[4] = { &matrix[0][0][0][0], &matrix[0][0][1][0], &matrix[0][0][2][0], &matrix[0][0][3][0] };
uint8_t *matrix_m01[4] = { &matrix[0][1][0][0], &matrix[0][1][1][0], &matrix[0][1][2][0], &matrix[0][1][3][0] };
uint8_t *matrix_m02[4] = { &matrix[0][2][0][0], &matrix[0][2][1][0], &matrix[0][2][2][0], &matrix[0][2][3][0] };
uint8_t *matrix_m10[4] = { &matrix[1][0][0][0], &matrix[1][0][1][0], &matrix[1][0][2][0], &matrix[1][0][3][0] };
uint8_t *matrix_m11[4] = { &matrix[1][1][0][0], &matrix[1][1][1][0], &matrix[1][1][2][0], &matrix[1][1][3][0] };
uint8_t *matrix_m12[4] = { &matrix[1][2][0][0], &matrix[1][2][1][0], &matrix[1][2][2][0], &matrix[1][2][3][0] };

uint8_t **matrix_l0[3] = { &matrix_m00[0], &matrix_m01[0], &matrix_m02[0] };
uint8_t **matrix_l1[3] = { &matrix_m10[0], &matrix_m11[0], &matrix_m12[0] };

uint8_t ***matrix_k[2] = { &matrix_l0[0], &matrix_l1[0] };

matrix_k hat also zwei Elemente, die jeweils auf den Anfang
einer 3*4*5-Matrix zeigen.

Diese 3*4*5-Matrizen haben je 3 Elemente, die jeweils auf den
Anfang einer 4*5-Matrix zeigen.

Diese 4*5-Matrizen haben je 4 Elemente, die jeweils auf den Anfang
eines 5-Vektors (5 Elemente uint8_t) zeigen.

Diese Vektoren wiederum sind Teile der ursprünglichen matrix[][][][].

Jetzt kann man über matrix_k mit 4 Indices auf ein Element zugreifen:

uint8_t i = 1, j = 2, k = 3, l = 4;
uint8_t tmp;

tmp = matrix[i][j][k][l];
tmp = matrix_k[i][j][k][l];

Die beiden Anweisungen sehen jetzt verdächtig gleich aus,
sind aber zwei grundverschiedene Dinge:

matrix[i][j][k][l] ist ein Zugriff auf ein Element
eines 4-dimensionalen Feldes.

matrix_k[i][j][k][l] dagegen fasst mit matrix_k[i]
bzw. matrix_k[1] auf das Feld matrix_l1[0], darin mit
dem zweiten Index [j] ([2]) auf matrix_m12, darin
mit dem 3. Index [k] ([3]) auf den entsprechenden
Teilvektor in matrix[][][][].

Auch wenn die beiden eben noch gleich aussahen, merkt
man den Unterschied, wenn man eine Funktion aufruft.
Sowohl mit matrix als auch mit matrix_z (siehe oben)
sähe das so aus:

void f1( uint8_t *m )
{
  uint8_t tmp = m[((i*3 + j)*4 + k)*5 + l];
}
...
  f1( matrix );
  f1( matrix_z );

Ggf. müsste man der Funktion auch noch zumindest alle
außer der letzten Dimension mitgeben (hier die 3, 4 und 5
als Konstanten verwendet).
Die erste Dimension (2) muß in der Funktion nicht
zwingend bekannt sein, solange man sicher ist, nicht
über das Feld hinauszugreifen.
Sowohl bei dem Aufruf mit matrix bzw. matrix_z wird
in Wirklichkeit die Adresse von matrix[0][0][0][0]
übergeben.
In beiden Fällen muß manuell die Zeigerarithmetik für
alles über der ersten Dimension gemacht werden.

Dagegen die zweite Variante: mit dem Mehraufwand beim
Anlegen der Felder gewinnt man einen lässigen Zugriff
auf die Elemente auch in einer Funktion.

void f2( uint8_t ****m )
{
  uint8_t  tmp = m[i][j][k][l];
}
...
  f2( matrix_k );

Hier sieht man, daß matrix_k etwas ganz anderes ist
als matrix bzw. matrix_z.
Mit letzteren könnte man f2() nicht aufrufen.

[Klaus W. (mfgkw)]

Nachtrag 1:
Es gibt noch diese Variante für den Funktionsaufruf:

void f3( uint8_t m[][3][4][5] )
{
  uint8_t  tmp = m[i][j][k][l];
}

oder

void f3( uint8_t m[2][3][4][5] )
{
  uint8_t  tmp = m[i][j][k][l];
}

Eine solche Funktion kann mit matrix ebenso wie mit
matrix_z aufgerufen werden, aber nicht mit matrix_k
(also nicht mit den Zwischenfeldern).
Beim Aufruf mit matrix_z kommt ggf. eine Warnung des
Compilers, aber es funktioniert trotzdem.

Vorteil dieser Variante:
- der Compiler kann mir wieder die Arithmetik mit den
  mehreren Indices abnehmen

Nachteil:
- alle Dimensionen (ggf. außer der ersten) müssen
  konstant sein, mit anders dimensioonierten Feldern
  geht nichts.

Bei meiner Zwischenfeldvariante (f2()) können sowohl
die 4 Dimensionen unterschiedlich sein von Aufruf zu
Aufruf, ebenso wie die Teilfelder gar nicht einheitlich
lang sein müssen (z.B. für Dreiecksmatrizen) - trotzdem
beherrscht der Compiler die Indexberechnung für alle
Dimensionen.

[Klaus W. (mfgkw)]

Nachtrag 2 zu der Zwischenfeldversion (f2()):

- wie eben erwähnt muß die Matrix nicht komplett gefüllt sein,
  z.B. kann bei zweidimensionalen Matrizen jede Zeile eine
  andere Länge haben (sparsame Speicherung von Dreiecksmatrizen)

- im ursprünglichen Beispiel liegen die eigentlichen
  Feldelement der Matrix in einem durchgehenden Speicherbereich.
  Das ist eigentlich gar nicht nötig, z.B. könnten für
  eine 2-D-Matrix die Zeilen jeweils getrennt voneinander
  liegen. Dadurch kann der Speicher auch zeilenweise zur
  Laufzeit mit malloc() allokiert werden.

- Die Längen der einzelnen Dimensionen können sich bei
  Bedarf auch erst zur Laufzeit ergeben, sie müssen
  nicht dem Compiler als Konstanten bekannt sein.

[Yalu X. (yalu) (Moderator)]

Ein Zeiger, der gleich indiziert werden kann wie ein Array, ist ein
Zeiger auf das erste Array-Element. Bei einem eindimensionalen
uint8_t-Array ist der Zeiger also einfach ein Zeiger auf uint8_t:

uint8_t vektor[10];
uint8_t *vektor_z = vektor;

// Zugriff:
  uint8_t x;
  x = vektor[3];
  x = vektor_z[3];  // Kurzschreibweise für x = *(vektor_z + 3)

Mehrdimensionale Arrays gibt es in C eigentlich gar nicht. Statt einem
n-dimensionalen Array verwendet man in Wirklichkeit ein Array von
(n-1)-dimensionalen Unterarrays. Dewegen kann das oben für vektor
Geschriebene auch auf mehrdimensionale Arrays übertragen werden.

Die Definition

uint8_t matrix[8][10];

legt also ein Array mit 8 Elementen an, von denen jedes ein Array von 10
uint8_t-Werten ist.

Der Zugriff

x = matrix[4][3];

ermittelt also zuerst das Element von matrix mit dem Index 4. Dieses
Element ist ein uint8_t-Array, von dem schließlich das Element mit dem
Index 3 gelesen wird.

Wenn man das verstanden hat, ist es nicht mehr schwer, einen zum Array
matrix äquivalenten Zeiger zu definieren. Der Elementdatentyp von
matrix ist (uint8_t [10]), nämlich ein Array aus 10 uint8_t-Werten.
Also wird der Zeiger wie folgt definiert:

uint8_t (*matrix_z)[10] = matrix;

Die Klammern um *matrix sind wichtig, weil der []-Operator stärker als
der *-Operator bindet.

Damit ist matrix_z ein Zeiger auf das erste Element (Unterarray) von
matrix und *matrix_z das Unterarray selber. Statt *matrix_z kann man
schöner auch matrix_z[0] schreiben. Mit

  x = matrix_z[4][3]; // entspricht x = (*(matrix + 4))[3]

wird also aus dem Unterarray matrix[4] das uint8_t-Element mit dem Index
3 gelesen. Das ist genau das, was gewünscht ist.

Beim vierdimensionalen Array wird in entsprechender Weise ein Zeiger auf
ein dreidimensionales Array angelegt:

uint8_t array4[3][4][8][10];
uint8_t (*array4_z)[4][8][10] = array4;

// Zugriff:
  uint8_t x;
  x = array4[0][2][4][3];
  x = array4_z[0][2][4][3];

Das ist alles.


Klaus hat oben gezeigt, wie man ein mehrdimensionales Array als
Funktionsargument übergibt:

Klaus Wachtler schrieb:
> Es gibt noch diese Variante für den Funktionsaufruf:

void f3( uint8_t m[][3][4][5] )
{
  uint8_t  tmp = m[i][j][k][l];
}

Auch hier wird letztendlich ein Zeiger auf ein dreidimensionales Array
übergeben. Nur wird dort in der ausführlichen Schreibweise

void f3( uint8_t (*m)[3][4][5] )

das (*m) durch das äquivalente m[] ersetzt, was speziell bei der Dekla-
ration von Formalparametern zulässig ist und zum Ausdruck bringt, dass
m nicht irgendein Zeiger ist, sondern auf ein real im Speicher exis-
tierendes Array zeigen soll.

[Martin (Gast)]

Hi Leute!

Danke für eure tollen Erklärungen.
Klaus: Dein geniales Beispiel hat mir sehr anschaulich gezeigt, was man 
mit Zeigerfeldern alles machen kann. Dadurch habe ich wieder viel 
gelernt.
Yalu: Deine Erklärungen war sehr aufschlussreicht und haben meine Fragen 
restlos beantwortet. Dadurch sind mir einige Lichter aufgegangen.

Ich habe versucht, verschiedene Zugriffsmöglichkeiten zusammenzufassen, 
um sie hier bereitzustellen.

#include <utility.h>
#include<stdio.h>

typedef unsigned char uint8_t;
typedef signed char int8_t;
typedef unsigned short uint16_t;
typedef signed short int16_t;
typedef unsigned long uint32_t;
typedef signed long int32_t;


uint8_t matrix_feld[2][3][4][5]; // Originalfeld

uint8_t *matrix_z;               // Ein Zeiger, der auf ein Feld zeigt (Hat jedoch nur einen Index.).
uint8_t *matrix_zfeld1[2][3][4][5]; // Ein mehrdimensionales Zeigerfeld. Jedes Element ist ein Zeiger. Jeder Zeiger zeigt auf ein einzelnes Element eines Feldes.
uint8_t *matrix_zfeld2[2][3][4]; // Ein mehrdimensionales Zeigerfeld. Jedes Element ist ein Zeiger. Jeder Zeiger zeigt auf das erste Element eines Feldes. 
uint8_t (*matrix_zindex)[3][4][5]; // Ein Zeiger, der auf ein Feld zeigt. Der Zeiger erhält entsprechende Index-Infos, damit er weiß, wie das Feld aussieht.

uint8_t zc1,zc2,zc3,zc4;
const uint8_t zx1=2,zx2=3,zx3=4,zx4=5;
uint8_t wert;




void main(void)
{

// Zuweisung, Befüllung
for(zc1=0,wert=0;zc1<zx1;zc1++)
{
  for(zc2=0;zc2<zx2;zc2++)
  {
    for(zc3=0;zc3<zx3;zc3++)
    {
      matrix_zfeld2[zc1][zc2][zc3]=matrix_feld[zc1][zc2][zc3];   // zfeld2 wird mit Adressen befüllt.
      for(zc4=0;zc4<zx4;zc4++,wert++)
      {
        matrix_feld[zc1][zc2][zc3][zc4]=wert;           // Originalfeld (feld) wird mit Werten befüllt.
        matrix_zfeld1[zc1][zc2][zc3][zc4]=&matrix_feld[zc1][zc2][zc3][zc4]; // zfeld1 wird mit Adressen befüllt.
      }
    }
  }
}

matrix_z=(uint8_t *) matrix_feld;   // z erhält die Adresse des Originalfeldes.
matrix_zindex=matrix_feld;          // zindex erhält die Adresse des Originalfeldes.

// Ausgabe
for(zc1=0;zc1<zx1;zc1++)
{
  for(zc2=0;zc2<zx2;zc2++)
  {
    for(zc3=0;zc3<zx3;zc3++)
    {
      for(zc4=0;zc4<zx4;zc4++)
      {
        printf("%d:%d:%d:%d   %d - %d - %d - %d - %d - %d\r\n"
      ,zc1,zc2,zc3,zc4                                      // Index
      ,matrix_feld[zc1][zc2][zc3][zc4]                          // Originalfeld
    ,matrix_z[(zx2*zx3*zx4*zc1)+(zx3*zx4*zc2)+(zx4*zc3)+zc4]  // Zeiger, der auf ein Array zeigt.
    ,*matrix_zfeld1[zc1][zc2][zc3][zc4]                       // Feld von Zeigern. Ein Zeiger zeigt auf ein einzelnes Element.
        ,matrix_zfeld2[zc1][zc2][zc3][zc4]                        // Feld von Zeigern. Ein Zeiger zeigt jeweils auf das erste Element.
        ,matrix_zindex[zc1][zc2][zc3][zc4]                        // Zeiger, der auf ein definiertes Array zeigt.
    ,(*(matrix_zindex+zc1))[zc2][zc3][zc4]);                  // Zeiger, der auf ein definiertes Array zeigt. Zugriff auf eine andere Art.
      }
    }
  }
}

GetKey();
}

Falls etwas an meiner Zusammenfassung nicht stimmen sollte, bitte ich, 
Bescheid zu geben.


LG

Martin

[Klaus W. (mfgkw)]

Yalu X. schrieb:
> Klaus Wachtler schrieb:
>> Es gibt noch diese Variante für den Funktionsaufruf:void f3( uint8_t 
m[][3][4][5] )
> {
>   uint8_t  tmp = m[i][j][k][l];
> }
>
> Auch hier wird letztendlich ein Zeiger auf ein dreidimensionales Array
> übergeben. Nur wird dort in der ausführlichen Schreibweise
> void f3( uint8_t (*m)[3][4][5] )
>
> das (*m) durch das äquivalente m[] ersetzt, was speziell bei der Dekla-
> ration von Formalparametern zulässig ist und zum Ausdruck bringt, dass
> m nicht irgendein Zeiger ist, sondern auf ein real im Speicher exis-
> tierendes Array zeigen soll.

Ja.

Wobei sich uint8_t m[][3][4][5] und uint8_t (*m)[3][4][5]
in einem Punkt unterscheiden:
Im ersten Fall ist m konstant, in der zweiten eine Variable
(wenn man nicht noch ein const spendiert).
Beides kann sinnvoll sein.