2-dimension. Array dynamisch erzeugen

[Hans M. (fuxdancer)]

Hallo!

Ich hätte ein Frage zur dynamischen Allokation der Arraygröße in C.

Und zwar will ich einen eingelesenen String durch Trennzeichen trennen 
und Wort für Wort in ein weiteres dynamisch erzeugtes 2-dimensionales 
Array  kopieren.

Das erste Array, mit dem ich einlese, das erzeuge ich mit malloc und 
einer bestimmten Blockgröße, reallokiere es danach und nun will ich, 
dass mein zweites Array genau soviel Zeilen hat, wie der eingelesene 
String Wörter und genau soviele Spalten pro Zeilen, wie ein Wort 
Buchstaben besitzt.

Nun bin ich soweit, dass ich genauso viele Spalten erzeugen kann, wie 
ein Wort Buchstaben besitzt.
Mein Problem ist aber, ich muss die Größe des 2-dim. Arrays 
(Zeilenanzahl) am Anfang schon in der Main definieren mit einer fixen 
Größe, ich schaffe es nicht, diese auch dynamisch zu erzeugen.
Könnte mir jemand einen Ansatz oder altes Programm senden, in welchem 
man ein 2-dim. Array dynamisch allokiert?

Bsp: That is bad.
                          Spalte
Zeile        0          1          2        3      4     5
0            T          h          a        t     \0
1            i          s          \0
2            b          a          d       \0
3            NULL

[** (Gast)]

Hm...

char ** array;

array=malloc(42*sizeof(char*));

for(uint8_t i=0;i<42;i++)
  array[i]=malloc(Größe des Strings)

+ Fehlerbehandlung usw

[** (Gast)]

** schrieb:
>   array[i]=malloc(Größe des Strings)
also x*sizeof(char)

[Karl H. (kbuchegg)]

** schrieb:
> ** schrieb:
>>   array[i]=malloc(Größe des Strings)
> also x*sizeof(char)

(Mehr als Hinweis an den Fragesteller gedacht:)

Meistens (x+1)*szeof(char)
weil x meistens die Länge eines Strings ist, die mit strlen (oder einem 
Äquivalent dazu) bestimmt wird.

[** (Gast)]

Karl Heinz Buchegger schrieb:
> ** schrieb:
>> ** schrieb:
>>>   array[i]=malloc(Größe des Strings)
>> also x*sizeof(char)
>
> (Mehr als Hinweis an den Fragesteller gedacht:)
>
> Meistens (x+1)*szeof(char)
> weil x meistens die Länge eines Strings ist, die mit strlen (oder einem
> Äquivalent dazu) bestimmt wird.
Wo du Recht hast hast du Recht... :-)

[Hans M. (fuxdancer)]

Was ich noch wissen will ist, habe ich beispielsweise so ein 
zweidimensionales Array
char **string1;

brauche ich hier nur ein malloc für die Größe der Spalten und der Zeilen 
machen oder wie?

sagen wir mal, dass mein vorher eingelesener String
"That is bad"
aus 3 Wörtern besteht
und Wort 1 (That) aus 4 Buchstaben.

Wie müsste ich das mit malloc und realloc realisieren?

[** (Gast)]

Nicht schön aber selten... Fehlerbehandlung fehlt!

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include "memcheck.h"

int main(int argv, char *argc[])
{
  char **array;
  char string[]="This is very bad.";
  uint8_t i,j,k;
  uint8_t nbel=0;

  array=malloc(1*sizeof(char*));

  for(i=0;i<strlen(string);i++)
  {
    for(j=i;j<strlen(string)&&string[j]!=' ';j++);
    nbel++;
    array=realloc(array,nbel*sizeof(char*));
    array[nbel-1]=malloc((j-i+1)*sizeof(char));
    memcpy(array[nbel-1],string+i,j-i+1);
    array[nbel-1][j-i]='\0';
    _mc_check(NULL);
    i=j;
    j=0;
  }
  for(i=0;i<nbel;i++)
  {
    printf("%s\n",array[i]);
  }
  return 0;
}

Ich gebe zu ich musste debuggen, hatte das ='\0' vergessen...

[** (Gast)]

Ich bin definitiv nicht wach heute!

>_mc_check(NULL);
restlos streichen bitte (Debugfunktion).

[** (Gast)]

Jetzt rächt sich der Gastaccount. Noch ein Fehler:
memcpy(array[nbel-1],string+i,j-i);
                              ^^^^
SCHÄM

[Hans M. (fuxdancer)]

Danke für die schnellen Antworten. Ich werd mal versuchen, dass ich eure 
Denkanstöße in einen anständigen Code umsetze.

Gruß Hans

[Karl H. (kbuchegg)]

Hans M. schrieb:
> Was ich noch wissen will ist, habe ich beispielsweise so ein
> zweidimensionales Array
> char **string1;


Was du damit aufbaust ist streng genommen kein 2D-Array sondern etwas 
das wie ein 2D Array benutzt werden kann. Im Speicher sieht dein Aufbau 
zb so aus

   string1
   +-------+
   |   o   |
   +---|---+
       |
       v
   +-------+            +---+---+---+---+
   |   o--------------->|   |   |   |   |
   +-------+            +---+---+---+---+
   |   o----------+   +---+---+---+---+---+---+
   +-------+      +-->|   |   |   |   |   |   |
   |   o-------+      +---+---+---+---+---+---+
   +-------+   |
               |   +---+---+---+
               +-->|   |   |   |
                   +---+---+---+

string1 ist ein Zeiger auf ein 1D Array von Pointern (der Kasten links), 
wobei jeder Pointer wieder auf ein 1D Array von Charactern zeigt.

Da die beiden Arrays unterschiedlicher Natur sind, müssen sie auch 
getrennt allokiert werden.

Zuerst wird das 1D Pointer Array allokiert (mit einem malloc) ....

  string1
   +-------+
   |   o   |
   +---|---+
       |
       v
   +-------+
   |       |
   +-------+
   |       |
   +-------+
   |       |
   +-------+

und danach wird für jeden einzelnen Pointer ein malloc für das Character 
Array gemacht und der Pointer drauf eingerichtet

1. Pointer:

  string1
   +-------+
   |   o   |
   +---|---+
       |
       v
   +-------+            +---+---+---+---+
   |   o--------------->|   |   |   |   |
   +-------+            +---+---+---+---+
   |       |
   +-------+
   |       |
   +-------+

2. Pointer:

  string1
   +-------+
   |   o   |
   +---|---+
       |
       v
   +-------+            +---+---+---+---+
   |   o--------------->|   |   |   |   |
   +-------+            +---+---+---+---+
   |   o----------+   +---+---+---+---+---+---+
   +-------+      +-->|   |   |   |   |   |   |
   |       |          +---+---+---+---+---+---+
   +-------+

3. Pointer:

  string1
   +-------+
   |   o   |
   +---|---+
       |
       v
   +-------+            +---+---+---+---+
   |   o--------------->|   |   |   |   |
   +-------+            +---+---+---+---+
   |   o----------+   +---+---+---+---+---+---+
   +-------+      +-->|   |   |   |   |   |   |
   |   o-------+      +---+---+---+---+---+---+
   +-------+   |
               |   +---+---+---+
               +-->|   |   |   |
                   +---+---+---+

In diesem Beispiel sind also 4 mallocs beteiligt.

[Hans M. (fuxdancer)]

Danke, habs geschafft.

[Daniel F. (df311)]

Karl Heinz Buchegger schrieb:
> In diesem Beispiel sind also 4 mallocs beteiligt.

und nicht vergessen - allokierter speicher muss auch wieder freigegeben 
werden. 4 malloc -> 4 free

(o.k. wenn man es bei kleinen testprogrammen mal vergisst ist nicht soo 
schlimm, aber man sollte es sich gleich angewöhnen)