Hallo en welkom terug.
We zitten in een nieuwe sectie.
Dit deel gaat over het schrijven en lezen van bestanden.
We zullen ons concentreren op tekstbestanden, maar ook binaire bestanden komen aan bod.
In deze lezing wil ik alleen een overzicht geven, u vertellen wat een bestand is, en u vertellen hoe het goed te
gebruiken is om persistente gegevens op te slaan.
Dus tot nu toe zijn alle gegevens waartoe ons programma toegang heeft via het geheugen.
We zijn bekend met dit concept van variabelen, structuren, wat dan ook.
Wis alle gegevens die uw programma gebruikt in het geheugen.
En de reden dat het in het geheugen wordt opgeslagen is dat het geheugen heel snel is en je er snel bij
kunt om berekeningen uit te voeren.
Je doet de fetch, execute cyclus, al die dingen.
Dus het toepassingsgebied, maar het is ook beperkt omdat het toepassingsgebied en de verscheidenheid van onze toepassingen,
als het alleen geheugen gebruikt, enigszins beperkt zullen zijn.
We weten dat het geheugen weggaat als het programma weggaat, en dat kan dus zeer beperkend zijn.
Alle serieuze zakelijke toepassingen vereisen meer gegevens dan in het hoofdgeheugen passen.
Het hoofdgeheugen is ook erg klein, recht omhoog.
En tegenwoordig kun je veel geheugen krijgen, 1630 tot 32 gigabyte.
Maar in het verleden, en vooral op embedded apparaten, heb je niet zoveel RAM en als gevolg daarvan zijn je toepassingen
zeer beperkt vanwege ruimte en grootte.
Je wilt eigenlijk alleen variabelen en dat soort dingen in het hoofdgeheugen opslaan.
Ook omdat het hoofdgeheugen weggaat als het programma weggaat.
Je kunt geen gegevens hebben die persistent zijn opgeslagen tijdens reboots.
Alles hangt dus af van het vermogen om gegevens te verwerken die persistent zijn en op een extern apparaat,
zoals een harde schijf, zijn opgeslagen.
Dus u wilt deze mogelijkheid hebben om op de harde schijf op te slaan.
Het is iets langzamer, maar je kunt er veel gegevens op opslaan en grote programma's moeten veel gegevens
opslaan.
C biedt in het headerbestand standaard veel functies voor het schrijven naar en lezen van externe apparaten.
U hoeft geen eigen code te schrijven om de bestanden te lezen en te schrijven, maar u ziet het voordeel
dat toepassingen bieden die de mogelijkheid hebben om gegevens voor langere tijd op te slaan.
Veel voordelen.
Het externe apparaat dat u gebruikt voor het opslaan en ophalen van gegevens is meestal de harde
schijf.
Echter, de headerfile functies die we gaan bespreken kun je gebruiken op elk extern opslagapparaat.
Je zou het dus kunnen gebruiken op een USB-schijf, je zou het kunnen gebruiken op elk extern apparaat dat gegevens opslaat en SSD-schijf
alles met alle voorbeelden.
Tot nu toe gaan alle gegevens die de gebruiker invoert verloren.
Na afloop van het programma wordt dit vluchtig geheugen genoemd.
Wanneer u die term voltijds geheugen hoort, betekent dit dat het geheugen niet persistent is of dat de gegevens niet
persistent zijn.
Het gaat weg als het programma eindigt of als de machine opnieuw opstart.
Dus als de gebruiker het programma wil uitvoeren met dezelfde gegevens, moet hij die telkens opnieuw invoeren, zodat
ze worden hersteld.
Het is erg lastig.
Het beperkt de programmering.
En nogmaals, dit is vluchtig geheugen.
Als je dingen opslaat in bestanden en je slaat ze op de harde schijf op, dan is dat permanente opslag.
Het is er nog steeds.
Zelfs wanneer je de machine opnieuw hebt opgestart of wanneer je programma niet draait.
Dat wordt niet-vluchtig geheugen genoemd omdat het bij een bestand blijft, niet-vluchtige gegevens kan opslaan en meestal wordt
opgeslagen op de schijf of tegenwoordig op een solid state drive en SSD.
Het is een met name genoemd deel van de opslag en de stam standaard IO is een bestand met het gebruik van informatie om te kunnen
lezen en schrijven naar die bestanden.
Maar we gaan dit concept van het schrijven en lezen van gegevens uit een bestand gebruiken voor
permanente opslag, en u gaat merken hoe uw toepassingen veel nuttiger, veel robuuster en veel schaalbaarder worden, omdat
we nu de mogelijkheid hebben om grote hoeveelheden gegevens op te slaan en we ons ook geen zorgen hoeven te maken dat de gegevens
verdwijnen wanneer het programma eindigt of de computer opnieuw opstart.
Dus het zal zeer, zeer voordelig zijn om bestanden te gebruiken.
Een bestand in een Linux- of Windows-besturingssysteem wordt op een bepaalde manier opgeslagen.
Maar wat C betreft, de programmeertaal, is het gewoon een reeks bytes, waarbij elke byte afzonderlijk kan
worden gelezen.
Dit komt overeen met de bestandsstructuur in Unix, maar dat hoeft niet.
Het maakt alleen verschil als je tekstbestanden en vensters leest, omdat je dan misschien extra
tekens hebt waar je je zorgen over moet maken wat betreft de grootte, maar het is gewoon een reeks bytes.
Dus als je een tekstbestand hebt en het heeft meer bytes, kun je die bytes nog steeds lezen.
Je moet alleen begrijpen wat die bytes voorstellen.
Dus dit is hoe een bestand eruit ziet en hoe we het gaan lezen en ernaar schrijven met behulp van de programmeertaal
C.
Het is gewoon een reeks bytes met verschillende offsets.
Het begin van het bestand zou op nul staan, en dan kun je altijd verschillende posities in het bestand
vinden.
Kan vier zijn, het kan vier bij tien twee zijn, er kunnen 100 bytes in.
En dan heb je het einde van het bestand en het einde van het bestand meestal gemarkeerd met een speciale markering genaamd
EOF en een bestand.
Een bestand heeft dus een begin en een einde en een huidige positie.
De huidige positie is zoveel bytes in het begin gedefinieerd.
De huidige positie is waar elke bestandsactie zal plaatsvinden.
Je gaat schrijven of je gaat lezen op die positie.
En we gaan het ook hebben over enkele functies waarmee je de huidige positie in een bestand overal naartoe
kunt verplaatsen.
Zelfs aan het einde, als je wilt lezen aan het einde of tot het einde.
Er zijn twee soorten bestanden.
Er zijn tekstbestanden en binaire bestanden.
Een tekstbestand is gegevens die worden geschreven als een opeenvolging van tekens, georganiseerd als regels.
Elke regel eindigt met een nieuwe regel, en de tekstgegevens kunnen van systeem tot systeem verschillen, afhankelijk van hoe tekens
worden geïnterpreteerd.
Dus bijvoorbeeld, op Windows in DOS heeft elke regel een carriage return en een line feed, dus een backslash R en
een backslash N.
En dus wanneer je de gegevens leest of schrijft, moet je dit begrijpen omdat het formaat een beetje
anders is.
Maar op Linux heb je geen backslash.
R En dus moet je begrijpen hoe tekstgegevens worden geschreven, ook al zijn ze per regel georganiseerd en is het een reeks bytes,
binaire gegevens worden geschreven als een reeks bytes precies zoals ze in het geheugen verschijnen.
Voorbeelden van bestanden met binaire gegevens zijn dus data.
Onze bestanden zoals beeldgegevens of binaire bestanden met muziekcodering zijn niet leesbaar.
Als u zou proberen ze in een tekstverwerker op te roepen omdat het gewoon bytes zijn, gaan we ons in dit deel concentreren
op tekstbestanden, maar u kunt alle gegevens die u wilt naar een bestand schrijven.
Je kunt het schrijven als een reeks bytes en hoe die in het geheugen verschijnen, of je kunt het schrijven als tekst.
Maar zodra het bestand daadwerkelijk is geschreven, bestaat het gewoon uit een reeks bytes, ook
al wordt het weergegeven als tekst.
U kunt tekstbestanden in een editor bekijken, wat de leesbaarheid ten goede komt.
Je moet het formaat van het bestand begrijpen om het te kunnen lezen en dit is waar
ik het over had als je op DOS Windows of Linux draait, waar Windows extra tekens kan hebben wanneer het gegevens schrijft.
Een reeks van 12 bytes in een binair bestand kan dus 12 tekens zijn, het kunnen 12 gehele getallen van acht
bij acht bits zijn of 12 gehele getallen zonder teken.
Binaire branden zijn bijzonder lastig omdat ze gewoon Watson opslaan als het schijnbare geheugen.
Dus in binaire modus is elke bit van het bestand toegankelijk.
Maar om iets uit een bestand te kunnen lezen, moet je begrijpen wat er in staat aan gegevens en hoe het is opgeslagen.
En het kan afhangen van het systeem waarop je draait.
En het hangt er ook vanaf of het tekst of binair is.
Stromen.
C-programma's worden automatisch geopend op drie bestanden in uw naam.
Een stream kan een bestand voorstellen, maar een stream is een meer algemene term die elke vorm van invoer kan voorstellen.
Dus het kan het toetsenbord voorstellen, het kan de console voorstellen, het kan een bestand voorstellen, het kan een
socket voorstellen.
Als je gewend bent aan netwerken zijn streams een meer algemene term, en er zijn drie streams die automatisch
voor je worden geopend in de programmeertaal C.
Eén daarvan is de standaard invoer, en dit is het normale invoerapparaat van uw systeem.
Meestal is dat standaard het toetsenbord.
We hebben de standaard invoer gebruikt als we scan F doen, maar je zou scan off kunnen gebruiken om uit bestanden
te lezen.
Als u de invoerstroom verandert, verandert u misschien de invoerstroom in een bestand standaard uitvoer
dit meestal op het scherm, meestal via de console.
De standaardfout staat ook op het scherm, maar je moet hem meestal omleiden om hem te kunnen zien,
bijvoorbeeld met de ampersand drie of zoiets.
Maar dit zijn de drie uitgangen die ik noemde.
Standaard input is het bestand dat wordt gelezen door guitar en scan F Standaard output wordt gebruikt door output us en print
F we hebben voornamelijk printf gebruikt.
U kunt ook bestanden op het systeem omleiden zodat ze worden herkend als de standaard invoeruitvoer.
Dit is omleiding.
Dit is een besturingssysteemconcept waarbij je gegevens kunt omleiden, de uitvoer bijvoorbeeld naar een bestand kunt sturen, of de invoer kunt
sturen, invoer kunt krijgen van een bestand, in tegenstelling tot standaard.
Hier kunt u de symbolen kleiner dan of groter dan gebruiken.
Het doel van de standaard foutuitvoer is om een logisch gescheiden plaats te bieden voor foutmeldingen.
Dus het is een beetje apart, ook al wordt het op het scherm weergegeven.
Om daar toegang toe te krijgen, moet je een speciaal commando hebben.
De stream is een abstracte weergave van een externe bron of bestemming voor gegevens.
Daarom is het generieker dan bijvoorbeeld een bestand.
Het toetsenbord.
De opdrachtregel op uw weergavebestanden op een schijf.
Dat zijn allemaal voorbeelden van hoe je met stromen werkt.
Streams worden veel belangrijker als je C++ gaat studeren.
De C-bibliotheek biedt functies voor het lezen en schrijven naar en van gegevensstromen, zodat u dezelfde in- en uitvoerfuncties kunt
gebruiken voor het lezen en schrijven van elk extern apparaat dat is gekoppeld aan een stroom.
Daarom zei ik dat je scan F kunt gebruiken om van het toetsenbord te lezen.
U zou ook scan F kunnen gebruiken om uit bestanden te lezen.
Het hangt allemaal af van de invoer, waar de stroom naar toe wijst.
En dus zijn de functies zeer, zeer nuttig en zeer, zeer flexibel om dit te doen.
En dit is dus een overzicht op hoog niveau van wat een bestand is en waarom we het gebruiken, hoe het persistente gegevens
zijn, het is een niet-vluchtig geheugen.
Het blijft bestaan, we gaan het gebruiken en we gaan het standaard IO header bestand gebruiken om er naar te
lezen en te schrijven wanneer we gegevens moeten opslaan voor ons programma en onze programma's worden uiteindelijk een stuk
robuuster, een stuk bruikbaarder, een stuk flexibeler.
Dus in onze volgende lezing zullen we het hebben over het daadwerkelijk implementeren hiervan met behulp van de functies in
de standaard IO header.
Bedankt.