Hallo en welkom. In deze lezing wil ik het hebben over de preprocessor.
We hebben dit concept in eerdere lezingen kort besproken,
voornamelijk als een voordeel.
De belangrijkste reden dat ik er nu vroeg in de klas wat over wil
praten, is omdat het in elk afzonderlijk programma wordt gebruikt.
En ik wil het hebben over de include-richtlijn, een preprocessor-opdracht.
Dus als ik daarover wil praten, moet ik eerst de preprocessor in
het algemeen beschrijven. Dit wordt een beschrijving op hoog niveau.
Terwijl we door de les gaan, zullen we het hebben over meer van de
preprocessor in termen van zijn verschillende richtlijnen enzovoort.
Maar om de basis te begrijpen, is deze preprocessor
een uniek kenmerk van c.
Het is niet gevonden in veel andere talen.
En het is erg voordelig, en je zou moeten proberen het te begrijpen.
En we moeten proberen om zoveel mogelijk te gebruiken.
Het zorgt er in feite voor dat programma's gemakkelijker door de ontwikkelaar kunnen worden ontwikkeld.
Het maakt programma's gemakkelijker te lezen. Het maakt ze gemakkelijker aan te passen en het maakt ze gemakkelijker te porten.
Het biedt dus veel voordelen.
En dus is het belangrijk om een beschrijving te hebben om te begrijpen wat het
is in een vroeg stadium van het leren van c.
Het maakt deel uit van het c-compilatieproces,
maar wordt herkend als speciale instructies.
En net zoals het preprocessor in de naam zegt,
impliceert het dat er iets aan de hand is voordat je de code verwerkt.
Dus analyseert bepaalde uitspraken in uw code voordat
het daadwerkelijk het programma zelf analyseert.
Het doet dingen voordat het compileert, in wezen.
Dus het vertelt je compiler dat, hé, voordat je daadwerkelijk converteert
naar deze code, voordat je de objectbestanden genereert,
voordat je alle koppelingen genereert en uitvoert en het uitvoerbare bestand genereert,
doe dit eerst.
En omdat je dit soort dingen doet voordat je compileert, kun je
dingen optimaliseren en dingen een stuk eenvoudiger maken.
Nu heb je deze preprocessor-opdrachten vaak helemaal bovenaan
je broncode, maar ze
kunnen overal zijn. Ze kunnen overal in uw code worden verspreid.
Een van de belangrijkste waar we het over gaan hebben, is de include.
Dus de manier waarop u preprocessor-statements in uw broncode kunt identificeren, is dat ze
een hekje ervoor hebben, dus ze hebben
dat aantal hekjes.
En dat moet het eerste niet-spatieteken op de regel
zijn om een preprocessor-commando te
zijn, ook wel een preprocessor-instructie genoemd.
Zoals ik al zei, gebruikte onze eerste uitdaging eigenlijk een preprocessor-richtlijn.
Het was de include-richtlijn. We weten dat het een preprocessor-richtlijn is omdat we het hekje hebben gezien.
Wat de include precies doet weten we niet, daar gaan we het in een andere lezing over hebben.
Maar het is een preprocessor-opdracht, het is een preprocessor-richtlijn.
En nogmaals, omdat het zo algemeen wordt gebruikt, in elk
programma, omdat elk programma een include zal hebben, wilde ik
er al vroeg over praten.
Maar het betekent niet alleen dat er een include is.
De pre-processor kan vele, vele andere dingen doen en andere commando's hebben.
Enkele van de dingen waar we het over zullen hebben tijdens deze cursus over de preprocessor zijn zaken
als het kunnen creëren van constanten. Constanten is een concept
waarbij het in wezen een variabele is die nooit van waarde verandert.
Het zijn gegevens die nooit veranderen, zo kun je erover nadenken, want we hebben het nog niet eens over variabelen gehad.
Maar u kunt constanten
in de preprocessor maken en dit optimaliseert uw code, maakt deze efficiënter en sneller.
Er is ook dit concept van een macro, dat op zich een heel ander onderwerp is.
Maar een macro is een andere preprocessor-richtlijn.
En de manier waarop u de macro's kunt maken, is door de instructie definiëren te gebruiken.
En dus zullen we praten over de definitie, we zullen praten over het creëren van constanten.
Maar u moet bekend zijn
met dit preprocessor-concept en deze verschillende dingen gebruiken, zoals include,define, constant.
Opnemen, waar we het in de volgende lezing specifiek over hebben, maar een
voordeel hiervan is dat je je eigen bibliotheekbestanden kunt maken.
En we hadden het over wat een bibliotheek is, een bibliotheek hergebruikt gewoon bestaande code.
Het is dus code die u niet hoeft te schrijven.
De programmeertalen c worden geleverd met een eigen standaardbibliotheek die veel dingen voor
je doet, zoals het weergeven
van uitvoer naar de console, het lezen en schrijven van bestanden,
het afhandelen van streams en allerlei verschillende dingen. Als u bekend bent met java,
kunt u vergelijkbare Java-API's importeren,
interfaces voor applicatieprogrammering.
Andere voorbeelden van een preprocessor-richtlijn zijn voorwaardelijke voorwaardelijke dingen, zoals de if def
the end if, the else
of de in if not definitie-statements, en we zullen
daar ook in meer detail over praten.
Maar al deze preprocessor-richtlijnen helpen bij de efficiëntie van
de code, en ze worden uitgevoerd voordat de compiler daadwerkelijk wordt uitgevoerd.
Het wordt uitgevoerd voordat
enige code objectbestanden of uitvoerbare bestanden heeft gegenereerd.
Maar we zullen dit alles in veel meer details behandelen in toekomstige lezingen.
Ik wilde je er vooraf een klein voorproefje van
geven, omdat we het moeten begrijpen voordat we kunnen begrijpen wat we doen met de
include-instructie waarover we het nu gaan hebben. Dank u.