TechCodeview

Compila-time e Runtime sono i due termini di programmazione utilizzati nello sviluppo del software. Il tempo di compilazione è il momento in cui il codice sorgente viene convertito in un codice eseguibile mentre il tempo di esecuzione è il momento in cui viene avviata l'esecuzione del codice eseguibile. Sia in fase di compilazione che in fase di esecuzione si riferiscono a diversi tipi di errore.

Errori in fase di compilazione

Gli errori in fase di compilazione sono gli errori che si sono verificati quando abbiamo scritto la sintassi sbagliata. Se scriviamo la sintassi o la semantica sbagliata di qualsiasi linguaggio di programmazione, il compilatore genererà errori in fase di compilazione. Il compilatore non consentirà di eseguire il programma finché tutti gli errori non verranno rimossi dal programma. Quando tutti gli errori verranno rimossi dal programma, il compilatore genererà il file eseguibile.

Gli errori in fase di compilazione possono essere:

• Errori di sintassi
• Errori semantici

Errori di sintassi

Quando il programmatore non segue la sintassi di alcun linguaggio di programmazione, il compilatore genererà un errore di sintassi.

Per esempio,

intero a, b:

La dichiarazione precedente genera l'errore in fase di compilazione come in C, ogni istruzione termina con il punto e virgola, ma inseriamo i due punti (:) alla fine dell'istruzione.

Errori semantici

Gli errori semantici esistono quando le istruzioni non sono significative per il compilatore.

sei giunto

Per esempio,

a+b=c;

L'istruzione precedente genera errori in fase di compilazione. Nell'istruzione precedente, stiamo assegnando il valore di 'c' alla somma di 'a' e 'b', cosa non possibile nel linguaggio di programmazione C poiché può contenere solo una variabile a sinistra dell'operatore di assegnazione mentre a destra di l'operatore di assegnazione può contenere più di una variabile.

La precedente affermazione può essere riscritta come:

volpe contro lupo

c=a+b;

Errori di esecuzione

Gli errori di runtime sono gli errori che si verificano durante l'esecuzione e dopo la compilazione. Gli esempi di errori di runtime sono la divisione per zero, ecc. Questi errori non sono facili da rilevare poiché il compilatore non indica questi errori.

Esploriamo alcuni tipici C tipi di errori di runtime, casi e i loro possibili effetti.

Divisione per zero:

Poiché la divisione per zero lo è matematicamente indefinibile , tentando di dividere un numero intero per zero porta ad a errore di esecuzione . Questo errore provoca l'arresto anomalo del programma o la produzione di un'eccezione. Ecco un esempio:

 #include int main() { int a = 10; int b = 0; int result = a / b; // Division by zero printf('Result: %d
', result); return 0; } 

Produzione:

 Floating point exception (core dumped) 

Spiegazione:

UN 'Eccezione in virgola mobile' viene prodotto un messaggio di errore quando il programma rileva un problema di runtime a causa della divisione per zero.

Accesso all'array fuori limite:

UN errore di esecuzione si verifica quando si accede a un elemento dell'array al di fuori di determinati limiti. Si verifica un errore quando un indice è maggiore della dimensione dell'array e le leggi di accesso alla memoria non vengono rispettate. Ecco un esempio:

 #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; } 

Produzione:

 Segmentation fault (core dumped) 

Spiegazione:

L'elemento a indice 10 è oltre i limiti dell'array quando il programma tenta di accedervi. Di conseguenza, a si verifica un errore di segmentazione e il programma termina con un errore.

ordinamento della selezione Java

Dereferenza del puntatore nullo:

UN errore di esecuzione succede quando provi ad accedere a a memoria del puntatore nullo indirizzo, noto come dereferenziazione un puntatore nullo. L'accesso ai puntatori nulli provoca un comportamento imprevedibile perché non puntano a posizioni di memoria legittime . Ecco un esempio:

 #include int main() { int* ptr = NULL; // Null pointer int value = *ptr; // Null pointer dereference printf('Value: %d
', value); return 0; } 

Produzione:

 Segmentation fault (core dumped) 

Spiegazione:

Il tentativo di dereferenziazione un puntatore nullo risulta in a errore di segmentazione , che causa l'arresto anomalo del programma con un messaggio di errore.

Overflow dello stack:

UN overflow dello stack accade quando lo stack di chiamate diventa più grande del previsto, contenente informazioni sulle chiamate di funzione. UN ricorsione infinita di solito si verifica quando le funzioni ricorsive non dispongono di criteri di terminazione appropriati. Ecco un esempio:

 #include void recursiveFunction() { recursiveFunction(); // Recursive call without termination condition } int main() { recursiveFunction(); return 0; } 

Produzione:

 Segmentation fault (core dumped) 

Spiegazione:

Ciclo for in Java

Il programma avvia un ricorsione infinita , che fa traboccare lo stack e causa un errore di segmentazione.

Variabili non utilizzate:

Perché variabili non inizializzate Avere valori indefiniti , il loro utilizzo potrebbe causare errori di runtime. Il programma potrebbe fornire risultati sorprendenti o bloccarsi, a seconda delle circostanze. Ecco un esempio:

 #include int main() { int uninitializedVariable; printf('Value: %d
', uninitializedVariable); // Using uninitialized variable return 0; } 

Produzione:

 Some random value (varies each time) 

Spiegazione:

In questo esempio, il valore di an variabile non inizializzata può essere qualsiasi valore casuale scelto casualmente dalla regione di memoria designata a quella variabile.

Diamo un'occhiata alle differenze tra fase di compilazione e runtime:

Esempio di errore in fase di compilazione

significato dhl

 #include int main() { int a=20; printf('The value of a is : %d',a): return 0; } 

Nel codice precedente, abbiamo provato a stampare il valore di 'a', ma viene generato un errore. Inseriamo i due punti alla fine dell'istruzione invece del punto e virgola, quindi questo codice genera un errore in fase di compilazione.

Produzione

Esempio di errore di runtime

 #include int main() { int a=20; int b=a/0; // division by zero printf('The value of b is : %d',b): return 0; } 

Nel codice sopra, proviamo a dividere il valore di 'b' per zero e questo genera un errore di runtime.

Produzione

Conclusione:

In conclusione, i periodi di sviluppo software conosciuto come fase di compilazione E errori di esecuzione sono separati e ciascuno ha un insieme unico di difetti ciò potrebbe accadere. Errori in fase di compilazione accadere quando il codice viene convertito in formato eseguibile durante la fase di compilazione. Questi errori includono errori semantici , che producono illogico O codice assurdo , E errori di sintassi , che vanno contro le leggi del linguaggio di programmazione. Questi errori sono identificati da compilatore e segnalato, bloccandone l'esecuzione del codice finché non vengono risolti.

D'altra parte, errori di esecuzione si verificano quando un programma è in esecuzione e non vengono rilevati dal compilatore. Possono derivare da diverse condizioni, incluso divisione per zero, accesso errato alla memoria o altri eventi imprevisti. Errori di esecuzione sono più difficili da individuare ed eseguire il debug poiché spesso provocano arresti anomali del programma o comportamenti imprevisti. Per gestire in modo elegante gli errori di runtime e garantire la stabilità del programma, gli sviluppatori utilizzano tecniche di gestione degli errori Piace la gestione delle eccezioni .