Arrêt à la reprise et à partir un point d'arrêt

Apprendre à utiliser le débogueur est l'une des choses les plus importantes que vous pouvez faire pour votre C ++ jeu. Ce qui suit sont les étapes nécessaires pour mettre un point d'arrêt, arrêtez votre programme, examiner quelques variables, et reprendre le programme.

Au printemps 2014, Code :: Blocks ne intègre pas avec le débogueur pour le Mac, donc si vous êtes un utilisateur Mac ces exemples peuvent ne pas fonctionner pour vous.

Qu'est-ce qu'un débogueur?

Avant d'aller plus loin, il peut aider si vous comprenez ce qu'est un débogueur est. UN débogueur est un programme séparé qui vous permet de contrôler votre programme d'exécution. Plus précisément, il vous permet d'arrêter l'exécution du programme au niveau des lignes de code spécifiques, d'examiner la valeur des variables, pour modifier la valeur des variables, et de reprendre l'exécution du programme.

Le débogueur GNU dispose d'une interface de ligne de commande qui est à la fois difficile à retenir et difficile à utiliser (ce qui est une combinaison gagnante si vous avez jamais entendu un). Heureusement, Code :: Blocks fournit une interface graphique presque transparente pour le débogueur GNU. Alors que vous cliquez sur les fenêtres d'éditeur et d'activer des menus déroulants, Code :: Blocks envoie des commandes cryptiques au débogueur en arrière-plan, puis interprète et affiche graphiquement les résultats. Est-ce pas génial lorsque deux programmes bavardage en arrière-plan pour sauver vous travaillez?

La meilleure façon d'en apprendre davantage sur le débogueur est de simplement suivre ces exemples.

Configuration de votre programme à utiliser le débogueur

Vous devez construire votre programme en utilisant les paramètres de compilation spéciales si vous avez l'intention de l'exécuter sous le contrôle du débogueur. La meilleure façon de faire cela est juste au début, lorsque vous créez votre projet. Une fois que vous avez spécifié que vous voulez créer une application console et à condition que le nom du programme, Code :: Blocks vous demandera si vous voulez construire votre programme dans la configuration de débogage, la configuration de sortie, ou les deux, comme indiqué dans la Figure 1 . Assurez-vous que la configuration de débogage est activé.

Un programme de débogage dans la configuration comprend un grand nombre d'informations supplémentaires que le débogueur a besoin pour faire sa magie. Cette information comprend

• L'adresse de chaque ligne de code source C

• L'adresse de chaque variable

• Les noms et la composition de chaque classe dans votre programme

Toutes ces informations de débogage ajoute beaucoup de volume au programme exécutable - des centaines de kilo-octets ou plus. Cet espace est totalement inutile si vous ne comptez pas utiliser le programme sous le contrôle du débogueur, alors Code :: Blocks vous donne la possibilité d'exécutables de construction sans cette information dans ce qui est connu comme la configuration de sortie. Programmes de sortie sont plus petites, charger plus rapidement, et même exécuter plus rapidement.

Si vous activez les deux débogage et la libération des configurations dans votre projet, vous aurez à choisir au moment de la construction du type de exécutable que vous essayez de construire.

Il ya deux différences entre les configurations de débogage et de sortie:

• La configuration de débogage comprend le -g option du compilateur.

  Cette option indique au compilateur d'inclure des informations de symbole dans l'exécutable final. Ceci est tout ça mentionné ci-dessus - l'adresse de chaque ligne de code et de chaque variable, ainsi qu'une description de chaque classe utilisée dans votre programme.

• L'optimisateur de code est désactivé dans la configuration de débogage et activé dans la configuration de sortie.

  Le code GNU optimiseur génère programmes qui exécutent plus vite, mais il le fait en se déplaçant autour des instructions d'une manière qui peut être assez déroutant lorsque vous déboguer votre programme. La configuration de libération ne comprend pas le -g passer et permet un certain niveau d'optimisation grâce à l'inclusion de la -O interrupteur.

Assurez-vous que vous êtes en train de construire la libération de débogage en sélectionnant Build-Select Target-Debug, comme indiqué dans la Figure 2.

Reconstruire votre programme en sélectionnant Build-Reconstruire.

Arrêt à un point d'arrêt

Pour définir un point d'arrêt, il suffit de cliquer dans la zone juste à la droite du numéro de ligne - cette zone est connue dans Code :: Blocks le langage que le auge. Non seulement la ligne apparaît une couleur différente, ce qui indique que l'éditeur a choisi, mais un petit stop apparaît dans le creux, comme le montre la figure 3. Ceci est une indication que un point d'arrêt a été mis à la ligne 11.

Vous pouvez définir autant de points d'arrêt que vous voulez à un moment, mais celui-ci point d'arrêt serez amende pour cet exemple.

Ici, vous pouvez démarrer le programme en utilisant le Debug-Start / option Continuer le montre la figure 4.

Le programme commence l'exécution comme d'habitude, mais arrête presque immédiatement avec une petite flèche jaune pointant à la ligne 11 comme indiqué sur la Figure 5. En outre, une fenêtre vide qui contiendrait normalement la sortie du programme apparaît. Rien apparaît dans la sortie de programme parce que la ligne 11 n'a pas encore à exécuter.

Hou la la! C'est cool.

Reprise exécution d'un programme

Vous pouvez définir un point d'arrêt sur la ligne suivante et sélectionnez Debug-Start / Continuer pour poursuivre l'exécution du programme à la ligne suivante si vous wanted- cependant, puisque cela est une chose commune à faire, Code :: Blocks fournit Debug-Next option Ligne, ce qui signifie, "Exécuter le programme à la ligne suivante."

Cela provoque le programme à clignoter momentanément le contrôle passe au programme juste assez longtemps pour exécuter la ligne 11 avant de venir à un arrêt de plus, comme le montre la figure 6.

Vous pouvez répéter ce processus aussi souvent que vous le souhaitez, efficacement mode pas à pas mon chemin à travers le programme.

Quand vous venez à un appel de fonction, la ligne suivante reste dans la fonction en cours, l'exécution de la fonction entière comme si elle était une seule ligne (ce qui est à ce niveau). Si vous souhaitez passer commande à l'appel de fonction, sélectionnez Debug-Step Into place. Cela ne fonctionne que pour les fonctions pour lesquelles vous avez le code source - cela ne fonctionne pas très bien pour les fonctions C ++ bibliothèque.

Chaque fois que vous êtes fatigués de mode pas à pas autour, vous pouvez terminer le programme en sélectionnant Debug-Stop Debugger. Non seulement cela arrête le débogueur, mais il arrête votre programme ainsi.

Examen des variables

Single-stepping grâce à votre programme est une excellente façon d'obtenir une idée de là où votre programme est en cours, mais il peut être difficile de comprendre pourquoi, sauf si vous pouvez examiner les variables qu'il utilise pour prendre des décisions. Par exemple, lorsque vous en une seule étape le programme d'exemple, vous pouvez remarquer que le contrôle ne pénètre pas dans le pour boucle à tous. Pourquoi donc?

Vous arrêtez le programme en sélectionnant Debug-Stop Debugger ou en appuyant sur Maj + F8 et redémarrer en sélectionnant Debug-Démarrer / Continuer ou en appuyant sur F8. En une seule étape en sélectionnant Debug-Ligne suivante ou en appuyant sur F7 jusqu'à ce que l'exécution atteint le début de la pour boucle.

Cette fois, assurez-vous que la fenêtre Watch est visible en sélectionnant Debug-fenêtres de débogage-Montres. Une fenêtre comme celle de la Figure 7 apparaît montrant les valeurs des arguments et des variables locales. Notez que nNumberofArgs est 1, juste le nom du programme lui-même. Depuis que je commence avec une valeur de 1, la boucle ne va jamais être exécutée. Ajoutez les variables de montres pszArgs [0] et pszArgs [1] pour voir ce qu'ils contiennent: le nom du programme et un nul. Aha! Le programme n'a pas d'arguments pour parcourir.

Vous pouvez modifier les arguments pour le programme en sélectionnant les arguments de projet-Set programmes. Dans cette fenêtre, vous pouvez mettre tous les arguments que vous voulez.

Notez que la fenêtre Regarder me montre le nom de la variable, son type et sa valeur. Vous ne pouvez pas changer son type, mais vous pouvez changer sa valeur de cette fenêtre, si vous voulez. Modification de la valeur de nNumberofArgs est pas très utile, mais parfois changer la valeur d'une variable me permet de forcer l'exécution dans une voie différente, juste pour voir ce qui pourrait arriver.

Poursuivant un programme arrêté

Un truc à se rappeler est que cela peut parfois devenir confus pour expliquer pourquoi un programme est arrêté. Pas tous les programmes qui sont arrêtés sont sous le contrôle du débogueur. Parfois, ils sont en attente pour l'entrée de l'utilisateur.

Pour voir cet effet, une seule étape du programme PrintArgs jusqu'au contrôle a atteint la ligne 26. Lorsque vous sélectionnez la ligne suivante, le curseur disparaît comme le montre la Figure 8. Finie est la flèche jaune agréable qui vous rappelle où vous suis dans le programme. Ce qui s'est passé?

Ce qui est arrivé est que le programme est en attente pour moi d'appuyer sur Entrée au clavier. Tout d'abord, vous devez sélectionner la fenêtre du programme. Ensuite, vous pouvez appuyer sur Entrée (vous devrez peut-être faire plus d'une fois). Après avoir fait cela, rien ne semble se passer dans la fenêtre du programme parce que le contrôle est maintenant passée de retour au débogueur dans la fenêtre Code :: Blocks. Lorsque vous sélectionnez la fenêtre à nouveau, vous voyez la flèche jaune rassurant en me disant que Code :: Blocks est de retour dans le contrôle.

Lorsque vous êtes l'exécution de votre programme sous le débogueur et de contrôle apparaît à tout simplement disparaître, le programme peut être en attente d'entrée à partir du clavier. Passer à la fenêtre du programme pour voir si cela est le cas. Si oui, dès que vous entrez quelque chose, le contrôle sera de retour pour le débogueur.