Hallo en welkom.
In deze video wil ik je uitleggen wat compilerfouten zijn.
Tot zover.
Juist.
We hebben wat code geschreven en we hebben gemerkt dat we in het uitvoervenster van de build een compileeropdracht
geven en we weten wanneer we fouten hebben.
Juist.
Meestal is er een mooie beschrijving die zegt dat er een fout in je code zit, maar wat betekent
dat precies?
Dus wanneer je code schrijft voor een programmeertaal, zijn programmeertalen zeer, zeer strikt.
Ze hebben regels.
En je moet die regels volgen om een programma uitvoerbaar te krijgen.
Een compiler controleert de syntaxis van de code.
En als het correct is en er geen semantische fouten zijn, zal het uit de broncode, machinetaal code genereren,
en kun je een programma uitvoeren.
En dus moet je deze regels volgen en het zijn zeer gedetailleerde regels.
En dus moet je zeer gedetailleerd zijn.
Compilerfouten kunnen dus in twee vormen voorkomen.
Ze kunnen de vorm aannemen van een syntaxisfout of een semantische fout.
Een syntax fout is wanneer er iets mis is met de structuur van de code, je volgt
niet de regels van de taal wat betreft de syntax, toch?
Je zet de haakjes niet op de juiste plaats.
Je voegt niet al je uitspraken toe met een puntkomma.
Je spelt geen sleutelwoorden verkeerd.
Dit zijn allemaal veel voorkomende voorbeelden.
Een puntkomma is heel gebruikelijk als je voor het eerst begint.
Dus als je een variabele declareert en je wijst hem toe aan vijf, maar je hebt geen puntkomma aan het eind,
dan is dat een syntaxisfout.
Er is iets mis met die structuur.
Hetzelfde als wanneer je een printf statement zou gebruiken en je zegt een printf statement binnen dubbele aanhalingstekens,
maar je vergeet het einde, dubbele aanhalingstekens.
Dat is een syntaxisfout.
En dus is er iets mis met die structuur in de compiler, wanneer hij je broncode scant en deze
fout vindt, zal hij meestal een beschrijvende foutmelding geven die je in de juiste richting kan wijzen en meestal
ook het regelnummer geeft.
En dat hebben we in eerdere video's gezien.
Het andere type fout dat de compiler kan opvangen is een semantische fout.
Het pakt niet altijd semantische fouten als het logische fouten zijn, maar semantisch betekent meestal dat er iets
mis is met de betekenis.
De bedoeling van het programma.
Dus, bijvoorbeeld, als je twee variabelen A en B zou toevoegen, maar die variabelen waren van verschillende
types en het had geen zin, toch?
Het heeft geen zin om A en B toe te voegen.
De compiler kan deze semantische fouten soms opvangen.
Andere semantische fouten hebben te maken met logica en die gaan we bespreken.
En de compiler vindt die niet altijd.
De structuur klopte en alles was in orde met de structuur, maar logisch gezien klopte er iets niet.
Er zit een fout in de logica van de code.
Dus als je denkt aan semantische fouten, wat de compiler kan vangen, dan heeft dat
meer te maken met het vangen van types en dingen die je niet mag doen, met verschillende regels
van de taal, zoals variabele types.
En dus laten we nu een kijkje nemen in code light om enkele veel voorkomende voorbeelden te zien van enkele syntaxis- en semantische fouten
in de programmeertaal C.
Dus hier zijn we in code light met een eenvoudige Hello world-applicatie.
Dit is code die voor u wordt gegenereerd vanuit uw projectinstellingen.
Als je het hebt opgeslagen als een sjabloon.
Erg simpele code toch?
En wanneer u dit bestand compileert, zal het u vertellen of u al dan niet syntaxfouten hebt.
Je kunt weer rechts klikken en zeggen compileren.
En nu hebben we geen fouten, toch?
Maar syntactisch volgen we alle regels.
Maar de syntax omvat, nogmaals, de hele structuur van de code.
Dus als je geen puntkomma hebt of geen pondsymbool voor een include en je probeert het te
compileren.
Je gaat zien dat er een fout is en meestal heeft de compiler error een soort van betekenis.
Naarmate je meer en meer code schrijft en meer en meer oefent, zullen deze compilers niet meer zo stompzinnig
zijn.
Ze zullen niet zo onbeschrijvend zijn dat je er bekend mee bent, zoals bijvoorbeeld,
deze fout zegt dat we een fout hebben op regel één, toch?
En zo is het leuk.
Je kunt hierop dubbelklikken.
Het zal naar die fout gaan, maar het zegt verwacht is gelijk aan weet puntkomma.
Het vertelt je niet echt wat er mis is.
Weet je, door programmeer oefening realiseer je je, oh, ik ben het pond symbool vergeten.
Dus sommige compilerfouten zijn niet zo beschrijvend als je zou willen als je nieuw bent in het programmeren.
Dus dat voeg je toe, dat pondsteken, je compileert opnieuw en je kunt aan de slag.
Als je standaard i o verkeerd gespeld hebt, kan hij hem soms niet vinden.
Dus je slaat het op en je hercompileert het en je ziet een foutmelding die iets beschrijvender is.
Toch?
Geen bestand of map Stdio. h dat je zegt, oh, misschien heb je het verkeerd gespeld.
Dus spelfouten zijn veel voorkomende fouten.
Je weet wel, dingen niet in het juiste perspectief plaatsen in termen van verkeerde haakjes.
Weet je, je vergeet een haakje, weet je, nogmaals, je compileert opnieuw.
Laten we eens kijken hoe die fout eruit ziet.
Nogmaals, dat is niet super beschrijvend.
Het zegt, weet je, er is eigenlijk een haakje voor het einde van de accolade omdat het niet weet
dat het denkt dat dit rechter haakje hier ergens gaat eindigen.
Het kan je niet altijd precies vertellen wat er aan de hand is.
Dus haakjes en ontbrekende accolades zijn soms niet zo beschrijvend.
Maar als er een puntkomma ontbreekt, is dat vrij eenvoudig.
Die compileerfout vertelt je precies wat er aan de hand is.
De verwachte puntkomma voor de return wijst je zelfs naar waar je die puntkomma moet plaatsen.
Dus je kunt daar dubbel op klikken, een puntkomma plaatsen als je een dubbel aanhalingsteken mist en opnieuw compileren.
Toch?
Je ziet nu iets dat in principe zegt, afsluitende dubbele aanhalingstekens.
En nogmaals, het wijst je een beetje naar waar het eerste citaat gebeurt en het geeft je meerdere
fouten, juist, terwijl je er eigenlijk maar één hebt.
Dus je had dat dubbele citaat en je bent klaar om te gaan.
Deze main zegt dat je een int moet teruggeven.
Wat als je eigenlijk zou proberen om iets terug te geven zoals binnen tussen dubbele aanhalingstekens?
Nogmaals, je volgt die structuur van de taal niet en het vertelt je in feite dat je een karakteraanwijzer
teruggeeft van een functietype.
Nogmaals, deze compileerfouten zijn nu misschien niet logisch, maar naarmate u meer en meer code
schrijft, zullen ze steeds duidelijker worden.
Maar het gaat erom die structuur te volgen.
Nu, als je dingen probeert te doen die het syntactisch zinvol maken, maar de betekenis klopt niet.
Dus stel bijvoorbeeld dat we een F afdrukken en dan proberen een rekenkundige bewerking uit te voeren zoals
delen door acht of delen door zeven.
We slaan het op en compileren het en nu zien we meer een semantische fout waar we een delingssymbool hebben na de dubbele aanhalingstekens.
Je weet waar het eigenlijk puntkomma C verwachtte. Voornamelijk syntaxisfouten, semantische fouten.
De betekenis van de code heeft meestal te maken met logica.
Niet zoveel semantische fouten komen meer voor in een taal als C plus als je gebruikt.
Objecten.
Let dus op syntaxfouten van de compiler.
Gewone dingen die verkeerd gespeld worden.
Trefwoorden die je haakjes niet beëindigen wanneer je ze begint blokken code wanneer je het
eind en begin blok niet hebt En je kunt meerdere fouten hebben, toch?
Dus laten we zeggen dat we Hello world hebben.
We missen een puntkomma.
We sturen een string terug.
Weet je, we missen een beugel, weet je, en we bouwen het.
En dit is een vrij klein programma.
Maar als we het nu proberen te compileren, zien we meerdere fouten, toch?
Twee fouten.
En het is best lastig, waar moet ik beginnen?
Meestal los je de eerste fout op, want soms kan één fout meer fouten veroorzaken.
U wilt dus altijd kijken naar de compilerfout helemaal bovenaan en die eerst oplossen.
Dus je wilt die op regel vijf repareren, toch?
En dan wil je misschien die op regel zes daarna herstellen en opnieuw compileren.
En nu staat er Jason.
Dus nu kunt u zeggen: stuur nul terug, maar repareer altijd eerst die eerste fout voordat u de volgende fouten repareert,
want de ene kan de andere veroorzaken.
En trouwens, we zullen altijd fouten hebben in onze code.
Zelfs de meest doorgewinterde programmeurs zullen syntaxfouten hebben.
En dus zijn er vaak fouten.
Wat echt belangrijk is, is het begrijpen van de boodschappen die van de compiler komen om je te vertellen hoe
je ze kunt corrigeren.
En nogmaals, dat komt in de praktijk.
We zullen het in toekomstige video's meer hebben over compilers, gemeenschappelijke compilers, maar probeer er gewoon
voor te zorgen dat je de structuur van de taal volgt terwijl je hem leert, de syntactische talen enzovoort.
In de volgende lezingen zullen we het hebben over hoe we verschillende soorten fouten kunnen hebben.
Ik had het over logische fouten.
We kunnen ook een beetje praten over waarschuwingen.
We zullen het ook hebben over linker errors en runtime errors.
Bedankt.