A fordítási idő és a futási idő a szoftverfejlesztésben használt két programozási kifejezés. A fordítási idő az az idő, amikor a forráskódot végrehajtható kóddá alakítják, míg a futási idő az az idő, amikor a végrehajtható kód futni kezd. Mind a fordítási idő, mind a futási idő különböző típusú hibákra utal.

Fordítási időbeli hibák

A fordítási hibák azok a hibák, amelyek akkor fordulnak elő, amikor rossz szintaxist írtunk. Ha valamelyik programozási nyelvnek rossz szintaxisát vagy szemantikáját írjuk le, akkor a fordítási hibákat a fordító fogja kidobni. A fordító nem engedi futtatni a programot, amíg az összes hibát el nem távolítja a programból. Amikor az összes hibát eltávolította a programból, a fordító létrehozza a végrehajtható fájlt.

script shell végrehajtása

A fordítási idő hibák a következők lehetnek:

• Szintaktikai hibák
• Szemantikai hibák

Szintaktikai hibák

Ha a programozó nem követi egyik programozási nyelv szintaxisát sem, akkor a fordító szintaktikai hibát dob.

Például,

int a, b:

A fenti deklaráció a fordítási idő hibát generálja, mint a C-ben, minden utasítás pontosvesszővel végződik, de kettőspontot (:) teszünk az utasítás végére.

Szemantikai hibák

A szemantikai hibák akkor fordulnak elő, ha az állítások nem értelmesek a fordító számára.

Például,

a+b=c;

A fenti utasítás fordítási idejű hibákat vet fel. A fenti utasításban a 'c' értékét az 'a' és 'b' összegzéséhez rendeljük, ami C programozási nyelvben nem lehetséges, mivel csak egy változót tartalmazhat a hozzárendelési operátor bal oldalán, míg a jobb oldalon. a hozzárendelési operátor egynél több változót is tartalmazhat.

A fenti állítás a következőképpen írható át:

c=a+b;

Futásidejű hibák

A futásidejű hibák azok a hibák, amelyek a végrehajtás során és a fordítás után fordulnak elő. A futásidejű hibák példái a nullával való osztás stb. Ezeket a hibákat nem könnyű felismerni, mivel a fordító nem mutat rá ezekre a hibákra.

Nézzünk meg néhány tipikus C-t futásidejű hibatípusok, esetek és lehetséges hatásaik.

Osztás nullával:

Mivel a nullával való osztás az matematikailag meghatározhatatlan , megpróbál egy egész számot elosztani ezzel nulla vezet a Futtatási hiba . Ez a hiba a program összeomlását vagy kivételt okoz. Íme egy példa:

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

Kimenet:

 Floating point exception (core dumped) 

Magyarázat:

A 'Lebegőpontos kivétel' hibaüzenet jelenik meg, ha a program futásidejű problémába ütközik a nullával való osztás miatt.

A tömb határokon kívüli elérése:

A Futtatási hiba akkor fordul elő, ha egy tömbelemhez bizonyos határokon kívül férünk hozzá. Hiba történik, ha egy index nagyobb, mint a tömb mérete, és megsértik a memória-hozzáférési törvényeket. Íme egy példa:

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

Kimenet:

 Segmentation fault (core dumped) 

Magyarázat:

Az elem at index 10 túl van a tömb határain, amikor a program megpróbál hozzáférni. Ennek eredményeként a szegmentációs hiba lép fel , és a program hibával fejeződik be.

Null mutató hivatkozás:

A Futtatási hiba akkor történik, amikor megpróbál hozzáférni a null mutató memóriája címet, amely néven ismert hivatkozás megszüntetése egy null mutató. A nullmutatók elérése kiszámíthatatlan viselkedést eredményez, mivel nem mutatnak rá legitim memóriahelyek . Íme egy példa:

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

Kimenet:

 Segmentation fault (core dumped) 

Magyarázat:

A kísérlet arra hivatkozást a null mutató eredménye a felosztási hiba , ami miatt a program összeomlik egy hibaüzenettel.

Stack túlcsordulás:

A verem túlcsordulás akkor történik, amikor a hívási verem a tervezettnél nagyobbra nő, és információkat tartalmaz a függvényhívásokról. An végtelen rekurzió általában akkor jön létre, ha a rekurzív függvények nem rendelkeznek megfelelő lezárási feltételekkel. Íme egy példa:

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

Kimenet:

 Segmentation fault (core dumped) 

Magyarázat:

A program elindul egy végtelen rekurzió , ami túlcsordul a veremben és szegmentációs hibát okoz.

Nem használt változók:

Mert inicializálatlan változók van meghatározatlan értékek , ezek használata futásidejű hibákhoz vezethet. A program a körülményektől függően meglepő eredményekkel vagy összeomlással járhat. Íme egy példa:

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

Kimenet:

 Some random value (varies each time) 

Magyarázat:

Ebben a példában az an értéke inicializálatlan változó lehet bármilyen véletlenszerű érték, amelyet véletlenszerűen választunk ki az adott változóhoz kijelölt memóriaterületből.

Nézzük meg a fordítási idő és a futási idő közötti különbségeket:

Példa fordítási idő hibára

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

A fenti kódban megpróbáltuk kinyomtatni az 'a' értékét, de hibát jelez. Pontosvessző helyett kettőspontot teszünk az utasítás végére, így ez a kód fordítási időt generál.

Kimenet

Példa futásidejű hibára

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

A fenti kódban megpróbáljuk elosztani a 'b' értékét nullával, és ez futásidejű hibát dob.

Kimenet

Következtetés:

Összefoglalva, az időszakok szoftverfejlesztés ismert, mint fordítási idő és futásidejű hibák különállóak, és mindegyiknek egyedi készlete van hibákat ami előfordulhat. Fordítási időbeli hibák akkor történik meg, amikor a kódot végrehajtható formává alakítják a fordítási lépés során. Ezek a hibák közé tartozik szemantikai hibák , amelyek termelnek logikátlan vagy abszurd kód , és szintaktikai hibák , amelyek ellentétesek a programozási nyelv törvényeivel. Ezeket a hibákat a fordítóprogram és jelentették, blokkolja a végrehajtást a kódot, amíg ki nem javítják.

Másrészről, futásidejű hibák akkor fordulnak elő, amikor egy program fut, és a fordító nem fogja el. Számos körülményből származhatnak, beleértve nullával való osztás, hibás memória hozzáférés , vagy egyéb előre nem látható események. Futásidejű hibák nehezebb felfedezni és hibakeresést végezni, mivel gyakran a program összeomlásához vagy váratlan viselkedéshez vezetnek. A futásidejű hibák elegáns kezelése és a program stabilitásának garantálása érdekében a fejlesztők ezt használják hibakezelési technikák mint kivételkezelés .