logo

TechCodeview

Runtime-fouten

Runtime-fouten:

  • Een runtimefout in een programma is een fout die optreedt terwijl het programma actief is nadat het met succes is gecompileerd.
  • Runtimefouten worden gewoonlijk insecten en worden vaak aangetroffen tijdens het foutopsporingsproces voordat de software wordt uitgebracht.
  • Wanneer er runtimefouten optreden nadat een programma onder het publiek is gedistribueerd, brengen ontwikkelaars vaak patches of kleine updates uit die zijn ontworpen om de fouten te herstellen.
  • Iedereen kan de lijst met problemen vinden waarmee hij te maken kan krijgen als hij een beginner is Dit artikel .
  • Bij het oplossen van problemen op onlineplatforms kunnen veel runtimefouten optreden, die niet duidelijk worden gespecificeerd in het bericht dat daarbij wordt geleverd. Er kunnen verschillende runtimefouten optreden, zoals logische fouten , Invoer-/uitvoerfouten , ongedefinieerde objectfouten , deling door nul fouten , en nog veel meer.

Soorten runtimefouten:

  • SIGFPE: SIGFPE is een drijvende komma fout. Het wordt vrijwel altijd veroorzaakt door a delen door 0 . Er kunnen hoofdzakelijk drie hoofdoorzaken van een SIGFPE-fout zijn, die als volgt worden beschreven:
    1. Deling door nul.
    2. Modulo-bediening door nul.
    3. Overloop van gehele getallen.
    Hieronder vindt u het programma om de SIGFPE-fout te illustreren: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);>
     Uitgang:
  • SIGABRT: Het is een fout die zelf door het programma wordt gedetecteerd, waarna dit signaal wordt gegenereerd met behulp van de oproep naar afbreken() functie. Dit signaal wordt ook door de standaardbibliotheek gebruikt om een ​​interne fout te melden. beweren() functie in C++ gebruikt ook abort() om dit signaal te genereren. Hieronder vindt u het programma om de SIGBRT-fout te illustreren: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();>
     Uitgang:
  • NZEC: Deze fout geeft aan Niet-nul uitgangscode . Voor C gebruikers, wordt deze fout gegenereerd als de main() methode heeft geen retour 0 stelling. Java /C++-gebruikers kunnen deze fout genereren als ze een uitzondering genereren. Hieronder staan ​​de mogelijke redenen voor het krijgen van een NZEC-fout:
    1. Oneindige recursie of als u geen stapelgeheugen meer heeft.
    2. Er is toegang tot de negatieve array-index.
    3. Uitzondering ArrayIndexOutOfBounds.
    4. Uitzondering StringIndexOutOfBounds.
    Hieronder vindt u het programma om de NZEC-fout te illustreren:C++ 
    #include  #include  using namespace std; int main() {  vector arr = {1, 2};  try {// Opzettelijke fout: toegang tot een element dat buiten het bereik ligt 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]);>
     Uitgang:
  • SIGSEGV: Deze fout is de meest voorkomende fout en staat bekend als Segmentatie fout . Het wordt gegenereerd wanneer het programma probeert toegang te krijgen tot een geheugen dat geen toegang heeft, of probeert toegang te krijgen tot een geheugenlocatie op een manier die niet is toegestaan. Een lijst met enkele veelvoorkomende redenen voor segmentatiefouten zijn:
    1. Toegang tot een array buiten het bereik.
    2. NULL-aanwijzers niet meer verwijzen.
    3. Dereferentie vrijgemaakt geheugen.
    4. Dereferentie naar niet-geïnitialiseerde pointers.
    5. Verkeerd gebruik van de & (adres van) en * (dereferentie) operatoren.
    6. Onjuiste opmaakspecificaties in printf- en scanf-instructies.
    7. Stapeloverloop.
    8. Schrijven naar alleen-lezen geheugen.
    Hieronder vindt u het programma om de SIGSEGV-fout te illustreren: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.>
     Uitgang:

Manieren om runtimefouten te voorkomen:

  • Vermijd het gebruik van variabelen die niet zijn geïnitialiseerd. Deze kunnen worden ingesteld op 0 op uw systeem, maar niet op het codeerplatform.
  • Controleer elk afzonderlijk voorkomen van een array-element en zorg ervoor dat dit niet buiten de grenzen valt.
  • Vermijd het declareren van te veel geheugen. Controleer de geheugenlimiet die in de vraag is opgegeven.
  • Vermijd te veel declareren Stapel geheugen . Grote matrices moeten globaal buiten de functie worden gedeclareerd.
  • Gebruik return als eindstatement.
  • Vermijd verwijzingen vrij geheugen of nul-aanwijzers .