String einlesen und in Array speichern

CrazyOwl

Hallo

Es geht darum einen String zeilenweise einzulesen und den String jeweils als einen Eintrag in einem Array zu speichern.

Mit einem statischen Array wäre das etwa so möglich:

char[10][20] sString;

sString[0] = "Eins";
sString[1] = "Zwei";
sString[2] = "Drei";
sString[3] = "Vier";

Nun ist es die Aufgabe dazu ein dynamisches Array zu verwenden in der Form:

char **text;

Meine Frage ist nun wie ich den Speicherplatz für das Array reservieren kann, da ja bei der Eingabe der ersten Zeile noch nicht bekannt ist, ob danach noch eine Zeile kommt, usw...
Und wie ich das Array dann verwenden kann wenn ich an einer Stelle einen neuen String einfügen möchte.

Dabei gehts jetzt gar nicht mal primär so um die programmiertechnische Lösung sondern eher um theoretische Fragen, wieviel und wann ich Speicher reservieren muss und wie ich mit dem Array dann arbeiten kann.

Falls jemand Ideen hat, bitte schreiben.

Danke

feigling

Erst mit malloc x Strings reservieren, vielleicht 2 und den wert in "size" speichern. Wenn du dann Strings addest, eine Variable hochzählen, die "count" heißt. Vor dem hochzählen prüfen, ob "count" == "size" ist und wenn ja, realloc benutzen, um das Array zu vergrößern, damit der neue String reinpasst.

supertux

Stichwort: man: malloc(3)

also, hier ein kleines Bsp: Ich will ein Array haben mit 4 Strings, die ich vom stdin einlesen soll

#include <stdlib.h>
#include <string.h>
#define MAX_LINES 4

void cleanup(void** ptr, size_t len)
{
    int i;
    for(i=0; i<len; ++i)
        free(ptr[i]);

    free(ptr);
}

void foo()
{
    char **text, line[1024];
    size_t i, line_len;

    text = malloc(sizeof(char*) * MAX_LINES);

    if(!test) do_fehler_behandlung();

    for(i=0; i<MAX_LINES; ++i)
    {
        fgets(line, 1024, stdin);
        line_len = strlen(line);

        text[i] = malloc(line_len + 1);

        if(!text[i])
        {
            cleanup(test, i);
            do_fehler_behandlung();
        }

        strncpy(test[i], line, line_len);
        text[i][line_len] = 0;
    }

    /* ok, text ist ein Array von strings */

    cleanup(text, MAX_LINES); /* Speicher freigeben */
}

CrazyOwl

supertux: Danke aber die Anzahl der maximalen Zeilen ist leider erst nachher durch Abbrechen der Eingabe bekannt.

feigling: realloc ist wohl das Zauberwort

Vielen Dank euch beiden, sollte jetzt klappen

supertux

CrazyOwl schrieb:

supertux: Danke aber die Anzahl der maximalen Zeilen ist leider erst nachher durch Abbrechen der Eingabe bekannt.

feigling: realloc ist wohl das Zauberwort

Vielen Dank euch beiden, sollte jetzt klappen

das ist ja kein Problem, dann musst du es nur so ändern:

#include <stdlib.h>
#include <string.h>

void cleanup(void** ptr, size_t len)
{
    int i;
    for(i=0; i<len; ++i)
        free(ptr[i]);

    free(ptr);
}

void foo()
{
    char **text, **tmp, line[1024];
    size_t i, line_len;

    if(!test) do_fehler_behandlung();

    i=0;

    while(irgendwas)
    {        
        fgets(line, 1024, stdin);
        line_len = strlen(line);

        if(!i)
        {
              text = malloc(sizeof(char*));
              if(!text) do_fehler_behandlung();
        } else {
              tmp = realloc(text, sizeof(char*)*(i+1));

              if(!tmp)
              {
                  cleanup(text, i-1);
                  do_fehler_behandlung();
              }

              if(tmp != text)
                  text = tmp;
        }

        text[i] = malloc(line_len + 1);

        if(!text[i])
        {
            cleanup(test, i-i);
            do_fehler_behandlung();
        }

        strncpy(test[i], line, line_len);
        text[i][line_len] = 0;

        ++i;
    }

    /* ok, text ist ein Array von strings */

    cleanup(text, i-1); /* Speicher freigeben */
}

CrazyOwl

Das sieht schon mal sehr nett aus, muss ich auch gleich ausprobieren.
Super danke.

supertux

der code ist on the fly entstanden, es kann sein, dass ich an manchen Stellen zu wenig freigebe. Das musst du selber herausfinden.

CrazyOwl

Kein Problem, danke für die Umstände.