Wat is EOF in de programmeertaal C?

Hoe krijg je de laatste afdruk te zien? Met andere woorden wat in te zetten voor EOF? Ik heb de definities gecontroleerd en er staat dat EOF -1 is.

En als je Ctrl-D invoert, zie je niets.

#include <stdio.h>
int main() {
 int c;
 while((c = getchar() != EOF)) {
  printf("%d\n", c);
 }
 printf("%d - at EOF\n", c);
}

Antwoord 1, autoriteit 100%

Op Linux-systemen en OS X is het teken dat moet worden ingevoerd om een EOF te veroorzaken Ctrl–D. Voor Windows is dit Ctrl–Z.

Afhankelijk van het besturingssysteem werkt dit teken alleen als het het eerste teken op een regel is, d.w.z. het eerste teken na een Enter. Aangezien console-invoer vaak lijngericht is, herkent het systeem het EOF-teken mogelijk pas nadat u het hebt opgevolgd met een Enter.

En ja, als dat teken wordt herkend als een EOF, dan zal je programma het eigenlijke teken nooit zien. In plaats daarvan krijgt een C-programma een -1van getchar().

Antwoord 2, autoriteit 62%

U moet uw haakjes veranderen in

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

Omdat de operator “=” een lagere prioriteit heeft dan de operator “!=”. Dan krijg je de verwachte resultaten. Uw uitdrukking is gelijk aan

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

Je krijgt de twee enen als uitvoer, omdat je de vergelijking “c!=EOF” maakt. Dit wordt altijd een voor het teken dat u hebt ingevoerd en vervolgens de “\n” die volgt door op Return te drukken. Behalve de laatste vergelijking waarbij c echt EOF is, krijg je een 0.

Bewerken Over EOF: EOF is typisch -1, maar dit wordt niet gegarandeerd door de standaard. De standaard definieert alleen over EOF in paragraaf 7.19.1:

EOF die uitzet naar een geheel getal
constante uitdrukking, met type int en
een negatieve waarde, die wordt geretourneerd door
Verschillende functies om aan te geven
Eind-of-bestand, dat wil zeggen, geen invoer meer
van een stroom;

Het is redelijk om aan te nemen dat EOF gelijk is aan -1, maar wanneer u EOF gebruikt, moet u niet testen tegen de specifieke waarde, maar gebruik het liever de macro.

Antwoord 3, Autoriteit 19%

De waarde van EOF is een negatief geheel getal om het te onderscheiden van “char” -waarden die in het bereik van 0 tot 255 zijn. Het is typisch -1, maar het kan een ander negatief getal zijn … volgens de POSIX-specificaties , dus je moet niet aannemen dat het -1 is.

Het ^ D-teken is wat u typt bij een consolestroom op Unix / Linux om het te vertellen om logisch een ingangsstroom te beëindigen. Maar in andere contexten (zoals wanneer u uit een bestand leest), is het gewoon een ander gegevenskarakter. Hoe dan ook, het ^ D-karakter (betekenis van het einde van de invoer) maakt het nooit naar toepassingscode.

Zoals @Bastien zegt, wordt EOF ook geretourneerd als getchar()mislukt. Strikt genomen, moet u ferrorof feofbellen om te zien of het EOF een fout of een einde van de stroom weergeeft. Maar in de meeste gevallen zal uw aanvraag in beide gevallen hetzelfde doen.

Antwoord 4, Autoriteit 8%

Paar typefouten:

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

In plaats van:

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

Ook Getchar () behandelt een retoursleutel als een geldige invoer, dus u moet het ook bufferen.EOF is een marker om het einde van de invoer aan te geven. Over het algemeen is het een int met alle bits.

#include <stdio.h>
int main()
{
 int c;
 while((c = getchar())!= EOF)
 {
  if( getchar() == EOF )
    break;
  printf(" %d\n", c);
 }
  printf("%d %u %x- at EOF\n", c , c, c);
}

afdrukken:

49
50
-1 4294967295 ffffffff- bij EOF

voor invoer:

1
2
<ctrl-d>

Antwoord 5, autoriteit 6%

EOFbetekent einde van bestand. Het is een teken dat het einde van een bestand is bereikt en dat er geen gegevens meer zijn.

Bewerken:

Ik sta gecorrigeerd. In dit geval is het geen einde van het bestand. Zoals vermeld, wordt het doorgegeven wanneer CTRL+d (linux) of CTRL+z (windows) wordt doorgegeven.

Antwoord 6, autoriteit 6%

ninvoer vanaf een terminal “eindigt nooit” (tenzij het apparaat is losgekoppeld), maar het is handig om meer dan één “bestand” in een terminal in te voeren, dus een toetsenreeks is gereserveerd om het einde van de invoer aan te geven. In UNIX wordt de vertaling van de toetsaanslag naar EOF uitgevoerd door het terminalstuurprogramma, dus een programma hoeft terminals niet te onderscheiden van andere invoerbestanden. Standaard zet het stuurprogramma een Control-D-teken aan het begin van een regel om in een indicator voor het einde van het bestand. Om een echt Control-D (ASCII 04)-teken in de invoerstroom in te voegen, laat de gebruiker dit voorafgaan door een “aanhalingsteken”-opdrachtteken (meestal Control-V). AmigaDOS is vergelijkbaar, maar gebruikt Control-\ in plaats van Control-D.

In Microsoft’s DOS en Windows (en in CP/M en veel DEC-besturingssystemen) zal het lezen van de terminal nooit een EOF opleveren. In plaats daarvan herkennen programma’s dat de bron een terminal is (of een ander “karakterapparaat”) en interpreteren een bepaald gereserveerd teken of een bepaalde reeks als een indicator voor het einde van het bestand; meestal is dit een ASCII Control-Z, code 26. Sommige MS-DOS-programma’s, waaronder delen van de Microsoft MS-DOS-shell (COMMAND.COM) en hulpprogramma’s voor het besturingssysteem (zoals EDLIN), behandelen een Control-Z in een tekstbestand als markering van het einde van zinvolle gegevens, en/of voeg een Control-Z toe aan het einde bij het schrijven van een tekstbestand. Dit is om twee redenen gedaan:

1. Achterwaartse compatibiliteit met CP/M. Het CP/M-bestandssysteem registreerde alleen de lengte van bestanden in veelvouden van 128-byte “records”, dus volgens afspraak werd een Control-Z-teken gebruikt om het einde van zinvolle gegevens te markeren als het in het midden van een record eindigde. Het MS-DOS-bestandssysteem heeft altijd de exacte byte-lengte van bestanden vastgelegd, dus dit was nooit nodig op MS-DOS.

2. Het stelt programma’s in staat om dezelfde code te gebruiken om invoer van zowel een terminal als een tekstbestand te lezen.

Antwoord 7, autoriteit 2%

#include <stdio.h>
int main() {
    int c;
    while((c = getchar()) != EOF) { //precedence of != is greater than =, so use braces
        printf("%d\n", c);
    }
    printf("%d - at EOF\n", c);
}

Ik denk dat dit de juiste manier is om de waarde van EOF te controleren.
En ik heb de uitvoer gecontroleerd.

Voor INPUT: abc en Enter kreeg ik OUTPUT: 97 98 99 10. (de ASCII-waarden)

Voor INPUT Ctrl-D kreeg ik OUTPUT: -1 – bij EOF.
Dus ik denk dat -1 de waarde is voor EOF.

Probeer andere invoer in plaats van Ctrl-D, zoals Ctrl-Z.
Ik denk dat het per compiler verschilt.

Antwoord 8

om het simpel te houden: EOF is een integer type met waarde -1. Daarom moeten we een integer-variabele gebruiken om EOF te testen.

Antwoord 9

#include <stdio.h>
int main() {
    int c;
    while((c = getchar()) != EOF) { 
        putchar(c);
    }    
    printf("%d  at EOF\n", c);
}

de bovenstaande code gewijzigd om meer duidelijkheid te geven over EOF. Druk op Ctrl+d en putchar wordt gebruikt om de char af te drukken. Vermijd het gebruik van printf in de while-lus.

Antwoord 10

int c;
while((c = getchar())!= 10)
{
    if( getchar() == EOF )
        break;
     printf(" %d\n", c);
}