Bestandsinvoer en -uitvoer in C

Een bestand bestaat uit opgeslagen gegevens; een gegevensstroom is het kanaal dat een draaiend programma gebruikt om die te bereiken. Dezelfde functies voor gegevensstromen kunnen ook met een terminal of pipe werken. Neem <stdio.h> op en bewaar de gegevensstroompointer in een variabele van het type FILE *.

Wat de gegevensstroom onthoudt

Het FILE-object van de bibliotheek houdt een buffer, de huidige bestandspositie en indicatoren voor het bestandseinde en fouten bij. Geef de pointer door aan functies zoals fgetc en fprintf; bekijk of wijzig de velden niet. Een lees- of schrijfbewerking schuift de positie voorbij de verwerkte gegevens. Als een binair bestand begint met "hello\nworld\n", begint de volgende leesbewerking na het lezen van de eerste zes bytes bij de w.

Buffering groepeert kleine bewerkingen tot grotere overdrachten. Een geslaagde schrijfbewerking kan betekenen dat gegevens een geheugenbuffer hebben bereikt, terwijl de overdracht naar het besturingssysteem nog moet plaatsvinden. fflush(fp) stuurt uitvoer die nog in de buffer staat naar het besturingssysteem. fclose(fp) doet dat voordat de gegevensstroom wordt vrijgegeven. Geen van beide garandeert dat gegevens een plotselinge stroomuitval overleven.

Gewone bestanden die met fopen zijn geopend, zijn volledig gebufferd. Interactieve apparaten kunnen andere buffering gebruiken. Een terminal of pipe biedt geen gewone bestandsposities om achteruit en vooruit te springen.

Kies tekstmodus of binaire modus

Tekstmodus verwerkt voor mensen leesbare regels. Binaire modus behoudt bytewaarden zonder tekstvertalingen. Voeg b toe aan de openingsmodus voor binaire gegevens: "rb" leest ze en "wb" schrijft ze. Afbeeldingen, gecomprimeerde gegevens en ruwe records vereisen binaire modus, ook als een versie in tekstmodus op je eigen computer lijkt te werken.

Op Linux en macOS is een nieuweregelteken één LF-byte, 0x0A, en gedragen de twee modi zich normaal gesproken hetzelfde. In Windows vertaalt tekstuitvoer '\n' naar de twee bytes CR LF, 0x0D 0x0A. Tekstinvoer vertaalt CR LF terug naar één '\n'. De tekstinvoer van Microsoft herkent ook 0x1A, Ctrl+Z, als bestandseinde.

Als je bijvoorbeeld "a\nb\nc\n" in tekstmodus schrijft, levert dat zes bytes op Linux of macOS en negen op Windows op. Drie letters nemen drie bytes in; drie Windows-regeleinden nemen zes bytes in. Als je het Windows-bestand op Windows in tekstmodus leest, krijg je zes tekens, terwijl binaire modus alle negen bytes zichtbaar maakt.

Houd de bytes van het bestand gescheiden van de tekst

Een op Windows gemaakte regel die op Linux wordt gelezen, kan "\r\n" behouden. Als je alleen '\n' verwijdert, blijft '\r' staan, waardoor een vergelijking met "yes" kan mislukken. Een positie in een tekststroom kan ook de vertaaltoestand weerspiegelen. Sla tekstposities daarom op en herstel ze in plaats van byte-offsets te berekenen.

De garantie van C dat tekst exact kan worden teruggelezen, geldt voor afdrukbare tekens, tabs en nieuweregeltekens, zonder spatie direct vóór een nieuweregelteken en met een nieuweregelteken aan het einde van de laatste regel. Andere bytereeksen horen in binaire gegevensstromen. C-bytes hebben ten minste acht bits; voorbeelden met bytewaarden van 0–255 en gangbare bestandsformaten gebruiken bytes van acht bits.

Kies een openingsmodus voordat je verwerkingscode schrijft. De modus bepaalt of het bestand moet bestaan, of de inhoud behouden blijft en waar schrijfbewerkingen terechtkomen. fopen werkt direct op het bestand: een geslaagde opening met "w" wist een bestaand bestand, ook als er daarna niet wordt geschreven.

Kies de modus die bij de taak past

Voeg b toe voor binaire modus; "r+b" en "rb+" betekenen hetzelfde. C11 voegt exclusieve bestandsaanmaak met x toe aan schrijfmodi, zoals "wx" en "wbx": het openen faalt als het bestand bestaat. Gebruik een gedocumenteerde modusstring; extra modusletters zijn niet overdraagbaar.

Controleer voordat je de pointer gebruikt

fopen geeft bij succes een nieuwe gegevensstroompointer terug en bij een fout NULL. Ontbrekende bestanden, ontoegankelijke paden en ontbrekende mappen kunnen allemaal een fout veroorzaken.

FILE *fp = fopen("scores.txt", "r");
if (fp == NULL) {
    fprintf(stderr, "Cannot open scores.txt\n");
    return EXIT_FAILURE;
}
/* Read through fp here. */
if (fclose(fp) == EOF) {
    fprintf(stderr, "Cannot close scores.txt\n");
    return EXIT_FAILURE;
}

Het codefragment gebruikt <stdio.h> en <stdlib.h>. Functies zoals fgetc, fprintf en fclose hebben een geldige gegevensstroom nodig; NULL doorgeven leidt tot ongedefinieerd gedrag. fflush(NULL) is een bewuste uitzondering die alle uitvoerstromen leegmaakt.

fclose geeft 0 terug bij succes en EOF bij een fout. Na de aanroep is de gegevensstroom afgesloten, ook als het sluiten een fout meldt. Probeer fclose niet opnieuw op dezelfde pointer en gebruik die niet voor verdere invoer of uitvoer. Sluit bestanden op tijd: het aantal beschikbare gegevensstromen is beperkt en C garandeert ondersteuning voor ten minste acht open gegevensstromen, inclusief de drie standaardstromen.

Bepaal paden vanuit het draaiende programma

Een relatief pad zoals "data/input.txt" begint bij de huidige werkmap, niet bij de map van het bronbestand. Als je het programma ergens anders start, verwijst dat pad naar iets anders. Voorwaartse schuine strepen werken ook met de C-bibliotheek van Microsoft. Een achterwaartse schuine streep in een C-string moet worden verdubbeld, zoals in "C:\\data\\in.txt"; anders kan een escapesequentie zoals \n de string veranderen.

Gebruik voor namen die op de opdrachtregel worden opgegeven int main(int argc, char *argv[]). Bij een kopieeropdracht met twee namen moet argc 3 zijn, is argv[1] de invoernaam en argv[2] de uitvoernaam. Open eerst de invoer, zodat een verkeerd gespelde invoernaam geen uitvoerbestand aanmaakt of wist. Als het openen van de uitvoer mislukt, sluit dan de al geopende invoer. Gebruik verschillende invoer- en uitvoerbestanden: eerst de invoer openen beschermt die niet als de uitvoernaam naar hetzelfde bestand verwijst.

Normaal terugkeren uit main of exit sluit gegevensstromen, maar door ze expliciet te sluiten kan het programma vertraagde uitvoerfouten detecteren. Bij een crash kunnen gebufferde gegevens verloren gaan; abort biedt niet de opruimgarantie van een normale afsluiting.

Een C-programma begint met drie open gegevensstromen: standaardinvoer stdin, standaarduitvoer stdout en standaardfoutuitvoer stderr. Ze zijn meestal verbonden met de terminal, maar de shell kan ze verbinden met bestanden of andere programma’s. Je kunt ze rechtstreeks doorgeven aan functies voor gegevensstromen.

Houd resultaten gescheiden van diagnostische meldingen

printf schrijft naar stdout; scanf leest uit stdin. getchar() leest een teken uit stdin en putchar(c) schrijft er een naar stdout. puts(s) schrijft een string naar stdout en voegt een nieuweregelteken toe. Met hun vormen voor gegevensstromen kan dezelfde code met een bestand werken:

void print_total(FILE *out, int total)
{
    fprintf(out, "Total: %d\n", total);
}

De aanroep print_total(stdout, 12) drukt een resultaat af; als je een pointer naar een geopend bestand doorgeeft, gaat dezelfde opmaak naar een bestand. Laat de hulpfunctie in productiecode een mislukte schrijfbewerking melden aan de aanroepende functie.

Schrijf diagnostische meldingen met fprintf(stderr, ...). Een programma dat gegevens verwerkt, kan dan een schoon resultatenbestand maken en fouten afzonderlijk verklaren. Een foutmelding op stdout kan de gegevens beschadigen die een ander programma verwacht te lezen.

Laat de shell de verbindingen kiezen

In een Unix-achtige shell scheidt deze opdracht alle drie de gegevensstromen:

./sortnums < numbers.txt > sorted.txt 2> errors.txt

< levert invoer, > maakt uitvoer aan of vervangt die, >> voegt uitvoer toe en 2> leidt foutmeldingen om. De omleidingsoperatoren werken ook in de Windows-opdrachtprompt, waar de programmanaam vaak wordt geschreven als sortnums.exe. Een pipe, zoals in generate | sortnums, stuurt de standaarduitvoer van het eerste programma naar de standaardinvoer van het tweede programma. Standaard wordt stderr niet meegenomen.

Een filter kan een optionele invoernaam accepteren en anders stdin lezen. Houd het eigenaarschap bij: sluit een gegevensstroom die je functie heeft geopend, maar laat een geleende gegevensstroom over aan de eigenaar. Voor een eenvoudig opdrachtregelfilter herkent if (in != stdin) het bestand dat het zelf heeft geopend.

Maak de uitvoerbuffer leeg voordat je op invoer wacht

Een terminal maakt stdout doorgaans regelgebufferd. Een omgeleid bestand of een pipe maakt die doorgaans volledig gebufferd. stderr is niet volledig gebufferd. Dit verklaart waarom de uitvoervolgorde kan veranderen wanneer beide gegevensstromen naar dezelfde bestemming worden gestuurd.

Na printf("Saving...") kan de tekst in de buffer blijven staan omdat er geen nieuweregelteken is. Gebruik fflush(stdout) en controleer op EOF als de tekst vóór de volgende bewerking zichtbaar moet zijn. Het leegmaken van de buffer verstuurt uitvoer die nog klaarstaat; het leest of verwijdert geen invoer. Standaard C definieert fflush(stdin) niet als een bewerking om invoer te wissen. Om een regel te verwijderen, lees je tekens tot '\n' of EOF.

Als een programma twee regels naar stdout afdrukt en daartussen een waarschuwing naar stderr, toont een terminal doorgaans de programmavolgorde. Met > out.txt 2>&1 kan de waarschuwing het bestand vóór de gebufferde standaarduitvoer bereiken. Gebruik de weergavevolgorde van gemengde gegevensstromen niet als vastlegging van de uitvoeringsvolgorde.

Geef scripts een bruikbaar resultaat terug

Geef EXIT_SUCCESS of 0 terug als de volledige taak slaagt en EXIT_FAILURE als die mislukt. Beide macro’s zijn gedeclareerd in <stdlib.h>. Een shellopdracht zoals convert in.csv out.txt && echo done voert de tweede opdracht alleen na succes uit. Een eerlijke afsluitstatus is even belangrijk als een nuttige diagnostische melding.

Tekeninvoer en -uitvoer is nuttig wanneer elk teken bepaalt wat er daarna gebeurt: scheidingstekens tellen, hoofdletters en kleine letters omzetten of een eenvoudig tekstformaat herkennen. fgetc leest één teken en fputc schrijft er één. Beide zijn gedeclareerd in <stdio.h>.

Bewaar de retourwaarde in een int

fgetc(fp) geeft het teken terug als een naar int geconverteerde unsigned char, of de negatieve constante EOF wanneer geen teken beschikbaar is omdat de invoer is geëindigd of een leesbewerking is mislukt. Op de gebruikelijke systemen met bytes van acht bits lopen geldige bytewaarden van 0 tot 255. Een int houdt die waarden gescheiden van EOF.

int c;
while ((c = fgetc(in)) != EOF) {
    if (fputc(c, out) == EOF) {
        /* Report a write failure and clean up. */
        break;
    }
}
/* Check ferror(in) before declaring the input complete. */

Een gewone char kan dit onderscheid verliezen. Bij een char met teken kan byte 0xFF -1 worden en op het bestandseinde lijken. Bij een char zonder teken wordt de negatieve EOF-waarde naar een byte geconverteerd en kan die bij vergelijking nooit gelijk zijn aan EOF.

Behoud beide haakjes rond de toewijzing. In c = fgetc(in) != EOF gebeurt de vergelijking eerst, zodat c 1 of 0 ontvangt in plaats van het teken. getc leest op dezelfde manier en kan een macro zijn; fputc geeft het geschreven teken of EOF terug.

Tel geslaagde leesbewerkingen, geen pogingen

De lusvoorwaarde moet de leesbewerking uitvoeren. feof beschrijft een eerdere poging die het einde heeft bereikt; de functie kan de volgende poging niet voorspellen. Een lus die !feof(in) controleert en daarna onvoorwaardelijk telt, voegt aan het einde een extra doorgang toe.

Voor de tekst "hi\nyo\n" leveren zes geslaagde leesbewerkingen zes tekens en twee nieuweregeltekens op. Alleen nieuweregeltekens tellen werkt voor regels die eindigen op een nieuweregelteken. De tekst "red\ngreen\nblue" heeft twee nieuweregeltekens maar drie regels, omdat het laatste "blue" nog steeds een regel is.

Om een laatste regel zonder nieuweregelteken mee te tellen, houd je ook het laatste teken bij:

size_t lines = 0;
int c, last = '\n';
while ((c = fgetc(in)) != EOF) {
    if (c == '\n') ++lines;
    last = c;
}
if (last != '\n') ++lines;

Door last te laten beginnen met '\n' telt een leeg bestand als nul regels. Een leesfout vereist nog steeds een apart foutpad; een gedeeltelijke telling is geen volledig resultaat.

Verander tekens of kijk vooruit

toupper uit <ctype.h> kan letters veranderen voordat ze worden geschreven. Een geslaagd resultaat van fgetc ligt al binnen het geldige invoerbereik voor toupper, dus fputc(toupper(c), out) is veilig binnen de lus. Willekeurige char-waarden met teken moeten naar unsigned char worden geconverteerd voordat je ze aan tekenclassificatiefuncties doorgeeft.

ungetc(c, in) plaatst een teken terug, zodat de volgende leesbewerking het opnieuw teruggeeft. Terugplaatsen van één teken is gegarandeerd; controleer op EOF als het terugplaatsen mislukt. Dit helpt een parser om het volgende teken te bekijken zonder het te verliezen. Een positioneringsbewerking maakt het terugplaatsen ongedaan.

De telling beschrijft wat de gekozen gegevensstroommodus oplevert. In Windows telt tekstmodus een CR LF-paar als één '\n'; binaire modus maakt beide bytes zichtbaar. Een tekentelling via een tekststroom hoeft daarom niet gelijk te zijn aan het opgeslagen aantal bytes.

Opgemaakte invoer en uitvoer converteert tussen C-waarden en leesbare tekst. fprintf schrijft in een opmaak die je kiest; fscanf leest waarden die bij een formaat passen. Hun conversiespecificaties lijken op elkaar, maar invoer vereist pointers naar de juiste doeltypen.

Schrijf leesbare waarden

Gebruik %d voor een int, %ld voor een long, %zu voor een size_t, %s voor een string en %c voor een teken. Voor uitvoer drukt %f een double af; een float-argument wordt gepromoveerd tot double. %% drukt een procentteken af.

int result = fprintf(fp, "%-8s%6.2f\n", "Oslo", 3.14159);
if (result < 0) {
    /* Handle a write failure. */
}

%-8s lijnt "Oslo" links uit in acht kolommen; %6.2f lijnt "3.14" rechts uit in zes. De resulterende regel is "Oslo 3.14\n" en de retourwaarde is 15 tekens. Veldbreedte is een minimum, geen beperking van de uitvoerlengte. Precisie verandert ook de opgeslagen informatie: %.2f schrijft 3.14159 als "3.14", zodat die extra cijfers niet uit het bestand kunnen worden teruggehaald.

Een eenvoudige CSV-schrijver kan "Lima,2024,19.5" uitvoeren met een vaste volgorde en komma’s tussen de velden. Tekst met komma’s, aanhalingstekens of nieuweregeltekens vereist dat CSV-velden tussen aanhalingstekens worden geplaatst. Zet zo’n veld tussen dubbele aanhalingstekens en verdubbel elk aanhalingsteken erin. Een schrijver met alleen %s is alleen geschikt als tekstvelden die tekens niet bevatten.

Maak tekst op in een begrensde array

sprintf heeft geen argument voor de grootte van de bestemming. Voor het opmaken van "007.jpg" zijn acht bytes nodig, inclusief het afsluitende nulteken. Gebruik bij voorkeur snprintf:

char name[32];
int n = snprintf(name, sizeof name, "%03d.jpg", 7);
if (n < 0 || (size_t)n >= sizeof name) {
    /* Formatting failed or the full result did not fit. */
}

De niet-negatieve retourwaarde is de lengte die de volledige tekst nodig zou hebben, exclusief het afsluitende nulteken. Een waarde gelijk aan de buffergrootte betekent al dat de tekst is afgekapt. Controleer of het resultaat negatief is voordat je het naar size_t converteert.

Lees het verwachte aantal waarden

char name[20];
int age;
int matched = fscanf(fp, "%19s %d", name, &age);

Deze aanroep slaagt alleen volledig als die 2 teruggeeft. De breedte 19 laat een byte over voor het afsluitende nulteken. De arraynaam levert het adres; het gehele getal heeft &age nodig. Voor invoer heeft %f een float * nodig en %lf een double *. Een afwijkend type leidt tot ongedefinieerd gedrag, niet tot een onschuldige conversie.

De meeste conversies slaan witruimte aan het begin over, inclusief nieuweregeltekens. fscanf dwingt dus niet één record per regel af en %s kan "New York" niet als één waarde lezen. Een tekenset zoals %19[^,] leest tot aan een komma; voor records is invoer van hele regels vaak duidelijker.

Bij "10 abc 20" slaat %d eerst 10 op en geeft 1 terug. De volgende aanroep geeft 0 terug omdat "abc" niet past; die tekst blijft ongelezen. Testen op != EOF herhaalt de fout eindeloos. Test op == 1 en handel ongeldige gegevens vervolgens afzonderlijk af van het einde van de invoer of een fout in de gegevensstroom. Een conversieresultaat is een telling van toegewezen waarden, geen waarheidswaarde voor het hele bestand.

Door een volledige regel te lezen voordat je die analyseert, houd je tekstrecords van elkaar gescheiden. Als een record ongeldig is, kun je het regelnummer melden en doorgaan met het volgende record. fgets begrenst hoeveel de functie schrijft, maar je moet nog steeds rekening houden met behouden nieuweregeltekens en regels die groter zijn dan de array.

Lees in een buffer met bekende capaciteit

char line[256];
while (fgets(line, sizeof line, fp) != NULL) {
    /* Process this successful read. */
}
if (ferror(fp)) {
    /* Report an interrupted read. */
}

fgets leest maximaal één teken minder dan de capaciteit, stopt na een nieuweregelteken als de functie er een tegenkomt en voegt een afsluitend nulteken toe. Bij succes geeft de functie de buffer terug. Een NULL-resultaat betekent dat er aan het einde van het bestand geen tekens beschikbaar waren of dat er een fout is opgetreden; verwerk de buffer niet na een leesfout.

sizeof line levert in dit geldigheidsgebied de capaciteit van de array. In een hulpfunctie met parameter char *line is het de grootte van de pointer. Geef de werkelijke capaciteit afzonderlijk door. De oude functie gets kan invoer niet begrenzen en is in C11 verwijderd.

Herken stukken van lange regels

Met char buf[8] komt "temperature\n" binnen als "tempera" en daarna "ture\n". De eerste aanroep gebruikt zeven bytes voor tekens en één voor het afsluitende nulteken. Een geslaagde leesbewerking zonder nieuweregelteken kan een stuk van een lange regel zijn of het laatste stuk aan het bestandseinde zonder afsluitend nieuweregelteken.

Kies een aanpak: voeg stukken samen tot een groter record, verwerk ze als een aaneengesloten reeks of wijs het record af en verwerp alle resterende stukken ervan. Controleer bij een groottelimiet het volgende teken voordat je een precies gevulde buffer afwijst. Een volgend nieuweregelteken voltooit het record; EOF zonder fout in de gegevensstroom voltooit een laatste regel zonder nieuweregelteken; een ander teken betekent dat er meer inhoud is. Plaats een teken alleen terug als latere code het opnieuw moet lezen.

Verwijder alleen een regeleinde dat je echt hebt gevonden

Nadat je hebt bepaald of het record compleet is, verwijder je regeleinden:

line[strcspn(line, "\r\n")] = '\0';

strcspn uit <string.h> vindt het eerste van de opgegeven tekens, of het bestaande afsluitende nulteken als geen van beide voorkomt. Dit verwerkt zowel achtergebleven CR LF als LF. Onvoorwaardelijk line[strlen(line) - 1] verwijderen kan echte gegevens verwijderen van een laatste regel zonder nieuweregelteken en is ongeldig voor een lege string.

fputs(line, out) schrijft de string zonder een nieuweregelteken toe te voegen; puts(line) schrijft naar stdout en voegt er wel een toe. Een tekstkopie kan elk met fgets geslaagd gelezen stuk doorgeven aan fputs en op fouten controleren, ook als een lange regel uit meerdere stukken bestaat. Gebruik binaire blokinvoer en -uitvoer als de oorspronkelijke bytes exact behouden moeten blijven.

Analyseer en valideer afzonderlijk

sscanf(line, "%d %9s", &qty, item) geeft 2 terug voor "7 apples" en 0 voor "seven apples". Bij een mislukte analyse blijft geen ongeldig token in de invoerstroom achter, omdat de regel al is gelezen. Numerieke conversies met sscanf vereisen nog steeds invoer die binnen het bereik kan worden weergegeven; gebruik strtol voor strikte bereikcontrole.

Zet voor strtol errno op nul, geef een eindpointer door en controleer op ontbrekende cijfers, ERANGE en onverwachte tekst aan het einde. Bij "42abc" is het resultaat 42 slechts een numeriek voorvoegsel. Sta voor een veld met een geheel getal de gekozen witruimte aan het einde toe en vereis daarna het einde van de string. Controleer het bereik van het doeltype voordat je een geldige long versmalt naar int.

Binaire invoer en uitvoer draagt de bytes van objecten over zonder ze naar leesbare getallen of woorden te converteren. fread en fwrite ontvangen een adres, een elementgrootte, een aantal elementen en een gegevensstroom. Hun retourwaarden tellen volledige elementen, dus de gekozen elementgrootte bepaalt wat je uit het resultaat kunt afleiden.

Schrijf en lees arrays

int a[5] = {1, 2, 3, 4, 5};
if (fwrite(a, sizeof a[0], 5, out) != 5) {
    /* Handle a write failure. */
}

Op een systeem waar int vier bytes groot is, schrijft dit 20 bytes en geeft het 5 terug. Door de gegevens in een andere array van vijf elementen met dezelfde representatie te lezen, kun je de waarden terugkrijgen. Gebruik "wb" en "rb", zodat tekstvertalingen de bytes niet kunnen veranderen.

Geef voor één object het adres door: fwrite(&rec, sizeof rec, 1, out). Gebruik voor objecten die via een pointer p worden bereikt fwrite(p, sizeof *p, count, out). sizeof p meet de pointer en &p wijst naar de pointervariabele zelf. Geen van beide beschrijft de bedoelde gegevensoverdracht. Als de elementgrootte of het aantal nul is, geven beide functies nul terug zonder gegevens over te dragen.

Kopieer precies de gelezen bytes

unsigned char buf[512];
size_t n;
while ((n = fread(buf, 1, sizeof buf, in)) > 0) {
    if (fwrite(buf, 1, n, out) != n) {
        /* Handle failure and stop copying. */
        break;
    }
}

Een elementgrootte van 1 maakt n tot een aantal bytes. Een invoer van 1.300 bytes levert 512, 512 en 276 bytes op, en daarna nul. De laatste schrijfbewerking moet 276 gebruiken, niet de capaciteit 512. Als je de hele buffer schrijft, voeg je 236 bytes toe die van eerdere leesbewerkingen zijn overgebleven.

Met fread(buf, 512, 1, in) geeft dezelfde invoer achtereenvolgens 1, 1 en 0 terug. De laatste 276 bytes vormen slechts een onvolledig element; ze worden niet meegeteld en de waarde van dat onvolledige element is onbepaald. Kies elementen van één byte wanneer een onvolledig laatste blok nuttig is. Kies elementen ter grootte van een record wanneer onvolledige records moeten worden afgewezen.

Een fread die minder elementen oplevert dan gevraagd, kan wijzen op het bestandseinde of een fout. Controleer na het kopiëren ferror en controleer fclose op de uitvoer: een schrijfbewerking die in een buffer is geaccepteerd, kan later falen. Een onvolledige bestandskop of een onvolledig record mag nooit als een volledig object worden behandeld.

Bekijk signaturen en opgeslagen objecten

Gebruik unsigned char voor ruwe bytes; op systemen met bytes van acht bits bevat dit type waarden van 0–255 zonder negatieve waarden. JPEG-gegevens beginnen met 0xFF 0xD8. Foto’s van camera’s en telefoons gaan vaak verder met een APPn-markering, wat het herstelpatroon FF D8 FF E0 tot en met FF D8 FF EF oplevert. Dat patroon is een nuttige test om mogelijke bestanden te vinden; valideer het formaat voordat je het vertrouwt. Sommige JPEG-bestanden gebruiken een ander volgend segment.

Een struct met char name[20] en een int score neemt meestal 24 bytes in. Een ruwe schrijfbewerking bevat alle opgeslagen bytes, inclusief opvulling. Een pointerveld slaat een adres op, niet de string waarnaar het verwijst. Gebruik een ingebedde array of schrijf de lengte en tekens van de string afzonderlijk.

Leesbare tekst kan meer ruimte innemen: "1000000\n" gebruikt acht bytes op Linux en negen in Windows-tekstmodus. Een expliciet gecodeerd 32-bits geheel getal gebruikt vier bytes van acht bits. Ruwe opslag van objecten is compact, maar bindt het bestand aan de representatie van het systeem dat het heeft gemaakt.

Een binaire gegevensstroom behoudt bytes, maar twee computers kunnen dezelfde bytes verschillend interpreteren. Een overdraagbaar formaat legt vast wat elke byte betekent, in plaats van de indeling over te nemen die de compiler aan een object geeft.

Leg groottes, volgorde en indeling vast

Drie keuzes maken het rechtstreeks wegschrijven van een object afhankelijk van de computer:

Little-endian slaat de minst significante byte eerst op. Big-endian slaat de meest significante byte eerst op. De waarde 258, hexadecimaal 0x00000102, is 02 01 00 00 in little-endian-volgorde en 00 00 01 02 in big-endian-volgorde.

Een gangbare structindeling voor een char gevolgd door een int neemt acht bytes in: één byte voor het teken, drie opvulbytes en vier voor het gehele getal. De waarden van de opvulbytes zijn niet gespecificeerd. Typen met exacte bitbreedte uit <stdint.h>, zoals uint32_t, leggen de bitbreedte vast waar ze beschikbaar zijn; ze leggen de bytevolgorde niet vast en verwijderen geen opvulling. Veelgebruikte voorbeelden van bestandsformaten gaan uit van bytes van acht bits en de beschikbaarheid van die typen.

Decodeer velden expliciet

Lees vier bytes volledig voordat je ze interpreteert. Voor een little-endian-veld:

uint32_t v = (uint32_t)b[0]
           | (uint32_t)b[1] << 8
           | (uint32_t)b[2] << 16
           | (uint32_t)b[3] << 24;

Hier is b een array van bytes zonder teken. Elke expliciete typeconversie vindt vóór de bitverschuiving plaats, zodat de berekening de vereiste breedte zonder teken heeft. Om te coderen haal je de laagste acht bits eruit, daarna de volgende acht, enzovoort. Controleer elke uitvoerbewerking. Als je v rechtstreeks met fwrite schrijft, breng je de bytevolgorde van de computer weer in het formaat binnen.

Definieer een volledig klein formaat

Een scoreformaat kan "SCR1" gebruiken als signatuur van vier bytes, gevolgd door een little-endian-aantal van vier bytes en records die bestaan uit 20 naambytes plus vier little-endian-scorebytes. De signatuur geeft ook de versie aan. De bestandskop is acht bytes; elk record is precies 24 bytes.

Vijf records nemen 128 bytes in. Record met index 3 begint bij byte 80: sla acht bytes van de bestandskop en drie volledige records over. Leg bij een echt formaat de codering van het naamveld en de regels voor afsluiting of opvulling vast; een naamveld van 20 bytes is niet automatisch een C-string.

Controleer de volledige lengte en signatuur van een bestandskop voordat je de velden gebruikt. Controleer daarna aantallen en lengtes aan de hand van redelijke limieten en de beschikbare gegevens voordat je geheugen reserveert. Een aannemelijk aantal is niet genoeg als latere records ontbreken.

Lees de werkelijke structuur van het formaat

Sommige PCM WAV-bestanden hebben een eenvoudige bestandskop van 44 bytes, met de bemonsteringsfrequentie op bytes 24–27. De bytes 44 AC 00 00 worden gedecodeerd als 44.100 monsters per seconde. Andere WAV-bestanden bevatten extra blokken, dus volgt een algemeen leesprogramma de bloknamen en -groottes om het fmt -blok te vinden. Als je voor elk bestand uitgaat van één vaste bestandskopindeling, kun je een niet-gerelateerd veld als frequentie lezen.

Tekst zoals CSV vermijdt problemen met de grootte van gehele getallen, bytevolgorde en opvulling in structs en is gemakkelijk te bekijken. Wel zijn nog steeds een vastgelegde veldindeling, regels voor aanhalingstekens en gecontroleerde analyse nodig. Kies tekst wanneer leesbaarheid en uitwisseling belangrijker zijn dan een compacte binaire representatie.

Bij sequentieel lezen worden gegevens op volgorde verwerkt. Met directe toegang kan een programma naar een bekende locatie springen, zoals één record in een groot bestand. Positioneren werkt alleen als de onderliggende gegevensstroom dit ondersteunt, en de betekenis van een positie verschilt tussen binaire gegevensstromen en tekststromen.

Positie opvragen en verplaatsen

ftell(fp) geeft een long-positie terug of -1L bij een fout. Voor een binair bestand telt een positie bytes vanaf het begin. fseek(fp, offset, whence) verplaatst de positie ten opzichte van een gekozen referentiepunt en geeft 0 terug bij succes en een waarde ongelijk aan nul bij een fout.

Zo vraagt fseek(fp, -4L, SEEK_END) om de laatste vier bytes van een binair bestand op een systeem dat verplaatsingen ten opzichte van het einde ondersteunt. Controleer het resultaat voordat je leest. Een verzoek op een pipe of terminal, of een verzoek om naar vóór het begin van een gewoon bestand te gaan, kan mislukken.

Bereken de locatie van een record

Voor binaire records van vaste grootte zonder bestandskop geeft de index vanaf nul, vermenigvuldigd met de recordbreedte, de beginoffset. Bij records van 24 bytes begint index 3 bij byte 72. Na het lezen van dat volledige record is de positie 96.

long offset = 3L * (long)sizeof(struct record);
if (fseek(fp, offset, SEEK_SET) != 0) {
    /* Handle the failed move before reading. */
}

Dit voorbeeld gaat ervan uit dat het bestand met dezelfde structindeling is geschreven. Een vastgelegd overdraagbaar formaat gebruikt in plaats daarvan de gedefinieerde recordbreedte. Tel bytes van een aanwezige bestandskop mee. Het derde record geteld vanaf 1 heeft index 2, niet index 3. Valideer bij grote indexen de vermenigvuldiging en controleer of het resultaat in long past voordat je de positie wijzigt.

Op gangbare systemen kun je een binair bestand meten door naar het einde te gaan en ftell te gebruiken: een bestand van 120 bytes met records van 24 bytes bevat vijf records. Controleer beide aanroepen en herstel daarna de positie. Standaard C vereist geen zinvolle SEEK_END voor elke binaire gegevensstroom, dus de methode hangt af van de ondersteuning door die gegevensstroom.

Sla tekstposities op zonder ermee te rekenen

Tekstmodus kan regeleinden vertalen. Een teruggegeven tekstpositie is informatie om naar een plaats terug te keren, geen getal om bij op te tellen of van af te trekken. Een positiewijziging in tekstmodus met een waarde ongelijk aan nul gebruikt een eerder door ftell voor hetzelfde bestand teruggegeven waarde, met SEEK_SET. Een offset van nul is toegestaan met elk referentiepunt.

rewind(fp) keert terug naar het begin en wist zowel de bestandseinde-indicator als de foutindicator. De functie geeft geen resultaat terug, dus gebruik een gecontroleerde fseek(fp, 0L, SEEK_SET) wanneer moet worden bevestigd dat de verplaatsing is geslaagd. Een geslaagde fseek wist de bestandseinde-indicator en maakt het terugplaatsen met ungetc ongedaan, maar laat een bestaande foutindicator staan.

Bewaar een positiewaarde

fgetpos(fp, &pos) slaat een positie op in fpos_t; fsetpos(fp, &pos) herstelt die. Controleer bij beide of een waarde ongelijk aan nul een fout aangeeft. Behandel fpos_t als een ondoorzichtige waarde waarmee je niet rekent. Die kan meer positie-informatie bevatten dan een eenvoudige telling van bytes.

fseek en ftell gebruiken long, dat op Windows meestal 32 bits is en de weer te geven posities beperkt tot ongeveer 2 GiB. Een positiewaarde voorkomt dat de interface aan long wordt gebonden, maar de ondersteunde bestandsgrootte hangt nog steeds af van de implementatie en configuratie.

Een gegevensstroom voor lezen en schrijven leest en schrijft hetzelfde bestand. Gebruik "r+b" om een bestaand binair bestand te behouden terwijl je de records wijzigt. "w+b" wist het oude bestand direct en toevoegmodi sturen elke schrijfbewerking naar het einde.

Wissel geldig van richting

Voor een gegevensstroom voor lezen en schrijven gelden twee wisselregels:

Positioneringsfuncties zijn onder meer fseek, fsetpos en rewind. Controleer functies die een resultaat melden voordat je verdergaat. Een richtingswisseling zonder de vereiste handeling leidt tot ongedefinieerd gedrag; je kunt er niet op rekenen dat alleen het volgende record wordt beïnvloed.

Werk één volledig record bij

Stel dat een bestand zonder bestandskop vijf records van 24 bytes bevat met dezelfde representatie als struct record. Om index 3 te wijzigen:

1. Open met "r+b" en controleer de pointer.
2. Ga naar byte 72 en controleer of dit is geslaagd.
3. Lees precies één volledig record.
4. Verander het veld score in 99.
5. Ga terug naar het begin van het record.
6. Schrijf precies één record en controleer het resultaat van het sluiten.

De belangrijkste bewerkingen daartussen zijn:

if (fread(&rec, sizeof rec, 1, fp) != 1) {
    /* Report the incomplete input, then clean up. */
    goto cleanup;
}
rec.score = 99;
if (fseek(fp, -(long)sizeof rec, SEEK_CUR) != 0) {
    /* Report the failed seek, then clean up. */
    goto cleanup;
}
if (fwrite(&rec, sizeof rec, 1, fp) != 1) {
    /* Report the failed write, then clean up. */
    goto cleanup;
}

De omvattende functie bevat een label cleanup dat de gegevensstroom sluit en bij deze takken een foutstatus teruggeeft. Na het lezen is de positie 96. Door 24 bytes terug te gaan, selecteer je het oorspronkelijke record en maak je de wisseling van lezen naar schrijven mogelijk. Na een geslaagde vervanging blijft het bestand 120 bytes groot en bevat het vijf records. Een opgeslagen beginpositie herstellen is een andere geldige manier om de wijziging uit te voeren.

Bepaal wanneer je opnieuw moet schrijven

Als je een record van 24 bytes toevoegt, groeit dat bestand tot 144 bytes. Door naar het begin van een "ab"- of "a+b"-gegevensstroom te gaan, kun je de volgende schrijfbewerking niet laten overschrijven; die gaat nog steeds naar het huidige einde.

Een vervanging op dezelfde positie moet passen in de ruimte die ze vervangt. "Bo,7" veranderen in "Bo,9" past. Als je "Bo,12" over "Bo,7\n" schrijft, wordt het nieuweregelteken overschreven en wordt de volgende tekst aan het record vastgemaakt. Om records groter of kleiner te maken, schrijf je een gecorrigeerd nieuw bestand. Standaard C heeft geen functie voor gegevensstromen die een reeks bytes uit het midden van een bestand verwijdert. Voor verwijdering kun je in plaats daarvan alle overblijvende records kopiëren of een record van vaste grootte als verwijderd markeren.

Zorg dat vervanging herstelbaar blijft

Controleer remove en rename; beide geven 0 terug bij succes. Of rename een bestaande bestemming vervangt, wordt door de implementatie bepaald. Linux en macOS ondersteunen vervanging; de C-bibliotheek van Microsoft faalt wanneer de bestemming bestaat.

Een overdraagbaar herstelplan schrijft en sluit het nieuwe bestand, hernoemt het origineel naar een afzonderlijke back-upnaam en hernoemt het nieuwe bestand naar de oorspronkelijke naam. Als het plaatsen mislukt, houd je de back-up beschikbaar voor herstel en meld je waar die staat. Verwijder de back-up pas nadat het plaatsen is geslaagd. Deze reeks maakt herstel mogelijk; het is geen overdraagbare atomaire transactie en geen garantie tegen stroomuitval.

Een bestand kan met succes worden geopend en toch falen tijdens lezen, schrijven, positioneren of sluiten. Een robuust programma controleert het resultaat van de bewerking die het daadwerkelijk heeft geprobeerd. Het onderscheidt een voltooide leesbewerking van onderbroken invoer en onjuist opgemaakte gegevens van een falende gegevensstroom.

Leer elk foutsignaal kennen

rewind, clearerr en perror geven geen waarde terug. Als moet worden gecontroleerd of de verplaatsing naar het begin is geslaagd, gebruik dan fseek in plaats van op een resultaat van rewind te vertrouwen.

Controleer de gegevensstroom nadat het lezen stopt

De gegevensstroom houdt afzonderlijke indicatoren voor het bestandseinde en fouten bij. feof(fp) test de eerste; ferror(fp) test de tweede. Elk geeft een waarde ongelijk aan nul terug als de bijbehorende indicator is gezet.

while (fgets(line, sizeof line, fp) != NULL) {
    /* Process successful input. */
}
if (ferror(fp)) {
    fprintf(stderr, "Input could not be completed\n");
    /* Return failure after cleanup. */
}

De retourwaarde van fgets alleen maakt geen onderscheid tussen de twee redenen om te stoppen. Op dezelfde manier geeft fgetc EOF terug en geeft fread een kleiner aantal terug, zowel bij het bestandseinde als bij een leesfout. Test feof niet vóór het lezen om te voorspellen of er nog gegevens zijn.

Indicatoren blijven gezet. clearerr wist ze beide, net als rewind. Een geslaagde fseek of fsetpos wist de bestandseinde-indicator, maar niet een bestaande foutindicator. Het wissen van een indicator geeft aan dat je die hebt verwerkt; het herstelt niet de verbinding met een verwijderd station en repareert geen beschadigd bestand. Probeer het pas opnieuw als de oorzaak is aangepakt.

Onderscheid ongeldige gegevens van mislukte toegang

Als fscanf(fp, "%d", &value) 0 teruggeeft bij "abc", is de conversie mislukt vóór een toewijzing. Daarvoor hoeft geen bestandseinde of leesfout te zijn opgetreden. Meld een ongeldig veld, bij voorkeur met een regelnummer. Een melding over de schijf zou het verkeerde probleem beschrijven.

Als een vereiste bestandskop als één element wordt gelezen en fread 0 teruggeeft, is de bestandskop onvolledig. Bekijk dat gedeeltelijk gevulde object niet. Als ferror is gezet, meld je een invoerfout; als het bestand is geëindigd, meld je afgekorte gegevens. Een leeg bestand en een onvolledige bestandskop kunnen hetzelfde aantal elementen opleveren, dus het verwachte formaat bepaalt dat de bestandskop aanwezig moet zijn.

Vang vertraagde uitvoerfouten af

Een schijf kan vol raken nadat het programma de uitvoer heeft geopend. Gebufferde schrijfbewerkingen kunnen geslaagd lijken totdat fflush of fclose de wachtende bytes daadwerkelijk overdraagt. Controleer de afsluitende sluitbewerking en laat een fout daarbij een verder geslaagde taak doen mislukken. Sluit dezelfde gegevensstroom daarna niet opnieuw.

Op een terminal geeft Ctrl+D aan het begin van een regel op Linux of macOS, of Ctrl+Z gevolgd door Enter op Windows, doorgaans het einde van de invoer aan. clearerr(stdin) wist de resulterende indicator als het programma nog een poging nodig heeft. De handeling op de terminal en een leesfout blijven verschillende oorzaken.

Een retourwaarde vertelt je dat een bewerking is mislukt. Een foutcode kan helpen verklaren waarom. Gebruik errno alleen binnen de context van het gedocumenteerde gedrag van de bewerking en bewaar de waarde voordat andere bibliotheekaanroepen die kunnen veranderen.

Laat de bewerking de fout vaststellen

errno is een wijzigbare int-expressie uit <errno.h>, met in C11 een afzonderlijke opslagduur per thread. De waarde begint op nul. Bibliotheekaanroepen zetten de waarde niet terug op nul en een geslaagde aanroep kan een waarde ongelijk aan nul laten staan of instellen. Als je errno na een geslaagde fopen test, vertelt dat je dus niet dat het openen is mislukt.

Op POSIX-systemen stelt een mislukte fopen een foutcode in. De C-bibliotheek van Microsoft biedt ook bestandsfoutcodes. Standaard C vereist niet dat fopen errno instelt. Voor overdraagbare foutmeldingen kun je de waarde vóór het openen op nul zetten en een algemene melding gebruiken als geen code is opgegeven:

errno = 0;
FILE *fp = fopen(name, "r");
if (fp == NULL) {
    int saved = errno;
    if (saved != 0)
        fprintf(stderr, "Cannot open %s: %s\n",
                name, strerror(saved));
    else
        fprintf(stderr, "Cannot open %s\n", name);
    return EXIT_FAILURE;
}

Dit codefragment heeft ook <stdio.h>, <stdlib.h> en <string.h> nodig. Door de code direct op te slaan voorkom je dat latere aanroepen voor meldingen of opruimen de oorspronkelijke reden vervangen. Een opgeslagen code is ook nuttig als de uiteindelijke melding veel later wordt afgedrukt.

Kies een functie voor meldingen

perror(label) schrijft het label, een dubbele punt en spatie, de huidige foutmelding en een nieuweregelteken naar stderr. Een typische melding voor een ontbrekend bestand is "missing.txt: No such file or directory"; de exacte formulering hangt af van het systeem.

strerror(code) geeft de melding van de bibliotheek voor een opgegeven code terug en past dus bij een eigen diagnostische melding die het programma, de bewerking en het bestand noemt. Wijzig de teruggegeven string niet. Gebruik na het opruimen strerror(saved) in plaats van de nieuwe waarde van errno op te vragen.

C definieert EDOM, ERANGE en EILSEQ. Veelvoorkomende bestandscodes zoals ENOENT, EACCES, EEXIST en ENOSPC worden geleverd door POSIX en breed beschikbare C-bibliotheken. Stem je code af op de interface en het platform waarvoor je schrijft. Ga er niet van uit dat numerieke codewaarden of exacte Engelse meldingsteksten overal gelijk zijn.

Handel een dubbelzinnige retourwaarde af

Bij sommige functies kan het resultaat alleen geen onderscheid maken tussen succes en een bereikfout. strtol kan LONG_MAX teruggeven als geldig getal of als resultaat van overloop. Zet errno vóór de conversie op nul en controleer daarna de gedocumenteerde bereikcode:

errno = 0;
char *end;
long value = strtol(text, &end, 10);
if (end == text) {
    /* No digits were converted. */
} else if (errno == ERANGE) {
    /* The value is outside the long range. */
} else {
    /* Validate trailing characters and the target range. */
}

Een nuttige diagnostische melding geeft de gebruiker informatie om te handelen. Noem het bestand en de beoogde handeling; behoud de reden van het systeem als die beschikbaar is. Stuur de melding naar stderr, zodat stdout beschikbaar blijft voor geldige resultaatgegevens.

Foutafhandeling is pas compleet wanneer hulpbronnen zijn vrijgegeven en het programma het werkelijke resultaat meldt. Bepaal het eigenaarschap wanneer je een gegevensstroom opent en zorg dat elk later pad die afspraak volgt.

Sluit elke geopende gegevensstroom eenmaal

Als het openen van de invoer mislukt, is er geen gegevensstroom om te sluiten. Als het openen van de uitvoer mislukt nadat de invoer is geopend, sluit je de invoer. Als het kopiëren mislukt nadat beide zijn geopend, sluit je beide, controleer je het sluiten van de uitvoer en behoud je een foutstatus. Een pointer tweemaal sluiten is geen extra bescherming; je gebruikt dan een afgesloten gegevensstroom.

Code die vroegtijdig terugkeert, sluit hulpbronnen meestal in omgekeerde volgorde. Een gedeeld opruimlabel is nuttig wanneer meerdere foutpaden hetzelfde werk vereisen. Initialiseer pointers op NULL, houd standaard een foutstatus aan en stel pas succes in nadat de verwerkingsfase is voltooid.

Het volgende volledige programma kopieert verschillende invoer- en uitvoerbestanden in binaire modus. Het gebruikt algemene meldingen omdat standaard C niet vereist dat elke stdio-fout errno instelt.

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

int main(int argc, char *argv[])
{
    FILE *in = NULL, *out = NULL;
    int status = EXIT_FAILURE;
    int output_acquired = 0;
    unsigned char buf[512];
    size_t n;

    if (argc != 3) {
        fprintf(stderr, "Usage: %s input output\n", argv[0]);
        return EXIT_FAILURE;
    }
    in = fopen(argv[1], "rb");
    if (in == NULL) {
        fprintf(stderr, "Cannot open input: %s\n", argv[1]);
        goto cleanup;
    }
    out = fopen(argv[2], "wb");
    if (out == NULL) {
        fprintf(stderr, "Cannot open output: %s\n", argv[2]);
        goto cleanup;
    }
    output_acquired = 1;
    while ((n = fread(buf, 1, sizeof buf, in)) > 0) {
        if (fwrite(buf, 1, n, out) != n) {
            fprintf(stderr, "Write failed: %s\n", argv[2]);
            goto cleanup;
        }
    }
    if (ferror(in)) {
        fprintf(stderr, "Read failed: %s\n", argv[1]);
        goto cleanup;
    }
    status = EXIT_SUCCESS;

cleanup:
    if (out != NULL && fclose(out) == EOF) {
        fprintf(stderr, "Close failed: %s\n", argv[2]);
        status = EXIT_FAILURE;
    }
    if (in != NULL && fclose(in) == EOF) {
        fprintf(stderr, "Close failed: %s\n", argv[1]);
        status = EXIT_FAILURE;
    }
    if (output_acquired && status != EXIT_SUCCESS) {
        if (remove(argv[2]) != 0)
            fprintf(stderr, "Cannot remove incomplete output: %s\n",
                    argv[2]);
    }
    return status;
}

De invoerlus verwerkt alleen bytes die daadwerkelijk zijn gelezen. Een schrijfbewerking die minder bytes schrijft dan gevraagd, springt naar het opruimen; een invoerfout wordt na de lus gecontroleerd. Het sluiten van de uitvoer kan succes alsnog in een fout veranderen. Verwijdering wordt alleen geprobeerd als deze uitvoering de uitvoer met succes heeft geopend, zodat een openingsfout niet leidt tot verwijdering van een niet-gerelateerd bestand. De eis van verschillende bestanden is van belang: "wb" zou de invoer wissen als beide namen naar hetzelfde bestand verwijzen.

Behoud belangrijke bestaande gegevens

Door de uitvoer rechtstreeks te openen kun je het leegmaken niet ongedaan maken. Om waardevolle gegevens te vervangen, schrijf je eerst onder een afzonderlijke tijdelijke naam. Controleer elke schrijfbewerking en de afsluitende sluitbewerking voordat je bestanden hernoemt. Bewaar het origineel onder een back-upnaam totdat het nieuwe bestand is geplaatst; controleer elke hernoeming en verwijdering. Als het plaatsen mislukt, meld dan de locatie van het herstelbare bestand in plaats van het te verwijderen.

Een hulpfunctie moet sluiten wat ze heeft geopend en een resultaat voor succes of een fout teruggeven aan de aanroepende functie. Die kan beslissen of ze het opnieuw probeert of afsluit. Door na elke onvolledige stap EXIT_FAILURE terug te geven, kan een script stoppen vóór een afhankelijke handeling, zoals het verwijderen van het origineel na een back-up.