TechCodeview

Compile-time och Runtime är de två programmeringstermer som används i mjukvaruutvecklingen. Kompileringstid är den tidpunkt då källkoden konverteras till en körbar kod medan körtiden är den tidpunkt då den körbara koden börjar köras. Både kompileringstiden och körtiden hänvisar till olika typer av fel.

Fel vid kompilering

Kompileringsfel är de fel som uppstod när vi skriver fel syntax. Om vi ​​skriver fel syntax eller semantik för något programmeringsspråk, kommer kompileringsfelen att kastas av kompilatorn. Kompilatorn tillåter inte att köra programmet förrän alla fel har tagits bort från programmet. När alla fel har tagits bort från programmet kommer kompilatorn att generera den körbara filen.

Kompileringsfelen kan vara:

• Syntaxfel
• Semantiska fel

Syntaxfel

När programmeraren inte följer syntaxen för något programmeringsspråk, kommer kompilatorn att kasta syntaxfelet.

Till exempel,

int a, b:

Ovanstående deklaration genererar kompileringstidsfelet som i C, varje sats slutar med semikolon, men vi sätter ett kolon (:) i slutet av satsen.

Semantiska fel

De semantiska felen finns när satserna inte är meningsfulla för kompilatorn.

Till exempel,

a+b=c;

Ovanstående uttalande ger ett kompileringsfel. I ovanstående uttalande tilldelar vi värdet av 'c' till summeringen av 'a' och 'b' vilket inte är möjligt i programmeringsspråket C eftersom det bara kan innehålla en variabel till vänster om tilldelningsoperatorn medan höger om tilldelningsoperatorn kan innehålla mer än en variabel.

Ovanstående uttalande kan skrivas om som:

c=a+b;

Körtidsfel

Runtime-felen är de fel som uppstår under körningen och efter kompileringen. Exemplen på runtime-fel är division med noll, etc. Dessa fel är inte lätta att upptäcka eftersom kompilatorn inte pekar på dessa fel.

Låt oss utforska några typiska C runtime error typer, fall och deras möjliga effekter.

Dividera med noll:

Eftersom division med noll är matematiskt odefinierbar , försöker dividera ett heltal med noll leder till en körtidsfel . Detta misstag gör att programmet kraschar eller skapar ett undantag. Här är ett exempel:

 #include int main() { int a = 10; int b = 0; int result = a / b; // Division by zero printf('Result: %d
', result); return 0; } 

Produktion:

 Floating point exception (core dumped) 

Förklaring:

A 'Flytande komma undantag' felmeddelande produceras när programmet stöter på ett körtidsproblem på grund av division med noll.

Åtkomst till Array Out of Bounds:

A körtidsfel inträffar när ett arrayelement nås utanför vissa gränser. Ett fel inträffar när ett index är större än arrayens storlek och lagar för minnesåtkomst bryts. Här är ett exempel:

vad är linux-filsystemet

 #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; } 

Produktion:

 Segmentation fault (core dumped) 

Förklaring:

Elementet kl index 10 är bortom gränserna för arrayen när programmet försöker komma åt den. Som ett resultat, a segmenteringsfel uppstår , och programmet avslutas med ett fel.

Null Pointer Dereference:

A körtidsfel händer när du försöker komma åt en nollpekarens minne adress, som kallas dereferencing en nollpekare. Att komma åt nollpekare resulterar i oförutsägbart beteende eftersom de inte pekar på legitima minnesplatser . Här är ett exempel:

Exempel på json-format

 #include int main() { int* ptr = NULL; // Null pointer int value = *ptr; // Null pointer dereference printf('Value: %d
', value); return 0; } 

Produktion:

 Segmentation fault (core dumped) 

Förklaring:

Försöket att hänvisning en nollpekare resulterar i en segmenteringsfel , vilket gör att programmet kraschar med ett felmeddelande.

Stack Overflow:

A stack overflow händer när anropsstacken växer sig större än tänkt och innehåller information om funktionsanrop. En oändlig rekursion resulterar vanligtvis när rekursiva funktioner saknar lämpliga avslutningskriterier. Här är ett exempel:

 #include void recursiveFunction() { recursiveFunction(); // Recursive call without termination condition } int main() { recursiveFunction(); return 0; } 

Produktion:

 Segmentation fault (core dumped) 

Förklaring:

Programmet startar en ändlös rekursion , som svämmar över stacken och orsakar ett segmenteringsfel.

Oanvända variabler:

Därför att oinitierade variabler ha odefinierade värden , kan användning av dem resultera i körtidsfel. Programmet kan ge överraskande resultat eller krascha, beroende på omständigheterna. Här är ett exempel:

 #include int main() { int uninitializedVariable; printf('Value: %d
', uninitializedVariable); // Using uninitialized variable return 0; } 

Produktion:

 Some random value (varies each time) 

Förklaring:

I det här exemplet är värdet av en oinitierad variabel kan vara vilket slumpmässigt värde som helst som valts slumpmässigt från minnesområdet som är designat för den variabeln.

Låt oss titta på skillnaderna mellan kompileringstid och körtid:

Exempel på fel vid kompilering

 #include int main() { int a=20; printf('The value of a is : %d',a): return 0; } 

I ovanstående kod har vi försökt skriva ut värdet på 'a', men det ger ett fel. Vi sätter kolon i slutet av satsen istället för ett semikolon, så den här koden genererar ett kompileringsfel.

Produktion

Exempel på körtidsfel

 #include int main() { int a=20; int b=a/0; // division by zero printf('The value of b is : %d',b): return 0; } 

I koden ovan försöker vi dividera värdet på 'b' med noll, och detta ger ett körtidsfel.

Produktion

Slutsats:

Sammanfattningsvis perioderna av mjukvaruutveckling känd som kompileringstid och körtidsfel är separata och var och en har en unik uppsättning av fel som kan inträffa. Fel vid kompilering hända när koden konverteras till körbar form under kompileringssteget. Dessa fel inkluderar semantiska fel , som producerar ologisk eller absurd kod , och syntaxfel , som strider mot programmeringsspråkets lagar. Dessa fel identifieras av kompilator och rapporterade, blockerar utförandet av koden tills de är fixade.

Å andra sidan, körtidsfel uppstår när ett program körs och inte fångas upp av kompilatorn. De kan bero på flera tillstånd, inklusive division med noll, felaktig minnesåtkomst eller andra oförutsedda händelser. Körtidsfel är svårare att upptäcka och felsöka eftersom de ofta leder till programkrascher eller oväntat beteende. För att elegant hantera runtime-fel och garantera programmets stabilitet använder utvecklare felhanteringstekniker tycka om undantagshantering .