Compile-time en Runtime zijn de twee programmeertermen die worden gebruikt bij de softwareontwikkeling. Compile-time is het tijdstip waarop de broncode wordt omgezet in een uitvoerbare code, terwijl de runtime het tijdstip is waarop de uitvoerbare code wordt gestart. Zowel de compileertijd als de runtime verwijzen naar verschillende soorten fouten.
Fouten tijdens het compileren
Compilatiefouten zijn de fouten die optreden als we de verkeerde syntaxis schrijven. Als we de verkeerde syntaxis of semantiek van een programmeertaal schrijven, worden de compileerfouten door de compiler gegenereerd. De compiler staat niet toe het programma uit te voeren totdat alle fouten uit het programma zijn verwijderd. Wanneer alle fouten uit het programma zijn verwijderd, genereert de compiler het uitvoerbare bestand.
De compileerfouten kunnen de volgende zijn:
- Syntaxisfouten
- Semantische fouten
Syntaxisfouten
Wanneer de programmeur de syntaxis van een programmeertaal niet volgt, genereert de compiler een syntaxisfout.
Bijvoorbeeld,
int a, b:
De bovenstaande declaratie genereert een compileerfout zoals in C, elke instructie eindigt met een puntkomma, maar we plaatsen een dubbele punt (:) aan het einde van de instructie.
Semantische fouten
De semantische fouten bestaan wanneer de instructies niet betekenisvol zijn voor de compiler.
Bijvoorbeeld,
a+b=c;
De bovenstaande verklaring genereert fouten tijdens het compileren. In de bovenstaande verklaring wijzen we de waarde van 'c' toe aan de sommatie van 'a' en 'b', wat niet mogelijk is in de programmeertaal C, omdat deze slechts één variabele links van de toewijzingsoperator kan bevatten, terwijl rechts van de toewijzingsoperator kan meer dan één variabele bevatten.
De bovenstaande verklaring kan worden herschreven als:
c=a+b;
Runtime-fouten
De runtimefouten zijn de fouten die optreden tijdens de uitvoering en na het compileren. De voorbeelden van runtimefouten zijn delen door nul, enz. Deze fouten zijn niet gemakkelijk te detecteren omdat de compiler niet naar deze fouten verwijst.
Laten we enkele typische C runtime-fouttypen, gevallen en hun mogelijke effecten.
Deling door nul:
Omdat delen door nul is wiskundig ondefinieerbaar , in een poging een geheel getal te delen door nul leidt tot een runtime-fout . Deze fout zorgt ervoor dat het programma crasht of een uitzondering veroorzaakt. Hier is een voorbeeld:
#include int main() { int a = 10; int b = 0; int result = a / b; // Division by zero printf('Result: %d
', result); return 0; } Uitgang:
Floating point exception (core dumped)
Uitleg:
A 'Zwevende-komma-uitzondering' Er wordt een foutmelding weergegeven wanneer het programma een runtime-probleem tegenkomt vanwege deling door nul.
Toegang tot array buiten bereik:
A runtime-fout treedt op wanneer een array-element buiten bepaalde grenzen wordt benaderd. Er treedt een fout op wanneer een index groter is dan de grootte van de array en de wetten voor geheugentoegang worden overtreden. Hier is een voorbeeld:
#include int main() { int arr[5] = {1, 2, 3, 4, 5}; int index = 10; int value = arr[index]; // Accessing array out of bounds printf('Value: %d
', value); return 0; } Uitgang:
Segmentation fault (core dumped)
Uitleg:
gedeeltelijke afhankelijkheid
Het element bij index 10 bevindt zich buiten de grenzen van de array wanneer het programma er toegang toe probeert te krijgen. Als gevolg hiervan is een Er treedt een segmentatiefout op , en het programma eindigt met een fout.
Null Pointer-dereferentie:
A runtime-fout gebeurt wanneer u probeert toegang te krijgen tot een het geheugen van de nulaanwijzer adres, dat bekend staat als derefereren een nulwijzer. Toegang tot nulaanwijzers resulteert in onvoorspelbaar gedrag omdat ze niet naar verwijzen legitieme geheugenlocaties . Hier is een voorbeeld:
#include int main() { int* ptr = NULL; // Null pointer int value = *ptr; // Null pointer dereference printf('Value: %d
', value); return 0; } Uitgang:
Segmentation fault (core dumped)
Uitleg:
int naar string
De poging om minachting een nulwijzer resulteert in a segmentatie fout , waardoor het programma crasht met een foutmelding.
Stapeloverloop:
A stapeloverloop gebeurt wanneer de call-stack groter wordt dan bedoeld en informatie bevat over functie-aanroepen. Een oneindige recursie ontstaat meestal wanneer recursieve functies geen geschikte beëindigingscriteria hebben. Hier is een voorbeeld:
#include void recursiveFunction() { recursiveFunction(); // Recursive call without termination condition } int main() { recursiveFunction(); return 0; } Uitgang:
Segmentation fault (core dumped)
Uitleg:
Het programma start een eindeloze recursie , waardoor de stapel overstroomt en een segmentatiefout ontstaat.
Ongebruikte variabelen:
Omdat niet-geïnitialiseerde variabelen hebben ongedefinieerde waarden , kan het gebruik ervan leiden tot runtimefouten. Het programma kan, afhankelijk van de omstandigheden, verrassende resultaten opleveren of crashen. Hier is een voorbeeld:
#include int main() { int uninitializedVariable; printf('Value: %d
', uninitializedVariable); // Using uninitialized variable return 0; } Uitgang:
Some random value (varies each time)
Uitleg:
In dit voorbeeld is de waarde van an niet-geïnitialiseerde variabele kan elke willekeurige waarde zijn die willekeurig wordt gekozen uit het geheugengebied dat aan die variabele is toegewezen.
Laten we eens kijken naar de verschillen tussen compileertijd en runtime:
| Compileertijd | Looptijd |
|---|---|
| De compileerfouten zijn de fouten die tijdens het compileren worden geproduceerd en die door de compiler worden gedetecteerd. | De runtimefouten zijn de fouten die niet door de compiler worden gegenereerd en die tijdens de uitvoering een onvoorspelbaar resultaat opleveren. |
| In dit geval verhindert de compiler dat de code wordt uitgevoerd als er een fout in het programma wordt gedetecteerd. | In dit geval detecteert de compiler de fout niet en kan dus niet voorkomen dat de code wordt uitgevoerd. |
| Het bevat syntaxis- en semantische fouten, zoals ontbrekende puntkomma's aan het einde van de instructie. | Het bevat de fouten zoals delen door nul, het bepalen van de vierkantswortel van een negatief getal. |
Voorbeeld van een compileerfout
#include int main() { int a=20; printf('The value of a is : %d',a): return 0; } In de bovenstaande code hebben we geprobeerd de waarde van 'a' af te drukken, maar er treedt een fout op. We plaatsen de dubbele punt aan het einde van de instructie in plaats van een puntkomma, dus deze code genereert een compilatiefout.
Uitvoer
Voorbeeld van runtimefout
#include int main() { int a=20; int b=a/0; // division by zero printf('The value of b is : %d',b): return 0; } In de bovenstaande code proberen we de waarde van 'b' door nul te delen, en dit levert een runtime-fout op.
Uitvoer
Conclusie:
Kortom, de perioden van software ontwikkeling bekend als compileertijd En runtime-fouten zijn afzonderlijk en elk heeft een unieke set fouten dat zou kunnen gebeuren. Fouten tijdens het compileren gebeurt wanneer de code tijdens de compilatiestap wordt omgezet in uitvoerbare vorm. Deze fouten omvatten semantische fouten , die produceren onlogisch of absurde code , En syntaxisfouten , die in strijd zijn met de wetten van de programmeertaal. Deze fouten worden geïdentificeerd door de compiler en gerapporteerd, het blokkeren van de executie van de code totdat ze zijn opgelost.
Aan de andere kant, runtime-fouten komen voor wanneer een programma actief is en worden niet door de compiler opgevangen. Ze kunnen het gevolg zijn van verschillende omstandigheden, waaronder delen door nul, foutieve geheugentoegang of andere onvoorziene gebeurtenissen. Runtime-fouten zijn moeilijker te ontdekken en te debuggen, omdat ze vaak resulteren in programmacrashes of onverwacht gedrag. Om runtime-fouten op een elegante manier te beheren en de stabiliteit van het programma te garanderen, gebruiken ontwikkelaars technieken voor foutafhandeling leuk vinden afhandeling van uitzonderingen .