1
00:00:00,000 --> 00:00:00,309

2
00:00:00,309 --> 00:00:02,350
[? DAN ARMADARAS:?] Salut,
Je suis [? Dan Armadaras?].

3
00:00:02,350 --> 00:00:04,410
Aujourd'hui, nous allons
être à la recherche au débogage.

4
00:00:04,410 --> 00:00:06,697
Non seulement allons-nous
parler de certaines techniques,

5
00:00:06,697 --> 00:00:09,280
mais aussi nous allons regarder
certaines des caractéristiques contenues

6
00:00:09,280 --> 00:00:14,170
au sein de l'IDE qui permettent CS50
de déboguer facilement un programme.

7
00:00:14,170 --> 00:00:16,272
>> Juste un exemple de
quelque chose qui peut aller mal

8
00:00:16,272 --> 00:00:18,730
et il est en fait quelque chose
que nous avons déjà vu avant.

9
00:00:18,730 --> 00:00:23,200
Dans ce cas, cela est un programme C
qui accepte un nombre entier de l'utilisateur,

10
00:00:23,200 --> 00:00:27,580
la divise par deux, et fournit
la sortie à l'utilisateur.

11
00:00:27,580 --> 00:00:30,610
Maintenant à partir de ce que nous avons vu
plus tôt dans des conférences,

12
00:00:30,610 --> 00:00:34,370
nous savons que ce sera effectivement causer
des types spécifiques de problèmes de division

13
00:00:34,370 --> 00:00:35,860
lorsque nous avons des numéros impairs.

14
00:00:35,860 --> 00:00:40,330
>> Plus précisément, nous allons simplement jetons
quoi que ce soit après la virgule.

15
00:00:40,330 --> 00:00:43,170
Maintenant, nous savons que ce
arrive à être le cas.

16
00:00:43,170 --> 00:00:47,430
Et si nous courons, nous pouvons confirmer
nos soupçons, d'abord, par la compilation.

17
00:00:47,430 --> 00:00:50,460
Et puis, en courant et en
entrer un nombre impair.

18
00:00:50,460 --> 00:00:51,720
>> Rien de nouveau.

19
00:00:51,720 --> 00:00:54,490
Mais cela est en fait un
exemple d'un bug qui

20
00:00:54,490 --> 00:00:58,810
peut exister au sein d'un programme plus vaste
cela devient plus difficile à traquer.

21
00:00:58,810 --> 00:01:02,640
Même si nous savons quel est le problème
est, le véritable nœud de la question

22
00:01:02,640 --> 00:01:06,250
pourrait être d'essayer d'identifier
spécifiquement où l'erreur se produit,

23
00:01:06,250 --> 00:01:09,750
identifier ce que ce problème
est, puis fixer.

24
00:01:09,750 --> 00:01:14,400
Donc fournir cela comme un exemple
de ce qui pourrait être quelque chose

25
00:01:14,400 --> 00:01:19,030
que nous savons déjà, mais peuvent être enterrés
dans les autres éléments du code.

26
00:01:19,030 --> 00:01:23,090
>> Donc, l'ouverture de cette autre source
fichier de code comme un exemple,

27
00:01:23,090 --> 00:01:27,165
ce problème est maintenant de division
partie d'un programme plus vaste.

28
00:01:27,165 --> 00:01:29,040
Encore pourrait être un peu
peu artificiel, et nous

29
00:01:29,040 --> 00:01:31,076
pourrait être en mesure de facilement
identifier, en particulier

30
00:01:31,076 --> 00:01:32,450
puisque nous sommes en train de discuter de cette.

31
00:01:32,450 --> 00:01:38,250
Mais nous pouvons comprendre que cette
problème peut exister sur une plus grande échelle.

32
00:01:38,250 --> 00:01:45,450
>> Si je compile cela et maintenant
exécuter, entrez un nombre impair,

33
00:01:45,450 --> 00:01:49,816
nous pouvons voir que nous ne recevons pas précisément
la sortie que nous avons prévu.

34
00:01:49,816 --> 00:01:51,690
Dans ce cas particulier,
nous pourrions dire que nous

35
00:01:51,690 --> 00:01:56,060
vouloir compter tous les numéros
de une à un nombre spécifique.

36
00:01:56,060 --> 00:01:58,130
Et nous pouvons voir que nous
avoir une variété de questions

37
00:01:58,130 --> 00:02:03,880
ici si nous délivrer, tout simplement, 0
et 1 lorsque nous fournissons une entrée 5.

38
00:02:03,880 --> 00:02:07,380
>> Donc, nous savons déjà que
il ya un problème ici.

39
00:02:07,380 --> 00:02:11,662
Mais nous ne savons pas précisément
où cette question existe réellement.

40
00:02:11,662 --> 00:02:13,620
Maintenant l'un des moyens que
nous pouvons essayer de résoudre ce problème

41
00:02:13,620 --> 00:02:15,745
est quelque chose que nous avons
déjà été introduite à.

42
00:02:15,745 --> 00:02:18,880
Nous pouvons simplement l'utiliser sur une plus grande échelle.

43
00:02:18,880 --> 00:02:21,680
>> Sur la ligne 14, nous avons
cette fonction printf,

44
00:02:21,680 --> 00:02:25,620
ce qui nous permet d'imprimer sur l'état
de divers éléments d'information.

45
00:02:25,620 --> 00:02:28,880
Et ceci est quelque chose que vous
devrait tirer parti de votre programme

46
00:02:28,880 --> 00:02:33,100
pour essayer de comprendre exactement ce qui est
passe dans diverses lignes de code.

47
00:02:33,100 --> 00:02:36,350
Donc, même si ce ne est pas
sortie finale que nous fait

48
00:02:36,350 --> 00:02:39,830
vouloir produire sur
ce programme, nous avons encore

49
00:02:39,830 --> 00:02:42,300
pourrait avoir une certaine debug
états où nous

50
00:02:42,300 --> 00:02:46,970
peut essayer de comprendre précisément ce que
qui se passe à l'intérieur de notre code.

51
00:02:46,970 --> 00:02:51,210
>> Donc dans ce cas, je vais
printf avec l'étiquette de débogage.

52
00:02:51,210 --> 00:02:53,540
Dans ce cas, cela est
juste une chaîne de débogage

53
00:02:53,540 --> 00:02:56,840
que je suis jusqu'à la mise-de sorte qu'il devient
très clair dans la sortie de mon code

54
00:02:56,840 --> 00:02:59,200
ce qu'il est que je veux montrer.

55
00:02:59,200 --> 00:03:04,410
Et sortie ici le nombre
que nous avons calculé.

56
00:03:04,410 --> 00:03:06,800
>> Dans ce cas, je pourrais
veulent savoir précisément

57
00:03:06,800 --> 00:03:11,380
ce qui se passe avant et
après un certain calcul spécifique.

58
00:03:11,380 --> 00:03:16,224
Donc, je pourrais utiliser un printf avant
et après cette ligne de code.

59
00:03:16,224 --> 00:03:18,640
Dans ce cas, je ne pouvais même
rendre un peu plus clair

60
00:03:18,640 --> 00:03:21,960
en disant débogage avant
et déboguer après tant

61
00:03:21,960 --> 00:03:26,540
que je ne me confonds pas avec
plusieurs lignes qui semblent identiques.

62
00:03:26,540 --> 00:03:32,290
>> Maintenant, si nous recompiler et exécuter
il, entrez un numéro comme cinq fois,

63
00:03:32,290 --> 00:03:35,090
nous pouvons voir que nous avons
maintenant affichée avant et après

64
00:03:35,090 --> 00:03:40,670
et constatons que nous avons fait un pas clair
division ou ayant clairement du nombre

65
00:03:40,670 --> 00:03:43,680
que nous voulons réellement faire.

66
00:03:43,680 --> 00:03:48,660
Or, dans ce cas, cela est
pas vraiment un résultat clair.

67
00:03:48,660 --> 00:03:52,440
Il est pas vraiment un résultat clair que
nous voulons sortir de ce programme particulier.

68
00:03:52,440 --> 00:03:54,427
>> Et cela est, à nouveau, un
peu parvint.

69
00:03:54,427 --> 00:03:57,510
Mais, peut-être, l'une des choses qui
nous pourrions faire si la spécification dit

70
00:03:57,510 --> 00:04:01,900
que nous voulons diviser par
2 et ajouter 1-- donc en d'autres termes,

71
00:04:01,900 --> 00:04:04,550
nous voulons arrondir up-- puis
nous sachions que nous pourrions

72
00:04:04,550 --> 00:04:08,060
faire cette chose particulière, dans ce cas.

73
00:04:08,060 --> 00:04:14,010
Maintenant, ici, nous savons que nous serons
en mesure d'ajouter 1 à notre nombre réduit de moitié.

74
00:04:14,010 --> 00:04:16,490
>> Disons recompiler
et de confirmer que cette

75
00:04:16,490 --> 00:04:18,860
se comporte de la façon dont nous voulons.

76
00:04:18,860 --> 00:04:21,980
Nous pouvons voir que maintenant avant
ayant, nous avons le numéro 5.

77
00:04:21,980 --> 00:04:26,620
Après avoir, nous avons le numéro 3,
qui, selon notre cahier des charges,

78
00:04:26,620 --> 00:04:29,292
est ce que nous voulions faire.

79
00:04:29,292 --> 00:04:31,000
Mais si nous regardons le
sortie ici, nous pouvons

80
00:04:31,000 --> 00:04:33,760
voir que nous pourrions avoir une autre
bug tout à fait, qui est

81
00:04:33,760 --> 00:04:36,940
que nous commençons notre comptage de 0.

82
00:04:36,940 --> 00:04:39,390
>> Maintenant, encore une fois, ceci est quelque chose
que nous avons vu dans le passé

83
00:04:39,390 --> 00:04:42,500
et nous pouvons corriger assez facilement.

84
00:04:42,500 --> 00:04:44,790
Mais dans ce cas, nous
également eu l'avantage

85
00:04:44,790 --> 00:04:48,940
d'utiliser l'instruction printf
directement à l'intérieur de la boucle for

86
00:04:48,940 --> 00:04:52,930
de savoir précisément où
cette erreur se produisait.

87
00:04:52,930 --> 00:04:55,150
Donc déclarations sont printf
très utile pour aider

88
00:04:55,150 --> 00:04:57,940
à déterminer où,
précisément dans le code source,

89
00:04:57,940 --> 00:05:00,620
une erreur spécifique est en cours.

90
00:05:00,620 --> 00:05:03,650
>> Et il est aussi important de réaliser
que, comme nous l'écriture de code,

91
00:05:03,650 --> 00:05:06,052
nous pourrions avoir des hypothèses
sur l'état d'un programme.

92
00:05:06,052 --> 00:05:08,510
Ou nous pourrions avoir hypothèses
sur ce que le cadre du programme

93
00:05:08,510 --> 00:05:13,020
est en fait correcte ou incorrecte lorsque
plus tard que nous construisons sur ce programme

94
00:05:13,020 --> 00:05:15,950
et faire partie d'un
complexe et vaste programme

95
00:05:15,950 --> 00:05:19,700
que nous nous rendons compte que certains aspects
de qui est réellement buggy.

96
00:05:19,700 --> 00:05:22,680
>> Utilisation de printf peut vraiment aider
affiner et d'identifier

97
00:05:22,680 --> 00:05:26,430
les régions d'un programme qui ne peut
se comporter exactement de la manière que nous

98
00:05:26,430 --> 00:05:29,500
attendre, sur la base de nos hypothèses.

99
00:05:29,500 --> 00:05:31,460
Mais il ya d'autres outils
disponibles, ainsi,

100
00:05:31,460 --> 00:05:34,860
qui nous permettent d'essayer de comprendre
où une erreur se produit

101
00:05:34,860 --> 00:05:39,930
Et aussi, précisément, que les choses
sont passe à l'intérieur du programme.

102
00:05:39,930 --> 00:05:41,990
>> Donc, en utilisant printf est très
lorsque cela est utile que nous voulons

103
00:05:41,990 --> 00:05:45,900
d'identifier les domaines spécifiques de
un programme qui possède quelques bugs.

104
00:05:45,900 --> 00:05:47,730
Mais il devient aussi
pénible après un moment.

105
00:05:47,730 --> 00:05:50,500
Dans ce cas, cela est un
programme relativement simple

106
00:05:50,500 --> 00:05:52,750
avec seulement une ou deux variables.

107
00:05:52,750 --> 00:05:57,260
Et il devient très facile pour nous de
imprimer la valeur de ces variables

108
00:05:57,260 --> 00:05:59,670
dans le contexte plus large du programme.

109
00:05:59,670 --> 00:06:02,670
>> Mais nous pourrions avoir une autre
programme qui a de nombreuses variables.

110
00:06:02,670 --> 00:06:06,530
Et il ne peut pas être tout à fait
si facile à utiliser printf

111
00:06:06,530 --> 00:06:10,120
pour tenter d'évaluer ce qui se passe
à chacune de ces variables

112
00:06:10,120 --> 00:06:13,590
que le programme est exécuté.

113
00:06:13,590 --> 00:06:16,960
Il ya un programme qui existe
appelé un programme de débogage.

114
00:06:16,960 --> 00:06:20,320
Dans ce cas, celui que nous allons
l'utilisation est le débogueur GNU, ou GDB,

115
00:06:20,320 --> 00:06:24,260
qui nous permet d'inspecter les internes
fonctionnement d'un programme dans une beaucoup plus

116
00:06:24,260 --> 00:06:25,700
de façon détaillée.

117
00:06:25,700 --> 00:06:28,810
>> Nous pouvons en fait exécuter
GDB de la ligne de commande

118
00:06:28,810 --> 00:06:35,370
ici en tapant simplement GDB et la
commande que nous voulons pour déboguer.

119
00:06:35,370 --> 00:06:37,550
Dans ce cas, compter.

120
00:06:37,550 --> 00:06:41,650
Or, dans ce cas, nous pouvons voir qu'il
nous amène à une invite qui dit GDB.

121
00:06:41,650 --> 00:06:44,020
Et nous pouvons réellement
exécuter des commandes GDB

122
00:06:44,020 --> 00:06:48,260
pour commencer effectivement l'exécution de la
programme, l'arrêter à certains points,

123
00:06:48,260 --> 00:06:51,060
évaluer les variables et
inspecter les variables

124
00:06:51,060 --> 00:06:54,152
exister à l'état de programme
à ce moment particulier,

125
00:06:54,152 --> 00:06:55,110
et ainsi de suite.

126
00:06:55,110 --> 00:06:57,240
Il offre beaucoup de puissance pour nous.

127
00:06:57,240 --> 00:06:59,960
>> Mais il se trouve
que l'IDE CS50 aussi

128
00:06:59,960 --> 00:07:05,870
fournit une interface graphique ou un utilisateur
Interface pour que GDB

129
00:07:05,870 --> 00:07:11,120
nous permet de faire ce sans avoir besoin
l'interface de ligne de commande que ce soit

130
00:07:11,120 --> 00:07:13,560
ou pas du tout même.

131
00:07:13,560 --> 00:07:16,930
La manière que je peux accéder à ce
est en utilisant le bouton de débogage

132
00:07:16,930 --> 00:07:20,120
au sommet de l'IDE de CS50.

133
00:07:20,120 --> 00:07:24,280
Maintenant, dans le passé, ce que nous avons
vu est que nous utilisons la commande

134
00:07:24,280 --> 00:07:27,660
ligne pour compiler puis exécuter un programme.

135
00:07:27,660 --> 00:07:29,790
>> Le bouton de débogage fait
ces deux étapes.

136
00:07:29,790 --> 00:07:34,380
Mais il apportera également le
onglet débogueur sur l'extrême droite

137
00:07:34,380 --> 00:07:38,280
qui nous permet d'inspecter une variété
des propriétés du programme

138
00:07:38,280 --> 00:07:40,500
car il est en cours d'exécution.

139
00:07:40,500 --> 00:07:44,280
Si je clique débogage, dans ce
cas, il mettra en place

140
00:07:44,280 --> 00:07:48,230
un nouvel onglet dans la console
fenêtre au bas.

141
00:07:48,230 --> 00:07:51,160
>> Et vous pouvez voir que cet onglet a
quelques informations au sommet.

142
00:07:51,160 --> 00:07:52,670
Et nous pouvons largement ignorer.

143
00:07:52,670 --> 00:07:54,800
Mais l'une des choses
que nous voulons remarquer

144
00:07:54,800 --> 00:07:57,170
est qu'il délivre
la même chose que nous

145
00:07:57,170 --> 00:08:03,000
obtiendriez si nous avons essayé de faire fonctionner sur
le programme de C dans la fenêtre de terminal.

146
00:08:03,000 --> 00:08:06,230
>> Ici, nous pouvons voir qu'il est en cours d'exécution clang,
et il a une variété de drapeaux,

147
00:08:06,230 --> 00:08:12,660
et il compile notre fichier count.c,
qui était l'onglet sélectionné au moment

148
00:08:12,660 --> 00:08:15,100
que je frappe débogage.

149
00:08:15,100 --> 00:08:18,010
Donc, ce qui est très utile car
maintenant en utilisant ce bouton de débogage,

150
00:08:18,010 --> 00:08:23,280
nous pouvons simultanément compiler et puis
exécuter le programme que nous avons fait

151
00:08:23,280 --> 00:08:24,460
vouloir courir.

152
00:08:24,460 --> 00:08:27,880
>> Un des drapeaux qui est
importante, dans ce cas,

153
00:08:27,880 --> 00:08:30,190
nous avons été effectivement à l'aide
le plus longtemps

154
00:08:30,190 --> 00:08:32,450
mais aussi juste fait une main
agitant [inaudible], qui

155
00:08:32,450 --> 00:08:33,820
est-ce un ici.

156
00:08:33,820 --> 00:08:35,790
Dans clang, il dit -ggdb3.

157
00:08:35,790 --> 00:08:38,570

158
00:08:38,570 --> 00:08:41,250
Dans ce cas, ce que nous sommes
dire clang, notre compilateur,

159
00:08:41,250 --> 00:08:43,820
est que nous voulons compiler notre programme.

160
00:08:43,820 --> 00:08:46,810
Mais aussi de fournir ce sont
appelé informations de symbole

161
00:08:46,810 --> 00:08:50,940
afin que le compilateur a effectivement accès
à beaucoup de l'information sous-jacente

162
00:08:50,940 --> 00:08:52,610
contenue dans le programme.

163
00:08:52,610 --> 00:08:55,260
>> Plus précisément, le nombre
des fonctions que je dois,

164
00:08:55,260 --> 00:08:58,000
les noms de ces fonctions,
les variables, les types

165
00:08:58,000 --> 00:09:01,730
que ces variables sont, et une variété
d'autres choses qui aident le débogueur

166
00:09:01,730 --> 00:09:04,350
effectuer son fonctionnement.

167
00:09:04,350 --> 00:09:06,600
Maintenant, il ya quelque chose d'autre
ce qui est important de mentionner

168
00:09:06,600 --> 00:09:10,280
lorsque nous parlons en marche
un programme de cette manière.

169
00:09:10,280 --> 00:09:13,660
>> Notez qu'il a fait
donné un nouvel onglet dans notre console

170
00:09:13,660 --> 00:09:14,780
le long du fond.

171
00:09:14,780 --> 00:09:18,600
Nous avons plus d'interagir
directement avec la fenêtre du terminal.

172
00:09:18,600 --> 00:09:21,420
Mais ce nouvel onglet est
en fait une fenêtre de terminal.

173
00:09:21,420 --> 00:09:26,710
Il est juste spécifique à la gestion
programme que nous avons créé.

174
00:09:26,710 --> 00:09:29,270
>> Notez que dans le bas, en
combinaison avec une certaine sortie

175
00:09:29,270 --> 00:09:33,500
clang par le compilateur et GDB,
que nous ne pouvons ignorer en grande partie,

176
00:09:33,500 --> 00:09:37,570
elle montre en fait la sortie de
notre programme tout en bas.

177
00:09:37,570 --> 00:09:41,240
Maintenant, il est important de réaliser
ce qui en fait une fenêtre

178
00:09:41,240 --> 00:09:43,360
va vous montrer la
sortie de votre programme

179
00:09:43,360 --> 00:09:47,190
mais peut aussi accepter l'entrée
pour ce programme, ainsi.

180
00:09:47,190 --> 00:09:49,260
>> Donc, avis qui dit
s'il vous plaît entrer un numéro,

181
00:09:49,260 --> 00:09:53,050
qui est la même sortie que nous avions
eu dans la fenêtre du terminal avant.

182
00:09:53,050 --> 00:09:55,510
Mais il est maintenant représenté dans ce nouvel onglet.

183
00:09:55,510 --> 00:09:56,550
Je peut entrer un numéro.

184
00:09:56,550 --> 00:10:00,900
Et il sera en fait
fonction que nous attendons

185
00:10:00,900 --> 00:10:05,890
nous montrant notre débogage, la production,
la sortie qui pourrait être buggé,

186
00:10:05,890 --> 00:10:07,010
que nous avons vu auparavant.

187
00:10:07,010 --> 00:10:10,460
Et tout en bas, il
a fait quelque sortie supplémentaire

188
00:10:10,460 --> 00:10:14,550
du PIB juste que
ce programme est terminé.

189
00:10:14,550 --> 00:10:16,655
>> Maintenant que vous avez vu dans ce
notamment grâce à terme,

190
00:10:16,655 --> 00:10:19,370
il n'a pas été particulièrement
utile parce que même

191
00:10:19,370 --> 00:10:23,740
si nous avions le menu du débogueur venir
jusqu'à, ce fut encore un programme de course.

192
00:10:23,740 --> 00:10:26,790
A aucun moment, il fait
suspendre l'exécution pour nous

193
00:10:26,790 --> 00:10:30,767
pour être en mesure d'inspecter tous
les variables contenues dans.

194
00:10:30,767 --> 00:10:32,850
Il ya autre chose
que nous avons à faire pour

195
00:10:32,850 --> 00:10:36,910
pour obtenir GDB de reconnaître que nous voulons
à suspendre l'exécution du programme

196
00:10:36,910 --> 00:10:42,820
et ne pas laisser tout cela de procéder
normalement comme nous le ferions dans tout autre cas.

197
00:10:42,820 --> 00:10:45,530
>> Pour suspendre l'exécution,
à une certaine ligne spécifique,

198
00:10:45,530 --> 00:10:47,830
nous avons besoin pour créer ce qui est
appelé un point de rupture.

199
00:10:47,830 --> 00:10:52,670
Et un point de rupture est très facilement créé
dans ce CS50 IDE en prenant votre souris

200
00:10:52,670 --> 00:10:57,090
et en cliquant directement sur la gauche
de certains numéro de ligne spécifique.

201
00:10:57,090 --> 00:10:59,920
Une fois que je fais ça, un point rouge
apparaît, qui indique

202
00:10:59,920 --> 00:11:02,300
que cette ligne est maintenant un point de rupture.

203
00:11:02,300 --> 00:11:07,540
>> Et la prochaine fois que je dirige GDB, il
va arrêter l'exécution à ce point de rupture

204
00:11:07,540 --> 00:11:10,280
quand il atteint cette ligne de code.

205
00:11:10,280 --> 00:11:12,230
Maintenant, ceci est une importante
chose à réaliser

206
00:11:12,230 --> 00:11:16,140
qu'il est pas nécessairement le
cas que chaque ligne de code

207
00:11:16,140 --> 00:11:17,880
est en fait accessible.

208
00:11:17,880 --> 00:11:23,780
Si je devais créer une fonction
ici, pour F-- vide example--

209
00:11:23,780 --> 00:11:31,230
et juste faire une ligne d'impression ici-- bonjour
monde-- si je ne appeler cette fonction,

210
00:11:31,230 --> 00:11:34,770
ce sera le cas que,
si je mets un point d'arrêt ici,

211
00:11:34,770 --> 00:11:36,220
la fonction ne sera jamais appelé.

212
00:11:36,220 --> 00:11:38,310
Et donc, ce
notamment le point de rupture

213
00:11:38,310 --> 00:11:43,040
ne sera jamais fait une pause
exécution du programme.

214
00:11:43,040 --> 00:11:48,020
>> Donc, disons que je crée correctement
un point sur certaines ligne de code de pause

215
00:11:48,020 --> 00:11:50,340
qui seront effectivement exécutés.

216
00:11:50,340 --> 00:11:53,470
Or, dans ce cas, cela est le
première ligne dans la fonction principale.

217
00:11:53,470 --> 00:11:56,630
Donc, ce sera certainement le cas
que, dès que je commence l'exécution,

218
00:11:56,630 --> 00:11:58,580
la première ligne sera atteint.

219
00:11:58,580 --> 00:12:00,230
GDB va suspendre l'exécution.

220
00:12:00,230 --> 00:12:04,100
Et puis, je vais être en mesure de
interagir avec le débogueur.

221
00:12:04,100 --> 00:12:08,480
>> Vous pouvez définir plusieurs lignes que
points d'arrêt, si vous le souhaitez.

222
00:12:08,480 --> 00:12:11,365
Nous pouvons également créer un line up
ici, dans ce segment de code

223
00:12:11,365 --> 00:12:12,490
qui ne sera jamais atteint.

224
00:12:12,490 --> 00:12:14,744
Et nous pouvons également mettre un peu plus loin.

225
00:12:14,744 --> 00:12:16,660
La raison pour laquelle nous le ferions
vouloir faire cela nous allons

226
00:12:16,660 --> 00:12:19,119
aller dans un peu plus
détail dans un instant.

227
00:12:19,119 --> 00:12:21,660
Donc pour l'instant, permettez-moi simplement désactiver
ces points de rupture supplémentaires

228
00:12:21,660 --> 00:12:24,940
de sorte que nous pouvons regarder ce qui se passe
quand je dois une seule pause

229
00:12:24,940 --> 00:12:27,650
point de mon programme.

230
00:12:27,650 --> 00:12:29,410
Je l'ai fait quelques
changements à ce programme.

231
00:12:29,410 --> 00:12:30,750
Donc, je dois le sauver.

232
00:12:30,750 --> 00:12:34,490
Je vais cliquez sur débogage afin que je puisse
commencer la compilation, puis

233
00:12:34,490 --> 00:12:36,880
exécution du débogueur.

234
00:12:36,880 --> 00:12:40,632
>> Nous allons voir que, après les moments, les
la ligne que nous avons sélectionnés comme la pause

235
00:12:40,632 --> 00:12:43,360
point est surligné en jaune.

236
00:12:43,360 --> 00:12:47,440
Nous pouvons également remarquer que dans le
en haut à droite dans le panneau de débogage

237
00:12:47,440 --> 00:12:50,940
que l'icône de pause a tourné
dans une petite icône de lecture.

238
00:12:50,940 --> 00:12:54,710
Cela signifie que nous avons une pause
l'exécution, dans ce cas particulier.

239
00:12:54,710 --> 00:12:57,840
Et frapper serait sur le bouton Lecture
nous permettent de reprendre l'exécution

240
00:12:57,840 --> 00:13:00,000
à ce point précis.

241
00:13:00,000 --> 00:13:03,240
>> Notez qu'il ya une couple d'autres
boutons disponibles dans ce panneau de débogage,

242
00:13:03,240 --> 00:13:04,220
aussi.

243
00:13:04,220 --> 00:13:09,470
Enjamber, ce qui me permet de
exécuter cette seule ligne de code

244
00:13:09,470 --> 00:13:14,030
et enjamber à cette ligne à la
suivant, qui, dans ce cas,

245
00:13:14,030 --> 00:13:17,060
signifierait que le printf
instruction est exécutée.

246
00:13:17,060 --> 00:13:22,310
Et ce sera alors une pause
l'exécution de la ligne 13, comme tant.

247
00:13:22,310 --> 00:13:25,090
>> Et il ya aussi une étape
en fonction, qui

248
00:13:25,090 --> 00:13:28,950
est utile si je l'ai créé d'autres
fonctions ailleurs dans le code source.

249
00:13:28,950 --> 00:13:31,420
Et je veux entrer dans
ces fonctions plutôt que

250
00:13:31,420 --> 00:13:33,050
exécuter cette fonction dans son ensemble.

251
00:13:33,050 --> 00:13:37,279
Mais nous allons examiner plus à l'étape
en fonction dans un instant.

252
00:13:37,279 --> 00:13:40,320
Maintenant, remarquez d'autres choses qui
exister réellement dans ce panneau de débogage.

253
00:13:40,320 --> 00:13:44,110
>> Nous avons ce panneau appelé
pile d'appel, qui nous montre

254
00:13:44,110 --> 00:13:45,300
où nous en sommes exactement.

255
00:13:45,300 --> 00:13:48,550
Dans ce cas, nous sommes à l'intérieur
de la fonction principale.

256
00:13:48,550 --> 00:13:50,880
Notre script est appelé count.c.

257
00:13:50,880 --> 00:13:53,820
Et il nous arrive d'être sur
ligne 13, première colonne, qui

258
00:13:53,820 --> 00:13:58,950
est précisément ce que la région en surbrillance
du code source indique ainsi.

259
00:13:58,950 --> 00:14:02,435
>> Maintenant, remarquez que cela montre aussi
en vertu de la section variable locale

260
00:14:02,435 --> 00:14:06,710
toutes les variables qui
exister à l'intérieur de cette fonction.

261
00:14:06,710 --> 00:14:08,930
Il est important de noter
que toutes les variables

262
00:14:08,930 --> 00:14:12,580
apparaîtront dans cette variable locale
section dans une fonction,

263
00:14:12,580 --> 00:14:14,380
avant même qu'ils sont définis.

264
00:14:14,380 --> 00:14:19,160
Nous pouvons voir ici que nous avons une variable
appelé num, a une valeur par défaut de 0,

265
00:14:19,160 --> 00:14:21,280
et il est de type int.

266
00:14:21,280 --> 00:14:24,110
>> Maintenant, avant de nous initialisons effectivement
toutes ces variables,

267
00:14:24,110 --> 00:14:26,685
nous ne sommes pas nécessairement
garantie de voir une valeur de 0.

268
00:14:26,685 --> 00:14:29,200
Et selon d'autres exécutions
que vous avez effectué

269
00:14:29,200 --> 00:14:32,020
et l'état de votre mémoire lorsque
vous avez réellement exécutez ce programme,

270
00:14:32,020 --> 00:14:34,605
vous pourriez découvrir que vous
ne pas voir les valeurs de 0

271
00:14:34,605 --> 00:14:36,550
et, à la place, d'autres chiffres fous.

272
00:14:36,550 --> 00:14:38,390
>> Mais ne vous inquiétez pas à ce sujet.

273
00:14:38,390 --> 00:14:44,610
Ça ne va pas être concerné jusqu'à
initialiser fait la valeur.

274
00:14:44,610 --> 00:14:49,630
Or, dans ce cas, nous pouvons voir que
Je l'ai effectué quelques sorties.

275
00:14:49,630 --> 00:14:52,131
Et je suis, en ce moment, une pause l'exécution.

276
00:14:52,131 --> 00:14:53,880
Mais dans ce cas, ce
Je veux vraiment faire

277
00:14:53,880 --> 00:14:58,060
est à l'étape maintenant plus de cette ligne
du code de sorte que je peux réellement

278
00:14:58,060 --> 00:15:04,390
interroger l'utilisateur pour ce qui int
nous voulons utiliser dans notre programme.

279
00:15:04,390 --> 00:15:07,060
>> Or, dans ce cas, lorsque
Je frappe enjamber, un avis

280
00:15:07,060 --> 00:15:11,940
que la Pause ou plutôt le CV
bouton a changé à ce bouton Pause

281
00:15:11,940 --> 00:15:14,022
car ce code est effectivement en cours d'exécution.

282
00:15:14,022 --> 00:15:15,730
Que se passe-t-il
est en ce moment qu'il est

283
00:15:15,730 --> 00:15:21,630
nous attendait à l'entrée de l'information
comme nous pouvons voir notre texte de sortie

284
00:15:21,630 --> 00:15:23,600
tout au fond.

285
00:15:23,600 --> 00:15:25,787
>> Donc maintenant, cela est
pas réellement pause,

286
00:15:25,787 --> 00:15:28,620
même si elle, en quelque sorte, semble
être parce que rien ne se passe.

287
00:15:28,620 --> 00:15:32,360
Mais il se trouve que, dans
mon cas précis de la ligne 13,

288
00:15:32,360 --> 00:15:34,210
Je suis en attente pour l'entrée utilisateur.

289
00:15:34,210 --> 00:15:39,130
Et ainsi de GDB est pas en mesure d'inspecter
un programme car il est en cours d'exécution.

290
00:15:39,130 --> 00:15:43,370
>> Maintenant, la prochaine fois que je rentre un peu
input-- donc je vais entrer dans ce numéro 5,

291
00:15:43,370 --> 00:15:46,140
comme nous l'avons vu dans le
past-- frappé retour, et nous

292
00:15:46,140 --> 00:15:51,430
Notez que, immédiatement, pauses GDB
et, encore une fois, met en évidence la ligne suivante.

293
00:15:51,430 --> 00:15:55,320
Mais remarquez que maintenant, en tant que
résultat de notre saisi une valeur,

294
00:15:55,320 --> 00:15:58,930
nous avons mis à jour cette valeur à l'intérieur
de nos variables locales, qui

295
00:15:58,930 --> 00:16:05,560
est très utile de savoir précisément
ce que ce nombre était en mémoire.

296
00:16:05,560 --> 00:16:10,650
>> Maintenant, je peux permettre à ce programme pour continuer
la lecture jusqu'à la fin de son exécution

297
00:16:10,650 --> 00:16:12,570
en frappant CV.

298
00:16:12,570 --> 00:16:16,410
Nous pouvons voir que très rapidement
fait la finition du programme d'exécution

299
00:16:16,410 --> 00:16:19,790
avec la même sortie que l'on
eu avant, le débogueur ferme,

300
00:16:19,790 --> 00:16:23,170
et maintenant ce programme
a complètement cessé.

301
00:16:23,170 --> 00:16:25,320
>> Je montre que seulement pour le
fins de voir ce que

302
00:16:25,320 --> 00:16:27,280
qui se passe quand nous avons frappé effectivement CV.

303
00:16:27,280 --> 00:16:30,640
Mais nous avons effectivement allons
envie de retourner dans ce programme

304
00:16:30,640 --> 00:16:33,820
afin que nous puissions essayer de débogage
précisément ce qui se passe.

305
00:16:33,820 --> 00:16:37,980
Maintenant que je suis en utilisant le débogueur, je peut
pas besoin de ces déclarations débogage printf.

306
00:16:37,980 --> 00:16:43,860
>> Donc, je pouvais les enlever comme je vais le faire
maintenant juste pour revenir à notre code simple

307
00:16:43,860 --> 00:16:45,950
que nous avions il ya un instant.

308
00:16:45,950 --> 00:16:48,790
Maintenant, quand je économise le
programmer et exécuter,

309
00:16:48,790 --> 00:16:53,700
il sera, à nouveau, aller à cette initiale
point de rupture que je devais à la ligne 11.

310
00:16:53,700 --> 00:16:57,700
Et je serai en mesure d'inspecter
mes variables que je veux faire.

311
00:16:57,700 --> 00:17:00,695
>> Il se trouve que cette
partie ne soit pas très intéressant,

312
00:17:00,695 --> 00:17:04,364
Et je sais que je vais
imprimer cette déclaration.

313
00:17:04,364 --> 00:17:05,280
S'il vous plaît entrer un numéro.

314
00:17:05,280 --> 00:17:08,099
Et puis, je sais que je vais
demander à l'utilisateur de cet entier.

315
00:17:08,099 --> 00:17:13,329
Alors peut-être, je veux vraiment bouger mon
point de rupture un peu plus bas.

316
00:17:13,329 --> 00:17:16,710
>> Vous pouvez supprimer des points de rupture
en cliquant, à nouveau, directement

317
00:17:16,710 --> 00:17:18,460
à la gauche de ce numéro de ligne.

318
00:17:18,460 --> 00:17:22,200
Ce point rouge disparaîtra, indiquant
que ce point de rupture est maintenant disparu.

319
00:17:22,200 --> 00:17:24,780
Or, dans ce cas,
l'exécution a été suspendue.

320
00:17:24,780 --> 00:17:27,770
Et si ça ne se passe réellement à
reprendre dans ce cas particulier.

321
00:17:27,770 --> 00:17:30,210
Mais je peux mettre une pause
signaler un peu plus tard.

322
00:17:30,210 --> 00:17:33,880
>> Et quand je reprends maintenant mes
code, il va reprendre et de dire

323
00:17:33,880 --> 00:17:36,190
le point de ce point de rupture.

324
00:17:36,190 --> 00:17:37,374
Encore une fois, je frappe CV.

325
00:17:37,374 --> 00:17:39,040
Ne semble pas comme quelque chose qui se passe.

326
00:17:39,040 --> 00:17:41,450
Mais cela est parce que mon
code est en attente d'entrée.

327
00:17:41,450 --> 00:17:47,900
Je vais entrer un numéro 5, appuyez sur Entrée, et
Maintenant, la prochaine point de rupture sera atteint.

328
00:17:47,900 --> 00:17:50,570
>> Or, dans ce cas, ce
est la ligne de code

329
00:17:50,570 --> 00:17:53,820
que, avant, nous savions
qui est arrivé à être buggy.

330
00:17:53,820 --> 00:17:57,590
Donc, nous allons évaluer ce qui se passe
à ce moment précis dans le temps.

331
00:17:57,590 --> 00:18:02,620
Quand une ligne est en surbrillance, ce
ligne n'a pas encore été exécuté.

332
00:18:02,620 --> 00:18:06,490
Donc dans ce cas, nous pouvons voir
que je ai un certain nombre, qui

333
00:18:06,490 --> 00:18:11,610
Je dois un entier appelé
num qui a une valeur 5.

334
00:18:11,610 --> 00:18:15,090
Et je vais être performants
un peu de maths sur ce numéro.

335
00:18:15,090 --> 00:18:20,130
>> Si je fais un pas sur cela, nous pouvons
remarquer que la valeur de num

336
00:18:20,130 --> 00:18:23,780
a changé conformément à la
arithmétique que nous avons réellement fait.

337
00:18:23,780 --> 00:18:26,810
Et maintenant que nous sommes
à l'intérieur de cette boucle

338
00:18:26,810 --> 00:18:29,090
ou maintenant que la boucle
lui-même est mis en évidence,

339
00:18:29,090 --> 00:18:32,450
nous voyons que nous avons un nouveau
variable i appelé que

340
00:18:32,450 --> 00:18:35,370
qui va être utilisé en ce que pour la boucle.

341
00:18:35,370 --> 00:18:38,230
>> Maintenant, rappelez-vous avant que je
dit que, parfois, vous êtes

342
00:18:38,230 --> 00:18:43,470
aller voir une sorte de fou
numéros défaut avant que ce nombre

343
00:18:43,470 --> 00:18:45,530
ou que variable est
en fait initialisées.

344
00:18:45,530 --> 00:18:49,040
Nous pouvons voir que précisément
ici dans la cette variable

345
00:18:49,040 --> 00:18:51,345
appelé i, qui n'a pas
encore été initialisé

346
00:18:51,345 --> 00:18:53,560
au moment de mettre en évidence.

347
00:18:53,560 --> 00:18:57,070
Mais nous pouvons voir qu'il a un certain nombre
que nous ne serions pas fait attendre.

348
00:18:57,070 --> 00:18:57,620
>> C'est bon.

349
00:18:57,620 --> 00:18:59,661
Ne vous inquiétez pas à ce sujet
parce que nous avons pas réellement

350
00:18:59,661 --> 00:19:04,970
initialisé ce nombre jusqu'à ce que je
enjamber cette ligne et la valeur

351
00:19:04,970 --> 00:19:08,560
i a été initialisé à la valeur 1.

352
00:19:08,560 --> 00:19:11,400
Donc, pour voir que ce est effectivement
le cas, nous allons passer par-dessus.

353
00:19:11,400 --> 00:19:14,420
Nous pouvons maintenant voir que ce
ligne a été exécuté.

354
00:19:14,420 --> 00:19:17,000
Et nous sommes maintenant soulignons
cette ligne de printf.

355
00:19:17,000 --> 00:19:22,230
>> Et nous pouvons maintenant voir comment nos valeurs
de i et 3 ont changé au fil du temps.

356
00:19:22,230 --> 00:19:26,450
Ceci est très utile de faire, en fait,
est à l'étape sur les lignes à plusieurs reprises.

357
00:19:26,450 --> 00:19:30,480
Et vous pouvez trouver ce que fait
passe à l'intérieur de votre boucle for

358
00:19:30,480 --> 00:19:33,660
et ce qui se passe à la
les variables à l'intérieur de cette boucle

359
00:19:33,660 --> 00:19:39,200
comme que l'exécution du programme
se produit une étape à la fois.

360
00:19:39,200 --> 00:19:41,110
>> Maintenant, à ce stade, je
enjambé juste assez

361
00:19:41,110 --> 00:19:44,210
que je suis maintenant à la fin de mon programme.

362
00:19:44,210 --> 00:19:46,980
Si je fais un pas sur cela, il sera
fait cesser l'exécution

363
00:19:46,980 --> 00:19:48,860
comme nous l'avons vu dans le passé.

364
00:19:48,860 --> 00:19:52,110
Permettez-moi de redémarrer ce, encore une fois, de sorte
que je peux pointer quelque chose d'autre,

365
00:19:52,110 --> 00:19:53,320
aussi.

366
00:19:53,320 --> 00:19:55,350
>> Dans ce cas, il est
maintenant me demander, à nouveau,

367
00:19:55,350 --> 00:19:57,100
pour un certain nombre, qui
Je vais, encore une fois, entrez.

368
00:19:57,100 --> 00:20:00,300
Mais cette fois, je vais entrer dans
un nombre plus grand de sorte que la boucle for

369
00:20:00,300 --> 00:20:02,540
va parcourir plusieurs fois.

370
00:20:02,540 --> 00:20:06,090
Dans ce cas, je vais
pour entrer une valeur de 11.

371
00:20:06,090 --> 00:20:08,390
>> Maintenant, encore une fois parce que je mets
un point à la ligne 15 de la pause,

372
00:20:08,390 --> 00:20:10,490
il va mettre en évidence cette ligne.

373
00:20:10,490 --> 00:20:12,980
Nous pouvons voir que notre
Numéro 11 est correctement

374
00:20:12,980 --> 00:20:15,560
représentés dans nos variables locales.

375
00:20:15,560 --> 00:20:22,460
Enjambant que nous pouvons maintenant
regardez ce qui arrive à notre valeur de i

376
00:20:22,460 --> 00:20:25,680
que nous procédons à l'intérieur de cette boucle.

377
00:20:25,680 --> 00:20:31,960
Il obtient incrémenté à chaque fois nous avons de
atteindre le sommet de cette boucle.

378
00:20:31,960 --> 00:20:35,110
>> Or l'une des choses qui pourraient
être utile de le faire lors de l'exécution

379
00:20:35,110 --> 00:20:40,490
de ce programme est pour moi de fait
modifier les variables midstream pour voir

380
00:20:40,490 --> 00:20:42,450
ce qui arrive à mon programme.

381
00:20:42,450 --> 00:20:46,540
Dans ce cas, je peux réellement
double-cliquez sur la valeur.

382
00:20:46,540 --> 00:20:48,040
Notez que cela devient un champ de texte.

383
00:20:48,040 --> 00:20:50,280
>> Maintenant, je peux entrer différente
valoriser tout

384
00:20:50,280 --> 00:20:55,700
pour voir comment mon programme se comporte
quand je l'ai changé cette variable.

385
00:20:55,700 --> 00:20:59,560
Or, dans ce cas, la variable
i contient maintenant la valeur 10.

386
00:20:59,560 --> 00:21:02,810
Mais le programme est encore
pause dans l'exécution.

387
00:21:02,810 --> 00:21:07,610
Lorsque je fais un pas plus, je vois que le
valeur i, qui je suis entré en tant que 10,

388
00:21:07,610 --> 00:21:12,170
est inférieure ou égale à la valeur de num,
ce qui provoque immédiatement la boucle

389
00:21:12,170 --> 00:21:14,240
de cesser d'exécuter.

390
00:21:14,240 --> 00:21:16,210
>> Maintenant que est pas la seule
raison pour laquelle vous le feriez

391
00:21:16,210 --> 00:21:19,450
vouloir modifier la variable en place.

392
00:21:19,450 --> 00:21:22,210
Vous pourriez veulent réellement
pour essayer de le modifier de manière

393
00:21:22,210 --> 00:21:24,590
que vous pouvez continuer
exécution d'une boucle

394
00:21:24,590 --> 00:21:27,370
ou de sorte que vous pouvez modifier
une certaine valeur avant

395
00:21:27,370 --> 00:21:32,630
atteint un certain ensemble spécifique de l'arithmétique
que vous vous apprêtez à effectuer.

396
00:21:32,630 --> 00:21:36,210
>> Alors, maintenant que nous avons réellement changer la
valeur de i que le programme a été exécuté,

397
00:21:36,210 --> 00:21:39,540
il a causé la boucle de quitter
prématurément en raison, tout d'un coup, i

398
00:21:39,540 --> 00:21:42,770
se trouvait être supérieure à la valeur
NUM, ce qui signifie que pour que la boucle

399
00:21:42,770 --> 00:21:45,410
ne sont plus nécessaires à exécuter.

400
00:21:45,410 --> 00:21:48,780
En outre, il est arrivé à être le
cas que nous avons changé la valeur de i

401
00:21:48,780 --> 00:21:53,270
lorsque la ligne 17 a été soulignée,
qui était le point dans le temps

402
00:21:53,270 --> 00:21:56,280
pour que l'exécution de la boucle
a été effectivement évalués.

403
00:21:56,280 --> 00:22:00,210
>> Si je l'avais changé la valeur de
i sur une ligne différente, dis 19,

404
00:22:00,210 --> 00:22:03,360
nous aurions vu différente
comportement parce que la ligne 19 serait

405
00:22:03,360 --> 00:22:08,310
ont exécuté avant que la boucle
condition a été réévalué.

406
00:22:08,310 --> 00:22:11,900
Or, à ce point, je suis, encore une fois,
à la fin de ce programme.

407
00:22:11,900 --> 00:22:15,707
Et je ne peux permettre que cela procéder à
mon programme permet de quitter naturellement.

408
00:22:15,707 --> 00:22:18,290
Mais il ya un certain nombre de choses
qui sont importants à emporter

409
00:22:18,290 --> 00:22:19,960
à partir de cette discussion particulière.

410
00:22:19,960 --> 00:22:22,490
Vous devez évaluer
vos propres hypothèses

411
00:22:22,490 --> 00:22:24,710
sur la façon dont le code doit être comporte.

412
00:22:24,710 --> 00:22:28,220
Chaque fois que vous pensez que quelque morceau
de code que vous savez qui se passe au travail,

413
00:22:28,220 --> 00:22:30,940
cela pourrait être un drapeau rouge pour aller
recul et d'évaluer, et être sûr

414
00:22:30,940 --> 00:22:33,470
que votre accession
comment ce code fonctionne

415
00:22:33,470 --> 00:22:38,290
est effectivement vrai à la façon dont il est
exprimé dans votre code source.

416
00:22:38,290 --> 00:22:41,300
>> Mais encore plus le point est,
lorsque nous utilisons le débogueur,

417
00:22:41,300 --> 00:22:43,920
vous pouvez mettre des points d'arrêt au
différentes lignes de code,

418
00:22:43,920 --> 00:22:48,110
ce qui provoquera le débogueur
suspendre l'exécution à chacune de ces lignes

419
00:22:48,110 --> 00:22:52,210
afin que vous puissiez évaluer la
mémoire ou même changer en place.

420
00:22:52,210 --> 00:22:55,630
Et encore une fois, rappelez-vous que vous pouvez
créer plusieurs points d'arrêt afin que vous

421
00:22:55,630 --> 00:23:00,390
peut également reprendre l'exécution, sautez
sur de grandes portions de code,

422
00:23:00,390 --> 00:23:04,790
et il va automatiquement en pause
au prochain point de rupture.

423
00:23:04,790 --> 00:23:07,760
>> Il ya en fait plus avancé
caractéristiques du débogueur, ainsi.

424
00:23:07,760 --> 00:23:10,170
Mais nous devrons vous renvoyer
à quelques vidéos suivantes

425
00:23:10,170 --> 00:23:14,090
afin de vraiment démêler comment
d'utiliser ces fonctions particulières.

426
00:23:14,090 --> 00:23:15,990
Pour l'instant, je vous remercie
beaucoup pour regarder.

427
00:23:15,990 --> 00:23:18,080
Et bonne chance débogage.