Compile-time et Runtime sont les deux termes de programmation utilisés dans le développement de logiciels. Le moment de la compilation est l'heure à laquelle le code source est converti en code exécutable tandis que le moment de l'exécution est l'heure à laquelle l'exécution du code exécutable commence. Le moment de la compilation et celui de l'exécution font référence à différents types d'erreurs.

Erreurs de compilation

Les erreurs au moment de la compilation sont les erreurs qui se produisent lorsque nous écrivons une syntaxe incorrecte. Si nous écrivons la mauvaise syntaxe ou sémantique d’un langage de programmation, les erreurs de compilation seront renvoyées par le compilateur. Le compilateur ne permettra pas d'exécuter le programme tant que toutes les erreurs n'auront pas été supprimées du programme. Lorsque toutes les erreurs sont supprimées du programme, le compilateur génère le fichier exécutable.

sous-chaîne chaîne java

Les erreurs de compilation peuvent être :

• Erreurs de syntaxe
• Erreurs sémantiques

Erreurs de syntaxe

Lorsque le programmeur ne suit la syntaxe d’aucun langage de programmation, le compilateur génère une erreur de syntaxe.

Par exemple,

int a, b :

La déclaration ci-dessus génère l'erreur de compilation comme en C, chaque instruction se termine par un point-virgule, mais nous mettons un deux-points (:) à la fin de l'instruction.

Erreurs sémantiques

Les erreurs sémantiques existent lorsque les instructions n'ont pas de sens pour le compilateur.

Par exemple,

a+b=c;

L'instruction ci-dessus génère des erreurs de compilation. Dans l'instruction ci-dessus, nous attribuons la valeur de « c » à la somme de « a » et « b », ce qui n'est pas possible en langage de programmation C car elle ne peut contenir qu'une seule variable à gauche de l'opérateur d'affectation tandis qu'à droite de l'opérateur d'affectation peut contenir plusieurs variables.

La déclaration ci-dessus peut être réécrite comme suit :

c=a+b;

Erreurs d'exécution

Les erreurs d'exécution sont les erreurs qui surviennent lors de l'exécution et après la compilation. Les exemples d'erreurs d'exécution sont la division par zéro, etc. Ces erreurs ne sont pas faciles à détecter car le compilateur ne pointe pas vers ces erreurs.

Explorons quelques C typiques types d'erreurs d'exécution, cas , et leurs effets possibles.

Division par zéro:

Puisque la division par zéro est mathématiquement indéfinissable , en essayant de diviser un entier par zéro conduit à un erreur d'exécution . Cette erreur provoque le crash du programme ou génère une exception. Voici un exemple :

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

Sortir:

entreprise contre entreprise

 Floating point exception (core dumped) 

Explication:

UN 'Exception à virgule flottante' Un message d'erreur est généré lorsque le programme rencontre un problème d'exécution en raison d'une division par zéro.

Accès au tableau hors limites :

UN erreur d'exécution se produit lorsqu'un élément du tableau est accédé en dehors de certaines limites. Une erreur se produit lorsqu'un index est plus grand que la taille du tableau et que les lois d'accès à la mémoire sont enfreintes. Voici un exemple :

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

Sortir:

 Segmentation fault (core dumped) 

Explication:

L'élément à indice 10 est au-delà des limites du tableau lorsque le programme tente d'y accéder. En conséquence, un une erreur de segmentation se produit , et le programme se termine par une erreur.

Déréférencement de pointeur nul :

UN erreur d'exécution se produit lorsque vous essayez d'accéder à un mémoire du pointeur nul adresse, connue sous le nom de déréférencement un pointeur nul. L'accès aux pointeurs nuls entraîne un comportement imprévisible car ils ne pointent pas vers emplacements de mémoire légitimes . Voici un exemple :

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

Sortir:

trouver des numéros bloqués sur Android

 Segmentation fault (core dumped) 

Explication:

La tentative de déréférencement un pointeur nul entraîne un erreur de segmentation , ce qui provoque le crash du programme avec un message d'erreur.

Débordement de pile :

UN débordement de pile se produit lorsque la pile d'appels devient plus grande que prévu, contenant des informations sur les appels de fonction. Un récursivité infinie se produit généralement lorsque les fonctions récursives manquent de critères de terminaison appropriés. Voici un exemple :

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

Sortir:

 Segmentation fault (core dumped) 

Explication:

Le programme démarre un récursivité sans fin , ce qui déborde de la pile et provoque une erreur de segmentation.

Variables inutilisées :

Parce que variables non initialisées avoir valeurs non définies , leur utilisation peut entraîner des erreurs d'exécution. Le programme pourrait fournir des résultats surprenants ou planter, selon les circonstances. Voici un exemple :

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

Sortir:

 Some random value (varies each time) 

Explication:

Dans cet exemple, la valeur d'un variable non initialisée peut être n'importe quelle valeur aléatoire choisie au hasard dans la région de mémoire désignée pour cette variable.

Examinons les différences entre la compilation et l'exécution :

Exemple d'erreur au moment de la compilation

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

Dans le code ci-dessus, nous avons essayé d'imprimer la valeur de « a », mais cela génère une erreur. Nous mettons les deux points à la fin de l'instruction au lieu d'un point-virgule, ce code génère donc une erreur de compilation.

Sortir

Exemple d'erreur d'exécution

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

Dans le code ci-dessus, nous essayons de diviser la valeur de « b » par zéro, ce qui génère une erreur d'exécution.

Sortir

chaîne en json java

Conclusion:

En conclusion, les périodes de développement de logiciels connu comme moment de la compilation et erreurs d'exécution sont séparés et chacun possède un ensemble unique de défauts cela pourrait arriver. Erreurs de compilation se produire lorsque le code est converti en forme exécutable lors de l'étape de compilation. Ces erreurs incluent erreurs sémantiques , qui produisent illogique ou code absurde , et défauts de syntaxe , qui vont à l’encontre des lois du langage de programmation. Ces erreurs sont identifiées par le compilateur et signalé, bloquer l'exécution du code jusqu'à ce qu'ils soient corrigés.

D'autre part, erreurs d'exécution se produisent lorsqu'un programme est en cours d'exécution et ne sont pas interceptés par le compilateur. Ils peuvent résulter de plusieurs conditions, notamment division par zéro, accès mémoire erroné , ou d'autres événements imprévus. Erreurs d'exécution sont plus difficiles à découvrir et à déboguer car ils entraînent fréquemment des plantages du programme ou un comportement inattendu. Pour gérer avec élégance les erreurs d'exécution et garantir la stabilité du programme, les développeurs utilisent techniques de gestion des erreurs comme gestion des exceptions .