C-taal voor beginners - hoofdstuk 7

bestandsinput/output

[7.1 een bestand openen] [7.2 een bestand sluiten] [7.3 uitvoer naar een bestand] [7.4 een bestand lezen] [7.5 een bestandsnaam als variabele] [7.6 afdrukken naar de printer]

7.1 een bestand openen

Tot nu toe hebben we alleen met het scherm gewerkt. De grote kracht achter C is het kunnen gebruiken en manipuleren van bestanden. Bekijk het volgende voorbeeld voor het schrijven van data naar een bestand:

#include<stdio.h>
#include<string.h>
int main(void)
{
FILE *fp;
char een_string[25];
int index;

    fp = fopen("TIENLIJNEN.TXT", "w");	/* openen voor schrijven,  lijn 1 (zie tekst) */
    strcpy(een_string, "Dit is een voorbeeldlijn.");

    for (index = 1 ; index <= 10 ; index++)
        fprintf(fp, "%s Lijn nummer %d\n", een_string, index);	/* lijn 2 (zie tekst) */

    fclose(fp);	/* het bestand sluiten */

    return 0;
}

We beginnen zoals altijd met het #include statement voor stdio.h en we includeren ook de header voor de string functies. Daarna definiëren we een paar variabelen, inclusief een nogal vreemd uitziend nieuw type. Het type FILE noemt men een structure en dit is gedefinieerd in het stdio.h bestand. Het wordt gebruikt voor het definiëren van een bestandspointer voor het gebruik in bestandsoperaties. C vereist een pointer naar een FILE type voor het verstrekken van toegang tot een bestand en zoals gewoonlijk kan de naam elke geldige variabelnaam zijn. Veel schrijvers gebruiken fp voor de naam van het eerste voorbeeld van een pointer naar een bestand, dus zullen wij ook zo beginnen.

Voordat we naar een bestand kunnen schrijven moeten we het openen. Wat dit eigenlijk betekent is dat we aan het systeem moeten vertellen dat we een bestand willen schrijven en wat de bestandsnaam is. Dit doen we met de fopen() functie, zoals in het voorbeeld aangegeven. De pointer naar het bestand, fp in ons geval, zal naar de structuur voor het bestand en twee argumenten, die vereist zijn voor deze functie, wijzen. Het eerste argument is de bestandsnaam, het tweede het bestandsattribuut. De bestandsnaam mag eender welke naam zijn, zolang hij maar in regel is met de bepalingen voor naamgeving van uw besturingssysteem (zoals Windows). Hij mag dus kleine letters en hoofdletters bevatten. Allebei de argumenten staan afzonderlijk tussen dubbele qoutes " ", net als bij een string constante (zie lijn 1). Voor dit voorbeeld hebben we de naam TIENLIJNEN.TXT gekozen. Breng het voorbeeld in uw compiler en sla het ergens op. Zorg ervoor dat er in die map geen bestand met de naam TIENLIJNEN.TXT bestaat, anders wordt dit overschreven. Compileer nu het programma en run het. Ga nu naar de directory waar u het bestand opsloeg en het bestand TIENLIJNEN.TXT zou aangemaakt moeten zijn, een tiental bijna identieke regels bevattend.

Merk op dat we niet verplicht zijn om een string constante voor de bestandsnaam te gebruiken, zoals we dat hier deden. Dit werd enkel zo gedaan voor het gemak. We kunnen een string variabele gebruiken die reeds de bestandsnaam bevat en deze dan als het eerste argument van de fopen() functie nemen. Dit zal later in dit hoofdstuk duidelijk worden.

De tweede parameter is het bestandsattribuut en dit kan één van de volgende zijn (de kleine-letter-notatie is verplicht):

modus open voor...
r lezen in tekst modus
w schrijven in tekst modus
a toevoegen in tekst modus
rb lezen in binaire modus
wb schrijven in binaire modus
ab toevoegen in binaire modus
r+ lezen en schrijven in tekst modus
w+ lezen en schrijven in tekst modus
a+ lezen en toevoegen in tekst modus
r+b of rb+ lezen en schrijven in binaire modus
w+b pf wb+ lezen en schrijven in binaire modus
a+b pf ab+ lezen en schrijven in binaire modus

Sommige lijken dus exact hetzelfde te doen. Het verschil zit hem in het feit dat een bestand reeds moet bestaan of niet:

7.1.1 lezen ("r")

In feite zijn er nog extra attributen beschikbaar in C om meer flexibele input en output toe te laten. Wanneer u dit hoofdstuk volledig bestudeert heeft, kan u de documentatie van uw compiler daarover raadplegen. Als er een "r" gebruikt wordt, wordt het bestand geopend voor lezen (reading), een "w" opent een bestand om ernaar te schrijven (writing) en een "a" duid aan dat we data willen toevoegen (appending), aan de data die reeds aanwezig is in het bestand. Een bestand voor lezen openen vereist dat het bestand reeds bestaat. Indien dit niet zo is zal de bestandspointer op NULL gezet worden en dit kan gecontroleerd worden door het programma. In ons huidige voorbeeld is dit niet zo, maar dat kunnen we gemakkelijk doen als volgt:

if(fp == NULL)
{
    printf("Het bestand kon niet geopend worden\n");
    return EXIT_FAILURE;
}

Een degelijke programmeur zal altijd zijn bestandspointers controleren om geen problemen te ondervinden bij het werken met bestanden. In vorige voorbeelden liet ik het even opzij liggen om het niet te ingewikkeld te maken. De EXIT_FAILURE zal zodadelijk besproken worden.

7.1.2 schrijven ("w")

Wanneer een bestand geopend is om te schrijven, wordt het aangemaakt als het nog niet bestaat en zal het gereset worden als het al wel bestaat. Dit heeft als resultaat dat data die reeds aanwezig is gewist zal worden. Als het bestand toch niet geopend kan worden, hetgeen het geval kan zijn als u een alleen-lezen bestand wilt overschrijven, wordt er een NULL teruggestuurd naar de pointer. Dit zou dus best weer getest worden zoals hierboven.

7.1.3 toevoegen ("a")

Een bestand dat geopend is voor toevoegen, zal aangemaakt worden als het nog niet bestaat en het zal dan initieel leeg zijn. Bestaat het wel, dan wordt het data invoer punt op het einde van de data die reeds bestaat geplaatst, zodat nieuwe data er onmiddelijk achter komt te staan. Controleer ook hier uw NULL pointer.

7.2 een bestand sluiten

Om een bestand te sluiten gebruiken we de functie fclose() met de bestandspointer tussen de ronde haken. Dit is zeer simpel en misschien niet altijd nodig, aangezien het systeem probeert alle geopende bestanden te sluiten alvorens naar het besturingssysteem terug te keren. Ik raad u echter aan om elk bestand dat u opent ook weer te sluiten. Dit is een goede gewoonte en helpt u ook herinneren welke bestanden er op het einde van programma allemaal geopend zijn.

U kan een bestand openen voor schrijven, het sluiten, het openen voor lezen, het sluiten, het openen voor toevoegen, enz... . Elke keer zou u dezelfde pointer kunnen gebruiken, maar dit is niet verplicht. De bestandspointer is simpelweg een handig middel om naar een bestand te wijzen en u beslist naar welk bestand hij wijst.

Verwijder het bestand TIENLIJNEN.TXT nog niet. We zullen het verder in dit hoofdstuk nog gebruiken.

7.3 uitvoer naar een bestand

7.3.1 fprintf()

Dit functioneert op bijna dezelfde manier als we dat tot nu toe gewoon waren. Het verschil is de nieuwe functienaam en de toevoeging van de bestandspointer als een van de functieargumenten. Op lijn 2 van ons programma vervangt fprintf() het bekende printf() en onze pointer naar het bestand is het eerste argument. De rest van het statement is identiek aan het printf() statement. U kan dus net doen alsof u naar het scherm wilt schrijven, maar nu voegt u de bestandspointer toe, zodat de compiler weet naar welk bestand hij moet schrijven.

7.3.2 één karakter per keer

#include <stdio.h>
#include <string.h>
#include <stdlib.h>	/* voor de EXIT_SUCCESS */

int main(void)
{
FILE *point;
char anderen[35];
int indexer, teller;

    strcpy(anderen, "Extra lijnen.");
    point = fopen("tienlijnen.txt", "a");
    if (point == NULL)
    {
        printf("Het bestand kon niet geopend worden\n");
        exit (EXIT_FAILURE);
    }

    for (teller = 1 ; teller <= 10 ; teller++)
    {
        for (indexer = 0 ; anderen[indexer] ; indexer++)
            putc(anderen[indexer], point);	/* één karakter outputten */
        putc('\n', point);	/* een linefeed outputten */
    }
    fclose(point);

    return EXIT_SUCCESS;
}

Het programma begint met de #include statements. Daarna worden enkele variabelen gedefininieerd, inclusief een bestandspointer. Deze pointer werd point genoemd, maar we zouden eender welke naam kunnen gebruiken, zolang deze voldoet aan de regels van variabelnamen. Daarna definiëren we een string van karakters om in de output functie te gebruiken met een strcpy(). We zijn dan klaar om het bestand te openen voor toevoegen en dit doen we dan ook met de fopen() functie, behalve dat we dit keer kleine letters voor de bestandsnaam gebruiken. Dit doe ik hier enkel om te illustreren dat sommige systemen, zoals Windows en Dos, geen onderscheid maken tussen kleine letters of hoofdletters. Merk op dat het bestand voor toevoeging zal geopend worden en de uitvoer zal na de uitvoer van ons vorige programma komen staan, tenminste als u het programma in dezelfde directory compileert en runt. Als het bestand niet geopend kan worden, zal er een NULL waarde teruggegeven worden door de fopen() functie.

De constante EXIT_FAILURE is gedefinieerd in het stdlib.h bestand en is meestal gedefinieerd om de waarde 1 te hebben. De constante EXIT_SUCCESS is ook gedefinieerd in het stdlib.h bestand en heeft meestal de waarde 0. Het besturingssysteem op uw computer kan deze teruggegeven waarden gebruiken om te bepalen of het programma normaal tot zijn einde kwam en kan dan de nodige acties ondernemen, indien nodig. Bijvoorbeeld: als een tweedelig programma wordt uitgevoerd en het eerste deel geeft een error (fout) terug, dan is er geen behoefte om het tweede deel van het programma uit te voeren. Uw compiler werkt waarschijnlijk in verschillende stappen, waarbij elke uitvoering afhangt van het succes van de vorige stap.

Ons programma is eigenlijk niet meer dan twee geneste for() loops. De buitenste loop is een teller tot tien zodat we de binnenste loop tien keer doorlopen. Deze roept de functie putc() herhaaldelijk op totdat een karakter string genaamd anderen nul geworden is. Dit is de afsluitende null voor de string.

Het deel van het programma waarin we geïnteresseerd zijn is the putc() functie. Dit voert één karakter per keer uit, waarbij het karakter het eerste argument tussen de haken is en de bestandspointer het tweede en laatste argument. Waarom de ontwikkelaar van C de pointer eerst plaatste in de fprintf() functie en als laatste in de putc() functie is een goede vraag. Dit is een punt tot discussie, waar we niet op in zullen gaan.

Wanneer de tekstlijn anderen uitgeput is, is er een nieuwe lijn (newline) nodig omdat deze niet in bovenstaande definitie opgenomen was. Een enkele putc() wordt dan uitgevoerd om het "\n" karakter, wat hetzelfde is als een return op het toetsenbord, terug te geven en een linefeed te doen.

Vanaf het moment dat de buitenste loop tien keer doorlopen is wordt het bestand gesloten en het programma eindigt. Compileer en run dit programma en zorg dat u het goed begrijpt. Normaal zou na het runnen TIENLIJNEN.TXT een paar extra lijnen moeten bevatten. Telkens u het runt komen er bij.

7.4 een bestand lezen

7.4.1 één karakter per keer

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

int main(void)
{
FILE *grappig;
int c;

    grappig = fopen("TIENLIJNEN.TXT", "r");

    if (grappig == NULL)
    {
        printf("Het bestand bestaat niet\n");
        exit (EXIT_FAILURE);
        getchar();
    }
    else
    {
        do
        {
            c = getc(grappig);	/* één karakter van het bestand opnemen */
            putchar(c);	/* het karakter op het scherm tonen */
        } while (c != EOF);	/* herhalen tot EOF (end of file) */
    }
    fclose(grappig);

    return EXIT_SUCCESS;
}

Dit is ons eerste programma dat van een bestand kan lezen. Het begint met de ondertussen bekende #include statements, een paar data definities en het statement om een bestand te openen. Dit vereist geen extra uitleg, behalve voor het feit dat we hier "r" gebruiken omdat we van het bestand willen kunnen lezen. We controleren in dit voorbeeld of het bestand bestaat en indien dit zo is executeren we het algemene gedeelte. Als het niet bestaat drukken we een boodschap af en stoppen we. De pointer zal in dit geval weer op NULL gezet worden. U ziet dat ik hier voor de verandering ook een getchar() toegevoegd heb, na de foutmelding. Dit doe ik omdat anders de boodschap gedrukt wordt en er onmiddelijk afgesloten wordt, zonder dat u iets ziet. Met de getchar() wacht het programma op een return alvorens te stoppen. Dit is een zeer geliefde methode om ervoor te zorgen dat een programma tijdens het compileren te bekijken is alvorens alles gebeurd is. In de vorige voorbeelden kan u dit zelf toepassen.

Het hoofddeel van ons programma is een do while() loop waarin één enkel karakter van het invoerbestand wordt gelezen en getoond wordt op het scherm, totdat een EOF ('end of file' of 'einde van het bestand') wordt gevonden. Het bestand wordt dan gesloten en het programma stopt.

OPGEPAST

Op dit moment moeten we opletten voor één van meest voorkomende en verbijsterende problemen bij het programmeren in C. De variabele die teruggegeven wordt bij de getc() functie is een karakter, dus kunnen we een char variabele gebruiken voor dit doel. Er is een probleem dat zich hier zou kunnen ontwikkelen indien we een unsigned char zouden gebruiken, omdat C een -1 teruggeeft voor een EOF. Een unsigned char type variabele kan geen negatieve waarden bevatten, maar enkel de waarden van 0 tot 255, dus wordt er een 255 teruggeven voor een -1, wat nooit op de juiste manier kan vergeleken worden met de EOF. Dit is een zeer frustrerend probleem als men het zelf zou moeten vinden. Het programma zal nooit de EOF vinden en daarom zal de loop nooit eindigen. Dit kan echter voorkomen worden. Gebruik altijd een int type variabele als de return een EOF kan zijn, omdat een int altijd signed (positief en negatief) is. Volgens de ANSI-C standaard kan een char ofwel als signed, ofwel als unsigned toegepast worden, door welk type van compiler dan ook.

Sommige compilers gebruiken een char type dat niet 8 bits lang is. Als uw compiler een ander aantal bits dan 8 gebruikt voor het char type, dan gelden dezelfde mogelijke problemen. Gebruik geen unsigned type als u op een EOF moet controleren, teruggeven door de functie, omdat EOF meestal als -1 gedefinieerd wordt en dit dus niet zal passen. Er schuilt echter nog een ander probleem in ons programma, maar daar zullen we ons zorgen om maken als we bij het volgende programma komen en we zullen het oplossen met het daaropvolgende programma.

Nadat u het voorbeeld compileerde en runde zou het een goede oefening zijn om de naam van TIENLIJNEN.TXT te veranderen om te controleren of de NULL test ook werkt zoals we het bedoelden. In een echt produktieprogramma zou u het programma eigenlijk niet beëindigen. U zou de gebruiker de mogelijkheid kunnen geven om een andere bestandsnaam op te geven. We hebben interesse in het illustreren van de basis van de bestands-handelingstechnieken, dus gebruiken we een zeer eenvoudige error-manipulatie methode.

7.4.2 één woord per keer

#include <stdio.h>

int main(void)
{
FILE *fp1;
char eenwoord[100];
int c;

    fp1 = fopen("TIENLIJNEN.TXT", "r");

    do
    {
        c = fscanf(fp1, "%s", eenwoord);	/* één woord uit het bestand opnemen */
        printf("%s\n", eenwoord);	/* het woord op het scherm */
    } while (c != EOF);	/* herhalen tot EOF */

    fclose(fp1);

    return 0;
}

Dit programma is bijna identiek aan het vorige, behalve dat we nu één woord per keer opnemen uit het bestand, met de fscanf() functie. Deze functie zal, net zoals onze bekende scanf() functie, stoppen met lezen zodra er een een witruimte of een newline karakter gevonden wordt. Dit drukken we dan telkens af met een gewone printf(). U kan dit zien als u het compileert en runt, in dezelfde map als het bestand TIENLIJNEN.TXT, maar eerst bestuderen we nog een programmeerprobleem.

Het is aan u om op de juiste manier een controle in te voegen voor het openen van het bestand. Zorg ook voor een juiste respons indien het niet geopend kan worden. Een betekenisvolle respons is om simpelweg een foutboodschap te tonen en te "exiten" naar het systeem, zoals we in ons vorige voorbeeld al deden.

DIT IS EEN PROBLEEM

Een gedetailleerde kijk op ons programma zal onthullen dat wanneer we data inlezen en de EOF vinden, we iets afdrukken vooraleer we op de EOF controleren en daardoor een extra lijn afdrukken. Wat we meestal afdrukken is hetzelfde dat afgedrukt werd de vorige keer dat we door de loop gingen, aangezien dit nog in de buffer eenwoord zit. Daarom moeten we op de EOF controleren, voordat we de printf() functie uitvoeren. In ons volgende programma wordt dit toegepast.

Compileer en run het programma dat we aan het bespreken waren en observeer de output. Als u TIENLIJNEN.TXT niet veranderde zullen de woorden uit dit bestand één voor één op het scherm getoond worden, met als laatste twee identieke woorden. Dit komt door het probleem dat we zonet besproken. Merk op dat sommig compilers de buffer ledigen na het printen, dus het kan zijn dat u een extra lege lijn als laatste krijgt, in plaats van twee dezelfde woorden.

HET PROBLEEM OPLOSSEN

int main(void)
{
FILE *fp1;
char eenwoord[100];
int c;

    fp1 = fopen("TIENLIJNEN.TXT", "r");

    do		/* lijn 1 (zie tekst) */
    {
        c = fscanf(fp1, "%s", eenwoord);
        if (c != EOF)
            printf("%s\n", eenwoord);
    } while (c != EOF);		/* lijn 2 (zie tekst) */

    fclose(fp1);

    return 0;
}

Compileer en run dit programma en u zal zien dat het extra woord niet verschijnt, omdat we een extra controle op de EOF inbouwden in het midden van de loop. Dit was drie programma's terug al een probleem, maar ik koos ervoor om er daar nog niet op in te gaan omdat de fout niet zo voor de hand lag. Ook in dit programma is er weer geen openingscontrole, maar u weet ondertussen hoe u dat zelf kan doen.

Een ervaren C-programmeur zou niet de code gebruiken die wij hier gebruikten, omdat c tweemaal vergeleken wordt met EOF, elke keer als de loop uitgevoerd wordt. We gebruikten deze methode omdat ze makkelijk te begrijpen is, maar hoe meer ervaring u opdoet, hoe meer u gebruik zal willen maken van meer efficiënte methodes, zelfs als deze moeilijker te lezen en begrijpen zijn. Een ervaren C-programmeur zal de volledige structuur van lijn 1 t.e.m. 2 vervangen door:

while((c = fscanf(fp1, "%s", eenwoord)) != EOF)
{
    printf("%s\n", oneword);
}

Er is geen twijfel mogelijk dat deze code moeilijker te lezen is, maar als u het nauwkeurig bekijkt ziet u dat ze identiek is aan de code in ons programma en dat de extra controle niet meer nodig is. Alhoewel meer efficiënt, is het niet duidelijk of de kleine tijdswinst de slechte leesbaarheid waard is. Stel dat uw programma tien milliseconden bespaart bij het lezen van een bestand dat één keer per dag gebruikt wordt, en het kost de programmeur een uur langer om uw code aan te passen, een jaar nadat ze geschreven werd. Dan zal u weinig voordeel halen uit de korte methode. U zal veel soortgelijke beslissingen moeten maken tijdens het schrijven van een programma.

7.4.3 een volledige lijn

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

int main(void)
{
FILE *fp1;
char eenwoord[100];
char *c;

    fp1 = fopen("TIENLIJNEN.TXT", "r");
    if (fp1 == NULL)
    {
        printf("Het bestand kon niet geopend worden\n");
        exit (EXIT_FAILURE);
    }

    do
    {
        c = fgets(eenwoord, 100, fp1); /* neemt een volledige lijn uit het bestand */
        if (c != NULL)
            printf("%s", eenwoord);
    } while (c != NULL);

    fclose(fp1);

    return EXIT_SUCCESS;
}

Dit programma lijkt hard op onze vorige voorbeelden, behalve dat we nu een volledige lijn inlezen van het bestand. We gebruiken fgets() wat een volledige lijn opneemt inclusief het newline karakter "\n", in een geheugenbuffer. De buffer is het eerste argument in de functieaanroep. Het maximum aantal karakters dat per lijn gelezen mag worden is het tweede argument. Deze functie zal karakters in de buffer inlezen tot er een newline karakter gevonden wordt, of tot het maximum aantal karakters - 1 bereikt wordt. Het laatste wordt gebruikt voor het null karakter. Wanneer de EOF gevonden wordt, wordt er een NULL teruggegeven. In ons voorbeeld zal pointer c dan de waarde NULL krijgen. Onthoud dat NULL als 0 gedefinieerd is in uw stdio.h bestand.

Wanneer we merken dat de pointer c de waarde NULL gekregen heeft kunnen we stoppen met het verwerken van data, maar we moeten dit controleren voordat we printen, net zoals in ons vorige programma. Als laatste, natuurlijk, sluiten we het bestand.

7.5 een bestandsnaam als variabele

Bekijk het volgende programma als een voorbeeld voor het lezen van een willekeurig bestand:

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

int main(void)
{
FILE *fp1;
char eenwoord[100], bestandsnaam[25];
char *c;

    printf("Geef de bestandsnaam -> ");
    scanf("%s", bestandsnaam); /* de gekozen bestandsnaam opnemen */
    fp1 = fopen(bestandsnaam, "r");
    if (fp1 == NULL)
    {
        printf("Het bestand kon niet geopend worden\n");
        exit (EXIT_FAILURE);
    }

    do
    {
        c = fgets(eenwoord, 100, fp1);
        if (c != NULL)
            printf("%s", eenwoord);
    } while (c != NULL);

    fclose(fp1);

    return EXIT_SUCCESS;
}

Dit programma vraagt de gebruiker om een bestandsnaam en leest deze in door hem in een string op te slaan. Daarna wordt het bestand geopend om te lezen. Het volledige bestand wordt dan ingelezen en getoond op het scherm. U zou de rest moeten begrijpen, dus worden er geen extra opmerkingen gemaakt.

Compileer en run dit programma. Wanneer het een bestandsnaam vraagt geeft u een naam en extensie in van een bestand dat tekst bevat. Dit kan zelfs een C-bronbestand zijn. Bij het ingeven van de bestandsnaam gelden dezelfde regels als bij de Dos-prompt. D.w.z. dat u een pad kan opgeven zoals "C:\windows\desktop\mijn_tekst_bestand.txt". In onze vorige programma's gebruikten we altijd slechts de bestandsnaam, waardoor deze in dezelfde directory als het programma moest staan. Ook hier kunt u een volledig pad opgeven. Let op: in een string wordt de backslash \ weergegeven door de escape sequentie toe te passen:

fp1 = fopen("c:\\windows\\desktop\\tienlijnen.txt", "r");

Indien u Windows gebruikt zal het volgende waarschijnlijk ook toegelaten worden:

fp1 = fopen("c:/windows/desktop/tienlijnen.txt", "r");

7.6 afdrukken naar de printer

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

int main(void)
{
FILE *grappig, *printer;
int c;

    grappig = fopen("TIENLIJNEN.TXT", "r");  /* inputbestand openen */
    if (grappig == NULL)
    {
        printf("Het bestand kon niet geopend worden\n");
        getchar();
        exit (EXIT_FAILURE);
    }

    printer = fopen("PRN", "w");      /* printerbestand openen */
    if (printer == NULL)
    {
        printf("De printer is niet beschikbaar \n");
        getchar();
        exit (EXIT_FAILURE);
    }

    do
    {
        c = getc(grappig);	/* één karakter van het bestand opnemen */
        if (c != EOF)
        {
            putchar(c);	/* op het scherm tonen */
            putc(c, printer);	/* het karakter afdrukken op de printer */
        }
    } while (c != EOF);		/* herhalen tot EOF */

    fclose(grappig);
    fclose(printer);

    return 0;
}

Dit programma is een voorbeeld van hoe we naar de printer kunnen afdrukken. Het zou geen verassingen moeten opleveren dus gaan we er snel overheen.

Opnieuw openen we TIENLIJNEN.TXT om te lezen en we openen PRN om te schrijven. Printen is identiek aan het schrijven van data naar een schijf behalve dat we een standaard naam gebruiken als bestandsnaam. Veel C compilers gebruiken het gereserveerde woord PRN dat de compiler instructeert om de uitvoer naar de printer te sturen. Er zijn andere namen als LPT, LPT1 of LPT2. Raadpleeg de documentatie bij uw compiler. Heeft u een nogal nieuwe compiler kan de vooraf gedefinieerde pointer stdprn ook mogelijk zijn. Indien u het programma runt en u krijgt de foutboodschap voor de printer, probeer dan LPT1. Lukt dit nog niet dan kan het nuttig zijn om de softwarematige instellingen van uw printer na te kijken voor de juiste printerpoort. Vergeet ook niet om uw printer aan te zetten.

Het programma is simpelweg een loop waarin een karakter ingelezen wordt en als het niet EOF is, wordt het getoond en afgedrukt. Merk op dat een goede programmeur beide bestandspointers controleert om te verzekeren dat de bestanden geopend kunnen worden. U kan nu TIENLIJNEN.TXT verwijderen, we zullen het verder niet meer gebruiken.

opdrachten

1. Leesopdracht: besteed wat tijd aan het bestuderen van de documentatie bij uw compiler en lees over de volgende functies. U zal er niet alles over begrijpen, maar u zal een goed idee krijgen van hoe bibliotheekfuncties gedocumenteerd zijn. Bekijk ook de declaratie voor het woord FILE.

fopen(), fclose(), putc(), putchar(), printf(), fprintf(), scanf(), fscanf(), fgets()

2. Schrijf een programma dat een bestandsnaam vraagt voor een invoerbestand en een bestand om naar te schrijven en ze beide opent, tezamen met een bestand naar de printer. Gebruik een loop die telkens één karakter leest en dit uitvoert naar het bestand, de printer en het scherm. Stop bij EOF.

3. Schrijf een programma dat een bestandsnaam vraagt. Lees het bestand lijn per lijn in en toon het op het scherm, met lijnnummers.

4. Tip: plaats de regel "FILES=40" in uw config.sys bestand, dat onder de C: root staat. Dan kan u zeker genoeg bestanden tegelijk openen en bewerken met een programma. Indien u deze regel er niet staat kan u normaal gezien zo'n acht bestanden tegelijk openen.

referenties

[C Language Tutorial]

Gordon Dodrill

[C FAQ]

Steve Summit

 

Verder naar hoofdstuk 8

Terug naar inleiding