Exécution vs temps de compilation

je pense à elle en termes d'erreurs, et quand ils peuvent être pris.

compiler time:

string my_value = Console.ReadLine();
int i = my_value;

une valeur de chaîne de caractères ne peut pas être assignée à une variable de type int, donc le compilateur sait avec certitude au moment de la compilation que ce code a un problème

moment de l'Exécution:

string my_value = Console.ReadLine();
int i = int.Parse(my_value);

ici le résultat dépend de quelle chaîne a été retournée par ReadLine (). Certaines valeurs peuvent être interprétées int, les autres ne peuvent pas. Cela ne peut être déterminé qu'à durée d'exécution

au moment de la Compilation: la période de temps dans lequel vous, le développeur, sont la compilation de votre code.

Run-time: la période de temps sur laquelle un utilisateur est en cours d'exécution de 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 aide).

par exemple, l'erreur suivante sera détectée par le compilateur (à compiler time ) avant d'exécuter un programme et résultera en une erreur de compilation:

int i = "string"; --> error at compile-time

par contre, une erreur comme celle-ci ne peut pas être détectée par le compilateur. Vous recevoir une erreur / exception à run-time (quand le programme est lancé).

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 stuff-happening-on-the-[screen|disk|network] peut se produire de deux façons (en gros): les appeler compiler et interpréter.

dans un programme compilé (exemples: c et fortran):

1. 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).
2. L'exécutable est lancé (par double-cliquer dessus, ou taper son nom sur la ligne de commande)

des Choses qui arrivent dans la première étape sont dit d'arriver à la "compilation", des choses qui arrivent dans la deuxième étape sont dit d'arriver au "temps d'exécution".

Dans un interprété du programme (exemple MicroSoft de base (sur le dos) et python (je pense)):

1. le code source est introduit dans un autre programme (généralement appelé un interprète), qui "court" directement. Ici, l'interpréteur Sert de couche intermédiaire entre votre programme et le système d'exploitation (ou le matériel dans les ordinateurs vraiment simples).

dans ce cas, la différence entre le temps de compilation et le temps d'exécution est plus difficile à déterminer, et beaucoup moins pertinente pour le programmeur ou l'utilisateur.

Java est une sorte d'hybride, où le code est compilé en bytecode, qui exécute alors sur un machine virtuelle qui est habituellement un interpréteur pour le bytecode.

il y a aussi un cas intermédiaire dans lequel le programme est compilé pour bytecode et exécuté immédiatement (comme dans awk ou perl).

en gros, si votre compilateur peut comprendre ce que vous voulez dire ou ce qu'est une valeur" 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 s'exécutera plus lentement, donc si vous pouvez déterminer quelque chose au moment de la compilation, c'est beaucoup mieux.

par exemple.

Constantes:

si j'écris:

int i = 2;
i += MY_CONSTANT;

le compilateur peut effectuer ceci calulation au moment de la compilation car il sait ce qu'est 2 et ce qu'est MY_CONSTANT. En tant que tel il se sauve de l'exécution du calcul chaque exécution simple.

Hmm, ok bien, 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 quand un programme est construit (habituellement, par un compilateur).

suite à la réponse précédente similaire à la question Quelle est la différence entre l'erreur d'exécution et l'erreur de compilation?

Compilation/Compilation/Syntaxe/Sémantique des erreurs: de la Compilation ou de la compilation des erreurs sont erreur s'est produite en raison de faute de frappe, si on ne suit pas la bonne syntaxe et la sémantique d'un langage de programmation, puis la compilation des erreurs générées par le compilateur. Ils ne laisseront pas votre programme pour exécuter une seule ligne jusqu'à ce que vous supprimiez toutes les erreurs de syntaxe ou jusqu'à ce que vous déboguiez les erreurs de compilation.

Exemple: absence d'un point-virgule en C ou confusion de int avec Int .

erreurs d'Exécution: erreurs d'Exécution sont les erreurs qui sont générés lorsque le programme est en cours d'exécution. Ces types d'erreurs feront que votre programme se comporte de façon inattendue ou peuvent même tuer votre programme. Ils sont souvent désignés comme Exception.

Exemple: supposons que vous lisiez un fichier qui n'existe pas, il en résultera une erreur d'exécution.

plus d'informations à propos de tous erreurs de programmation ici

Compiler Time:

les choses qui sont faites au moment de la compilation n'entraînent (presque) aucun coût lorsque le programme résultant est exécuté, mais peuvent entraîner des coûts importants lorsque vous construisez le programme.

Run-Time:

plus ou moins exactement le contraire. Petit coût quand vous construisez, plus de coût quand le programme est exécuté.

de l'autre côté; si quelque chose est fait au moment de la compilation, il ne tourne que sur votre machine et si quelque chose est le temps de fonctionnement, il fonctionne sur votre machine d'utilisateurs.

pertinence

un exemple de cas où cela est important serait un type de transport d'unité. Une version de compilation (comme Boost.Unités ou ma version en D ) finit par être tout aussi rapide que la résolution du problème avec le code flottant natif tandis qu'une version d'exécution finit par avoir à emballer des informations sur les unités qu'une valeur sont dans et effectuer des vérifications en eux, à côté de chaque opération. D'un autre côté, les versions de compilation time exigent que les unités des valeurs soient connues au moment de la compilation et ne puissent pas traiter le cas où elles proviennent de l'entrée d'exécution.

par exemple: dans un langage fortement typé, un type peut être vérifié lors de la compilation ou lors de l'exécution. Au moment de la compilation, cela signifie que le compilateur se plaint si les types ne sont pas compatibles. À l'exécution signifie, que vous pouvez compiler votre programme juste bien, mais à l'exécution, il jette une exception.

En tout simplement word différence b/w moment de la Compilation et de l'Exécution.

compiler le temps: le développeur écrit le programme .java format & converts en Bytecode qui est un fichier de classe, lors de cette compilation toute erreur se produit peut être définie comme une erreur de compilation.

de l'Exécution:Le générés .fichier de classe est utilisé par l'application pour ses fonctionnalités supplémentaires et la logique s'avère être fausse et déclenche une erreur, une erreur d'exécution

Voici une citation de Daniel Liang, auteur de 'Introduction to JAVA programming', sur le sujet de la compilation:

"Un programme écrit dans un langage de haut niveau est appelé un programme source ou de code source. Parce qu'un ordinateur ne peut pas exécuter un programme source, UN programme source doit être traduit en code machine pour exécution . La traduction peut être faite en utilisant une autre outil de programmation appelé un interprète ou un compilateur ."(Daniel Liang, , "Introduction à la programmation JAVA" , p8).

...Il Continue...

"un compilateur traduit la totalité du code source en un fichier de code machine , et le fichier de code machine est alors exécuté"

quand on frappe code de haut niveau/lisible par l'homme c'est, au début, inutile! Il doit être traduit en une séquence de "happenings électroniques" dans votre minuscule petit CPU! La première étape vers ce qui est de la compilation.

pour faire simple: une erreur de compilation se produit pendant cette phase, tandis qu'une erreur d'exécution se produit plus tard.

rappelez-vous: ce n'est pas parce qu'un programme est compilé sans erreur qu'il fonctionnera sans erreur.

Une erreur D'exécution se produira dans la partie "ready", "running" ou "waiting" du cycle de vie d'un programme, tandis qu'une erreur de compilation se produira avant la "nouvelle" étape du cycle de vie.

exemple d'une erreur de compilation:

une erreur de syntaxe-comment votre code peut-il être compilé dans des instructions au niveau de la 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é dans le travail code machine .

exemple d'erreur d'exécution:

manquer de mémoire - un appel à une fonction récursive par exemple pourrait conduire à un débordement de pile étant donné une variable d'un degré particulier! Comment cela peut-il être anticipé par le compilateur!? il ne peut pas.

Et c'est la différence entre une erreur de compilation et d'une erreur d'exécution

en complément des autres réponses, voici comment je l'expliquerais à un profane:

votre code source est comme le plan d'un vaisseau. Il définit la façon dont le navire doit être construit.

si vous remettez votre plan au chantier naval, et qu'ils trouvent un défaut lors de la construction du navire, ils arrêteront la construction et vous le signaleront immédiatement, avant que le navire n'ait jamais quitté la cale sèche ou touché l'eau. C'est une erreur de compilation. Le navire n'a même jamais été flottant ou utilisant ses moteurs. L'erreur a été trouvée parce qu'il a empêché le navire même.

quand votre code se compile, c'est comme si le vaisseau était terminé. Construit et prêt à aller. Quand vous exécutez votre code, c'est comme lancer le navire dans un voyage. Les passagers sont montés à bord, les moteurs fonctionnent et la coque est sur l'eau, donc c'est l'Heure de départ. Si votre navire a un défaut fatal qui le coule sur son voyage inaugural (ou peut-être un certain voyage après pour plus maux de tête), puis il a subi une erreur runtime.

Run time signifie que quelque chose se produit lorsque vous exécutez le programme.

temps de compilation signifie que quelque chose se produit lorsque vous compilez le programme.

Compiler Time:

les choses qui sont faites au moment de la compilation n'entraînent (presque) aucun coût lorsque le programme résultant est exécuté, mais peuvent entraîner des coûts importants lorsque vous construisez le programme. Au Moment De L'Exécution:

plus ou moins exactement le contraire. Petit coût quand vous construisez, plus de coût quand le programme est exécuté.

De l'autre côté; Si quelque chose est fait au moment de la compilation, il fonctionne uniquement sur votre machine et si quelque chose est au moment de l'exécution, de l'exécuter sur votre machine à utilisateurs.

voici une extension à la réponse à la question "différence entre le temps d'exécution et le temps de compilation?"-- Différences dans les frais généraux associés à l'exécution et au moment de la compilation?

les performances d'exécution du produit contribuent à sa qualité en fournissant des résultats plus rapidement. Les performances de compilation du produit contribuent à son actualité en raccourcissant le cycle d'édition-compilation-débogage. Cependant, à la fois les performances d'exécution et les performances en matière de compilation sont des facteurs secondaires pour parvenir à une qualité en temps voulu. Par conséquent, on ne devrait envisager d'améliorer les performances d'exécution et de compilation que si cela se justifie par des améliorations de la qualité globale du produit et de l'actualité.

une grande source pour lire la suite ici :

j'ai toujours pensé à lui par rapport aux frais généraux de traitement de programme et comment il affecte la préformance comme précédemment indiqué. Un exemple simple serait, soit définir la mémoire absolue requise pour mon objet en code ou non.

un booléen défini prend la mémoire x celle-ci est alors dans le programme compilé et ne peut pas être changée. Quand le programme tourne, il sait exactement combien de mémoire allouer pour X.

d'un autre côté si je viens de définir un type d'objet générique (c'est-à-dire une sorte de support de place non défini ou peut-être un pointeur vers un blob géant) la mémoire réelle requise pour mon objet n'est pas connue jusqu'à ce que le programme soit exécuté et je lui attribue quelque chose, donc il doit ensuite être évalué et l'allocation de mémoire, etc. sera ensuite manipulé dynamiquement au moment de l'exécution (plus de temps d'exécution au-dessus).

la façon dont il est géré dynamiquement dépend alors du langage, du compilateur, du système D'exploitation, de votre code, etc.

On cette note cependant, cela dépend vraiment du contexte dans lequel vous utilisez le temps d'exécution vs le temps de compilation.

nous pouvons les classer en deux grands groupes: la liaison statique et la liaison dynamique. Il est basé sur lorsque la liaison est faite avec les valeurs correspondantes. Si les références sont résolues au moment de la compilation, alors c'est une liaison statique et si les références sont résolues au moment de l'exécution, c'est une liaison dynamique. La fixation statique et la fixation dynamique sont également appelées fixation précoce et fixation tardive. Parfois, on parle aussi de polymorphisme statique et de polymorphisme dynamique.

Joseph Kulandai.

la différence majeure entre le temps d'exécution et le temps de compilation est:

1. S'il y a des erreurs de syntaxe et des vérifications de type dans votre code,alors il lance erreur de compilation, où-comme exécution:il vérifie après l'exécution du code. Par exemple:

int a = 1 int b = a/0;

ici, la première ligne n'ont pas de point-virgule à la fin---> erreur de compilation après l'exécution du programme pendant l'exécution de l'opération b, le résultat est infini---> erreur d'exécution.

2. le temps de compilation ne Recherche pas la sortie de la fonctionnalité fournie par votre code, contrairement au temps d'exécution.

voici une réponse très simple:

exécution et temps de compilation sont des termes de programmation qui se réfèrent à différentes étapes du développement de logiciel. Pour créer un programme, un développeur écrit d'abord le code source, qui définit le fonctionnement du programme. De petits programmes ne peut contenir qu'une centaine de lignes de code source, tandis que les grands programmes peuvent contenir des centaines de milliers de lignes de code source. Le code source doit être compilé en code machine dans ordre de devenir et programme exécutable. Ce processus de compilation est appelé le temps de compilation.(pensez à un compilateur comme traducteur)

Un programme compilé peut être ouvert et exécuté par un utilisateur. Quand une application est en cours d'exécution, elle s'appelle 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 comme une erreur de syntaxe ou manquant de référence de fichier qui empêche le programme de la compilation. Le compilateur produit des erreurs de compilation et indique habituellement 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, il peut encore y avoir des bogues qui se produisent pendant que le programme est en cours d'exécution. Des exemples incluent des fonctionnalités qui ne fonctionnent pas, un comportement de programme inattendu, ou des pannes de programme. Ces types de problèmes sont appelés erreurs d'exécution puisqu'ils se produisent à Runtime.

la référence

en dehors de ce qui est dit ci-dessus, je tiens à ajouter que parfois une image vaut 1000 mots:

1. l'ordre de ces deux: d'abord le temps de compilation et ensuite l'exécution Un programme compilé peut être ouvert et exécuté par un utilisateur. Quand une application est en cours d'exécution, elle s'appelle runtime : compiler time et ensuite runtime1 ;

CLR_diag compiler time and then runtime2

2. recherche sur google et comparer les erreurs d'exécution vs compiler les erreurs:

;

3. À mon avis, une chose très importante à savoir : 3.1 la différence entre construire vs compiler et le cycle de vie de la construction https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html

3.2 la différence entre ces 3 choses: compiler vs construire vs exécuter

https://www.quora.com/What-is-the-difference-between-build-run-and-compile Fernando Padoan, un développeur qui est juste un peu curieux pour la conception de la langue Réponse 23 Février Je recule Par rapport à d'autres réponses:

exécuter est d'obtenir un exécutable binaire (ou un script, pour les langues interprétées) pour être, bien… exécuté comme un nouveau processus sur l'ordinateur; la compilation est le processus d'analyse d'un programme écrit dans un langage de haut niveau (plus élevé si comparé au code machine), la vérification de sa syntaxe, la sémantique, les bibliothèques de liaison, peut-être faire une certaine optimisation, puis la création d'un programme exécutable binaire comme une sortie. Cet exécutable peut être sous la forme de code machine, ou une sorte de code octet -, les instructions ciblant une sorte de machine virtuelle; la construction implique généralement de vérifier et de fournir dépendances, inspection du code, compilation du code en binaire, exécution de tests automatisés et empaquetage des binaires résultants et 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 facultatives et certaines dépendent de la plateforme ciblée que vous construisez. Par exemple, empaqueter une application Java pour Tomcat produira A.la guerre de fichier. La construction D'un exécutable à partir du code C++ pourrait juste produire le Win32 .programme exe, ou pourrait aussi paquet à l'intérieur d'un .programme d'installation msi.

compiler time: Le temps nécessaire pour convertir le code source en code machine afin qu'il devienne un exécutable s'appelle le temps de compilation.

moment de l'Exécution: Quand une application est en cours d'exécution, elle s'appelle run time.

les erreurs de temps de compilation sont ces erreurs de syntaxe, les erreurs de référence de fichier manquantes. Les erreurs d'exécution se produisent après que le code source a été compilé dans un programme exécutable et alors que le le programme est en cours d'exécution. Les exemples sont les pannes de programme, le comportement inattendu du programme ou les fonctionnalités ne fonctionnent pas.

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'y a pas d'erreur de syntaxe,il est parfaitement valide. Mais à la course, il jette l'erreur suivante.

Exception in thread "main" java.lang.NegativeArraySizeException
    at Test.main(Test.java:5)

comme quand dans le temps de compilation certains cas ont été vérifiés,après ce temps d'exécution certains cas ont été vérifiés une fois que le programme satisfait à toutes les conditions vous obtiendrez une sortie. Sinon, vous obtiendrez moment de la compilation ou de l'exécution d'erreur.

Ce n'est pas une bonne question pour S. O. (c'est pas une programmation spécifique en question), mais ce n'est pas une mauvaise question en général.

si vous pensez que c'est trivial: qu'en est-il du temps de lecture vs du temps de compilation, et quand est-ce une distinction utile à faire? Qu'en est-il des langues dans lesquelles le compilateur est disponible à l'exécution? Guy Steele (no dummy, he) a écrit 7 pages dans CLTL2 sur EVAL-WHEN, que les programmeurs CL peuvent utiliser pour contrôler cela. 2 phrases suffisent à peine pour un définition , qui lui-même est loin d'être un explication .

en général, il est un problème difficile que les concepteurs de langue ont semblé essayer d'éviter. Ils se contentent souvent de dire "Voici un compilateur, il fait des choses de compilation; tout après cela, c'est l'exécution, amusez-vous". C est conçu pour être simple à mettre en œuvre, pas l'environnement le plus flexible pour le calcul. Lorsque vous n'avez pas le compilateur disponible à l'exécution, ou le capacité de contrôler facilement lorsqu'une expression est évaluée, vous avez tendance à vous retrouver avec des hacks dans le langage pour simuler des utilisations courantes de macros, ou les utilisateurs viennent avec des modèles de conception pour simuler ayant des constructions plus puissantes. Un langage simple à mettre en œuvre peut certainement être un objectif valable, mais cela ne veut pas dire que c'est la fin-tout-être-tout de la conception de langage de programmation. (Je n'utilise pas EVAL-quand beaucoup, mais je ne peux pas imaginer la vie sans elle.)

et l'espaceproblématique autour le temps de compilation et le temps de fonctionnement sont énormes et encore largement inexplorés. Cela ne veut pas dire que le So est le bon endroit pour discuter, mais j'encourage les gens à explorer davantage ce territoire, surtout ceux qui n'ont aucune idée préconçue de ce qu'il devrait être. La question n'est ni simple ni idiote, et nous pourrions au moins indiquer à l'inquisiteur la bonne direction.

malheureusement, je ne connais pas de bonnes références à ce sujet. CLTL2 en parle un peu, mais ce n'est pas idéal pour l'apprentissage à ce sujet.