Wie zu Lesen Eingabe unbekannter Länge mit fgets

Wie soll ich Lesen, lange Eingabe mit fgets() ich nicht ganz kapiert.

Schrieb ich diese

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

int main()
{
    char buffer[10];
    char *input;
    while (fgets(buffer,10,stdin)){
        input = malloc(strlen(buffer)*sizeof(char));
        strcpy(input,buffer);
    }
    printf("%s [%d]",input, (int)strlen(input));
    free(input);
    return 0;
}

Blick auf realloc. Und überlegen Sie eine Strategie der Verdopplung der Zuweisung jeder Zeit, wie auch die Lektüre direkt in den Puffer. BTW: Die printf-format für size_t ist %zu.
Wenn Sie es haben, sollten Sie mithilfe von getline statt fgets.
ich weiß, über getline, aber ich habe die Verwendung der Funktion fgets
ich sah Sie, aber ich dont verstehen, von der es, wie fgets funktioniert, was passiert, wenn die Eingabe länger ist, dann buffer ich angeben, macht es für mich warten, um Speicher zuzuweisen und speichern Sie es?
Dein code hat ein klassischer off-by-one Fehler in der malloc(). Mit strlen(str) ist fast immer falsch; Sie sollte fast immer strlen(str)+1. Ihre Schleife Speicherverluste schrecklich, zu; Sie überschreiben den vorherigen Zeiger gespeichert in input bei jeder iteration.

InformationsquelleAutor lllook | 2014-12-06

c input string string-length

5
```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    char buffer[10];
    char *input = 0;
    size_t cur_len = 0;
    while (fgets(buffer, sizeof(buffer), stdin) != 0)
    {
        size_t buf_len = strlen(buffer);
        char *extra = realloc(input, buf_len + cur_len + 1);
        if (extra == 0)
            break;
        input = extra;
        strcpy(input + cur_len, buffer);
        cur_len += buf_len;
    }
    printf("%s [%d]", input, (int)strlen(input));
    free(input);
    return 0;
}
```
Dies ist über die minimale Anzahl der änderungen, geben Sie die vollständige Zeile der Eingabe. Dieser wächst der Speicherplatz um bis zu 9 bytes auf ein mal; das ist nicht der beste Weg, es zu tun, aber es gibt extra Buchhaltung beteiligt sind, tun es die besseren Möglichkeiten (Verdoppelung der Speicherplatz, und halten Sie eine Aufzeichnung von, wie viel reserviert ist vs wie viel verwendet wird). Beachten Sie, dass cur_len aufzeichnen die Länge der Zeichenfolge in den Raum, wies auf die von input ohne das terminal null. Beachten Sie auch, dass die Verwendung von extra vermeidet ein Speicherverlust auf Fehler bei der Zuordnung.

Den strcpy() Betrieb könnte legitimerweise ersetzt durch memmove(input + cur_len, buffer, buf_len + 1) (und in diesem Zusammenhang könnten Sie memcpy() statt memmove(), aber es funktioniert nicht immer, während memmove() bedeutet immer Arbeit, so ist es mehr zuverlässig zu bedienen memmove()).

Länge-Verdoppelung, — die cur_max variable Datensätze, wie viel Speicherplatz reserviert, und die cur_len zeichnet auf, wie viel Speicherplatz verwendet wird.
```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    char buffer[10];
    char *input = 0;
    size_t cur_len = 0;
    size_t cur_max = 0;
    while (fgets(buffer, sizeof(buffer), stdin) != 0)
    {
        size_t buf_len = strlen(buffer);
        if (cur_len + buf_len + 1 > cur_max)
        {
            size_t new_len = cur_max * 2 + 1;
            if (buf_len + 1 > new_len)
                new_len = buf_len + 1;
            char *extra = realloc(input, new_len);
            if (extra == 0)
                break;
            input = extra;
            cur_max = new_len;
        }
        strcpy(input + cur_len, buffer);
        cur_len += buf_len;
    }
    printf("%s [%d]", input, (int)strlen(input));
    free(input);
    return 0;
}
```
danke, also wenn wollte ich die Zeilen gelesen, die sind in der Regel sehr lange, ich muss mit realloc Größenänderung durch 2 mal mehr als bei seiner bisherigen Größe?
Nein; das einfachste ist die Verwendung char buffer[4096]; und mit dem Leben. Nur JSON kommt in Zeilen, die länger als das, und dann bekommt man zu Lesen die gesamte Datei in eine Zeile. (Ich übertreibe, aber nicht so viel, wie alle das.) Gelingt das nicht, die Idee ist, dass Sie zuweisen von 10 bytes der ersten Zeit, dann reservieren 20, dann Neuverteilung der 40 (aber Lesen Sie 2 Einheiten von 10 in den extra-Raum), dann 80, dann 160 dann 320... Wenn du nicht gehst, um kostenlos den Speicherplatz, bevor die Funktion beendet und es gibt mehr als, sagen wir, 64 Byte unbenutzt, Sie könnte verwenden realloc() zu verkleinern die Zuordnung auf die gewünschte Größe.
Es sei denn, du bist auf einen winzig kleinen Maschine, einer 4 Kb-Puffer ist nicht zu führen, dass Sie Trauer. Wenn Sie auf solch eine winzige Maschine, die Sie wahrscheinlich nicht verwenden malloc() an - oder Lesen-so lange Zeilen.
danke für die Antwort, was bedeutet, wenn (extra == 0) break; tut dies zu Ihrer änderung, ist 0 representiing 'NULL'?
NULL ist ein anderer name für 0 - mehr oder weniger. Es gibt Komplikationen, aber beide sind (oder werden kann) null-Zeiger-Konstanten. Sie können 0 in Orten, die Sie sollten nicht NULL; es gibt nirgendwo können Sie NULL, dass Sie nicht verwenden können, 0. In C, einige Systeme definieren, die NULL als ((void *)0) oder so ungefähr; das nicht-Fliegen-in C++ (aber den richtigen Wert für die NULL ist ein problem für den compiler, nicht der Programmierer mit NULL). Mit NULL können Sie, wo ich schrieb 0: char *input = NULL;, while (fgets(buffer, sizeof(buffer), stdin) != NULL), if (extra == NULL).

InformationsquelleAutor Jonathan Leffler

Ein besserer Ansatz ist die Verwendung einer input-Mechanismus, die Zuordnung, für Sie wie getline (oder sogar scanf). (Hinweis: scanf reserviert nicht in allen Compilern. In gcc/Linux, aber nicht mit Windows/Codeblocks/gcc)

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

int main()
{
    char *input;
    scanf ("%m[^\n]%*c", &input);
    printf("\n %s [%d]\n\n",input, (int)strlen(input));
    free(input);
    return 0;
}

Ausgabe:

$ ./bin/scanfinput
This is my longer string.

 This is my longer string. [25]

getline Beispiel

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char *input = NULL;     /* input buffer, NULL forces getline to allocate */
    size_t n = 0;           /* maximum characters to read (0 - no limit      */
    ssize_t nchr = 0;       /* number of characters actually read            */

    if ((nchr = getline (&input, &n, stdin)) != -1)
        input[--nchr] = 0;  /* strip newline */

    printf ("\n %s [%zd]\n\n", input, nchr);
    free(input);

    return 0;
}

danke, das gibt mir die warning -, unknown-format %m, im arbeiten mit c90
Wenn Sie unter Windows arbeiten, scanf wird nicht reserviert, wenn mit codeblocks usw.., Verwendung getline. Ich werde das update für Linux nur. Ich arbeitete mit gcc/C89 mit gnu-Erweiterungen.
ich bin kompilieren auf linux, in codeblocks
Loswerden von codeblocks :) ich habe andere berichten, dass scanf wird nicht reserviert, wenn mit codeblocks. Es muss eine Einschränkung sein.
Code::Blocks hat nichts zu tun mit dem kompilieren. Es ist nur die IDE

InformationsquelleAutor David C. Rankin

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.