Kompilierungszeit und Laufzeit sind die beiden Programmierbegriffe, die in der Softwareentwicklung verwendet werden. Die Kompilierungszeit ist der Zeitpunkt, zu dem der Quellcode in einen ausführbaren Code umgewandelt wird, während die Laufzeit der Zeitpunkt ist, zu dem die Ausführung des ausführbaren Codes gestartet wird. Sowohl die Kompilierungszeit als auch die Laufzeit beziehen sich auf unterschiedliche Fehlertypen.
Fehler bei der Kompilierung
Kompilierzeitfehler sind Fehler, die auftreten, wenn wir die falsche Syntax schreiben. Wenn wir die falsche Syntax oder Semantik einer Programmiersprache schreiben, werden vom Compiler Fehler bei der Kompilierung ausgegeben. Der Compiler erlaubt die Ausführung des Programms erst, wenn alle Fehler aus dem Programm entfernt wurden. Wenn alle Fehler aus dem Programm entfernt sind, generiert der Compiler die ausführbare Datei.
Die Fehler bei der Kompilierung können sein:
- Syntaxfehler
- Semantische Fehler
Syntaxfehler
Wenn der Programmierer die Syntax einer Programmiersprache nicht befolgt, gibt der Compiler einen Syntaxfehler aus.
Zum Beispiel,
int a, b:
Die obige Deklaration erzeugt den Kompilierzeitfehler wie in C, jede Anweisung endet mit dem Semikolon, aber wir setzen am Ende der Anweisung einen Doppelpunkt (:).
Semantische Fehler
Die semantischen Fehler liegen vor, wenn die Anweisungen für den Compiler keine Bedeutung haben.
Zum Beispiel,
a+b=c;
Die obige Anweisung löst einen Fehler bei der Kompilierung aus. In der obigen Anweisung weisen wir den Wert von „c“ der Summe von „a“ und „b“ zu, was in der Programmiersprache C nicht möglich ist, da sie links vom Zuweisungsoperator und rechts davon nur eine Variable enthalten kann Der Zuweisungsoperator kann mehr als eine Variable enthalten.
Die obige Aussage kann wie folgt umgeschrieben werden:
c=a+b;
Laufzeitfehler
Die Laufzeitfehler sind die Fehler, die während der Ausführung und nach der Kompilierung auftreten. Beispiele für Laufzeitfehler sind Division durch Null usw. Diese Fehler sind nicht leicht zu erkennen, da der Compiler nicht auf diese Fehler verweist.
Lassen Sie uns einige typische C untersuchen Laufzeitfehlertypen, Fälle und ihre möglichen Auswirkungen.
Durch Null teilen:
Da Division durch Null ist mathematisch undefinierbar , der versucht, eine ganze Zahl durch zu dividieren null führt zu a Laufzeit Fehler . Dieser Fehler führt zum Absturz des Programms oder zu einer Ausnahme. Hier ist ein Beispiel:
#include int main() { int a = 10; int b = 0; int result = a / b; // Division by zero printf('Result: %d
', result); return 0; } Ausgabe:
sind Musterbeispiele
Floating point exception (core dumped)
Erläuterung:
A „Gleitkomma-Ausnahme“ Eine Fehlermeldung wird ausgegeben, wenn das Programm aufgrund einer Division durch Null auf ein Laufzeitproblem stößt.
Zugriff auf ein Array außerhalb der Grenzen:
A Laufzeit Fehler Tritt auf, wenn auf ein Array-Element außerhalb bestimmter Grenzen zugegriffen wird. Ein Fehler tritt auf, wenn ein Index größer als die Größe des Arrays ist und die Speicherzugriffsgesetze verletzt werden. Hier ist ein Beispiel:
#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; } Ausgabe:
Segmentation fault (core dumped)
Erläuterung:
Das Element bei Index 10 liegt außerhalb der Grenzen des Arrays, wenn das Programm versucht, darauf zuzugreifen. Infolgedessen a Es tritt ein Segmentierungsfehler auf , und das Programm endet mit einem Fehler.
Nullzeiger-Dereferenzierung:
A Laufzeit Fehler passiert, wenn Sie versuchen, auf a zuzugreifen Speicher des Nullzeigers Adresse, die als bekannt ist Dereferenzierung ein Nullzeiger. Der Zugriff auf Nullzeiger führt zu unvorhersehbarem Verhalten, da sie nicht auf zeigen legitime Speicherorte . Hier ist ein Beispiel:
#include int main() { int* ptr = NULL; // Null pointer int value = *ptr; // Null pointer dereference printf('Value: %d
', value); return 0; } Ausgabe:
Segmentation fault (core dumped)
Erläuterung:
Der Versuch Dereferenzierung Ein Nullzeiger führt zu a Segmentierungsfehler , was zum Absturz des Programms mit einer Fehlermeldung führt.
Paketüberfluss:
A Paketüberfluss passiert, wenn der Aufrufstapel größer wird als beabsichtigt und Informationen über Funktionsaufrufe enthält. Ein unendliche Rekursion tritt normalerweise auf, wenn rekursiven Funktionen keine geeigneten Beendigungskriterien fehlen. Hier ist ein Beispiel:
#include void recursiveFunction() { recursiveFunction(); // Recursive call without termination condition } int main() { recursiveFunction(); return 0; } Ausgabe:
Segmentation fault (core dumped)
Erläuterung:
Das Programm startet eine endlose Rekursion , was den Stapel überläuft und einen Segmentierungsfehler verursacht.
Unbenutzte Variablen:
Weil nicht initialisierte Variablen haben undefinierte Werte , kann ihre Verwendung zu Laufzeitfehlern führen. Das Programm könnte je nach den Umständen überraschende Ergebnisse liefern oder abstürzen. Hier ist ein Beispiel:
#include int main() { int uninitializedVariable; printf('Value: %d
', uninitializedVariable); // Using uninitialized variable return 0; } Ausgabe:
Some random value (varies each time)
Erläuterung:
In diesem Beispiel ist der Wert von an nicht initialisierte Variable kann ein beliebiger Zufallswert sein, der zufällig aus dem dieser Variablen zugewiesenen Speicherbereich ausgewählt wird.
Schauen wir uns die Unterschiede zwischen Kompilierungszeit und Laufzeit an:
| Kompilierzeit | Laufzeit |
|---|---|
| Bei den Kompilierzeitfehlern handelt es sich um Fehler, die zur Kompilierungszeit auftreten und vom Compiler erkannt werden. | Bei den Laufzeitfehlern handelt es sich um Fehler, die nicht vom Compiler generiert werden und zur Ausführungszeit zu einem unvorhersehbaren Ergebnis führen. |
| In diesem Fall verhindert der Compiler die Ausführung des Codes, wenn er einen Fehler im Programm erkennt. | In diesem Fall erkennt der Compiler den Fehler nicht und kann daher die Ausführung des Codes nicht verhindern. |
| Es enthält Syntax- und Semantikfehler, z. B. fehlende Semikolons am Ende der Anweisung. | Es enthält Fehler wie die Division durch Null und die Bestimmung der Quadratwurzel einer negativen Zahl. |
Beispiel für einen Fehler bei der Kompilierung
#include int main() { int a=20; printf('The value of a is : %d',a): return 0; } Im obigen Code haben wir versucht, den Wert von „a“ auszugeben, aber es wird ein Fehler ausgegeben. Wir setzen den Doppelpunkt anstelle eines Semikolons am Ende der Anweisung, sodass dieser Code einen Fehler bei der Kompilierung generiert.
Ausgabe
Beispiel für einen Laufzeitfehler
#include int main() { int a=20; int b=a/0; // division by zero printf('The value of b is : %d',b): return 0; } Im obigen Code versuchen wir, den Wert von „b“ durch Null zu dividieren, was einen Laufzeitfehler auslöst.
Ausgabe
Abschluss:
Abschließend sind die Perioden von Software-Entwicklung bekannt als Kompilierzeit Und Laufzeitfehler sind getrennt und jedes hat einen einzigartigen Satz von Fehler das könnte passieren. Fehler bei der Kompilierung passieren, wenn der Code während des Kompilierungsschritts in eine ausführbare Form umgewandelt wird. Zu diesen Fehlern gehören Semantische Fehler , die produzieren unlogisch oder absurder Code , Und Syntaxfehler , die gegen die Gesetze der Programmiersprache verstoßen. Diese Fehler werden durch die identifiziert Compiler und berichtet, die Ausführung blockieren des Codes, bis sie behoben sind.
Andererseits, Laufzeitfehler treten auf, wenn ein Programm ausgeführt wird, und werden vom Compiler nicht abgefangen. Sie können aus verschiedenen Bedingungen resultieren, darunter Division durch Null, fehlerhafter Speicherzugriff oder andere unvorhergesehene Ereignisse. Laufzeitfehler sind schwieriger zu erkennen und zu debuggen, da sie häufig zu Programmabstürzen oder unerwartetem Verhalten führen. Um Laufzeitfehler elegant zu verwalten und die Stabilität des Programms zu gewährleisten, verwenden Entwickler Techniken zur Fehlerbehandlung wie Ausnahmebehandlung .