logo

TechCodeview

Errori di esecuzione

Errori di esecuzione:

  • Un errore di runtime in un programma è un errore che si verifica mentre il programma è in esecuzione dopo essere stato compilato correttamente.
  • Gli errori di runtime sono comunemente chiamati indicati come bug e si trovano spesso durante il processo di debug prima del rilascio del software.
  • Quando si verificano errori di runtime dopo che un programma è stato distribuito al pubblico, gli sviluppatori spesso rilasciano patch o piccoli aggiornamenti progettati per correggere gli errori.
  • Chiunque può trovare l'elenco dei problemi che potrebbe incontrare se è un principiante Questo articolo .
  • Durante la risoluzione dei problemi sulle piattaforme online, si possono riscontrare molti errori di runtime, che non sono chiaramente specificati nel messaggio che li accompagna. Esistono numerosi errori di runtime che si verificano come errori logici , Errori di ingresso/uscita , errori di oggetto non definiti , divisione per zero errori , e molti altri.

Tipi di errori di runtime:

  • SIGFPE: SIGFPE è un virgola mobile errore. È praticamente sempre causato da a divisione per 0 . Possono esserci principalmente tre cause principali dell'errore SIGFPE descritte come segue:
    1. Divisione per zero.
    2. Operazione Modulo da Zero.
    3. Overflow di numeri interi.
    Di seguito è riportato il programma per illustrare l'errore 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; }>
    Giava 
    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);>
     Produzione:
  • SIGABRT: È un errore stesso rilevato dal programma, quindi questo segnale viene generato utilizzando la chiamata a interrompere() funzione. Questo segnale viene utilizzato anche dalla libreria standard per segnalare un errore interno. affermare() funzione dentro C++ utilizza anche abort() per generare questo segnale. Di seguito è riportato il programma per illustrare l'errore 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; }>
    Giava 
    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();>
     Produzione:
  • NZEC: Questo errore denota Codice di uscita diverso da zero . Per C utenti, questo errore verrà generato se il file metodo main() non ha un ritorno 0 dichiarazione. Giava Gli utenti /C++ potrebbero generare questo errore se generano un'eccezione. Di seguito sono riportati i possibili motivi per cui viene visualizzato l'errore NZEC:
    1. Ricorsione infinita o se si esaurisce la memoria dello stack.
    2. Si accede all'indice dell'array negativo.
    3. Indice della Matrice Fuori Dai Limiti d'Eccezione.
    4. Eccezione StringIndexOutOfBounds.
    Di seguito è riportato il programma per illustrare l'errore NZEC:C++ 
    #include  #include  using namespace std; int main() {  vector arr = {1, 2};  try { // Errore intenzionale: accesso a un elemento fuori dai limiti 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>
    Giava 
    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.>
    Pitone 
    # 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]);>
     Produzione:
  • SIGSEGV: Questo errore è l'errore più comune ed è noto come Errore di segmentazione . Viene generato quando il programma tenta di accedere a una memoria a cui non è consentito l'accesso o tenta di accedere a una posizione di memoria in un modo non consentito. L'elenco di alcuni dei motivi più comuni per gli errori di segmentazione è:
    1. Accesso a un array fuori dai limiti.
    2. Dereferenziazione di puntatori NULL.
    3. Dereferenziazione della memoria liberata.
    4. Dereferenziazione di puntatori non inizializzati.
    5. Utilizzo scorretto del & (indirizzo di) e * operatori (di dereferenziazione).
    6. Specificatori di formattazione non corretti nelle istruzioni printf e scanf.
    7. Overflow dello stack.
    8. Scrittura nella memoria di sola lettura.
    Di seguito è riportato il programma per illustrare l'errore 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); }>
    Giava 
    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.>
    Pitone 
    # 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.>
     Produzione:

Modi per evitare errori di runtime:

  • Evitare di utilizzare variabili che non sono state inizializzate. Questi possono essere impostati su 0 sul tuo sistema ma non sulla piattaforma di codifica.
  • Controlla ogni singola occorrenza di un elemento dell'array e assicurati che non sia fuori limite.
  • Evitare di dichiarare troppa memoria. Verificare il limite di memoria specificato nella domanda.
  • Evita di dichiarare troppo Memoria dello stack . Gli array di grandi dimensioni dovrebbero essere dichiarati globalmente all'esterno della funzione.
  • Utilizzare return come istruzione finale.
  • Evitare riferimenti memoria libera O puntatori nulli .