Wie zu Lesen, die Standardeingabe in einer string-variable, bis ein EOF-Zeichen in C?

Bin ich immer der "Bus-Error" versucht zu Lesen stdin in eine char* variable.
Ich die einfach nur Lesen wollen ganze Zeug über stdin und legen Sie es zuerst in eine variable, dann arbeiten Sie weiter auf die variable.

Mein Code ist wie folgt:

char* content;
char* c;
while( scanf( "%c", c)) {
 strcat( content, c);
}

fprintf( stdout, "Size: %d", strlen( content));

Aber irgendwie bekomme ich immer "Bus error" zurückgegeben, indem cat test.txt | myapp, wo myapp ist der kompilierte code oben.

Meine Frage ist, wie lese ich stdin bis ein EOF-Zeichen in eine variable? Wie du im code sehen, ich will nur drucken die Größe der input kommt über stdin, in diesem Fall sollte gleich der Größe der Datei test.txt.

Ich dachte nur mit scanf genug sein würde, vielleicht gepufferten Weise zu Lesen stdin?

Warum nicht einfach stat() auf, um die Größe der Datei, dann verwenden Sie den Datei-Größe + 1 zu (versuchen zu) malloc den Puffer und dann read() auf den Puffer?

InformationsquelleAutor NovumCoder | 2010-03-23

c stdin

17

Erste, Sie ' re passing nicht initialisierte Zeiger, was bedeutet, dass scanf und strcat schreiben von Speicher, die Sie nicht besitzen. Zweitens strcat erwartet zwei null-terminierte Zeichenfolgen, während c nur ein Charakter. Dies wird wieder dazu führen, dass es zu lese-Speicher, die Sie nicht besitzen. Sie nicht brauchen, scanf, weil Sie nicht tun, werden keine Echtzeit-Verarbeitung. Schließlich, Lesen ein Zeichen in einer Zeit, ist unnötig langsam. Hier ist der Anfang einer Lösung, bei der ein in der Größe veränderbares Puffer für die Letzte saite, und einen festen Puffer für die Funktion fgets nennen
```
#define BUF_SIZE 1024
char buffer[BUF_SIZE];
size_t contentSize = 1; //includes NULL
/* Preallocate space.  We could just allocate one char here, 
but that wouldn't be efficient. */
char *content = malloc(sizeof(char) * BUF_SIZE);
if(content == NULL)
{
    perror("Failed to allocate content");
    exit(1);
}
content[0] = '\0'; //make null-terminated
while(fgets(buffer, BUF_SIZE, stdin))
{
    char *old = content;
    contentSize += strlen(buffer);
    content = realloc(content, contentSize);
    if(content == NULL)
    {
        perror("Failed to reallocate content");
        free(old);
        exit(2);
    }
    strcat(content, buffer);
}

if(ferror(stdin))
{
    free(content);
    perror("Error reading from stdin.");
    exit(3);
}
```
EDIT: Wie Wolfer angedeutet, eine NULL in Ihrem Eingang verursacht, dass sich der string vorzeitig beendet werden, wenn die Verwendung der Funktion fgets. getline ist eine bessere Wahl, wenn verfügbar, da Sie die Speicherzuordnung verarbeitet und hat keine Probleme mit NUL-Eingang.
- Gibt invalid conversion from ‘void*’ to ‘char*’ [- fpermissive] auf char *content = malloc(sizeof(char) * BUF_SIZE); und content = realloc(content, contentSize); mit gcc 4.8.1 ...
- Auch schlägt es fehl, wenn Sie mit vorgestellt 0x00 in stdin.
- gcc C compiler keine -fpermissive. Sind Sie vielleicht kompilieren Sie C++; das wäre eine Erklärung für den Fehler? Die tags sagen C. Du hast Recht, dass fgets nicht gut spielen mit NUL-Zeichen. Es hat nicht bewirkt, dass alle undefinierten Verhalten, aber Sie wissen nicht, und der string vorzeitig beendet. Ich füge einen Hinweis über getline auf die Frage.
- Whoops, my bad, sorry.
InformationsquelleAutor Matthew Flaschen
7

Dein problem ist, dass Sie nie zugeteilt c und content, so sind Sie nicht auf den überall definiert-Sie sind wahrscheinlich deutete auf einige nicht zugeordneten Speicher, oder etwas, das überhaupt nicht existiert. Und dann setzen Sie Daten in Ihnen. Sie zuteilen müssen Sie Sie zuerst. (Das ist, was ein bus-Fehler bedeutet in der Regel; Sie versucht haben, zu tun, einen Zugang zum Speicher, der nicht gültig ist.)

(Abwechselnd, da c immer halten nur einen einzigen Charakter, Sie kann es erklären, wie char c und pass &c zu scanf. Keine Notwendigkeit zu erklären, eine Zeichenfolge von Zeichen, wenn ein tun wird.)

Sobald Sie das tun, werden Sie laufen in das Problem, dass Sie sicher, dass content ist lang genug, um alle halten Sie die Eingabe. Entweder müssen Sie raten, wie viel input, den Sie erwarten, und ordnen es zumindest, dass lange (und dann ein Fehler ausgegeben, wenn Sie mehr als das), oder Sie benötigen eine Strategie, um den Puffer in einer größeren Größe, wenn es nicht lange genug.

Oh, und du wirst auch irgendwann das problem, dass strcat erwartet einen string, nicht einen einzigen Charakter. Selbst wenn Sie verlassen c als char*, die scanf nennen, macht es nicht einen string. Eine Einzel-Zeichen-string ist (im Speicher) ein-Zeichen, gefolgt durch ein null-Zeichen an das Ende der Zeichenfolge. scanf beim Scannen für ein einzelnes Zeichen, nicht gehen, um in die null-Zeichen nach dem es. Als Ergebnis strcpy ist nicht zu wissen, wo das Ende der Schnur ist, und gehen Wandern ab, durch das Gedächtnis der Suche nach dem null-Zeichen.
- Sie sind nicht NULL, Sie haben Undefinierte Werte.
- +1 @Matthäus, es sei denn, Sie sind globals.
- nur c eine char und mit &c ist nicht genug, da strcat() muss eine null-terminierte Zeichenfolge.
- Carl: Danke, ich war nur hinzufügen, dass. Matthäus, vielen Dank für den Kommentar; ich werde es Bearbeiten, um hinzuzufügen, dass, wie gut.
InformationsquelleAutor Brooks Moses
6

Seit Sie kümmern sich nicht um den eigentlichen Inhalt, warum die Mühe der Aufbau einer Schnur? Würde ich auch verwenden getchar():
```
int    c;
size_t s = 0;

while ((c = getchar()) != EOF)
{
  s++;
}

printf("Size: %z\n", s);
```
Dieser code korrekt behandelt Fälle, in denen Sie Ihre Datei hat '\0' Zeichen.
- Der OP sagte: "ich die einfach nur Lesen wollen ganze Zeug über stdin und legen Sie es zuerst in eine variable, dann arbeiten Sie weiter auf die variable." Ich denke, die Länge () - Aufruf auf das ist nur ein Beispiel. Aber dein Kommentar über die Datei, die mit '\0' - Zeichen ist wichtig-die ganze Idee, dass es in einer einzigen variable kann ein bisschen fehlerhaft dort.
- c erklärt werden sollte, wie int umfassen den Bereich der char plus EOF.
- yup, guter Ruf. Tippen ohne zu denken.
- Ich muss verpasst haben, dass beim Lesen. Ich denke, die Antwort steht wie ein vernünftiges Beispiel.
- Carl: Einverstanden. (Und von Ihnen positiv bewertet werden.)
InformationsquelleAutor Carl Norum
1

Das problem hier ist, dass Sie verweisen auf eine Zeiger-variable, die keinen reservierten Speicher über malloc, damit die Ergebnisse wären unbestimmt, und nicht allein, dass durch die Verwendung strcat auf einem undefinierten Zeiger werden könnte, zeigen auf etwas, Sie endete mit einem bus-Fehler!

Dies wäre der Feste code erforderlich....
```
char* Inhalt = malloc (100 * sizeof(char)); 
char c; 
if (Inhalt != NULL){ 
Inhalt[0] = '\0'; //vielen Dank David! 
while ((c = getchar()) != EOF) 
{ 
if (strlen(Inhalt) < 100){ 
strcat(Inhalt, c); 
Inhalt[strlen(Inhalt)-1] = '\0'; 
} 
} 
} 
/* Wenn die variable */
free(content); 
```
Den code highlights der Programmierer verantwortlich zu verwalten die Speicher - für jedes malloc es gibt eine free wenn nicht, haben Sie ein Speicherleck!

Edit: Dank David Gelhar für seine Punkt-bei meiner glitch! Ich habe die Feste bis Sie den code oben entsprechend die Korrekturen...natürlich in einer realen situation, die vielleicht dem festen Wert 100 verändert werden könnte, um vielleicht eine #define um es leicht zu erweitern, den Puffer durch die Verdoppelung über die Höhe der Speicher über realloc und schneiden Sie es auf Größe...
- Dieser code hat einen Fehler: das erste mal durch die Schleife, die Sie aufrufen "strlen" auf nicht initialisierte Daten. (und natürlich sollten Sie prüfen, die für Pufferüberläufe, wenn mehr als 100 Zeichen der Eingabe vorhanden sind)
- Als Jon Purdy bemerkte auf einem der anderen Beiträge, Sie brauchen, um zu erklären, c als int, nicht char, so dass das möglich EOF Ergebnis in Reichweite. Ansonsten wirst du in einer endlos-Schleife. Auch Ihre strcat Aufruf erwartet zwei null-terminierte Zeichenfolgen, nicht einen string und ein Zeichen. Wie geschrieben, es wird nicht kompiliert.
InformationsquelleAutor t0mm13b

Unter der Annahme, dass Sie möchten, zu bekommen (kürzer als MAXL-1 chars) strings und nicht um Ihre file char by char, ich habe Sie wie folgt vor:

#include <stdio.h>
#include <string.h>
#define MAXL 256

main(){
  char s[MAXL];
  s[0]=0;
  scanf("%s",s);
  while(strlen(s)>0){
    printf("Size of %s : %d\n",s,strlen(s));
    s[0]=0;
    scanf("%s",s);
  };
}

InformationsquelleAutor user3715859

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.