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

2
00:00:00,309 --> 00:00:02,350
[? DAN ARMADARAS:?] Hallo,
Ich bin [? Dan Armadaras?].

3
00:00:02,350 --> 00:00:04,410
Heute sind wir zu gehen
sein Blick auf das Debugging.

4
00:00:04,410 --> 00:00:06,697
Nicht nur werden wir
sprechen über einige Techniken,

5
00:00:06,697 --> 00:00:09,280
sondern auch wir gehen, zu betrachten
einige der Merkmale enthalten

6
00:00:09,280 --> 00:00:14,170
innerhalb des CS50 IDE, mit denen
Sie einfach ein Programm zu debuggen.

7
00:00:14,170 --> 00:00:16,272
>> Nur ein Beispiel,
etwas, was schief gehen kann,

8
00:00:16,272 --> 00:00:18,730
und es ist tatsächlich etwas,
dass wir bereits gesehen.

9
00:00:18,730 --> 00:00:23,200
In diesem Fall ist dies ein C-Programm
daß nimmt eine ganze Zahl von dem Benutzer,

10
00:00:23,200 --> 00:00:27,580
teilt es durch zwei und liefert
die Ausgabe an den Benutzer zurück.

11
00:00:27,580 --> 00:00:30,610
Nun, was wir gesehen haben,
früher in Vorträgen,

12
00:00:30,610 --> 00:00:34,370
wir wissen, dass dies tatsächlich dazu führen,
bestimmte Arten von Divisionsaufgaben

13
00:00:34,370 --> 00:00:35,860
wenn wir ungeraden Zahlen.

14
00:00:35,860 --> 00:00:40,330
>> Genauer gesagt, werden wir einfach wegwerfen
alles nach dem Komma.

15
00:00:40,330 --> 00:00:43,170
Nun, wir wissen, dass dies
zufällig der Fall sein.

16
00:00:43,170 --> 00:00:47,430
Und wenn wir es laufen, können wir bestätigen,
unseren Verdacht, erstens, durch die Zusammenstellung.

17
00:00:47,430 --> 00:00:50,460
Und dann, durch Ausführen und
Eingabe eine ungerade Anzahl.

18
00:00:50,460 --> 00:00:51,720
>> Das ist nichts Neues.

19
00:00:51,720 --> 00:00:54,490
Aber dies ist eigentlich eine
Beispiel für einen Fehler, der

20
00:00:54,490 --> 00:00:58,810
kann innerhalb eines größeren Programms vorhanden
dass wird härter auf die Spur.

21
00:00:58,810 --> 00:01:02,640
Auch wenn wir wissen, was das Problem
ist der wahre Kern der Sache

22
00:01:02,640 --> 00:01:06,250
Möglicherweise versuchen Sie, zu identifizieren
Insbesondere an der der Fehler auftritt,

23
00:01:06,250 --> 00:01:09,750
herauszufinden, was das Problem
ist, und dann die Festsetzung es.

24
00:01:09,750 --> 00:01:14,400
So bieten dies als Beispiel
von dem, was könnte etwas sein,

25
00:01:14,400 --> 00:01:19,030
dass wir bereits wissen, kann aber begraben werden
in anderen Elementen des Codes.

26
00:01:19,030 --> 00:01:23,090
>> So Öffnen dieser anderen Quelle
Code-Datei als ein Beispiel,

27
00:01:23,090 --> 00:01:27,165
diese Teilung Problem ist nun,
Teil eines größeren Programms.

28
00:01:27,165 --> 00:01:29,040
Dennoch könnte ein wenig sein
bit erfunden, und wir

29
00:01:29,040 --> 00:01:31,076
vielleicht in der Lage zu sein, leicht
zu identifizieren, vor allem

30
00:01:31,076 --> 00:01:32,450
da wir gerade über diese.

31
00:01:32,450 --> 00:01:38,250
Aber wir herausfinden können, dass dies
Problem kann in einem größeren Maßstab existieren.

32
00:01:38,250 --> 00:01:45,450
>> Wenn ich diese kompilieren und jetzt
führen Sie es, geben Sie eine ungerade Zahl ist,

33
00:01:45,450 --> 00:01:49,816
können wir sehen, dass wir nicht genau erhalten
die Ausgabe, die wir erwartet haben können.

34
00:01:49,816 --> 00:01:51,690
In diesem besonderen Fall,
könnten wir sagen, dass wir

35
00:01:51,690 --> 00:01:56,060
wollen alle Zahlen zu zählen
von einem bis zu einigen spezifischen Nummer.

36
00:01:56,060 --> 00:01:58,130
Und wir können sehen, dass wir
haben eine Reihe von Problemen

37
00:01:58,130 --> 00:02:03,880
hier, wenn wir die Ausgabe, einfach, 0
und 1, wenn wir eine Eingabe von 5.

38
00:02:03,880 --> 00:02:07,380
>> So dass wir wissen bereits, dass
es gibt ein Problem hier.

39
00:02:07,380 --> 00:02:11,662
Aber wir können nicht genau wissen,
wo dieses Problem tatsächlich existiert.

40
00:02:11,662 --> 00:02:13,620
Jetzt ist einer der Wege,
wir können versuchen, dieses Problem zu beheben

41
00:02:13,620 --> 00:02:15,745
ist etwas, was wir haben
bereits eingeführt worden.

42
00:02:15,745 --> 00:02:18,880
Wir können es einfach verwenden, in einem größeren Maßstab.

43
00:02:18,880 --> 00:02:21,680
>> In Zeile 14 haben wir
Diese Funktion printf,

44
00:02:21,680 --> 00:02:25,620
, die uns aus dem Stand drucken können
der verschiedenen Informationen.

45
00:02:25,620 --> 00:02:28,880
Und das ist etwas, dass Sie
sollte in Ihrem Programm nutzen

46
00:02:28,880 --> 00:02:33,100
um zu versuchen, herauszufinden, was genau ist
geschieht in verschiedenen Zeilen Code.

47
00:02:33,100 --> 00:02:36,350
Selbst wenn dies nicht der
endgültige Ausgabe, dass wir tatsächlich

48
00:02:36,350 --> 00:02:39,830
will aus produzieren
Dieses Programm, das wir immer noch

49
00:02:39,830 --> 00:02:42,300
könnte einige Debug haben
Aussagen, wo wir

50
00:02:42,300 --> 00:02:46,970
kann versuchen, herauszufinden, genau das, was
innerhalb unseres Codes geschieht.

51
00:02:46,970 --> 00:02:51,210
>> Also in diesem Fall, ich will
printf mit dem Debug-Tag.

52
00:02:51,210 --> 00:02:53,540
In diesem Fall ist dies
nur eine Debug-String

53
00:02:53,540 --> 00:02:56,840
dass ich bis abstoßend, so dass es
sehr klar in der Ausgabe von meinem Code

54
00:02:56,840 --> 00:02:59,200
was es ist, dass ich will, um zu zeigen.

55
00:02:59,200 --> 00:03:04,410
Und Ausgangs hier die Anzahl
dass wir berechnet.

56
00:03:04,410 --> 00:03:06,800
>> In diesem Fall, könnte ich
wollen genau wissen,

57
00:03:06,800 --> 00:03:11,380
was passiert, und vor
nach einiger spezifischer Berechnung.

58
00:03:11,380 --> 00:03:16,224
So könnte ich eine printf, bevor verwenden
und nach dieser Codezeile.

59
00:03:16,224 --> 00:03:18,640
In diesem Fall könnte ich auch
machen es ein bisschen mehr klar,

60
00:03:18,640 --> 00:03:21,960
mit den Worten: debug vor
und Debug nach so

61
00:03:21,960 --> 00:03:26,540
dass ich mich nicht mit verwirren
mehrere Zeilen, die identisch aussehen.

62
00:03:26,540 --> 00:03:32,290
>> Wenn wir nun diese neu kompilieren und ausführen
es, geben Sie eine Zahl wie fünf wieder,

63
00:03:32,290 --> 00:03:35,090
können wir sehen, dass wir
jetzt vor und nach dem Ausgang

64
00:03:35,090 --> 00:03:40,670
und finden Sie, dass wir nicht einen klaren getan
Division oder klar mit der Anzahl

65
00:03:40,670 --> 00:03:43,680
dass wir tatsächlich tun will.

66
00:03:43,680 --> 00:03:48,660
Nun in diesem Fall ist dies
nicht wirklich eine klare Ausgangs.

67
00:03:48,660 --> 00:03:52,440
Es ist nicht wirklich ein klares Ergebnis,
Wir wollen aus diesem Programm.

68
00:03:52,440 --> 00:03:54,427
>> Und dies ist wiederum ein
wenig gekünstelt.

69
00:03:54,427 --> 00:03:57,510
Aber vielleicht, eines der Dinge, die
wir tun könnten, wenn die Spezifikation, sagte

70
00:03:57,510 --> 00:04:01,900
dass wir, dies durch unterteilen wollen
2 und fügen Sie 1-- so mit anderen Worten,

71
00:04:01,900 --> 00:04:04,550
wir dann runden up-- möchten
könnten wir, dass wir wissen,

72
00:04:04,550 --> 00:04:08,060
zu tun, dass bestimmte Sache, in diesem Fall.

73
00:04:08,060 --> 00:04:14,010
Jetzt ist hier wissen wir, dass wir in der
in der Lage, ein, um unsere halbiert Nummer hinzuzufügen.

74
00:04:14,010 --> 00:04:16,490
>> Lassen Sie uns diese neu kompilieren
und bestätigen, dass dies

75
00:04:16,490 --> 00:04:18,860
verhält sich die Art und Weise, die wir wollen.

76
00:04:18,860 --> 00:04:21,980
Das können wir jetzt, bevor zu sehen
mit, haben wir die Zahl 5.

77
00:04:21,980 --> 00:04:26,620
Nachdem haben wir die Nummer 3,
die nach unserer Spezifikation

78
00:04:26,620 --> 00:04:29,292
ist das, was wir tun wollten.

79
00:04:29,292 --> 00:04:31,000
Aber wenn wir uns die
hier ausgegeben, können wir

80
00:04:31,000 --> 00:04:33,760
zu sehen, dass wir vielleicht ein anderes haben
bug haupt, das ist

81
00:04:33,760 --> 00:04:36,940
dass wir beginnen unsere Zählung von 0.

82
00:04:36,940 --> 00:04:39,390
>> Jetzt wieder, das ist etwas,
dass wir in der Vergangenheit gesehen haben

83
00:04:39,390 --> 00:04:42,500
und wir relativ leicht beheben kann.

84
00:04:42,500 --> 00:04:44,790
Aber in diesem Fall haben wir
hatte auch den Vorteil,

85
00:04:44,790 --> 00:04:48,940
der Verwendung der Anweisung printf
direkt in der for-Schleife

86
00:04:48,940 --> 00:04:52,930
genau zu wissen, wo
dass Fehler auftreten.

87
00:04:52,930 --> 00:04:55,150
So printf Aussagen
dabei hilfreich,

88
00:04:55,150 --> 00:04:57,940
Sie bestimmen, wo,
Gerade im Quellcode,

89
00:04:57,940 --> 00:05:00,620
ein spezifischer Fehler auftritt.

90
00:05:00,620 --> 00:05:03,650
>> Und es ist auch wichtig zu erkennen,
dass, wie wir das Schreiben von Code,

91
00:05:03,650 --> 00:05:06,052
könnten wir Annahmen
über den Zustand eines Programms.

92
00:05:06,052 --> 00:05:08,510
Oder wir könnten Annahmen
zu welchem ​​Teil des Programms

93
00:05:08,510 --> 00:05:13,020
ist eigentlich richtig oder falsch, wenn
Später, als wir an diesem Programm zu erstellen

94
00:05:13,020 --> 00:05:15,950
und machen es Teil einer
komplexe und größere Programm

95
00:05:15,950 --> 00:05:19,700
, dass wir erkennen, dass einige Aspekte
der, dass ist eigentlich Buggy.

96
00:05:19,700 --> 00:05:22,680
>> Mit printf kann wirklich helfen,
eingrenzen und identifizieren

97
00:05:22,680 --> 00:05:26,430
die Regionen ein Programm, das nicht kann
werden genau die Art und Weise verhalten, dass wir

98
00:05:26,430 --> 00:05:29,500
erwartet, basierend auf unseren Annahmen.

99
00:05:29,500 --> 00:05:31,460
Aber es gibt andere Werkzeuge
zur Verfügung, ebenso,

100
00:05:31,460 --> 00:05:34,860
dass es uns ermöglichen, um Abbildung zu versuchen
aus dem ein Fehler auftritt,

101
00:05:34,860 --> 00:05:39,930
und auch, insbesondere, was die Dinge
innerhalb des Programms geschieht.

102
00:05:39,930 --> 00:05:41,990
>> Also mit printf ist sehr
sinnvoll, wenn wir wollen,

103
00:05:41,990 --> 00:05:45,900
um bestimmte Bereiche zu identifizieren
ein Programm, das einige Fehler haben.

104
00:05:45,900 --> 00:05:47,730
Sondern es wird auch
mühsame nach einer Weile.

105
00:05:47,730 --> 00:05:50,500
In diesem Fall ist dies ein
relativ einfaches Programm

106
00:05:50,500 --> 00:05:52,750
mit nur einer oder zwei Variablen.

107
00:05:52,750 --> 00:05:57,260
Und es wird für uns sehr einfach,
drucken Sie den Wert dieser Variablen

108
00:05:57,260 --> 00:05:59,670
in Zusammenhang mit der größeren Programms.

109
00:05:59,670 --> 00:06:02,670
>> Aber wir einen anderen haben könnte
Programm, das viele Variablen hat.

110
00:06:02,670 --> 00:06:06,530
Und es kann nicht ganz sein
so einfach zu verwenden printf

111
00:06:06,530 --> 00:06:10,120
um zu versuchen, zu bewerten, was geschieht,
zu jedem von diesen Variablen

112
00:06:10,120 --> 00:06:13,590
als das Programm ausgeführt wird.

113
00:06:13,590 --> 00:06:16,960
Es gibt ein Programm, das vorhanden ist
rief ein Debugger-Programm.

114
00:06:16,960 --> 00:06:20,320
In diesem Fall ist der, dass wir
Verwendung der GNU-Debugger oder GDB,

115
00:06:20,320 --> 00:06:24,260
dass erlaubt uns, die internen inspizieren
Funktionsweise des Programms in einer wesentlich

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

117
00:06:25,700 --> 00:06:28,810
>> Wir können tatsächlich ausführen
GDB über die Befehlszeile

118
00:06:28,810 --> 00:06:35,370
hier, indem Sie einfach GDB und der
Befehl, die wir debuggen möchten.

119
00:06:35,370 --> 00:06:37,550
In diesem Fall zählen.

120
00:06:37,550 --> 00:06:41,650
Nun in diesem Fall können wir sehen, dass es
bringt uns zu einer Eingabeaufforderung, die GDB sagt.

121
00:06:41,650 --> 00:06:44,020
Und wir können tatsächlich
Befehle ausführen, um GDB

122
00:06:44,020 --> 00:06:48,260
um die Ausführung der tatsächlichen Beginn
Programm, hör auf zu bestimmten Zeitpunkten,

123
00:06:48,260 --> 00:06:51,060
die Variablen zu bewerten und
überprüfen Sie die Variablen,

124
00:06:51,060 --> 00:06:54,152
gibt es in der Programmzustand
in diesem Moment,

125
00:06:54,152 --> 00:06:55,110
und so weiter und so fort.

126
00:06:55,110 --> 00:06:57,240
Sie bietet eine Menge Power, mit uns.

127
00:06:57,240 --> 00:06:59,960
>> Aber es passiert einfach so,
dass der CS50 IDE auch

128
00:06:59,960 --> 00:07:05,870
bietet eine grafische Oberfläche oder ein Benutzer
Schnittstelle für GDB, dass

129
00:07:05,870 --> 00:07:11,120
ermöglicht es uns, dies zu tun, ohne dass
Die Befehlszeilenschnittstelle auch immer

130
00:07:11,120 --> 00:07:13,560
oder überhaupt noch.

131
00:07:13,560 --> 00:07:16,930
Die Möglichkeit, dass ich zugreifen, dass
ist die Verwendung des Debug-Taste

132
00:07:16,930 --> 00:07:20,120
an der Spitze des CS50 IDE.

133
00:07:20,120 --> 00:07:24,280
Jetzt in der Vergangenheit, was wir haben,
zu sehen ist, dass wir den Befehl

134
00:07:24,280 --> 00:07:27,660
Linie zu kompilieren und dann ein Programm ausführen.

135
00:07:27,660 --> 00:07:29,790
>> Die Debug-Taste funktioniert
beide dieser Schritte.

136
00:07:29,790 --> 00:07:34,380
Aber es auch öffnet die
Debugger-Register auf der rechten

137
00:07:34,380 --> 00:07:38,280
dass ermöglicht es uns, eine Vielzahl inspizieren
der Eigenschaften des Programms

138
00:07:38,280 --> 00:07:40,500
wie es ausgeführt wird.

139
00:07:40,500 --> 00:07:44,280
Wenn ich auf Debuggen, in diesem
Fall wird es bringen

140
00:07:44,280 --> 00:07:48,230
ein neuer Tab in der Konsole
Fenster ganz unten.

141
00:07:48,230 --> 00:07:51,160
>> Und Sie können sehen, dass diese Lasche
einige Informationen an der Spitze.

142
00:07:51,160 --> 00:07:52,670
Und wir können weitgehend ignorieren.

143
00:07:52,670 --> 00:07:54,800
Aber eines der Dinge,
dass wir zu bemerken wollen

144
00:07:54,800 --> 00:07:57,170
ist, dass es ausgibt
die gleiche Sache, dass wir

145
00:07:57,170 --> 00:08:03,000
wäre, wenn wir versuchten, make auf
das C-Programm im Terminal-Fenster.

146
00:08:03,000 --> 00:08:06,230
>> Hier können wir sehen, es läuft Klang,
und es hat eine Vielzahl von Flags,

147
00:08:06,230 --> 00:08:12,660
und es wird der Zusammenstellung unserer count.c-Datei,
denen die ausgewählten Registerkarte zu der Zeit war

148
00:08:12,660 --> 00:08:15,100
dass ich auf Debug.

149
00:08:15,100 --> 00:08:18,010
Also das ist sehr nützlich, weil
Jetzt mit diesen Debug-Taste,

150
00:08:18,010 --> 00:08:23,280
wir können gleichzeitig zu kompilieren und dann
das Programm ausführen, dass wir tatsächlich

151
00:08:23,280 --> 00:08:24,460
will laufen.

152
00:08:24,460 --> 00:08:27,880
>> Eine der Fahnen, die ist
wichtig ist, in diesem Fall

153
00:08:27,880 --> 00:08:30,190
wir haben eigentlich mit gewesen
am längsten

154
00:08:30,190 --> 00:08:32,450
aber auch nur tat etwas Hand
winken [unverständlich], die

155
00:08:32,450 --> 00:08:33,820
ist dies eine genau hier.

156
00:08:33,820 --> 00:08:35,790
Im Klang, heißt es -ggdb3.

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

158
00:08:38,570 --> 00:08:41,250
In diesem Fall ist das, was wir
erzählt clang unsere Compiler,

159
00:08:41,250 --> 00:08:43,820
ist, dass wir unser Programm kompilieren wollen.

160
00:08:43,820 --> 00:08:46,810
Sondern auch, was sind
genannt Symbolinformationen

161
00:08:46,810 --> 00:08:50,940
so dass der Compiler tatsächlich Zugang
zu einer Menge des zu Grunde liegenden Informationen

162
00:08:50,940 --> 00:08:52,610
innerhalb des Programms enthalten ist.

163
00:08:52,610 --> 00:08:55,260
>> Genauer gesagt, die Zahl
Funktionen, die ich habe,

164
00:08:55,260 --> 00:08:58,000
die Namen der Funktionen,
die Variablen, die Typen

165
00:08:58,000 --> 00:09:01,730
dass diese Variablen sind, und eine Vielzahl
andere Dinge, die den Debugger helfen

166
00:09:01,730 --> 00:09:04,350
führen seinen Betrieb.

167
00:09:04,350 --> 00:09:06,600
Jetzt gibt es etwas anderes
das ist wichtig zu erwähnen,

168
00:09:06,600 --> 00:09:10,280
wenn wir diskutieren Lauf
ein Programm auf diese Weise.

169
00:09:10,280 --> 00:09:13,660
>> Beachten Sie, dass es tatsächlich
eine neue Registerkarte in unserer Konsole gebracht

170
00:09:13,660 --> 00:09:14,780
entlang der Unterseite.

171
00:09:14,780 --> 00:09:18,600
Wir müssen nicht mehr zu interagieren
direkt mit dem Terminal-Fenster.

172
00:09:18,600 --> 00:09:21,420
Aber diese neue Registerkarte ist
eigentlich ein Terminal-Fenster.

173
00:09:21,420 --> 00:09:26,710
Es einfach ist spezifisch für die Lauf
Programm, das wir geschaffen haben.

174
00:09:26,710 --> 00:09:29,270
>> Feststellen, dass an der Unterseite, in
Kombination mit einigen Ausgangs

175
00:09:29,270 --> 00:09:33,500
von clang den Compiler und GDB,
die wir größtenteils zu ignorieren,

176
00:09:33,500 --> 00:09:37,570
andererseits weist sie den Ausgang des
unser Programm ganz unten.

177
00:09:37,570 --> 00:09:41,240
Jetzt ist es wichtig zu erkennen,
dass dieses eine Fenster tatsächlich

178
00:09:41,240 --> 00:09:43,360
zeigen Ihnen die
von Ihrem Programmausgabe

179
00:09:43,360 --> 00:09:47,190
kann aber auch Eingabe akzeptieren
für dieses Programm, wie gut.

180
00:09:47,190 --> 00:09:49,260
>> So Hinweis, der besagt
Bitte geben Sie eine Zahl,

181
00:09:49,260 --> 00:09:53,050
die die gleiche Ausgabe, die wir
hatte im Terminalfenster vor.

182
00:09:53,050 --> 00:09:55,510
Aber es ist jetzt in dieser neuen Registerkarte angezeigt.

183
00:09:55,510 --> 00:09:56,550
Ich kann Eingang eine Nummer.

184
00:09:56,550 --> 00:10:00,900
Und es wird tatsächlich
Funktion als wir erwarten

185
00:10:00,900 --> 00:10:05,890
zeigt uns unsere debug, Ausgang,
die Ausgabe, die fehlerhaft sein könnte,

186
00:10:05,890 --> 00:10:07,010
wie wir zuvor gesehen haben.

187
00:10:07,010 --> 00:10:10,460
Und am unteren Ende, das
tatsächlich hat einige zusätzliche Ausgangs

188
00:10:10,460 --> 00:10:14,550
vom BIP nur sagen, dass
dieses Programm beendet ist.

189
00:10:14,550 --> 00:10:16,655
>> Nun, wie Sie in das sah
insbesondere Durchlauf,

190
00:10:16,655 --> 00:10:19,370
es war nicht besonders
nützlich, weil auch

191
00:10:19,370 --> 00:10:23,740
obwohl wir das Debugger-Menü zu kommen
up, das war immer noch ein laufendes Programm.

192
00:10:23,740 --> 00:10:26,790
Zu keinem Zeitpunkt habe es tatsächlich
unterbrechen die Ausführung für uns

193
00:10:26,790 --> 00:10:30,767
in der Lage sein, alle zu prüfen sein,
die Variablen innerhalb enthalten.

194
00:10:30,767 --> 00:10:32,850
Da ist noch etwas
dass wir, um zu tun haben

195
00:10:32,850 --> 00:10:36,910
um GDB erhalten, zu erkennen, dass wir wollen,
zur Ausführung des Programms unterbrechen

196
00:10:36,910 --> 00:10:42,820
und nicht nur lassen Sie es gehen
normalerweise als würden wir in jedem anderen Fall.

197
00:10:42,820 --> 00:10:45,530
>> Um die Ausführung zu unterbrechen,
zu irgendeinem bestimmten Zeile,

198
00:10:45,530 --> 00:10:47,830
wir brauchen, um zu schaffen, was ist
genannt Bruchstelle.

199
00:10:47,830 --> 00:10:52,670
Und eine Bruchstelle ist sehr einfach erstellt
in diesem CS50 IDE, indem Sie mit der Maus

200
00:10:52,670 --> 00:10:57,090
und klicken Sie direkt auf der linken Seite
einiger spezifischer Zeilennummer.

201
00:10:57,090 --> 00:10:59,920
Sobald ich das tun, ein roter Punkt
angezeigt wird, die anzeigt,

202
00:10:59,920 --> 00:11:02,300
dass diese Zeile ist jetzt ein Bruchstelle.

203
00:11:02,300 --> 00:11:07,540
>> Und das nächste Mal, das ich laufen GDB, es
wird die Ausführung an diesem Haltepunkt stoppen

204
00:11:07,540 --> 00:11:10,280
wenn es, dass die Codezeile erreicht.

205
00:11:10,280 --> 00:11:12,230
Nun ist dies ein wichtiger
was zu realisieren

206
00:11:12,230 --> 00:11:16,140
dass es nicht notwendigerweise der
Fall, dass jede Zeile Code

207
00:11:16,140 --> 00:11:17,880
ist eigentlich erreichbar.

208
00:11:17,880 --> 00:11:23,780
Wenn ich, um eine Funktion zu erstellen
hier, für nichtig example-- F--

209
00:11:23,780 --> 00:11:31,230
und einfach eine Druckzeile hier-- hallo
world-- wenn ich diese Funktion nicht aufrufen,

210
00:11:31,230 --> 00:11:34,770
es wird der Fall sein, dass,
wenn ich einen Haltepunkt hier,

211
00:11:34,770 --> 00:11:36,220
die Funktion nie aufgerufen werden.

212
00:11:36,220 --> 00:11:38,310
Und daher dieser
insbesondere Bruchstelle

213
00:11:38,310 --> 00:11:43,040
wird nie anhalten
Ausführung des Programms.

214
00:11:43,040 --> 00:11:48,020
>> Also lassen Sie uns sagen, dass ich mich richtig zu erstellen
einen Haltepunkt auf einige Codezeile

215
00:11:48,020 --> 00:11:50,340
dass auch tatsächlich durchgeführt werden.

216
00:11:50,340 --> 00:11:53,470
Nun in diesem Fall ist dies die
erste Zeile in der Hauptfunktion.

217
00:11:53,470 --> 00:11:56,630
So wird es sicherlich der Fall sein,
dass, sobald ich die Ausführung zu beginnen,

218
00:11:56,630 --> 00:11:58,580
die erste Zeile zu erreichen.

219
00:11:58,580 --> 00:12:00,230
GDB wird die Ausführung angehalten.

220
00:12:00,230 --> 00:12:04,100
Und dann werde ich in der Lage,
interagieren mit dem Debugger.

221
00:12:04,100 --> 00:12:08,480
>> Sie können mehrere Linien als Set
Breakpoints, wenn Sie möchten.

222
00:12:08,480 --> 00:12:11,365
Wir können auch eine Zeile nach oben
hier in diesem Codesegment

223
00:12:11,365 --> 00:12:12,490
daß nie erreicht wird.

224
00:12:12,490 --> 00:12:14,744
Und wir können auch weiter unten eingestellten.

225
00:12:14,744 --> 00:12:16,660
Der Grund, dass wir
Dies wollen wir tun

226
00:12:16,660 --> 00:12:19,119
Gehen Sie in ein bisschen mehr
Detail in nur einem Augenblick.

227
00:12:19,119 --> 00:12:21,660
So jetzt, lassen Sie mich nur zu deaktivieren
Diese zusätzlichen Haltepunkte

228
00:12:21,660 --> 00:12:24,940
so dass wir, was passiert, schauen
wenn ich ein einziges Break

229
00:12:24,940 --> 00:12:27,650
Punkt in meinem Programm.

230
00:12:27,650 --> 00:12:29,410
Ich habe einige
Änderungen zu diesem Programm.

231
00:12:29,410 --> 00:12:30,750
Also muss ich sie zu speichern.

232
00:12:30,750 --> 00:12:34,490
Ich werde Debug klicken, so dass ich kann,
beginnen die Zusammenstellung und dann

233
00:12:34,490 --> 00:12:36,880
Ausführung des Debuggers.

234
00:12:36,880 --> 00:12:40,632
>> Wir werden sehen, dass nach Augenblicken der
Linie, die wir nach der Pause gewählt

235
00:12:40,632 --> 00:12:43,360
Punkt wird gelb hervorgehoben.

236
00:12:43,360 --> 00:12:47,440
Wir können auch feststellen, dass in der
oben rechts in der Austestkonsole

237
00:12:47,440 --> 00:12:50,940
dass das Symbol Pause gemacht hat
in ein wenig Spiel-Symbol.

238
00:12:50,940 --> 00:12:54,710
Das heißt, wir haben Pause
Ausführung, in diesem speziellen Fall.

239
00:12:54,710 --> 00:12:57,840
Und schlagen die Play-Taste würde
es uns ermöglichen, die Ausführung wieder aufzunehmen

240
00:12:57,840 --> 00:13:00,000
an diesem bestimmten Punkt.

241
00:13:00,000 --> 00:13:03,240
>> Beachten Sie, dass es gibt ein paar andere
Knopf in dieser Debug-Panel,

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

243
00:13:04,220 --> 00:13:09,470
Überschritt, der mir erlaubt
auszuführen, dass eine Zeile Code

244
00:13:09,470 --> 00:13:14,030
und Schritt über zu dieser Linie, um die
nächste, was in diesem Fall,

245
00:13:14,030 --> 00:13:17,060
würde, dass der printf bedeuten
Anweisung ausgeführt wird.

246
00:13:17,060 --> 00:13:22,310
Und es wird dann Pause
Ausführung in Zeile 13, wie so.

247
00:13:22,310 --> 00:13:25,090
>> Und es gibt auch ein Schritt
in-Funktion, die

248
00:13:25,090 --> 00:13:28,950
ist nützlich, wenn ich anderen erstellt
Funktionen anderer Stelle im Quellcode.

249
00:13:28,950 --> 00:13:31,420
Und ich möchte in Schritt
diese Funktionen statt

250
00:13:31,420 --> 00:13:33,050
ausgeführt wird, die Funktion als Ganzes.

251
00:13:33,050 --> 00:13:37,279
Aber wir werden in dem Schritt mehr sehen
in-Funktion in nur einem Augenblick.

252
00:13:37,279 --> 00:13:40,320
Jetzt bemerken einige andere Dinge,
tatsächlich existieren innerhalb dieser Debug-Panel.

253
00:13:40,320 --> 00:13:44,110
>> Wir haben diese Platte genannt
Aufruf-Liste, die uns zeigt,

254
00:13:44,110 --> 00:13:45,300
wo wir genau sind.

255
00:13:45,300 --> 00:13:48,550
In diesem Fall wird im Inneren sind wir
der Hauptfunktion.

256
00:13:48,550 --> 00:13:50,880
Unser Skript aufgerufen count.c.

257
00:13:50,880 --> 00:13:53,820
Und wir zufällig auf sein
Zeile 13, Spalte eins, die

258
00:13:53,820 --> 00:13:58,950
ist genau das, was die hervorgehobenen Bereich
der Quellcode angibt, wie gut.

259
00:13:58,950 --> 00:14:02,435
>> Nun beachtet, dass dies zeigt auch,
unter dem lokalen variablem Querschnitt

260
00:14:02,435 --> 00:14:06,710
alle Variablen,
gibt es innerhalb dieser Funktion.

261
00:14:06,710 --> 00:14:08,930
Es ist wichtig zu beachten,
dass alle Variablen

262
00:14:08,930 --> 00:14:12,580
wird in dieser lokalen Variablen angezeigt
Abschnitt innerhalb einer Funktion,

263
00:14:12,580 --> 00:14:14,380
noch bevor sie definiert sind.

264
00:14:14,380 --> 00:14:19,160
Hier können wir sehen, dass wir eine Variable haben
genannt num, hat einen Standardwert von 0,

265
00:14:19,160 --> 00:14:21,280
und es ist vom Typ int.

266
00:14:21,280 --> 00:14:24,110
>> Nun, bevor wir tatsächlich initialisieren
alle diese Variablen,

267
00:14:24,110 --> 00:14:26,685
wir sind nicht notwendigerweise
garantiert, um einen Wert von 0 zu sehen.

268
00:14:26,685 --> 00:14:29,200
Und in Abhängigkeit von anderen Hinrichtungen
dass Sie durchgeführt haben

269
00:14:29,200 --> 00:14:32,020
und der Zustand des Speichers, wenn
Sie tatsächlich führen Sie dieses Programm,

270
00:14:32,020 --> 00:14:34,605
Sie können, dass Sie finden,
Sie Werte von 0 nicht sehen

271
00:14:34,605 --> 00:14:36,550
und stattdessen einige andere verrückte Zahlen.

272
00:14:36,550 --> 00:14:38,390
>> Aber keine Sorgen machen.

273
00:14:38,390 --> 00:14:44,610
Es wird nicht relevant, bis sein
Sie tatsächlich initialisiert den Wert.

274
00:14:44,610 --> 00:14:49,630
Nun in diesem Fall können wir sehen
Ich habe einige Ausgänge durchgeführt.

275
00:14:49,630 --> 00:14:52,131
Und ich bin, gerade jetzt, pausiert die Ausführung.

276
00:14:52,131 --> 00:14:53,880
Aber in diesem Fall, was
Ich wirklich tun möchte,

277
00:14:53,880 --> 00:14:58,060
ist es jetzt über diese Leitung Schritt
der Code, so dass ich tatsächlich

278
00:14:58,060 --> 00:15:04,390
Abfrage der Benutzer für die int, dass
Wir wollen in unserem Programm verwenden.

279
00:15:04,390 --> 00:15:07,060
>> Nun in diesem Fall, wenn
Ich schlug Schritt über, Ankündigung

280
00:15:07,060 --> 00:15:11,940
dass die Pause oder vielmehr die Wiederaufnahme-
Button hat auf diese Schaltfläche Pause verändert

281
00:15:11,940 --> 00:15:14,022
da dieser Code tatsächlich auszuführen.

282
00:15:14,022 --> 00:15:15,730
Was ist los
im Augenblick ist, dass es

283
00:15:15,730 --> 00:15:21,630
auf uns wartet, um Eingangs einige Informationen
wie wir von unseren Ausgangs Text sehen

284
00:15:21,630 --> 00:15:23,600
ganz unten.

285
00:15:23,600 --> 00:15:25,787
>> So jetzt ist dies
eigentlich nicht angehalten,

286
00:15:25,787 --> 00:15:28,620
obwohl es, irgendwie, scheint
zu sein, weil nichts passiert.

287
00:15:28,620 --> 00:15:32,360
Aber es passiert einfach so, dass in
meinem speziellen Fall in Zeile 13,

288
00:15:32,360 --> 00:15:34,210
Ich warte auf Benutzereingaben.

289
00:15:34,210 --> 00:15:39,130
Usw. GDB ist nicht in der Lage zu kontrollieren
ein Programm, wie es ausgeführt wird.

290
00:15:39,130 --> 00:15:43,370
>> Jetzt ist das nächste Mal, dass ich an manchen
input-- so werde ich diese Zahl 5 eingeben,

291
00:15:43,370 --> 00:15:46,140
Wie wir in der gesehen haben
past-- drücken Sie Return, und wir

292
00:15:46,140 --> 00:15:51,430
Beachten Sie, dass sofort, GDB Pausen
und wiederum unterstreicht die nächste Zeile.

293
00:15:51,430 --> 00:15:55,320
Aber beachten Sie, dass jetzt, da ein
Ergebnis unserer Eingabe eines Wertes,

294
00:15:55,320 --> 00:15:58,930
haben wir diesen Wert innerhalb aktualisiert
von unseren lokalen Variablen, die

295
00:15:58,930 --> 00:16:05,560
ist sehr nützlich, um genau zu wissen,
was diese Zahl war im Speicher.

296
00:16:05,560 --> 00:16:10,650
>> Jetzt kann ich dieses Programm ermöglichen, auch weiterhin
spielen, bis das Ende der Ausführung

297
00:16:10,650 --> 00:16:12,570
indem Sie auf Fortsetzen.

298
00:16:12,570 --> 00:16:16,410
Das können wir sehr schnell zu sehen
wird das Programm die Ausführung Finish

299
00:16:16,410 --> 00:16:19,790
bei gleicher Leistung, die wir
hatte vor, der Debugger geschlossen,

300
00:16:19,790 --> 00:16:23,170
und jetzt dieses Programm
vollständig gestoppt.

301
00:16:23,170 --> 00:16:25,320
>> Ich zeigen, dass nur für die
Zwecken zu sehen, was

302
00:16:25,320 --> 00:16:27,280
passiert, wenn wir tatsächlich getroffen Lebenslauf.

303
00:16:27,280 --> 00:16:30,640
Aber wir tatsächlich sind los
will wieder in dieses Programm gehen

304
00:16:30,640 --> 00:16:33,820
so dass wir versuchen, zu debuggen
genau, was geschieht.

305
00:16:33,820 --> 00:16:37,980
Jetzt, wo ich mit dem Debugger, darf ich
brauchen diese Debug printf-Anweisungen.

306
00:16:37,980 --> 00:16:43,860
>> So konnte ich sie zu entfernen, wie ich werde tun,
Jetzt, nur um wieder zurück zu unserer einfacheren Code zu gehen

307
00:16:43,860 --> 00:16:45,950
dass wir vor einem Moment hatte.

308
00:16:45,950 --> 00:16:48,790
Nun, wenn ich spare den
programmieren und ausführen,

309
00:16:48,790 --> 00:16:53,700
wird es, wieder in diesem Anfangs gehen
brechen Punkt, dass ich auf der Linie 11 hatte.

310
00:16:53,700 --> 00:16:57,700
Und ich werde in der Lage, zu prüfen sein,
meine Variablen, wie ich will, um zu tun.

311
00:16:57,700 --> 00:17:00,695
>> Es passiert einfach so, dass diese
Teil ist nicht sehr interessant,

312
00:17:00,695 --> 00:17:04,364
Und ich weiß, dass ich werde
ausdrucken diese Aussage.

313
00:17:04,364 --> 00:17:05,280
Bitte geben Sie eine Zahl ein.

314
00:17:05,280 --> 00:17:08,099
Und dann weiß ich, dass ich werde
um den Benutzer für die ganze Zahl fragen.

315
00:17:08,099 --> 00:17:13,329
Also vielleicht, habe ich eigentlich verschieben möchten meine
Haltepunkt ein wenig weiter nach unten.

316
00:17:13,329 --> 00:17:16,710
>> Sie können Haltepunkte entfernen
indem Sie wiederum direkt

317
00:17:16,710 --> 00:17:18,460
links von dieser Zeilennummer an.

318
00:17:18,460 --> 00:17:22,200
Das red dot verschwindet, wodurch angezeigt
dass diese Bruchstelle ist jetzt weg.

319
00:17:22,200 --> 00:17:24,780
Nun in diesem Fall
Ausführung wurde angehalten.

320
00:17:24,780 --> 00:17:27,770
Und so ist es nicht tatsächlich zu
wieder in diesem besonderen Fall.

321
00:17:27,770 --> 00:17:30,210
Aber ich kann eine Pause eingestellt
Punkt ein wenig später.

322
00:17:30,210 --> 00:17:33,880
>> Und wenn ich jetzt wieder meine
Code, wird es wieder aufzunehmen und zu sagen

323
00:17:33,880 --> 00:17:36,190
der Punkt dieser Bruchstelle.

324
00:17:36,190 --> 00:17:37,374
Wieder schlug ich fortsetzen.

325
00:17:37,374 --> 00:17:39,040
Mag nichts passiert zu sein scheinen.

326
00:17:39,040 --> 00:17:41,450
Aber das ist, weil mein
Code auf eine Eingabe wartet.

327
00:17:41,450 --> 00:17:47,900
Ich werde eine Reihe 5 einzugeben, drücken Sie die Eingabetaste, und
Jetzt der nächste Haltepunkt wird betroffen sein.

328
00:17:47,900 --> 00:17:50,570
>> Nun in diesem Fall diese
ist die Codezeile

329
00:17:50,570 --> 00:17:53,820
dass vor, wir wussten,
passiert fehlerhaft sein.

330
00:17:53,820 --> 00:17:57,590
Lassen Sie uns also zu beurteilen, was passiert,
an diesem bestimmten Punkt in der Zeit.

331
00:17:57,590 --> 00:18:02,620
Wenn eine Linie markiert ist, diese
Linie ist noch nicht ausgeführt worden ist.

332
00:18:02,620 --> 00:18:06,490
Also in diesem Fall, können wir sehen,
dass ich eine Nummer, die

333
00:18:06,490 --> 00:18:11,610
Ich habe eine ganze Zahl genannt
num die einen Wert 5 hat.

334
00:18:11,610 --> 00:18:15,090
Und ich werde die Durchführung
einige Mathematik auf diese Zahl.

335
00:18:15,090 --> 00:18:20,130
>> Wenn ich Schritt auf, dass, we can
feststellen, dass Sie den Wert für num

336
00:18:20,130 --> 00:18:23,780
wurde in Übereinstimmung mit dem geänderten
Arithmetik, die wir tatsächlich getan haben.

337
00:18:23,780 --> 00:18:26,810
Und jetzt, wo wir sind
dies für Schleife innerhalb

338
00:18:26,810 --> 00:18:29,090
oder jetzt, dass die for-Schleife
selbst markiert ist,

339
00:18:29,090 --> 00:18:32,450
wir sehen, dass wir eine neue
Variable i genannt, dass

340
00:18:32,450 --> 00:18:35,370
wird sich in die for-Schleife verwendet werden.

341
00:18:35,370 --> 00:18:38,230
>> Jetzt erinnere ich vor diesem
erwähnt, dass manchmal sind Sie

342
00:18:38,230 --> 00:18:43,470
gehen, um eine Art von verrückten sehen
Zahlen als Standard vor dieser Nummer

343
00:18:43,470 --> 00:18:45,530
oder die Variable
tatsächlich initialisiert.

344
00:18:45,530 --> 00:18:49,040
Das können wir genau sehen,
hier in der diese Variable

345
00:18:49,040 --> 00:18:51,345
rief ich, was nicht hat
noch initialisiert

346
00:18:51,345 --> 00:18:53,560
zum Zeitpunkt der Hervorhebung.

347
00:18:53,560 --> 00:18:57,070
Aber wir können sehen, dass es eine gewisse Anzahl
dass wir nicht wirklich erwartet.

348
00:18:57,070 --> 00:18:57,620
>> Das ist ok.

349
00:18:57,620 --> 00:18:59,661
Machen Sie sich keine Sorgen machen
denn wir haben nicht wirklich

350
00:18:59,661 --> 00:19:04,970
initialisiert die Zahl ist, bis ich
Schritt über diese Leitung und dem Wert

351
00:19:04,970 --> 00:19:08,560
i auf den Wert 1 initialisiert.

352
00:19:08,560 --> 00:19:11,400
So zu sehen, dass das ist eigentlich
der Fall ist, lassen Sie uns Schritt über.

353
00:19:11,400 --> 00:19:14,420
Wir können jetzt sehen, dass diese
Linie ausgeführt wurde.

354
00:19:14,420 --> 00:19:17,000
Und wir sind jetzt Hervorheben
Diese printf Linie.

355
00:19:17,000 --> 00:19:22,230
>> Und wir können nun sehen, wie unsere Werte
i und 3 wurden im Laufe der Zeit verändert.

356
00:19:22,230 --> 00:19:26,450
Dies ist sehr nützlich zu machen, in der Tat,
ist es, Linien wiederholt Schritt über.

357
00:19:26,450 --> 00:19:30,480
Und Sie, was tatsächlich finden
passiert im Inneren des for-Schleife

358
00:19:30,480 --> 00:19:33,660
und was passiert mit der
Variablen innerhalb der for-Schleife, dass

359
00:19:33,660 --> 00:19:39,200
so dass die Programmausführung
erfolgt ein Schritt zu einem Zeitpunkt.

360
00:19:39,200 --> 00:19:41,110
>> An diesem Punkt, I
stieg über gerade genug,

361
00:19:41,110 --> 00:19:44,210
dass ich jetzt am Ende meines Programms.

362
00:19:44,210 --> 00:19:46,980
Wenn ich Schritt auf, dass, wird es
tatsächlich Ausführung aufhören

363
00:19:46,980 --> 00:19:48,860
wie wir in der Vergangenheit gesehen haben.

364
00:19:48,860 --> 00:19:52,110
Lassen Sie mich diese neu zu starten, noch einmal, so
dass ich etwas anderes darauf hin,

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

366
00:19:53,320 --> 00:19:55,350
>> In diesem Fall ist es
Jetzt fragen mich, wieder,

367
00:19:55,350 --> 00:19:57,100
für eine Zahl, die
Ich werde wieder in Kraft.

368
00:19:57,100 --> 00:20:00,300
Aber dieses Mal werde ich in geben
eine größere Anzahl, so dass die for-Schleife

369
00:20:00,300 --> 00:20:02,540
wird mehrmals durchlaufen.

370
00:20:02,540 --> 00:20:06,090
In diesem Fall werde ich
um einen Wert von 11 eingeben.

371
00:20:06,090 --> 00:20:08,390
>> Jetzt wieder, weil ich eingestellt
einen Haltepunkt in Zeile 15,

372
00:20:08,390 --> 00:20:10,490
es geht um die Zeile zu markieren.

373
00:20:10,490 --> 00:20:12,980
Wir können sehen, dass unsere
Nummer 11 richtig ist

374
00:20:12,980 --> 00:20:15,560
in unserem lokalen Variablen vertreten.

375
00:20:15,560 --> 00:20:22,460
Stieg über das, können wir jetzt
beobachten, was passiert, um unseren Wert von i

376
00:20:22,460 --> 00:20:25,680
wie wir vorgehen Innere dieser for-Schleife.

377
00:20:25,680 --> 00:20:31,960
Es wird erhöht, jedes Mal wenn wir
erreichen die Spitze, dass for-Schleife.

378
00:20:31,960 --> 00:20:35,110
>> Jetzt eines der Dinge, das könnte
nützlich sein, um während der Ausführung zu tun

379
00:20:35,110 --> 00:20:40,490
dieses Programms ist für mich eigentlich
ändern Sie die Variablen Midstream zu sehen

380
00:20:40,490 --> 00:20:42,450
Was passiert mit meinem Programm.

381
00:20:42,450 --> 00:20:46,540
In diesem Fall kann ich eigentlich
doppelklicken Sie auf den Wert.

382
00:20:46,540 --> 00:20:48,040
Beachten Sie, dass es ein Textfeld.

383
00:20:48,040 --> 00:20:50,280
>> Jetzt kann ich verschiedene eingeben
Insgesamt schätzen

384
00:20:50,280 --> 00:20:55,700
zu sehen, wie mein Programm verhält
wenn ich diese Variable verändert.

385
00:20:55,700 --> 00:20:59,560
Nun in diesem Fall die Variable
i enthält nun den Wert 10.

386
00:20:59,560 --> 00:21:02,810
Aber das Programm noch
in der Ausführung angehalten.

387
00:21:02,810 --> 00:21:07,610
Als ich Schritt über, sehe ich, dass die
Wert i, die ich als 10 eingegeben,

388
00:21:07,610 --> 00:21:12,170
nicht größer als der Wert von num,
was bewirkt, dass unmittelbar die for-Schleife

389
00:21:12,170 --> 00:21:14,240
zu stoppen Ausführen.

390
00:21:14,240 --> 00:21:16,210
>> Nun, das ist nicht der einzige
Grund, warum Sie würde

391
00:21:16,210 --> 00:21:19,450
wollen die Variable an Stelle ändern.

392
00:21:19,450 --> 00:21:22,210
Sie könnte in der Tat wollen
zu versuchen, es so zu modifizieren

393
00:21:22,210 --> 00:21:24,590
dass Sie fortfahren können
Ausführung einer Schleife

394
00:21:24,590 --> 00:21:27,370
oder so, dass Sie ändern können
einen gewissen Wert, bevor es

395
00:21:27,370 --> 00:21:32,630
eine bestimmte Gruppe von arithmetischen erreicht
dass Sie sind dabei, das durchzuführen.

396
00:21:32,630 --> 00:21:36,210
>> So, jetzt, dass wir tatsächlich verändern die
Wert von i als das Programm ausgeführt wurde,

397
00:21:36,210 --> 00:21:39,540
es verursacht die for-Schleife zu beenden
vorzeitig wegen, ganz plötzlich, i

398
00:21:39,540 --> 00:21:42,770
passiert größer als der Wert zu sein,
von num, was bedeutet, dass die for-Schleife

399
00:21:42,770 --> 00:21:45,410
nicht mehr durchgeführt werden musste.

400
00:21:45,410 --> 00:21:48,780
Ferner kam es zu dem sein
Fall, dass wir verändert den Wert von i

401
00:21:48,780 --> 00:21:53,270
wenn die Leitung 17 wurde hervorgehoben,
die der Zeitpunkt war,

402
00:21:53,270 --> 00:21:56,280
dass die für die Schleifenausführung
tatsächlich ausgewertet wird.

403
00:21:56,280 --> 00:22:00,210
>> Wenn ich den Wert verändert
i auf einer anderen Leitung, sagen, 19,

404
00:22:00,210 --> 00:22:03,360
würden wir anders gesehen haben
Verhalten, da die Leitung 19 würde

405
00:22:03,360 --> 00:22:08,310
haben, bevor die Schleife ausgeführt wird
Bedingung wurde neu bewertet.

406
00:22:08,310 --> 00:22:11,900
Jetzt an diesem Punkt bin ich wieder,
Am Ende des Programms.

407
00:22:11,900 --> 00:22:15,707
Und ich kann zulassen, dass dies, um fortzufahren
erlauben mein Programm auf natürliche Weise zu beenden.

408
00:22:15,707 --> 00:22:18,290
Aber es gibt ein paar Dinge,
die wichtig zum Mitnehmen sind

409
00:22:18,290 --> 00:22:19,960
von diesem besonderen Diskussion.

410
00:22:19,960 --> 00:22:22,490
Sie brauchen, um zu bewerten
Ihre eigenen Annahmen

411
00:22:22,490 --> 00:22:24,710
darüber, wie der Code sollte sein Verhalten.

412
00:22:24,710 --> 00:22:28,220
Jedes Mal, wenn Sie denken, dass einige Stück
der Code, den Sie wissen, kommt, um zu arbeiten,

413
00:22:28,220 --> 00:22:30,940
das könnte eine rote Fahne zu gehen
Rücken und zu bewerten, und sicher sein,

414
00:22:30,940 --> 00:22:33,470
dass Ihre Annahme
wie das Code-Betriebs

415
00:22:33,470 --> 00:22:38,290
tatsächlich wahr ist, wie es ist
im Quellcode zum Ausdruck gebracht.

416
00:22:38,290 --> 00:22:41,300
>> Aber noch mehr, um Punkt war,
wenn wir mit dem Debugger,

417
00:22:41,300 --> 00:22:43,920
Sie können Haltepunkte setzen bei
verschiedene Codezeilen,

418
00:22:43,920 --> 00:22:48,110
welche den Debugger, um zu bewirken wird
unterbrechen die Ausführung an jeder dieser Linien

419
00:22:48,110 --> 00:22:52,210
so dass Sie die zu bewerten
Speicher oder sogar ändern Sie sie fest.

420
00:22:52,210 --> 00:22:55,630
Und wieder, denken Sie daran, dass Sie
erstellen Sie mehrere Haltepunkte, so dass Sie

421
00:22:55,630 --> 00:23:00,390
kann auch die Ausführung wieder aufzunehmen, überspringen
über große Teile des Codes,

422
00:23:00,390 --> 00:23:04,790
und es wird automatisch angehalten
bei der nächsten Haltepunkt.

423
00:23:04,790 --> 00:23:07,760
>> Es gibt tatsächlich fortgeschrittenere
Features des Debuggers, wie gut.

424
00:23:07,760 --> 00:23:10,170
Aber wir müssen Sie sich beziehen
zu einigen nachfolgenden Videos

425
00:23:10,170 --> 00:23:14,090
um wirklich zu necken auseinander, wie
, jene besondere Funktionen zu nutzen.

426
00:23:14,090 --> 00:23:15,990
Denn jetzt, danke
Dank für das Aufpassen.

427
00:23:15,990 --> 00:23:18,080
Und viel Glück Debugging.