Débogage

Le processus de suppression des erreurs est généralement appelé débogage. La suppression des erreurs de votre code mérite autant d'attention que la conception originale d'un programme. Cette attention à la suppression des erreurs est importante non seulement parce que les erreurs doivent être supprimées pour que le code fonctionne correctement, mais aussi parce que le taux d'erreur associé au débogage est très élevé. En moyenne, pour deux erreurs que les programmeurs professionnels corrigent, une nouvelle erreur est produite. Il s'agit d'un taux d'erreur beaucoup plus élevé que dans le nouveau codage de programme. Le débogage et les tests ne seront peut-être jamais aussi excitants que le codage original, mais ils seront beaucoup moins frustrants et prendront beaucoup moins de temps si vous corrigez systématiquement les erreurs de votre code.

Correction des erreurs

Les erreurs de syntaxe sont les plus faciles à trouver et à corriger, car QBASIC et QuickBASIC détecte et signale la plupart d'entre elles. Si vous ne comprenez pas immédiatement une erreur, vérifiez attentivement les fautes d'orthographe. Si rien n'est mal orthographié, recherchez le format de l'instruction dans votre texte ou dans la documentation QuickBASIC pour vous assurer que la ligne est conforme aux exigences de de QBASIC ou QuickBASIC.

Les exemples plus contient des exemples de réponses de QuickBASIC à deux erreurs de syntaxe, une faute d'orthographe et l'autre un guillemet manquant. Dans le premier cas, l'erreur est la faute d'orthographe du mot INPUT. Dans de tels cas, l'aide de QBASIC ou QuickBASIC est généralement suffisante pour permettre une correction facile de l'erreur.

L'erreur de format dans le deuxième exemple est l'omission du guillemet précédant le littéral "Adulte". Plutôt que d'être utile, le QBASIC ou le QuickBASIC complique en fait la situation dans ce cas; il pense que l'erreur est un point-virgule manquant et des guillemets fermants, il les ajoute donc. Une simple erreur de syntaxe est maintenant devenue une erreur de logique. Heureusement, de tels cas sont rares.

Les erreurs de logique sont plus difficiles à supprimer que les erreurs de syntaxe. La raison de la difficulté est que vous devez les trouver avant de pouvoir les corriger. En développant et en testant vos programmes un module à la fois, la plupart des erreurs seront confinées au nouveau code. Si vos modules remplissent une seule fonction, ils seront rarement compliqués ou longs, et trouver des erreurs et les corriger sera généralement facile.

Pour gérer les erreurs de logique, commencez par examiner le pseudo-code et le diagramme de structure pour confirmer que la conception de votre programme est correcte. Si vous n'y découvrez aucune erreur, comparez le code QBASIC ou QuickBASIC avec les documents logiques. Essayez de simuler les étapes que l'ordinateur prendra pour exécuter votre programme pour aider à évaluer votre logique. Si vous trouvez que le code n'est pas une mise en oeuvre fidèlement à votre conception, réécrivez les instructions QBASIC ou QuickBASIC incorrectes. Cependant, si les erreurs vous échappent encore, vous devrez aller les chercher.

Erreur de syntaxe causée par une faute d'orthographe

Le QBASIC ou QuickBASIC trouve l'erreur en traduisant le code et met en évidence le mot inconnu. Si l'utilisateur demande de l'aide à ce stade, le QBASIC ou QuickBASIC indique qu'une cause probable de l'erreur est un mot clef ou un paramètre mal saisi, un exemple de l'aide contextuelle de QuickBASIC.

Erreur de syntaxe causée par un format incorrect

La dernière ligne aurait dû être lu de la manière suivante : «If AGE >= 18 THEN PRINT "Adulte"». Une fois que la touche ENTER est enfoncée, le QBASIC ou QuickBASIC révise la ligne pour qu'elle se lit comme suit :

Une façon d'observer ce qui se passe dans un programme consiste à utiliser des instructions PRINT pour surveiller la valeur des variables du programme. En affichant le contenu des variables, vous pouvez voir comment le programme les modifie. La sortie des instructions PRINT insérées dans le code indique le problème : la valeur du terminal est comptée comme un pointage. Vous pouvez corriger cela en ajoutant une entrée d'amorçage; et en déplaçant l'instruction INPUT dans la boucle afin qu'elle soit la dernière ligne avant LOOP. Le code révisé ressemblerait à ceci :

Fenêtre WATCH

L'insertion et la suppression d'instructions PRINT peuvent être fastidieuses. Pour faciliter la vie des programmeurs, QBASIC ou QuickBASIC a automatisé le processus en fournissant des points de surveillance instantanés. Les points de surveillance instantanés sont des variables ou des expressions que vous désignez : lorsque QBASIC ou QuickBASIC exécute votre programme, les valeurs des points de surveillance sont affichées dans ce que l'on appelle la fenêtre de surveillance en haut de l'écran. Pour voir comment cela fonctionne, entrez le code suivant (sans les instructions PRINT supplémentaires) dans l'éditeur de QBASIC ou QuickBASIC. Positionnez ensuite le curseur sur la variable "N" dans la fenêtre d'édition, appuyez sur Shift+F9 et appuyez sur Enter pour ajouter un watch; cela entre "N" dans la fenêtre de surveillance. Déplacez le curseur sur la variable "Score" et appuyez à nouveau sur Shift+F9 et Enter :

Exemple d'exécution :

Exécutez maintenant le programme en mode pas à pas. Vous faites cela en appuyant sur la touche F8. Chaque fois que vous appuyez sur F8, une autre ligne du programme s'exécute. Vous pourrez voir quelle ligne du programme est en cours d'exécution et les valeurs actuelles de "Score" et "N" s'afficheront dans la fenêtre de surveillance. Si vous souhaitez reprendre l'exécution normale du programme, sans la trace, appuyez sur F5. Si vous souhaitez supprimer un point de surveillance, appuyez sur Alt, D (pour le débogage) et D (pour supprimer la surveillance). Cette combinaison d'éléments de surveillance et d'exécution en une seule étape peut vous faire gagner des heures frustrantes à rechercher des erreurs.

Point d'arrêt

Lorsque vous avez un programme long, vous ne voudrez pas le parcourir en une seule étape pour trouver une erreur dans une seule partie du programme. Le QBASIC et le QuickBASIC laissera un programme s'exécuter sans interruption jusqu'à ce qu'une ligne du code de programme que vous avez spécifié s'exécute, ou une condition que vous avez spécifiée devienne vraie.

Les points d'arrêt sont des emplacements (lignes) dans votre programme où vous pouvez interrompre l'exécution et inspecter les valeurs des variables et expressions du programme. Les valeurs des variables peuvent être affichées pendant la pause en les affichant dans la fenêtre d'exécution en bas de l'écran. Vous pouvez vous déplacer dans une sortie de la fenêtre d'exécution en appuyant sur la touche F6. Une fois dans la fenêtre d'exécution, entrez simplement PRINT suivi de la liste de variables ou de l'expression que vous souhaitez inspecter. (Pour accélérer la saisie, remplacez le mot-clef PRINT par «?»). Vous pouvez également créer des points d'observation instantanés de variables et voir leurs valeurs dans la fenêtre de surveillance.

Les points d'arrêt dans le programme sont facile à marqués et non marqués. Déplacez le curseur sur l'instruction de programme souhaitée et appuyez sur F9. La ligne que vous avez marquée apparaîtra en image inversée ou en rouge. Un seul point d'arrêt peut être effacé en déplaçant le curseur sur la ligne marquée et en appuyant sur F9. Pour effacer tous les points d'arrêt, appuyez sur Alt, D (pour le débogage) et C (pour effacer tous les points d'arrêt).

L'autre façon de provoquer la rupture de votre programme est de définir des points de contrôle arrêtant l'exécution lorsqu'une expression que vous avez spécifiée devient vraie. Vous spécifiez des points de surveillance en ouvrant la fenêtre de débogage et en sélectionnant l'option Watchpoint. En réponse au prompt de QBASIC ou QuickBASIC, entrez une expression, par exemple, "Score < 0". L'expression apparaîtra dans la fenêtre de surveillance, et chaque fois que sa valeur devient vraie, QBASIC ou QuickBASIC interrompra l'exécution du programme, afin que vous puissiez inspecter les valeurs des variables et, si nécessaire, continuer l'exécution en mode pas à pas.

Trace

La fonction de trace de QBASIC ou QuickBASIC exécute votre programme à une vitesse plus lente que la vitesse normale, mettant en évidence chaque instruction lors de son exécution. On suppose que vous pouvez voir le flux d'exécution dans le programme, mais vous aurez peut-être du mal à observer beaucoup de choses avec la trace si vous utilisez un ordinateur à vitesse relativement élevée. Dans cette situation, une étape unique est probablement préférable.

Une autre caractéristique du traçage est l'enregistrement automatique des 20 dernières lignes de code exécutées avant un point d'arrêt tel que la fin du programme ou un point d'arrêt. Une fois le programme arrêté, vous pouvez utiliser Shift+F10 et Shift+F8 pour avancer et reculer d'un pas dans le code enregistré.

L'option Menus complets doit être appelée pour activer la fonction de trace. Appuyez ensuite sur Alt, D (pour Debug) et T (pour Trace On) avant d'exécuter le programme.