Was ist der einfachste Weg, Benutzereingaben in C zu erhalten?

Es scheint viele Möglichkeiten zu geben, Benutzereingaben in C zu erhalten.

Was ist der einfachste Weg, der wenig Code erfordert?

Grundsätzlich muss ich dies anzeigen:

Enter a file name: apple.text

Grundsätzlich muss ich den Benutzer nach einem Dateinamen fragen. Ich brauche also etwas, das nur dieses eine Wort erhält, das der Benutzer eingeben wird.

Das einfachste “Korrekt” Weg ist wahrscheinlich dieser, entnommen aus Bjarne Stroustrups Aufsatz Lernstandard C++ als neue Sprache.

(Hinweis: Ich habe Bjarnes Code geändert, um nach isspace() statt nur Zeilenende. Auch aufgrund des Kommentars von @matejkramny zu verwenden while(1) Anstatt von while(true)… und solange wir ketzerisch genug sind, um Stroustrups Code zu bearbeiten, habe ich auch C89-Kommentare anstelle von C++-Kommentaren eingefügt. :-P)

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

void quit() /* write error message and quit */
{
    fprintf(stderr, "memory exhausted\n");
    exit(1);
}

int main()
{
    int max = 20;
    char* name = (char*) malloc(max); /* allocate buffer */
    if (name == 0) quit();

    printf("Enter a file name: ");

    while (1) { /* skip leading whitespace */
        int c = getchar();
        if (c == EOF) break; /* end of file */
        if (!isspace(c)) {
             ungetc(c, stdin);
             break;
        }
    }

    int i = 0;
    while (1) {
        int c = getchar();
        if (isspace(c) || c == EOF) { /* at end, add terminating zero */
            name[i] = 0;
            break;
        }
        name[i] = c;
        if (i == max - 1) { /* buffer full */
            max += max;
            name = (char*) realloc(name, max); /* get a new and larger buffer */
            if (name == 0) quit();
        }
        i++;
    }

    printf("The filename is %s\n", name);
    free(filename); /* release memory */
    return 0;
}

Das umfasst:

• Leerzeichen überspringen, bis Sie zur Zeicheneingabe gelangen
• Dynamisches Erweitern des Zeichenfolgenpuffers, um Zeichenfolgen beliebiger Größe aufzunehmen
• Umgang mit Bedingungen, wenn Speicher nicht zugewiesen werden kann

Gibt es einfachere, aber kaputte Lösungen, die vielleicht sogar etwas schneller laufen? Unbedingt!!

Wenn Sie scanf in einen Puffer ohne Begrenzung der Lesegröße verwenden, überschreitet Ihre Eingabe die Größe des Puffers, es entsteht eine Sicherheitslücke und/oder ein Absturz.

Das Begrenzen der Größe des Messwerts auf beispielsweise nur 100 eindeutige Zeichen eines Dateinamens scheint besser zu sein als ein Absturz. Aber es kann schlimmer sein; zum Beispiel wenn der Benutzer meinte (...)/dir/foo/bar.txt aber am Ende interpretieren Sie ihre Eingabe falsch und überschreiben eine Datei namens bar.t was ihnen vielleicht wichtig war.

Es ist am besten, früh gute Gewohnheiten im Umgang mit diesen Problemen anzunehmen. Meine Meinung ist, dass es sich lohnt, den Sprung zu C++ in Betracht zu ziehen, wenn Ihre Anforderungen etwas Nahestehendes und “C-ähnliches” rechtfertigen. Es wurde entwickelt, um genau diese Bedenken zu bewältigen – mit Techniken, die robust und erweiterbar sind und dennoch eine gute Leistung erbringen.

scanf scheint in einer nicht-feindlichen Umgebung zu funktionieren. Mit anderen Worten, Sie erstellen ein einfaches Dienstprogramm für sich selbst.

BUFSIZ überschreitet normalerweise die Größenbeschränkungen von UNIX-Pfadnamen bei weitem.

#include <stdio.h>

int main(void) {
  char str[BUFSIZ];                                                                                                                                                                             

  printf("Enter a file name: ");                                                                                                                                                                
  scanf("%s", str);                                                                                                                                                                             

  printf("You entered: %s\n", str);                                                                                                                                                             
}

Wenn Sie Daten in einem Programm sammeln müssen, die das Ziel eines Pufferüberlaufs sein könnten, benötigen Sie möglicherweise etwas mehr.

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

char * prompt_and_read(const char * prompt) {
  char * response;
  char * bufsize;

  printf("%s", prompt);
  asprintf(&bufsize, "%%%us", BUFSIZ);

  if((response = malloc(BUFSIZ + 1)) == NULL) {
    fprintf(stderr,"out of memory\n");
    exit(1);
  }
  scanf(bufsize, response);
  free(bufsize);
  return response;
}

int main ( void ) {
  char * pathname;

  pathname = prompt_and_read("Enter a file name: ");
  printf("You entered: [%s]\n", pathname);
  free(pathname);

  return 0;
}

#include <stdio.h>
int main(void)
{
    char file[100];
    printf("File Name?: \n");
    fgets(file, 100, stdin);
    printf("Your input: %s", file);
}

#include <iostream>
#include <string>

using namespace std;

int main()
{
    cout << "Enter a file name:";

    string filepath;
    cin >> filepath;
}

Sie sollten Ihre eigene fgets()-Wrapper-Funktion schreiben, die eine Eingabezeile in einen Puffer einer bestimmten Größe liest und das Zeilenumbruchzeichen entfernt, das fgets() ebenfalls liest. Sie könnten auch einen Status zurückgeben, ob die gesamte Zeile in den Puffer gepasst hat oder nicht (dh ist der Zeilenumbruch am Ende des Puffers). Sie sollten niemals scanf oder gets verwenden, es sei denn, Sie möchten Überläufe.

BEARBEITEN: Dachte, ich könnte einen grundlegenden Code bereitstellen:

typedef unsigned char BOOL;
#define TRUE   1
#define FALSE  0

/* wraps fgets, returns FALSE if the whole line couldn't fit into the buffer */
BOOL read_input(char *dest, size_t len)
{
   /* our temp buffer needs to hold the extra new line char (len + 1)
        * should also add error checking to malloc */
   BOOL bSuccess = TRUE;
   size_t total_len = len + 1;
   char *temp = (char*) malloc( total_len * sizeof(char) );

   fgets(temp, total_len, stdin);

   /* if the whole line wasn't read, we'll return FALSE but still copy temp into dest */
   if (temp[strlen(temp) - 1] != '\n')
      bSuccess = FALSE;
   else
      temp[strlen(temp) - 1] = '\0'; /* overwrite the '\n' if it does infact exist */

   strcpy(dest, temp);

   free(temp);
   return bSuccess;
}

Verwenden Sie diesen einfachen Code

#include"stdio.h"
#include"stdlib.h"
main()
{
    int i=0,j=0;
    char c,buf[100];

start:
    printf("Enter the name:");
    while ( (c=getchar()) != '\n' )
    {
            buf[i++]=c;
            buf[i]='\0';
    }
    if ( buf[0] == '\0')
    {
    printf("invalid name\n");
    goto start;
    }
    else
    printf("Your name is valid\nName = %s\n",buf);
      }