Laufzeitfehler:

• Ein Laufzeitfehler in einem Programm ist ein Fehler, der auftritt, während das Programm nach erfolgreicher Kompilierung ausgeführt wird.
• Laufzeitfehler werden allgemein als bezeichnet Käfer und werden häufig während des Debugging-Prozesses vor der Veröffentlichung der Software gefunden.
• Wenn nach der Veröffentlichung eines Programms Laufzeitfehler auftreten, veröffentlichen Entwickler häufig Patches oder kleine Updates, um die Fehler zu beheben.
• Jeder kann die Liste der Probleme finden, mit denen er als Anfänger konfrontiert sein könnte Dieser Artikel .
• Bei der Lösung von Problemen auf Online-Plattformen können viele Laufzeitfehler auftreten, die in der zugehörigen Meldung nicht klar angegeben werden. Es treten verschiedene Laufzeitfehler auf, z logische Fehler , Eingabe-/Ausgabefehler , undefinierte Objektfehler , Division durch Nullfehler , und viele mehr.

Arten von Laufzeitfehlern:

• SIGFPE: SIGFPE ist ein Gleitkomma Fehler. Es wird praktisch immer durch a verursacht Division durch 0 . Es gibt hauptsächlich drei Hauptursachen für SIGFPE-Fehler, die wie folgt beschrieben werden:
  1. Durch Null teilen.
  2. Modulo-Operation durch Null.
  3. Ganzzahliger Überlauf.
  Nachfolgend finden Sie das Programm zur Veranschaulichung des SIGFPE-Fehlers:C++

  // C++ program to illustrate // the SIGFPE error #include  using namespace std; // Driver Code int main() {  int a = 5;  // Division by Zero  cout << a / 0;  return 0; }>

  Java

  public class Main {  public static void main(String[] args) {  int a = 5;  try {  // Division by Zero  System.out.println(a / 0);  } catch (ArithmeticException e) {  // Handle the ArithmeticException  System.out.println('Error: Division by zero is not allowed.');  }  } }>

  Python3

  # Python program to illustrate # the ZeroDivisionError # Driver Code def main(): a = 5 try: # Division by Zero print(a / 0) except ZeroDivisionError as e: print(f'Error: {e}') if __name__ == '__main__': main()>

  C#

  using System; class Program {  static void Main()  {  int a = 5;  try  {  // Division by Zero  Console.WriteLine(a / 0);  }  catch (DivideByZeroException ex)  {  // Handling DivideByZeroException  Console.WriteLine('Error: ' + ex.Message);  }  Console.ReadLine();  } }>

  Javascript

  // JavaScript program to demonstrate division by zero behavior // Perform division by zero let result = 5 / 0; // Print the result console.log(result);>

  Ausgabe:
• SIGABRT: Es handelt sich um einen Fehler, der vom Programm selbst erkannt wird. Anschließend wird dieses Signal mithilfe des Aufrufs von generiert abbrechen() Funktion. Dieses Signal wird auch von der Standardbibliothek verwendet, um einen internen Fehler zu melden. behaupten() Funktion in C++ verwendet auch abort(), um dieses Signal zu erzeugen. Nachfolgend finden Sie das Programm zur Veranschaulichung des SIGBRT-Fehlers:C++

  // C++ program to illustrate // the SIGBRT error #include  using namespace std; // Driver Code int main() {  // Assigning excessive memory  int a = 100000000000;  int* arr = new int[a];  return 0; }>

  Java

  public class Main {  public static void main(String[] args) {  try {  // Assigning excessive memory  int a = 1000000000;  int[] arr = new int[a];  } catch (OutOfMemoryError e) {  // Catch the OutOfMemoryError  System.err.println('Caught OutOfMemoryError: ' + e.getMessage());  }  } } //This code is contributed by Adarsh>

  Python3

  # Python program to illustrate # the MemoryError # Driver Code def main(): try: # Attempting to allocate excessive memory a = 100000000000 arr = [0] * a except MemoryError as e: print(f'Error: {e}') if __name__ == '__main__': main()>

  JavaScript

  // JavaScript program to illustrate the MemoryError // Driver Code function main() {  try {  // Attempting to allocate excessive memory  const a = 100000000000;  const arr = new Array(a).fill(0);  } catch (e) {  console.log('Error: ' + e.message);  } } main();>

  Ausgabe:
• NZEC: Dieser Fehler bezeichnet Exit-Code ungleich Null . Für C Benutzer, dieser Fehler wird generiert, wenn die main()-Methode hat keine Rückgabe 0 Stellungnahme. Java /C++-Benutzer könnten diesen Fehler generieren, wenn sie eine Ausnahme auslösen. Nachfolgend sind die möglichen Gründe für den Erhalt eines NZEC-Fehlers aufgeführt:
  1. Unendliche Rekursion oder wenn Ihnen der Stapelspeicher ausgeht.
  2. Es wird auf einen negativen Array-Index zugegriffen.
  3. ArrayIndexOutOfBounds-Ausnahme.
  4. StringIndexOutOfBounds-Ausnahme.
  Unten ist das Programm zur Veranschaulichung des NZEC-Fehlers:C++

  #include  #include  using namespace std; int main() {  vector arr = {1, 2};  try { // Absichtlicher Fehler: Zugriff auf ein Element außerhalb des zulässigen Bereichs cout<< arr.at(2) << endl; // Accessing index 2 which is out of bounds  }  catch (const out_of_range& e) {  cout << 'Error the index is out of bound'<< endl; // Handle the out_of_range exception  }    return 0; } //This code is contrbiuted by Adarsh>

  Java

  public class Main {  public static void main(String[] args) {  int[] arr = {1, 2};  // Intentional Error: Accessing an element out of bounds  System.out.println(arr[2]); // Error: Accessing index 2 which is out of bounds  } } //this code is contributed by Utkarsh.>

  Python

  # Python program to illustrate # the NZEC Error # Driver Code if __name__ == '__main__': arr = [1, 2] # Runtime Error # Array Index out of Bounds print(arr[2])>

  JavaScript

  // JavaScript program to illustrate // the error similar to NZEC Error // Driver Code let arr = [1, 2]; // Runtime Error // Array Index out of Bounds console.log(arr[2]);>

  Ausgabe:
• SIGSEGV: Dieser Fehler ist der häufigste Fehler und wird als bezeichnet Segmentierungsfehler . Es wird generiert, wenn das Programm versucht, auf einen Speicher zuzugreifen, auf den keine Zugriffsberechtigung besteht, oder wenn es versucht, auf eine nicht zulässige Weise auf einen Speicherort zuzugreifen. Liste einiger häufiger Gründe für Segmentierungsfehler:
  1. Zugriff auf ein Array außerhalb der Grenzen.
  2. NULL-Zeiger dereferenzieren.
  3. Freigegebenen Speicher dereferenzieren.
  4. Dereferenzierung nicht initialisierter Zeiger.
  5. Falsche Verwendung der & (Adresse von) und * (Dereferenzierungs-)Operatoren.
  6. Falsche Formatierungsspezifizierer in printf- und scanf-Anweisungen.
  7. Paketüberfluss.
  8. Schreiben in den Nur-Lese-Speicher.
  Unten ist das Programm zur Veranschaulichung des SIGSEGV-Fehlers:C++

  // C++ program to illustrate // the SIGSEGV error #include  using namespace std; // Function with infinite // Recursion void infiniteRecur(int a) {  return infiniteRecur(a); } // Driver Code int main() {  // Infinite Recursion  infiniteRecur(5); }>

  Java

  import java.util.*; public class Main {  // Function with infinite Recursion  static void infiniteRecur(int a) {  // Recursively call the function without a base case  infiniteRecur(a);  }  // Driver Code  public static void main(String[] args) {  // Infinite Recursion  infiniteRecur(5);  } } //This code is contributed by Monu.>

  Python

  # Python program to illustrate # the SIGSEGV error # Function with infinite # Recursion def infiniteRecur(a): return infiniteRecur(a) # Driver Code if __name__ == '__main__': # Infinite Recursion infiniteRecur(5) #This code is contributed by Utkarsh.>

  C#

  using System; class Program {  // Function with infinite Recursion  static void InfiniteRecur(int a)  {  // Recursively calling the function  InfiniteRecur(a);  }  // Driver Code  static void Main()  {  // Infinite Recursion  InfiniteRecur(5);  } }>

  JavaScript

  // Function with infinite Recursion function infiniteRecur(a) {  // Recursively call the function without a base case  infiniteRecur(a); } // Infinite Recursion infiniteRecur(5); // Note: JavaScript does not have tail-call optimization,  // so running this code will eventually lead to a maximum call stack size exceeded error.>

  Ausgabe:

Möglichkeiten zur Vermeidung von Laufzeitfehlern:

• Vermeiden Sie die Verwendung von Variablen, die nicht initialisiert wurden. Diese können auf eingestellt werden 0 auf Ihrem System, aber nicht auf der Codierungsplattform.
• Überprüfen Sie jedes einzelne Vorkommen eines Array-Elements und stellen Sie sicher, dass es nicht außerhalb der Grenzen liegt.
• Vermeiden Sie es, zu viel Speicher zu deklarieren. Überprüfen Sie das in der Frage angegebene Speicherlimit.
• Vermeiden Sie es, zu viel zu deklarieren Stapelspeicher . Große Arrays sollten global außerhalb der Funktion deklariert werden.
• Verwenden Sie return als Endanweisung.
• Vermeiden Sie Verweise freier Speicher oder Nullzeiger .