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

2
00:00:00,309 --> 00:00:02,350
[? DAN ARMADARAS:?] Hei,
Jeg er [? Dan Armadaras?].

3
00:00:02,350 --> 00:00:04,410
I dag skal vi
være ute på feilsøking.

4
00:00:04,410 --> 00:00:06,697
Ikke bare skal vi
snakke om noen teknikker,

5
00:00:06,697 --> 00:00:09,280
men også vi kommer til å se på
noen av funksjonene som finnes

6
00:00:09,280 --> 00:00:14,170
innenfor CS50 IDE som tillater
du enkelt kan feilsøke et program.

7
00:00:14,170 --> 00:00:16,272
>> Bare ett eksempel av
noe som kan gå galt

8
00:00:16,272 --> 00:00:18,730
og det er faktisk noe
som vi allerede har sett før.

9
00:00:18,730 --> 00:00:23,200
I dette tilfelle, er dette en C-program
som aksepterer et heltall fra brukeren,

10
00:00:23,200 --> 00:00:27,580
deler den med to, og gir
utgangen tilbake til brukeren.

11
00:00:27,580 --> 00:00:30,610
Nå fra hva vi har sett
tidligere i forelesninger,

12
00:00:30,610 --> 00:00:34,370
vi vet at dette faktisk vil føre til
bestemte typer divisjon problemer

13
00:00:34,370 --> 00:00:35,860
når vi har oddetall.

14
00:00:35,860 --> 00:00:40,330
>> Konkret vil vi bare kaste bort
noe etter desimaltegnet.

15
00:00:40,330 --> 00:00:43,170
Nå vet vi at dette
skjer for å være tilfelle.

16
00:00:43,170 --> 00:00:47,430
Og hvis vi kjøre den, kan vi bekrefte
våre mistanker, først ved kompilering.

17
00:00:47,430 --> 00:00:50,460
Og så, ved å kjøre og
skrive inn et oddetall.

18
00:00:50,460 --> 00:00:51,720
>> Dette er ikke noe nytt.

19
00:00:51,720 --> 00:00:54,490
Men dette er faktisk en
eksempel på en bug som

20
00:00:54,490 --> 00:00:58,810
kan eksistere innenfor et større program
som blir vanskeligere å spore opp.

21
00:00:58,810 --> 00:01:02,640
Selv om vi vet hva problemet
er den sanne crux av saken

22
00:01:02,640 --> 00:01:06,250
kanskje prøver å identifisere
spesielt der feilen oppstår,

23
00:01:06,250 --> 00:01:09,750
identifisere hva som er problemet
er, og deretter fikse det.

24
00:01:09,750 --> 00:01:14,400
Så gi dette som et eksempel
av hva som kan være noe

25
00:01:14,400 --> 00:01:19,030
som vi allerede kjenner, men kan bli begravet
innenfor andre elementer i koden.

26
00:01:19,030 --> 00:01:23,090
>> Så åpner denne annen kilde
kodefilen som et eksempel,

27
00:01:23,090 --> 00:01:27,165
denne divisjonen problemet nå
en del av et større program.

28
00:01:27,165 --> 00:01:29,040
Fortsatt kan være litt
litt contrived, og vi

29
00:01:29,040 --> 00:01:31,076
kan være i stand til å enkelt
identifisere det, spesielt

30
00:01:31,076 --> 00:01:32,450
siden vi bare diskuterer dette.

31
00:01:32,450 --> 00:01:38,250
Men vi kan finne ut at dette
Problemet kan ligge på en større skala.

32
00:01:38,250 --> 00:01:45,450
>> Hvis jeg kompilere dette og nå
kjøre den, angir et oddetall,

33
00:01:45,450 --> 00:01:49,816
Vi kan se at vi ikke får nøyaktig
utgangs at vi kan ha forventet.

34
00:01:49,816 --> 00:01:51,690
I dette spesielle tilfellet
vi kan si at vi

35
00:01:51,690 --> 00:01:56,060
ønsker å telle alle tallene
fra en opp til noen bestemt nummer.

36
00:01:56,060 --> 00:01:58,130
Og vi kan se at vi
har en rekke problemer

37
00:01:58,130 --> 00:02:03,880
her hvis vi sender ut, rett og slett, 0
og en når vi gir en inngang på fem.

38
00:02:03,880 --> 00:02:07,380
>> Så vi vet allerede at
det er et problem her.

39
00:02:07,380 --> 00:02:11,662
Men vi kan ikke vite nøyaktig
hvor dette problemet faktisk eksisterer.

40
00:02:11,662 --> 00:02:13,620
Nå er en av måtene som
vi kan prøve å fikse dette

41
00:02:13,620 --> 00:02:15,745
er noe som vi har
allerede blitt presentert for.

42
00:02:15,745 --> 00:02:18,880
Vi kan bare bruke den på en større skala.

43
00:02:18,880 --> 00:02:21,680
>> På linje 14, har vi
dette printf funksjon,

44
00:02:21,680 --> 00:02:25,620
som tillater oss å skrive ut staten
av ulike typer informasjon.

45
00:02:25,620 --> 00:02:28,880
Og dette er noe som du
bør utnytte i programmet

46
00:02:28,880 --> 00:02:33,100
for å prøve å finne ut nøyaktig hva som er
skjer på ulike linjer med kode.

47
00:02:33,100 --> 00:02:36,350
Så selv om dette ikke er
endelige resultatet at vi faktisk

48
00:02:36,350 --> 00:02:39,830
ønsker å produsere ut av
dette programmet, vi fortsatt

49
00:02:39,830 --> 00:02:42,300
kanskje har noen debug
setninger der vi

50
00:02:42,300 --> 00:02:46,970
kan prøve å finne ut nøyaktig hva
som skjer inne i vår kode.

51
00:02:46,970 --> 00:02:51,210
>> Så i dette tilfellet, vil jeg
printf med debug tag.

52
00:02:51,210 --> 00:02:53,540
I dette tilfelle, er denne
bare en debug streng

53
00:02:53,540 --> 00:02:56,840
at jeg er opp-putting slik at det blir
veldig klart i utgangen av min kode

54
00:02:56,840 --> 00:02:59,200
hva det er at jeg ønsker å vise.

55
00:02:59,200 --> 00:03:04,410
Og utgang her antall
som vi har beregnet.

56
00:03:04,410 --> 00:03:06,800
>> I dette tilfellet, kan jeg
ønsker å vite nøyaktig

57
00:03:06,800 --> 00:03:11,380
hva som skjer før og
etter noen spesifikk beregning.

58
00:03:11,380 --> 00:03:16,224
Så jeg kan bruke en printf før
og etter at kodelinje.

59
00:03:16,224 --> 00:03:18,640
I dette tilfellet kunne jeg selv
gjøre det litt mer klart

60
00:03:18,640 --> 00:03:21,960
ved å si debug før
og feilsøke etter så

61
00:03:21,960 --> 00:03:26,540
at jeg ikke forvirre meg selv med
flere linjer som ser identiske.

62
00:03:26,540 --> 00:03:32,290
>> Nå hvis vi rekompilere dette og kjøre
det, angir et nummer som fem igjen,

63
00:03:32,290 --> 00:03:35,090
Vi kan se at vi har
nå produksjonen før og etter

64
00:03:35,090 --> 00:03:40,670
og finner ut at vi ikke har gjort en klar
divisjon eller klart ha av antallet

65
00:03:40,670 --> 00:03:43,680
at vi faktisk ønsker å gjøre.

66
00:03:43,680 --> 00:03:48,660
Nå i dette tilfelle, er denne
ikke egentlig en klar utgang.

67
00:03:48,660 --> 00:03:52,440
Det er egentlig ikke et klart utfall som
vi ønsker ut av denne spesielle program.

68
00:03:52,440 --> 00:03:54,427
>> Og dette er, igjen, en
litt contrived.

69
00:03:54,427 --> 00:03:57,510
Men, kanskje en av de tingene som
vi kunne gjøre hvis spesifikasjonen sa

70
00:03:57,510 --> 00:04:01,900
at vi ønsker å dele dette med
2 og legge 1-- så med andre ord,

71
00:04:01,900 --> 00:04:04,550
vi ønsker å runde opp-- deretter
vi kunne vite at vi kunne

72
00:04:04,550 --> 00:04:08,060
gjøre det bestemt ting, i dette tilfellet.

73
00:04:08,060 --> 00:04:14,010
Nå her vi vet at vi vil være
legge en til vår halvert antall.

74
00:04:14,010 --> 00:04:16,490
>> La oss rekompilere dette
og bekrefter at dette

75
00:04:16,490 --> 00:04:18,860
oppfører seg slik som vi vil.

76
00:04:18,860 --> 00:04:21,980
Vi kan se at nå før
ha, har vi nummer fem.

77
00:04:21,980 --> 00:04:26,620
Etter å ha, har vi nummer tre,
som i henhold til vår spesifikasjonen,

78
00:04:26,620 --> 00:04:29,292
er hva vi ønsket å gjøre.

79
00:04:29,292 --> 00:04:31,000
Men hvis vi ser på
utgang her, kan vi

80
00:04:31,000 --> 00:04:33,760
se at vi kan ha en annen
bug helt, noe som er

81
00:04:33,760 --> 00:04:36,940
at vi starter vår teller fra 0.

82
00:04:36,940 --> 00:04:39,390
>> Nå igjen, dette er noe
som vi har sett i det siste

83
00:04:39,390 --> 00:04:42,500
og vi kan fikse ganske lett.

84
00:04:42,500 --> 00:04:44,790
Men i dette tilfellet, vi
også hadde nytte

85
00:04:44,790 --> 00:04:48,940
for å bruke printf uttalelse
direkte på innsiden av for loop

86
00:04:48,940 --> 00:04:52,930
å vite nøyaktig hvor
at feilen var oppstått.

87
00:04:52,930 --> 00:04:55,150
Så printf uttalelser er
svært nyttig i å hjelpe

88
00:04:55,150 --> 00:04:57,940
du bestemme hvor,
nettopp i kildekoden,

89
00:04:57,940 --> 00:05:00,620
en spesifikk feil oppstår.

90
00:05:00,620 --> 00:05:03,650
>> Og det er også viktig å innse
det, som vi skriver kode,

91
00:05:03,650 --> 00:05:06,052
vi kan ha forutsetninger
om tilstanden i et program.

92
00:05:06,052 --> 00:05:08,510
Eller vi kan ha forutsetninger
om hvilken del av programmet

93
00:05:08,510 --> 00:05:13,020
er faktisk riktig eller feil når
senere som vi bygger videre på det programmet

94
00:05:13,020 --> 00:05:15,950
og gjøre det en del av en
komplekse og større program

95
00:05:15,950 --> 00:05:19,700
at vi innser at noen aspekter
av det er faktisk buggy.

96
00:05:19,700 --> 00:05:22,680
>> Ved hjelp av printf virkelig kan hjelpe
innskrenke og identifisere

97
00:05:22,680 --> 00:05:26,430
regionene i et program som ikke kan
skal oppføre seg akkurat slik at vi

98
00:05:26,430 --> 00:05:29,500
forventer, basert på våre antagelser.

99
00:05:29,500 --> 00:05:31,460
Men det er andre verktøy
tilgjengelig, samt,

100
00:05:31,460 --> 00:05:34,860
som tillater oss å prøve å finne
ut hvor en feil er oppstått

101
00:05:34,860 --> 00:05:39,930
Og også, spesifikt, hva ting
skjer inne i programmet.

102
00:05:39,930 --> 00:05:41,990
>> Så bruker printf er veldig
nyttig når vi ønsker

103
00:05:41,990 --> 00:05:45,900
for å identifisere spesifikke områder av
et program som har noen bug.

104
00:05:45,900 --> 00:05:47,730
Men det blir også
kjedelig etter en stund.

105
00:05:47,730 --> 00:05:50,500
I dette tilfelle, er dette en
relativt enkelt program

106
00:05:50,500 --> 00:05:52,750
med bare én eller to variabler.

107
00:05:52,750 --> 00:05:57,260
Og blir det veldig enkelt for oss å
skrive ut verdien av disse variablene

108
00:05:57,260 --> 00:05:59,670
i sammenheng med den større program.

109
00:05:59,670 --> 00:06:02,670
>> Men vi kan ha en annen
program som har mange variabler.

110
00:06:02,670 --> 00:06:06,530
Og det er kanskje ikke helt
så lett å bruke printf

111
00:06:06,530 --> 00:06:10,120
å forsøke å vurdere hva som skjer
til hver og en av disse variablene

112
00:06:10,120 --> 00:06:13,590
som programmet utfører.

113
00:06:13,590 --> 00:06:16,960
Det er et program som eksisterer
kalles en debugger program.

114
00:06:16,960 --> 00:06:20,320
I dette tilfellet, som vi vil
bruk er GNU debugger, eller GDB,

115
00:06:20,320 --> 00:06:24,260
som tillater oss å inspisere den interne
arbeidet i et program i en mye mer

116
00:06:24,260 --> 00:06:25,700
detaljert måte.

117
00:06:25,700 --> 00:06:28,810
>> Vi kan faktisk kjøre
GDB fra kommandolinjen

118
00:06:28,810 --> 00:06:35,370
her ved å skrive GDB og
kommando som vi ønsker å feilsøke.

119
00:06:35,370 --> 00:06:37,550
I dette tilfelle teller.

120
00:06:37,550 --> 00:06:41,650
Nå i dette tilfellet, kan vi se at det
bringer oss til en melding som sier GDB.

121
00:06:41,650 --> 00:06:44,020
Og vi kan faktisk
utføre kommandoer til GDB

122
00:06:44,020 --> 00:06:48,260
å faktisk begynne utførelsen av
program, stoppe det på enkelte punkter,

123
00:06:48,260 --> 00:06:51,060
evaluere variablene og
inspisere de variablene som

124
00:06:51,060 --> 00:06:54,152
finnes i programtilstand
på det aktuelle tidspunktet,

125
00:06:54,152 --> 00:06:55,110
og så videre og så videre.

126
00:06:55,110 --> 00:06:57,240
Det gir mye makt til oss.

127
00:06:57,240 --> 00:06:59,960
>> Men det bare så skjer
at CS50 IDE også

128
00:06:59,960 --> 00:07:05,870
gir et GUI eller en bruker
grensesnitt for GDB som

129
00:07:05,870 --> 00:07:11,120
tillater oss å gjøre dette uten å måtte
kommandolinjegrensesnittet hodet

130
00:07:11,120 --> 00:07:13,560
eller i det hele tatt enda.

131
00:07:13,560 --> 00:07:16,930
Den måten jeg kan få tilgang til
er ved hjelp av debug-knappen

132
00:07:16,930 --> 00:07:20,120
på toppen av CS50 IDE.

133
00:07:20,120 --> 00:07:24,280
Nå i det siste, hva vi har
sett er at vi bruker kommandoen

134
00:07:24,280 --> 00:07:27,660
linje for å kompilere og kjøre et program.

135
00:07:27,660 --> 00:07:29,790
>> Debug knapp gjør
begge disse trinnene.

136
00:07:29,790 --> 00:07:34,380
Men det vil også få opp
debugger fanen lengst til høyre

137
00:07:34,380 --> 00:07:38,280
som tillater oss å inspisere en rekke
av egenskapene til det program

138
00:07:38,280 --> 00:07:40,500
som det blir utført.

139
00:07:40,500 --> 00:07:44,280
Hvis jeg klikker debug, i dette
tilfelle, vil det gi opp

140
00:07:44,280 --> 00:07:48,230
en ny fane i konsollen
vindu helt nederst.

141
00:07:48,230 --> 00:07:51,160
>> Og du kan se at denne kategorien har
litt informasjon på toppen.

142
00:07:51,160 --> 00:07:52,670
Og vi kan i stor grad ignorere dette.

143
00:07:52,670 --> 00:07:54,800
Men en av de tingene
at vi ønsker å legge merke til

144
00:07:54,800 --> 00:07:57,170
er at det utganger
det samme som vi

145
00:07:57,170 --> 00:08:03,000
ville fått hvis vi prøvde å kjøre gjøre på
C-program i terminalvinduet.

146
00:08:03,000 --> 00:08:06,230
>> Her kan vi se den kjører klang,
og den har en rekke flagg,

147
00:08:06,230 --> 00:08:12,660
og det er å samle vår count.c fil,
som var den valgte kategorien på tiden

148
00:08:12,660 --> 00:08:15,100
at jeg traff debug.

149
00:08:15,100 --> 00:08:18,010
Så dette er veldig nyttig fordi
nå bruker denne debug-knappen,

150
00:08:18,010 --> 00:08:23,280
kan vi samtidig kompilere og deretter
kjøre programmet at vi faktisk

151
00:08:23,280 --> 00:08:24,460
vil kjøre.

152
00:08:24,460 --> 00:08:27,880
>> En av de flagg som er
viktig, i dette tilfellet

153
00:08:27,880 --> 00:08:30,190
vi har faktisk vært å bruke
for lengst

154
00:08:30,190 --> 00:08:32,450
men også bare gjorde noen hånd
vinke [uhørbart], som

155
00:08:32,450 --> 00:08:33,820
er dette en rett her.

156
00:08:33,820 --> 00:08:35,790
I klang, sier -ggdb3.

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

158
00:08:38,570 --> 00:08:41,250
I dette tilfellet, det vi
forteller klang, vår kompilator,

159
00:08:41,250 --> 00:08:43,820
er at vi ønsker å kompilere programmet vårt.

160
00:08:43,820 --> 00:08:46,810
Men også gi hva er
kalt symbolinformasjon

161
00:08:46,810 --> 00:08:50,940
slik at kompilatoren faktisk har tilgang
til mye av den underliggende informasjon

162
00:08:50,940 --> 00:08:52,610
inneholdes i programmet.

163
00:08:52,610 --> 00:08:55,260
>> Mer spesielt er antallet
av funksjoner som jeg har,

164
00:08:55,260 --> 00:08:58,000
navnene på disse funksjoner,
variablene, hvilke typer

165
00:08:58,000 --> 00:09:01,730
at disse variabler er, og en rekke
av andre ting som hjelper debugger

166
00:09:01,730 --> 00:09:04,350
utføre sin operasjon.

167
00:09:04,350 --> 00:09:06,600
Nå er det noe annet
det er viktig å nevne

168
00:09:06,600 --> 00:09:10,280
når vi diskuterer løping
et program på denne måten.

169
00:09:10,280 --> 00:09:13,660
>> Legg merke til at det har faktisk
brakt opp en ny fane i vår konsoll

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

171
00:09:14,780 --> 00:09:18,600
Vi trenger ikke lenger å samhandle
direkte med terminalvinduet.

172
00:09:18,600 --> 00:09:21,420
Men denne nye kategorien er
faktisk et terminalvindu.

173
00:09:21,420 --> 00:09:26,710
Det er bare bestemt til driften
program som vi har skapt.

174
00:09:26,710 --> 00:09:29,270
>> Legg merke til at på bunnen, i
kombinasjon med noen utgang

175
00:09:29,270 --> 00:09:33,500
av clang kompilatoren og GDB,
som vi kan i stor grad ignorere,

176
00:09:33,500 --> 00:09:37,570
det faktisk viser resultatet av
programmet vårt helt nederst.

177
00:09:37,570 --> 00:09:41,240
Nå er det viktig å innse
at dette vinduet faktisk

178
00:09:41,240 --> 00:09:43,360
vil vise deg
utgang fra programmet

179
00:09:43,360 --> 00:09:47,190
men også kan akseptere innspill
for det program, samt.

180
00:09:47,190 --> 00:09:49,260
>> Så varsel som sier
Skriv inn et tall,

181
00:09:49,260 --> 00:09:53,050
som er den samme produksjonen som vi hadde
hadde i terminalvinduet før.

182
00:09:53,050 --> 00:09:55,510
Men det er nå vist i denne nye kategorien.

183
00:09:55,510 --> 00:09:56,550
Jeg kan legge inn et nummer.

184
00:09:56,550 --> 00:10:00,900
Og det vil faktisk
funksjon som vi forventer

185
00:10:00,900 --> 00:10:05,890
viser oss våre feilsøke, utgang,
utgang som kan være buggy,

186
00:10:05,890 --> 00:10:07,010
som vi har sett før.

187
00:10:07,010 --> 00:10:10,460
Og helt nederst, det
faktisk har noen ekstra utgang

188
00:10:10,460 --> 00:10:14,550
fra BNP sier bare at
dette programmet er fullført.

189
00:10:14,550 --> 00:10:16,655
>> Nå som du så i denne
Spesielt kjøre gjennom,

190
00:10:16,655 --> 00:10:19,370
Det var ikke særlig
nyttig fordi selv

191
00:10:19,370 --> 00:10:23,740
om vi hadde debugger menyen kommer
opp, dette var likevel et kjørende program.

192
00:10:23,740 --> 00:10:26,790
Ikke på noe punkt gjorde det faktisk
stanse henrettelsen for oss

193
00:10:26,790 --> 00:10:30,767
for å kunne inspisere hele
variablene som finnes.

194
00:10:30,767 --> 00:10:32,850
Det er noe annet
at vi må gjøre for

195
00:10:32,850 --> 00:10:36,910
å få GDB å erkjenne at vi ønsker
for å stanse gjennomføringen av programmet

196
00:10:36,910 --> 00:10:42,820
og ikke bare tillate den å gå videre
normalt som vi ville i alle andre tilfeller.

197
00:10:42,820 --> 00:10:45,530
>> For å stanse henrettelsen,
på noen bestemt linje,

198
00:10:45,530 --> 00:10:47,830
vi trenger for å lage hva som er
kalles et avbruddspunkt.

199
00:10:47,830 --> 00:10:52,670
Og en pause punkt er veldig enkelt laget
i denne CS50 IDE ved å ta musen

200
00:10:52,670 --> 00:10:57,090
og klikke direkte til venstre
av noen bestemt linjenummer.

201
00:10:57,090 --> 00:10:59,920
Når jeg gjør det, en rød prikk
vises, noe som indikerer

202
00:10:59,920 --> 00:11:02,300
at den linjen er nå en pause punkt.

203
00:11:02,300 --> 00:11:07,540
>> Og neste gang jeg kjører GDB, det
vil stoppe henrettelsen på det pause punkt

204
00:11:07,540 --> 00:11:10,280
når den når den kodelinje.

205
00:11:10,280 --> 00:11:12,230
Nå er dette en viktig
ting å innse

206
00:11:12,230 --> 00:11:16,140
at det ikke nødvendigvis
Ved at hver linje med kode

207
00:11:16,140 --> 00:11:17,880
er faktisk tilgjengelig.

208
00:11:17,880 --> 00:11:23,780
Hvis jeg skulle lage en funksjon
her oppe, for example-- ugyldig f--

209
00:11:23,780 --> 00:11:31,230
og bare gjøre en utskrift linje her-- hallo
world-- om jeg aldri kalle denne funksjonen,

210
00:11:31,230 --> 00:11:34,770
vil det være slik at,
hvis jeg setter en pause poeng her,

211
00:11:34,770 --> 00:11:36,220
funksjonen vil aldri bli kalt.

212
00:11:36,220 --> 00:11:38,310
Og derfor denne
Særlig break point

213
00:11:38,310 --> 00:11:43,040
vil aldri stoppe
gjennomføring av programmet.

214
00:11:43,040 --> 00:11:48,020
>> Så la oss si at jeg riktig opprette
en pause punkt på noen linje med kode

215
00:11:48,020 --> 00:11:50,340
som faktisk vil bli henrettet.

216
00:11:50,340 --> 00:11:53,470
Nå i dette tilfellet, er dette
første linje i hovedfunksjon.

217
00:11:53,470 --> 00:11:56,630
Så det vil sikkert være tilfelle
at så snart jeg begynner gjennomføring,

218
00:11:56,630 --> 00:11:58,580
den aller første linjen vil bli nådd.

219
00:11:58,580 --> 00:12:00,230
GDB vil stanse henrettelsen.

220
00:12:00,230 --> 00:12:04,100
Og da vil jeg være i stand til å
samhandle med debugger.

221
00:12:04,100 --> 00:12:08,480
>> Du kan stille inn flere linjer som
breakpoints, hvis du ønsker.

222
00:12:08,480 --> 00:12:11,365
Vi kan også lage en linje opp
her i dette segmentet av kode

223
00:12:11,365 --> 00:12:12,490
som aldri vil bli nådd.

224
00:12:12,490 --> 00:12:14,744
Og vi kan også opprette en nærmere nedenfor.

225
00:12:14,744 --> 00:12:16,660
Grunnen til at vi ville
ønsker å gjøre dette vi vil

226
00:12:16,660 --> 00:12:19,119
gå inn i en litt mer
detalj i bare et øyeblikk.

227
00:12:19,119 --> 00:12:21,660
Så for nå, la meg bare deaktivere
disse ekstra brytepunkter

228
00:12:21,660 --> 00:12:24,940
slik at vi kan se på hva som skjer
når jeg har en eneste pause

229
00:12:24,940 --> 00:12:27,650
punkt i mitt program.

230
00:12:27,650 --> 00:12:29,410
Jeg har gjort noen
endringer i dette programmet.

231
00:12:29,410 --> 00:12:30,750
Så jeg trenger å lagre det.

232
00:12:30,750 --> 00:12:34,490
Jeg vil klikke debug slik at jeg kan
begynne utarbeidelse og deretter

233
00:12:34,490 --> 00:12:36,880
gjennomføring av debugger.

234
00:12:36,880 --> 00:12:40,632
>> Vi vil se at etter øyeblikkene, de
linje som vi valgt som pause

235
00:12:40,632 --> 00:12:43,360
punkt er markert med gult.

236
00:12:43,360 --> 00:12:47,440
Vi kan også legge merke til at i
øverst til høyre i debug panel

237
00:12:47,440 --> 00:12:50,940
at pausen ikonet har slått
inn litt lek ikon.

238
00:12:50,940 --> 00:12:54,710
Dette betyr at vi har pause
utførelse, i dette spesielle tilfelle.

239
00:12:54,710 --> 00:12:57,840
Og trykket på play-knappen vil
tillate oss å gjenoppta kjøring

240
00:12:57,840 --> 00:13:00,000
på det bestemt punkt.

241
00:13:00,000 --> 00:13:03,240
>> Legg merke til at det er et par andre
knappene som er tilgjengelige i denne debug panel,

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

243
00:13:04,220 --> 00:13:09,470
Gå over, som tillater meg å
utføre som en linje med kode

244
00:13:09,470 --> 00:13:14,030
og gå over til den linje til
neste, som i dette tilfellet

245
00:13:14,030 --> 00:13:17,060
ville bety at printf
setningen utføres.

246
00:13:17,060 --> 00:13:22,310
Og det vil deretter pause
kjøring på linje 13, som så.

247
00:13:22,310 --> 00:13:25,090
>> Og det er også et skritt
i funksjon, hvilken

248
00:13:25,090 --> 00:13:28,950
er nyttig hvis jeg har skapt andre
funksjoner andre steder i kildekoden.

249
00:13:28,950 --> 00:13:31,420
Og jeg ønsker å gå inn
disse funksjonene i stedet

250
00:13:31,420 --> 00:13:33,050
utføre som fungerer som en helhet.

251
00:13:33,050 --> 00:13:37,279
Men vi vil se mer på trinnet
i funksjon i løpet av et øyeblikk.

252
00:13:37,279 --> 00:13:40,320
Nå merke noen andre ting som
faktisk eksisterer innenfor denne debug panel.

253
00:13:40,320 --> 00:13:44,110
>> Vi har dette panelet kalles
kaller stack, som viser oss

254
00:13:44,110 --> 00:13:45,300
hvor vi er.

255
00:13:45,300 --> 00:13:48,550
I dette tilfellet, er vi inne
til hovedfunksjonen.

256
00:13:48,550 --> 00:13:50,880
Vår script kalles count.c.

257
00:13:50,880 --> 00:13:53,820
Og vi måtte være på
linje 13, en kolonne, hvilken

258
00:13:53,820 --> 00:13:58,950
er nettopp hva den markerte regionen
av kildekoden indikerer at, i tillegg.

259
00:13:58,950 --> 00:14:02,435
>> Nå merker at dette viser også
under den lokale variable delen

260
00:14:02,435 --> 00:14:06,710
alle variablene som
eksisterer innenfor denne funksjonen.

261
00:14:06,710 --> 00:14:08,930
Det er viktig å merke seg
at alle variablene

262
00:14:08,930 --> 00:14:12,580
vises i denne lokal variabel
seksjon innenfor en funksjon,

263
00:14:12,580 --> 00:14:14,380
til og med før de er definert.

264
00:14:14,380 --> 00:14:19,160
Vi ser her at vi har en variabel
kalt num, har en standardverdi på 0,

265
00:14:19,160 --> 00:14:21,280
og det er av typen int.

266
00:14:21,280 --> 00:14:24,110
>> Nå før vi faktisk initial
alle disse variablene,

267
00:14:24,110 --> 00:14:26,685
vi er ikke nødvendigvis
garantert å se en verdi på 0.

268
00:14:26,685 --> 00:14:29,200
Og avhengig av andre henrettelser
at du har utført

269
00:14:29,200 --> 00:14:32,020
og staten hukommelsen når
du faktisk kjøre dette programmet,

270
00:14:32,020 --> 00:14:34,605
du kan finne det du
ikke ser verdiene av 0

271
00:14:34,605 --> 00:14:36,550
og, istedenfor, noen andre sprø tall.

272
00:14:36,550 --> 00:14:38,390
>> Men ikke bekymre deg om det.

273
00:14:38,390 --> 00:14:44,610
Det kommer ikke til å være relevant til
du faktisk initial verdien.

274
00:14:44,610 --> 00:14:49,630
Nå i dette tilfellet, kan vi se at
Jeg har gjort noen utganger.

275
00:14:49,630 --> 00:14:52,131
Og jeg, akkurat nå, stanset henrettelsen.

276
00:14:52,131 --> 00:14:53,880
Men i dette tilfelle, hva
Jeg ønsker virkelig å gjøre

277
00:14:53,880 --> 00:14:58,060
er å nå gå over denne linjen
av koden slik at jeg faktisk kan

278
00:14:58,060 --> 00:15:04,390
spørre brukeren for at int som
vi ønsker å bruke i vårt program.

279
00:15:04,390 --> 00:15:07,060
>> Nå i dette tilfellet, når
Jeg traff gå over, varsel

280
00:15:07,060 --> 00:15:11,940
at Pause eller snarere Resume
knappen er endret til dette Pause-knappen

281
00:15:11,940 --> 00:15:14,022
fordi denne kode er faktisk utfører.

282
00:15:14,022 --> 00:15:15,730
Hva er det som skjer
akkurat nå er at det er

283
00:15:15,730 --> 00:15:21,630
venter på oss for å legge inn litt informasjon
som vi kan se av produksjonen vår tekst

284
00:15:21,630 --> 00:15:23,600
helt nederst.

285
00:15:23,600 --> 00:15:25,787
>> Så akkurat nå, er dette
faktisk ikke stanset,

286
00:15:25,787 --> 00:15:28,620
selv om det, liksom, vises
å være fordi ingenting skjer.

287
00:15:28,620 --> 00:15:32,360
Men det har seg slik at i
min spesifikke saken på linje 13,

288
00:15:32,360 --> 00:15:34,210
Jeg venter på brukerundersøkelser.

289
00:15:34,210 --> 00:15:39,130
Og så GDB er ikke i stand til å inspisere
et program som det er i gang.

290
00:15:39,130 --> 00:15:43,370
>> Nå neste gang jeg skriver noe
input-- så jeg skal gå inn som nummer fem,

291
00:15:43,370 --> 00:15:46,140
som vi har sett i
past-- hit Return, og vi

292
00:15:46,140 --> 00:15:51,430
Legg merke til at med en gang, GDB pauser
og, igjen, understreker neste linje.

293
00:15:51,430 --> 00:15:55,320
Men legg merke til at nå, som en
Resultatet av vår legge inn en verdi,

294
00:15:55,320 --> 00:15:58,930
Vi har oppdatert at verdien inne
av våre lokale variabler, som

295
00:15:58,930 --> 00:16:05,560
er svært nyttig å vite nøyaktig
hva det tallet var i minnet.

296
00:16:05,560 --> 00:16:10,650
>> Nå kan jeg tillate dette programmet til å fortsette
spille til slutten av sin utførelse

297
00:16:10,650 --> 00:16:12,570
ved å treffe Resume.

298
00:16:12,570 --> 00:16:16,410
Vi kan se at svært raskt
gjør programmet ferdig utførende

299
00:16:16,410 --> 00:16:19,790
med den samme produksjonen som vi
hatt før, debugger lukkes,

300
00:16:19,790 --> 00:16:23,170
og nå dette programmet
har stoppet helt.

301
00:16:23,170 --> 00:16:25,320
>> I viser at bare for
formålene med å se hva

302
00:16:25,320 --> 00:16:27,280
skjer når vi faktisk treffer Resume.

303
00:16:27,280 --> 00:16:30,640
Men vi faktisk kommer til å
ønsker å gå tilbake til dette programmet

304
00:16:30,640 --> 00:16:33,820
slik at vi kan prøve å feilsøke
nøyaktig hva som skjer.

305
00:16:33,820 --> 00:16:37,980
Nå som jeg bruker debugger, kan jeg
ikke trenger disse debug printf uttalelser.

306
00:16:37,980 --> 00:16:43,860
>> Så jeg kan flytte dem som jeg vil gjøre
nå bare å gå tilbake til vår enklere kode

307
00:16:43,860 --> 00:16:45,950
at vi hadde et øyeblikk siden.

308
00:16:45,950 --> 00:16:48,790
Nå når jeg lagrer
programmere og kjøre den,

309
00:16:48,790 --> 00:16:53,700
det vil, igjen, gå til den innledende
bryte punktet at jeg hadde på linje 11.

310
00:16:53,700 --> 00:16:57,700
Og jeg skal være i stand til å inspisere
mine variabler som jeg ønsker å gjøre.

311
00:16:57,700 --> 00:17:00,695
>> Det bare så skjer at denne
del er ikke veldig interessant,

312
00:17:00,695 --> 00:17:04,364
Og jeg vet at jeg kommer
å skrive ut denne uttalelsen.

313
00:17:04,364 --> 00:17:05,280
Vennligst skriv inn et nummer.

314
00:17:05,280 --> 00:17:08,099
Og så vet jeg at jeg kommer
å spørre brukeren om at heltall.

315
00:17:08,099 --> 00:17:13,329
Så kanskje jeg faktisk ønsker å flytte min
bryte punkt litt lenger ned.

316
00:17:13,329 --> 00:17:16,710
>> Du kan fjerne break poeng
ved å klikke igjen, direkte

317
00:17:16,710 --> 00:17:18,460
til venstre for denne linjen nummer.

318
00:17:18,460 --> 00:17:22,200
Det røde prikken forsvinner, indikerer
at det knekkpunktet er nå borte.

319
00:17:22,200 --> 00:17:24,780
Nå i dette tilfellet
henrettelsen er midlertidig stoppet.

320
00:17:24,780 --> 00:17:27,770
Og så det er ikke faktisk kommer til å
fortsette i det aktuelle tilfellet.

321
00:17:27,770 --> 00:17:30,210
Men jeg kan sette en pause
peke litt senere.

322
00:17:30,210 --> 00:17:33,880
>> Og når jeg nå gjenoppta min
kode, vil den fortsette og fortelle

323
00:17:33,880 --> 00:17:36,190
poenget med at knekkpunktet.

324
00:17:36,190 --> 00:17:37,374
Igjen, jeg traff Resume.

325
00:17:37,374 --> 00:17:39,040
Ser ikke ut som noe som skjer.

326
00:17:39,040 --> 00:17:41,450
Men det er fordi min
kode venter på inngangen.

327
00:17:41,450 --> 00:17:47,900
Jeg vil legge inn et nummer fem, trykk Enter, og
nå neste break point vil bli rammet.

328
00:17:47,900 --> 00:17:50,570
>> Nå i dette tilfelle denne
er linjen med kode

329
00:17:50,570 --> 00:17:53,820
det, før vi visste
tilfeldigvis buggy.

330
00:17:53,820 --> 00:17:57,590
Så la oss vurdere hva som skjer
på dette spesielle tidspunktet.

331
00:17:57,590 --> 00:18:02,620
Når en linje er uthevet, dette
linje har ennå ikke blitt utført.

332
00:18:02,620 --> 00:18:06,490
Så i dette tilfellet, kan vi se
at jeg har et nummer, som

333
00:18:06,490 --> 00:18:11,610
Jeg har et heltall kalles
num som har en verdi 5.

334
00:18:11,610 --> 00:18:15,090
Og jeg kommer til å være utøvende
litt matematikk på dette nummeret.

335
00:18:15,090 --> 00:18:20,130
>> Hvis jeg gå over det, kan vi
Legg merke til at verdien for num

336
00:18:20,130 --> 00:18:23,780
er endret i henhold til
aritmetikk at vi faktisk har gjort.

337
00:18:23,780 --> 00:18:26,810
Og nå som vi er
innsiden av denne for loop

338
00:18:26,810 --> 00:18:29,090
eller nå som for loop
selv er markert,

339
00:18:29,090 --> 00:18:32,450
vi ser at vi har en ny
variabel kalt jeg at

340
00:18:32,450 --> 00:18:35,370
kommer til å bli brukt i den for loop.

341
00:18:35,370 --> 00:18:38,230
>> Nå husker før at jeg
nevnt at noen ganger du er

342
00:18:38,230 --> 00:18:43,470
kommer til å se en slags gal
numre som standard før det nummeret

343
00:18:43,470 --> 00:18:45,530
eller at variabelen er
faktisk initialisert.

344
00:18:45,530 --> 00:18:49,040
Vi kan se at nettopp
her i denne variabelen

345
00:18:49,040 --> 00:18:51,345
heter jeg, som ikke har
ennå ikke blitt initialisert

346
00:18:51,345 --> 00:18:53,560
ved å fremheve.

347
00:18:53,560 --> 00:18:57,070
Men vi kan se at det har noen tall
at vi ikke ville faktisk forvente.

348
00:18:57,070 --> 00:18:57,620
>> Det er greit.

349
00:18:57,620 --> 00:18:59,661
Ikke bry deg om det
fordi vi har faktisk ikke

350
00:18:59,661 --> 00:19:04,970
initialisert det nummeret før jeg
gå over denne linjen og verdien

351
00:19:04,970 --> 00:19:08,560
Jeg har blitt initialisert til verdien 1.

352
00:19:08,560 --> 00:19:11,400
Så for å se at det er faktisk
tilfelle, la oss gå over.

353
00:19:11,400 --> 00:19:14,420
Vi kan nå se at det
linjen har blitt henrettet.

354
00:19:14,420 --> 00:19:17,000
Og vi er nå fremhever
dette printf linje.

355
00:19:17,000 --> 00:19:22,230
>> Og vi kan nå se hvordan våre verdier
av jeg og 3 har endret seg over tid.

356
00:19:22,230 --> 00:19:26,450
Dette er svært nyttig å gjøre, faktisk,
er å gå over linjene flere ganger.

357
00:19:26,450 --> 00:19:30,480
Og du kan finne hva som faktisk
skjer innsiden av for loop

358
00:19:30,480 --> 00:19:33,660
og hva som skjer med
variabler inne på at for loop

359
00:19:33,660 --> 00:19:39,200
som at programmet kjøres
oppstår ett skritt om gangen.

360
00:19:39,200 --> 00:19:41,110
>> Nå på dette punktet, jeg
tråkket over akkurat nok

361
00:19:41,110 --> 00:19:44,210
at jeg nå er på slutten av mitt program.

362
00:19:44,210 --> 00:19:46,980
Hvis jeg gå over det, vil det
faktisk opphøre henrettelse

363
00:19:46,980 --> 00:19:48,860
som vi har sett i det siste.

364
00:19:48,860 --> 00:19:52,110
La meg starte dette, enda en gang, så
at jeg kan peke noe annet ut,

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

366
00:19:53,320 --> 00:19:55,350
>> I dette tilfelle er det
nå spør meg igjen,

367
00:19:55,350 --> 00:19:57,100
for et tall, som
Jeg vil, igjen, gå inn.

368
00:19:57,100 --> 00:20:00,300
Men denne gangen kommer jeg til å gå inn i
et større antall, slik at for loop

369
00:20:00,300 --> 00:20:02,540
vil reagere flere ganger.

370
00:20:02,540 --> 00:20:06,090
I dette tilfellet, jeg kommer
å angi en verdi av 11.

371
00:20:06,090 --> 00:20:08,390
>> Nå igjen fordi jeg hadde satt
en pause punkt på linje 15,

372
00:20:08,390 --> 00:20:10,490
det kommer til å markere den linjen.

373
00:20:10,490 --> 00:20:12,980
Vi kan se at vår
nummer 11 er riktig

374
00:20:12,980 --> 00:20:15,560
representert i våre lokale variabler.

375
00:20:15,560 --> 00:20:22,460
Tråkke over at vi kan nå
se hva som skjer til vår verdi i

376
00:20:22,460 --> 00:20:25,680
når vi fortsetter på innsiden av denne for sløyfen.

377
00:20:25,680 --> 00:20:31,960
Det blir økes hver gang vi
når toppen av det for loop.

378
00:20:31,960 --> 00:20:35,110
>> Nå er en av de tingene som kanskje
være nyttig å gjøre under utførelse

379
00:20:35,110 --> 00:20:40,490
med dette programmet er for meg å faktisk
endre variabler midtstrøms å se

380
00:20:40,490 --> 00:20:42,450
hva som skjer med mitt program.

381
00:20:42,450 --> 00:20:46,540
I dette tilfellet kan jeg faktisk
Dobbeltklikk verdien.

382
00:20:46,540 --> 00:20:48,040
Legg merke til at det blir et tekstfelt.

383
00:20:48,040 --> 00:20:50,280
>> Nå kan jeg skrive annerledes
verds helt

384
00:20:50,280 --> 00:20:55,700
for å se hvordan mitt program oppfører seg
når jeg har endret den variabelen.

385
00:20:55,700 --> 00:20:59,560
Nå i dette tilfellet, den variable
jeg nå inneholder verdien 10.

386
00:20:59,560 --> 00:21:02,810
Men programmet er fremdeles
pauset i kjøring.

387
00:21:02,810 --> 00:21:07,610
Når jeg går over, jeg ser at
verdi i, som jeg skrev som 10,

388
00:21:07,610 --> 00:21:12,170
ikke er større enn verdien av num,
som umiddelbart fører til at for loop

389
00:21:12,170 --> 00:21:14,240
å stoppe gjennomføring.

390
00:21:14,240 --> 00:21:16,210
>> Nå det er ikke den eneste
Grunnen til at du ville

391
00:21:16,210 --> 00:21:19,450
ønsker å endre den variable på plass.

392
00:21:19,450 --> 00:21:22,210
Du kan faktisk ønsker
for å prøve å endre det slik

393
00:21:22,210 --> 00:21:24,590
at du kan fortsette
utførelse av en løkke

394
00:21:24,590 --> 00:21:27,370
eller slik at du kan endre
noen verdi før det

395
00:21:27,370 --> 00:21:32,630
når noen bestemt sett av aritmetiske
at du er i ferd med å utføre.

396
00:21:32,630 --> 00:21:36,210
>> Så nå som vi faktisk endre
Verdien av jeg så programmet ble utførende,

397
00:21:36,210 --> 00:21:39,540
det forårsaket for loop å slutte
tidlig på grunn, plutselig, jeg

398
00:21:39,540 --> 00:21:42,770
skjedde til å være større enn verdien
av num, noe som betyr at det for loop

399
00:21:42,770 --> 00:21:45,410
ikke lenger nødvendig å bli henrettet.

400
00:21:45,410 --> 00:21:48,780
Videre skjedde det å være
Ved at vi endret verdien av jeg

401
00:21:48,780 --> 00:21:53,270
når linjen 17 ble fremhevet,
som var poenget i tid

402
00:21:53,270 --> 00:21:56,280
at for loop kjøring
ble faktisk blir evaluert.

403
00:21:56,280 --> 00:22:00,210
>> Hvis jeg hadde endret verdien av
jeg på en annen linje, sier 19,

404
00:22:00,210 --> 00:22:03,360
vi ville ha sett annerledes
atferd fordi linje 19 ville

405
00:22:03,360 --> 00:22:08,310
har utført før løkken
Tilstanden ble revurdert.

406
00:22:08,310 --> 00:22:11,900
Nå på dette punktet, er jeg, igjen,
ved slutten av dette programmet.

407
00:22:11,900 --> 00:22:15,707
Og jeg kan la dette fortsette til
tillate mitt program til å avslutte naturlig.

408
00:22:15,707 --> 00:22:18,290
Men det er et par ting
som er viktig å ta bort

409
00:22:18,290 --> 00:22:19,960
fra denne diskusjonen.

410
00:22:19,960 --> 00:22:22,490
Du må vurdere
dine egne forutsetninger

411
00:22:22,490 --> 00:22:24,710
om hvordan koden skal oppføre seg.

412
00:22:24,710 --> 00:22:28,220
Hver gang du tror at noen stykke
av koden du vet skjer til å arbeide,

413
00:22:28,220 --> 00:22:30,940
som kan være et rødt flagg for å gå
tilbake og vurdere, og sørg

414
00:22:30,940 --> 00:22:33,470
at forutsetningen om
hvordan koden fungerer

415
00:22:33,470 --> 00:22:38,290
er faktisk sant til hvordan det er
uttrykt i kildekoden.

416
00:22:38,290 --> 00:22:41,300
>> Men enda mer til poenget var,
når vi bruker debugger,

417
00:22:41,300 --> 00:22:43,920
du kan sette stoppunkter på
ulike linjer med kode,

418
00:22:43,920 --> 00:22:48,110
noe som vil føre til at debugger til
pause utførelse ved hver av disse linjer

419
00:22:48,110 --> 00:22:52,210
slik at du kan evaluere
minne eller endre det på plass.

420
00:22:52,210 --> 00:22:55,630
Og igjen, husk at du kan
opprette flere stoppunkter, slik at du

421
00:22:55,630 --> 00:23:00,390
kan også gjenoppta kjøring, hopp
over store deler av koden,

422
00:23:00,390 --> 00:23:04,790
og det vil automatisk pause
ved neste pause punkt.

423
00:23:04,790 --> 00:23:07,760
>> Det er faktisk mer avansert
funksjonene i debugger, så vel.

424
00:23:07,760 --> 00:23:10,170
Men vi må henvise deg
til noen påfølgende videoer

425
00:23:10,170 --> 00:23:14,090
for å virkelig erte hverandre hvordan
å bruke de bestemte funksjoner.

426
00:23:14,090 --> 00:23:15,990
For nå, takk
veldig mye for å se på.

427
00:23:15,990 --> 00:23:18,080
Og lykke debugging.