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

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

3
00:00:02,350 --> 00:00:04,410
I dag vil vi
se på fejlfinding.

4
00:00:04,410 --> 00:00:06,697
Ikke alene vil vi
tale om nogle teknikker,

5
00:00:06,697 --> 00:00:09,280
men også vi kommer til at se på
nogle af de funktioner, der er indeholdt

6
00:00:09,280 --> 00:00:14,170
i CS50 IDE, der tillader
du nemt fejlsøge et program.

7
00:00:14,170 --> 00:00:16,272
>> Blot et eksempel på
noget, der kan gå galt

8
00:00:16,272 --> 00:00:18,730
og det er faktisk noget
at vi allerede har set før.

9
00:00:18,730 --> 00:00:23,200
I dette tilfælde er det en C program
der accepterer et heltal fra brugeren,

10
00:00:23,200 --> 00:00:27,580
deler den med to, og giver
output tilbage til brugeren.

11
00:00:27,580 --> 00:00:30,610
Nu fra hvad vi har set
tidligere i foredrag,

12
00:00:30,610 --> 00:00:34,370
vi, at dette rent faktisk vil medføre
specifikke typer af division problemer

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

14
00:00:35,860 --> 00:00:40,330
>> Konkret vil vi bare smide væk
noget efter kommaet.

15
00:00:40,330 --> 00:00:43,170
Nu ved vi, at dette
sker for at være tilfældet.

16
00:00:43,170 --> 00:00:47,430
Og hvis vi kører det, kan vi bekræfte,
vores mistanke, første, ved at indsamle.

17
00:00:47,430 --> 00:00:50,460
Og så, ved at køre og
indtastning et ulige antal.

18
00:00:50,460 --> 00:00:51,720
>> Dette er ikke noget nyt.

19
00:00:51,720 --> 00:00:54,490
Men det er faktisk en
eksempel på en fejl, der

20
00:00:54,490 --> 00:00:58,810
kan eksistere inden for et større program
der bliver sværere at opspore.

21
00:00:58,810 --> 00:01:02,640
Selv om vi ved, hvad problemet
er, den sande kerne

22
00:01:02,640 --> 00:01:06,250
kunne være at forsøge at identificere
specifikt hvor fejlen opstår,

23
00:01:06,250 --> 00:01:09,750
identificere, hvad problemet
er, og derefter fastsættelse det.

24
00:01:09,750 --> 00:01:14,400
Så giver dette som et eksempel
af, hvad der kunne være noget

25
00:01:14,400 --> 00:01:19,030
at vi allerede kender, men kan blive begravet
inden andre elementer i koden.

26
00:01:19,030 --> 00:01:23,090
>> Så åbner denne anden kilde
kode fil som et eksempel,

27
00:01:23,090 --> 00:01:27,165
denne opdeling problem er nu
en del af et større program.

28
00:01:27,165 --> 00:01:29,040
Stadig kan være lidt
bit konstruerede, og vi

29
00:01:29,040 --> 00:01:31,076
kan være i stand til nemt
identificere det, især

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

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

32
00:01:38,250 --> 00:01:45,450
>> Hvis jeg kompilere dette, og nu
køre den, skal du indtaste et ulige antal,

33
00:01:45,450 --> 00:01:49,816
Vi kan se, at vi ikke får præcis
output, som vi måske have forventet.

34
00:01:49,816 --> 00:01:51,690
I dette særlige tilfælde,
Vi kan sige, at vi

35
00:01:51,690 --> 00:01:56,060
vil tælle alle numrene
fra en op til nogle specifikke nummer.

36
00:01:56,060 --> 00:01:58,130
Og vi kan se, at vi
har en række spørgsmål

37
00:01:58,130 --> 00:02:03,880
her, hvis vi udsende, simpelthen, 0
og 1, når vi giver et input af 5.

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

39
00:02:07,380 --> 00:02:11,662
Men vi kan ikke vide præcist
hvor dette spørgsmål rent faktisk eksisterer.

40
00:02:11,662 --> 00:02:13,620
Nu er en af ​​de måder,
vi kan forsøge at løse dette

41
00:02:13,620 --> 00:02:15,745
er noget, som vi har
allerede blevet introduceret til.

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

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

44
00:02:21,680 --> 00:02:25,620
som giver os mulighed for at udskrive staten
af forskellige oplysninger.

45
00:02:25,620 --> 00:02:28,880
Og det er noget, du
bør udnytte i dit program

46
00:02:28,880 --> 00:02:33,100
at forsøge at finde ud af præcis, hvad der er
sker i forskellige linjer kode.

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

48
00:02:36,350 --> 00:02:39,830
ønsker at producere ud af
dette program, vi stadig

49
00:02:39,830 --> 00:02:42,300
kunne have nogle debug
udsagn, hvor vi

50
00:02:42,300 --> 00:02:46,970
kan prøve at finde ud af præcis, hvad
der sker inde i vores kode.

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

52
00:02:51,210 --> 00:02:53,540
I dette tilfælde er det
bare en debug string

53
00:02:53,540 --> 00:02:56,840
at jeg er up-lægge, så det bliver
meget klar i produktionen af ​​min kode

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

55
00:02:59,200 --> 00:03:04,410
Og output her nummeret
at vi har beregnet.

56
00:03:04,410 --> 00:03:06,800
>> I dette tilfælde, jeg kunne
ønsker at vide præcist

57
00:03:06,800 --> 00:03:11,380
hvad der sker før og
efter nogle specifikke beregning.

58
00:03:11,380 --> 00:03:16,224
Så jeg kan bruge en printf før
og efter denne linje kode.

59
00:03:16,224 --> 00:03:18,640
I dette tilfælde kunne jeg selv
gøre det lidt mere klart

60
00:03:18,640 --> 00:03:21,960
ved at sige debug før
og debug efter så

61
00:03:21,960 --> 00:03:26,540
at jeg ikke forveksle mig med
flere linjer, der ser identiske.

62
00:03:26,540 --> 00:03:32,290
>> Nu, hvis vi kompilere dette og køre
det, indtaste et nummer ligesom fem igen,

63
00:03:32,290 --> 00:03:35,090
Vi kan se, at vi har
nu output før og efter

64
00:03:35,090 --> 00:03:40,670
og opdager, at vi ikke har gjort en klar
division eller klar have af det antal

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

66
00:03:43,680 --> 00:03:48,660
Nu i dette tilfælde, det er
egentlig ikke en klar output.

67
00:03:48,660 --> 00:03:52,440
Det er egentlig ikke et klart resultat,
Vi vil ud af dette program.

68
00:03:52,440 --> 00:03:54,427
>> Og det er, igen, en
lidt konstruerede.

69
00:03:54,427 --> 00:03:57,510
Men måske en af ​​de ting,
vi kunne gøre, hvis specifikationen sagde

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

71
00:04:01,900 --> 00:04:04,550
vi ønsker at runde up-- derefter
vi måske vide, at vi kunne

72
00:04:04,550 --> 00:04:08,060
gøre det bestemt ting, i dette tilfælde.

73
00:04:08,060 --> 00:04:14,010
Nu her ved vi, at vi vil være
i stand til at tilføje 1 til vores halveret nummer.

74
00:04:14,010 --> 00:04:16,490
>> Lad os genkompilere dette
og bekræfte, at dette

75
00:04:16,490 --> 00:04:18,860
opfører den måde, som vi ønsker at.

76
00:04:18,860 --> 00:04:21,980
Vi kan se, at nu før
have, har vi nummer 5.

77
00:04:21,980 --> 00:04:26,620
Efter at have, har vi tallet 3,
som ifølge vores specifikationer,

78
00:04:26,620 --> 00:04:29,292
er, hvad vi ønskede at gøre.

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

80
00:04:31,000 --> 00:04:33,760
se, at vi kan have en anden
bug helt, hvilket er

81
00:04:33,760 --> 00:04:36,940
at vi starter vores optælling fra 0.

82
00:04:36,940 --> 00:04:39,390
>> Nu igen, det er noget
at vi har set tidligere

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

84
00:04:42,500 --> 00:04:44,790
Men i dette tilfælde, vi
havde også gavn

85
00:04:44,790 --> 00:04:48,940
for at bruge printf erklæring
direkte inde i for-løkken

86
00:04:48,940 --> 00:04:52,930
at vide præcist, hvor
Denne fejl foregik.

87
00:04:52,930 --> 00:04:55,150
Så printf udsagn er
meget nyttige i at hjælpe

88
00:04:55,150 --> 00:04:57,940
du bestemme, hvor,
netop i din kildekode,

89
00:04:57,940 --> 00:05:00,620
forekommer en specifik fejl.

90
00:05:00,620 --> 00:05:03,650
>> Og det er også vigtigt at indse
at som vi skriver kode,

91
00:05:03,650 --> 00:05:06,052
vi måske have antagelser
om status for et program.

92
00:05:06,052 --> 00:05:08,510
Eller vi kunne have antagelser
hvad del af programmet

93
00:05:08,510 --> 00:05:13,020
er faktisk korrekt eller forkert, når
senere som vi bygger på, at programmet

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

95
00:05:15,950 --> 00:05:19,700
at vi indser, at nogle aspekter
af det er faktisk buggy.

96
00:05:19,700 --> 00:05:22,680
>> Brug printf kan virkelig hjælpe
indsnævre og identificere

97
00:05:22,680 --> 00:05:26,430
regionerne et program, der måske ikke
skal opføre sig præcis den måde, at vi

98
00:05:26,430 --> 00:05:29,500
forventer, baseret på vores antagelser.

99
00:05:29,500 --> 00:05:31,460
Men der er andre værktøjer
til rådighed, samt,

100
00:05:31,460 --> 00:05:34,860
at tillade os at forsøge at figur
ud af, hvor der sker en fejl

101
00:05:34,860 --> 00:05:39,930
og også specifikt hvilke ting
der sker inde i programmet.

102
00:05:39,930 --> 00:05:41,990
>> Så ved hjælp af printf er meget
nyttigt, når vi ønsker

103
00:05:41,990 --> 00:05:45,900
at identificere specifikke områder af
et program, der har nogle fejl.

104
00:05:45,900 --> 00:05:47,730
Men bliver det også
kedelige efter et stykke tid.

105
00:05:47,730 --> 00:05:50,500
I dette tilfælde er det en
relativt simpelt program

106
00:05:50,500 --> 00:05:52,750
med blot en eller to variable.

107
00:05:52,750 --> 00:05:57,260
Og det bliver meget let for os at
udskrive værdien af ​​disse variabler

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

109
00:05:59,670 --> 00:06:02,670
>> Men vi har måske en anden
program, der har mange variable.

110
00:06:02,670 --> 00:06:06,530
Og det kan ikke være helt
så let at bruge printf

111
00:06:06,530 --> 00:06:10,120
at forsøge at vurdere, hvad der sker
til hver enkelt af disse variabler

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

113
00:06:13,590 --> 00:06:16,960
Der er et program, der findes
kaldes en debugger program.

114
00:06:16,960 --> 00:06:20,320
I dette tilfælde den, som vi vil
anvendelse er GNU debugger, eller GDB,

115
00:06:20,320 --> 00:06:24,260
der giver os mulighed for at inspicere det indre
arbejdet i et program i en langt mere

116
00:06:24,260 --> 00:06:25,700
detaljeret måde.

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

118
00:06:28,810 --> 00:06:35,370
her ved blot at skrive GDB og
kommando, som vi ønsker at debug.

119
00:06:35,370 --> 00:06:37,550
I dette tilfælde, ud.

120
00:06:37,550 --> 00:06:41,650
Nu i dette tilfælde, kan vi se, at det
bringer os til en prompt, der siger GDB.

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

122
00:06:44,020 --> 00:06:48,260
til rent faktisk at begynde udførelse af
program, stop det på visse punkter,

123
00:06:48,260 --> 00:06:51,060
evaluere variabler og
inspicere variabler,

124
00:06:51,060 --> 00:06:54,152
findes i programmet tilstand
på det pågældende tidspunkt,

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 giver en masse strøm til os.

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

128
00:06:59,960 --> 00:07:05,870
giver en GUI eller en bruger
interface til GDB at

129
00:07:05,870 --> 00:07:11,120
tillader os at gøre dette uden at behøve
kommandolinjen overhovedet

130
00:07:11,120 --> 00:07:13,560
eller på alle selv.

131
00:07:13,560 --> 00:07:16,930
Den måde, at jeg kan få adgang til denne
er ved hjælp af knappen debug

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

133
00:07:20,120 --> 00:07:24,280
Nu i fortiden, hvad vi har
set, er, at vi bruger kommandoen

134
00:07:24,280 --> 00:07:27,660
line til at kompilere og derefter køre et program.

135
00:07:27,660 --> 00:07:29,790
>> Knappen debug gør
begge disse trin.

136
00:07:29,790 --> 00:07:34,380
Men det også vil bringe op
debugger fanen længst til højre

137
00:07:34,380 --> 00:07:38,280
der giver os mulighed for at inspicere en række
egenskaber af programmet

138
00:07:38,280 --> 00:07:40,500
som det er at udføre.

139
00:07:40,500 --> 00:07:44,280
Hvis jeg klikker debug, i dette
tilfælde vil det bringe op

140
00:07:44,280 --> 00:07:48,230
en ny fane i konsollen
vinduet i bunden.

141
00:07:48,230 --> 00:07:51,160
>> Og du kan se, at denne fane har
nogle oplysninger på toppen.

142
00:07:51,160 --> 00:07:52,670
Og vi kan stort set ignorere dette.

143
00:07:52,670 --> 00:07:54,800
Men en af ​​de ting
at vi ønsker at lægge mærke til

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

145
00:07:57,170 --> 00:08:03,000
ville få, hvis vi forsøgte at køre gøre på
C-programmet i terminalvinduet.

146
00:08:03,000 --> 00:08:06,230
>> Her kan vi se det kører klang,
og det har en række flag,

147
00:08:06,230 --> 00:08:12,660
og det er at samle vores count.c fil,
som var den valgte fane på tidspunktet

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

149
00:08:15,100 --> 00:08:18,010
Så det er meget nyttigt, fordi
nu ved hjælp af denne debug knap,

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

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

152
00:08:24,460 --> 00:08:27,880
>> Et af flagene, som er
vigtigt i dette tilfælde,

153
00:08:27,880 --> 00:08:30,190
Vi har faktisk brugt
i længst tid

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

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

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

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

158
00:08:38,570 --> 00:08:41,250
I dette tilfælde, hvad vi er
fortæller klang, vores compiler,

159
00:08:41,250 --> 00:08:43,820
er, at vi ønsker at kompilere vores program.

160
00:08:43,820 --> 00:08:46,810
Men også give hvad er
kaldes symboloplysninger

161
00:08:46,810 --> 00:08:50,940
så compileren faktisk har adgang
til en masse af de underliggende oplysninger

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

163
00:08:52,610 --> 00:08:55,260
>> Mere specifikt antal
funktioner, som jeg har,

164
00:08:55,260 --> 00:08:58,000
navnene på disse funktioner,
variablerne, typerne

165
00:08:58,000 --> 00:09:01,730
at disse variabler er, og en række
andre ting, der hjælper debugger

166
00:09:01,730 --> 00:09:04,350
udføre sin funktion.

167
00:09:04,350 --> 00:09:06,600
Nu er der noget andet
det er vigtigt at nævne

168
00:09:06,600 --> 00:09:10,280
når vi diskuterer kører
et program på denne måde.

169
00:09:10,280 --> 00:09:13,660
>> Læg mærke til, at det har faktisk
opdraget en ny fane i vores konsol

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

171
00:09:14,780 --> 00:09:18,600
Vi behøver ikke længere at interagere
direkte med terminalvinduet.

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

173
00:09:21,420 --> 00:09:26,710
Det netop er specifik for kørende
program, som vi har skabt.

174
00:09:26,710 --> 00:09:29,270
>> Bemærk, at ved bunden, i
kombination med nogle output

175
00:09:29,270 --> 00:09:33,500
ved clang compileren og GDB,
som vi stort set bort,

176
00:09:33,500 --> 00:09:37,570
det faktisk viser outputtet af
vores program i bunden.

177
00:09:37,570 --> 00:09:41,240
Nu er det vigtigt at indse,
at denne ene vindue faktisk

178
00:09:41,240 --> 00:09:43,360
vil vise dig
output fra dit program

179
00:09:43,360 --> 00:09:47,190
men også kan acceptere input
for dette program, så godt.

180
00:09:47,190 --> 00:09:49,260
>> Så varsel, der siger
angiv et tal,

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

182
00:09:53,050 --> 00:09:55,510
Men det er nu vist i denne nye fane.

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

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

185
00:10:00,900 --> 00:10:05,890
viser os vores debug, output,
output, der kan være fejlbehæftet,

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

187
00:10:07,010 --> 00:10:10,460
Og i bunden, er det
faktisk har nogle ekstra udgang

188
00:10:10,460 --> 00:10:14,550
fra BNP bare at sige, at
dette program er afsluttet.

189
00:10:14,550 --> 00:10:16,655
>> Nu som du så i denne
særlige løbe igennem,

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

191
00:10:19,370 --> 00:10:23,740
selvom vi havde kommet debugger menuen
op, dette var stadig et kørende program.

192
00:10:23,740 --> 00:10:26,790
På intet tidspunkt gjorde det faktisk
pause henrettelse for os

193
00:10:26,790 --> 00:10:30,767
at være i stand til at inspicere alle
variablerne indeholdt deri.

194
00:10:30,767 --> 00:10:32,850
Der er noget andet
at vi er nødt til at gøre for

195
00:10:32,850 --> 00:10:36,910
at få GDB at erkende, at vi ønsker
at holde pause gennemførelse af programmet

196
00:10:36,910 --> 00:10:42,820
og ikke blot gør det muligt at fortsætte
normalt som vi ville i alle andre tilfælde.

197
00:10:42,820 --> 00:10:45,530
>> For at holde pause udførelse,
på nogle specifikke linje,

198
00:10:45,530 --> 00:10:47,830
vi nødt til at skabe, hvad der er
kaldes en knækpunkt.

199
00:10:47,830 --> 00:10:52,670
Og en pause punkt er meget nemt oprettes
i dette CS50 IDE ved at tage musen

200
00:10:52,670 --> 00:10:57,090
og klikke direkte til venstre
af nogle specifikke linje nummer.

201
00:10:57,090 --> 00:10:59,920
Når jeg gør det, en rød prik
vises, hvilket indikerer

202
00:10:59,920 --> 00:11:02,300
at denne linje er nu et knækpunkt.

203
00:11:02,300 --> 00:11:07,540
>> Og næste gang, jeg kører GDB, det
vil stoppe udførelsen på dette knækpunkt

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

205
00:11:10,280 --> 00:11:12,230
Nu er dette er en vigtig
ting at indse

206
00:11:12,230 --> 00:11:16,140
at det ikke nødvendigvis den
tilfælde, at hver linje kode

207
00:11:16,140 --> 00:11:17,880
er faktisk tilgængelige.

208
00:11:17,880 --> 00:11:23,780
Hvis jeg skulle lave en funktion
heroppe, for example-- tomrum F--

209
00:11:23,780 --> 00:11:31,230
og bare gøre en udskrift linje her-- hej
verden-hvis jeg aldrig kalde denne funktion,

210
00:11:31,230 --> 00:11:34,770
vil det være sådan, at
hvis jeg sætte en pause punkt her,

211
00:11:34,770 --> 00:11:36,220
funktionen vil aldrig blive kaldt.

212
00:11:36,220 --> 00:11:38,310
Og derfor denne
særlige knækpunkt

213
00:11:38,310 --> 00:11:43,040
vil faktisk aldrig pause
gennemførelsen af ​​programmet.

214
00:11:43,040 --> 00:11:48,020
>> Så lad os sige, at jeg rigtigt skaber
en pause punkt på nogle linje kode

215
00:11:48,020 --> 00:11:50,340
der rent faktisk vil blive henrettet.

216
00:11:50,340 --> 00:11:53,470
Nu i dette tilfælde, er dette den
første linje i hovedfunktion.

217
00:11:53,470 --> 00:11:56,630
Så det vil helt sikkert være tilfældet
at så snart jeg begynder udførelse,

218
00:11:56,630 --> 00:11:58,580
den allerførste linje vil blive nået.

219
00:11:58,580 --> 00:12:00,230
GDB vil holde pause udførelse.

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

221
00:12:04,100 --> 00:12:08,480
>> Du kan indstille flere linjer som
breakpoints, hvis du gerne vil.

222
00:12:08,480 --> 00:12:11,365
Vi kan også oprette en linje op
her i dette segment af kode

223
00:12:11,365 --> 00:12:12,490
der aldrig vil blive nået.

224
00:12:12,490 --> 00:12:14,744
Og vi kan også indstille en yderligere nedenfor.

225
00:12:14,744 --> 00:12:16,660
Grunden til, at vi ville
ønsker at gøre dette vi får

226
00:12:16,660 --> 00:12:19,119
gå ind i en lidt mere
detalje i bare et øjeblik.

227
00:12:19,119 --> 00:12:21,660
Så for nu, lad mig bare deaktivere
disse yderligere knækpunkter

228
00:12:21,660 --> 00:12:24,940
så vi kan se på, hvad der sker
når jeg har en enkelt pause

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

230
00:12:27,650 --> 00:12:29,410
Jeg har lavet nogle
ændringer til dette program.

231
00:12:29,410 --> 00:12:30,750
Så jeg har brug for at gemme det.

232
00:12:30,750 --> 00:12:34,490
Jeg vil klikke debug, så jeg kan
begynde indsamling og derefter

233
00:12:34,490 --> 00:12:36,880
udførelse af debugger.

234
00:12:36,880 --> 00:12:40,632
>> Vi vil se, at, efter øjeblikke, de
linje, vi valgt som pausen

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

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

237
00:12:47,440 --> 00:12:50,940
at ikonet pause er vendt
ind i en lille play-ikon.

238
00:12:50,940 --> 00:12:54,710
Det betyder, at vi har pause
udførelse, i dette særlige tilfælde.

239
00:12:54,710 --> 00:12:57,840
Og rammer på knappen Afspil ville
giver os mulighed for at genoptage udførelsen

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

241
00:13:00,000 --> 00:13:03,240
>> Bemærk, at der er et par andre
knapper til rådighed i denne debug-panel,

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

243
00:13:04,220 --> 00:13:09,470
Trin over, som tillader mig at
udføre, at én linje kode

244
00:13:09,470 --> 00:13:14,030
og trin over til denne linje til
næste, som i dette tilfælde,

245
00:13:14,030 --> 00:13:17,060
ville betyde, at printf
sætningen udføres.

246
00:13:17,060 --> 00:13:22,310
Og det vil derefter pause
udførelse på linje 13, som så.

247
00:13:22,310 --> 00:13:25,090
>> Og der er også et skridt
i funktion, som

248
00:13:25,090 --> 00:13:28,950
er nyttigt, hvis jeg har skabt andre
funktioner andre steder i kildekoden.

249
00:13:28,950 --> 00:13:31,420
Og jeg ønsker at træde ind
disse funktioner snarere end

250
00:13:31,420 --> 00:13:33,050
udføre denne funktion som en helhed.

251
00:13:33,050 --> 00:13:37,279
Men vi vil se mere på trin
i funktion i et øjeblik.

252
00:13:37,279 --> 00:13:40,320
Nu bemærke nogle andre ting,
faktisk eksisterer inden for denne debug panel.

253
00:13:40,320 --> 00:13:44,110
>> Vi har dette panel kaldet
kalder stakken, som viser os

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

255
00:13:45,300 --> 00:13:48,550
I dette tilfælde er vi inde
af den primære funktion.

256
00:13:48,550 --> 00:13:50,880
Vores script kaldes count.c.

257
00:13:50,880 --> 00:13:53,820
Og vi tilfældigvis at være på
linie 13, kolonne et, som

258
00:13:53,820 --> 00:13:58,950
er netop, hvad det fremhævede område
af kildekoden angiver, samt.

259
00:13:58,950 --> 00:14:02,435
>> Nu opdager, at det også viser
under den lokale variabel sektion

260
00:14:02,435 --> 00:14:06,710
alle de variabler,
Der findes inden for denne funktion.

261
00:14:06,710 --> 00:14:08,930
Det er vigtigt at bemærke,
at alle variabler

262
00:14:08,930 --> 00:14:12,580
vises i denne lokale variabel
afsnit i en funktion,

263
00:14:12,580 --> 00:14:14,380
endnu før de er defineret.

264
00:14:14,380 --> 00:14:19,160
Vi kan se her, at vi har en variabel
kaldte num, har en standardværdi på 0,

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

266
00:14:21,280 --> 00:14:24,110
>> Nu, før vi faktisk initialisere
alle disse variabler,

267
00:14:24,110 --> 00:14:26,685
vi er ikke nødvendigvis
garanteret at se en værdi på 0.

268
00:14:26,685 --> 00:14:29,200
Og afhængigt af andre henrettelser
at du har udført

269
00:14:29,200 --> 00:14:32,020
og tilstanden af ​​din hukommelse, når
du faktisk køre dette program,

270
00:14:32,020 --> 00:14:34,605
du måske opleve, at du
kan ikke se værdier 0

271
00:14:34,605 --> 00:14:36,550
og i stedet nogle andre skøre numre.

272
00:14:36,550 --> 00:14:38,390
>> Men du behøver ikke bekymre dig om det.

273
00:14:38,390 --> 00:14:44,610
Det kommer ikke til at være relevant, indtil
du faktisk initialisere værdi.

274
00:14:44,610 --> 00:14:49,630
Nu i dette tilfælde, kan vi se, at
Jeg har udført nogle udgange.

275
00:14:49,630 --> 00:14:52,131
Og jeg, lige nu, pause udførelse.

276
00:14:52,131 --> 00:14:53,880
Men i dette tilfælde, hvad
Jeg virkelig ønsker at gøre

277
00:14:53,880 --> 00:14:58,060
er nu træde over denne linje
af kode, så jeg kan faktisk

278
00:14:58,060 --> 00:15:04,390
forespørge brugeren om, at int, der
vi vil bruge i vores program.

279
00:15:04,390 --> 00:15:07,060
>> Nu i denne sag, når
Jeg ramte trin over, varsel

280
00:15:07,060 --> 00:15:11,940
at Pause eller rettere Genoptag
Knappen er ændret til denne pause

281
00:15:11,940 --> 00:15:14,022
fordi denne kode er faktisk bliver kørt.

282
00:15:14,022 --> 00:15:15,730
Hvad sker der
lige nu er, at det er

283
00:15:15,730 --> 00:15:21,630
venter os at indtaste nogle oplysninger
som vi kan se af vores output tekst

284
00:15:21,630 --> 00:15:23,600
i bunden.

285
00:15:23,600 --> 00:15:25,787
>> Så lige nu, det er
faktisk ikke sat på pause,

286
00:15:25,787 --> 00:15:28,620
selv om det, slags, vises
at være, fordi der ikke sker noget.

287
00:15:28,620 --> 00:15:32,360
Men det bare så sker det, at i
mit konkrete tilfælde på linje 13,

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

289
00:15:34,210 --> 00:15:39,130
Og så GDB er ikke i stand til at inspicere
et program, som det kører.

290
00:15:39,130 --> 00:15:43,370
>> Nu næste gang, jeg indtaste nogle
input-- så jeg vil indtaste dette nummer 5,

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

292
00:15:46,140 --> 00:15:51,430
meddele, at straks, GDB pauser
og igen, fremhæver den næste linje.

293
00:15:51,430 --> 00:15:55,320
Men se, at nu, som en
resultat af vores indtastning af en værdi,

294
00:15:55,320 --> 00:15:58,930
Vi har opdateret denne værdi inde
af vores lokale variable, som

295
00:15:58,930 --> 00:16:05,560
er meget nyttigt at vide nøjagtigt
hvad dette nummer var i hukommelsen.

296
00:16:05,560 --> 00:16:10,650
>> Nu kan jeg tillade dette program til at fortsætte
spille indtil udgangen af ​​dens udførelse

297
00:16:10,650 --> 00:16:12,570
ved at trykke på Genoptag.

298
00:16:12,570 --> 00:16:16,410
Vi kan se, at meget hurtigt
gør programmet færdig udfører

299
00:16:16,410 --> 00:16:19,790
med samme output, som vi
havde før, debugger lukker,

300
00:16:19,790 --> 00:16:23,170
og nu dette program
er stoppet helt.

301
00:16:23,170 --> 00:16:25,320
>> I viser, at kun for
henblik på at se, hvad

302
00:16:25,320 --> 00:16:27,280
der sker, når vi rent faktisk ramt Genoptag.

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

304
00:16:30,640 --> 00:16:33,820
så vi kan forsøge at debug
præcist, hvad der sker.

305
00:16:33,820 --> 00:16:37,980
Nu, hvor jeg bruger debugger, kan jeg
ikke brug for disse debug printf udsagn.

306
00:16:37,980 --> 00:16:43,860
>> Så jeg kunne fjerne dem, som jeg vil gøre
nu bare at gå tilbage til vores enklere kode

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

308
00:16:45,950 --> 00:16:48,790
Nu når jeg gemmer
programmere og udføre det,

309
00:16:48,790 --> 00:16:53,700
det vil igen gå til, at de første
bryde punkt, som jeg havde på linje 11.

310
00:16:53,700 --> 00:16:57,700
Og jeg vil være i stand til at inspicere
mine variabler som jeg ønsker at gøre.

311
00:16:57,700 --> 00:17:00,695
>> Det bare så sker det, at dette
del ikke er meget interessant,

312
00:17:00,695 --> 00:17:04,364
Og jeg ved, at jeg har tænkt mig
at udskrive denne erklæring.

313
00:17:04,364 --> 00:17:05,280
Indtast venligst et tal.

314
00:17:05,280 --> 00:17:08,099
Og så ved jeg, at jeg har tænkt mig
at bede brugeren om at heltal.

315
00:17:08,099 --> 00:17:13,329
Så måske, jeg rent faktisk ønsker at flytte min
bryde punkt lidt længere nede.

316
00:17:13,329 --> 00:17:16,710
>> Du kan fjerne break points
ved at klikke igen, direkte

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

318
00:17:18,460 --> 00:17:22,200
Det røde prik forsvinder, hvilket indikerer
at det knækpunkt nu er væk.

319
00:17:22,200 --> 00:17:24,780
Nu i denne sag,
henrettelse er blevet sat på pause.

320
00:17:24,780 --> 00:17:27,770
Og så er det faktisk ikke kommer til at
genoptages i det pågældende tilfælde.

321
00:17:27,770 --> 00:17:30,210
Men jeg kan sætte en pause
pege lidt senere.

322
00:17:30,210 --> 00:17:33,880
>> Og når jeg nu genoptage min
kode, vil det fortsætte og fortælle

323
00:17:33,880 --> 00:17:36,190
meningen med det knækpunkt.

324
00:17:36,190 --> 00:17:37,374
Igen, jeg ramte Genoptag.

325
00:17:37,374 --> 00:17:39,040
Synes ikke som noget, der sker.

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

327
00:17:41,450 --> 00:17:47,900
Jeg vil indtaste et nummer 5, tryk Enter, og
nu det næste brudpunkt vil blive ramt.

328
00:17:47,900 --> 00:17:50,570
>> Nu i dette tilfælde, er dette
er linje kode

329
00:17:50,570 --> 00:17:53,820
at før, vi vidste
tilfældigvis buggy.

330
00:17:53,820 --> 00:17:57,590
Så lad os vurdere, hvad der sker
på dette særlige tidspunkt.

331
00:17:57,590 --> 00:18:02,620
Når en linie er markeret,
linje er endnu ikke blevet henrettet.

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

333
00:18:06,490 --> 00:18:11,610
Jeg har et heltal kaldet
num, der har en værdi 5.

334
00:18:11,610 --> 00:18:15,090
Og jeg har tænkt mig til at optræde
del matematik på dette nummer.

335
00:18:15,090 --> 00:18:20,130
>> Hvis jeg træde over det, vi kan
bemærke, at værdien for num

336
00:18:20,130 --> 00:18:23,780
har ændret sig i overensstemmelse med
aritmetiske, at vi faktisk har gjort.

337
00:18:23,780 --> 00:18:26,810
Og nu hvor vi er
inde i denne for-løkke

338
00:18:26,810 --> 00:18:29,090
eller nu, at for-løkken
selv er fremhævet,

339
00:18:29,090 --> 00:18:32,450
vi se, at vi har en ny
variabel kaldet i, at

340
00:18:32,450 --> 00:18:35,370
vil blive anvendt i denne for-løkke.

341
00:18:35,370 --> 00:18:38,230
>> Husk nu, før at jeg
nævnte, at nogle gange er du

342
00:18:38,230 --> 00:18:43,470
kommer til at se en slags skøre
numre som standard, før dette nummer

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

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

345
00:18:49,040 --> 00:18:51,345
kaldte jeg, som ikke har
endnu ikke blevet initialiseret

346
00:18:51,345 --> 00:18:53,560
på tidspunktet for at fremhæve.

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

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

349
00:18:57,620 --> 00:18:59,661
Må ikke bekymre dig om det
fordi vi har faktisk ikke

350
00:18:59,661 --> 00:19:04,970
initialiseret dette nummer, indtil jeg
trin over denne linje, og værdien

351
00:19:04,970 --> 00:19:08,560
I er blevet initialiseret med værdien 1.

352
00:19:08,560 --> 00:19:11,400
Så at se, at det er faktisk
tilfældet, lad os træde over.

353
00:19:11,400 --> 00:19:14,420
Vi kan nu se, at der
linje er blevet henrettet.

354
00:19:14,420 --> 00:19:17,000
Og vi er nu at fremhæve
denne printf linje.

355
00:19:17,000 --> 00:19:22,230
>> Og vi kan nu se, hvordan vores værdier
i I og 3 har ændret sig over tid.

356
00:19:22,230 --> 00:19:26,450
Dette er meget nyttigt at gøre, i virkeligheden,
er at træde over linjer gentagne gange.

357
00:19:26,450 --> 00:19:30,480
Og du kan finde, hvad der faktisk
sker inde i din for-løkke

358
00:19:30,480 --> 00:19:33,660
og hvad der sker med
variabler inde i denne for-løkke

359
00:19:33,660 --> 00:19:39,200
som dette program henrettelse
opstår et skridt ad gangen.

360
00:19:39,200 --> 00:19:41,110
>> Nu på dette punkt, jeg
styrke over lige nok

361
00:19:41,110 --> 00:19:44,210
at jeg nu er ved afslutningen af ​​mit program.

362
00:19:44,210 --> 00:19:46,980
Hvis jeg træder over det, vil det
faktisk ophøre henrettelse

363
00:19:46,980 --> 00:19:48,860
som vi har set tidligere.

364
00:19:48,860 --> 00:19:52,110
Lad mig starte denne, endnu en gang, så
at jeg kan pege noget andet ud,

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

366
00:19:53,320 --> 00:19:55,350
>> I dette tilfælde er det
nu spørger mig, igen,

367
00:19:55,350 --> 00:19:57,100
for et nummer, der
Jeg vil igen komme ind.

368
00:19:57,100 --> 00:20:00,300
Men denne gang, jeg har tænkt mig at komme ind i
et større antal, så for-løkken

369
00:20:00,300 --> 00:20:02,540
vil gentage flere gange.

370
00:20:02,540 --> 00:20:06,090
I dette tilfælde, vil jeg
at indtaste en værdi på 11.

371
00:20:06,090 --> 00:20:08,390
>> Nu igen, fordi jeg ville sætte
en pause punkt linje 15,

372
00:20:08,390 --> 00:20:10,490
det kommer til at fremhæve denne linje.

373
00:20:10,490 --> 00:20:12,980
Vi kan se, at vores
nummer 11 er korrekt

374
00:20:12,980 --> 00:20:15,560
repræsenteret i vores lokale variable.

375
00:20:15,560 --> 00:20:22,460
Stepping over det, vi kan nu
se hvad der sker med vores værdi af i

376
00:20:22,460 --> 00:20:25,680
Når vi fortsætter inde i denne for-løkken.

377
00:20:25,680 --> 00:20:31,960
Det får øges hver gang vi
nå toppen af ​​denne for-løkken.

378
00:20:31,960 --> 00:20:35,110
>> Nu er en af ​​de ting, der kan
være nyttigt at gøre under udførelse

379
00:20:35,110 --> 00:20:40,490
med dette program er for mig at der faktisk
ændre variabler midstream at se

380
00:20:40,490 --> 00:20:42,450
hvad der sker med mit program.

381
00:20:42,450 --> 00:20:46,540
I dette tilfælde kan jeg faktisk
dobbeltklikke på værdien.

382
00:20:46,540 --> 00:20:48,040
Bemærk, at det bliver et tekstfelt.

383
00:20:48,040 --> 00:20:50,280
>> Nu kan jeg komme ind forskellige
helt værdsætter

384
00:20:50,280 --> 00:20:55,700
at se, hvordan mit program opfører sig
når jeg har ændret denne variabel.

385
00:20:55,700 --> 00:20:59,560
Nu i dette tilfælde den variable
I indeholder nu værdien 10.

386
00:20:59,560 --> 00:21:02,810
Men programmet er stadig
pause i udførelsen.

387
00:21:02,810 --> 00:21:07,610
Når jeg trin over, ser jeg, at den
værdi i, som jeg indtastes som 10,

388
00:21:07,610 --> 00:21:12,170
ikke er større end værdien af ​​num,
som straks medfører for-løkken

389
00:21:12,170 --> 00:21:14,240
at stoppe udførelsen.

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

391
00:21:16,210 --> 00:21:19,450
vil ændre variablen på plads.

392
00:21:19,450 --> 00:21:22,210
Du kan faktisk ønsker
at forsøge at ændre det, så

393
00:21:22,210 --> 00:21:24,590
at du kan fortsætte
udførelse af en løkke

394
00:21:24,590 --> 00:21:27,370
eller så du kan ændre
en vis værdi, før det

395
00:21:27,370 --> 00:21:32,630
når nogle specifikke sæt aritmetiske
at du er ved at udføre.

396
00:21:32,630 --> 00:21:36,210
>> Så nu, at vi faktisk ændre
værdi i som programmet blev udføre,

397
00:21:36,210 --> 00:21:39,540
det forårsagede for-løkken til at holde op
tidligt fordi, lige pludselig, jeg

398
00:21:39,540 --> 00:21:42,770
sket at være større end værdien
af num, således, at denne for-løkke

399
00:21:42,770 --> 00:21:45,410
ikke længere er brug for at blive henrettet.

400
00:21:45,410 --> 00:21:48,780
Endvidere er det tilfældigvis
sådan, at vi ændret værdien af ​​i

401
00:21:48,780 --> 00:21:53,270
når linien 17 blev fremhævet,
som var det tidspunkt

402
00:21:53,270 --> 00:21:56,280
at for-løkken udførelse
faktisk blive evalueret.

403
00:21:56,280 --> 00:22:00,210
>> Hvis jeg havde ændret værdien af
i på en anden linje, siger 19,

404
00:22:00,210 --> 00:22:03,360
vi ville have set anderledes
adfærd, fordi linje 19 ville

405
00:22:03,360 --> 00:22:08,310
har udført før løkken
tilstand blev revurderet.

406
00:22:08,310 --> 00:22:11,900
Nu på dette punkt, jeg er, igen,
ved afslutningen af ​​dette program.

407
00:22:11,900 --> 00:22:15,707
Og jeg kan lade dette gå videre til
lade mit program til at holde op naturligt.

408
00:22:15,707 --> 00:22:18,290
Men der er et par ting
der er vigtige at tage væk

409
00:22:18,290 --> 00:22:19,960
fra dette særlige diskussion.

410
00:22:19,960 --> 00:22:22,490
Du er nødt til at evaluere
dine egne antagelser

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

412
00:22:24,710 --> 00:22:28,220
Hver gang du tror, ​​at nogle stykke
af kode, du kender tilfældigvis arbejde,

413
00:22:28,220 --> 00:22:30,940
der kan være et rødt flag til at gå
tilbage og evaluere, og være sikker på

414
00:22:30,940 --> 00:22:33,470
at din antagelse om
hvordan denne kode fungerer

415
00:22:33,470 --> 00:22:38,290
er faktisk rigtigt, at hvordan det er
udtrykt i din kildekode.

416
00:22:38,290 --> 00:22:41,300
>> Men endnu mere at punkt var,
når vi bruger debugger,

417
00:22:41,300 --> 00:22:43,920
du kan sætte breakpoints på
forskellige linjer kode,

418
00:22:43,920 --> 00:22:48,110
hvilket vil medføre, at debugger til
pause udførelse på hver af disse linjer

419
00:22:48,110 --> 00:22:52,210
så du kan evaluere
hukommelse eller endda ændre det på plads.

420
00:22:52,210 --> 00:22:55,630
Og igen, husk, at du kan
oprette flere breakpoints, så du

421
00:22:55,630 --> 00:23:00,390
kan også genoptage udførelse, springe
over store dele af koden,

422
00:23:00,390 --> 00:23:04,790
og det vil automatisk holde pause
ved næste knækpunkt.

423
00:23:04,790 --> 00:23:07,760
>> Der er faktisk mere avanceret
funktioner i debugger, så godt.

424
00:23:07,760 --> 00:23:10,170
Men vi bliver nødt til at henvise dig
til nogle efterfølgende videoer

425
00:23:10,170 --> 00:23:14,090
for virkelig at drille hinanden, hvordan
at bruge disse særlige funktioner.

426
00:23:14,090 --> 00:23:15,990
For nu, tak
meget til at se.

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