Temps d'exécution vs temps de compilation
Quelqu'un peut-il me donner une bonne compréhension de la différence entre le temps d'exécution et le temps de compilation?
La différence entre le temps de compilation et le temps d’exécution est un exemple de ce que les théoriciens pointés appellent la distinction de phase . C'est l'un des concepts les plus difficiles à apprendre, en particulier pour les personnes peu familiarisées avec les langages de programmation. Pour aborder ce problème, je trouve utile de demander
- Quels invariants le programme satisfait-il?
- Qu'est-ce qui ne va pas dans cette phase?
- Si la phase réussit, quelles sont les post-conditions (que savons-nous)?
- Quelles sont les entrées et les sorties, le cas échéant?
Temps de compilation
- Le programme n'a besoin de satisfaire aucun invariant. En fait, il ne doit pas du tout s'agir d'un programme bien formé. Vous pouvez transmettre ce code HTML au compilateur et le regarder.
- Qu'est-ce qui peut aller mal au moment de la compilation:
- Erreurs de syntaxe
- Erreurs de vérification
- (Rarement) le compilateur plante
- Si le compilateur réussit, que savons-nous?
- Le programme était bien formé - un programme significatif dans n'importe quelle langue.
- Il est possible de lancer le programme. (Le programme peut échouer immédiatement, mais au moins nous pouvons essayer.)
- Quelles sont les entrées et les sorties?
- Le programme en cours de compilation était saisi en entrée, ainsi que tous les fichiers d'en-tête, interfaces, bibliothèques ou autres outils nécessaires à importer pour être compilés.
- J'espère que la sortie est un code Assembly ou un code objet pouvant être déplacé, voire un programme exécutable. Ou si quelque chose ne va pas, la sortie est un tas de messages d'erreur.
Temps d'exécution
- Nous ne savons rien des invariants du programme - ce sont ce que le programmeur a mis. Les invariants d'exécution sont rarement appliqués par le compilateur seul; il a besoin de l'aide du programmeur.
Les erreurs au moment de l'exécution:
- Division par zéro
- Déréférencer un pointeur nul
- À court de mémoire
De plus, il peut y avoir des erreurs détectées par le programme lui-même:
- Essayer d'ouvrir un fichier qui n'est pas là
- Essayer de trouver une page Web et de découvrir qu'une URL supposée n'est pas bien formée
- Si l'exécution réussit, le programme se termine (ou continue) sans se planter.
- Les entrées et les sorties sont entièrement laissées au programmeur. Fichiers, fenêtres à l'écran, paquets réseau, tâches envoyées à l'imprimante, vous le nommez. Si le programme lance des missiles, c'est une sortie qui ne se produit qu'au moment de l'exécution :-)
J'y pense en termes d'erreurs et quand elles peuvent être attrapées.
Temps de compilation:
string my_value = Console.ReadLine();
int i = my_value;
Une valeur de chaîne ne peut pas être affectée à une variable de type int, le compilateur sait donc à coup sûr au moment de la compilation que ce code a un problème
Temps d'exécution:
string my_value = Console.ReadLine();
int i = int.Parse(my_value);
Ici, le résultat dépend de la chaîne renvoyée par ReadLine (). Certaines valeurs peuvent être analysées dans un entier, d'autres pas. Ceci ne peut être déterminé que pendant le temps d'exécution
Compile-time: la période de temps pendant laquelle vous, le développeur, compilez votre code.
Durée: la période pendant laquelle un utilisateur exécute votre logiciel.
Avez-vous besoin d'une définition plus claire?
( edit : ce qui suit s’applique à C # et aux langages de programmation similaires fortement typés. Je ne sais pas si cela vous aidera).
Par exemple, l'erreur suivante sera détectée par le compilateur (à à la compilation ) avant d'exécuter un programme et entraînera une erreur de compilation:
int i = "string"; --> error at compile-time
D'autre part, une erreur comme celle-ci ne peut pas être détectée par le compilateur. Vous recevrez une erreur/une exception à run-time (lorsque le programme est exécuté).
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 traduction du code source en éléments pouvant se produire sur [écran | disque | réseau] peut se produire de deux manières (environ); appelez-les compiler et interpréter.
Dans un programme compilé (les exemples sont c et fortran):
- Le code source est introduit dans un autre programme (généralement appelé compilateur - go figure), qui produit un programme exécutable (ou une erreur).
- L'exécutable est exécuté (en double-cliquant dessus ou en tapant son nom sur la ligne de commande)
On dit que les choses qui arrivent dans la première étape arrivent au "moment de la compilation", les choses qui arrivent dans la deuxième étape se passent au "temps d'exécution".
Dans un programme interprété (exemple Microsoft basic (sur dos) et python (je pense)):
- Le code source est introduit dans un autre programme (généralement appelé un interpréteur) qui le "lance" directement. Ici, l'interprète sert de couche intermédiaire entre votre programme et le système d'exploitation (ou le matériel dans des ordinateurs très simples).
Dans ce cas, la différence entre le temps de compilation et le temps d'exécution est plus difficile à cerner et beaucoup moins pertinente pour le programmeur ou l'utilisateur.
Java est une sorte d'hybride, où le code est compilé en bytecode, qui s'exécute ensuite sur une machine virtuelle qui est généralement un interpréteur pour le bytecode.
Il existe également un cas intermédiaire dans lequel le programme est compilé en bytecode et exécuté immédiatement (comme dans awk ou Perl).
Fondamentalement, si votre compilateur peut comprendre ce que vous voulez dire ou quelle valeur est "au moment de la compilation", il peut le coder en dur dans le code d'exécution. Évidemment, si votre code d’exécution doit faire un calcul à chaque fois, il fonctionnera plus lentement, donc si vous pouvez déterminer quelque chose au moment de la compilation, c’est beaucoup mieux.
Par exemple.
Pliage constant:
Si j'écris:
int i = 2;
i += MY_CONSTANT;
Le compilateur peut effectuer ce calcul lors de la compilation car il sait ce que 2 est et ce que MY_CONSTANT est. En tant que tel, il évite d'effectuer un calcul à chaque exécution.
Hmm, ok bien, le runtime est utilisé pour décrire quelque chose qui se produit quand un programme est en cours d'exécution.
Le temps de compilation est utilisé pour décrire quelque chose qui se produit lors de la création d'un programme (généralement par un compilateur).
Suite d'une réponse similaire précédente de la question Quelle est la différence entre une erreur d'exécution et une erreur du compilateur?
Compilation/Temps de compilation/Syntaxe/Erreurs sémantiques: Les erreurs de compilation ou de compilation sont des erreurs dues à une faute de frappe. Si nous ne suivons pas la syntaxe et la sémantique correctes d'un langage de programmation, les erreurs de compilation sont générées . Ils ne laisseront pas votre programme exécuter une seule ligne jusqu'à ce que vous supprimiez toutes les erreurs de syntaxe ou que vous ne déboguiez pas les erreurs de compilation.
Exemple: Manquer un point-virgule en C ou saisir int en tant que Int.
Erreurs d'exécution: Les erreurs d'exécution sont les erreurs générées lorsque le programme est en cours d'exécution. Ces types d'erreurs provoqueront un comportement inattendu de votre programme, voire le tueront. Ils sont souvent appelés des exceptions.
Exemple: Supposons que vous lisiez un fichier qui n’existe pas, ce qui entraînera une erreur d’exécution.
En savoir plus sur tous erreurs de programmation ici
Temps de compilation:
Les tâches effectuées au moment de la compilation n'engendrent (pratiquement) aucun coût lors de l'exécution du programme résultant, mais peuvent entraîner des coûts importants lors de la création du programme.
Durée d'exécution:
Plus ou moins l'exact opposé. Peu de frais lorsque vous construisez, plus de coûts lorsque le programme est exécuté.
Depuis l'autre côté; Si quelque chose est fait au moment de la compilation, il ne s'exécute que sur votre machine et s'il s'agit d'une exécution, il s'exécute sur la machine de vos utilisateurs.
Pertinence
Un exemple de ce qui est important serait un type d'unité transportant. Une version de compilation (comme Boost.Units ou ma version de D ) finit par être aussi rapide que de résoudre le problème avec du code natif à virgule flottante, tandis qu'une version d'exécution finit par avoir à emballer des informations sur les unités dans lesquelles une valeur se trouve et les vérifie à chaque opération. D'autre part, les versions à la compilation exigent que les unités des valeurs soient connues au moment de la compilation et ne puissent pas gérer le cas où elles proviennent d'une entrée à l'exécution.
Par exemple: Dans un langage fortement typé, un type peut être vérifié à la compilation ou à l'exécution. Au moment de la compilation, cela signifie que le compilateur se plaint si les types ne sont pas compatibles. Au moment de l'exécution, cela signifie que vous pouvez bien compiler votre programme, mais qu'il lance une exception.
Simplement la différence entre mots n/w Compile time & Run time.
temps de compilation: le développeur écrit le programme au format .Java et le convertit en Bytecode qui est un fichier de classe. Pendant cette compilation, toute erreur éventuelle peut être définie comme une erreur de temps de compilation.
Durée d'exécution: le fichier .class généré est utilisé par l'application pour ses fonctionnalités supplémentaires. La logique s'avère être fausse et génère une erreur qui est une erreur d'exécution.
Voici une citation de Daniel Liang, auteur de "Introduction à la programmation Java", sur le sujet de la compilation:
"Un programme écrit dans un langage évolué est appelé programme source ou code source. Puisqu'un ordinateur ne peut exécuter un programme source, un programme source doit être traduit en code machineexécution. La traduction peut être effectuée à l'aide d'un autre outil de programmation appelé interprète ou compilateur. " (Daniel Liang, "Introduction à la programmation Java" , p8).
...Il continue...
"Un compilateur traduit l'intégralité du code source _ en un fichier code machine, et le fichier du code machine est ensuite exécuté"
Lorsque nous introduisons du code de haut niveau/lisible par l'homme, cela est, au début, inutile! Cela doit être traduit en une séquence de «happenings électroniques» dans votre tout petit processeur! La première étape dans cette direction est la compilation.
En termes simples: une erreur de compilation survient pendant cette phase, tandis qu'une erreur d'exécution se produit plus tard.
Rappelez-vous: le fait qu'un programme soit compilé sans erreur ne signifie pas qu'il s'exécutera sans erreur.
Une erreur d'exécution se produira dans la partie prête, en cours d'exécution ou en attente du cycle de vie d'un programme, tandis qu'une erreur lors de la compilation se produira avant la phase "Nouveau" du cycle de vie.
Exemple d'erreur de compilation:
Une erreur de syntaxe - comment votre code peut-il être compilé en instructions de niveau machine si elles sont ambiguës? Votre code doit se conformer à 100% aux règles syntaxiques du langage, sinon il ne peut pas être compilé en travail code machine .
Exemple d'erreur d'exécution:
Manquer de mémoire - Un appel à une fonction récursive, par exemple, peut entraîner un dépassement de capacité de la pile en fonction d'une variable d'un degré particulier! Comment cela peut-il être anticipé par le compilateur!? ça ne peut pas.
Et c’est la différence entre une erreur de compilation et une erreur d’exécution
Pour compléter les autres réponses, voici comment je l'expliquerais à un profane:
Votre code source est comme le plan d'un navire. Il définit comment le navire doit être fabriqué.
Si vous remettez votre plan au chantier naval et que celui-ci trouve un défaut lors de la construction du navire, il arrêtera de le construire et vous le signalera immédiatement, avant que le navire ait quitté la cale sèche ou touché l'eau. C'est une erreur de compilation. Le navire n'a jamais même flotté ou utilisé ses moteurs. L'erreur a été trouvée parce qu'elle empêchait même le navire d'être fait.
Lorsque votre code est compilé, c'est comme si le vaisseau était en train d'être terminé. Construit et prêt à partir. Lorsque vous exécutez votre code, cela revient à lancer le navire dans un voyage. Les passagers sont montés à bord, les moteurs tournent et la coque est sur l'eau, donc c'est l'heure de la course. Si votre navire a un défaut fatal qui le fait sombrer lors de son voyage inaugural (ou peut-être un voyage après pour des maux de tête supplémentaires), il a subi une erreur d'exécution.
L'exécution signifie que quelque chose se passe lorsque vous exécutez le programme.
Le temps de compilation signifie que quelque chose se passe lorsque vous compilez le programme.
Temps de compilation: Le temps nécessaire pour convertir le code source en code machine afin qu’il devienne un exécutable est appelé temps de compilation.
Durée d'exécution: Lorsqu'une application est en cours d'exécution, elle s'appelle exécution.
Les erreurs de compilation sont les erreurs de syntaxe, les erreurs de référence de fichier manquantes. Des erreurs d’exécution surviennent après la compilation du code source dans un programme exécutable et pendant l’exécution du programme. Des exemples sont les plantages de programmes, les comportements de programmes inattendus ou les fonctionnalités ne fonctionnent pas.
Temps de compilation:
Les tâches effectuées au moment de la compilation n'engendrent (presque) aucun coût lors de l'exécution du programme résultant, mais peuvent entraîner des coûts importants lors de la création du programme ..
Plus ou moins l'exact opposé. Peu de frais lorsque vous construisez, plus de coûts lorsque le programme est exécuté.
Depuis l'autre côté; Si quelque chose est fait au moment de la compilation, il ne s'exécute que sur votre machine et s'il s'agit d'une exécution, il s'exécute sur la machine de vos utilisateurs.
Voici une extension de la réponse à la question "différence entre l'exécution et la compilation?" - Différences dans overheads associées à l'exécution et à la compilation?
La performance d'exécution du produit contribue à sa qualité en fournissant des résultats plus rapidement. Les performances du produit au moment de la compilation contribuent à son actualité en raccourcissant le cycle édition-compilation-débogage. Toutefois, les performances d'exécution et de compilation sont des facteurs secondaires pour obtenir une qualité optimale. Par conséquent, il convient d’envisager des améliorations des performances au moment de l’exécution et de la compilation uniquement lorsque cela est justifié par des améliorations de la qualité et de la rapidité des produits.
Une excellente source de lecture ici :
J'y ai toujours pensé par rapport aux frais généraux de traitement de programme et à son incidence sur la performance, comme indiqué précédemment. Un exemple simple serait soit de définir la mémoire absolue requise pour mon objet dans le code ou non.
Un booléen défini prend x mémoire. Il est alors dans le programme compilé et ne peut pas être modifié. Lorsque le programme est exécuté, il sait exactement combien de mémoire allouer pour x.
Par contre, si je viens de définir un type d’objet générique (c’est-à-dire un type d’espace réservé indéfini ou peut-être un pointeur sur un blob géant), la mémoire requise pour mon objet n’est pas connue avant que le programme ne soit exécuté et que je ne lui attribue quelque chose , il doit donc être évalué et l’allocation de mémoire, etc., sera ensuite gérée de manière dynamique au moment de l’exécution (temps supplémentaire d’exécution).
La façon dont il est géré dynamiquement dépend alors de la langue, du compilateur, du système d'exploitation, de votre code, etc.
Sur cette note cependant, cela dépend vraiment du contexte dans lequel vous utilisez le temps d’exécution par rapport au temps de compilation.
voici une réponse très simple:
Runtime et compile time sont des termes de programmation faisant référence à différentes étapes du développement d'un logiciel . Pour créer un programme, le développeur écrit d'abord le code source, qui définit le fonctionnement du programme. Les petits programmes ne peuvent contenir que quelques centaines de lignes de code source, alors que les grands programmes peuvent contenir des centaines de milliers de lignes de code source. Le code source doit être compilé en code machine pour devenir un programme exécutable. Ce processus de compilation est appelé temps de compilation (pensez à un compilateur en tant que traducteur).
Un programme compilé peut être ouvert et exécuté par un utilisateur. Lorsqu'une application est en cours d'exécution, cela s'appelle le runtime.
Les termes "exécution" et "temps de compilation" sont souvent utilisés par les programmeurs pour désigner différents types d'erreurs. Une erreur de compilation est un problème tel qu'une erreur de syntaxe ou une référence de fichier manquante qui empêche le programme de compiler correctement. Le compilateur génère des erreurs de compilation et indique généralement quelle ligne du code source est à l'origine du problème.
Si le code source d'un programme a déjà été compilé dans un programme exécutable, des bogues peuvent encore se produire pendant l'exécution du programme. Les exemples incluent des fonctionnalités qui ne fonctionnent pas, un comportement de programme inattendu ou un blocage du programme. Ces types de problèmes sont appelés erreurs d'exécution car ils se produisent au moment de l'exécution.
nous pouvons les classer sous deux grands groupes différents: liaison statique et liaison dynamique. Il est basé sur le moment où la liaison est faite avec les valeurs correspondantes. Si les références sont résolues lors de la compilation, il s'agit d'une liaison statique et si les références sont résolues lors de l'exécution, il s'agit d'une liaison dynamique. La liaison statique et la liaison dynamique sont également appelées liaison précoce et liaison tardive. Parfois, ils sont également appelés polymorphisme statique et polymorphisme dynamique.
Joseph Kulandai.
Regardez dans cet exemple:
public class Test {
public static void main(String[] args) {
int[] x=new int[-5];//compile time no error
System.out.println(x.length);
}}
Le code ci-dessus est compilé avec succès, il n’ya pas d’erreur de syntaxe, il est parfaitement valide . Mais au moment de l’exécution, il génère l’erreur suivante.
Exception in thread "main" Java.lang.NegativeArraySizeException
at Test.main(Test.Java:5)
Comme lors de la compilation de certains cas, certains cas ont été vérifiés une fois que le programme a rempli la condition voulue pour obtenir une sortie ..__ Sinon, vous obtiendrez une erreur lors de la compilation ou une exécution.
Imaginez que vous êtes un patron et que vous avez un assistant et une bonne, et que vous leur donnez une liste de tâches à effectuer, l’assistant (heure de compilation) saisit cette liste et fait un bilan pour voir si les tâches sont compréhensibles et que vous n'a pas écrit dans une langue ou une syntaxe maladroite, il comprend donc que vous souhaitiez affecter quelqu'un à un emploi; il vous l'a donc assigné et il comprend que vous souhaitiez un peu de café; son rôle est donc terminé et la femme de chambre (temps d'exécution) commence à exécuter ces tâches alors elle va vous préparer du café mais tout à coup elle ne trouve plus de café à préparer, alors elle cesse de le faire ou elle agit différemment et vous prépare du thé (lorsque le programme agit différemment car il a trouvé une erreur ).
La principale différence entre le temps d'exécution et le temps de compilation est la suivante:
- S'il y a des erreurs de syntaxe et que le type vérifie votre code, il renvoie une erreur de compilation, où -sans l'exécution: il vérifie après l'exécution du code .
int a = 1
int b = a/0;
ici, la première ligne n'a pas de point-virgule à la fin ---> erreur de compilation après l'exécution du programme lors de l'exécution de l'opération b, le résultat est infini ---> erreur d'exécution.
- Le temps de compilation ne recherche pas la sortie des fonctionnalités fournies par votre code, contrairement à l'exécution.
À mon humble avis, vous devez lire de nombreux liens et ressources pour vous faire une idée de la différence entre le temps d’exécution et le temps de compilation, car c’est un sujet très complexe. J'ai la liste ci-dessous certaines de ces images/liens que je vous recommande.
Outre ce qui est dit ci-dessus, je souhaite ajouter que parfois une image vaut 1000 mots:
- l'ordre de ces deux: le premier est le temps de compilation, puis vous exécutez Un programme compilé peut être ouvert et exécuté par un utilisateur. Lorsqu'une application est en cours d'exécution, elle s'appelle runtime: Compile time, puis runtime1
![compile time and then runtime1]()
;
; CLR_diag compile time puis runtime2 
from Wiki
https://en.wikipedia.org/wiki/Run_timehttps://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase)
L'exécution, l'exécution ou l'exécution peuvent faire référence à:
L'informatique
Durée d'exécution (phase du cycle de vie du programme), période d'exécution d'un programme d'ordinateur
Runtime library, une bibliothèque de programmes conçue pour implémenter des fonctions intégrées à un langage de programmation
Runtime system, logiciel conçu pour permettre l'exécution de programmes informatiques
Exécution du logiciel, processus consistant à exécuter des instructions une par une pendant la phase d'exécution
Liste des compilateurs 
https://en.wikipedia.org/wiki/List_of_compilers
- rechercher sur google et comparer les erreurs d'exécution et les erreurs de compilation:
;
- À mon avis, il est très important de savoir: 3.1 la différence entre build vs compile et Build Lifecycle https://maven.Apache.org/guides/introduction/introduction-to-the-lifecycle .html
3.2 la différence entre ces 3 choses: compiler vs construire vs runtime
https://www.quora.com/What-is-the-difference-between-build-run-and-compile Fernando Padoan, un développeur un peu curieux pour la conception de langage Répondu le 23 février. Je reviens en arrière par rapport à d’autres réponses:
exécuter, c’est obtenir un exécutable binaire (ou un script pour les langages interprétés), bien… exécuté comme un nouveau processus sur l’ordinateur; compiler est le processus d’analyse d’un programme écrit dans un langage de haut niveau en code machine), en vérifiant la syntaxe, la sémantique, la liaison de bibliothèques, peut-être une optimisation, puis la création d’un programme exécutable binaire en sortie. Cet exécutable peut prendre la forme de code machine ou d’un type de code octet, c’est-à-dire des instructions ciblant un type de machine virtuelle; la construction implique généralement la vérification et la fourniture de dépendances, le des tests automatisés et le conditionnement des fichiers binaires résultants et d'autres actifs (images, fichiers de configuration, bibliothèques, etc.) dans un format spécifique de fichier déployable. Notez que la plupart des processus sont facultatifs et que certains dépendent de la plate-forme ciblée pour laquelle vous créez. À titre d'exemple, le conditionnement d'une application Java pour Tomcat générera un fichier .war. Construire un exécutable Win32 à partir de code C++ peut simplement sortir le programme .exe ou l’intégrer dans un programme d’installation .msi.
classe publique 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{
}