array aus arrays??

[Michael (Gast)]

Hallo!

Ich habe ein Problem mit arrays.
Ich würde gerne einen array aus arrays anlegen.
Ich möchte also nicht unsigned char test[][] haben,
sondern eher sowas wie unsigned char* test[]. Dabei soll
das zweite ein array sein der Pointer auf char arrays enthält.
Mein compiler macht das aber nicht mit. Sicher ein
Anfänger fehler. Kann mir jemand helfen?

Michael

[Andreas Horneff (Gast)]

Also ob das mit Arrays geht weiß ich nicht, hab ich noch nie gesehen,
muss ich sagen. Einzige, was mir einfallen würde, wäre, das ganze mit
Vectoren zu machen!?!
So hab ich das zumindest mal in Java gelöst.

Vielleicht hilfts dir weiter.

[Karl H. (kbuchegg)]

Ich geh mal davon aus, dass du das Ganze dynamisch
zur Laufzeit zusammenbauen moechtest.

Am besten ist mal, wenn Du Dir die Struktur, die
da entstehen soll aufzeichnest (jawohl!)

Du moechtest zb. so was erzeugen:

   test
   +-------+
   |  o    |
   +--|----+
      |
      |
      v
   +-----+
   |     |             +----+----+----+----+----+
   |  o--------------->|    |    |    |    |    |
   |     |             +----+----+----+----+----+
   +-----+
   |     |          +----+----+----+----+----+
   |  o------------>|    |    |    |    |    |
   |     |          +----+----+----+----+----+
   +-----+
   |     |              +----+----+----+----+----+
   |  o---------------->|    |    |    |    |    |
   |     |              +----+----+----+----+----+
   +-----+

Also eine Struktur, die aus 3 Zeilen und 5 Spalten besteht,
wobei alles voll dynamisch zur Laufzeit erzeugt wird.

Also fangen wir an.

Welchen Datentype muss test haben?
Test zeigt auf ein Array (ist also selbst ein Pointer) und
in dem Array muessen selbst wieder Pointer gespeichert werden.

Wie wuerde ein Pointer auf ein Array aussehen, wenn da int
gespeichert werden sollten:

    int * Test;

Nun wollen wir da aber keine int Speichern sondern char*.
Also ersetzen wir int duech char* und erhalten:

  char** test;

Soweit so gut. Jetzt, da wir test haben, koennen wir mal
das Array links aufbauen. Das muss sein: Ein Array von
char*, in dem 3 char* gespeichert werden koennen.

Also:

  test = malloc( 3 * sizeof( char* ) );

Danach muessen wir in einer Schleife fuer jede Zeile einen
Pointer installieren, der auf die eigentlichen Daten zeigt.
Die eigentlichen Daten sind aber jeweils ein Array der Laenge
5 vom Datentyp char:

  for( i = 0; i < 3; ++i )
    test[i] = malloc( 5 * sizeof( char ) );

Das wars. Damit ist die Datenstruktur komplett aufgebaut.
Was ist mit Loeschen?
Nun die Freigabe erfolgt in umgekehrter Reihenfolge zum Aufbau.
Also:

   for( i = 0; i < 3; ++i )
     free( test[i] );
   free( test );

Und fertig.

Um auf das Element 1;4 zuzugreifen, kannst Du ganz normale
Syntax verwenden (da ja ein Zusammenhang zwischen Pointer
und Arrays auf Syntaxebene besteht):

     c = test[1][4];

     test[0][3] = 's';

[Dirk (Gast)]

Hallo,

ein Lob an Ihre Anworten Herr Buchegger. Sehr verstaendlich und die
Grafik rundet alles noch ab!

Gruß,
Dirk

[Michael (Gast)]

Hallo!

Vielen Dank für die gute Antwort!
Ich hab das so  probiert und es hat geklappt.
Kann mich dem vorherigen Posting nur anschließen.
Suuuper verständlich :-)

Michael