Compile-time og Runtime er de to programmeringsbegrepene som brukes i programvareutviklingen. Kompileringstid er tidspunktet da kildekoden konverteres til en kjørbar kode, mens kjøretiden er tidspunktet da den kjørbare koden begynner å kjøre. Både kompileringstiden og kjøretiden refererer til forskjellige typer feil.

Kompileringstidsfeil

Kompileringstidsfeil er feilene som oppstod når vi skriver feil syntaks. Hvis vi skriver feil syntaks eller semantikk for et hvilket som helst programmeringsspråk, vil kompileringstidsfeilene bli kastet av kompilatoren. Kompilatoren vil ikke tillate å kjøre programmet før alle feilene er fjernet fra programmet. Når alle feilene er fjernet fra programmet, vil kompilatoren generere den kjørbare filen.

Kompileringstidsfeilene kan være:

• Syntaksfeil
• Semantiske feil

Syntaksfeil

Når programmereren ikke følger syntaksen til noe programmeringsspråk, vil kompilatoren kaste syntaksfeilen.

For eksempel,

int a, b:

java streng til heltall konvertering

Deklarasjonen ovenfor genererer kompileringstidsfeilen som i C, hver setning slutter med semikolon, men vi setter et kolon (:) på slutten av setningen.

Semantiske feil

De semantiske feilene eksisterer når setningene ikke er meningsfulle for kompilatoren.

For eksempel,

a+b=c;

int i streng

Utsagnet ovenfor gir en kompileringstidsfeil. I setningen ovenfor tildeler vi verdien av 'c' til summeringen av 'a' og 'b', noe som ikke er mulig i programmeringsspråket C, da det bare kan inneholde én variabel til venstre for tildelingsoperatøren mens høyre for tilordningsoperatøren kan inneholde mer enn én variabel.

Utsagnet ovenfor kan omskrives som:

c=a+b;

Kjøretidsfeil

Runtime-feilene er feilene som oppstår under kjøringen og etter kompilering. Eksemplene på kjøretidsfeil er divisjon med null osv. Disse feilene er ikke enkle å oppdage da kompilatoren ikke peker på disse feilene.

La oss utforske noen typiske C kjøretidsfeiltyper, tilfeller , og deres mulige effekter.

Divisjon med null:

Siden divisjon med null er matematisk udefinerbare , prøver å dele et heltall med null fører til en kjøretidsfeil . Denne feilen fører til at programmet krasjer eller produserer et unntak. Her er et eksempel:

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

Produksjon:

 Floating point exception (core dumped) 

Forklaring:

EN 'Flytende punkt unntak' feilmelding produseres når programmet støter på et kjøretidsproblem på grunn av deling med null.

Tilgang til Array Out of Bounds:

EN kjøretidsfeil oppstår når et array-element er tilgjengelig utenfor visse grenser. En feil oppstår når en indeks er større enn matrisens størrelse og minnetilgangslovene brytes. Her er et eksempel:

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

Produksjon:

generisitet i java

 Segmentation fault (core dumped) 

Forklaring:

Elementet kl indeks 10 er utenfor arrayets grenser når programmet prøver å få tilgang til den. Som et resultat, a segmenteringsfeil oppstår , og programmet avsluttes med en feil.

Null Pointer Dereference:

EN kjøretidsfeil skjer når du prøver å få tilgang til en null-pekerens minne adresse, som er kjent som dereferering en null-peker. Å få tilgang til null-pekere resulterer i uforutsigbar oppførsel fordi de ikke peker på legitime minneplasseringer . Her er et eksempel:

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

Produksjon:

 Segmentation fault (core dumped) 

Forklaring:

Forsøket på avvisning en null-peker resulterer i en segmenteringsfeil , som får programmet til å krasje med en feilmelding.

Stack Overflow:

EN stabeloverløp skjer når anropsstabelen vokser seg større enn beregnet, og inneholder informasjon om funksjonskall. An uendelig rekursjon resulterer vanligvis når rekursive funksjoner mangler passende termineringskriterier. Her er et eksempel:

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

Produksjon:

 Segmentation fault (core dumped) 

Forklaring:

Programmet starter en endeløs rekursjon , som renner over stabelen og forårsaker en segmenteringsfeil.

Ubrukte variabler:

Fordi uinitialiserte variabler ha udefinerte verdier , kan bruk av dem resultere i kjøretidsfeil. Programmet kan gi overraskende resultater eller krasje, avhengig av omstendighetene. Her er et eksempel:

for loop java

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

Produksjon:

 Some random value (varies each time) 

Forklaring:

I dette eksemplet er verdien av en uinitialisert variabel kan være en hvilken som helst tilfeldig verdi valgt tilfeldig fra minneområdet utpekt til den variabelen.

La oss se på forskjellene mellom kompileringstid og kjøretid:

Eksempel på kompileringstidsfeil

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

I koden ovenfor har vi prøvd å skrive ut verdien av 'a', men det gir en feil. Vi setter kolon på slutten av setningen i stedet for semikolon, så denne koden genererer en kompileringstidsfeil.

Produksjon

sove for javascript

Eksempel på kjøretidsfeil

 #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 ovenfor prøver vi å dele verdien av 'b' med null, og dette gir en kjøretidsfeil.

Produksjon

Konklusjon:

Avslutningsvis er periodene med programvare utvikling kjent som kompileringstid og kjøretidsfeil er separate, og hver har et unikt sett med feil som kan oppstå. Kompileringstidsfeil skje når koden konverteres til kjørbar form under kompileringstrinnet. Disse feilene inkluderer semantiske feil , som produserer ulogisk eller absurd kode , og syntaksfeil , som strider mot lovene til programmeringsspråket. Disse feilene er identifisert av kompilator og rapporterte, blokkerer utførelsen av koden til de er fikset.

På den andre siden, kjøretidsfeil oppstår når et program kjører og ikke fanges opp av kompilatoren. De kan skyldes flere forhold, inkludert divisjon på null, feilaktig minnetilgang , eller andre uforutsette hendelser. Kjøretidsfeil er vanskeligere å oppdage og feilsøke siden de ofte resulterer i programkrasj eller uventet oppførsel. For å elegant administrere kjøretidsfeil og garantere programmets stabilitet, bruker utviklere feilhåndteringsteknikker som avvikshåndtering .