1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Woche 4]

2
00:00:03,000 --> 00:00:05,000
[David J. Malan] [Harvard University]

3
00:00:05,000 --> 00:00:08,000
[Dies ist CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Alle Rechte, ist dies CS50, und dies ist der Beginn der Woche 4

5
00:00:12,000 --> 00:00:16,000
und dies ist einer der langsamsten möglichen Sortieralgorithmen.

6
00:00:16,000 --> 00:00:19,000
Welches war es, dass wir nur zugesehen da?

7
00:00:19,000 --> 00:00:24,000
Das war bubble sort, um big O (n ^ 2) + Summe,

8
00:00:24,000 --> 00:00:28,000
und in der Tat sind wir nicht die einzigen, die in dieser Welt scheinen zu wissen,

9
00:00:28,000 --> 00:00:30,000
Welche bubble sort ist oder dessen Laufzeit.

10
00:00:30,000 --> 00:00:33,000
In der Tat war dies ein Interview mit Eric Schmidt von Google

11
00:00:33,000 --> 00:00:45,000
und ehemaliger Senator Barack Obama nur ein paar Jahre her.

12
00:00:45,000 --> 00:00:48,000
>> Nun, Senator, sind Sie hier bei Google,

13
00:00:48,000 --> 00:00:54,000
und Ich mag die Präsidentschaft als ein Vorstellungsgespräch zu denken.

14
00:00:54,000 --> 00:00:58,000
Nun, es ist schwer, einen Job als Präsident bekommen, und du bist durch die Strapazen gehe jetzt.

15
00:00:58,000 --> 00:01:00,000
Es ist auch schwer, einen Job bei Google zu bekommen.

16
00:01:00,000 --> 00:01:05,000
Wir haben Fragen, und wir bitten unsere Kandidaten Fragen,

17
00:01:05,000 --> 00:01:10,000
und dieses ist von Larry Schwimmer.

18
00:01:10,000 --> 00:01:14,000
You guys glaube, ich bin ein Scherz? Es ist hier genau richtig.

19
00:01:14,000 --> 00:01:18,000
Was ist der effizienteste Weg, um eine Million 32-Bit-Integer sortieren?

20
00:01:18,000 --> 00:01:21,000
[Gelächter]

21
00:01:21,000 --> 00:01:24,000
Well-

22
00:01:24,000 --> 00:01:26,000
Es tut mir leid. >> Nein, nein, nein, nein.

23
00:01:26,000 --> 00:01:34,000
Ich denke, die bubble sort wäre der falsche Weg zu gehen.

24
00:01:34,000 --> 00:01:39,000
>> Come on, der ihm sagte, diese?

25
00:01:39,000 --> 00:01:43,000
Letzte Woche erinnern wir uns eine Pause von Code, zumindest für einen Tag,

26
00:01:43,000 --> 00:01:46,000
und begann mit Schwerpunkt auf einigen höherrangigen Ideen und Problemlösungen allgemein

27
00:01:46,000 --> 00:01:49,000
im Rahmen der Suche und Sortierung,

28
00:01:49,000 --> 00:01:53,000
und wir stellten etwas, das wir nicht zu schlagen diesen Namen auf letzte Woche,

29
00:01:53,000 --> 00:01:56,000
aber asymptotische Notation, die Big O, der Big Omega,

30
00:01:56,000 --> 00:02:00,000
und manchmal auch die Big Theta-Notation, und diese waren einfach Möglichkeiten

31
00:02:00,000 --> 00:02:02,000
beschreiben die Laufzeit von Algorithmen,

32
00:02:02,000 --> 00:02:05,000
wie viel Zeit für einen Algorithmus zum Ausführen dauert.

33
00:02:05,000 --> 00:02:08,000
>> Und Sie erinnern sich vielleicht, dass Sie über die Laufzeit sprach in Bezug auf die Größe

34
00:02:08,000 --> 00:02:11,000
des Eingangs, die wir allgemein n, was das Problem sein kann,

35
00:02:11,000 --> 00:02:13,000
wobei n die Anzahl der Personen im Raum,

36
00:02:13,000 --> 00:02:17,000
die Anzahl der Seiten in einem Telefonbuch, und wir begannen, die Dinge schreiben,

37
00:02:17,000 --> 00:02:21,000
wie O (n ^ 2) oder O (n) oder O (n log n),

38
00:02:21,000 --> 00:02:24,000
und selbst wenn die Mathematik nicht so recht geklappt so perfekt

39
00:02:24,000 --> 00:02:28,000
und es war n ² - n / 2 oder so ähnlich

40
00:02:28,000 --> 00:02:31,000
würden wir statt einfach wegwerfen einige der Terme niedrigerer Ordnung,

41
00:02:31,000 --> 00:02:34,000
und die Motivation es ist, dass wir wirklich einen

42
00:02:34,000 --> 00:02:37,000
Art objektive Art und Weise der Auswertung

43
00:02:37,000 --> 00:02:39,000
die Leistung der Programme oder die Leistung der Algorithmen

44
00:02:39,000 --> 00:02:42,000
dass am Ende des Tages nichts zu tun hat, beispielsweise

45
00:02:42,000 --> 00:02:45,000
mit der Geschwindigkeit Ihres Computers heute.

46
00:02:45,000 --> 00:02:47,000
>> Zum Beispiel, wenn Sie bei der Umsetzung bubble sort,

47
00:02:47,000 --> 00:02:50,000
oder Sie implementieren Mergesort oder Auswahl Art auf der heutigen Computer,

48
00:02:50,000 --> 00:02:53,000
ein 2 GHz Computer, und Sie laufen lassen,

49
00:02:53,000 --> 00:02:56,000
und es dauert eine gewisse Anzahl von Sekunden, im nächsten Jahr gibt es einen 3 GHz

50
00:02:56,000 --> 00:02:59,000
oder eine 4 GHz Computer, und man könnte dann behaupten, dass "Wow, mein Algorithmus

51
00:02:59,000 --> 00:03:03,000
ist jetzt doppelt so schnell ", wenn in Wirklichkeit die offensichtlich nicht der Fall ist.

52
00:03:03,000 --> 00:03:06,000
Es ist nur die Hardware ist mittlerweile schneller, aber Ihr Computer

53
00:03:06,000 --> 00:03:10,000
nicht, und so wollen wir wirklich wegwerfen Dinge wie

54
00:03:10,000 --> 00:03:13,000
Vielfache von 2 oder ein Vielfaches von 3, wenn es um die Beschreibung kommt

55
00:03:13,000 --> 00:03:17,000
wie schnell oder wie langsam ein Algorithmus ist und wirklich nur zu konzentrieren

56
00:03:17,000 --> 00:03:20,000
auf n oder einem Faktor davon,

57
00:03:20,000 --> 00:03:24,000
etwas Strom davon, wie in dem Fall der Art von den letzten Wochen.

58
00:03:24,000 --> 00:03:27,000
Und daran erinnern, dass mit Hilfe von Mergesort

59
00:03:27,000 --> 00:03:31,000
konnten wir so viel besser als bubble sort und Auswahl sort

60
00:03:31,000 --> 00:03:33,000
und sogar insertion sort.

61
00:03:33,000 --> 00:03:36,000
>> Wir haben bis zu n log n, und wieder

62
00:03:36,000 --> 00:03:39,000
daran erinnern, dass log n in der Regel bezieht sich auf etwas, das wächst

63
00:03:39,000 --> 00:03:43,000
langsamer, dann n, so n log n bisher war gut

64
00:03:43,000 --> 00:03:45,000
denn es war weniger als n ².

65
00:03:45,000 --> 00:03:47,000
Aber zu erreichen n log n mit Mergesort

66
00:03:47,000 --> 00:03:51,000
was war der Grund Keim einer Idee, die wir nutzen mussten

67
00:03:51,000 --> 00:03:54,000
dass wir auch wieder in Woche 0 genutzt?

68
00:03:54,000 --> 00:03:58,000
Wie haben wir bekämpfen die Sortierung Problem geschickt mit Mergesort?

69
00:03:58,000 --> 00:04:04,000
Was war die wichtigste Erkenntnis, vielleicht?

70
00:04:04,000 --> 00:04:07,000
Wer überhaupt.

71
00:04:07,000 --> 00:04:09,000
Okay, lassen Sie uns einen Schritt zurück.

72
00:04:09,000 --> 00:04:11,000
Beschreiben Mergesort in Ihren eigenen Worten.

73
00:04:11,000 --> 00:04:15,000
Wie hat es funktioniert?

74
00:04:15,000 --> 00:04:17,000
Okay, wir rudern zurück zur Woche 0.

75
00:04:17,000 --> 00:04:19,000
Okay, yeah.

76
00:04:19,000 --> 00:04:22,000
[Unverständlich-Student]

77
00:04:22,000 --> 00:04:26,000
Okay, gut, so teilten wir die Anordnung von Zahlen in 2 Stücke.

78
00:04:26,000 --> 00:04:29,000
Wir sortierten jedes dieser Stücke, und dann werden wir fusionierte sie,

79
00:04:29,000 --> 00:04:33,000
und wir haben diese Idee schon einmal gesehen zu nehmen ein Problem, das diese groß ist

80
00:04:33,000 --> 00:04:36,000
und Hacken es zu einem Problem, das dieser große oder diese groß ist.

81
00:04:36,000 --> 00:04:38,000
>> Rufen Sie das Telefonbuch Beispiel.

82
00:04:38,000 --> 00:04:42,000
Rufen Sie den Selbst-Zählung Algorithmus Wochen

83
00:04:42,000 --> 00:04:45,000
so Mergesort wurde von diesem Pseudocode hier zusammengefasst.

84
00:04:45,000 --> 00:04:48,000
Wenn Sie n Elemente sind gegeben, zuerst war es Plausibilitätsprüfung.

85
00:04:48,000 --> 00:04:51,000
Wenn n <2 dann nicht überhaupt etwas tun

86
00:04:51,000 --> 00:04:55,000
denn wenn n <2 ist, dann n 0 oder 1 ist offensichtlich,

87
00:04:55,000 --> 00:04:57,000
und so, wenn es entweder ist 0 oder 1 gibt es nichts zu sortieren.

88
00:04:57,000 --> 00:04:59,000
Du bist fertig.

89
00:04:59,000 --> 00:05:01,000
Ihre Liste ist bereits trivial sortiert.

90
00:05:01,000 --> 00:05:04,000
Aber sonst, wenn du hast 2 oder mehr Elementen gehen Sie vor und teilen sie

91
00:05:04,000 --> 00:05:06,000
in 2 Hälften, links und rechts.

92
00:05:06,000 --> 00:05:09,000
Sortieren jede dieser Hälften, und dann verschmelzen die sortierten Hälften.

93
00:05:09,000 --> 00:05:13,000
Aber das Problem dabei ist, dass auf den ersten Blick, wie wir punting sind anfühlt.

94
00:05:13,000 --> 00:05:17,000
Dies ist eine zirkuläre Definition, dass, wenn ich dich gebeten habe, diese n Elemente zu sortieren

95
00:05:17,000 --> 00:05:22,000
und du willst mir erzählen, "Alles klar, gut, wir diese n / 2 und die n / 2 Elemente sortieren"

96
00:05:22,000 --> 00:05:27,000
dann meine nächste Frage sein wird "Fine, wie sehen Sie die n / 2 Elemente zu sortieren?"

97
00:05:27,000 --> 00:05:30,000
>> Aber aufgrund der Struktur dieses Programms,

98
00:05:30,000 --> 00:05:33,000
weil es zu diesem Basismodell, so zu sprechen,

99
00:05:33,000 --> 00:05:39,000
diesem speziellen Fall, dass, wenn n <Einige festen Wert wie 2 Rückkehr sofort sagt.

100
00:05:39,000 --> 00:05:42,000
Nicht mit dem gleichen kreisförmigen Antwort reagieren.

101
00:05:42,000 --> 00:05:46,000
Dieser Prozess wird diese Zyklizität schließlich am Ende.

102
00:05:46,000 --> 00:05:50,000
Wenn ich Sie "Sortieren diese n Elemente" zu stellen und Sie sagen: "Fine, sortieren diese n / 2,"

103
00:05:50,000 --> 00:05:53,000
dann sagen Sie, "Fine, sortieren diese n / 4, n / 8, N/16"

104
00:05:53,000 --> 00:05:56,000
schließlich werden Sie von einem großen genug Zahl dividieren

105
00:05:56,000 --> 00:05:59,000
dass Sie haben nur 1 Element links, an welchem ​​Punkt kann man sagen,

106
00:05:59,000 --> 00:06:02,000
"Hier, hier ist eine sortierte einzelnes Element."

107
00:06:02,000 --> 00:06:06,000
Dann die Brillanz dieses Algorithmus hier oben ist aus der Tatsache abzuleiten

108
00:06:06,000 --> 00:06:09,000
dass, sobald Sie haben alle diese einzeln sortierten Listen,

109
00:06:09,000 --> 00:06:12,000
von denen alle von der Größe 1, welches sich als nutzlos scheint,

110
00:06:12,000 --> 00:06:15,000
sobald Sie anfangen, ihre Zusammenlegung und ihre Zusammenlegung

111
00:06:15,000 --> 00:06:19,000
Sie bauen schließlich als Rob hat in dem Video ein finally sortierte Liste.

112
00:06:19,000 --> 00:06:22,000
>> Aber diese Idee weit über Sortierung.

113
00:06:22,000 --> 00:06:26,000
Es ist diese Idee in diesem Programm als Rekursion bezeichnet eingebettet,

114
00:06:26,000 --> 00:06:29,000
die Idee, wodurch Sie ein Programm,

115
00:06:29,000 --> 00:06:32,000
und ein Problem nennen Sie sich zu lösen,

116
00:06:32,000 --> 00:06:36,000
oder im Kontext von Programmiersprachen Sie sind eine Funktion setzen,

117
00:06:36,000 --> 00:06:39,000
und um ein Problem zu lösen, können Sie die Funktion nennen sich

118
00:06:39,000 --> 00:06:42,000
wieder und wieder und wieder, aber Sie die Funktion

119
00:06:42,000 --> 00:06:44,000
können nicht nennen sich unendlich oft.

120
00:06:44,000 --> 00:06:47,000
Irgendwann muss man die Talsohle, so zu sprechen,

121
00:06:47,000 --> 00:06:49,000
und haben einige hartcodierte base Zustand, sagt

122
00:06:49,000 --> 00:06:53,000
an dieser Stelle aufhören, sich so, dass der gesamte Prozess

123
00:06:53,000 --> 00:06:56,000
Schließlich ist in der Tat zu stoppen.

124
00:06:56,000 --> 00:06:58,000
Was bedeutet das eigentlich, um recurse?

125
00:06:58,000 --> 00:07:01,000
>> Mal sehen, ob wir eine einfache, triviale Beispiel mit tun können, sagen wir,

126
00:07:01,000 --> 00:07:03,000
3 Leute mit mir hier oben auf der Bühne, wenn jemand ist komfortabel.

127
00:07:03,000 --> 00:07:06,000
1, auf bis, 2 und 3 kommen.

128
00:07:06,000 --> 00:07:09,000
Wenn Sie 3 bis hier herauf kommen wollen.

129
00:07:09,000 --> 00:07:12,000
Wenn Sie direkt stehen, um mich hier in einer Linie wollen, nehme an, dass das Problem an der Hand

130
00:07:12,000 --> 00:07:15,000
ist sehr trivial zählen die Anzahl der Menschen, die hier sind.

131
00:07:15,000 --> 00:07:18,000
Aber ehrlich gesagt, ich bin müde von all diesen zählen Beispiele.

132
00:07:18,000 --> 00:07:21,000
Das wird einige Zeit dauern, 1, 2 und Punkt, Punkt, Punkt zu nehmen.

133
00:07:21,000 --> 00:07:23,000
Es wird ewig dauern.

134
00:07:23,000 --> 00:07:25,000
Ich würde lieber nur punt dieses Problem überhaupt mit Hilfe der-wie ist dein Name?

135
00:07:25,000 --> 00:07:27,000
Sara. >> Sara, alles in Ordnung.

136
00:07:27,000 --> 00:07:29,000
Kelly. >> Kelly und?

137
00:07:29,000 --> 00:07:31,000
>> Willy. >> Willy, Sara, Kelly und Willy.

138
00:07:31,000 --> 00:07:34,000
Im Moment habe ich die Frage von jemandem gefragt,

139
00:07:34,000 --> 00:07:37,000
wie viele Menschen auf dieser Stufe, und ich habe keine Ahnung.

140
00:07:37,000 --> 00:07:40,000
Dies ist eine wirklich lange Liste, und so statt Ich werde diesen Trick zu tun.

141
00:07:40,000 --> 00:07:43,000
Ich werde die Person neben mir die meiste Arbeit tun, fragen,

142
00:07:43,000 --> 00:07:46,000
und sobald sie getan wird dabei die meiste Arbeit

143
00:07:46,000 --> 00:07:49,000
Ich werde die geringste Menge an Arbeit zu tun und fügen Sie einfach 1

144
00:07:49,000 --> 00:07:51,000
um was ihre Antwort ist, so here we go.

145
00:07:51,000 --> 00:07:54,000
Ich bin gebeten worden, wie viele Menschen auf der Bühne.

146
00:07:54,000 --> 00:07:57,000
Wie viele Menschen sind auf der Bühne nach links von euch?

147
00:07:57,000 --> 00:08:00,000
Die links von mir? >> Okay, aber nicht zu betrügen.

148
00:08:00,000 --> 00:08:04,000
Das ist gut, das ist richtig, aber wenn wir wollen, diese Logik weiter

149
00:08:04,000 --> 00:08:08,000
Lassen Sie uns annehmen, dass Sie ähnlich wollen punt dieses Problem auf der linken Seite von Ihnen,

150
00:08:08,000 --> 00:08:11,000
so als Antwort direkt vor gehen und nur die Schuld zuschieben.

151
00:08:11,000 --> 00:08:14,000
Oh, wie viele Menschen sind auf der linken Seite von mir?

152
00:08:14,000 --> 00:08:16,000
Wie viele Menschen sind auf der linken Seite?

153
00:08:16,000 --> 00:08:18,000
Ein.

154
00:08:18,000 --> 00:08:27,000
[Gelächter]

155
00:08:27,000 --> 00:08:30,000
Okay, so 0, so was nun Willy getan hat

156
00:08:30,000 --> 00:08:33,000
ist du hast wieder deine Antwort in diese Richtung sagen 0.

157
00:08:33,000 --> 00:08:36,000
Nun, was sollte man tun? >> 1.

158
00:08:36,000 --> 00:08:39,000
Okay, so dass Sie die 1 sind, so dass Sie sagen: "Alles klar, werde ich hinzu: 1

159
00:08:39,000 --> 00:08:41,000
um unabhängig von Willy Graf war, "so 1 + 0.

160
00:08:41,000 --> 00:08:43,000
Du bist jetzt ein so Ihre Antwort auf der rechten Seite ist jetzt

161
00:08:43,000 --> 00:08:45,000
1. >> Und mir würde 2 sein.

162
00:08:45,000 --> 00:08:48,000
Gut, so nimmst du die vorherige Antwort von 1,

163
00:08:48,000 --> 00:08:51,000
Hinzufügen die minimale Menge an Arbeit, die Sie tun möchten, ist die +1.

164
00:08:51,000 --> 00:08:55,000
Sie haben nun 2, und Sie dann gib mir welchen Wert?

165
00:08:55,000 --> 00:08:57,000
3, meine ich, sorry, 2.

166
00:08:57,000 --> 00:08:59,000
Gut.

167
00:08:59,000 --> 00:09:02,000
>> Nun, wir hatten 0 nach links.

168
00:09:02,000 --> 00:09:05,000
Dann hatten wir ein, und dann fügen wir 2,

169
00:09:05,000 --> 00:09:07,000
und jetzt bist du reichte mir die Nummer 2

170
00:09:07,000 --> 00:09:10,000
und so sage ich, okay, +1, 3.

171
00:09:10,000 --> 00:09:13,000
Es gibt ja 3 Personen neben mir auf der Bühne,

172
00:09:13,000 --> 00:09:16,000
so konnten wir natürlich getan haben dies sehr linear,

173
00:09:16,000 --> 00:09:19,000
sehr viel in der Hand Mode, aber was wir wirklich tun?

174
00:09:19,000 --> 00:09:21,000
Wir haben ein Problem der Größe 3 zunächst.

175
00:09:21,000 --> 00:09:24,000
Wir haben dann brach es sich in ein Problem der Größe 2,

176
00:09:24,000 --> 00:09:27,000
dann ein Problem der Größe 1, und dann schließlich die Base-Case-

177
00:09:27,000 --> 00:09:29,000
war wirklich, oh, es ist niemand da,

178
00:09:29,000 --> 00:09:33,000
an welcher Stelle Willy kehrte effektiv eine hartcodierte Antwort ein paar Mal,

179
00:09:33,000 --> 00:09:36,000
und die zweite wurde dann, sprudelte, sprudelte sprudelte,

180
00:09:36,000 --> 00:09:39,000
und dann durch Zugabe von in diesem einen zusätzlichen 1

181
00:09:39,000 --> 00:09:41,000
Wir haben diese Grundidee der Rekursion implementiert.

182
00:09:41,000 --> 00:09:44,000
>> Nun, in diesem Fall ist es nicht wirklich ein Problem zu lösen

183
00:09:44,000 --> 00:09:46,000
mehr effektiv dann haben wir bisher gesehen.

184
00:09:46,000 --> 00:09:48,000
Aber über die Algorithmen, die wir auf der Bühne gemacht habe bisher denken.

185
00:09:48,000 --> 00:09:51,000
Wir hatten 8 Stück Papier an die Tafel,

186
00:09:51,000 --> 00:09:55,000
auf Video, als Sean wurde für die Zahl 7 suchen, und was hat er wirklich?

187
00:09:55,000 --> 00:09:58,000
Nun, er nicht jede Art von Teile und Herrsche.

188
00:09:58,000 --> 00:10:01,000
Er tat es nicht jede Art von Rekursion.

189
00:10:01,000 --> 00:10:03,000
Vielmehr ist er gerade tat diese lineare Algorithmus.

190
00:10:03,000 --> 00:10:07,000
Aber wenn wir die Idee von sortierten Zahlen auf Stufe eingeführt leben letzten Woche

191
00:10:07,000 --> 00:10:09,000
dann hatten wir diesen Instinkt zu gehen bis in die Mitte,

192
00:10:09,000 --> 00:10:13,000
An diesem Punkt hatten wir eine kleinere Liste der Größe 4 oder einer anderen Liste der Größe 4,

193
00:10:13,000 --> 00:10:17,000
und dann haben wir genau das gleiche Problem hatten, so dass wir wiederholt, wiederholt, wiederholt.

194
00:10:17,000 --> 00:10:19,000
Mit anderen Worten, wir rekursiv.

195
00:10:19,000 --> 00:10:24,000
Vielen Dank an unsere 3 Freiwilligen hier zur Demonstration Rekursion mit uns.

196
00:10:24,000 --> 00:10:28,000
>> Lasst uns sehen, ob wir nicht machen dies nun ein wenig konkreter,

197
00:10:28,000 --> 00:10:30,000
ein Problem zu lösen, dass wir wieder konnte ziemlich leicht tun,

198
00:10:30,000 --> 00:10:34,000
aber wir werden es als ein Sprungbrett für die Umsetzung dieser Grundidee verwenden.

199
00:10:34,000 --> 00:10:37,000
Wenn ich will, um die Summierung einer Reihe von Zahlen zu berechnen,

200
00:10:37,000 --> 00:10:39,000
zum Beispiel, wenn Sie passieren in der Nummer 3,

201
00:10:39,000 --> 00:10:42,000
Ich möchte Ihnen den Wert von Sigma 3,

202
00:10:42,000 --> 00:10:46,000
so dass die Summe von 3 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
Ich will wieder die Antwort 6,

204
00:10:48,000 --> 00:10:51,000
so dass wir implementieren diese sigma Funktion, diese Summenfunktion

205
00:10:51,000 --> 00:10:54,000
dass wiederum nimmt im Eingang, und kehrt dann die Summation

206
00:10:54,000 --> 00:10:57,000
dieser Zahl den ganzen Weg hinunter auf 0 gesetzt.

207
00:10:57,000 --> 00:10:59,000
Wir könnten dies ziemlich einfach zu tun, nicht wahr?

208
00:10:59,000 --> 00:11:01,000
Wir könnten dies mit irgendeiner Art von looping Struktur zu tun,

209
00:11:01,000 --> 00:11:04,000
so lassen Sie mich gehen Sie vor und bekomme gestartet.

210
00:11:04,000 --> 00:11:07,000
>> Include stdio.h.

211
00:11:07,000 --> 00:11:09,000
Lassen Sie mich mich in Haupt mit hier zu arbeiten.

212
00:11:09,000 --> 00:11:12,000
Retten wir dies als sigma.c.

213
00:11:12,000 --> 00:11:14,000
Dann werde ich hier, und ich werde einen int n erklären,

214
00:11:14,000 --> 00:11:18,000
und ich werde Folgendes tun, während der Benutzer nicht kooperiert.

215
00:11:18,000 --> 00:11:22,000
Während der Benutzer hat mir nicht eine positive Zahl

216
00:11:22,000 --> 00:11:26,000
Lassen Sie mich gehen Sie vor und fordert sie für n = GetInt,

217
00:11:26,000 --> 00:11:28,000
und lassen Sie mich ihnen einige Anweisungen, was zu tun ist,

218
00:11:28,000 --> 00:11:33,000
so printf ("Positive Ganzzahl bitte").

219
00:11:33,000 --> 00:11:39,000
Nur etwas relativ einfach wie diese, so dass durch die Zeit, die wir Zeile 14 getroffen

220
00:11:39,000 --> 00:11:42,000
wir haben jetzt eine positive ganze Zahl vermutlich in n.

221
00:11:42,000 --> 00:11:44,000
>> Jetzt machen wir etwas mit ihm.

222
00:11:44,000 --> 00:11:50,000
Lassen Sie mich gehen Sie vor und berechnet die Summe, so int sum = sigma (n).

223
00:11:50,000 --> 00:11:54,000
Sigma ist nur Summation, so Ich schreibe es in der ausgefalleneren Art und Weise.

224
00:11:54,000 --> 00:11:56,000
Wir nennen es einfach sigma gibt.

225
00:11:56,000 --> 00:11:58,000
Das ist die Summe, und jetzt werde ich zum Ausdrucken des Ergebnisses,

226
00:11:58,000 --> 00:12:08,000
printf ("Die Summe ist% d \ n", sum).

227
00:12:08,000 --> 00:12:11,000
Und dann werde ich 0 für eine gute Maßnahme zurück.

228
00:12:11,000 --> 00:12:15,000
Wir haben alles, was dieses Programm erfordert außer der interessanteste Teil getan,

229
00:12:15,000 --> 00:12:18,000
was tatsächlich umzusetzen den sigma-Funktion.

230
00:12:18,000 --> 00:12:22,000
>> Lassen Sie mich gehen hier unten auf den Boden, und lassen Sie mich erklären, Funktion sigma.

231
00:12:22,000 --> 00:12:26,000
Es muss eine Variable vom Typ integer ist zu nehmen,

232
00:12:26,000 --> 00:12:30,000
und was Datentyp will ich vermutlich wieder von Sigma?

233
00:12:30,000 --> 00:12:34,000
Int, weil ich es zu meinen Erwartungen on line 15 entsprechen soll.

234
00:12:34,000 --> 00:12:37,000
Hier lassen Sie mich gehen Sie vor und implementieren diese

235
00:12:37,000 --> 00:12:41,000
in einem hübschen unkompliziert.

236
00:12:41,000 --> 00:12:45,000
>> Fahren wir fort und sagen int sum = 0,

237
00:12:45,000 --> 00:12:47,000
und jetzt werde ich gehen ein wenig for-Schleife hier

238
00:12:47,000 --> 00:12:50,000
das wird so etwas sagen,

239
00:12:50,000 --> 00:13:01,000
for (int i = 0; i <= Zahl; i + +) sum + = i.

240
00:13:01,000 --> 00:13:05,000
Und dann werde ich Betrag zurückzuerstatten.

241
00:13:05,000 --> 00:13:07,000
Ich konnte dies in irgendeiner Anzahl von Arten implementiert sein.

242
00:13:07,000 --> 00:13:09,000
Ich konnte eine while-Schleife verwendet haben.

243
00:13:09,000 --> 00:13:11,000
Ich konnte übersprungen Verwendung der Summe Variable, wenn ich wirklich wollte zu haben,

244
00:13:11,000 --> 00:13:15,000
aber kurz, wir haben nur eine Funktion, wenn ich nicht goof erklärt Summe 0 ist.

245
00:13:15,000 --> 00:13:18,000
Dann durchläuft von 0 auf bis über die Anzahl,

246
00:13:18,000 --> 00:13:23,000
und bei jeder Iteration fügt es, dass die gegenwärtige Wert Summe und kehrt dann Summe.

247
00:13:23,000 --> 00:13:25,000
>> Jetzt gibt es eine leichte Optimierung hier.

248
00:13:25,000 --> 00:13:29,000
Dies ist wahrscheinlich eine Verschwendung Schritt, aber es so sein. Das ist jetzt in Ordnung.

249
00:13:29,000 --> 00:13:32,000
Wir sind zumindest ist gründlich und gehen 0 den ganzen Weg rauf.

250
00:13:32,000 --> 00:13:34,000
Nicht sehr hart und ziemlich einfach,

251
00:13:34,000 --> 00:13:37,000
aber es stellt sich heraus, dass mit dem Sigma-Funktion, die wir die gleichen Chancen haben,

252
00:13:37,000 --> 00:13:39,000
wie wir es hier getan habe auf der Bühne.

253
00:13:39,000 --> 00:13:42,000
Auf der Bühne haben wir nur gezählt, wie viele Leute waren neben mir,

254
00:13:42,000 --> 00:13:47,000
sondern wenn wir wollten, um die Zahl 3 + 2 + 1 zu zählen

255
00:13:47,000 --> 00:13:51,000
auf bis zu 0 könnten wir ähnlich punt zu einer Funktion

256
00:13:51,000 --> 00:13:55,000
dass ich statt als rekursive beschreiben.

257
00:13:55,000 --> 00:13:57,000
Hier wollen wir tun, eine schnelle Vernunft und zu überprüfen, damit ich nicht goof.

258
00:13:57,000 --> 00:14:00,000
>> Ich weiß, es ist zumindest eine Sache in diesem Programm, dass ich falsch gemacht habe.

259
00:14:00,000 --> 00:14:04,000
Wenn ich in traf ich werde jede Art von schrie mich bekommen?

260
00:14:04,000 --> 00:14:06,000
Was mache ich bei etwa werden angeschrien?

261
00:14:06,000 --> 00:14:11,000
Ja, ich den Prototyp vergessen, so verwende ich eine Funktion namens Sigma on line 15,

262
00:14:11,000 --> 00:14:16,000
aber es ist nicht bis Zeile 22 deklariert, so dass ich am besten proaktiv gehen hier

263
00:14:16,000 --> 00:14:22,000
und erklären, ein Prototyp, und ich werde int sigma (int number) sagen, und das ist es.

264
00:14:22,000 --> 00:14:24,000
Es ist an der Unterseite umgesetzt.

265
00:14:24,000 --> 00:14:27,000
>> Oder eine andere Art, wie ich dieses Problem lösen könnte,

266
00:14:27,000 --> 00:14:30,000
Ich konnte die Funktion dort oben zu bewegen, das ist nicht schlecht,

267
00:14:30,000 --> 00:14:32,000
aber zumindest, wenn Ihre Programme zu starten, um lange, ehrlich gesagt,

268
00:14:32,000 --> 00:14:35,000
Ich denke, es gibt einige Wert in immer mit Haupt an der Spitze

269
00:14:35,000 --> 00:14:38,000
so dass Sie in der Leser kann die Datei öffnen und dann sofort sehen,

270
00:14:38,000 --> 00:14:40,000
was das Programm, ohne sich durch sie zu suchen dabei

271
00:14:40,000 --> 00:14:42,000
Suche nach dem main-Funktion.

272
00:14:42,000 --> 00:14:49,000
Wir gehen hinunter zu meinem Terminal-Fenster hier, versuchen Sie, sigma machen sigma,

273
00:14:49,000 --> 00:14:51,000
und ich vermasselt auch hier.

274
00:14:51,000 --> 00:14:55,000
Implizite Deklaration der Funktion GetInt heißt, ich habe vergessen, was tun?

275
00:14:55,000 --> 00:14:57,000
[Unverständlich-Student]

276
00:14:57,000 --> 00:15:00,000
Gut, so scheint ein weit verbreiteter Irrtum, so lasst uns dieses hier,

277
00:15:00,000 --> 00:15:04,000
cs50.h, und jetzt gehen wir zurück zu meinem Terminal-Fenster.

278
00:15:04,000 --> 00:15:08,000
>> Ich werde den Bildschirm, und ich werde erneut machen sigma.

279
00:15:08,000 --> 00:15:11,000
Es scheint zusammengestellt. Lassen Sie mich jetzt laufen sigma.

280
00:15:11,000 --> 00:15:15,000
Ich werde in der Nummer 3 geben, und ich habe 6 erhalten, so dass nicht eine strenge Prüfung,

281
00:15:15,000 --> 00:15:18,000
aber zumindest scheint es auf den ersten Blick zu arbeiten, aber jetzt wollen wir zerreißen sie auseinander,

282
00:15:18,000 --> 00:15:21,000
und lasst uns tatsächlich nutzen die Idee der Rekursion wieder

283
00:15:21,000 --> 00:15:24,000
in einer sehr einfachen Rahmen, so dass in ein paar Wochen Zeit,

284
00:15:24,000 --> 00:15:27,000
wenn wir erkunden schicker Datenstrukturen als Arrays

285
00:15:27,000 --> 00:15:30,000
Wir haben ein anderes Werkzeug im Toolkit, mit dem

286
00:15:30,000 --> 00:15:33,000
Bearbeitung dieser Datenstrukturen wie wir sehen werden.

287
00:15:33,000 --> 00:15:36,000
Dies ist die iterative Vorgehensweise, die Schleife Ansatz.

288
00:15:36,000 --> 00:15:39,000
>> Lassen Sie mich statt jetzt tun.

289
00:15:39,000 --> 00:15:44,000
Lassen Sie mich stattdessen sagen, dass die Summe der Anzahl

290
00:15:44,000 --> 00:15:48,000
auf bis zu 0 ist wirklich das gleiche wie

291
00:15:48,000 --> 00:15:53,000
Nummer + sigma (Anzahl - 1).

292
00:15:53,000 --> 00:15:57,000
In anderen Worten, genau wie auf der Bühne I zu jedem der Leute neben mir punted,

293
00:15:57,000 --> 00:16:00,000
und sie wiederum hielt punting bis wir die Talsohle endlich bei Willy,

294
00:16:00,000 --> 00:16:03,000
Wer hatte einen hartcodierten Antwort wie 0 zurück.

295
00:16:03,000 --> 00:16:07,000
Hier nun sind wir ähnlich punting zu Sigma

296
00:16:07,000 --> 00:16:10,000
die gleiche Funktion wie hieß ursprünglich, aber die wichtigste Erkenntnis hier

297
00:16:10,000 --> 00:16:12,000
ist, dass wir nicht anlaufen sigma identisch.

298
00:16:12,000 --> 00:16:14,000
Wir sind nicht auf und übergibt n.

299
00:16:14,000 --> 00:16:17,000
Wir deutlich vorbei an der Zahl - 1,

300
00:16:17,000 --> 00:16:20,000
so ein etwas kleineres Problem, geringfügig kleiner Problem.

301
00:16:20,000 --> 00:16:23,000
>> Leider ist dies nicht ganz eine Lösung noch nicht, und ehe wir

302
00:16:23,000 --> 00:16:26,000
was sein könnte herausspringen so offensichtlich bei einigen von euch

303
00:16:26,000 --> 00:16:28,000
Lassen Sie mich gehen Sie vor und führen Sie machen.

304
00:16:28,000 --> 00:16:30,000
Es scheint zu kompilieren okay.

305
00:16:30,000 --> 00:16:32,000
Lassen Sie mich erneut sigma mit 6.

306
00:16:32,000 --> 00:16:37,000
Whoops, lass mich erneut sigma mit 6.

307
00:16:37,000 --> 00:16:42,000
Wir haben dies vor, wenn auch versehentlich letzte Mal gesehen, wie gut.

308
00:16:42,000 --> 00:16:48,000
Warum habe ich diese kryptischen Segmentation Fault? Yeah.

309
00:16:48,000 --> 00:16:50,000
[Unverständlich-Student]

310
00:16:50,000 --> 00:16:53,000
Es gibt keine base case, genauer gesagt, was wohl passiert?

311
00:16:53,000 --> 00:16:58,000
Dies ist ein Symptom, welches Verhalten?

312
00:16:58,000 --> 00:17:00,000
Sagen Sie es ein wenig lauter.

313
00:17:00,000 --> 00:17:02,000
[Unverständlich-Student]

314
00:17:02,000 --> 00:17:05,000
Es ist eine unendliche Schleife effektiv, und das Problem mit Endlosschleifen

315
00:17:05,000 --> 00:17:08,000
wenn sie beinhalten Rekursion in diesem Fall ruft eine Funktion selbst,

316
00:17:08,000 --> 00:17:10,000
was passiert jedes Mal, wenn Sie eine Funktion aufrufen?

317
00:17:10,000 --> 00:17:13,000
Nun, denken Sie zurück an, wie wir legte den Speicher in einem Computer.

318
00:17:13,000 --> 00:17:16,000
Wir haben gesagt, dass es dieses Stück Speicher genannt Stack, der an der Unterseite ist,

319
00:17:16,000 --> 00:17:19,000
und jedes Mal, wenn Sie eine Funktion aufrufen ein wenig mehr Speicher wird gesetzt

320
00:17:19,000 --> 00:17:24,000
auf dieser sogenannten Stack enthält dieses Funktionsdisplay lokalen Variablen oder Parameter,

321
00:17:24,000 --> 00:17:27,000
also wenn sigma nennt Sigma Anrufe Sigma nennt sigma

322
00:17:27,000 --> 00:17:29,000
 nennt Sigma Woher kommt diese Geschichte?

323
00:17:29,000 --> 00:17:31,000
>> Nun, es ist schließlich Überschreitungen der Gesamtbetrag

324
00:17:31,000 --> 00:17:33,000
der Erinnerung, die Sie zur Verfügung zu Ihrem Computer haben.

325
00:17:33,000 --> 00:17:37,000
Sie überrannt das Segment, das man eigentlich zum Verweilen ein,

326
00:17:37,000 --> 00:17:40,000
und Sie diese Segmentation Fault zu bekommen, Core Dump,

327
00:17:40,000 --> 00:17:43,000
und was core dumped bedeutet, ist, dass ich jetzt eine Datei namens core

328
00:17:43,000 --> 00:17:46,000
das ist eine Datei mit Nullen und Einsen

329
00:17:46,000 --> 00:17:49,000
, dass in der Zukunft tatsächlich wird diagnostisch nützlich.

330
00:17:49,000 --> 00:17:52,000
Wenn es nicht klar, wo Ihre Fehler ist

331
00:17:52,000 --> 00:17:54,000
Sie konkret tun können ein bisschen forensische Analyse, so zu sprechen,

332
00:17:54,000 --> 00:17:58,000
auf dieser Core-Dump-Datei ist, die wiederum nur eine ganze Reihe von Nullen und Einsen

333
00:17:58,000 --> 00:18:02,000
das stellt im Wesentlichen den Zustand Ihres Programms im Speicher

334
00:18:02,000 --> 00:18:05,000
der Moment, es stürzte auf diese Weise.

335
00:18:05,000 --> 00:18:11,000
>> Der Fix ist, dass wir nicht einfach blind zurück sigma,

336
00:18:11,000 --> 00:18:14,000
die Zahl + Sigma von einem etwas kleineren Problem.

337
00:18:14,000 --> 00:18:16,000
Wir müssen eine Art von base case hier zu haben,

338
00:18:16,000 --> 00:18:19,000
und was sollte die Basis Fall wahrscheinlich sein?

339
00:18:19,000 --> 00:18:22,000
[Unverständlich-Student]

340
00:18:22,000 --> 00:18:25,000
Okay, so lange die Zahl positiv ist, dass wir eigentlich wieder dazu

341
00:18:25,000 --> 00:18:29,000
oder anders gesagt, wenn die Zahl, sagen wir, <= auf 0

342
00:18:29,000 --> 00:18:32,000
wissen Sie was, ich werde weitermachen und 0 zurückgeben,

343
00:18:32,000 --> 00:18:36,000
ähnlich wie Willy tat, und sonst, ich werde weitermachen

344
00:18:36,000 --> 00:18:41,000
und geben diese, so dass es nicht so viel kürzer

345
00:18:41,000 --> 00:18:44,000
als die iterative Version, dass wir Schlagsahne zuerst mit einer for-Schleife

346
00:18:44,000 --> 00:18:48,000
aber feststellen, dass es diese Art von Eleganz zu.

347
00:18:48,000 --> 00:18:51,000
Statt der Rücksendung eine gewisse Anzahl und Durchführung all diese math

348
00:18:51,000 --> 00:18:54,000
und das Hinzufügen Dinge mit lokalen Variablen

349
00:18:54,000 --> 00:18:57,000
Sie stattdessen sagen: "Okay, wenn dies ist ein super einfaches Problem,

350
00:18:57,000 --> 00:19:01,000
wie die Zahl <0 ist, lassen Sie mich sofort 0 zurück. "

351
00:19:01,000 --> 00:19:03,000
>> Wir gehen nicht auf die Unterstützung negative Zahlen stören,

352
00:19:03,000 --> 00:19:05,000
so bin ich zu hart Code wird den Wert von 0 auf.

353
00:19:05,000 --> 00:19:08,000
Aber sonst, zur Umsetzung dieser Idee Summierung

354
00:19:08,000 --> 00:19:11,000
alle diese Zahlen zusammen können Sie effektiv einen kleinen Happen

355
00:19:11,000 --> 00:19:14,000
aus dem Problem, viel wie wir hier auf der Bühne,

356
00:19:14,000 --> 00:19:18,000
dann punt der Rest des Problems an die nächste Person,

357
00:19:18,000 --> 00:19:20,000
aber in diesem Fall die nächste Person ist sich.

358
00:19:20,000 --> 00:19:22,000
Es ist eine gleichnamige Funktion.

359
00:19:22,000 --> 00:19:25,000
Übergeben Sie einfach es ist ein kleiner und kleineres Problem jedes Mal,

360
00:19:25,000 --> 00:19:28,000
und obwohl wir noch nicht ganz formalisiert Dinge im Code hier

361
00:19:28,000 --> 00:19:33,000
das ist genau, was los war in Woche 0 mit dem Telefonbuch.

362
00:19:33,000 --> 00:19:36,000
Das ist genau, was los war in den vergangenen Wochen mit Sean

363
00:19:36,000 --> 00:19:39,000
und mit unseren Demonstrationen der Suche nach Zahlen.

364
00:19:39,000 --> 00:19:42,000
Es dauert ein Problem und dividiert sie wieder und wieder.

365
00:19:42,000 --> 00:19:44,000
>> In anderen Worten, es ist ein Weg, jetzt übersetzen

366
00:19:44,000 --> 00:19:47,000
Diese realen Welt Konstrukt, diese höhere Ebene Konstrukt

367
00:19:47,000 --> 00:19:51,000
des divide et impera und etwas wieder und wieder

368
00:19:51,000 --> 00:19:56,000
im Code, so ist dies etwas, das wir wieder sehen wird im Laufe der Zeit.

369
00:19:56,000 --> 00:20:00,000
Jetzt, als beiseite, wenn Sie neu in Rekursion sind, sollten Sie zumindest verstehe jetzt

370
00:20:00,000 --> 00:20:02,000
warum das so ist lustig.

371
00:20:02,000 --> 00:20:05,000
Ich werde auf google.com gehen,

372
00:20:05,000 --> 00:20:17,000
und ich werde für ein paar Tipps und Tricks auf Rekursion zu suchen, geben.

373
00:20:17,000 --> 00:20:21,000
Sagen Sie der Person neben dir, wenn sie nicht lachten gerade jetzt.

374
00:20:21,000 --> 00:20:23,000
Meinten Sie Rekursion?

375
00:20:23,000 --> 00:20:25,000
Meinten Sie-ah, es geht los.

376
00:20:25,000 --> 00:20:28,000
Okay, das ist jetzt, dass der Rest der jedermann.

377
00:20:28,000 --> 00:20:30,000
Ein wenig Osterei irgendwo in Google eingebettet.

378
00:20:30,000 --> 00:20:33,000
Nebenbei, einer der Links, die wir auf dem Kurs der Website genommen

379
00:20:33,000 --> 00:20:36,000
heute ist nur dieses Gitter verschiedener Sortieralgorithmen

380
00:20:36,000 --> 00:20:39,000
von denen wir einige sah letzte Woche, aber was ist mit dieser Visualisierung schöne

381
00:20:39,000 --> 00:20:43,000
wie Sie versuchen, Ihren Verstand um verschiedene Dinge im Zusammenhang mit Algorithmen wickeln

382
00:20:43,000 --> 00:20:46,000
wissen, dass man sehr leicht jetzt mit verschiedenen Eingängen zu beginnen.

383
00:20:46,000 --> 00:20:50,000
Die Eingänge alle umgekehrt, meist die Eingänge sortiert, die Eingänge zufällig und so weiter.

384
00:20:50,000 --> 00:20:53,000
Wie Sie, erneut zu versuchen, zeichnen diese Dinge im Kopf

385
00:20:53,000 --> 00:20:57,000
erkennen, dass diese URL auf den Verlauf der Website auf dem Lectures Seite

386
00:20:57,000 --> 00:21:00,000
könnte Ihnen helfen, Vernunft durch einige von denen.

387
00:21:00,000 --> 00:21:05,000
>> Heute haben wir endlich mal dieses Problem eine Weile zurück zu lösen,

388
00:21:05,000 --> 00:21:08,000
was war, dass diese Swap-Funktion einfach nicht funktioniert,

389
00:21:08,000 --> 00:21:12,000
und was war das grundlegende Problem mit dieser Funktion swap,

390
00:21:12,000 --> 00:21:15,000
deren Ziel es war wieder um einen Wert hier und hier austauschen

391
00:21:15,000 --> 00:21:17,000
so dass in diesem Fall?

392
00:21:17,000 --> 00:21:20,000
Das ist nicht wirklich funktionieren. Warum?

393
00:21:20,000 --> 00:21:22,000
Yeah.

394
00:21:22,000 --> 00:21:28,000
[Unverständlich-Student]

395
00:21:28,000 --> 00:21:31,000
Genau, die Erklärung für diese Verrücktheit

396
00:21:31,000 --> 00:21:34,000
war einfach, weil, wenn Sie die Funktionen in C aufrufen

397
00:21:34,000 --> 00:21:38,000
und jene Funktionen übernehmen Argumente, wie a und b hier

398
00:21:38,000 --> 00:21:42,000
Sie werden in Kopien, was Wert du auf diese Funktion, die vorbei.

399
00:21:42,000 --> 00:21:46,000
Sie sind nicht die Bereitstellung der ursprünglichen Werte selbst,

400
00:21:46,000 --> 00:21:49,000
so sahen wir dies im Rahmen der buggyc,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, die ein wenig so etwas sah.

402
00:21:52,000 --> 00:21:57,000
>> Erinnern, dass wir x und y auf 1 und 2 initialisiert sind.

403
00:21:57,000 --> 00:21:59,000
Wir haben dann, was sie gedruckt wurden.

404
00:21:59,000 --> 00:22:03,000
Ich habe dann behauptet, dass ich tauschen sie durch den Aufruf Tausch von x, y.

405
00:22:03,000 --> 00:22:06,000
Aber das Problem war, dass der Austausch funktioniert,

406
00:22:06,000 --> 00:22:10,000
aber nur im Rahmen der Swap-Funktion selbst.

407
00:22:10,000 --> 00:22:13,000
Sobald wir getroffen Linie 40 Diejenigen getauschte Werte

408
00:22:13,000 --> 00:22:16,000
wurden weggeworfen, und so nichts

409
00:22:16,000 --> 00:22:21,000
in der ursprünglichen Funktion main wurde tatsächlich geändert überhaupt,

410
00:22:21,000 --> 00:22:26,000
Wenn Sie also denken, damals, was so aussieht wie in Bezug auf unser Gedächtnis

411
00:22:26,000 --> 00:22:29,000
wenn dies linken Seite des Brettes für-

412
00:22:29,000 --> 00:22:33,000
und ich werde mein Bestes für alle, um zu sehen this-wenn dies linken Seite des Brettes

413
00:22:33,000 --> 00:22:37,000
stellt, sagen wir, Ihre RAM, und der Stapel wird wachsen auf bis auf diese Weise,

414
00:22:37,000 --> 00:22:43,000
und wir nennen eine Funktion wie Haupt-und wichtigsten verfügt über 2 lokale Variablen x und y,

415
00:22:43,000 --> 00:22:48,000
Lassen Sie uns beschreiben, die als x hier, und wir beschreiben diese als y hier

416
00:22:48,000 --> 00:22:55,000
und lassen Sie uns in den Werten 1 und 2 gesetzt, so ist das hier main,

417
00:22:55,000 --> 00:22:58,000
und wenn Haupt ruft die Swap-Funktion des Betriebssystems

418
00:22:58,000 --> 00:23:02,000
verleiht dem Swap-Funktion eine eigene Schneise der Speicher auf dem Stack,

419
00:23:02,000 --> 00:23:04,000
eigenen Rahmen auf dem Stack, so zu sprechen.

420
00:23:04,000 --> 00:23:08,000
Es teilt auch 32 Bit für diese ints.

421
00:23:08,000 --> 00:23:11,000
Es passiert nennen a und b, aber das ist völlig willkürlich.

422
00:23:11,000 --> 00:23:13,000
Es könnte sie berufen habe, was sie will, aber was passiert, wenn der Haupt-

423
00:23:13,000 --> 00:23:19,000
Anrufe Swap ist es dauert diese 1, legt eine Kopie gibt, legt eine Kopie gibt.

424
00:23:19,000 --> 00:23:23,000
>> Es gibt 1 weitere lokale Variable in swap, aber als was? >> Tmp.

425
00:23:23,000 --> 00:23:27,000
Tmp, so lassen Sie mich mich noch 32 Bits hier

426
00:23:27,000 --> 00:23:29,000
und was habe ich zu tun in dieser Funktion?

427
00:23:29,000 --> 00:23:34,000
Ich sagte int tmp bekommt ein, so dass eine hat 1, also tat ich dies, wenn wir mit diesem Beispiel zuletzt gespielt.

428
00:23:34,000 --> 00:23:39,000
Dann ein bekommt b, so b 2, so dass nun wird dies 2,

429
00:23:39,000 --> 00:23:42,000
und nun b erhält temp, so temp ist 1,

430
00:23:42,000 --> 00:23:44,000
so jetzt b wird diese.

431
00:23:44,000 --> 00:23:46,000
Das ist toll. Es funktionierte.

432
00:23:46,000 --> 00:23:49,000
Aber dann, sobald die Funktion zurückkehrt

433
00:23:49,000 --> 00:23:52,000
Swap-Speicher effektiv ausgeblendet, so dass es wiederverwendet werden kann

434
00:23:52,000 --> 00:23:58,000
durch eine andere Funktion in der Zukunft, und die wichtigsten ist offensichtlich völlig unverändert.

435
00:23:58,000 --> 00:24:00,000
Wir brauchen einen Weg grundlegend Lösung dieses Problems

436
00:24:00,000 --> 00:24:03,000
und heute werden wir endlich einen Weg, dies zu tun, wobei

437
00:24:03,000 --> 00:24:06,000
können wir die Einführung einer so genannten Zeiger.

438
00:24:06,000 --> 00:24:09,000
Es stellt sich heraus, dass wir dieses Problem lösen kann

439
00:24:09,000 --> 00:24:12,000
nicht durch Einleiten von Kopien von x und y

440
00:24:12,000 --> 00:24:18,000
sondern, indem in dem, was, denken Sie an den Swap-Funktion?

441
00:24:18,000 --> 00:24:20,000
Ja, was ist die Adresse?

442
00:24:20,000 --> 00:24:22,000
Wir haben nicht wirklich über Adressen sehr detailliert gesprochen,

443
00:24:22,000 --> 00:24:25,000
aber wenn diese Tafel stellt meine Arbeitsspeicher des Computers

444
00:24:25,000 --> 00:24:28,000
Wir könnten sicherlich Nummerierung beginnen die Bytes in meinem RAM

445
00:24:28,000 --> 00:24:31,000
und sagen, das ist das Byte Nr. 1, ist dieses Byte # 2, Byte # 3,

446
00:24:31,000 --> 00:24:35,000
Byte # 4, Byte # ... 2 Milliarden, wenn ich 2 Gigabyte RAM haben,

447
00:24:35,000 --> 00:24:38,000
so konnten wir sicherlich kommen mit einer beliebigen Numerierung

448
00:24:38,000 --> 00:24:41,000
für alle einzelnen Bytes in meinem Arbeitsspeicher des Computers.

449
00:24:41,000 --> 00:24:43,000
>> Was wäre, wenn statt, wenn ich Makeln

450
00:24:43,000 --> 00:24:47,000
anstatt Durchgang in Kopien von x und y

451
00:24:47,000 --> 00:24:51,000
warum ich nicht stattdessen in der Adresse x dahin,

452
00:24:51,000 --> 00:24:55,000
die Adresse y hier im wesentlichen die Postanschrift

453
00:24:55,000 --> 00:24:59,000
von x und y, weil dann tauschen, wenn er informiert

454
00:24:59,000 --> 00:25:01,000
der Adresse im Speicher von x und y,

455
00:25:01,000 --> 00:25:04,000
dann tauschen, wenn wir ihn trainiert ein wenig,

456
00:25:04,000 --> 00:25:07,000
Er könnte zu dieser Adresse fahren, so zu sprechen,

457
00:25:07,000 --> 00:25:11,000
x, und ändern Sie dort die Rufnummer, dann an die Adresse von y zu fahren,

458
00:25:11,000 --> 00:25:16,000
die Anzahl gibt, auch wenn nicht eigentlich immer Kopien von den Werten selbst,

459
00:25:16,000 --> 00:25:19,000
so, obwohl wir sprachen über dies als wichtigsten Speicher

460
00:25:19,000 --> 00:25:23,000
und dies als Swap-Speicher die Mächtigen und die gefährlichste Teil C

461
00:25:23,000 --> 00:25:28,000
ist, dass jede Funktion Speicher überall in dem Computerspeicher zu berühren,

462
00:25:28,000 --> 00:25:32,000
und dies ist mächtig, dass man sehr ausgefallene Dinge mit Computerprogrammen in C schreiben

463
00:25:32,000 --> 00:25:36,000
Dies ist gefährlich, da man auch vermasseln sehr leicht.

464
00:25:36,000 --> 00:25:39,000
Tatsächlich einem der gängigsten Methoden für Programme in diesen Tagen ausgenutzt werden

465
00:25:39,000 --> 00:25:42,000
noch für einen Programmierer nicht zu erkennen,

466
00:25:42,000 --> 00:25:45,000
dass er oder sie ermöglicht eine Daten

467
00:25:45,000 --> 00:25:49,000
in einer Speicherstelle, die nicht beabsichtigt war geschrieben werden.

468
00:25:49,000 --> 00:25:51,000
>> Zum Beispiel erklärt er oder sie ein Array der Größe 10

469
00:25:51,000 --> 00:25:56,000
aber dann versehentlich versucht, 11 Bytes in dieser Reihe von Speicher abgelegt,

470
00:25:56,000 --> 00:25:59,000
und starten Sie berühren Teile des Speichers, die nicht mehr gültig sind.

471
00:25:59,000 --> 00:26:02,000
Nur um kontextuelle dies könnte einige von euch wissen, dass

472
00:26:02,000 --> 00:26:06,000
Software oft fordert Sie auf, Seriennummern oder Registrierungsschlüssel,

473
00:26:06,000 --> 00:26:08,000
Photoshop und Word und Programme wie dieses.

474
00:26:08,000 --> 00:26:12,000
Es gibt Risse, wie einige von euch wissen, online, wo kann man ein kleines Programm ausführen,

475
00:26:12,000 --> 00:26:14,000
und voila, keine Aufträge mehr für eine Seriennummer.

476
00:26:14,000 --> 00:26:16,000
Wie ist das Problem?

477
00:26:16,000 --> 00:26:21,000
In vielen Fällen sind diese Dinge sind einfach zu finden in den Computern

478
00:26:21,000 --> 00:26:24,000
Textsegmente in den Computer tatsächlichen Nullen und Einsen

479
00:26:24,000 --> 00:26:28,000
wo ist diese Funktion, wo die Seriennummer angefordert wird,

480
00:26:28,000 --> 00:26:31,000
und überschreiben Sie diesen Raum, oder während das Programm läuft

481
00:26:31,000 --> 00:26:33,000
Sie können herausfinden, wo der Schlüssel tatsächlich gespeichert wird

482
00:26:33,000 --> 00:26:37,000
mit etwas namens ein Debugger, und Sie können Software, die Art und Weise zu knacken.

483
00:26:37,000 --> 00:26:40,000
Dies ist nicht zu sagen, dass dies unser Ziel ist es, für die nächsten paar Tage,

484
00:26:40,000 --> 00:26:42,000
aber es hat sehr reale Konsequenzen.

485
00:26:42,000 --> 00:26:45,000
Dass man passiert den Diebstahl von Software beinhalten,

486
00:26:45,000 --> 00:26:47,000
aber es gibt auch Kompromisse kompletter Maschinen.

487
00:26:47,000 --> 00:26:50,000
>> In der Tat, wenn Webseiten in diesen Tagen ausgebeutet werden

488
00:26:50,000 --> 00:26:53,000
und kompromittiert und die Daten zugespielt und Passwörter gestohlen werden

489
00:26:53,000 --> 00:26:58,000
sehr oft bezieht sich auf schlechtes Management des eigenen Speicher,

490
00:26:58,000 --> 00:27:01,000
oder, im Fall von Datenbanken, zum Scheitern antizipieren

491
00:27:01,000 --> 00:27:03,000
kontradiktorischen Eingang, so mehr auf, dass in den kommenden Wochen,

492
00:27:03,000 --> 00:27:07,000
aber für jetzt nur eine Vorschau auf die Art von Schäden, die Sie tun können

493
00:27:07,000 --> 00:27:11,000
um nicht ganz zu verstehen, wie die Dinge unter der Haube arbeiten.

494
00:27:11,000 --> 00:27:14,000
Lassen Sie uns über das Verständnis, warum dies ist kaputt gehen

495
00:27:14,000 --> 00:27:17,000
mit einem Werkzeug, das wird mehr und mehr nützlich

496
00:27:17,000 --> 00:27:19,000
wie unsere Programme immer komplexer.

497
00:27:19,000 --> 00:27:21,000
So weit, wenn Sie habe einen Fehler in Ihrem Programm

498
00:27:21,000 --> 00:27:23,000
wie haben Sie zum Debuggen es weg?

499
00:27:23,000 --> 00:27:25,000
Was haben Ihre Techniken bisher gewesen, ob von Ihrem TF unterrichtet

500
00:27:25,000 --> 00:27:27,000
oder einfach nur Autodidakt?

501
00:27:27,000 --> 00:27:29,000
[Student] Printf.

502
00:27:29,000 --> 00:27:31,000
Printf, so printf ist wahrscheinlich dein Freund, dass, wenn Sie sehen wollen

503
00:27:31,000 --> 00:27:33,000
was los ist auf der Innenseite des Programms

504
00:27:33,000 --> 00:27:36,000
setzt man printf hier printf hier printf hier.

505
00:27:36,000 --> 00:27:38,000
Anschließend führen Sie es, und Sie bekommen eine ganze Menge Zeug auf dem Bildschirm

506
00:27:38,000 --> 00:27:43,000
die Sie verwenden können, um dann ableiten, was ist eigentlich los in Ihrem Programm falsch.

507
00:27:43,000 --> 00:27:45,000
>> Printf neigt dazu, eine sehr mächtige Sache sein,

508
00:27:45,000 --> 00:27:47,000
aber es ist ein sehr manueller Prozess.

509
00:27:47,000 --> 00:27:49,000
Sie müssen eine printf hier setzen, ein printf hier

510
00:27:49,000 --> 00:27:51,000
und wenn man es innerhalb einer Schleife erhalten Sie möglicherweise 100 Zeilen

511
00:27:51,000 --> 00:27:53,000
der Ausgabe, die Sie dann zu sichten.

512
00:27:53,000 --> 00:27:58,000
Es ist nicht eine sehr benutzerfreundliche und interaktive Mechanismus für Debuggen von Programmen,

513
00:27:58,000 --> 00:28:00,000
aber zum Glück gibt es Alternativen.

514
00:28:00,000 --> 00:28:03,000
Es ist ein Programm, zum Beispiel, genannt GDB, der GNU Debugger,

515
00:28:03,000 --> 00:28:06,000
das ist etwas obskure, wie Sie es verwenden.

516
00:28:06,000 --> 00:28:08,000
Es ist ein wenig komplex, aber ehrlich gesagt,

517
00:28:08,000 --> 00:28:11,000
Dies ist eines der Dinge, wo, wenn Sie in dieser Woche gestellt und im nächsten

518
00:28:11,000 --> 00:28:14,000
die zusätzliche Stunde so etwas wie GDB verstehen

519
00:28:14,000 --> 00:28:18,000
es spart Ihnen wahrscheinlich Dutzende von Stunden auf lange Sicht,

520
00:28:18,000 --> 00:28:21,000
so mit, dass, lassen Sie mich Ihnen einen Vorgeschmack, wie dieses Ding funktioniert.

521
00:28:21,000 --> 00:28:23,000
>> Ich bin in meinem Terminal-Fenster.

522
00:28:23,000 --> 00:28:26,000
Lassen Sie mich gehen Sie vor und dieses Programm kompilieren, buggy3.

523
00:28:26,000 --> 00:28:28,000
Es ist bereits up to date.

524
00:28:28,000 --> 00:28:31,000
Lassen Sie mich laufen lassen, so wie wir eine Weile zurück tat, und in der Tat, es ist gebrochen.

525
00:28:31,000 --> 00:28:34,000
Aber warum ist das? Vielleicht habe ich vermasselt die Swap-Funktion.

526
00:28:34,000 --> 00:28:37,000
Vielleicht ist es a und b. Ich bin nicht ganz bewegt sie herum richtig.

527
00:28:37,000 --> 00:28:39,000
Lassen Sie mich gehen Sie vor und tun dies.

528
00:28:39,000 --> 00:28:43,000
Anstatt nur buggy3 laufen lassen mich stattdessen dieses Programm GDB,

529
00:28:43,000 --> 00:28:48,000
und ich werde es sagen, buggy3 laufen,

530
00:28:48,000 --> 00:28:52,000
und ich werde ein Befehlszeilenargument-tui gehören,

531
00:28:52,000 --> 00:28:55,000
und wir werden dies auch in Zukunft Probleme bei spec zu erinnern setzen.

532
00:28:55,000 --> 00:28:57,000
Und nun diese Schwarz-Weiß-Schnittstelle tauchte, dass wieder

533
00:28:57,000 --> 00:28:59,000
ist ein wenig überwältigend auf den ersten, weil es all dies

534
00:28:59,000 --> 00:29:02,000
Informationen zur Garantie hier unten, aber zumindest gibt es etwas Vertrautes.

535
00:29:02,000 --> 00:29:04,000
Im oberen Bereich des Fensters ist meine eigentliche Code,

536
00:29:04,000 --> 00:29:08,000
und wenn ich nach oben ließ mich hier navigieren Sie zu dem ganz oben auf meiner Datei

537
00:29:08,000 --> 00:29:11,000
und in der Tat, es gibt buggy3.c, und beachten Sie am unteren Rand des Fensters

538
00:29:11,000 --> 00:29:13,000
Ich habe dieses GDB prompt.

539
00:29:13,000 --> 00:29:16,000
>> Dies ist nicht das Gleiche wie mein normales John Harvard prompt.

540
00:29:16,000 --> 00:29:19,000
Dies ist eine Aufforderung, die gehen mir zu erlauben, GDB Control.

541
00:29:19,000 --> 00:29:21,000
GDB ist ein Debugger.

542
00:29:21,000 --> 00:29:24,000
Ein Debugger ist ein Programm, das Sie durch gehen können

543
00:29:24,000 --> 00:29:27,000
Ausführung des Programms Zeile Zeile für Zeile,

544
00:29:27,000 --> 00:29:30,000
entlang des Weges zu tun, was Sie wollen mit dem Programm,

545
00:29:30,000 --> 00:29:33,000
auch den Aufruf von Funktionen, oder auf der Suche, was noch wichtiger ist,

546
00:29:33,000 --> 00:29:35,000
an verschiedenen Variablen Werte.

547
00:29:35,000 --> 00:29:37,000
Lasst uns weitermachen und tun.

548
00:29:37,000 --> 00:29:40,000
Ich werde weitermachen und geben Sie in Lauf bei GDB Eingabeaufforderung

549
00:29:40,000 --> 00:29:43,000
so an der Unterseite des Bildschirms Ich tippte laufen gelassen haben bemerkt,

550
00:29:43,000 --> 00:29:45,000
und ich habe getroffen, und geben, was half das?

551
00:29:45,000 --> 00:29:50,000
Es ist buchstäblich lief mein Programm, aber ich habe nicht wirklich viel zu sehen hier gehen

552
00:29:50,000 --> 00:29:55,000
weil ich habe nicht wirklich gesagt, den Debugger

553
00:29:55,000 --> 00:29:57,000
zu pausieren zu einem bestimmten Zeitpunkt.

554
00:29:57,000 --> 00:29:59,000
Nur die Eingabe run läuft das Programm.

555
00:29:59,000 --> 00:30:01,000
Ich weiß nicht wirklich etwas sehen. Ich kann mich nicht manipulieren.

556
00:30:01,000 --> 00:30:03,000
>> Stattdessen lassen Sie mich dies tun.

557
00:30:03,000 --> 00:30:08,000
An diesem GDB Prompt ließ mich stattdessen schreiben Pause geben.

558
00:30:08,000 --> 00:30:10,000
Das ist nicht, was ich zu geben gemeint.

559
00:30:10,000 --> 00:30:13,000
Lasst uns stattdessen schreiben Pause main.

560
00:30:13,000 --> 00:30:15,000
In anderen Worten, ich möchte so etwas wie ein Breakpoint gesetzt,

561
00:30:15,000 --> 00:30:18,000
was ist treffend benannt, weil sie brechen oder Pause

562
00:30:18,000 --> 00:30:21,000
Ausführung des Programms an diesem besonderen Ort.

563
00:30:21,000 --> 00:30:23,000
Main ist der Name meiner Funktion.

564
00:30:23,000 --> 00:30:25,000
Beachten Sie, dass GDB ziemlich schlau ist.

565
00:30:25,000 --> 00:30:28,000
Es herausgefunden, dass Haupt auf rund beginnen in Zeile 18 geschieht,

566
00:30:28,000 --> 00:30:32,000
der buggy3.c, und dann hier bemerken, links oben

567
00:30:32,000 --> 00:30:34,000
b + befindet sich direkt neben der Leitung 18.

568
00:30:34,000 --> 00:30:38,000
Das ist erinnert mich, dass ich einen Haltepunkt in Zeile 18 gesetzt.

569
00:30:38,000 --> 00:30:42,000
Dieses Mal, wenn ich run geben, werde ich mein Programm laufen

570
00:30:42,000 --> 00:30:45,000
bis er trifft, dass Haltepunkt,

571
00:30:45,000 --> 00:30:48,000
so dass das Programm pausiert für mich in Zeile 18.

572
00:30:48,000 --> 00:30:50,000
Here we go, laufen.

573
00:30:50,000 --> 00:30:53,000
Nichts scheint passiert zu sein, aber beachten Sie unten links

574
00:30:53,000 --> 00:30:58,000
Starten des Programms, buggy3, Haltepunkt 1 in Haupt am buggy3.c Linie 18.

575
00:30:58,000 --> 00:31:00,000
Was kann ich jetzt tun?

576
00:31:00,000 --> 00:31:03,000
>> Beachten Sie, ich kann der Eingabe beginnen Dinge wie Druck,

577
00:31:03,000 --> 00:31:08,000
nicht printf, print x, und das ist jetzt seltsam.

578
00:31:08,000 --> 00:31:11,000
Das $ 1 ist nur ein Kuriosum, wie wir sehen werden

579
00:31:11,000 --> 00:31:14,000
jedes Mal, wenn Sie etwas ausdrucken erhalten Sie eine neue $ value.

580
00:31:14,000 --> 00:31:18,000
Das ist so, dass man entnehmen zurück zur vorherigen Werte nur für den Fall,

581
00:31:18,000 --> 00:31:21,000
aber für jetzt, was Druck ist mir zu sagen ist, dass der Wert von x an diesem Punkt in der Geschichte

582
00:31:21,000 --> 00:31:26,000
ist offenbar 134514032.

583
00:31:26,000 --> 00:31:29,000
Was? Wo hast, dass auch herkommen?

584
00:31:29,000 --> 00:31:31,000
[Unverständlich-Student]

585
00:31:31,000 --> 00:31:34,000
In der Tat ist das, was wir eine Garbage-Wert nennen, und wir haben nicht darüber gesprochen noch

586
00:31:34,000 --> 00:31:37,000
aber der Grund, dass Sie Variablen zu initialisieren

587
00:31:37,000 --> 00:31:40,000
ist offensichtlich so, dass sie einen gewissen Wert, dass Sie wollen, dass sie bei sich haben müssen.

588
00:31:40,000 --> 00:31:44,000
Aber der Haken ist daran erinnern, dass Sie Variablen deklarieren

589
00:31:44,000 --> 00:31:46,000
wie ich vorhin in meinem Sigma beispielsweise

590
00:31:46,000 --> 00:31:48,000
ohne tatsächlich ihnen einen Wert.

591
00:31:48,000 --> 00:31:50,000
Erinnern, was ich über habe hier im Sigma.

592
00:31:50,000 --> 00:31:52,000
Ich erklärte n, sondern welchen Wert habe ich ihm geben?

593
00:31:52,000 --> 00:31:56,000
Keine, weil ich wusste, dass in den nächsten paar Zeilen

594
00:31:56,000 --> 00:31:59,000
GetInt kümmern würde das Problem der Umsetzung einen Wert innerhalb der n nehmen.

595
00:31:59,000 --> 00:32:02,000
>> Aber an diesem Punkt in der Geschichte der Linie 11

596
00:32:02,000 --> 00:32:05,000
und Linie 12 und Linie 13 und Linie 14

597
00:32:05,000 --> 00:32:08,000
in all den mehreren Zeilen ist, was der Wert von n?

598
00:32:08,000 --> 00:32:10,000
In C Sie wissen einfach nicht.

599
00:32:10,000 --> 00:32:14,000
Es ist in der Regel einige Müll Wert, einige völlig Zufallszahl

600
00:32:14,000 --> 00:32:17,000
Das ist mehr als im Wesentlichen aus einem früheren Funktion verlassen

601
00:32:17,000 --> 00:32:21,000
worden laufen, so wie Ihr Programm läuft

602
00:32:21,000 --> 00:32:24,000
daran erinnern, dass function, Funktion, Funktion erhält.

603
00:32:24,000 --> 00:32:27,000
All diese Bilder bekommen auf den Speicher zu stellen, und dann jene Funktionen geben,

604
00:32:27,000 --> 00:32:31,000
und genau wie ich vorgeschlagen mit dem Radiergummi ihr Gedächtnis schließlich wiederverwendet wird.

605
00:32:31,000 --> 00:32:37,000
Nun, es passiert einfach so, dass diese Variable x in diesem Programm

606
00:32:37,000 --> 00:32:41,000
scheint enthalten einige Müll Wert wie 134514032 haben

607
00:32:41,000 --> 00:32:44,000
aus einem früheren Funktion, nicht ein, dass ich geschrieben habe.

608
00:32:44,000 --> 00:32:47,000
Es könnte etwas die effektiv kommt mit dem Betriebssystem sein,

609
00:32:47,000 --> 00:32:49,000
eine Funktion unter der Haube.

610
00:32:49,000 --> 00:32:52,000
>> Okay, das ist in Ordnung, aber wir nun voraus auf die nächste Zeile.

611
00:32:52,000 --> 00:32:55,000
Wenn ich "next" an meinem GDB Eingabeaufforderung eingeben und ich drücken Sie Enter

612
00:32:55,000 --> 00:32:58,000
feststellen, dass die Hervorhebung nach unten bewegt, um die Leitung 19,

613
00:32:58,000 --> 00:33:01,000
sondern die logische Implikation ist, dass Zeile 18

614
00:33:01,000 --> 00:33:06,000
ist nun fertig ausgeführt, so dass, wenn ich wieder geben "print x"

615
00:33:06,000 --> 00:33:10,000
Ich sollte jetzt 1, und in der Tat, das tue ich.

616
00:33:10,000 --> 00:33:14,000
Auch hier ist die $ zeug ein Weg GDB Sie daran erinnert,

617
00:33:14,000 --> 00:33:17,000
was die Geschichte der Ausdrucke sind, dass du getan hast.

618
00:33:17,000 --> 00:33:21,000
Nun lassen Sie mich gehen Sie vor und drucken Sie y, und in der Tat ist y ein paar verrückte Wert als gut,

619
00:33:21,000 --> 00:33:24,000
aber keine große Sache, weil in Zeile 19 sind wir zu zuweisen

620
00:33:24,000 --> 00:33:27,000
der Wert 2, so lassen Sie mich geben "next" wieder.

621
00:33:27,000 --> 00:33:29,000
Und jetzt sind wir auf dem printf Linie.

622
00:33:29,000 --> 00:33:31,000
Lass es mich tun print x.

623
00:33:31,000 --> 00:33:34,000
Lass es mich tun Print y. Ehrlich gesagt, ich bin ein wenig müde von Druck-dies.

624
00:33:34,000 --> 00:33:38,000
Lassen Sie mich statt geben "Anzeige x" und "Display y"

625
00:33:38,000 --> 00:33:41,000
und jetzt jedes Mal, wenn ich einen Befehl in der Zukunft

626
00:33:41,000 --> 00:33:45,000
Ich werde von dem, was erinnert werden x und y, was ist x und y, was ist x und y.

627
00:33:45,000 --> 00:33:48,000
>> Ich kann auch, wie eine Seite, geben Sie "info Einheimischen."

628
00:33:48,000 --> 00:33:50,000
Info ist ein spezieller Befehl.

629
00:33:50,000 --> 00:33:52,000
Die Einheimischen bedeutet dies zeigt mir die lokalen Variablen.

630
00:33:52,000 --> 00:33:55,000
Nur für den Fall vergesse ich oder ist dies eine verrückte, komplizierte Funktion

631
00:33:55,000 --> 00:33:57,000
dass ich oder jemand anderes schrieb info Einheimischen werden Ihnen sagen,

632
00:33:57,000 --> 00:34:00,000
was sind all die lokalen Variablen innerhalb dieses lokalen Funktion

633
00:34:00,000 --> 00:34:03,000
dass Sie vielleicht zu, wenn Sie wollen, um stecken zu kümmern.

634
00:34:03,000 --> 00:34:07,000
Jetzt, printf ist ca. auszuführen, so lassen Sie mich weiter und geben Sie einfach gehen "Weiter".

635
00:34:07,000 --> 00:34:10,000
Weil wir in diesem Umfeld sind wir nicht wirklich sehen es

636
00:34:10,000 --> 00:34:14,000
führen hier unten, aber feststellen, es ist immer ein wenig verstümmelt hier.

637
00:34:14,000 --> 00:34:17,000
Aber merkt es das Überschreiben der Bildschirm gibt,

638
00:34:17,000 --> 00:34:21,000
so ist es nicht ein perfektes Programm hier, aber das ist okay, weil ich immer in der Nähe stecken kann

639
00:34:21,000 --> 00:34:23,000
mit Druck, wenn ich will.

640
00:34:23,000 --> 00:34:26,000
>> Lassen Sie mich nächste wieder geben, und jetzt hier ist der interessante Teil.

641
00:34:26,000 --> 00:34:29,000
An diesem Punkt in der Geschichte y gleich 2 ist und x 1 ist,

642
00:34:29,000 --> 00:34:32,000
wie hier vorgeschlagen, und wieder

643
00:34:32,000 --> 00:34:35,000
Der Grund dies automatisch angezeigt wird, ist, weil ich den Befehl verwendet

644
00:34:35,000 --> 00:34:40,000
Anzeige x und Anzeige y, so dass der Moment, als ich als nächstes schreiben

645
00:34:40,000 --> 00:34:43,000
in der Theorie x und y werden sollte getauscht.

646
00:34:43,000 --> 00:34:45,000
Nun, wir wissen bereits, dass wird nicht der Fall sein,

647
00:34:45,000 --> 00:34:49,000
aber wir werden gleich sehen, wie wir tiefer tauchen, um herauszufinden, warum das so ist wahr.

648
00:34:49,000 --> 00:34:54,000
Weiter, und leider ist y noch 2 und x ist noch 1, und ich kann so viel zu bestätigen.

649
00:34:54,000 --> 00:34:56,000
Drucken x-, Druck-y.

650
00:34:56,000 --> 00:34:59,000
In der Tat, kein Swapping tatsächlich passiert, so beginnen wir diese über.

651
00:34:59,000 --> 00:35:01,000
Klar Swap ist gebrochen.

652
00:35:01,000 --> 00:35:04,000
Lasst uns stattdessen schreiben "run" wieder.

653
00:35:04,000 --> 00:35:07,000
Lassen Sie mich sagen, ja, ich will es von Anfang starten wollen, geben.

654
00:35:07,000 --> 00:35:09,000
>> Jetzt bin ich wieder in Zeile 18.

655
00:35:09,000 --> 00:35:11,000
Jetzt bemerken, x und y sind Müll Werte wieder.

656
00:35:11,000 --> 00:35:15,000
Weiter, weiter, weiter, weiter.

657
00:35:15,000 --> 00:35:17,000
Wenn mir langweilig Ich kann auch einfach n für die nächste.

658
00:35:17,000 --> 00:35:21,000
Sie können es auf die kürzest mögliche Folge von Zeichen abkürzen.

659
00:35:21,000 --> 00:35:23,000
Swap ist nun gebrochen.

660
00:35:23,000 --> 00:35:25,000
Lasst uns eintauchen, so dass anstelle der Eingabe nächsten,

661
00:35:25,000 --> 00:35:30,000
Jetzt werde ich Schritt geben, so dass ich in Intensivierung bin von dieser Funktion

662
00:35:30,000 --> 00:35:33,000
so dass ich durch sie hindurchgehen, so schlug ich Schritt und geben Sie dann.

663
00:35:33,000 --> 00:35:37,000
Beachten Sie, dass die Hervorhebung springt hinunter tiefer in mein Programm zu Zeile 36.

664
00:35:37,000 --> 00:35:39,000
Nun, was sind die lokalen Variablen?

665
00:35:39,000 --> 00:35:41,000
Info Einheimischen.

666
00:35:41,000 --> 00:35:43,000
Nichts nur noch, weil wir nicht auf dieser Linie bekommen,

667
00:35:43,000 --> 00:35:47,000
so lassen Sie uns gehen und sagen "Weiter".

668
00:35:47,000 --> 00:35:50,000
Jetzt scheinen wir tmp, Print tmp haben.

669
00:35:50,000 --> 00:35:52,000
Garbage-Wert, nicht wahr? Ich denke schon.

670
00:35:52,000 --> 00:35:55,000
Wie wäre es drucken, print b, 1 und 2?

671
00:35:55,000 --> 00:35:58,000
In einem Moment, sobald ich als nächstes schreiben wieder

672
00:35:58,000 --> 00:36:02,000
tmp wird auf einem Wert von 1 treffen, hoffentlich

673
00:36:02,000 --> 00:36:05,000
weil tmp wird zugeordnet den Wert eines werden.

674
00:36:05,000 --> 00:36:08,000
>> Nun wollen wir noch einen, Druck b drucken,

675
00:36:08,000 --> 00:36:11,000
aber jetzt gedruckt tmp, und es ist in der Tat ein.

676
00:36:11,000 --> 00:36:14,000
Lassen Sie mich als nächstes tun. Lassen Sie mich als nächstes tun.

677
00:36:14,000 --> 00:36:16,000
Ich habe die Swap-Funktion beendet.

678
00:36:16,000 --> 00:36:19,000
Ich bin immer noch in der es in Zeile 40, also lasst mich auszudrucken a,

679
00:36:19,000 --> 00:36:22,000
print b, und ich weiß nicht, was tmp ist.

680
00:36:22,000 --> 00:36:27,000
Es sieht aus wie Swap ist richtig, wenn es um Swapping a und b kommt.

681
00:36:27,000 --> 00:36:31,000
Aber wenn ich nun neben geben, springe ich zurück zu Zeile 25,

682
00:36:31,000 --> 00:36:34,000
und natürlich, wenn ich Typ in x-und Print-y

683
00:36:34,000 --> 00:36:38,000
sie sind immer noch unverändert, so haben wir nicht das Problem behoben.

684
00:36:38,000 --> 00:36:41,000
Aber diagnostisch jetzt vielleicht mit diesem GDB-Programm

685
00:36:41,000 --> 00:36:44,000
wir haben zumindest bekommen einen Schritt näher an das Verständnis

686
00:36:44,000 --> 00:36:47,000
was ist los, ohne Einstreu unseren Code, indem sie eine printf hier falsch,

687
00:36:47,000 --> 00:36:50,000
printf hier printf hier und dann läuft es wieder und wieder

688
00:36:50,000 --> 00:36:52,000
versuchen herauszufinden, was falsch läuft.

689
00:36:52,000 --> 00:36:55,000
>> Ich werde weitermachen und beenden aus diesem insgesamt mit beenden.

690
00:36:55,000 --> 00:36:57,000
Es wird dann sagen: "Beenden Sie eigentlich?" Ja.

691
00:36:57,000 --> 00:37:00,000
Jetzt bin ich wieder in meinem normalen Eingabeaufforderung, und ich bin fertig mit GDB.

692
00:37:00,000 --> 00:37:03,000
Nebenbei, die Sie nicht brauchen, um diese-tui-Flag verwenden.

693
00:37:03,000 --> 00:37:07,000
In der Tat, wenn Sie es weglassen man im wesentlichen die untere Hälfte des Bildschirms.

694
00:37:07,000 --> 00:37:11,000
Wenn ich dann break main und führen Sie dann

695
00:37:11,000 --> 00:37:15,000
Ich kann mich noch mein Programm, aber was sie tun ist textlich

696
00:37:15,000 --> 00:37:18,000
nur zeigen mir die aktuelle Zeile ein zu einer Zeit.

697
00:37:18,000 --> 00:37:21,000
Die-tui, textuelle Benutzeroberfläche

698
00:37:21,000 --> 00:37:25,000
nur zeigt Ihnen mehr von dem Programm auf einmal, das ist wahrscheinlich ein wenig konzeptionell einfacher.

699
00:37:25,000 --> 00:37:27,000
Aber in der Tat, kann ich nur als nächstes tun, next, next,

700
00:37:27,000 --> 00:37:30,000
und ich werde auf eine Zeile zu einem Zeitpunkt, zu sehen, und wenn ich wirklich will, um zu sehen, was los ist

701
00:37:30,000 --> 00:37:35,000
Ich kann geben Liste und sehen eine ganze Reihe von benachbarten Linien.

702
00:37:35,000 --> 00:37:39,000
>> Es gibt ein Video, dass wir darum gebeten, dass Sie Probleme setzt 3 zu sehen

703
00:37:39,000 --> 00:37:43,000
in denen Nate deckt einige der Feinheiten der GDB,

704
00:37:43,000 --> 00:37:46,000
und dies ist eines jener Dinge, ehrlich, wo einige nicht-triviale Prozentsatz Ihrer

705
00:37:46,000 --> 00:37:49,000
wird niemals berühren GDB, und das wird eine schlechte Sache sein

706
00:37:49,000 --> 00:37:53,000
weil buchstäblich Sie am Ende verbringen mehr Zeit im Laufe dieses Semesters

707
00:37:53,000 --> 00:37:56,000
Jagd nach Bugs dann würden Sie, wenn Sie setzen in dieser halben Stunde / Stunde

708
00:37:56,000 --> 00:38:00,000
diese und nächste Woche Lernen, sich bequem mit GDB.

709
00:38:00,000 --> 00:38:02,000
Printf war Ihr Freund.

710
00:38:02,000 --> 00:38:05,000
GDB sollte jetzt dein Freund sein.

711
00:38:05,000 --> 00:38:08,000
>> Haben Sie Fragen zum GDB?

712
00:38:08,000 --> 00:38:12,000
Und hier ist eine kurze Liste von einigen der mächtigsten und nützlichsten Befehlen.

713
00:38:12,000 --> 00:38:15,000
Yeah. >> Können Sie einen String?

714
00:38:15,000 --> 00:38:17,000
Können Sie eine Zeichenfolge? Absolut.

715
00:38:17,000 --> 00:38:19,000
Es muss nicht nur ganzzahlig sein.

716
00:38:19,000 --> 00:38:22,000
Wenn eine Variable s ist ein String geben Sie einfach in print s.

717
00:38:22,000 --> 00:38:24,000
Es zeigt Ihnen, was das String-Variable ist.

718
00:38:24,000 --> 00:38:26,000
[Unverständlich-Student]

719
00:38:26,000 --> 00:38:28,000
Es wird Ihnen die Adresse und den String selbst.

720
00:38:28,000 --> 00:38:32,000
Es zeigt Ihnen beides.

721
00:38:32,000 --> 00:38:34,000
Und eine letzte Sache, nur weil diese gut zu kennen.

722
00:38:34,000 --> 00:38:37,000
Backtrace und Rahmen, lassen Sie mich in diese ein letztes Mal tauchen,

723
00:38:37,000 --> 00:38:39,000
genau dasselbe Programm mit GDB.

724
00:38:39,000 --> 00:38:44,000
Lassen Sie mich gehen Sie vor und führen Sie die textuelle Benutzeroberfläche Version

725
00:38:44,000 --> 00:38:46,000
break main.

726
00:38:46,000 --> 00:38:49,000
Lassen Sie mich gehen Sie vor und führen Sie erneut. Hier bin ich.

727
00:38:49,000 --> 00:38:55,000
Jetzt lass mich gehen nächste, nächste, nächste, nächste, nächste, Schritt geben.

728
00:38:55,000 --> 00:39:00,000
>> Und jetzt nehme ich bin jetzt in swap bewusst, aber ich bin wie "Verdammt, was war der Wert von x?"

729
00:39:00,000 --> 00:39:02,000
Ich kann das nicht x mehr.

730
00:39:02,000 --> 00:39:05,000
Ich kann das nicht y, weil sie nicht im Lieferumfang sind.

731
00:39:05,000 --> 00:39:07,000
Sie sind nicht in Zusammenhang, aber kein Problem.

732
00:39:07,000 --> 00:39:09,000
Ich kann geben backtrace.

733
00:39:09,000 --> 00:39:13,000
Das zeigt mir alle Funktionen, die bis zu diesem Zeitpunkt ausgeführt wurden.

734
00:39:13,000 --> 00:39:16,000
Beachten Sie, dass ein auf dem Boden, Haupt-, Linien mit Haupt

735
00:39:16,000 --> 00:39:18,000
ist auf der Unterseite der unser Bild hier.

736
00:39:18,000 --> 00:39:22,000
Die Tatsache, dass Swap darüber Linien ist mit Swap oberhalb im Speicher hier

737
00:39:22,000 --> 00:39:26,000
und wenn ich wieder an die wichtigsten vorübergehend wollen, kann ich sagen, "frame".

738
00:39:26,000 --> 00:39:30,000
Welche Nummer? Main frame # 1.

739
00:39:30,000 --> 00:39:32,000
Ich werde weitermachen und sagen: "Frame 1".

740
00:39:32,000 --> 00:39:36,000
>> Jetzt bin ich wieder in main, und ich kann x zu drucken, und ich kann y drucken,

741
00:39:36,000 --> 00:39:40,000
aber ich kann nicht drucken oder b.

742
00:39:40,000 --> 00:39:43,000
Aber ich kann, wenn ich sage: "Okay, warten Sie eine Minute. Wo war das swap?"

743
00:39:43,000 --> 00:39:46,000
Lassen Sie mich gehen Sie vor und sagen, "frame 0".

744
00:39:46,000 --> 00:39:48,000
Jetzt bin ich wieder da, wo ich sein möchte, und so nebenbei,

745
00:39:48,000 --> 00:39:52,000
gibt es weitere Befehle zu, wie wenn Sie wirklich immer langweilig Typisierung nächsten, Weiter, Weiter, weiter,

746
00:39:52,000 --> 00:39:56,000
Sie können in der Regel sagen Dinge wie "nächsten 10," und das wird durch die nächsten 10 Zeilen fort.

747
00:39:56,000 --> 00:39:59,000
Sie können auch auf "Weiter", wenn Sie wirklich mit Schrittmotoren durch sie gefüttert.

748
00:39:59,000 --> 00:40:05,000
Weiter wird Ihr Programm ohne Unterbrechung laufen, bis es einen weiteren Haltepunkt trifft,

749
00:40:05,000 --> 00:40:07,000
ob in einer Schleife oder weiter unten in Ihrem Programm.

750
00:40:07,000 --> 00:40:11,000
>> In diesem Fall werden wir weiter bis zum Ende, und das Programm beendet normal.

751
00:40:11,000 --> 00:40:13,000
Dies ist eine andere Art, inferior Prozess.

752
00:40:13,000 --> 00:40:16,000
Nur Ihr Programm beendet normal.

753
00:40:16,000 --> 00:40:24,000
Mehr dazu im Video und in Debugging-Sitzungen zu kommen.

754
00:40:24,000 --> 00:40:26,000
Das war eine Menge.

755
00:40:26,000 --> 00:40:35,000
Nehmen wir unsere 5-minütige Pause hier, und wir werden mit Strukturen und Dateien zurückzukehren.

756
00:40:35,000 --> 00:40:38,000
>> Wenn Sie in dieser Woche pset tauchten bereits

757
00:40:38,000 --> 00:40:41,000
Sie wissen, dass wir bei der Verteilung Code zu verwenden,

758
00:40:41,000 --> 00:40:45,000
der Quellcode, die wir Ihnen bieten als Ausgangspunkt, einige neue Techniken.

759
00:40:45,000 --> 00:40:50,000
Insbesondere haben wir dieses neue Schlüsselwort heißt struct, für Struktur,

760
00:40:50,000 --> 00:40:53,000
so dass wir können benutzerdefinierte Variablen Sorten.

761
00:40:53,000 --> 00:40:57,000
Wir haben auch den Begriff des Datei-I / O, Datei-und Ausgang,

762
00:40:57,000 --> 00:41:00,000
und das ist so, dass wir den Staat zu retten

763
00:41:00,000 --> 00:41:03,000
Ihrer Scramble Bord in einer Datei auf einer Disc

764
00:41:03,000 --> 00:41:06,000
so dass die Lehre Stipendiaten und ich kann verstehen,

765
00:41:06,000 --> 00:41:09,000
was innerhalb des Programms gehen, ohne manuell zu spielen

766
00:41:09,000 --> 00:41:11,000
Dutzende von Spielen Scramble.

767
00:41:11,000 --> 00:41:13,000
Wir können dies mehr automatisiert zu tun.

768
00:41:13,000 --> 00:41:18,000
>> Diese Idee einer Struktur löst eine ziemlich überzeugende Problem.

769
00:41:18,000 --> 00:41:21,000
Angenommen, wir wollen einige Programm umsetzen wollen

770
00:41:21,000 --> 00:41:25,000
das irgendwie verfolgt von Informationen über Studenten,

771
00:41:25,000 --> 00:41:28,000
und Studenten haben könnte, zum Beispiel, eine ID, einen Namen

772
00:41:28,000 --> 00:41:31,000
und ein Haus an einem Ort wie Harvard, so sind diese 3 Stücke von Informationen

773
00:41:31,000 --> 00:41:34,000
Wir wollen, um zu halten, so lassen Sie mich gehen Sie vor und mit dem Schreiben beginnen ein kleines Programm hier

774
00:41:34,000 --> 00:41:38,000
gehören stdio.h.

775
00:41:38,000 --> 00:41:42,000
Lass es mich tun zählen cs50.h.

776
00:41:42,000 --> 00:41:44,000
Und dann beginne meine Hauptfunktion.

777
00:41:44,000 --> 00:41:46,000
Ich werde nicht mit Befehlszeilenargumenten stören,

778
00:41:46,000 --> 00:41:49,000
und hier möchte ich einen Schüler haben, so werde ich zu sagen

779
00:41:49,000 --> 00:41:54,000
ein Student hat einen Namen, so werde ich sagen: "string name."

780
00:41:54,000 --> 00:41:59,000
Dann werde ich sagen, ein Student hat auch eine ID, so int id,

781
00:41:59,000 --> 00:42:03,000
und ein Student hat ein Haus, so bin ich auch sagen würde "string Haus."

782
00:42:03,000 --> 00:42:06,000
Dann werde ich diese ein wenig mehr sauber bestellen wie diese.

783
00:42:06,000 --> 00:42:11,000
Okay, jetzt habe ich 3 Variablen, mit denen ein Student vertreten, so "ein Student."

784
00:42:11,000 --> 00:42:15,000
>> Und jetzt habe ich diese Werte auffüllen möchten, so lassen Sie es mich voran gehen und etwas sagen wie

785
00:42:15,000 --> 00:42:18,000
"Id = 123".

786
00:42:18,000 --> 00:42:21,000
Name wird David bekommen.

787
00:42:21,000 --> 00:42:24,000
Lassen Sie uns sagen Haus wird Mather bekommen,

788
00:42:24,000 --> 00:42:31,000
und dann werde ich etwas willkürlich wie printf zu tun ("% s,

789
00:42:31,000 --> 00:42:37,000
dessen ID% d, lebt in% s.

790
00:42:37,000 --> 00:42:41,000
Und jetzt, was ich will hier anschließen, einer nach dem anderen?

791
00:42:41,000 --> 00:42:47,000
Name, ID, Haus; return 0.

792
00:42:47,000 --> 00:42:50,000
Okay, wenn ich vermasselt irgendwo hier

793
00:42:50,000 --> 00:42:54,000
Ich denke, wir haben eine ziemlich gute Programm, das ein Student speichert.

794
00:42:54,000 --> 00:42:57,000
Natürlich ist dies nicht so interessant. Was, wenn ich 2 Studenten haben wollen?

795
00:42:57,000 --> 00:42:59,000
Das ist keine große Sache. Ich kann unterstützt 2 Personen.

796
00:42:59,000 --> 00:43:03,000
Lassen Sie mich gehen Sie vor und markieren Sie diese und gehen Sie hier

797
00:43:03,000 --> 00:43:09,000
und ich kann sagen "id = 456" für jemanden wie Rob, der in Kirkland lebt.

798
00:43:09,000 --> 00:43:12,000
>> Okay, warten, aber ich kann nicht nennen diese die gleiche Sache,

799
00:43:12,000 --> 00:43:15,000
und es sieht aus wie ich zu haben, um diese zu kopieren bin,

800
00:43:15,000 --> 00:43:19,000
so lassen Sie mich sagen, dass dies wird Davids Variablen,

801
00:43:19,000 --> 00:43:23,000
und lassen Sie mich einige Kopien davon für Rob.

802
00:43:23,000 --> 00:43:27,000
Wir rufen diese Robs aber dies ist nicht zur Arbeit gehen jetzt

803
00:43:27,000 --> 00:43:33,000
weil ich-warten haben, ändern wir mir id1, name1 und house1.

804
00:43:33,000 --> 00:43:35,000
Rob wird 2, 2.

805
00:43:35,000 --> 00:43:42,000
Ich habe dies hier, hier, hier, hier, hier, hier ändern.

806
00:43:42,000 --> 00:43:45,000
Warten Sie, was Tommy? Lasst uns wieder tun.

807
00:43:45,000 --> 00:43:49,000
Natürlich, wenn Sie immer noch denke, dies ist ein guter Weg, dies zu tun, ist es nicht,

808
00:43:49,000 --> 00:43:52,000
so kopieren / einfügen schlecht.

809
00:43:52,000 --> 00:43:55,000
Aber wir lösen diese vor einer Woche.

810
00:43:55,000 --> 00:43:59,000
>> Was war unsere Lösung, wenn wir mehrere Instanzen des gleichen Datentyp haben wollte?

811
00:43:59,000 --> 00:44:01,000
[Studenten] Ein Array.

812
00:44:01,000 --> 00:44:03,000
Ein Array, so lassen Sie mich versuchen, diese bereinigen.

813
00:44:03,000 --> 00:44:07,000
Lassen Sie mich einige Zimmer für mich an der Spitze, und lass mich tun, anstatt dies hier.

814
00:44:07,000 --> 00:44:12,000
Wir rufen diese Menschen, und stattdessen werde ich sagen, "int ids"

815
00:44:12,000 --> 00:44:14,000
und ich werde bis 3 von uns jetzt zu unterstützen.

816
00:44:14,000 --> 00:44:18,000
Ich werde sagen, "string Namen," und ich werde 3 von uns unterstützt,

817
00:44:18,000 --> 00:44:22,000
und dann werde ich sagen: "string Häuser," und ich werde bis 3 von uns zu unterstützen.

818
00:44:22,000 --> 00:44:26,000
Jetzt hier anstelle von David immer seine eigenen lokalen Variablen

819
00:44:26,000 --> 00:44:28,000
können wir diejenigen loswerden.

820
00:44:28,000 --> 00:44:30,000
Das fühlt sich gut, dass wir die Reinigung ausgedacht.

821
00:44:30,000 --> 00:44:35,000
Ich kann dann sagen, David wird [0] und Namen [0] sein

822
00:44:35,000 --> 00:44:38,000
und Häuser [0].

823
00:44:38,000 --> 00:44:41,000
Und dann Rob können wir ebenfalls auf diese zu speichern.

824
00:44:41,000 --> 00:44:46,000
Lassen Sie uns dies hier unten gesetzt, so er wird willkürlich ids [1] sein.

825
00:44:46,000 --> 00:44:50,000
Er will Namen sein [1],

826
00:44:50,000 --> 00:44:53,000
und dann schließlich, Häuser [1].

827
00:44:53,000 --> 00:44:57,000
>> Noch ein wenig langweilig, und jetzt habe ich, um dies herauszufinden,

828
00:44:57,000 --> 00:45:03,000
so sagen wir "names [0] id [0], Häuser [0]

829
00:45:03,000 --> 00:45:06,000
und lasst pluralize dies.

830
00:45:06,000 --> 00:45:09,000
Ids, IDs IDs.

831
00:45:09,000 --> 00:45:12,000
Und wieder, ich mache es, so wieder, ich bin schon Rückgriff auf copy / paste wieder

832
00:45:12,000 --> 00:45:14,000
so Chancen gibt es eine andere Lösung.

833
00:45:14,000 --> 00:45:18,000
Ich kann wahrscheinlich reinigen diese bis weiter mit einer Schleife oder so etwas,

834
00:45:18,000 --> 00:45:21,000
Also kurz gesagt, ist es ein wenig besser, aber immer noch das Gefühl

835
00:45:21,000 --> 00:45:24,000
Ich Rückgriff auf copy / paste, aber selbst das, behaupte ich,

836
00:45:24,000 --> 00:45:27,000
ist nicht wirklich grundlegend die richtige Lösung, weil

837
00:45:27,000 --> 00:45:29,000
was ist, wenn irgendwann entscheiden wir wissen Sie was?

838
00:45:29,000 --> 00:45:32,000
Wir sollten wirklich worden Speichern E-Mail-Adressen für David und Rob

839
00:45:32,000 --> 00:45:34,000
und alle anderen in diesem Programm.

840
00:45:34,000 --> 00:45:36,000
Wir sollten auch speichern Telefonnummern.

841
00:45:36,000 --> 00:45:39,000
Wir sollten auch speichern Notrufnummern.

842
00:45:39,000 --> 00:45:41,000
Wir haben alle diese Stücke von Daten, die wir speichern wollen,

843
00:45:41,000 --> 00:45:43,000
so wie Sie zu tun, dass?

844
00:45:43,000 --> 00:45:46,000
>> Sie erklären anderes Array an der Spitze, und dann manuell hinzufügen

845
00:45:46,000 --> 00:45:49,000
eine E-Mail-Adresse [0], E-Mail-Adresse [1]

846
00:45:49,000 --> 00:45:51,000
David und Rob und so weiter.

847
00:45:51,000 --> 00:45:56,000
Aber es ist wirklich nur eine Vermutung zugrunde liegende Design

848
00:45:56,000 --> 00:45:59,000
dass ich mit dem Ehren-System zu wissen, dass

849
00:45:59,000 --> 00:46:03,000
[I] in jedem der mehreren Arrays

850
00:46:03,000 --> 00:46:06,000
passiert einfach so auf die gleiche Person beziehen,

851
00:46:06,000 --> 00:46:10,000
so [0] in ids ist die Nummer 123,

852
00:46:10,000 --> 00:46:13,000
und ich werde, dass die Namen anzunehmen [0]

853
00:46:13,000 --> 00:46:16,000
ist die gleiche Person den Namen und Häuser [0]

854
00:46:16,000 --> 00:46:21,000
ist die gleiche Person das Haus und so weiter für all die verschiedenen Arrays, dass ich schaffen.

855
00:46:21,000 --> 00:46:24,000
Aber beachten Sie, dass es keinen fundamentalen Verknüpfung

856
00:46:24,000 --> 00:46:27,000
unter diesen 3 Stück von Informationen, id, name und Haus,

857
00:46:27,000 --> 00:46:32,000
obwohl das Unternehmen wir zu modellieren versucht sind in diesem Programm ist nicht Arrays.

858
00:46:32,000 --> 00:46:35,000
Arrays sind nur diese programmatischen Weg, dies zu tun.

859
00:46:35,000 --> 00:46:38,000
Was wir wirklich wollen, in unserem Programm zu modellieren ist eine Person,

860
00:46:38,000 --> 00:46:41,000
wie David, ein Mensch wie Rob innerhalb derer

861
00:46:41,000 --> 00:46:46,000
oder Verkapselung ist ein Name und ID und ein Haus.

862
00:46:46,000 --> 00:46:49,000
>> Können wir irgendwie ausdrücken diese Idee der Kapselung

863
00:46:49,000 --> 00:46:52,000
bei dem eine Person eine ID, einen Namen und ein Haus

864
00:46:52,000 --> 00:46:55,000
und nicht wirklich diesen Hack zurückgreifen, wobei wir nur

865
00:46:55,000 --> 00:46:58,000
vertrauen, dass Halterung etwas

866
00:46:58,000 --> 00:47:02,000
bezieht sich auf die gleiche Entität menschlichen in jedem dieser unterschiedlichen Arrays?

867
00:47:02,000 --> 00:47:04,000
Wir können tatsächlich tun.

868
00:47:04,000 --> 00:47:08,000
Lassen Sie mich oben gehen jetzt Haupt-, und lassen Sie mich meine eigenen Datentyp

869
00:47:08,000 --> 00:47:10,000
für wirklich die erste Zeit.

870
00:47:10,000 --> 00:47:14,000
Wir verwendeten diese Technik in Scramble,

871
00:47:14,000 --> 00:47:17,000
aber hier werde ich weitermachen und erstellen einen Datentyp,

872
00:47:17,000 --> 00:47:19,000
und wissen Sie was, ich werde nennen es Studenten oder Personen,

873
00:47:19,000 --> 00:47:23,000
und ich werde zu verwenden typedef definieren für einen Typ.

874
00:47:23,000 --> 00:47:25,000
Ich werde sagen, dass dies eine Struktur,

875
00:47:25,000 --> 00:47:29,000
und dann diese Struktur wird vom Typ Student sein, sagen wir,

876
00:47:29,000 --> 00:47:31,000
obwohl es jetzt ein wenig für mich datiert.

877
00:47:31,000 --> 00:47:33,000
Wir sagen "int id."

878
00:47:33,000 --> 00:47:35,000
Wir sagen "string name."

879
00:47:35,000 --> 00:47:37,000
Dann werden wir sagen, "string Haus"

880
00:47:37,000 --> 00:47:40,000
so jetzt bis Ende diesen wenigen Zeilen Code

881
00:47:40,000 --> 00:47:45,000
Ich habe gerade clang gelehrt, dass es existiert,

882
00:47:45,000 --> 00:47:49,000
ein Datentyp neben ints neben Saiten neben verdoppelt neben schwimmt.

883
00:47:49,000 --> 00:47:54,000
>> Ab diesem Zeitpunkt Linie 11 gibt es nun eine neue Datentyp namens Studenten,

884
00:47:54,000 --> 00:47:58,000
und jetzt kann ich ein Student variable überall Ich möchte erklären,

885
00:47:58,000 --> 00:48:01,000
so lassen Sie mich nach unten scrollen Sie hier, um die Menschen.

886
00:48:01,000 --> 00:48:05,000
Jetzt kann ich loswerden, und ich kann wieder auf David hier

887
00:48:05,000 --> 00:48:10,000
und David Ich kann wirklich sagen, dass David,

888
00:48:10,000 --> 00:48:13,000
Wir können buchstäblich einen Namen für die Variable nach mir,

889
00:48:13,000 --> 00:48:16,000
wird vom Typ Student sein.

890
00:48:16,000 --> 00:48:18,000
Dies aussehen könnte ein wenig seltsam, aber das ist gar nicht so verschieden

891
00:48:18,000 --> 00:48:22,000
von der Deklaration etwas als int oder einer Schnur oder einem Schwimmer.

892
00:48:22,000 --> 00:48:24,000
Es passiert einfach so genannt Studenten nun,

893
00:48:24,000 --> 00:48:28,000
und wenn ich will etwas in dieser Struktur setzen

894
00:48:28,000 --> 00:48:31,000
Ich habe jetzt ein neues Stück Syntax verwenden, aber es ist ziemlich einfach,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = "David" in der Hauptstadt D,

896
00:48:39,000 --> 00:48:42,000
und david.house = "Mather,"

897
00:48:42,000 --> 00:48:46,000
und jetzt kann ich loswerden von diesem Zeug hier.

898
00:48:46,000 --> 00:48:51,000
Haben wir nun feststellen, unser Programm in wirklich einen viel besseren Weg umgestaltet

899
00:48:51,000 --> 00:48:54,000
, dass nun unser Programm spiegelt die reale Welt.

900
00:48:54,000 --> 00:48:57,000
>> Es gibt eine reale Vorstellung von einer Person oder eines Schülers.

901
00:48:57,000 --> 00:49:02,000
Hier haben wir nun eine C-Version von einer Person oder genauer gesagt eines Schülers.

902
00:49:02,000 --> 00:49:05,000
Innerhalb von dieser Person sind diese relevanten Eigenschaften,

903
00:49:05,000 --> 00:49:10,000
ID, Name und Haus, so Rob Wesentlichen wird die gleiche Sache hier unten,

904
00:49:10,000 --> 00:49:14,000
so Studentin rob, und jetzt rob.id = 456,

905
00:49:14,000 --> 00:49:17,000
rob.name = "Rob."

906
00:49:17,000 --> 00:49:20,000
Die Tatsache, dass die Variable heißt Rob ist eine Art bedeutungslos.

907
00:49:20,000 --> 00:49:22,000
Wir konnten nannte x bzw. y bzw. z sind.

908
00:49:22,000 --> 00:49:25,000
Wir nannten es Rob als semantisch konsistent,

909
00:49:25,000 --> 00:49:28,000
aber wirklich der Name ist innerhalb dieses Feldes selbst,

910
00:49:28,000 --> 00:49:30,000
so jetzt habe ich dies.

911
00:49:30,000 --> 00:49:33,000
Auch nicht wie das beste Design, dass ich hart David habe kodiert fühlen.

912
00:49:33,000 --> 00:49:35,000
Ich habe hart Rob codiert.

913
00:49:35,000 --> 00:49:39,000
Und ich habe noch bis zu einem gewissen Kopie zurückgreifen und fügen Sie jedes Mal möchte ich neue Variablen.

914
00:49:39,000 --> 00:49:43,000
Außerdem habe ich scheinbar zu geben jede dieser Variablen einen Namen,

915
00:49:43,000 --> 00:49:46,000
obwohl ich würde viel lieber beschreiben diese Variablen

916
00:49:46,000 --> 00:49:48,000
 mehr allgemein als Studenten.

917
00:49:48,000 --> 00:49:52,000
>> Jetzt können wir verschmelzen die Ideen, die gearbeitet haben, gut für uns

918
00:49:52,000 --> 00:49:56,000
und stattdessen sagen: "Weißt du was, gib mir eine Variable namens Studenten,

919
00:49:56,000 --> 00:50:01,000
und lasst uns haben es der Größe 3 sein, "so kann ich jetzt zu verfeinern dies weiter,

920
00:50:01,000 --> 00:50:04,000
loszuwerden, die manuell erklärt David,

921
00:50:04,000 --> 00:50:08,000
und ich kann stattdessen etwas sagen wie Studenten [0] hier.

922
00:50:08,000 --> 00:50:11,000
Ich kann dann sagen Studenten [0] hier

923
00:50:11,000 --> 00:50:14,000
Studenten [0] hier, und so weiter, und ich kann gehen um

924
00:50:14,000 --> 00:50:16,000
und reinigen, dass für Rob.

925
00:50:16,000 --> 00:50:19,000
Ich könnte auch über jetzt vielleicht indem eine Schleife gehen

926
00:50:19,000 --> 00:50:23,000
und mit GetString und GetInt um tatsächlich diese Werte durch den Benutzer.

927
00:50:23,000 --> 00:50:27,000
Ich konnte über das Hinzufügen eines konstanten gehen, weil dies in der Regel schlechte Praxis

928
00:50:27,000 --> 00:50:29,000
hart zu codieren einige willkürliche Zahl wie 3 hier

929
00:50:29,000 --> 00:50:33,000
und dann nur daran erinnern, dass Sie sollten nicht mehr als 3 Studenten in sie setzen.

930
00:50:33,000 --> 00:50:36,000
Es wäre wahrscheinlich besser, # verwende am Anfang meiner Datei definieren

931
00:50:36,000 --> 00:50:40,000
und Faktor, dass sich, so der Tat, lassen Sie mich gehen Sie vor und verallgemeinern diese.

932
00:50:40,000 --> 00:50:43,000
>> Lassen Sie mich eröffnen ein Beispiel, das unter den heutigen ist

933
00:50:43,000 --> 00:50:46,000
Beispiele: Vorkasse, structs1.

934
00:50:46,000 --> 00:50:49,000
Dies ist ein komplettes Programm, das # define hier verwendet

935
00:50:49,000 --> 00:50:51,000
und sagt, wir gehen zu 3 Studenten standardmäßig haben.

936
00:50:51,000 --> 00:50:54,000
Hier bin ich die Deklaration einer Klasse im Wert von Studenten,

937
00:50:54,000 --> 00:50:57,000
so ein Klassenzimmer der Schüler, und jetzt bin ich mit einer Schleife

938
00:50:57,000 --> 00:51:00,000
nur um den Code ein wenig eleganter, bevölkern die Klasse

939
00:51:00,000 --> 00:51:05,000
Mit der Eingabe des Benutzers, so von i = 0 auf iterieren bis zu Studenten, die 3 ist.

940
00:51:05,000 --> 00:51:07,000
Und dann habe ich den Benutzer auffordern, in dieser Version

941
00:51:07,000 --> 00:51:10,000
 was ist der Schüler-ID, und ich bekomme es mit GetInt.

942
00:51:10,000 --> 00:51:13,000
Was ist der Name des Studenten, und dann bekomme ich es mit GetString.

943
00:51:13,000 --> 00:51:15,000
Was ist des Schülers Haus? Ich bekomme es mit GetString.

944
00:51:15,000 --> 00:51:19,000
Und dann am Ende hier habe ich gerade beschlossen zu ändern

945
00:51:19,000 --> 00:51:22,000
wie ich Drucken Sie diese aus und tatsächlich eine Schleife verwenden,

946
00:51:22,000 --> 00:51:24,000
Und wer bin ich Bedrucken?

947
00:51:24,000 --> 00:51:27,000
Nach dem Kommentar, den ich bin Drucken jemand in Mather,

948
00:51:27,000 --> 00:51:30,000
und dass es so Rob und Tommy und so weiter, eigentlich Tommys in Mather.

949
00:51:30,000 --> 00:51:34,000
Tommy und David würde in diesem Fall gedruckt werden, aber wie wird das funktioniert?

950
00:51:34,000 --> 00:51:40,000
Wir haben diese Funktion nicht gesehen, aber zu erraten, was diese tut.

951
00:51:40,000 --> 00:51:42,000
Vergleicht Strings.

952
00:51:42,000 --> 00:51:45,000
>> Es ist ein wenig nicht klar, wie es Zeichenketten verglichen, weil sich herausstellt,

953
00:51:45,000 --> 00:51:49,000
wenn es 0 zurückgibt dh die Saiten sind gleich.

954
00:51:49,000 --> 00:51:53,000
Wenn es eine gibt -1 dh kommt Reihenfolge vor dem anderen,

955
00:51:53,000 --> 00:51:57,000
und wenn es ein gibt das heißt das andere Wort kommt alphabetisch

956
00:51:57,000 --> 00:52:00,000
vor dem anderen, und Sie können sich online oder auf der Manpage

957
00:52:00,000 --> 00:52:04,000
um genau zu sehen, welchen Weg ist, die aber all dies ist nun zu tun ist es sagt

958
00:52:04,000 --> 00:52:09,000
wenn die [i]. Haus ist gleich "Mather"

959
00:52:09,000 --> 00:52:13,000
dann gehen Sie vor und drucken Sie so und so ist in Mather.

960
00:52:13,000 --> 00:52:16,000
Aber hier ist etwas, was wir nicht gesehen haben, bevor, und wir kommen darauf zurück.

961
00:52:16,000 --> 00:52:21,000
Ich erinnere mich nicht, jemals dazu in keinem meiner Programme.

962
00:52:21,000 --> 00:52:24,000
Free ist offenbar auf Speicher freigegeben werden kann,

963
00:52:24,000 --> 00:52:31,000
aber was Speicher bin ich anscheinend zu befreien in dieser Schleife am unteren Rand dieses Programms?

964
00:52:31,000 --> 00:52:34,000
Es sieht aus wie ich befreit den Namen einer Person bin

965
00:52:34,000 --> 00:52:37,000
und eine Person das Haus, aber warum ist das so?

966
00:52:37,000 --> 00:52:41,000
>> Es stellt sich heraus all diesen Wochen, dass Sie schon mit GetString

967
00:52:41,000 --> 00:52:45,000
Wir haben Art wurde die Einführung eines Fehlers in jedem Ihrer Programme.

968
00:52:45,000 --> 00:52:51,000
GetString by design Speicher zuweist, so dass es für Sie eine Zeichenfolge zurückgeben kann,

969
00:52:51,000 --> 00:52:55,000
wie David oder Rob, und Sie können dann tun, was Sie wollen

970
00:52:55,000 --> 00:52:59,000
mit diesem String in Ihrem Programm, weil wir den Speicher für Sie reserviert.

971
00:52:59,000 --> 00:53:02,000
Das Problem ist, die ganze Zeit jedes Mal, rufen Sie GetString

972
00:53:02,000 --> 00:53:05,000
wir, die Autoren der GetString, gefragt haben das Betriebssystem

973
00:53:05,000 --> 00:53:07,000
um uns ein wenig RAM für diesen String.

974
00:53:07,000 --> 00:53:09,000
Geben Sie uns ein bisschen RAM für die nächste Saite.

975
00:53:09,000 --> 00:53:11,000
Gib uns etwas mehr RAM für die nächste Saite.

976
00:53:11,000 --> 00:53:13,000
Was Sie als Programmierer, noch nie getan

977
00:53:13,000 --> 00:53:15,000
gibt uns das Gedächtnis zurück,

978
00:53:15,000 --> 00:53:17,000
so für diese mehrere Wochen alle Programme, die Sie geschrieben haben,

979
00:53:17,000 --> 00:53:20,000
gehabt haben, was eine Speicherkarte Sprung bezeichnet, wodurch sie mit zu halten

980
00:53:20,000 --> 00:53:24,000
mehr und mehr Speicher jedes Mal rufen Sie GetString, und das ist in Ordnung.

981
00:53:24,000 --> 00:53:27,000
Wir haben uns bewusst machen, dass in den ersten Wochen, weil es nicht so interessant

982
00:53:27,000 --> 00:53:29,000
zu müssen, wo die Saite herkommt kümmern.

983
00:53:29,000 --> 00:53:34,000
Alles, was Sie wollen, ist das Wort Rob wieder zu kommen, wenn der Benutzer es in.

984
00:53:34,000 --> 00:53:38,000
>> Aber voran müssen wir jetzt beginnen immer ausgefeilter darüber.

985
00:53:38,000 --> 00:53:42,000
Jedes Mal, wenn wir Speicherzuweisung wir besser schließlich geben es zurück.

986
00:53:42,000 --> 00:53:45,000
Ansonsten in der realen Welt auf Ihrem Mac oder PC haben Sie vielleicht gelegentlich erfahrenen

987
00:53:45,000 --> 00:53:50,000
Symptome, wo Ihr Computer zu einem Stillstand Schleifen wird schließlich

988
00:53:50,000 --> 00:53:54,000
oder die dumme Spinnerei Beachball gerade Besetzung des Computers

989
00:53:54,000 --> 00:53:56,000
ganze Aufmerksamkeit und Sie können nicht Dinge tun.

990
00:53:56,000 --> 00:54:00,000
Dies kann durch eine beliebige Anzahl von Bugs erklärt werden, aber unter diesen möglichen Fehler

991
00:54:00,000 --> 00:54:03,000
werden Dinge genannt Speicherlecks wodurch jemand dieses Stück Software geschrieben

992
00:54:03,000 --> 00:54:07,000
Sie verwenden nicht um Speicher frei zu erinnern

993
00:54:07,000 --> 00:54:10,000
dass er oder sie gebeten das Betriebssystem für,

994
00:54:10,000 --> 00:54:14,000
nicht mit GetString, denn das ist ein CS50 Sache, aber mit ähnlichen Funktionen

995
00:54:14,000 --> 00:54:16,000
, die das Betriebssystem für den Speicher zu stellen.

996
00:54:16,000 --> 00:54:19,000
Wenn Sie oder sie vermasseln und eigentlich nie zurück, dass der Speicher

997
00:54:19,000 --> 00:54:24,000
ein Symptom, das sein, dass ein Programm und verlangsamt verlangsamt und verlangsamt können

998
00:54:24,000 --> 00:54:26,000
wenn Sie daran denken, rufen Sie kostenlos.

999
00:54:26,000 --> 00:54:28,000
>> Wir kommen wieder, wann und warum Sie kostenlos anrufen,

1000
00:54:28,000 --> 00:54:32,000
aber lassen Sie uns gehen, nur für eine gute Maßnahme und versuchen Sie, dieses besondere Programm.

1001
00:54:32,000 --> 00:54:35,000
Dies hieß structs1 geben.

1002
00:54:35,000 --> 00:54:40,000
Lassen Sie mich gehen Sie vor und führen Sie structs1, 123, David Mather,

1003
00:54:40,000 --> 00:54:47,000
456, Rob Kirkland, 789,

1004
00:54:47,000 --> 00:54:50,000
Tommy Mather, und wir sehen Davids in Mather, Tommys in Mather.

1005
00:54:50,000 --> 00:54:53,000
Dies ist nur eine kleine Plausibilitätsprüfung, dass das Programm funktioniert.

1006
00:54:53,000 --> 00:54:56,000
Nun, leider ist dieses Programm ein wenig frustrierend, dass

1007
00:54:56,000 --> 00:55:00,000
Ich habe all die Arbeit, die ich in 9 verschiedenen Zeichenketten eingegeben, drücken Sie Enter,

1008
00:55:00,000 --> 00:55:04,000
wurde gesagt, wer war in Mather, aber natürlich wusste ich, wer war in Mather schon, weil ich es eingetippt haben.

1009
00:55:04,000 --> 00:55:07,000
Es wäre zumindest schön, wenn dieses Programm ist mehr wie eine Datenbank

1010
00:55:07,000 --> 00:55:10,000
und es tatsächlich merkt, was ich eingetippt

1011
00:55:10,000 --> 00:55:12,000
so dass ich nie wieder die Eingabe diese Studenten Aufzeichnungen.

1012
00:55:12,000 --> 00:55:15,000
Vielleicht ist es wie ein registrarial System.

1013
00:55:15,000 --> 00:55:21,000
>> Wir können dies tun, indem diese Technik als Datei-I / O, Datei-und Ausgang bekannt ist,

1014
00:55:21,000 --> 00:55:24,000
eine sehr allgemeine Weise des Sagens wann immer Sie wollen, um Dateien zu lesen oder Schreiben von Dateien

1015
00:55:24,000 --> 00:55:26,000
Sie können dies mit einem bestimmten Satz von Funktionen zu tun.

1016
00:55:26,000 --> 00:55:29,000
Lassen Sie mich gehen Sie vor und öffnen Sie dieses Beispiel structs2.c,

1017
00:55:29,000 --> 00:55:33,000
das ist fast identisch, aber mal sehen, was es jetzt tut.

1018
00:55:33,000 --> 00:55:36,000
Am Anfang der Datei erkläre ich eine Klasse von Studenten.

1019
00:55:36,000 --> 00:55:38,000
Ich habe dann bevölkern die Klasse mit der Eingabe des Benutzers,

1020
00:55:38,000 --> 00:55:41,000
so dass diese Code-Zeilen sind genau wie früher.

1021
00:55:41,000 --> 00:55:45,000
Dann, wenn ich hier unten scrollen drucke ich alle, die in Mather ist beliebig wie vorher,

1022
00:55:45,000 --> 00:55:47,000
aber das ist eine interessante neue Funktion.

1023
00:55:47,000 --> 00:55:51,000
Diese Codezeilen sind neu, und führen sie hier etwas,

1024
00:55:51,000 --> 00:55:55,000
FILE, alle Kappen, und es hat * in auch hier.

1025
00:55:55,000 --> 00:55:58,000
Lassen Sie mich zu bewegen diese hier, eine * über hier.

1026
00:55:58,000 --> 00:56:00,000
>> Diese Funktion haben wir nicht gesehen, fopen,

1027
00:56:00,000 --> 00:56:03,000
aber es Datei bedeutet, offen, also lasst überfliegen diesen

1028
00:56:03,000 --> 00:56:05,000
und dies ist etwas, das wir wieder kommen werden, um in Zukunft pset

1029
00:56:05,000 --> 00:56:10,000
aber diese Linie hier im Wesentlichen öffnet eine Datei namens Datenbank

1030
00:56:10,000 --> 00:56:13,000
und es öffnet sie spezifisch in der Weise, dass er, was zu tun?

1031
00:56:13,000 --> 00:56:15,000
[Unverständlich-Student]

1032
00:56:15,000 --> 00:56:19,000
Richtig, so "w" bedeutet nur, es zu sagen das Betriebssystem

1033
00:56:19,000 --> 00:56:21,000
Öffnen Sie diese Datei in einer Weise, dass ich es zu schreiben.

1034
00:56:21,000 --> 00:56:23,000
Ich will nicht, es zu lesen. Ich will nicht nur auf ihn achten.

1035
00:56:23,000 --> 00:56:26,000
Ich möchte es ändern und Dinge möglicherweise dazu,

1036
00:56:26,000 --> 00:56:28,000
und die Datei wird als Datenbank.

1037
00:56:28,000 --> 00:56:30,000
Das kann alles abgerufen werden.

1038
00:56:30,000 --> 00:56:32,000
Dies könnte database.txt. Dies könnte. Db sein.

1039
00:56:32,000 --> 00:56:37,000
Dies könnte ein Wort wie foo sein, aber ich willkürlich gewählt, um die Datei-Datenbank zu nennen.

1040
00:56:37,000 --> 00:56:42,000
Dies ist ein wenig Plausibilitätsprüfung, dass wir kommen zurück, um im Detail über die Zeit,

1041
00:56:42,000 --> 00:56:47,000
wenn fp für Dateizeiger, nicht gleich NULL dh alles ist gut.

1042
00:56:47,000 --> 00:56:51,000
>> Lange Rede kurzer Sinn, Funktionen wie fopen manchmal fehl.

1043
00:56:51,000 --> 00:56:53,000
Möglicherweise ist die Datei nicht existiert. Vielleicht sind Sie von Speicherplatz.

1044
00:56:53,000 --> 00:56:55,000
Vielleicht haben Sie nicht die Berechtigung in diesem Ordner,

1045
00:56:55,000 --> 00:56:58,000
also wenn fopen gibt null etwas Schlimmes passiert.

1046
00:56:58,000 --> 00:57:02,000
Umgekehrt, wenn fopen nicht zurück null ist alles gut

1047
00:57:02,000 --> 00:57:04,000
und ich kann mit dem Schreiben beginnen diese Datei.

1048
00:57:04,000 --> 00:57:06,000
Hier ist ein neuer Trick.

1049
00:57:06,000 --> 00:57:08,000
Dies ist eine for-Schleife, Iteration über ist jeder meiner Studenten,

1050
00:57:08,000 --> 00:57:10,000
und das sieht so ähnlich, was wir bisher gemacht habe,

1051
00:57:10,000 --> 00:57:15,000
aber diese Funktion ist ein Cousin von printf fprintf für Datei printf aufgerufen,

1052
00:57:15,000 --> 00:57:18,000
und bemerken es anders in nur 2 Möglichkeiten.

1053
00:57:18,000 --> 00:57:20,000
Einer, es beginnt mit f statt p,

1054
00:57:20,000 --> 00:57:23,000
aber dann das erste Argument ist offenbar was?

1055
00:57:23,000 --> 00:57:25,000
[Studenten] File. >> Es ist eine Datei.

1056
00:57:25,000 --> 00:57:30,000
Dieses Ding namens fp, die wir schließlich zu necken werde auseinander, was einen Dateizeiger ist,

1057
00:57:30,000 --> 00:57:35,000
aber jetzt fp stellt einfach die Datei, die ich geöffnet haben,

1058
00:57:35,000 --> 00:57:41,000
so fprintf hier sagen Drucken Sie diese Benutzer-ID in der Datei, nicht auf dem Bildschirm.

1059
00:57:41,000 --> 00:57:44,000
Drucken den Namen des Benutzers in der Datei, nicht auf dem Bildschirm,

1060
00:57:44,000 --> 00:57:47,000
Das Haus an der Datei nicht auf dem Bildschirm, und dann hier unten, offensichtlich,

1061
00:57:47,000 --> 00:57:50,000
schließen Sie die Datei, und dann hinunter hier kostenlos das Gedächtnis.

1062
00:57:50,000 --> 00:57:53,000
>> Der einzige Unterschied zwischen dieser Version 2 und 1

1063
00:57:53,000 --> 00:57:58,000
ist die Einführung von fopen und diese Datei mit *

1064
00:57:58,000 --> 00:58:01,000
und diese Vorstellung von fprintf, also lasst uns sehen, was das Ergebnis ist.

1065
00:58:01,000 --> 00:58:03,000
Lassen Sie mich in mein Terminal-Fenster zu gehen.

1066
00:58:03,000 --> 00:58:06,000
Lassen Sie mich laufen structs2 geben.

1067
00:58:06,000 --> 00:58:09,000
Sieht aus wie alles ist gut. Lassen Sie uns erneut structs2.

1068
00:58:09,000 --> 00:58:15,000
123, David Mather, 456, Rob Kirkland,

1069
00:58:15,000 --> 00:58:19,000
789, Tommy Mather, geben.

1070
00:58:19,000 --> 00:58:23,000
Sieht aus wie es die gleiche verhalten, aber wenn ich jetzt tun ls

1071
00:58:23,000 --> 00:58:28,000
feststellen, welche Datei ist hier unter all meinen Code, Datenbank,

1072
00:58:28,000 --> 00:58:32,000
so öffnen wir, dass gedit der Datenbank, und schauen Sie sich, dass.

1073
00:58:32,000 --> 00:58:34,000
Es ist nicht die sexiest von Dateiformaten.

1074
00:58:34,000 --> 00:58:38,000
Es ist wirklich ein Stück von Daten Zeile für Zeile pro Zeile,

1075
00:58:38,000 --> 00:58:42,000
aber diejenigen von euch, die Excel-oder CSV-Dateien verwenden, Komma Werten getrennt,

1076
00:58:42,000 --> 00:58:47,000
Ich könnte sicherlich fprintf verwendet haben, statt vielleicht etwas tun

1077
00:58:47,000 --> 00:58:50,000
so dass ich tatsächlich schaffen das Äquivalent einer Excel-Datei

1078
00:58:50,000 --> 00:58:53,000
durch die Trennung Dinge mit Kommas, nicht nur neue Linien.

1079
00:58:53,000 --> 00:58:56,000
>> In diesem Fall hätte ich statt Kommas anstelle von neuen Linien verwendet

1080
00:58:56,000 --> 00:59:01,000
Ich konnte buchstäblich öffnen Sie diese Datenbank-Datei in Excel, wenn ich machte, anstatt es so aussehen.

1081
00:59:01,000 --> 00:59:03,000
Kurz gesagt, jetzt, dass wir die Macht haben, Dateien zu schreiben

1082
00:59:03,000 --> 00:59:07,000
Wir können jetzt damit beginnen anhaltenden Daten, hält es rund auf der Disc

1083
00:59:07,000 --> 00:59:10,000
so dass wir Informationen rund um wieder und wieder zu halten.

1084
00:59:10,000 --> 00:59:14,000
Beachten Sie ein paar andere Dinge, die jetzt ein bisschen mehr vertraut.

1085
00:59:14,000 --> 00:59:16,000
An der Spitze dieser C-Datei haben wir einen typedef

1086
00:59:16,000 --> 00:59:21,000
denn wir wollten einen Datentyp, der ein Wort darstellt, erstellt wird,

1087
00:59:21,000 --> 00:59:25,000
so dass diese Art genannt wird Wort, und innerhalb dieser Struktur

1088
00:59:25,000 --> 00:59:27,000
es ist ein wenig schicker jetzt.

1089
00:59:27,000 --> 00:59:30,000
Warum ist ein Wort aus scheinbar ein Array gemacht?

1090
00:59:30,000 --> 00:59:33,000
Was ist ein Wort nur intuitiv?

1091
00:59:33,000 --> 00:59:35,000
>> Es ist ein Array von Zeichen.

1092
00:59:35,000 --> 00:59:37,000
Es ist eine Folge von Zeichen Rücken an Rücken an Rücken.

1093
00:59:37,000 --> 00:59:41,000
BRIEFE in allen Caps passiert zu sein wir willkürlich sagen, dass die maximale Länge

1094
00:59:41,000 --> 00:59:44,000
von jedem Wort im Wörterbuch, dass wir für Scramble verwenden.

1095
00:59:44,000 --> 00:59:46,000
Warum muss ich eine +1?

1096
00:59:46,000 --> 00:59:48,000
Das Null-Zeichen.

1097
00:59:48,000 --> 00:59:51,000
Erinnern, wenn wir die Bananagrams Beispiel haben wir einen besonderen Wert nötig

1098
00:59:51,000 --> 00:59:55,000
am Ende des Wortes, um zu verfolgen

1099
00:59:55,000 --> 00:59:59,000
wo Worte tatsächlich zu Ende, und wie das Problem Satz Spezifikation sagt

1100
00:59:59,000 --> 01:00:03,000
hier haben wir es mit einem gegebenen Wort assoziieren einen booleschen Wert,

1101
01:00:03,000 --> 01:00:05,000
eine Fahne, so zu sprechen, wahr oder falsch.

1102
01:00:05,000 --> 01:00:09,000
Haben Sie dieses Wort schon gefunden, weil wir erkennen,

1103
01:00:09,000 --> 01:00:13,000
wir wirklich brauchen, einen Weg des Erinnerns nicht nur, was ein Wort ist in Scramble

1104
01:00:13,000 --> 01:00:15,000
aber ob Sie, der Mensch, habe es gefunden

1105
01:00:15,000 --> 01:00:20,000
so dass, wenn Sie tun, das Wort "das" man kann nicht einfach geben Sie das Geben, das Geben, das Geben

1106
01:00:20,000 --> 01:00:23,000
und erhalten Sie 3 Punkte, 3 Punkte, 3 Punkte, 3 Punkte.

1107
01:00:23,000 --> 01:00:26,000
Wir wollen in der Lage sein, dieses Wort, indem Sie einen bool Blacklist

1108
01:00:26,000 --> 01:00:29,000
true, wenn Sie es bereits gefunden habe, und damit ist, warum wir

1109
01:00:29,000 --> 01:00:31,000
eingekapselt in dieser Struktur.

1110
01:00:31,000 --> 01:00:35,000
>> Nun, hier unten in Scramble gibt es diese anderen struct genannt Wörterbuch.

1111
01:00:35,000 --> 01:00:39,000
Abwesend ist hier das Wort typedef weil in diesem Fall

1112
01:00:39,000 --> 01:00:43,000
wir brauchten, um die Idee eines Wörterbuchs zu kapseln,

1113
01:00:43,000 --> 01:00:46,000
und ein Wörterbuch enthält eine ganze Reihe von Wörtern,

1114
01:00:46,000 --> 01:00:49,000
wie von diesem Array implizit, und wie viele von diesen Worten gibt es?

1115
01:00:49,000 --> 01:00:51,000
Nun, was diese Variable namens Größe sagt.

1116
01:00:51,000 --> 01:00:53,000
Aber wir brauchen nur ein Wörterbuch.

1117
01:00:53,000 --> 01:00:55,000
Wir brauchen nicht einen Datentyp namens Wörterbuch.

1118
01:00:55,000 --> 01:00:58,000
Wir brauchen nur eine von ihnen, so stellt sich heraus, in C

1119
01:00:58,000 --> 01:01:03,000
dass, wenn Sie nicht sagen typedef, die Sie gerade sagen, struct, dann innerhalb der geschweiften Klammern

1120
01:01:03,000 --> 01:01:05,000
Sie setzen Ihre Variablen, dann setzen Sie den Namen.

1121
01:01:05,000 --> 01:01:09,000
Dies wird erklärt ein Variable namens Wörterbuch

1122
01:01:09,000 --> 01:01:11,000
das sieht wie folgt aus.

1123
01:01:11,000 --> 01:01:16,000
Im Gegensatz dazu, werden diese Linien, die eine wiederverwendbare Datenstruktur namens Wort

1124
01:01:16,000 --> 01:01:19,000
Sie können mehrere Kopien, wie wir geschaffen

1125
01:01:19,000 --> 01:01:22,000
mehrere Kopien von Studenten.

1126
01:01:22,000 --> 01:01:24,000
>> Was bedeutet das es uns ermöglichen, zu tun?

1127
01:01:24,000 --> 01:01:30,000
Lassen Sie mich zurück in, sagen wir, ein einfacheres Beispiel aus einfacheren Zeiten,

1128
01:01:30,000 --> 01:01:34,000
und lassen Sie mich öffnen, sagen wir mal, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
Das Problem hier bei der Hand ist, um tatsächlich abziehen

1130
01:01:38,000 --> 01:01:41,000
die Schicht aus einem String und starten Ausziehen diese Stützräder

1131
01:01:41,000 --> 01:01:44,000
weil es stellt sich heraus, dass ein String ganze Zeit

1132
01:01:44,000 --> 01:01:47,000
ist, wie wir in der Woche 1 wirklich versprochen, nur einen Spitznamen,

1133
01:01:47,000 --> 01:01:51,000
ein Synonym von der CS50-Bibliothek für etwas, das ein wenig mehr kryptisch aussieht,

1134
01:01:51,000 --> 01:01:53,000
char *, und wir haben diesen Stern gesehen.

1135
01:01:53,000 --> 01:01:55,000
Wir sahen sie in den Kontext von Dateien.

1136
01:01:55,000 --> 01:01:59,000
>> Lassen Sie uns nun sehen, warum wir versteckt habe dieses Detail für einige Zeit.

1137
01:01:59,000 --> 01:02:02,000
Hier ist eine Datei namens compare1.c,

1138
01:02:02,000 --> 01:02:07,000
und es scheint fragt den Benutzer nach 2 Strings, s und t,

1139
01:02:07,000 --> 01:02:11,000
und dann versucht, diese Zeichenfolgen für die Gleichstellung in Zeile 26 zu vergleichen,

1140
01:02:11,000 --> 01:02:14,000
und wenn sie gleich heißt es bist "Du dasselbe getippt"

1141
01:02:14,000 --> 01:02:17,000
und wenn sie es nicht sind gleich heißt es: "Sie gaben verschiedene Dinge."

1142
01:02:17,000 --> 01:02:19,000
Lassen Sie mich gehen Sie vor und führen Sie dieses Programm.

1143
01:02:19,000 --> 01:02:23,000
Lassen Sie mich in mein Quellverzeichnis, machen Sie eine compare1. Es zusammengestellt okay.

1144
01:02:23,000 --> 01:02:25,000
Lassen Sie mich laufen compare1.

1145
01:02:25,000 --> 01:02:27,000
Ich werde zu vergrößern, geben.

1146
01:02:27,000 --> 01:02:29,000
Etwas sagen. HALLO.

1147
01:02:29,000 --> 01:02:32,000
Ich werde wieder etwas sagen. HALLO.

1148
01:02:32,000 --> 01:02:34,000
Ich habe definitiv nicht geben verschiedene Dinge.

1149
01:02:34,000 --> 01:02:37,000
>> Lassen Sie mich noch einmal versuchen. BYE BYE.

1150
01:02:37,000 --> 01:02:40,000
Definitiv nicht anders, so was ist denn hier los?

1151
01:02:40,000 --> 01:02:44,000
Nun, das ist, was wirklich in Zeile 26 verglichen?

1152
01:02:44,000 --> 01:02:46,000
[Unverständlich-Student]

1153
01:02:46,000 --> 01:02:49,000
Ja, so stellt sich heraus, dass ein String, der Datentyp, eine Art Notlüge ist.

1154
01:02:49,000 --> 01:02:53,000
Ein String ist eine char *, aber was ist ein char *?

1155
01:02:53,000 --> 01:02:56,000
Ein char *, wie sie sagen, ist ein Zeiger,

1156
01:02:56,000 --> 01:03:00,000
und ein Zeiger ist effektiv eine Adresse,

1157
01:03:00,000 --> 01:03:05,000
eine Summe Stelle im Speicher, und wenn Sie zufällig in einem Wort wie HALLO eingegeben haben,

1158
01:03:05,000 --> 01:03:08,000
erinnern, aus der Vergangenheit Diskussionen über Strings

1159
01:03:08,000 --> 01:03:16,000
Das ist wie das Wort HALLO.

1160
01:03:16,000 --> 01:03:19,000
Beachten Sie, dass ein Wort wie HALLO dargestellt werden können,

1161
01:03:19,000 --> 01:03:22,000
als ein Array von Zeichen wie dies

1162
01:03:22,000 --> 01:03:25,000
und dann mit einem speziellen Zeichen am Ende genannt Nullzeichen

1163
01:03:25,000 --> 01:03:27,000
als \ bezeichnet.

1164
01:03:27,000 --> 01:03:29,000
Was ist eigentlich ein String?

1165
01:03:29,000 --> 01:03:32,000
Beachten Sie, dass diese mehrere Stücke der Erinnerung,

1166
01:03:32,000 --> 01:03:36,000
und in der Tat, ist das Ende der nur bekannt, wenn Sie durch den ganzen String suchen

1167
01:03:36,000 --> 01:03:38,000
Suche nach dem besonderen null Charakter.

1168
01:03:38,000 --> 01:03:41,000
Aber wenn dies ein Stück Erinnerung aus meinem Arbeitsspeicher des Computers,

1169
01:03:41,000 --> 01:03:44,000
lasst uns willkürlich sagen, dass diese Zeichenfolge einfach nur Glück,

1170
01:03:44,000 --> 01:03:47,000
und es wurde ganz am Anfang meines Computers RAM platziert.

1171
01:03:47,000 --> 01:03:54,000
Dies ist das Byte 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> Wenn ich etwas sagen wie GetString und ich string s = GetString

1173
01:04:02,000 --> 01:04:04,000
was wirklich zurückgegeben?

1174
01:04:04,000 --> 01:04:08,000
Für diese letzten paar Wochen, was ist wirklich in s gespeichert

1175
01:04:08,000 --> 01:04:13,000
nicht diese Zeichenfolge per se, aber in diesem Fall, was gespeichert ist

1176
01:04:13,000 --> 01:04:18,000
die Zahl 0, denn was GetString tatsächlich

1177
01:04:18,000 --> 01:04:20,000
ist es nicht physisch einen String zurück.

1178
01:04:20,000 --> 01:04:22,000
Das bedeutet aber nicht, auch wirklich konzeptionellen Sinn.

1179
01:04:22,000 --> 01:04:24,000
Was sie tut, Rückkehr eine Zahl ist.

1180
01:04:24,000 --> 01:04:28,000
Diese Zahl ist die Adresse des HALLO im Speicher

1181
01:04:28,000 --> 01:04:32,000
und String s dann, wenn wir abziehen diese Schicht, wird String nicht wirklich existieren.

1182
01:04:32,000 --> 01:04:35,000
Es ist nur eine Vereinfachung der CS50-Bibliothek.

1183
01:04:35,000 --> 01:04:38,000
>> Das ist wirklich etwas namens char *.

1184
01:04:38,000 --> 01:04:41,000
Char macht Sinn, denn was ist ein Wort, wie HALLO?

1185
01:04:41,000 --> 01:04:44,000
Nun, es ist eine Reihe von Zeichen, eine Reihe von Zeichen.

1186
01:04:44,000 --> 01:04:47,000
Char * bedeutet die Adresse eines Zeichens,

1187
01:04:47,000 --> 01:04:50,000
so was bedeutet es, einen String zurückgeben?

1188
01:04:50,000 --> 01:04:53,000
Eine schöne, einfache Möglichkeit der Rücksendung einen String

1189
01:04:53,000 --> 01:04:57,000
ist, anstatt zu versuchen, herauszufinden, wie ich 5 oder 6 verschiedenen Bytes zurück

1190
01:04:57,000 --> 01:05:01,000
Lassen Sie mich an die Adresse von welchem ​​Byte zurück?

1191
01:05:01,000 --> 01:05:03,000
Die erste.

1192
01:05:03,000 --> 01:05:06,000
In anderen Worten, lassen Sie mich Ihnen die Adresse eines Zeichens im Speicher.

1193
01:05:06,000 --> 01:05:10,000
Das hat char * darstellt, die Adresse der ein einzelnes Zeichen in den Speicher.

1194
01:05:10,000 --> 01:05:12,000
Rufen Sie die Variable s.

1195
01:05:12,000 --> 01:05:15,000
Store in s, dass bestimmte Adresse, die ich willkürlich die 0 ist,

1196
01:05:15,000 --> 01:05:19,000
nur um die Dinge einfach halten, aber in Wirklichkeit ist es in der Regel eine größere Anzahl.

1197
01:05:19,000 --> 01:05:21,000
>> Warten Sie eine Minute.

1198
01:05:21,000 --> 01:05:23,000
Wenn Sie nur geben sind mir die Adresse des ersten Zeichens, wie kann ich wissen, was die Adresse

1199
01:05:23,000 --> 01:05:25,000
des zweiten Zeichens, das dritte, das vierte und das fünfte?

1200
01:05:25,000 --> 01:05:27,000
[Unverständlich-Student]

1201
01:05:27,000 --> 01:05:31,000
Sie müssen nur wissen, wo das Ende des Strings ist durch dieses handlichen Trick,

1202
01:05:31,000 --> 01:05:35,000
so, wenn Sie etwas verwenden, wie printf, was printf wörtlich nimmt als Argument,

1203
01:05:35,000 --> 01:05:39,000
erinnern, dass wir dieses% s Platzhalter verwenden, und dann passieren,

1204
01:05:39,000 --> 01:05:41,000
die Variable, die die Speicherung eines Strings ist.

1205
01:05:41,000 --> 01:05:47,000
Was Sie wirklich vorbei ist die Adresse des ersten Zeichens des Strings.

1206
01:05:47,000 --> 01:05:50,000
Printf verwendet dann eine for-Schleife oder eine while-Schleife mit dem Erhalt der Adresse,

1207
01:05:50,000 --> 01:05:53,000
zum Beispiel 0, so lassen Sie mich dies jetzt zu tun,

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n", s);

1209
01:06:02,000 --> 01:06:07,000
Wenn ich rufe printf ("% s \ n", s); was ich wirklich Bereitstellung printf mit

1210
01:06:07,000 --> 01:06:13,000
ist die Adresse des ersten Zeichens in s, der in diesem Fall beliebig ist H.

1211
01:06:13,000 --> 01:06:16,000
>> Wie funktioniert printf wissen, was genau auf dem Bildschirm angezeigt werden?

1212
01:06:16,000 --> 01:06:19,000
Die Person, die umgesetzt printf eine while-Schleife oder eine for-Schleife implementiert

1213
01:06:19,000 --> 01:06:23,000
das sagt dieser Charakter entsprechen nicht den besonderen null Charakter?

1214
01:06:23,000 --> 01:06:25,000
Wenn nicht, ausdrucken. Wie wäre es mit diesem?

1215
01:06:25,000 --> 01:06:28,000
Wenn nicht drucken, drucken, drucken, drucken.

1216
01:06:28,000 --> 01:06:32,000
Oh, das ist ein besonderes. Brechen Sie den Druckvorgang und kehren an den Benutzer.

1217
01:06:32,000 --> 01:06:35,000
Und das ist buchstäblich alles, was unter der Haube wurde passiert,

1218
01:06:35,000 --> 01:06:38,000
und das ist eine Menge in den ersten Tag einer Klasse zu verdauen,

1219
01:06:38,000 --> 01:06:43,000
aber jetzt ist es wirklich der Baustein alles verstehen

1220
01:06:43,000 --> 01:06:46,000
Das ist auf der Innenseite der Arbeitsspeicher des Computers gegangen,

1221
01:06:46,000 --> 01:06:49,000
und schließlich werden wir necken diese außer mit ein wenig Hilfe

1222
01:06:49,000 --> 01:06:51,000
von einem unserer Freunde in Stanford.

1223
01:06:51,000 --> 01:06:56,000
>> Professor Nick Parlante an der Stanford hat diese wunderbare Videosequenz getan

1224
01:06:56,000 --> 01:06:58,000
aus allen möglichen verschiedenen Sprachen, die eingeführt

1225
01:06:58,000 --> 01:07:00,000
diese kleine Claymation Charakter Binky.

1226
01:07:00,000 --> 01:07:03,000
Die Stimme, die Sie sind im Begriff, in nur wenigen Sekunden Sneak Preview zu hören

1227
01:07:03,000 --> 01:07:05,000
ist, dass der Stanford-Professor, und Sie bekommen

1228
01:07:05,000 --> 01:07:07,000
nur 5 oder 6 Sekunden dieser gerade jetzt,

1229
01:07:07,000 --> 01:07:09,000
aber dies ist die Notiz auf dem schließen wir heute werde

1230
01:07:09,000 --> 01:07:11,000
und am Mittwoch beginnen.

1231
01:07:11,000 --> 01:07:15,000
Ich gebe Ihnen Pointer Spaß mit Binky, die Vorschau.

1232
01:07:15,000 --> 01:07:18,000
[♪ Music ♪] [Professor Parlante] Hey, Binky.

1233
01:07:18,000 --> 01:07:21,000
Aufwachen. Es ist Zeit für Zeiger Spaß.

1234
01:07:21,000 --> 01:07:24,000
[Binky] Was ist das? Erfahren Sie mehr über Zeiger?

1235
01:07:24,000 --> 01:07:26,000
Oh, goody!

1236
01:07:26,000 --> 01:07:29,000
>> Wir werden Sie am Mittwoch sehen.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]