Wie lese ich einen vom Benutzer eingegebenen Zeichenfolge in C?

Möchte ich Lesen den Namen eingegeben von meinem user, der sich mit C-Programmen.

Dazu schrieb ich:

char name[20];

printf("Enter name: ");
gets(name);

Aber mit gets ist nicht gut, so was ist eine bessere Möglichkeit?

InformationsquelleAutor Peeyush | 2010-10-26
  1. 79

    Sollten Sie nie Verwendung gets (oder scanf mit einem offenen string-Größe) da öffnet Sie bis zu buffer overflows. Verwenden Sie die fgets mit einem stdin handhaben, da es ermöglicht es Ihnen, die Daten beschränken, die in den Puffer.

    Hier ist eine kleine Schnipsel, die ich für line-Eingang vom Benutzer:

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

#define OK       0
#define NO_INPUT 1
#define TOO_LONG 2
static int getLine (char *prmpt, char *buff, size_t sz) {
    int ch, extra;

    //Get line with buffer overrun protection.
    if (prmpt != NULL) {
        printf ("%s", prmpt);
        fflush (stdout);
    }
    if (fgets (buff, sz, stdin) == NULL)
        return NO_INPUT;

    //If it was too long, there'll be no newline. In that case, we flush
    //to end of line so that excess doesn't affect the next call.
    if (buff[strlen(buff)-1] != '\n') {
        extra = 0;
        while (((ch = getchar()) != '\n') && (ch != EOF))
            extra = 1;
        return (extra == 1) ? TOO_LONG : OK;
    }

    //Otherwise remove newline and give string back to caller.
    buff[strlen(buff)-1] = '\0';
    return OK;
}

    Dies ermöglicht es mir, die maximale Größe festzulegen, wird erkennen, ob zu viele Daten eingegeben werden, auf die line, und Spülen Sie den rest der Zeile als gut, so dass es nicht auf die nächste Eingabe.

    Testen kann man es mit etwas wie:

    //Test program for getLine().

int main (void) {
    int rc;
    char buff[10];

    rc = getLine ("Enter string> ", buff, sizeof(buff));
    if (rc == NO_INPUT) {
        //Extra NL since my system doesn't output that on EOF.
        printf ("\nNo input\n");
        return 1;
    }

    if (rc == TOO_LONG) {
        printf ("Input too long [%s]\n", buff);
        return 1;
    }

    printf ("OK [%s]\n", buff);

    return 0;
}
    • nicht die system-Bibliotheken, die zur Umsetzung von scanf überlauf zu verhindern der Befehl ( ich verstehe, dass in dem Programm, wenn die Entwickler nicht überprüfen Sie die Eingabe, es könnte ein überlauf, aber die system-Bibliothek ist sicher richtig?).
    • Nein, wenn Sie scanf("%s") in ein 20-byte-Puffer, und der Benutzer gibt einen 40-byte-Zeile, du bist abgespritzt. Der springende Punkt bei der scanf scan-formatiert, und es ist wenig mehr unformatiert als user input 🙂
    • Denken Sie an es auf diese Weise unter Berücksichtigung der folgenden Frage: wie kann die Umsetzung verhindern, dass ein überlauf, wenn alle es wird ein Zeiger auf ein Stück Speicher (typecasted als char *) without any parameter that tells the implementation about the size of the destination buffer?
    • +1 zu paxdiablo für die Aufklärung das problem mit scanf und gets
    • Guten call auf die Funktion fgets, ich nur sprang auf meinen schlechten alten C Tagen mit meinem scanf Vorschlag. Ich predige mit strn Funktionen, durch die buffer-overflow-Problem, sollte gefangen haben, mich mit der scanf-overflow-Problemen. +1 für Ihre Lösung, und +1 zu deinem Kommentar mit den 20 byte/40-byte-Puffer-Beispiel!
    • die Konsole ist nicht immer schlechter, kann es sinnvoll sein, für eine begrenzte Dinge wie numerische Eingabe (und Hausaufgaben) und so. Aber selbst dann ist es nicht so robust, wie es sein sollte für eine Produktion-Qualität-Anwendung. Auch wenn ich mich benötigen, um eine Analyse der Eingabe mit einem scanf-wie operation, ich werde fgets es in einen Puffer, dann sscanf es von dort.
    • thnka u alle ....:)

    InformationsquelleAutor paxdiablo
  2. 17

    Ich denke, die beste und sicherste Weg, um zu Lesen Saiten durch den Benutzer eingegeben wird, mit getline()

    Hier ist ein Beispiel, wie dies zu tun:

    #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
    char *buffer = NULL;
    int read;
    unsigned int len;
    read = getline(&buffer, &len, stdin);
    if (-1 != read)
        puts(buffer);
    else
        printf("No line read...\n");

    printf("Size read: %d\n Len: %d\n", read, len);
    free(buffer);
    return 0;
}
    • Lesen = getline(&Puffer, &len, stdin); gibt GCC Warnungen zB:gcc-Wall -c "getlineEx2.c" getlineEx2.c: In function main : getlineEx2.c:32:5: warning: passing argument 2 of getline von inkompatiblen Zeigertyp [standardmäßig aktiviert] Lesen = getline(&Puffer, &len, stdin); ^ In-Datei aus /usr/include/stdio.h:29:0, getlineEx2.c:24: /usr/include/sys/stdio.h:37:9: Anmerkung: expected size_t * aber das argument vom Typ unsigned int * ssize_t _EXFUN(getline, (char **, size_t *, FILE *)); ^ Kompilierung erfolgreich beendet.
    • Nur die Aktualisierung, die getline jetzt erfordert len zu size_t oder unsigned long
    • Nachteil: POSIX-aber nicht in ANSI-C.
    InformationsquelleAutor joaopauloribeiro
  3. 6

    Auf einem POSIX-system, sollten Sie wahrscheinlich verwenden getline, wenn es verfügbar ist.

    Können Sie auch verwenden, Chuck Falkner public-domain ggets Funktion, die syntax näher zu gets aber ohne Probleme. (Chuck Falconer ' s website ist nicht mehr verfügbar, obwohl archive.org eine Kopie hat, und ich habe meine eigene Seite für ggets.)

    • Mit der Einschränkung, dass es nicht wie erwartet funktioniert mit Dateien, die am Ende nur in eine CR. Diese sind nicht so ungewöhnlich, wie Sie sich vorstellen können (er sagt, nach der Begegnung mit einem Ordner voll von Ihnen). Es ist eine verpasste Gelegenheit, dass Sie nicht zulassen getdelim/getline, um eine Liste von Trennzeichen statt einem int.
    • Es funktionieren würde, auf ein system, das CR als seine Muttersprache Zeilenende-format. Text-Modus-streams konvertieren, was auch immer die native Zeilenende-Typ \n.
    InformationsquelleAutor jamesdlin
  4. 3

    Fand ich eine einfache und schöne Lösung:

    char*string_acquire(char*s,int size,FILE*stream){
    int i;
    fgets(s,size,stream);
    i=strlen(s)-1;
    if(s[i]!='\n') while(getchar()!='\n');
    if(s[i]=='\n') s[i]='\0';
    return s;
}

    es basiert auf der Funktion fgets aber frei von '\n' und stdin zusätzliche Zeichen (ersetzen fflush(stdin), das funktioniert nicht auf allen OS, nützlich, wenn Sie haben, zu erwerben strings nach dieser).

    • Dies sollte die Verwendung fgetc statt getchar so, dass es mithilfe des mitgelieferten stream statt stdin.
    InformationsquelleAutor faber
  5. 1

    Auf BSD-Systemen und Android können Sie auch fgetln:

    #include <stdio.h>

char *
fgetln(FILE *stream, size_t *len);

    Etwa so:

    size_t line_len;
const char *line = fgetln(stdin, &line_len);

    Den line ist nicht null-terminiert und enthält \n (oder was auch immer Ihre Plattform nutzt) am Ende. Es wird ungültig nach dem nächsten I/O-operation auf dem stream. Sie sind berechtigt, ändern Sie den zurückgegebenen line Puffer.

    InformationsquelleAutor wonder.mice
  6. 0

    Können Sie verwenden scanf-Funktion zum Lesen string 

    scanf("%[^\n]",name);

    ich weiß nicht, über andere, bessere Möglichkeiten zu erhalten, string,

    • -1. Do nicht verwenden scanf; es ist berüchtigt schwer zu bedienen korrekt. Diese Verwendung ist besonders gefährlich, da es sich nicht beschränken-Eingang und kann leicht überlaufen der name Puffer.
    InformationsquelleAutor
Schreibe einen Kommentar