TechCodeview

Compile-time og Runtime er de to programmeringsudtryk, der bruges i softwareudviklingen. Kompileringstiden er det tidspunkt, hvor kildekoden konverteres til en eksekverbar kode, mens køretiden er det tidspunkt, hvor den eksekverbare kode begynder at køre. Både kompileringstiden og runtime refererer til forskellige typer fejl.

Fejl ved kompilering

Fejl ved kompilering er de fejl, der opstod, når vi skriver den forkerte syntaks. Hvis vi skriver den forkerte syntaks eller semantik for et hvilket som helst programmeringssprog, vil kompileringsfejlene blive kastet af compileren. Compileren tillader ikke at køre programmet, før alle fejlene er fjernet fra programmet. Når alle fejlene er fjernet fra programmet, vil compileren generere den eksekverbare fil.

Kompileringstidsfejlene kan være:

• Syntaksfejl
• Semantiske fejl

Syntaksfejl

Når programmøren ikke følger syntaksen for noget programmeringssprog, vil compileren kaste syntaksfejlen.

For eksempel,

int a, b:

konvertere en dato til en streng

Ovenstående erklæring genererer kompileringstidsfejlen som i C, hver sætning slutter med semikolon, men vi sætter et kolon (:) i slutningen af ​​sætningen.

Semantiske fejl

De semantiske fejl eksisterer, når sætningerne ikke er meningsfulde for compileren.

For eksempel,

a+b=c;

datastrukturer i java

Ovenstående erklæring kaster en kompileringstidsfejl. I ovenstående erklæring tildeler vi værdien 'c' til summeringen af ​​'a' og 'b', hvilket ikke er muligt i programmeringssproget C, da det kun kan indeholde én variabel til venstre for tildelingsoperatoren, mens det til højre for tildelingsoperatoren kan indeholde mere end én variabel.

Ovenstående erklæring kan omskrives som:

c=a+b;

Kørselsfejl

Kørselsfejlene er de fejl, der opstår under udførelsen og efter kompileringen. Eksemplerne på runtime fejl er division med nul osv. Disse fejl er ikke nemme at opdage, da compileren ikke peger på disse fejl.

Lad os udforske nogle typiske C runtime fejltyper, cases og deres mulige virkninger.

Division med nul:

Da division med nul er matematisk udefinerbare , forsøger at dividere et heltal med nul fører til en runtime fejl . Denne fejl får programmet til at gå ned eller producere en undtagelse. 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; } 

Produktion:

 Floating point exception (core dumped) 

Forklaring:

EN 'Flydende komma undtagelse' fejlmeddelelse produceres, når programmet støder på et runtime problem på grund af division med nul.

Adgang til Array Out of Bounds:

EN runtime fejl opstår, når et array-element tilgås uden for visse grænser. En fejl opstår, når et indeks er større end arrayets størrelse, og hukommelsesadgangslovene er brudt. 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; } 

Produktion:

java streng ind i array

 Segmentation fault (core dumped) 

Forklaring:

Elementet kl indeks 10 er uden for arrayets grænser, når programmet forsøger at få adgang til det. Som et resultat, en segmenteringsfejl opstår , og programmet slutter med en fejl.

Null Pointer Dereference:

EN runtime fejl sker, når du forsøger at få adgang til en null pointers hukommelse adresse, som er kendt som dereferencing en nul pointer. Adgang til nul-pointers resulterer i uforudsigelig adfærd, fordi de ikke peger på legitime hukommelsesplaceringer . Her er et eksempel:

 #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) 

Forklaring:

Forsøget på dereference en nul pointer resulterer i en segmenteringsfejl , hvilket får programmet til at gå ned med en fejlmeddelelse.

Stack Overflow:

EN stak overløb sker, når opkaldsstakken vokser sig større end beregnet og indeholder information om funktionskald. An uendelig rekursion resulterer normalt, når rekursive funktioner mangler passende afslutningskriterier. Her er et eksempel:

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

Produktion:

 Segmentation fault (core dumped) 

Forklaring:

Programmet starter en endeløs rekursion , som løber over stakken og forårsager en segmenteringsfejl.

Ubrugte variable:

Fordi uinitialiserede variable har udefinerede værdier , kan brug af dem resultere i runtime fejl. Programmet kan give overraskende resultater eller gå ned, afhængigt af omstændighederne. Her er et eksempel:

forbindelse java mysql

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

Produktion:

 Some random value (varies each time) 

Forklaring:

I dette eksempel er værdien af ​​en uinitialiseret variabel kan være en hvilken som helst tilfældig værdi valgt tilfældigt fra hukommelsesområdet, der er udpeget til denne variabel.

Lad os se på forskellene mellem kompileringstid og runtime:

Eksempel på kompileringstidsfejl

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

I ovenstående kode har vi forsøgt at udskrive værdien af ​​'a', men det giver en fejl. Vi sætter kolon i slutningen af ​​sætningen i stedet for et semikolon, så denne kode genererer en kompileringsfejl.

Produktion

sove til javascript

Eksempel på runtime fejl

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

I ovenstående kode forsøger vi at dividere værdien af ​​'b' med nul, og dette giver en runtime fejl.

Produktion

Konklusion:

Afslutningsvis er perioderne af softwareudvikling kendt som kompileringstid og runtime fejl er separate, og hver har et unikt sæt af fejl der kan forekomme. Fejl ved kompilering ske, når koden konverteres til eksekverbar form under kompileringstrinnet. Disse fejl inkluderer semantiske fejl , som producerer ulogisk eller absurd kode , og syntaksfejl , som går imod programmeringssprogets love. Disse fejl er identificeret af compiler og rapporterede, blokering af udførelsen af koden, indtil de er rettet.

På den anden side, runtime fejl opstår, når et program kører og ikke fanges af compileren. De kan skyldes flere forhold, bl.a division med nul, fejlagtig hukommelsesadgang eller andre uforudsete hændelser. Kørselsfejl er sværere at opdage og fejlfinde, da de ofte resulterer i programnedbrud eller uventet adfærd. For elegant at administrere runtime fejl og garantere programmets stabilitet, bruger udviklere fejlhåndteringsteknikker synes godt om undtagelseshåndtering .