Ich versuche zu verstehen, getchar ()! = EOF

getchar() ist eine Funktion, die liest ein Zeichen aus standard-Eingabe. EOF ist ein spezielles Zeichen im C zu behaupten, dass die ENDE DER DATEI erreicht wurde.

In der Regel erhalten Sie eine EOF Zeichen der Rückkehr von getchar() wenn Ihre standard-Eingabe ist eine andere als die Konsole (D. H., eine Datei).

Wenn Sie Ihr Programm in unix wie diese:

$ cat somefile | ./your_program

Dann Ihre getchar() zurückkehren wird jedes einzelne Zeichen in somefile und EOF sobald somefile endet.

Wenn Sie Ihr Programm wie diesem:

$ ./your_program

Und senden eine EOF über die Konsole (durch drücken CTRL+D in Unix oder STRG+Z in Windows), dann getchar() auch zurück EOF und die Ausführung wird beendet.

InformationsquelleAutor der Antwort Pablo Santa Cruz

Den code geschrieben, mit den aktuellen C-standards sollte

#include <stdio.h>

int main(void)
{
    int c;
    while ((c = getchar()) != EOF)
       putchar(c);
}

Die Schleife könnte umgeschrieben werden

int c;
while (1) {
    c = getchar();
    if (c != EOF)
        putchar(c);
    else
        break;
}

das liest sich wie

• immer wieder
  • bekommen Sie das nächste Zeichen ("byte") der input von standard-Eingabe und speichern Sie es in c
  • wenn keine außergewöhnlichen Zustand aufgetreten ist beim Lesen der besagten Charakter
    • dann die Ausgabe der Zeichen gespeichert, die in c in standard-Ausgabe
  • anderes
    • brechen die Schleife

Viele Programmiersprachen behandeln außergewöhnlichen Bedingungen durch auslösen von Ausnahmen , brechen Sie den normalen Programmablauf. C gibt keine solche Sache. Stattdessen Funktionen, die fehlschlagen können, haben einen Rückgabewert und alle außergewöhnlichen Umstände sind, signalisiert durch einen speziellen Rückgabewert, die Sie brauchen, um zu überprüfen, aus den Unterlagen, die von der gegebenen Funktion. Im Falle von getchar die Dokumentation aus der C11-standard sagt (C11 7.21.7.6p3):

1. Die getchar Funktion liefert das nächste Zeichen aus dem Eingabe-stream gezeigt, durch stdin. Wenn der stream am Ende der Datei, die end-of-file-Indikator für den stream festgelegt ist und getchar zurück EOF. Wenn ein Lesefehler Auftritt, wird der Fehlerindikator für den stream festgelegt ist und getchar zurück EOF.

Heißt es anderswo, dass EOF eine integer-Konstante, < 0, und bei jedem ordentlichen return Wert >= 0 - die unsigned char null-erweitert, um eine int.

Den stream am Ende der Datei bedeutet, dass alle input verbraucht wurde. Für die standard-Eingabe ist es möglich, dass diese von der Tastatur durch Eingabe von Strg+D auf Unix - /Linux-terminals und Strg+Z in Windows-console windows. Eine andere Möglichkeit wäre es, für das Programm zu erhalten, das input aus einer Datei oder einer pipe anstatt von der Tastatur - dann ist Ende-der-Datei würde signalisiert werden, wenn die Eingaben waren vollständig verbraucht wird, d.h.

cat file | ./myprogram

oder

./myprogram < file

Als die oben genannten fragment, das sagt, es gibt tatsächlich zwei verschiedene Bedingungen, die verursachen können getchar zurück EOF: entweder die end-of-file erreicht wurde, oder einen tatsächlichen Fehler aufgetreten. Dies kann nicht abgeleitet werden, die aus dem return-Wert allein. Stattdessen müssen Sie die Funktionen verwenden, die feof und ferror. feof(stdin) würde return-Wert true, wenn das Ende der Datei erreicht wurde, auf die standard-Eingabe. ferror(stdin) würde true zurückgeben, wenn ein Fehler aufgetreten ist.

Ob tatsächlich ein Fehler aufgetreten ist, wird die variable errno definiert durch <errno.h> enthält den Fehlercode; die Funktion perror können verwendet werden, um automatisch anzuzeigen, eine lesbare Fehlermeldung mit einem Präfix. So konnten wir erweitern das Beispiel um

#include <stdio.h>
#include <errno.h> //for the definition of errno
#include <stdlib.h> //for exit()
int main(void)
{
    int c;
    while ((c = getchar()) != EOF)
       putchar(c);

    if (feof(stdin)) {
        printf("end-of-file reached\n");
        exit(0);
    }
    else if (ferror(stdin)) {
        printf("An error occurred. errno set to %d\n", errno);
        perror("Human readable explanation");
        exit(1);
    }
    else {
        printf("This should never happen...\n");
        exit('?');
    }
}

Zum auslösen des end-of-file würde man mit Strg+D (hier dargestellt als ^D) auf eine neue Zeile unter Linux:

% ./a.out
Hello world
Hello world
^D
end-of-file reached

(beachten Sie, wie die Eingang hier ist line-gepuffert, so dass die Eingabe nicht-interleaved-in der Zeile mit Ausgang).

Ebenso können wir den gleichen Effekt durch die Verwendung eines pipeline.

% echo Hello world | ./a.out
Hello world
end-of-file reached

Auslösen ein Fehler ist ein wenig komplizierter. In bash und zsh Schalen der standard-Eingabe werden kann geschlossen, so dass es nicht von überall her kommen, durch Anhängen <&- auf der Kommandozeile:

% ./a.out <&-
An error occurred. errno set to 9
Human readable explanation: Bad file descriptor

Bad file descriptor, oder EBADF bedeutet, dass die standard-Eingabe - Datei-Deskriptor-Nummer 0 ungültig war, so wurde es nicht geöffnet.

Andere unterhaltsame Art und Weise zu erzeugen, würde ein Fehler sein, Lesen Sie den standard-input von einer Verzeichnis - dies bewirkt, dass errno gesetzt werden, um EISDIR auf Linux:

% ./a.out < / 
An error occurred. errno set to 21
Human readable explanation: Is a directory

Eigentlich den Rückgabewert von putchar sollte überprüft werden, zu - den es ebenfalls
zurück EOF auf Fehler, oder das Zeichen geschrieben:

while ((c = getchar()) != EOF) {
    if (putchar(c) == EOF) {
        perror("putchar failed");
        exit(1);
    }
}

Und jetzt können wir testen dies durch Umleitung der standard-Ausgabe zu /dev/full - aber es ist ein gotcha - seit der standard-Ausgang ist gepuffert, müssen wir schreiben genug zu bewirken, dass die Puffer zu Spülen sofort und nicht am Ende des Programms. Wir bekommen unendlich null-bytes /dev/zero:

 % ./a.out < /dev/zero > /dev/full
 putchar failed: No space left on device

P. S. es ist sehr wichtig, immer verwenden Sie eine variable vom Typ int zu speichern den Rückgabewert von getchar(). Obwohl, es liest sich ein Charakter, mit unterzeichnet/unsigned/plain char ist immer falsch.

InformationsquelleAutor der Antwort Antti Haapala

In einer ähnlichen Weise zu der | pipe-Befehl oben können Sie die Umleitung auf Ihrem system zu nutzen, um die oben genannten code, um die Anzeige aller Zeichen Inhalt einer Datei, bis es das Ende erreicht (EOF), vertreten durch CTRL-Z oder CTRL-D in der Regel.

In der Konsole:
ProgramName < FileName1.txt

Und zum erstellen einer Kopie von dem, was gelesen wird aus Datei1 können Sie:
ProgramName < FileName1.txt > CopyOfInput.txt

Dies zeigt Sie Ihr Programm in mehrere Möglichkeiten, um hoffentlich Hilfe für Ihr Verständnis.

-Hoffe, das hilft.

InformationsquelleAutor der Antwort Finding Nemo 2 is happening.

 getchar()

wird ein Zeichen von der Eingabe.

 c = getchar()

Den Wert dieser Zuweisung ist der Wert der linken Seite nach der Zuweisung oder der Wert der Zeichen, die gelesen wurden. Wert EOF ist standardmäßig -1.

 ((c = getchar()) != EOF)

Solange der Wert bleibt etwas anderes als EOF oder, in anderen Worten, solange die Bedingung bleibt wahr, wird die Schleife weiter Durchlaufen. Sobald der Wert wird EOF den Wert der gesamten Bedingung 0 und es bricht die Schleife ab.

Die zusätzlichen Klammern um c = getchar() sind für den compiler, um zu betonen, dass wir wirklich tun wollten, eine Zuweisung in der Bedingung, da es in der Regel davon ausgegangen, dass Sie wollte, geben == und warnt Sie.

 main() {
     int c;
     while ((c = getchar()) != EOF)
         putchar(c);
 }

Also der gesamte code tatsächlich Echos zurück, was Sie eingeben. Es weist den Wert der Figuren c in der Bedingung und dann gibt es wieder in den Körper der Schleife, die endet erst, wenn das Ende der Datei erkannt wird.

InformationsquelleAutor der Antwort Darinka Zobenica