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

2
00:00:00,309 --> 00:00:02,350
[? DAN ARMADARAS:?] Hi,
Im [? Dan Armadaras?].

3
00:00:02,350 --> 00:00:04,410
Vandaag gaan we
kijken naar debuggen.

4
00:00:04,410 --> 00:00:06,697
Niet alleen gaan we
praten over een aantal technieken,

5
00:00:06,697 --> 00:00:09,280
maar we gaan kijken naar
een aantal van de functies bevatte

6
00:00:09,280 --> 00:00:14,170
binnen de CS50 IDE die het mogelijk maken
je gemakkelijk debuggen van een programma.

7
00:00:14,170 --> 00:00:16,272
>> Een voorbeeld van
iets dat mis kan gaan

8
00:00:16,272 --> 00:00:18,730
en het is eigenlijk iets
dat we al eerder hebben gezien.

9
00:00:18,730 --> 00:00:23,200
In dit geval is dit een C programma
dat een integer accepteert de gebruiker,

10
00:00:23,200 --> 00:00:27,580
volgt dat door twee, en geeft
de uitgang aan de gebruiker.

11
00:00:27,580 --> 00:00:30,610
Nu van wat we hebben gezien
eerder in lezingen,

12
00:00:30,610 --> 00:00:34,370
We weten dat dit daadwerkelijk zal leiden
specifieke soorten divisie problemen

13
00:00:34,370 --> 00:00:35,860
wanneer we hebben oneven nummers.

14
00:00:35,860 --> 00:00:40,330
>> Concreet zullen we gewoon weggooien
iets achter de komma.

15
00:00:40,330 --> 00:00:43,170
Nu, we weten dat dit
toevallig het geval.

16
00:00:43,170 --> 00:00:47,430
En als we lopen, kunnen we bevestigen
onze vermoedens, eerste, door het opstellen.

17
00:00:47,430 --> 00:00:50,460
Dan, door het uitvoeren en
het invoeren van een oneven aantal.

18
00:00:50,460 --> 00:00:51,720
>> Dit is niets nieuws.

19
00:00:51,720 --> 00:00:54,490
Maar dit is eigenlijk een
voorbeeld van een bug die

20
00:00:54,490 --> 00:00:58,810
kunnen bestaan ​​binnen een groter programma
dat wordt moeilijker op te sporen.

21
00:00:58,810 --> 00:01:02,640
Ook al weten we wat het probleem
is de ware crux

22
00:01:02,640 --> 00:01:06,250
zou proberen te identificeren
specifiek waar de fout zich voordoet,

23
00:01:06,250 --> 00:01:09,750
identificeren wat dat probleem
is, en vervolgens de vaststelling van het.

24
00:01:09,750 --> 00:01:14,400
Dus bieden dit als een voorbeeld
wat zou iets zijn

25
00:01:14,400 --> 00:01:19,030
dat weten we al, maar kan worden begraven
op andere elementen van de code.

26
00:01:19,030 --> 00:01:23,090
>> Dus het openen van dit andere bron
codebestand als voorbeeld,

27
00:01:23,090 --> 00:01:27,165
deze divisie probleem is nu
deel van een groter programma.

28
00:01:27,165 --> 00:01:29,040
Nog steeds is misschien een beetje
beetje gekunsteld, en we

29
00:01:29,040 --> 00:01:31,076
zou gemakkelijk kunnen
identificeren, met name

30
00:01:31,076 --> 00:01:32,450
aangezien we dit enkel bespreken.

31
00:01:32,450 --> 00:01:38,250
Maar we kunnen achterhalen dat dit
probleem kan bestaan ​​op een grotere schaal.

32
00:01:38,250 --> 00:01:45,450
>> Als ik dit compileren en nu
voer het uit, voer een oneven aantal,

33
00:01:45,450 --> 00:01:49,816
we kunnen zien dat we niet precies krijgen
de uitvoer die wij hebben verwacht.

34
00:01:49,816 --> 00:01:51,690
In dit specifieke geval,
zouden we kunnen zeggen dat we

35
00:01:51,690 --> 00:01:56,060
willen alle nummers te tellen
van een tot een aantal specifieke nummer.

36
00:01:56,060 --> 00:01:58,130
En we kunnen dat we zien
een verscheidenheid aan kwesties

37
00:01:58,130 --> 00:02:03,880
hier als we uitvoeren, gewoon, 0
en 1 wanneer wij een ingang van 5.

38
00:02:03,880 --> 00:02:07,380
>> Dus we weten al dat
Er is hier een probleem.

39
00:02:07,380 --> 00:02:11,662
Maar we kunnen niet precies weten
wanneer dit probleem werkelijk bestaat.

40
00:02:11,662 --> 00:02:13,620
Nu een van de manieren waarop
we kunnen proberen om dit op te lossen

41
00:02:13,620 --> 00:02:15,745
is iets dat we hebben
al geïntroduceerd.

42
00:02:15,745 --> 00:02:18,880
We kunnen gewoon gebruik maken van het op een grotere schaal.

43
00:02:18,880 --> 00:02:21,680
>> Op lijn 14, hebben we
Dit printf functie,

44
00:02:21,680 --> 00:02:25,620
die ons in staat om af te drukken uit de staat
van de verschillende stukjes informatie.

45
00:02:25,620 --> 00:02:28,880
En dit is iets dat je
moet benutten binnen uw programma

46
00:02:28,880 --> 00:02:33,100
om te proberen om erachter te komen wat is
gebeurt in verschillende regels code.

47
00:02:33,100 --> 00:02:36,350
Dus zelfs als dit niet het
eindresultaat dat we eigenlijk

48
00:02:36,350 --> 00:02:39,830
willen produceren uit
dit programma, we nog steeds

49
00:02:39,830 --> 00:02:42,300
kunnen sommige debug hebben
verklaringen waar we

50
00:02:42,300 --> 00:02:46,970
kan proberen te achterhalen precies wat
gebeurt binnenkant van onze code.

51
00:02:46,970 --> 00:02:51,210
>> Dus in dit geval, zal ik
printf met de debug-tag.

52
00:02:51,210 --> 00:02:53,540
In dit geval is
slechts een debug-reeks

53
00:02:53,540 --> 00:02:56,840
dat ik up-zetten, zodat het
zeer duidelijk in de output van mijn code

54
00:02:56,840 --> 00:02:59,200
wat het is dat ik wil laten zien.

55
00:02:59,200 --> 00:03:04,410
En de output hier het aantal
we hebben berekend.

56
00:03:04,410 --> 00:03:06,800
>> In dit geval zou ik
willen precies weten

57
00:03:06,800 --> 00:03:11,380
wat er gebeurt en vóór
na een specifieke berekening.

58
00:03:11,380 --> 00:03:16,224
Dus ik kan een printf gebruiken voordat
en daarna regel code.

59
00:03:16,224 --> 00:03:18,640
In dit geval, ik kon zelfs
maken het een beetje meer duidelijk

60
00:03:18,640 --> 00:03:21,960
door te zeggen debug vóór
en debuggen na zo

61
00:03:21,960 --> 00:03:26,540
dat ik mezelf niet te verwarren met
meerdere regels die identiek uitzien.

62
00:03:26,540 --> 00:03:32,290
>> Nu als we deze en run hercompileer
het, voer een nummer als vijf weer,

63
00:03:32,290 --> 00:03:35,090
kunnen we zien dat we hebben
nu uitgang voor en na

64
00:03:35,090 --> 00:03:40,670
en vind dat we niet hebben gedaan een duidelijke
splitsing of duidelijk dat het aantal

65
00:03:40,670 --> 00:03:43,680
dat we eigenlijk willen doen.

66
00:03:43,680 --> 00:03:48,660
Nu in dit geval is
niet echt een duidelijke output.

67
00:03:48,660 --> 00:03:52,440
Het is niet echt een duidelijke uitkomst die
we willen uit van dit specifieke programma.

68
00:03:52,440 --> 00:03:54,427
>> Dit is wederom een
beetje gekunsteld.

69
00:03:54,427 --> 00:03:57,510
Maar, misschien, een van de dingen die
we konden doen als de specificatie zei

70
00:03:57,510 --> 00:04:01,900
dat we willen dit delen door
2 en voeg 1-- dus met andere woorden,

71
00:04:01,900 --> 00:04:04,550
We willen dan up-- afronden
we zouden weten dat we konden

72
00:04:04,550 --> 00:04:08,060
doe dat bepaalde ding, in dit geval.

73
00:04:08,060 --> 00:04:14,010
Hier nu weten we dat we zullen zijn
in staat om 1 toe te voegen aan onze gehalveerd nummer.

74
00:04:14,010 --> 00:04:16,490
>> Laten we dit opnieuw te compileren
en bevestigen dat dit

75
00:04:16,490 --> 00:04:18,860
gedraagt ​​de manier waarop we dat willen.

76
00:04:18,860 --> 00:04:21,980
We kunnen nu voor dat
hebben, hebben we het nummer 5.

77
00:04:21,980 --> 00:04:26,620
Na, hebben we de nummer 3,
die volgens onze specificatie

78
00:04:26,620 --> 00:04:29,292
is wat we wilden doen.

79
00:04:29,292 --> 00:04:31,000
Maar als we kijken naar de
uitgang hier, we kunnen

80
00:04:31,000 --> 00:04:33,760
zien dat we een ander zouden kunnen hebben
bug helemaal, dat is

81
00:04:33,760 --> 00:04:36,940
dat we beginnen onze telling van 0.

82
00:04:36,940 --> 00:04:39,390
>> Nu weer, dit is iets
die we hebben gezien in het verleden

83
00:04:39,390 --> 00:04:42,500
en we kunnen vrij gemakkelijk te repareren.

84
00:04:42,500 --> 00:04:44,790
Maar in dit geval, we
had ook het voordeel

85
00:04:44,790 --> 00:04:48,940
van het gebruik van de printf statement
direct in de lus

86
00:04:48,940 --> 00:04:52,930
weten precies waar de
die fout voorkwam.

87
00:04:52,930 --> 00:04:55,150
Dus printf verklaringen zijn
zeer nuttig bij het helpen

88
00:04:55,150 --> 00:04:57,940
u bepalen waar,
juist in uw broncode,

89
00:04:57,940 --> 00:05:00,620
een specifieke fout optreedt.

90
00:05:00,620 --> 00:05:03,650
>> En het is ook belangrijk om te beseffen
dat, als we het schrijven van code,

91
00:05:03,650 --> 00:05:06,052
we kunnen aannames
de toestand van een programma.

92
00:05:06,052 --> 00:05:08,510
Of we zouden aannames
over welk deel van het programma

93
00:05:08,510 --> 00:05:13,020
is eigenlijk juist of onjuist wanneer
later als we bouwen dat programma

94
00:05:13,020 --> 00:05:15,950
en maakt het deel uit van een
complex en groter programma

95
00:05:15,950 --> 00:05:19,700
dat we ons realiseren dat sommige aspecten
van die eigenlijk buggy.

96
00:05:19,700 --> 00:05:22,680
>> Met behulp van printf kan echt helpen
beperken en te identificeren

97
00:05:22,680 --> 00:05:26,430
de regio's van een programma dat niet mag
worden precies gedraagt ​​de manier waarop we

98
00:05:26,430 --> 00:05:29,500
verwacht op basis van onze veronderstellingen.

99
00:05:29,500 --> 00:05:31,460
Maar er is ander gereedschap
beschikbaar, evenals,

100
00:05:31,460 --> 00:05:34,860
die ons in staat om te proberen te achterhalen
waar een fout optreedt

101
00:05:34,860 --> 00:05:39,930
en, specifiek, welke dingen
gebeuren binnen het programma.

102
00:05:39,930 --> 00:05:41,990
>> Dus met behulp van printf is zeer
handig wanneer we willen

103
00:05:41,990 --> 00:05:45,900
om specifieke gebieden van identificatie
een programma dat enkele bug te hebben.

104
00:05:45,900 --> 00:05:47,730
Maar het wordt ook
vervelend na een tijdje.

105
00:05:47,730 --> 00:05:50,500
In dit geval is dit een
relatief eenvoudig programma

106
00:05:50,500 --> 00:05:52,750
met slechts een of twee variabelen.

107
00:05:52,750 --> 00:05:57,260
En wordt het heel gemakkelijk voor ons om
afdruk van de waarde van die variabelen

108
00:05:57,260 --> 00:05:59,670
in het geheel van het programma.

109
00:05:59,670 --> 00:06:02,670
>> Maar we zouden een ander hebben
programma dat vele variabelen.

110
00:06:02,670 --> 00:06:06,530
En het kan niet helemaal worden
zo gemakkelijk te gebruiken printf

111
00:06:06,530 --> 00:06:10,120
om te proberen om te evalueren wat er gebeurt
aan elk van die variabelen

112
00:06:10,120 --> 00:06:13,590
het programma uitvoert.

113
00:06:13,590 --> 00:06:16,960
Er is een programma dat bestaat
genoemd debugger programma.

114
00:06:16,960 --> 00:06:20,320
In dit geval degene die we zullen
gebruik is de GNU debugger, of GDB,

115
00:06:20,320 --> 00:06:24,260
dat ons toelaat om de interne inspecteren
werking van een programma op een meer

116
00:06:24,260 --> 00:06:25,700
gedetailleerde manier.

117
00:06:25,700 --> 00:06:28,810
>> We kunnen daadwerkelijk uit te voeren
GDB vanaf de opdrachtregel

118
00:06:28,810 --> 00:06:35,370
hier door simpelweg te typen GDB en de
commando dat we willen debuggen.

119
00:06:35,370 --> 00:06:37,550
In dit geval tellen.

120
00:06:37,550 --> 00:06:41,650
Nu in dit geval kunnen we zien dat het
brengt ons naar een prompt die GDB zegt.

121
00:06:41,650 --> 00:06:44,020
En we kunnen eigenlijk
commando's uitvoeren om GDB

122
00:06:44,020 --> 00:06:48,260
daadwerkelijk starten uitvoering van de
programma, stoppen op bepaalde punten,

123
00:06:48,260 --> 00:06:51,060
evalueren van de variabelen en
inspecteren van de variabelen die

124
00:06:51,060 --> 00:06:54,152
bestaan ​​in de programmastatus
op dat moment,

125
00:06:54,152 --> 00:06:55,110
enzovoort.

126
00:06:55,110 --> 00:06:57,240
Het geeft veel kracht voor ons.

127
00:06:57,240 --> 00:06:59,960
>> Maar het is gewoon zo gebeurt
dat de CS50 IDE ook

128
00:06:59,960 --> 00:07:05,870
levert een GUI of user
interface voor GDB dat

129
00:07:05,870 --> 00:07:11,120
stelt ons in staat om dit te doen zonder
de command line interface dan ook

130
00:07:11,120 --> 00:07:13,560
of helemaal niet zelfs.

131
00:07:13,560 --> 00:07:16,930
De manier waarop ik kan toegang tot die
is met behulp van de debug-toets

132
00:07:16,930 --> 00:07:20,120
op de top van de CS50 IDE.

133
00:07:20,120 --> 00:07:24,280
Nu in het verleden, wat we
gezien is dat we gebruik maken van de opdracht

134
00:07:24,280 --> 00:07:27,660
lijn te compileren en vervolgens uitvoeren van een programma.

135
00:07:27,660 --> 00:07:29,790
>> De debug-knop doet
beide van deze stappen.

136
00:07:29,790 --> 00:07:34,380
Maar het zal ook brengen de
tabblad debugger uiterst rechts

137
00:07:34,380 --> 00:07:38,280
die ons in staat stelt om een ​​verscheidenheid te inspecteren
van de eigenschappen van het programma

138
00:07:38,280 --> 00:07:40,500
zoals wordt uitgevoerd.

139
00:07:40,500 --> 00:07:44,280
Als ik klik debug, in dit
geval is, zal het te brengen

140
00:07:44,280 --> 00:07:48,230
een nieuw tabblad in de console
venster op de bodem.

141
00:07:48,230 --> 00:07:51,160
>> En je kunt zien dat dit tabblad heeft
wat informatie aan de top.

142
00:07:51,160 --> 00:07:52,670
En we kunnen grotendeels negeren.

143
00:07:52,670 --> 00:07:54,800
Maar een van de dingen
dat we willen zien

144
00:07:54,800 --> 00:07:57,170
dat deze luidspreker
het zelfde ding dat we

145
00:07:57,170 --> 00:08:03,000
zou krijgen als we probeerden te lopen maken op
het C-programma in het terminal-venster.

146
00:08:03,000 --> 00:08:06,230
>> Hier kunnen we zien het draait Clang,
en heeft diverse vlaggen,

147
00:08:06,230 --> 00:08:12,660
en het is het samenstellen van onze count.c bestand,
die het geselecteerde tabblad op dat moment was

148
00:08:12,660 --> 00:08:15,100
dat ik raakte debug.

149
00:08:15,100 --> 00:08:18,010
Dus dit is erg handig, omdat
nu met behulp van deze debug-knop,

150
00:08:18,010 --> 00:08:23,280
kunnen we tegelijkertijd compileren en vervolgens
het programma uit te voeren dat we eigenlijk

151
00:08:23,280 --> 00:08:24,460
wilt uitvoeren.

152
00:08:24,460 --> 00:08:27,880
>> Een van de vlaggen die
belang, in dit geval,

153
00:08:27,880 --> 00:08:30,190
we hebben eigenlijk geweest met
voor de langste tijd

154
00:08:30,190 --> 00:08:32,450
maar ook gewoon deed wat de hand
zwaaien [onhoorbaar], die

155
00:08:32,450 --> 00:08:33,820
is dit hier.

156
00:08:33,820 --> 00:08:35,790
In Clang, zegt -ggdb3.

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

158
00:08:38,570 --> 00:08:41,250
In dit geval, wat we
vertellen Clang, onze compiler,

159
00:08:41,250 --> 00:08:43,820
is dat we willen ons programma te compileren.

160
00:08:43,820 --> 00:08:46,810
Maar ook wat zijn
genaamd symbool informatie

161
00:08:46,810 --> 00:08:50,940
zodat de compiler daadwerkelijk toegang
veel van de onderliggende informatie

162
00:08:50,940 --> 00:08:52,610
vervat in het programma.

163
00:08:52,610 --> 00:08:55,260
>> Meer specifiek, het aantal
van de functies die ik heb,

164
00:08:55,260 --> 00:08:58,000
de namen van deze functies,
de variabelen, de types

165
00:08:58,000 --> 00:09:01,730
dat deze variabelen zijn, en diverse
andere dingen die de debugger helpen

166
00:09:01,730 --> 00:09:04,350
voeren de werking ervan.

167
00:09:04,350 --> 00:09:06,600
Nu is er iets anders
Dat is belangrijk om te vermelden

168
00:09:06,600 --> 00:09:10,280
als we bespreken running
een programma op deze manier.

169
00:09:10,280 --> 00:09:13,660
>> Merk op dat het eigenlijk
bracht een nieuw tabblad in onze console

170
00:09:13,660 --> 00:09:14,780
langs de bodem.

171
00:09:14,780 --> 00:09:18,600
We hoeven niet langer te interageren
rechtstreeks met de terminal-venster.

172
00:09:18,600 --> 00:09:21,420
Maar deze nieuwe tabblad is
eigenlijk een terminal venster.

173
00:09:21,420 --> 00:09:26,710
Het is gewoon eigen aan de lopende
programma dat we hebben gecreëerd.

174
00:09:26,710 --> 00:09:29,270
>> Merk op dat bij de bodem, in
combinatie met enkele uitgang

175
00:09:29,270 --> 00:09:33,500
kletteren door de compiler en de GDB,
die kunnen we grotendeels negeren,

176
00:09:33,500 --> 00:09:37,570
het eigenlijk toont de uitvoer van
ons programma op de bodem.

177
00:09:37,570 --> 00:09:41,240
Nu is het belangrijk om te beseffen
dat dit venster eigenlijk

178
00:09:41,240 --> 00:09:43,360
zal u de
uitvoer van je programma

179
00:09:43,360 --> 00:09:47,190
maar ook kan invoeren accepteren
voor dat programma, ook.

180
00:09:47,190 --> 00:09:49,260
>> Zo bericht dat zegt
Voer een getal,

181
00:09:49,260 --> 00:09:53,050
die dezelfde uitvoer die we hadden
had in de terminal venster voordat.

182
00:09:53,050 --> 00:09:55,510
Maar het is nu getoond in deze nieuwe tabblad.

183
00:09:55,510 --> 00:09:56,550
Ik kan een nummer invoeren.

184
00:09:56,550 --> 00:10:00,900
En het zal in feite
functie als we verwachten

185
00:10:00,900 --> 00:10:05,890
toont ons onze debug, output,
de uitvoer die misschien buggy,

186
00:10:05,890 --> 00:10:07,010
zoals we eerder hebben gezien.

187
00:10:07,010 --> 00:10:10,460
En helemaal onderaan het
heeft eigenlijk een aantal extra uitgang

188
00:10:10,460 --> 00:10:14,550
van het BBP gewoon te zeggen dat
dit programma is voltooid.

189
00:10:14,550 --> 00:10:16,655
>> Nu zoals je zag in deze
bijzonder lopen door,

190
00:10:16,655 --> 00:10:19,370
het was niet bijzonder
handig omdat zelfs

191
00:10:19,370 --> 00:10:23,740
al hadden we de debugger menu komen
up, was dit nog steeds een lopend programma.

192
00:10:23,740 --> 00:10:26,790
Op geen enkel moment heeft het eigenlijk
pauzeren uitvoering voor ons

193
00:10:26,790 --> 00:10:30,767
kunnen al inspecteren
de variabelen in ons systeem.

194
00:10:30,767 --> 00:10:32,850
Er is iets anders
dat we moeten doen om

195
00:10:32,850 --> 00:10:36,910
om GDB krijgen om te erkennen dat we willen
om de uitvoering van het programma te pauzeren

196
00:10:36,910 --> 00:10:42,820
en niet alleen toestaan ​​doorgaan
normaal gesproken als we zouden in elk ander geval.

197
00:10:42,820 --> 00:10:45,530
>> Om uitvoering te pauzeren,
bij een aantal specifieke lijn,

198
00:10:45,530 --> 00:10:47,830
we nodig hebben om te creëren wat
riep een breekpunt.

199
00:10:47,830 --> 00:10:52,670
En een breekpunt is heel gemakkelijk gemaakt
in deze CS50 IDE door het nemen van uw muis

200
00:10:52,670 --> 00:10:57,090
en naar links te klikken direct
van enkele specifieke lijnnummer.

201
00:10:57,090 --> 00:10:59,920
Zodra ik dat doe, een rode stip
verschijnt, wat aangeeft

202
00:10:59,920 --> 00:11:02,300
dat die lijn is nu een breekpunt.

203
00:11:02,300 --> 00:11:07,540
>> En de volgende keer dat ik run GDB, dat
stopt de uitvoering op dat breekpunt

204
00:11:07,540 --> 00:11:10,280
wanneer dat regel code bereikt.

205
00:11:10,280 --> 00:11:12,230
Nu is dit een belangrijke
ding om te realiseren

206
00:11:12,230 --> 00:11:16,140
dat het niet noodzakelijk de
zo dat elke regel code

207
00:11:16,140 --> 00:11:17,880
in feite bereikbaar.

208
00:11:17,880 --> 00:11:23,780
Als ik naar een functie te creëren
hier, voor example-- leegte F--

209
00:11:23,780 --> 00:11:31,230
en gewoon doen een afdruk lijn hier-- hello
wereld-- als ik nooit deze functie aan te roepen,

210
00:11:31,230 --> 00:11:34,770
Het is het geval dat,
als ik een break point hier,

211
00:11:34,770 --> 00:11:36,220
de functie niet genoemd.

212
00:11:36,220 --> 00:11:38,310
En daarom, dit
bijzonder breekpunt

213
00:11:38,310 --> 00:11:43,040
zal nooit echt pauzeren
uitvoering van het programma.

214
00:11:43,040 --> 00:11:48,020
>> Dus laten we zeggen dat ik het goed maak
een breekpunt op enkele regel code

215
00:11:48,020 --> 00:11:50,340
dat daadwerkelijk wordt uitgevoerd.

216
00:11:50,340 --> 00:11:53,470
Nu in dit geval is dat het
eerste lijn in de belangrijkste functie.

217
00:11:53,470 --> 00:11:56,630
Zo zal het zeker het geval
dat, zodra ik beginnen met de uitvoering,

218
00:11:56,630 --> 00:11:58,580
de eerste lijn zal worden bereikt.

219
00:11:58,580 --> 00:12:00,230
GDB zal uitvoering pauzeren.

220
00:12:00,230 --> 00:12:04,100
En dan zal ik in staat te zijn
interactie met de debugger.

221
00:12:04,100 --> 00:12:08,480
>> U kunt meerdere regels als set
breekpunten, als je zou willen.

222
00:12:08,480 --> 00:12:11,365
We kunnen ook een lijn te creëren up
hier in dit segment van de code

223
00:12:11,365 --> 00:12:12,490
dat zal nooit worden bereikt.

224
00:12:12,490 --> 00:12:14,744
En we kunnen ook een verder hieronder.

225
00:12:14,744 --> 00:12:16,660
De reden dat we zouden
wil dit We doen

226
00:12:16,660 --> 00:12:19,119
gaan in een beetje meer
detail in slechts een moment.

227
00:12:19,119 --> 00:12:21,660
Dus voor nu, laat me gewoon uitschakelen
deze extra breekpunten

228
00:12:21,660 --> 00:12:24,940
zodat we kunnen kijken naar wat er gebeurt
als ik één break

229
00:12:24,940 --> 00:12:27,650
punt in mijn programma.

230
00:12:27,650 --> 00:12:29,410
Ik heb gedaan wat
veranderingen in dit programma.

231
00:12:29,410 --> 00:12:30,750
Dus ik nodig om het te redden.

232
00:12:30,750 --> 00:12:34,490
Ik zal klikken debug, zodat ik kan
beginnen met het samenstellen en vervolgens

233
00:12:34,490 --> 00:12:36,880
uitvoering van de debugger.

234
00:12:36,880 --> 00:12:40,632
>> We zullen zien dat, na momenten, de
lijn die wij als de pauze gekozen

235
00:12:40,632 --> 00:12:43,360
punt is geel gemarkeerd.

236
00:12:43,360 --> 00:12:47,440
We kunnen ook merken dat er in de
rechtsboven in het debug panel

237
00:12:47,440 --> 00:12:50,940
dat het pauzepictogram heeft gedraaid
in een klein spel icoon.

238
00:12:50,940 --> 00:12:54,710
Dit betekent dat we pauze
uitvoeren, in dit geval.

239
00:12:54,710 --> 00:12:57,840
En het raken van de Play-knop zou
ons toelaten om de uitvoering te hervatten

240
00:12:57,840 --> 00:13:00,000
op dat specifieke moment.

241
00:13:00,000 --> 00:13:03,240
>> Merk op dat er een paar andere
knoppen beschikbaar in debug paneel,

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

243
00:13:04,220 --> 00:13:09,470
Stap over, die mij toelaat om
voeren dat een regel code

244
00:13:09,470 --> 00:13:14,030
en stap over naar die lijn naar de
volgende, die in dit geval,

245
00:13:14,030 --> 00:13:17,060
zou betekenen dat de printf
instructie wordt uitgevoerd.

246
00:13:17,060 --> 00:13:22,310
En het zal dan pauzeren
executie op lijn 13, zoals zo.

247
00:13:22,310 --> 00:13:25,090
>> En er is ook een stap
in functie, waarin

248
00:13:25,090 --> 00:13:28,950
is handig als ik andere hebben gecreëerd
functies elders in de broncode.

249
00:13:28,950 --> 00:13:31,420
En ik wil om de stap naar
die functies plaats

250
00:13:31,420 --> 00:13:33,050
voeren die functie als geheel.

251
00:13:33,050 --> 00:13:37,279
Maar we zullen meer kijken naar de stap
in functie in slechts een moment.

252
00:13:37,279 --> 00:13:40,320
Nu een aantal andere dingen die
werkelijk bestaan ​​binnen deze debug panel.

253
00:13:40,320 --> 00:13:44,110
>> Wij hebben dit panel genaamd de
noemen stack, die ons laat zien

254
00:13:44,110 --> 00:13:45,300
waar we precies zijn.

255
00:13:45,300 --> 00:13:48,550
In dit geval zijn wij binnen
van de hoofdfunctie.

256
00:13:48,550 --> 00:13:50,880
Ons script wordt genoemd count.c.

257
00:13:50,880 --> 00:13:53,820
En we toevallig op te zijn
lijn 13, kolom één, die

258
00:13:53,820 --> 00:13:58,950
is precies wat de gemarkeerde regio
van de broncode aangeeft, ook.

259
00:13:58,950 --> 00:14:02,435
>> Nu merken dat dit toont ook
onder de lokale variabele sectie

260
00:14:02,435 --> 00:14:06,710
alle variabelen die
bestaan ​​binnen deze functie.

261
00:14:06,710 --> 00:14:08,930
Het is belangrijk op te merken
dat alle variabelen

262
00:14:08,930 --> 00:14:12,580
verschijnt in deze lokale variabele
sectie binnen een functie,

263
00:14:12,580 --> 00:14:14,380
zelfs voordat ze zijn gedefinieerd.

264
00:14:14,380 --> 00:14:19,160
We kunnen hier zien dat we een variabele
num genaamd, heeft een standaard waarde van 0,

265
00:14:19,160 --> 00:14:21,280
en het is van het type int.

266
00:14:21,280 --> 00:14:24,110
>> Nu voordat we daadwerkelijk initialiseren
al deze variabelen,

267
00:14:24,110 --> 00:14:26,685
we zijn niet noodzakelijkerwijs
gegarandeerd een waarde van 0 te zien.

268
00:14:26,685 --> 00:14:29,200
En afhankelijk van andere uitvoeringen
die je hebt uitgevoerd

269
00:14:29,200 --> 00:14:32,020
en de staat van je geheugen als
je eigenlijk dit programma uitvoert,

270
00:14:32,020 --> 00:14:34,605
je zou kunnen vinden dat je
niet de waarden van 0 niet zien

271
00:14:34,605 --> 00:14:36,550
en in plaats daarvan een andere gekke nummers.

272
00:14:36,550 --> 00:14:38,390
>> Maar maak je geen zorgen over.

273
00:14:38,390 --> 00:14:44,610
Het gaat niet relevant tot zijn
je eigenlijk initialiseren van de waarde.

274
00:14:44,610 --> 00:14:49,630
Nu in dit geval, kunnen we dat zien
Ik heb uitgevoerd een aantal uitgangen.

275
00:14:49,630 --> 00:14:52,131
En ik ben, nu, zweeg uitvoering.

276
00:14:52,131 --> 00:14:53,880
Maar in dit geval, wat
Ik echt wil doen

277
00:14:53,880 --> 00:14:58,060
is nu stap over deze lijn
van de code, zodat ik kan eigenlijk

278
00:14:58,060 --> 00:15:04,390
zoekopdracht van de gebruiker voor die int die
we willen gebruiken in ons programma.

279
00:15:04,390 --> 00:15:07,060
>> Nu in dit geval, wanneer
Ik raakte stap over, bericht

280
00:15:07,060 --> 00:15:11,940
dat de Pauze of liever de Resume
knop is veranderd om dit pauzeknop

281
00:15:11,940 --> 00:15:14,022
omdat deze code daadwerkelijk uitvoert.

282
00:15:14,022 --> 00:15:15,730
Wat gebeurt er
nu is dat het

283
00:15:15,730 --> 00:15:21,630
op ons te wachten voor het invoeren van een aantal gegevens
zoals we kunnen zien door onze output tekst

284
00:15:21,630 --> 00:15:23,600
helemaal onderaan.

285
00:15:23,600 --> 00:15:25,787
>> Dus nu, dit is
eigenlijk niet onderbroken,

286
00:15:25,787 --> 00:15:28,620
hoewel het, soort van, verschijnt
te zijn, omdat er niets gebeurt.

287
00:15:28,620 --> 00:15:32,360
Maar het is gewoon zo gebeurt het dat in
mijn specifieke geval op lijn 13,

288
00:15:32,360 --> 00:15:34,210
Ik wacht op input van de gebruiker.

289
00:15:34,210 --> 00:15:39,130
En dus GDB is niet in staat om te inspecteren
een programma dat wordt uitgevoerd.

290
00:15:39,130 --> 00:15:43,370
>> Nu is de volgende keer dat ik dient een
input-- dus zal ik dat nummer 5 in te voeren,

291
00:15:43,370 --> 00:15:46,140
zoals we hebben gezien in de
past-- hit Return, en we

292
00:15:46,140 --> 00:15:51,430
opmerken dat, onmiddellijk, GDB pauzes
en, opnieuw, wijst op de volgende regel.

293
00:15:51,430 --> 00:15:55,320
Maar merken dat nu, als een
resultaat van onze het invoeren van een waarde,

294
00:15:55,320 --> 00:15:58,930
we hebben die waarde binnen bijgewerkt
van onze lokale variabelen, die

295
00:15:58,930 --> 00:16:05,560
is zeer nuttig om precies te weten
Wat dat nummer is in het geheugen.

296
00:16:05,560 --> 00:16:10,650
>> Nu kan ik toestaan ​​dat dit programma voort te zetten
spelen totdat het einde van de uitvoering

297
00:16:10,650 --> 00:16:12,570
door het raken van CV.

298
00:16:12,570 --> 00:16:16,410
We kunnen zien dat heel snel
doet het programma afwerking uitvoeren

299
00:16:16,410 --> 00:16:19,790
met dezelfde uitgang die we
had vóór, de debugger sluit,

300
00:16:19,790 --> 00:16:23,170
en nu dit programma
is volledig gestopt.

301
00:16:23,170 --> 00:16:25,320
>> I blijkt dat slechts de
toepassing van zien wat

302
00:16:25,320 --> 00:16:27,280
gebeurt er als we daadwerkelijk getroffen hervatten.

303
00:16:27,280 --> 00:16:30,640
Maar we eigenlijk gaan
willen terug te gaan in dit programma

304
00:16:30,640 --> 00:16:33,820
zodat we kunnen proberen te debuggen
precies wat er gebeurt.

305
00:16:33,820 --> 00:16:37,980
Nu dat ik het gebruik van de debugger, kan ik
niet deze debug printf verklaringen nodig.

306
00:16:37,980 --> 00:16:43,860
>> Dus ik kon ze te verwijderen als ik zal doen
nu alleen maar om terug te gaan naar onze eenvoudiger code

307
00:16:43,860 --> 00:16:45,950
dat we een ogenblik geleden.

308
00:16:45,950 --> 00:16:48,790
Nu wanneer ik sla de
programmeren en uit te voeren,

309
00:16:48,790 --> 00:16:53,700
zal, opnieuw naar die initiële
break punt dat ik had op lijn 11.

310
00:16:53,700 --> 00:16:57,700
En ik zal in staat zijn om te inspecteren
mijn variabelen zoals ik wil doen.

311
00:16:57,700 --> 00:17:00,695
>> Het is gewoon zo gebeurt het dat deze
deel is niet erg interessant,

312
00:17:00,695 --> 00:17:04,364
En ik weet dat ik ga
uit te printen deze verklaring.

313
00:17:04,364 --> 00:17:05,280
Vul een getal.

314
00:17:05,280 --> 00:17:08,099
En dan, ik weet dat ik ga
de gebruiker die integer stellen.

315
00:17:08,099 --> 00:17:13,329
Dus misschien, ik eigenlijk wilt verplaatsen mijn
break punt een beetje verder naar beneden.

316
00:17:13,329 --> 00:17:16,710
>> U kunt breekpunten verwijderen
door te klikken op, opnieuw, direct

317
00:17:16,710 --> 00:17:18,460
links van die lijnnummer.

318
00:17:18,460 --> 00:17:22,200
Dat red dot zal verdwijnen, wat aangeeft
dat breekpunt nu is verdwenen.

319
00:17:22,200 --> 00:17:24,780
Nu in dit geval
uitvoering is onderbroken.

320
00:17:24,780 --> 00:17:27,770
En zo gaat het eigenlijk niet van plan om
hervatten in dat geval.

321
00:17:27,770 --> 00:17:30,210
Maar ik kan een pauze instellen
wijzen een beetje later.

322
00:17:30,210 --> 00:17:33,880
>> En als ik nu weer mijn
code, het zal hervatten en vertel

323
00:17:33,880 --> 00:17:36,190
het punt van dat breekpunt.

324
00:17:36,190 --> 00:17:37,374
Nogmaals, ik raakte hervatten.

325
00:17:37,374 --> 00:17:39,040
Lijkt niet als iets gebeurt.

326
00:17:39,040 --> 00:17:41,450
Maar dat komt omdat mijn
code wacht op invoer.

327
00:17:41,450 --> 00:17:47,900
Ik zal een aantal 5 in te voeren, druk op Enter, en
nu de volgende breekpunt zal worden getroffen.

328
00:17:47,900 --> 00:17:50,570
>> Nu in dit geval is dit
is de regel code

329
00:17:50,570 --> 00:17:53,820
dat, voordat we wisten
is er gebeurd met buggy zijn.

330
00:17:53,820 --> 00:17:57,590
Dus laten we evalueren wat er gebeurt
op dit moment.

331
00:17:57,590 --> 00:18:02,620
Als een regel is gemarkeerd, dit
lijn nog niet is uitgevoerd.

332
00:18:02,620 --> 00:18:06,490
Dus in dit geval, kunnen we zien
dat ik een nummer, dat

333
00:18:06,490 --> 00:18:11,610
Ik heb een integer genoemd
num dat een waarde 5 heeft.

334
00:18:11,610 --> 00:18:15,090
En ik ga optreden
wat wiskunde op dat nummer.

335
00:18:15,090 --> 00:18:20,130
>> Als ik stap over, dat we kunnen
merken dat de waarde van num

336
00:18:20,130 --> 00:18:23,780
veranderd overeenkomstig de
rekenkunde dat we eigenlijk hebben gedaan.

337
00:18:23,780 --> 00:18:26,810
En nu dat we
binnenkant van deze lus

338
00:18:26,810 --> 00:18:29,090
of nu de lus
zelf is gemarkeerd,

339
00:18:29,090 --> 00:18:32,450
we zien dat we een nieuwe
variabele genaamd i die

340
00:18:32,450 --> 00:18:35,370
zal worden gebruikt in die lus.

341
00:18:35,370 --> 00:18:38,230
>> Nu herinner voordat ik
gezegd dat je soms bent

342
00:18:38,230 --> 00:18:43,470
gaat om een ​​soort van gekke zien
nummers als standaard voor dat getal

343
00:18:43,470 --> 00:18:45,530
of die variabele
eigenlijk geïnitialiseerd.

344
00:18:45,530 --> 00:18:49,040
We kunnen precies zien dat
Hier in deze variabele

345
00:18:49,040 --> 00:18:51,345
riep ik, die niet heeft
Nog geïnitialiseerd

346
00:18:51,345 --> 00:18:53,560
op het moment van het benadrukken.

347
00:18:53,560 --> 00:18:57,070
Maar we kunnen zien dat het een getal
dat we eigenlijk niet verwacht.

348
00:18:57,070 --> 00:18:57,620
>> Dat is geen probleem.

349
00:18:57,620 --> 00:18:59,661
Maak je geen zorgen over
want we hebben niet echt

350
00:18:59,661 --> 00:19:04,970
geïnitialiseerd dat nummer totdat ik
stap over deze lijn en de waarde

351
00:19:04,970 --> 00:19:08,560
i is geïnitialiseerd op de waarde 1.

352
00:19:08,560 --> 00:19:11,400
Dus om te zien dat dat eigenlijk
het geval is, laten we stap over.

353
00:19:11,400 --> 00:19:14,420
We kunnen nu zien dat
lijn is uitgevoerd.

354
00:19:14,420 --> 00:19:17,000
En we zijn nu markeren
Dit printf lijn.

355
00:19:17,000 --> 00:19:22,230
>> En we kunnen nu zien hoe onze waarden
van i en 3 zijn veranderd in de tijd.

356
00:19:22,230 --> 00:19:26,450
Dit is nuttig om te doen, in feite,
is herhaaldelijk stap over lijnen.

357
00:19:26,450 --> 00:19:30,480
En je kunt wat eigenlijk vinden
gebeurt binnenkant van de lus

358
00:19:30,480 --> 00:19:33,660
en wat gebeurt er met de
variabelen binnenkant van die lus

359
00:19:33,660 --> 00:19:39,200
als programmauitvoering
optreedt één stap tegelijk.

360
00:19:39,200 --> 00:19:41,110
>> Nu op dit punt, ik
stapte over net genoeg

361
00:19:41,110 --> 00:19:44,210
dat ik nu ben aan het eind van mijn programma.

362
00:19:44,210 --> 00:19:46,980
Als ik stap over dat, het zal
eigenlijk ophouden uitvoering

363
00:19:46,980 --> 00:19:48,860
zoals we hebben gezien in het verleden.

364
00:19:48,860 --> 00:19:52,110
Laat me opnieuw dit, wederom, dus
dat ik iets anders kan wijzen,

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

366
00:19:53,320 --> 00:19:55,350
>> In dit geval is
me nu vraagt, wederom,

367
00:19:55,350 --> 00:19:57,100
een nummer dat
Ik zal, nogmaals, in te voeren.

368
00:19:57,100 --> 00:20:00,300
Maar deze keer, ik ga in te voeren
een groter aantal, zodat de lus

369
00:20:00,300 --> 00:20:02,540
zal herhalen keer.

370
00:20:02,540 --> 00:20:06,090
In dit geval, ga ik
een waarde van 11 invoeren.

371
00:20:06,090 --> 00:20:08,390
>> Nu weer omdat ik ingesteld
een breekpunt op lijn 15,

372
00:20:08,390 --> 00:20:10,490
het gaat om die lijn te markeren.

373
00:20:10,490 --> 00:20:12,980
We kunnen zien dat onze
nummer 11 correct

374
00:20:12,980 --> 00:20:15,560
vertegenwoordigd in onze lokale variabelen.

375
00:20:15,560 --> 00:20:22,460
Intensivering over dat, we kunnen nu
kijk wat er gebeurt in onze waarde van i

376
00:20:22,460 --> 00:20:25,680
als we verder binnenkant van deze lus.

377
00:20:25,680 --> 00:20:31,960
Het wordt opgehoogd elke keer als we
bereikt de top van dat voor de lus.

378
00:20:31,960 --> 00:20:35,110
>> Nu is een van de dingen die zouden kunnen
nuttig zijn tijdens uitvoering

379
00:20:35,110 --> 00:20:40,490
van dit programma is voor mij eigenlijk
veranderen de variabelen midstream te zien

380
00:20:40,490 --> 00:20:42,450
wat gebeurt er met mijn programma.

381
00:20:42,450 --> 00:20:46,540
In dit geval, kan ik eigenlijk
Dubbelklik op de waarde.

382
00:20:46,540 --> 00:20:48,040
Merk op dat het een tekstveld.

383
00:20:48,040 --> 00:20:50,280
>> Nu kan ik anders in te voeren
waardeert totaal

384
00:20:50,280 --> 00:20:55,700
om te zien hoe mijn programma gedraagt
als ik die variabele ben veranderd.

385
00:20:55,700 --> 00:20:59,560
Nu in dit geval de variabele
i bevat nu de waarde 10.

386
00:20:59,560 --> 00:21:02,810
Maar het programma is nog steeds
gepauzeerd in de uitvoering.

387
00:21:02,810 --> 00:21:07,610
Toen ik stap over, zie ik dat de
waarde i, die ik ingevoerd als 10,

388
00:21:07,610 --> 00:21:12,170
niet groter is dan de waarde van num,
waardoor meteen de lus

389
00:21:12,170 --> 00:21:14,240
stoppen uitvoeren.

390
00:21:14,240 --> 00:21:16,210
>> Nu is dat niet de enige
reden waarom je zou

391
00:21:16,210 --> 00:21:19,450
willen de variabele in de plaats te wijzigen.

392
00:21:19,450 --> 00:21:22,210
Je zou eigenlijk willen
om te proberen om het zo te wijzigen

393
00:21:22,210 --> 00:21:24,590
dat u kunt blijven
uitvoeren van een lus

394
00:21:24,590 --> 00:21:27,370
of zo, dat u kunt wijzigen
zekere waarde vóór

395
00:21:27,370 --> 00:21:32,630
een aantal specifieke set van rekenkundige bereikt
dat je op het punt om uit te voeren.

396
00:21:32,630 --> 00:21:36,210
>> Dus nu dat we eigenlijk veranderen
waarde van i het programma werd uitgevoerd,

397
00:21:36,210 --> 00:21:39,540
het veroorzaakt de lus te stoppen
voortijdig want ineens, i

398
00:21:39,540 --> 00:21:42,770
toevallig groter is dan de waarde
van num, wat betekent dat voor de lus

399
00:21:42,770 --> 00:21:45,410
niet meer nodig te worden uitgevoerd.

400
00:21:45,410 --> 00:21:48,780
Verder is er gebeurd met de te
Indien we veranderde de waarde van i

401
00:21:48,780 --> 00:21:53,270
als de lijn 17 werd benadrukt,
welke het tijdstip was

402
00:21:53,270 --> 00:21:56,280
dat de voor de uitvoering lus
eigenlijk geëvalueerd.

403
00:21:56,280 --> 00:22:00,210
>> Als ik de waarde van was veranderd
ik op een andere lijn, zeggen 19,

404
00:22:00,210 --> 00:22:03,360
zouden we anders hebben gezien
gedrag omdat de lijn 19 zou

405
00:22:03,360 --> 00:22:08,310
hebben uitgevoerd voordat de lus
voorwaarde werd opnieuw geëvalueerd.

406
00:22:08,310 --> 00:22:11,900
Nu op dit punt, ik ben, nogmaals,
Aan het einde van het programma.

407
00:22:11,900 --> 00:22:15,707
En ik kan toestaan ​​dat deze over te gaan tot
toestaan ​​dat mijn programma op natuurlijke wijze af te sluiten.

408
00:22:15,707 --> 00:22:18,290
Maar er zijn een paar dingen
die belangrijk zijn om mee te nemen zijn

409
00:22:18,290 --> 00:22:19,960
van deze bijzondere discussie.

410
00:22:19,960 --> 00:22:22,490
Je nodig hebt om te evalueren
je eigen aannames

411
00:22:22,490 --> 00:22:24,710
over hoe de code moet worden gedragen.

412
00:22:24,710 --> 00:22:28,220
Elke keer als je denkt dat een stukje
code weet je toevallig aan het werk,

413
00:22:28,220 --> 00:22:30,940
dat een rode vlag te gaan zou kunnen zijn
rug en te evalueren, en zorg ervoor dat

414
00:22:30,940 --> 00:22:33,470
dat uw aanname van
hoe die code werkt

415
00:22:33,470 --> 00:22:38,290
is eigenlijk waar de manier waarop het is
uitgedrukt in uw broncode.

416
00:22:38,290 --> 00:22:41,300
>> Maar nog meer punt was,
wanneer we met behulp van de debugger,

417
00:22:41,300 --> 00:22:43,920
U kunt breekpunten op te zetten
verschillende regels code,

418
00:22:43,920 --> 00:22:48,110
die de debugger te veroorzaken
pauzeren uitvoering op elk van die lijnen

419
00:22:48,110 --> 00:22:52,210
zodat u kunt evalueren
geheugen of zelfs veranderen in de plaats.

420
00:22:52,210 --> 00:22:55,630
En nogmaals, vergeet niet dat je kunt
creëren van meerdere breekpunten, zodat u

421
00:22:55,630 --> 00:23:00,390
kan ook worden hervat uitvoering, skip
over grote delen van de code,

422
00:23:00,390 --> 00:23:04,790
en het zal automatisch pauzeren
bij de volgende breekpunt.

423
00:23:04,790 --> 00:23:07,760
>> Er is eigenlijk meer geavanceerde
kenmerken van de debugger, ook.

424
00:23:07,760 --> 00:23:10,170
Maar we moeten u verwijzen
wat latere video

425
00:23:10,170 --> 00:23:14,090
om echt te plagen elkaar hoe
die specifieke functies.

426
00:23:14,090 --> 00:23:15,990
Voor nu, dank u
heel erg voor het kijken.

427
00:23:15,990 --> 00:23:18,080
En veel geluk debuggen.