Tempo di esecuzione vs. tempo di compilazione
Risposte:
La differenza tra tempo di compilazione e tempo di esecuzione è un esempio di ciò che i teorici con la testa appuntita chiamano la distinzione di fase . È uno dei concetti più difficili da imparare, specialmente per le persone che non hanno molto background nei linguaggi di programmazione. Per affrontare questo problema, trovo utile chiedere
- Quali invarianti soddisfa il programma?
- Cosa può andare storto in questa fase?
- Se la fase ha esito positivo, quali sono le postcondizioni (cosa sappiamo)?
- Quali sono gli ingressi e le uscite, se presenti?
Tempo di compilazione
- Il programma non deve soddisfare alcun invariante. In realtà, non è necessario che sia un programma ben formato. Potresti alimentare questo HTML al compilatore e guardarlo ...
- Cosa può andare storto al momento della compilazione:
- Errori di sintassi
- Errori di verifica dei caratteri
- (Raramente) crash del compilatore
- Se il compilatore ha esito positivo, cosa sappiamo?
- Il programma era ben formato --- un programma significativo in qualunque lingua.
- È possibile avviare l'esecuzione del programma. (Il programma potrebbe fallire immediatamente, ma almeno possiamo provarci.)
- Quali sono gli ingressi e le uscite?
- L'input era il programma che veniva compilato, oltre a qualsiasi file di intestazione, interfacce, librerie o altri voodoo che doveva importare per essere compilato.
- Si spera che l'output sia un codice assembly o un codice oggetto trasferibile o anche un programma eseguibile. O se qualcosa va storto, l'output è un mucchio di messaggi di errore.
Tempo di esecuzione
- Non sappiamo nulla degli invarianti del programma --- sono qualunque cosa il programmatore abbia inserito. Gli invarianti di runtime sono raramente applicati dal solo compilatore; ha bisogno dell'aiuto del programmatore.
Cosa può andare storto sono gli errori di runtime :
- Divisione per zero
- Dereferenziazione di un puntatore nullo
- A corto di memoria
Inoltre, possono esserci errori rilevati dal programma stesso:
- Sto provando ad aprire un file che non c'è
- Cercare di trovare una pagina Web e scoprire che un presunto URL non è ben formato
- Se il runtime ha esito positivo, il programma termina (o continua) senza arresti anomali.
- Ingressi e uscite sono interamente a carico del programmatore. File, finestre sullo schermo, pacchetti di rete, lavori inviati alla stampante, il nome. Se il programma lancia missili, questo è un output e succede solo in fase di esecuzione :-)
Ci penso in termini di errori e quando possono essere colti.
Tempo di compilazione:
string my_value = Console.ReadLine();
int i = my_value;
A un valore stringa non può essere assegnata una variabile di tipo int, quindi il compilatore sa per certo al momento della compilazione che questo codice ha un problema
Tempo di esecuzione:
string my_value = Console.ReadLine();
int i = int.Parse(my_value);
Qui il risultato dipende da quale stringa è stata restituita da ReadLine (). Alcuni valori possono essere analizzati in un int, altri no. Questo può essere determinato solo in fase di esecuzione
.appun'estensione? o avviene su lancio da parte ogni volta che si avvia utente app?
Tempo di compilazione: il periodo di tempo in cui tu, lo sviluppatore, stai compilando il tuo codice.
Run-time: il periodo di tempo in cui un utente esegue il tuo software.
Hai bisogno di una definizione più chiara?
int x = 3/0ma non si fa nulla con questa variabile. Non lo stampiamo o altro. Sarà comunque considerato un errore di runtime?
( modifica : quanto segue si applica a C # e linguaggi di programmazione simili e fortemente tipizzati. Non sono sicuro che questo ti aiuti).
Ad esempio, il seguente errore verrà rilevato dal compilatore (in fase di compilazione ) prima di eseguire un programma e comporterà un errore di compilazione:
int i = "string"; --> error at compile-time
D'altra parte, un compilatore non può rilevare un errore come il seguente. Riceverai un errore / un'eccezione in fase di esecuzione (quando il programma viene eseguito).
Hashtable ht = new Hashtable();
ht.Add("key", "string");
// the compiler does not know what is stored in the hashtable
// under the key "key"
int i = (int)ht["key"]; // --> exception at run-time
La traduzione del codice sorgente in cose che accadono sullo [schermo | disco | rete] può avvenire (approssimativamente) in due modi; chiamali compilando e interpretando.
In un programma compilato (esempi sono c e fortran):
- Il codice sorgente viene inserito in un altro programma (di solito chiamato un compilatore - vai a figura), che produce un programma eseguibile (o un errore).
- L'eseguibile viene eseguito (facendo doppio clic su di esso o digitando il nome nella riga di comando)
Si dice che le cose che accadono nel primo passo accadano al "tempo di compilazione", mentre le cose che accadono nel secondo passo accadono al "tempo di esecuzione".
In un programma interpretato (esempio MicroSoft basic (su dos) e python (penso)):
- Il codice sorgente viene inserito in un altro programma (di solito chiamato un interprete) che lo "esegue" direttamente. Qui l'interprete funge da strato intermedio tra il programma e il sistema operativo (o l'hardware in computer molto semplici).
In questo caso, la differenza tra tempo di compilazione e tempo di esecuzione è piuttosto più difficile da definire e molto meno rilevante per il programmatore o l'utente.
Java è una sorta di ibrido, in cui il codice viene compilato in bytecode, che viene quindi eseguito su una macchina virtuale che di solito è un interprete per il bytecode.
C'è anche un caso intermedio in cui il programma viene compilato in bytecode ed eseguito immediatamente (come in awk o perl).
Fondamentalmente se il tuo compilatore può capire cosa intendi o quale valore è "in fase di compilazione", può codificarlo nel codice di runtime. Ovviamente se il tuo codice di runtime deve fare un calcolo ogni volta che verrà eseguito più lentamente, quindi se riesci a determinare qualcosa in fase di compilazione è molto meglio.
Per esempio.
Piegatura costante:
Se scrivo:
int i = 2;
i += MY_CONSTANT;
Il compilatore può eseguire questa calibrazione al momento della compilazione perché sa cos'è 2 e cos'è MY_CONSTANT. Come tale, si salva dall'eseguire un calcolo ogni singola esecuzione.
Tempo di compilazione:
Le cose che vengono eseguite in fase di compilazione non comportano (quasi) alcun costo quando viene eseguito il programma risultante, ma potrebbero comportare un costo elevato durante la creazione del programma.
Run-Time:
Più o meno l'esatto contrario. Poco costo durante la creazione, più costo durante l'esecuzione del programma.
Dall'altra parte; Se qualcosa viene fatto in fase di compilazione, viene eseguito solo sul tuo computer e se qualcosa è runtime, viene eseguito sul computer degli utenti.
rilevanza
Un esempio di dove questo è importante potrebbe essere un tipo portante unità. Una versione in fase di compilazione (come Boost.Units o la mia versione in D ) finisce per essere veloce quanto risolvere il problema con il codice a virgola mobile nativo mentre una versione di runtime finisce per dover racimolare informazioni sulle unità che un valore è ed eseguire controlli in essi lungo ogni operazione. D'altra parte, le versioni in fase di compilazione richiedono che le unità dei valori siano conosciute in fase di compilazione e non possano gestire il caso in cui provengono dall'input di runtime.
A seguito di una precedente risposta simile alla domanda Qual è la differenza tra errore di runtime e errore del compilatore?
Compilazione / Tempo di compilazione / Sintassi / Errori semantici: errori di compilazione o tempo di compilazione sono errori dovuti a errore di battitura, se non seguiamo la sintassi e la semantica corrette di qualsiasi linguaggio di programmazione, gli errori di compilazione vengono generati dal compilatore. Non permetteranno al tuo programma di eseguire una sola riga fino a quando non rimuovi tutti gli errori di sintassi o fino a quando non esegui il debug degli errori di compilazione.
Esempio: manca un punto e virgola in C o digita male intcome Int.
Errori di runtime: gli errori di runtime sono gli errori che vengono generati quando il programma è in esecuzione. Questo tipo di errori provocherà un comportamento imprevisto del programma o potrebbe addirittura interrompere il programma. Sono spesso indicati come eccezioni.
Esempio: supponiamo che stai leggendo un file che non esiste, causerà un errore di runtime.
Maggiori informazioni su tutti gli errori di programmazione qui
Come componente aggiuntivo per le altre risposte, ecco come lo spiegherei a un laico:
Il tuo codice sorgente è come il progetto di una nave. Definisce come deve essere costruita la nave.
Se consegni il progetto al cantiere e trovano un difetto durante la costruzione della nave, smetteranno di costruirlo e te lo segnaleranno immediatamente, prima che la nave abbia mai lasciato il bacino di carenaggio o toccato l'acqua. Questo è un errore in fase di compilazione. La nave non galleggiava o utilizzava mai i suoi motori. L'errore è stato rilevato perché impediva persino la realizzazione della nave.
Quando il codice viene compilato, è come se la nave fosse stata completata. Costruito e pronto per partire. Quando esegui il tuo codice, è come lanciare la nave in viaggio. I passeggeri sono saliti a bordo, i motori sono in funzione e lo scafo è in acqua, quindi questo è l'autonomia. Se la tua nave ha un difetto fatale che la affonda nel suo viaggio inaugurale (o forse un po 'di viaggio dopo per ulteriori mal di testa), ha subito un errore di runtime.
Ad esempio: in un linguaggio fortemente tipizzato, un tipo potrebbe essere verificato in fase di compilazione o in fase di esecuzione. Al momento della compilazione significa che il compilatore si lamenta se i tipi non sono compatibili. In fase di esecuzione significa che è possibile compilare il programma correttamente ma in fase di esecuzione genera un'eccezione.
In parole semplici differenza b / n Tempo di compilazione e tempo di esecuzione.
tempo di compilazione: lo sviluppatore scrive il programma in formato .java e si converte nel Bytecode che è un file di classe, durante questa compilazione qualsiasi errore può essere definito come errore di compilazione.
Tempo di esecuzione: il file .class generato viene utilizzato dall'applicazione per la sua funzionalità aggiuntiva e la logica risulta essere errata e genera un errore che è un errore di runtime
Ecco una citazione di Daniel Liang, autore di "Introduzione alla programmazione JAVA", sull'argomento della compilazione:
"Un programma scritto in un linguaggio di alto livello è chiamato programma sorgente o codice sorgente. Poiché un computer non è in grado di eseguire un programma sorgente, un programma sorgente deve essere tradotto in codice macchina per l' esecuzione . La traduzione può essere eseguita usando un altro strumento di programmazione chiamato un interprete o un compilatore ". (Daniel Liang, "Introduzione alla programmazione JAVA" , p8).
...Lui continua...
"Un compilatore traduce l'intero codice sorgente in un file di codice macchina e il file di codice macchina viene quindi eseguito"
Quando inseriamo un codice di alto livello / leggibile dall'uomo, questo è inizialmente inutile! Deve essere tradotto in una sequenza di "avvenimenti elettronici" nella tua piccola CPU! Il primo passo verso questo è la compilazione.
In poche parole: durante questa fase si verifica un errore di compilazione, mentre in seguito si verifica un errore di runtime.
Ricorda: solo perché un programma è compilato senza errori non significa che verrà eseguito senza errori.
Si verificherà un errore di runtime nella parte pronta, in esecuzione o in attesa del ciclo di vita di un programma mentre si verificherà un errore di tempo di compilazione prima della fase "Nuovo" del ciclo di vita.
Esempio di errore durante la compilazione:
Un errore di sintassi: come si può compilare il codice nelle istruzioni a livello di macchina se sono ambigui ?? Il codice deve essere conforme al 100% alle regole sintattiche della lingua, altrimenti non può essere compilato nel codice macchina funzionante .
Esempio di errore di runtime:
Esaurire la memoria - Una chiamata ad una funzione ricorsiva, ad esempio, potrebbe portare a un overflow dello stack dato una variabile di un grado particolare! Come può essere anticipato dal compilatore !? non può.
E questa è la differenza tra un errore di compilazione e un errore di run-time
Tempo di compilazione:
Le cose che vengono eseguite in fase di compilazione non comportano (quasi) alcun costo quando viene eseguito il programma risultante, ma potrebbero comportare un costo elevato durante la creazione del programma. Run-Time:
Più o meno l'esatto contrario. Poco costo durante la creazione, più costo durante l'esecuzione del programma.
Dall'altra parte; Se qualcosa viene fatto in fase di compilazione, viene eseguito solo sul tuo computer e se qualcosa è runtime, viene eseguito sul computer degli utenti.
Tempo di compilazione: il tempo impiegato per convertire il codice sorgente in un codice macchina in modo che diventi un eseguibile è chiamato tempo di compilazione.
Tempo di esecuzione: quando un'applicazione è in esecuzione, si chiama tempo di esecuzione.
Gli errori di compilazione sono quegli errori di sintassi, errori di riferimento ai file mancanti. Gli errori di runtime si verificano dopo che il codice sorgente è stato compilato in un programma eseguibile e mentre il programma è in esecuzione. Esempi sono arresti anomali del programma, comportamento imprevisto del programma o funzionalità non funzionanti.
Immagina di essere un capo e di avere un assistente e una cameriera, e dai loro un elenco di compiti da fare, l'assistente (tempo di compilazione) prenderà questo elenco e farà un controllo per vedere se i compiti sono comprensibili e che tu non ha scritto in nessuna lingua o sintassi scomoda, quindi capisce che vuoi assegnare qualcuno a un lavoro, quindi lo assegna per te e capisce che vuoi un caffè, quindi il suo ruolo è finito e la cameriera (tempo di esecuzione) inizia a svolgere tali compiti, quindi va a prepararti un caffè ma all'improvviso non trova alcun caffè da fare, quindi smette di prepararlo o si comporta in modo diverso e ti prepara un po 'di tè (quando il programma si comporta diversamente perché ha trovato un errore ).
Ecco un'estensione della risposta alla domanda "differenza tra tempo di esecuzione e tempo di compilazione?" - Differenze nelle spese generali associate al tempo di esecuzione e al tempo di compilazione?
Le prestazioni di runtime del prodotto contribuiscono alla sua qualità fornendo risultati più velocemente. Le prestazioni in fase di compilazione del prodotto contribuiscono alla sua tempestività accorciando il ciclo di modifica-compilazione-debug. Tuttavia, sia le prestazioni di runtime che quelle di compilazione sono fattori secondari per ottenere una qualità tempestiva. Pertanto, si dovrebbero considerare miglioramenti delle prestazioni in fase di esecuzione e in fase di compilazione solo quando giustificati da miglioramenti nella qualità e nella tempestività generali del prodotto.
Un'ottima fonte per ulteriori letture qui :
L'ho sempre pensato in relazione all'overhead dell'elaborazione del programma e al modo in cui influisce sulla preformance come precedentemente affermato. Un semplice esempio potrebbe essere, o definire la memoria assoluta richiesta per il mio oggetto nel codice o no.
Un booleano definito occupa x memoria che è quindi nel programma compilato e non può essere modificato. Quando il programma viene eseguito, sa esattamente quanta memoria allocare per x.
D'altra parte, se definisco semplicemente un tipo di oggetto generico (ovvero un tipo di segnaposto non definito o forse un puntatore a un blob gigante), la memoria effettiva richiesta per il mio oggetto non è nota fino a quando il programma non viene eseguito e gli assegno qualcosa , quindi deve essere valutato e l'allocazione di memoria, ecc. verrà quindi gestita in modo dinamico in fase di esecuzione (maggiore sovraccarico del tempo di esecuzione).
Il modo in cui viene gestito in modo dinamico dipende quindi dalla lingua, dal compilatore, dal sistema operativo, dal codice e così via.
Tuttavia, ciò dipende in realtà dal contesto in cui si sta utilizzando il tempo di esecuzione rispetto al tempo di compilazione.
possiamo classificarli in due diversi gruppi statici e leganti dinamici. Si basa su quando viene eseguita l'associazione con i valori corrispondenti. Se i riferimenti vengono risolti in fase di compilazione, allora è un binding statico e se i riferimenti vengono risolti in fase di esecuzione, allora è un binding dinamico. Associazione statica e associazione dinamica anche chiamata associazione anticipata e associazione tardiva. A volte vengono anche chiamati polimorfismo statico e polimorfismo dinamico.
Joseph Kulandai.
La principale differenza tra tempo di esecuzione e tempo di compilazione è:
- Se ci sono errori di sintassi e controlli del tipo nel codice, genera un errore di compilazione, dove-come runtime: controlla dopo aver eseguito il codice. Per esempio:
int a = 1
int b = a/0;
qui la prima riga non ha un punto e virgola alla fine ---> errore di compilazione dopo l'esecuzione del programma durante l'esecuzione dell'operazione b, il risultato è infinito ---> errore di runtime.
- Il tempo di compilazione non cerca l'output delle funzionalità fornite dal codice, mentre il runtime lo fa.
ecco una risposta molto semplice:
Runtime e tempo di compilazione sono termini di programmazione che si riferiscono a diverse fasi dello sviluppo del programma software. Per creare un programma, uno sviluppatore scrive prima il codice sorgente, che definisce come funzionerà il programma. I programmi di piccole dimensioni possono contenere solo poche centinaia di righe di codice sorgente, mentre i programmi di grandi dimensioni possono contenere centinaia di migliaia di righe di codice sorgente. Il codice sorgente deve essere compilato nel codice macchina per diventare un programma eseguibile. Questo processo di compilazione viene chiamato tempo di compilazione (pensa a un compilatore come a un traduttore)
Un programma compilato può essere aperto ed eseguito da un utente. Quando un'applicazione è in esecuzione, si chiama runtime.
I termini "runtime" e "tempo di compilazione" sono spesso utilizzati dai programmatori per fare riferimento a diversi tipi di errori. Un errore di compilazione è un problema come un errore di sintassi o un riferimento al file mancante che impedisce al programma di essere compilato correttamente. Il compilatore genera errori di compilazione e di solito indica quale riga del codice sorgente sta causando il problema.
Se il codice sorgente di un programma è già stato compilato in un programma eseguibile, è possibile che si verifichino dei bug durante l'esecuzione del programma. Gli esempi includono funzionalità che non funzionano, comportamento imprevisto del programma o arresti anomali del programma. Questi tipi di problemi sono chiamati errori di runtime poiché si verificano in fase di runtime.
IMHO è necessario leggere molti collegamenti, risorse per farsi un'idea della differenza tra tempo di runtime e tempo di compilazione perché è un argomento molto complesso. Ho un elenco qui sotto di alcune di queste immagini / collegamenti che mi consiglia.
A parte quanto detto sopra, voglio aggiungere che a volte un'immagine vale 1000 parole:
- l'ordine di questi due: prima è il tempo di compilazione e quindi si esegue Un programma compilato può essere aperto ed eseguito da un utente. Quando un'applicazione è in esecuzione, si chiama runtime: tempo di compilazione e quindi runtime1
;
CLR_diag tempo di compilazione e quindi runtime2
from Wiki
https://en.wikipedia.org/wiki/Run_time https://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase)
Tempo di esecuzione, tempo di esecuzione o runtime possono fare riferimento a:
Computing
Tempo di esecuzione (fase del ciclo di vita del programma) , il periodo durante il quale viene eseguito un programma per computer
Libreria di runtime , una libreria di programmi progettata per implementare funzioni integrate in un linguaggio di programmazione
Sistema di runtime , software progettato per supportare l'esecuzione di programmi per computer
Esecuzione del software, il processo di esecuzione delle istruzioni una per una durante la fase di esecuzione
Elenco dei compilatori
https://en.wikipedia.org/wiki/List_of_compilers
- cerca su google e confronta errori di runtime con errori di compilazione:
;
- Secondo me una cosa molto importante da sapere: 3.1 la differenza tra build vs compile e Build Lifecycle https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html
3.2 la differenza tra queste 3 cose: compilazione vs build vs runtime
https://www.quora.com/Che cosa è la differenza? ad altre risposte:
l'esecuzione sta ottenendo alcuni eseguibili binari (o uno script, per i linguaggi interpretati) per essere, ben ... eseguiti come un nuovo processo sul computer; la compilazione è il processo di analisi di un programma scritto in un linguaggio di alto livello (superiore se confrontato con il codice macchina), verifica della sua sintassi, semantica, collegamento delle librerie, forse facendo un po 'di ottimizzazione, quindi creando un programma binario eseguibile come output. Questo eseguibile può avere la forma di un codice macchina o un qualche tipo di codice byte, ovvero istruzioni rivolte a un tipo di macchina virtuale; la costruzione di solito implica il controllo e la fornitura di dipendenze, l'ispezione del codice, la compilazione del codice in binario, l'esecuzione di test automatizzati e il confezionamento dei file binari risultanti e altre risorse (immagini, file di configurazione, librerie, ecc.) in un formato specifico di file distribuibile. Nota che la maggior parte dei processi sono opzionali e alcuni dipendono dalla piattaforma di destinazione per la quale stai costruendo. Ad esempio, il packaging di un'applicazione Java per Tomcat produrrà un file .war. La creazione di un file eseguibile Win32 dal codice C ++ potrebbe semplicemente generare il programma .exe o anche impacchettarlo all'interno di un programma di installazione .msi.
Guarda in questo esempio:
public class Test {
public static void main(String[] args) {
int[] x=new int[-5];//compile time no error
System.out.println(x.length);
}}Il codice sopra è stato compilato correttamente, non c'è errore di sintassi, è perfettamente valido. Ma in fase di esecuzione, genera il seguente errore.
Exception in thread "main" java.lang.NegativeArraySizeException
at Test.main(Test.java:5)
Come quando in fase di compilazione sono stati controllati alcuni casi, dopo quel tempo di esecuzione alcuni casi sono stati controllati una volta che il programma soddisfa tutte le condizioni si otterrà un output. In caso contrario, verrà visualizzato il tempo di compilazione o l'errore di runtime.
classe pubblica RuntimeVsCompileTime {
public static void main(String[] args) {
//test(new D()); COMPILETIME ERROR
/**
* Compiler knows that B is not an instance of A
*/
test(new B());
}
/**
* compiler has no hint whether the actual type is A, B or C
* C c = (C)a; will be checked during runtime
* @param a
*/
public static void test(A a) {
C c = (C)a;//RUNTIME ERROR
}
}
class A{
}
class B extends A{
}
class C extends A{
}
class D{
}
Non è una buona domanda per SO (non è una domanda di programmazione specifica), ma non è una cattiva domanda in generale.
Se pensi che sia banale: che dire di read-time vs compilile-time, e quando è utile fare una distinzione? Che dire delle lingue in cui il compilatore è disponibile in fase di esecuzione? Guy Steele (non è un manichino, ha scritto 7 pagine in CLTL2 su EVAL-WHEN, che i programmatori CL possono usare per controllare questo. 2 frasi sono a malapena sufficienti per una definizione , che a sua volta è molto meno di una spiegazione .
In generale, è un problema difficile che i designer linguistici sembrano aver cercato di evitare. Spesso dicono "ecco un compilatore, fa cose in fase di compilazione; tutto ciò che segue è runtime, divertiti". C è progettato per essere semplice da implementare, non l'ambiente più flessibile per il calcolo. Quando non hai il compilatore disponibile in fase di esecuzione o la possibilità di controllare facilmente quando viene valutata un'espressione, tendi a finire con degli hack nella lingua per falsificare gli usi comuni delle macro o gli utenti escono con Pattern di progettazione per simulare avere costrutti più potenti. Un linguaggio semplice da implementare può sicuramente essere un obiettivo utile, ma ciò non significa che sia la fine del design del linguaggio di programmazione. (Non uso molto EVAL-QUANDO, ma non riesco a immaginare la vita senza di essa.)
E lo spazio problematico attorno al tempo di compilazione e al tempo di esecuzione è enorme e ancora in gran parte inesplorato. Questo non vuol dire che SO sia il posto giusto per discutere, ma incoraggio le persone a esplorare ulteriormente questo territorio, specialmente quelli che non hanno idee preconcette su cosa dovrebbe essere. La domanda non è né semplice né sciocca e potremmo almeno indirizzare l'inquisitore nella giusta direzione.
Sfortunatamente, non conosco buone referenze su questo. CLTL2 ne parla un po ', ma non è eccezionale per impararlo.