Erreurs d'exécution:

• Une erreur d'exécution dans un programme est une erreur qui se produit pendant l'exécution du programme après avoir été compilé avec succès.
• Les erreurs d'exécution sont communément appelées insectes et sont souvent trouvés pendant le processus de débogage avant la sortie du logiciel.
• Lorsque des erreurs d'exécution se produisent après la distribution d'un programme au public, les développeurs publient souvent des correctifs ou de petites mises à jour conçues pour corriger les erreurs.
• Tout le monde peut trouver la liste des problèmes auxquels il peut être confronté s'il débute dans Cet article .
• Lors de la résolution de problèmes sur les plateformes en ligne, de nombreuses erreurs d'exécution peuvent survenir, qui ne sont pas clairement spécifiées dans le message qui les accompagne. Il existe diverses erreurs d'exécution qui se produisent, telles que erreurs logiques , Erreurs d'entrée/sortie , erreurs d'objet non défini , division par zéro erreur , et beaucoup plus.

Types d'erreurs d'exécution:

• SIGFPE : Le SIGFPE est un point flottant erreur. Elle est presque toujours causée par un division par 0 . Il peut y avoir principalement trois causes principales d’erreur SIGFPE décrites comme suit :
  1. Division par zéro.
  2. Fonctionnement Modulo par Zero.
  3. Débordement d'entier.
  Vous trouverez ci-dessous le programme pour illustrer l'erreur SIGFPE :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);>

  Sortir:
• SIGABRT : C'est une erreur elle-même qui est détectée par le programme puis ce signal est généré en utilisant l'appel à avorter() fonction. Ce signal est également utilisé par la bibliothèque standard pour signaler une erreur interne. affirmer() fonctionner dans C++ utilise également abort() pour générer ce signal. Vous trouverez ci-dessous le programme pour illustrer l'erreur SIGBRT :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();>

  Sortir:
• NZEC : Cette erreur indique Code de sortie différent de zéro . Pour C utilisateurs, cette erreur sera générée si le méthode main() n'a pas de retour 0 déclaration. Java Les utilisateurs de /C++ pourraient générer cette erreur s'ils lèvent une exception. Vous trouverez ci-dessous les raisons possibles de l'erreur NZEC :
  1. Infinite Recursion ou si vous manquez de mémoire de pile.
  2. L'index de tableau négatif est accédé.
  3. Exception ArrayIndexOutOfBounds.
  4. Exception StringIndexOutOfBounds.
  Vous trouverez ci-dessous le programme pour illustrer l'erreur NZEC :C++

  #include  #include  using namespace std; int main() {  vector arr = {1, 2} ;  try { // Erreur intentionnelle : accès à un élément hors limites 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]);>

  Sortir:
• SIGSEGV : Cette erreur est l'erreur la plus courante et est connue sous le nom de Défaut de segmentation . Il est généré lorsque le programme tente d'accéder à une mémoire à laquelle l'accès n'est pas autorisé ou tente d'accéder à un emplacement mémoire d'une manière qui n'est pas autorisée. La liste de certaines des raisons courantes des erreurs de segmentation est la suivante :
  1. Accéder à un tableau hors limites.
  2. Déréférencement des pointeurs NULL.
  3. Déréférencement de la mémoire libérée.
  4. Déréférencement de pointeurs non initialisés.
  5. Une utilisation incorrecte du & (adresse de) et * opérateurs (de déréférencement).
  6. Spécificateurs de formatage incorrects dans les instructions printf et scanf.
  7. Débordement de pile.
  8. Écriture dans la mémoire morte.
  Vous trouverez ci-dessous le programme pour illustrer l'erreur SIGSEGV :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.>

  Sortir:

Façons d'éviter les erreurs d'exécution:

• Évitez d'utiliser des variables qui n'ont pas été initialisées. Ceux-ci peuvent être réglés sur 0 sur votre système mais pas sur la plateforme de codage.
• Vérifiez chaque occurrence d'un élément du tableau et assurez-vous qu'il n'est pas hors limites.
• Évitez de déclarer trop de mémoire. Vérifiez la limite de mémoire spécifiée dans la question.
• Évitez de trop déclarer Mémoire de pile . Les grands tableaux doivent être déclarés globalement en dehors de la fonction.
• Utilisez return comme instruction de fin.
• Évitez de faire référence mémoire libre ou pointeurs nuls .