1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [§ 4] [weniger komfortabel]

2
00:00:02,000 --> 00:00:04,000
[Nate Hardison] [Harvard University]

3
00:00:04,000 --> 00:00:07,000
[Dies ist CS50.] [CS50.TV]

4
00:00:07,000 --> 00:00:10,000
>> Alles klar, willkommen zurück zu Abschnitt.

5
00:00:10,000 --> 00:00:13,000
In dieser Woche Abschnitt werden wir ein paar Dinge zu tun.

6
00:00:13,000 --> 00:00:17,000
Wir gehen nach ersten recap Problem Set 2 gehen,

7
00:00:17,000 --> 00:00:20,000
was der Cäsar und Vigenère Problem set.

8
00:00:20,000 --> 00:00:23,000
Und dann werden wir in Quiz 0 Bewertungen tauchen

9
00:00:23,000 --> 00:00:26,000
und verbringen Sie ein wenig Zeit rekapitulieren, was wir gesprochen haben

10
00:00:26,000 --> 00:00:30,000
in jedem der Vorträge so weit, und wir tun auch ein paar Probleme

11
00:00:30,000 --> 00:00:32,000
vom Vorjahr Quiz.

12
00:00:32,000 --> 00:00:36,000
So können Sie Jungs haben eine gute Möglichkeit, um darauf vorbereiten.

13
00:00:36,000 --> 00:00:40,000
>> Um zu beginnen, habe ich ein paar gute Lösungen gebootet

14
00:00:40,000 --> 00:00:45,000
für das vorangegangene Problem Set, Set Problem 2, in diesen Raum.

15
00:00:45,000 --> 00:00:48,000
Wenn euch alle getroffen diesen Link,

16
00:00:48,000 --> 00:00:53,000
und wenn Sie auf meinen Namen, und klicken Sie auf meine erste Revision

17
00:00:53,000 --> 00:00:56,000
Sie werden sehen, caesar.c, die genau das, was ich bin auf der Suche ist.

18
00:00:56,000 --> 00:01:00,000
Lassen Sie uns über das wirklich schnell zu sprechen.

19
00:01:00,000 --> 00:01:02,000
Dies ist nur eine Probenlösung.

20
00:01:02,000 --> 00:01:05,000
Dies ist nicht unbedingt die perfekte Lösung.

21
00:01:05,000 --> 00:01:08,000
Es gibt viele verschiedene Wege, dies zu schreiben,

22
00:01:08,000 --> 00:01:10,000
aber es gibt ein paar Dinge, die ich hervorheben wollte

23
00:01:10,000 --> 00:01:13,000
, die ich sah, als ich mit einem Gehalt, häufige Fehler, dass ich denke,

24
00:01:13,000 --> 00:01:18,000
Diese Lösung macht einen sehr guten Job in der Handhabung.

25
00:01:18,000 --> 00:01:22,000
>> Die erste ist mit einer Art von Header Kommentar am Anfang.

26
00:01:22,000 --> 00:01:25,000
In den Zeilen 1 bis 7 sehen Sie die Details,

27
00:01:25,000 --> 00:01:28,000
was genau dieses Programm tut.

28
00:01:28,000 --> 00:01:32,000
Ein guter fachlicher Praxis, wenn du schreibst C-Code

29
00:01:32,000 --> 00:01:35,000
unabhängig davon, ob Ihr Programm in einer einzigen Datei enthalten sind oder

30
00:01:35,000 --> 00:01:38,000
ob es über mehrere Dateien aufgeteilt ist es, eine Art haben

31
00:01:38,000 --> 00:01:40,000
Orientieren Kommentar am Anfang.

32
00:01:40,000 --> 00:01:43,000
Dies gilt auch für Menschen, die gehen und Code schreiben, in der realen Welt.

33
00:01:43,000 --> 00:01:47,000
Dies ist, wo sie Informationen zum Urheberrecht finden setzen.

34
00:01:47,000 --> 00:01:50,000
Unten sind die # enthält.

35
00:01:50,000 --> 00:01:55,000
Auf der Linie 16 gibt es diese # define, was wir kommen zurück, um in nur einem Bit.

36
00:01:55,000 --> 00:01:59,000
Und dann noch einmal die Funktion startet, sobald wichtigsten Starts,

37
00:01:59,000 --> 00:02:03,000
weil dieses Programm wurde in einem einzigen Funktion enthalten

38
00:02:03,000 --> 00:02:09,000
Die erste Sache, die-passiert und das ist sehr idiomatisch und typisch für ein C-Programm

39
00:02:09,000 --> 00:02:14,000
das dauert in Kommandozeilenargumenten-ist, dass es prüft sofort

40
00:02:14,000 --> 00:02:18,000
>> für das Argument count, argc.

41
00:02:18,000 --> 00:02:24,000
Genau hier sehen wir, dass dieses Programm erwartet 2 Argumente genau.

42
00:02:24,000 --> 00:02:27,000
Denken Sie daran, dass es erste Argument, das das spezielle ist

43
00:02:27,000 --> 00:02:29,000
das ist immer der Name des Programms, die ausgeführt ist,

44
00:02:29,000 --> 00:02:31,000
der Name der ausführbaren Datei.

45
00:02:31,000 --> 00:02:36,000
Und so was dieser tut, ist es verhindert, dass Benutzer das Programm laufen

46
00:02:36,000 --> 00:02:42,000
mit mehr oder weniger Argumente.

47
00:02:42,000 --> 00:02:44,000
Der Grund wollen wir dieses Recht weg zu überprüfen ist, weil

48
00:02:44,000 --> 00:02:52,000
können wir nicht wirklich auf diese argv-Array hier zuverlässig

49
00:02:52,000 --> 00:02:55,000
bis wir eingecheckt haben, um zu sehen, wie groß es ist.

50
00:02:55,000 --> 00:02:58,000
>> Einer der häufigsten Fehler, die ich sah, war Menschen würden sofort reingehen

51
00:02:58,000 --> 00:03:01,000
und Greifer argv [1].

52
00:03:01,000 --> 00:03:06,000
Sie hatten das zentrale Argument aus dem Array zu packen und nicht die a bis i auf sie zu überprüfen,

53
00:03:06,000 --> 00:03:11,000
und dann würden sie den Test für argc sowie den nächsten Test zu tun,

54
00:03:11,000 --> 00:03:16,000
ob das erste Argument war tatsächlich eine ganze Zahl gleichzeitig,

55
00:03:16,000 --> 00:03:20,000
und das nicht funktionieren, da in dem Fall, dass es keine Argumente angegeben

56
00:03:20,000 --> 00:03:26,000
Sie werden packte ein Argument, das nicht da ist oder der Versuch, eine, die nicht da ist zu packen.

57
00:03:26,000 --> 00:03:29,000
>> Die andere große Sache, sollten Sie feststellen, dass

58
00:03:29,000 --> 00:03:32,000
Sie wollen immer auszudrucken irgendeine hilfreiche Fehlermeldung

59
00:03:32,000 --> 00:03:34,000
dem Benutzer zu orientieren sie.

60
00:03:34,000 --> 00:03:37,000
Ich bin sicher, Sie haben alle Programme ausführen, wo alle es plötzlich abstürzt,

61
00:03:37,000 --> 00:03:41,000
und Sie erhalten diese lächerlichen kleinen Dialog, der sich öffnet und sagt

62
00:03:41,000 --> 00:03:44,000
etwas furchtbar kryptisch und vielleicht gibt Ihnen einen Fehlercode oder so ähnlich

63
00:03:44,000 --> 00:03:47,000
das macht keinen Sinn.

64
00:03:47,000 --> 00:03:50,000
Dies ist, wo Sie wirklich wollen, etwas Hilfreiches bieten

65
00:03:50,000 --> 00:03:54,000
und dem Benutzer gezielte, so dass, wenn sie es laufen sie "Oh," face palm gehen.

66
00:03:54,000 --> 00:03:58,000
"Ich weiß genau, was zu tun ist. Ich weiß, wie man dieses Problem beheben."

67
00:03:58,000 --> 00:04:01,000
>> Wenn Sie nicht drucken eine Nachricht, dann am Ende tatsächlich

68
00:04:01,000 --> 00:04:04,000
sodass der Anwender zu gehen überprüfen Sie Ihre Source-Code

69
00:04:04,000 --> 00:04:07,000
um herauszufinden, was falsch gelaufen ist.

70
00:04:07,000 --> 00:04:11,000
Es gibt auch einige Male, dass Sie verschiedene Fehlercodes verwenden werden.

71
00:04:11,000 --> 00:04:14,000
Hier haben wir nur benutzt man sagen, es war ein Fehler,

72
00:04:14,000 --> 00:04:16,000
es war ein Fehler, es war ein Fehler.

73
00:04:16,000 --> 00:04:20,000
Bigger Programme, die oft Programme, die von anderen Programmen aufgerufen werden,

74
00:04:20,000 --> 00:04:25,000
wird eine Art von speziellen Fehlercodes in verschiedenen Szenarien zurück

75
00:04:25,000 --> 00:04:28,000
programmatisch zu kommunizieren, was Sie sonst

76
00:04:28,000 --> 00:04:32,000
Verwenden Sie nur ein nettes englisches Nachricht für.

77
00:04:32,000 --> 00:04:35,000
Cool.

78
00:04:35,000 --> 00:04:37,000
Als wir arbeiten, können Sie sehen, wir ziehen den Schlüssel aus.

79
00:04:37,000 --> 00:04:40,000
Wir testen, ob der Schlüssel passt.

80
00:04:40,000 --> 00:04:42,000
Wir bekommen eine Nachricht durch den Benutzer.

81
00:04:42,000 --> 00:04:46,000
Der Grund, warum wir es in diesem Zweck while-Schleife, und das ist etwas, das wir abdecken

82
00:04:46,000 --> 00:04:50,000
in ein wenig, aber es stellt sich heraus, dass, wenn Sie geben Control D

83
00:04:50,000 --> 00:04:54,000
wenn du das GetString prompt auf dem Terminal

84
00:04:54,000 --> 00:04:59,000
was das tatsächlich tut, ist es sendet einen besonderen Charakter

85
00:04:59,000 --> 00:05:01,000
an das Programm.

86
00:05:01,000 --> 00:05:05,000
Es nennt sich die ELF oder das Ende der Datei Charakter.

87
00:05:05,000 --> 00:05:08,000
Und in diesem Fall wird unsere Botschaft String null sein,

88
00:05:08,000 --> 00:05:14,000
so war dies nicht etwas, was wir für aufgegebenes das Problem setzte sich.

89
00:05:14,000 --> 00:05:17,000
>> Aber wie wir weiter gehen, jetzt, wo wir begonnen, über Zeiger zu sprechen

90
00:05:17,000 --> 00:05:21,000
und dynamische Speicherzuweisung auf dem Heap,

91
00:05:21,000 --> 00:05:25,000
Überprüfung auf null, wenn Sie eine Funktion, die haben könnte

92
00:05:25,000 --> 00:05:30,000
null zurück, wie ein Wert ist etwas, das Sie in die Gewohnheit zu tun bekommen werde.

93
00:05:30,000 --> 00:05:33,000
Dies ist hier in erster Linie zur Illustration.

94
00:05:33,000 --> 00:05:36,000
Aber wenn man sehe GetString in der Zukunft,

95
00:05:36,000 --> 00:05:41,000
so von Problem-Set 4 auf, sollten Sie dies im Hinterkopf behalten.

96
00:05:41,000 --> 00:05:44,000
Auch dies ist kein Problem für Problem-Set 3 entweder weil wir es nicht bedeckt hatte noch.

97
00:05:44,000 --> 00:05:53,000
Schließlich kommen wir zu diesem Teil, wo wir auf die wichtigsten Verschlüsselungs-Schleife

98
00:05:53,000 --> 00:05:57,000
und es gibt ein paar Dinge vor sich geht.

99
00:05:57,000 --> 00:06:02,000
Erstens haben wir über die gesamte Nachricht String selbst durchlaufen.

100
00:06:02,000 --> 00:06:07,000
Hier haben wir die strlen Anruf in dem Zustand gehalten,

101
00:06:07,000 --> 00:06:12,000
die einige von Ihnen haben darauf hingewiesen, ist nicht ein guter Weg zu gehen.

102
00:06:12,000 --> 00:06:15,000
Es stellt sich heraus in diesem Fall ist es auch nicht groß,

103
00:06:15,000 --> 00:06:20,000
teils, weil wir ändern den Inhalt der Nachricht selbst

104
00:06:20,000 --> 00:06:27,000
innerhalb der for-Schleife, so dass, wenn wir eine Nachricht, die 10 Zeichen lang ist,

105
00:06:27,000 --> 00:06:32,000
Zum ersten Mal beginnen wir, dass for-Schleife strlen wird, was zurück?

106
00:06:32,000 --> 00:06:35,000
10.

107
00:06:35,000 --> 00:06:40,000
>> Aber wenn wir dann ändern Nachricht, sagen wir ändern ihre fünfte Zeichen

108
00:06:40,000 --> 00:06:46,000
und wir in einem \ 0 Zeichen werfen in der fünften Position,

109
00:06:46,000 --> 00:06:49,000
auf einer anschließenden Iteration strlen (message) wird nicht zurückkehren, was er tat

110
00:06:49,000 --> 00:06:52,000
das erste Mal, dass wir iteriert,

111
00:06:52,000 --> 00:06:56,000
aber es wird stattdessen zurückgeben 5, weil wir in diesem Nullabschlusszeichen warf,

112
00:06:56,000 --> 00:06:59,000
und Länge der Zeichenfolge definiert

113
00:06:59,000 --> 00:07:03,000
durch die Position des \ 0.

114
00:07:03,000 --> 00:07:09,000
In diesem Fall ist dies ein guter Weg zu gehen, weil wir es zu ändern sind an Ort und Stelle.

115
00:07:09,000 --> 00:07:13,000
Aber man merkt, dass dies tatsächlich ist überraschend einfach zu verschlüsseln

116
00:07:13,000 --> 00:07:16,000
wenn Sie können die Mathematik richtig.

117
00:07:16,000 --> 00:07:19,000
Alles, was erforderlich ist, ob das Schreiben prüfen, ob Sie auf der Suche

118
00:07:19,000 --> 00:07:21,000
ist Groß-oder Kleinschreibung.

119
00:07:21,000 --> 00:07:24,000
>> Der Grund warum wir nur noch für, dass der Check und wir müssen nicht für den Check

120
00:07:24,000 --> 00:07:27,000
Die alpha Fall ist, weil

121
00:07:27,000 --> 00:07:30,000
wenn ein Charakter in Großbuchstaben oder ob es Kleinbuchstaben

122
00:07:30,000 --> 00:07:33,000
dann ist es definitiv ein alphabetisches Zeichen,

123
00:07:33,000 --> 00:07:38,000
weil wir keine Groß-und Kleinschreibung Ziffern.

124
00:07:38,000 --> 00:07:41,000
Die andere Sache, die wir tun, und das ist ein wenig knifflig-

125
00:07:41,000 --> 00:07:45,000
wird haben wir die Standard-Cäsar-Chiffre Formel modifiziert

126
00:07:45,000 --> 00:07:49,000
dass wir gaben das Problem set-Spezifikation.

127
00:07:49,000 --> 00:07:52,000
Was ist hier anders ist, dass wir abgezogen

128
00:07:52,000 --> 00:07:58,000
in der Groß-Fall Kapital A, und dann haben wir hinzugefügt Capital eine

129
00:07:58,000 --> 00:08:02,000
Zurück in am Ende.

130
00:08:02,000 --> 00:08:05,000
>> Ich weiß, einige von euch haben dies in Ihrem Code.

131
00:08:05,000 --> 00:08:09,000
Hat einer von euch tun dies in eure Einsendungen?

132
00:08:09,000 --> 00:08:13,000
Sie tat dies. Können Sie erklären, was das bedeutet, SAHB?

133
00:08:13,000 --> 00:08:18,000
Durch Subtraktion it out, weil du ein mod richtig gemacht, nachdem er,

134
00:08:18,000 --> 00:08:21,000
Sie müssen es nehmen, so dass die Art und Weise erhalten Sie [Husten] Position.

135
00:08:21,000 --> 00:08:25,000
Und dann, indem Sie es später wieder Sie verschoben über die eine, die Sie wollten.

136
00:08:25,000 --> 00:08:27,000
Ja, genau.

137
00:08:27,000 --> 00:08:32,000
Was SAHB sagte, war, dass, wenn wir hinzufügen möchten

138
00:08:32,000 --> 00:08:36,000
unsere Botschaft und unser Schlüssel zusammen

139
00:08:36,000 --> 00:08:42,000
und dann mod, dass mod, dass durch NUM_LETTERS,

140
00:08:42,000 --> 00:08:50,000
wenn wir nicht skalieren unsere Botschaft in die entsprechende Bereichs 0 bis 25 ersten,

141
00:08:50,000 --> 00:08:54,000
dann könnten wir am Ende immer eine wirklich seltsame Zahl

142
00:08:54,000 --> 00:08:59,000
weil die Werte, die wir sehen, wenn wir uns auf die Meldung [i] suchen,

143
00:08:59,000 --> 00:09:03,000
wenn wir auf die i-te Zeichen unserer Klartext-Nachricht suchen,

144
00:09:03,000 --> 00:09:08,000
ist ein Wert, irgendwo in diesem Bereich von 65 bis 122

145
00:09:08,000 --> 00:09:13,000
basierend auf den ASCII-Werte für Großbuchstaben A bis Kleinbuchstaben z.

146
00:09:13,000 --> 00:09:18,000
Und so, wenn wir MOD IT um 26 oder NUM_LETTERS,

147
00:09:18,000 --> 00:09:23,000
denn das war unsere # oben rechts hier definieren,

148
00:09:23,000 --> 00:09:28,000
das wird uns einen Wert, der in der 0 bis 25 ist,

149
00:09:28,000 --> 00:09:30,000
und wir müssen einen Weg finden, um dann zu skalieren, dass wieder

150
00:09:30,000 --> 00:09:32,000
und bekommen es in den entsprechenden ASCII-Bereich.

151
00:09:32,000 --> 00:09:36,000
Der einfachste Weg dies zu tun ist, einfach zu skalieren alles nieder

152
00:09:36,000 --> 00:09:39,000
in den Bereichs 0 bis 25 zu beginnen,

153
00:09:39,000 --> 00:09:43,000
und dann verschieben alles wieder am Ende.

154
00:09:43,000 --> 00:09:46,000
>> Ein weiterer häufiger Fehler, dass ich sah, wie Menschen in laufen ist, dass

155
00:09:46,000 --> 00:09:50,000
wenn Sie nicht tatsächlich diese Skalierung auf Anhieb

156
00:09:50,000 --> 00:09:53,000
und fügen Sie Nachricht und Schlüssel zusammen und fügen Sie sie, sagen wir,

157
00:09:53,000 --> 00:09:58,000
in eine char-Variable, das Problem mit, dass

158
00:09:58,000 --> 00:10:01,000
ist seit message [i] ist eine relativ große Zahl beginnen mit-

159
00:10:01,000 --> 00:10:05,000
erinnern, dass es mindestens 65, wenn es sich um einen Groß-Charakter-

160
00:10:05,000 --> 00:10:09,000
wenn Sie einen großen Schlüssel, sagen, so etwas wie 100,

161
00:10:09,000 --> 00:10:13,000
und fügen Sie die 2 zusammen in einem signed char wirst du einen Überlauf zu bekommen sind.

162
00:10:13,000 --> 00:10:17,000
Du wirst einen Wert, der größer als 127 ist zu bekommen,

163
00:10:17,000 --> 00:10:22,000
das ist der größte Wert, dass ein char Variable aufnehmen kann.

164
00:10:22,000 --> 00:10:26,000
Wieder ist der Grund, warum Sie wollen würde, um diese Art der Sache zu beginnen tun.

165
00:10:26,000 --> 00:10:29,000
Einige Leute herum diesem Fall, indem Sie eine if-else und Testen

166
00:10:29,000 --> 00:10:33,000
zu sehen, ob es wäre Überlauf bevor Sie das tun,

167
00:10:33,000 --> 00:10:36,000
aber auf diese Weise umgeht, dass.

168
00:10:36,000 --> 00:10:40,000
Und dann in dieser Lösung, die wir ausgedruckt den ganzen String ganz am Ende.

169
00:10:40,000 --> 00:10:45,000
Andere Leute ein Zeichen in einer Zeit gedruckt. Beide sind genial.

170
00:10:45,000 --> 00:10:51,000
An diesem Punkt kann euch irgendwelche Fragen haben, irgendwelche Kommentare dazu?

171
00:10:51,000 --> 00:10:56,000
Lust, Dinge, die Sie nicht mögen?

172
00:10:56,000 --> 00:10:58,000
>> Ich hatte eine Frage.

173
00:10:58,000 --> 00:11:01,000
Vielleicht habe ich es verpasst während Ihrer Erklärung, aber wie funktioniert das Programm

174
00:11:01,000 --> 00:11:07,000
Überspringen der Räume zum Verbinden der Schlüssel zu der Länge des Textes?

175
00:11:07,000 --> 00:11:10,000
Dies ist nur Caesar-Chiffre. >> Oh, sorry, yeah.

176
00:11:10,000 --> 00:11:13,000
Ja, wir sehen, dass.

177
00:11:13,000 --> 00:11:16,000
In der Caesar-Chiffre wir herum, dass da

178
00:11:16,000 --> 00:11:18,000
wir nur umgedreht Zeichen.

179
00:11:18,000 --> 00:11:27,000
Wir haben nur gedreht werden, wenn sie groß oder klein waren.

180
00:11:27,000 --> 00:11:32,000
You guys ein ziemlich gutes Gefühl this?

181
00:11:32,000 --> 00:11:34,000
Fühlen Sie sich frei, um dieses Haus zu kopieren, nehmen Sie es,

182
00:11:34,000 --> 00:11:37,000
vergleichen Sie es mit, was euch geschrieben hat.

183
00:11:37,000 --> 00:11:42,000
Auf jeden Fall fühlen sich frei, Fragen darüber zu senden.

184
00:11:42,000 --> 00:11:46,000
Und wieder erkennen, dass das Ziel hier mit Ihrem Problem stellt

185
00:11:46,000 --> 00:11:50,000
nicht um euch zu perfekten Code für Ihr Problem Sätze zu schreiben.

186
00:11:50,000 --> 00:11:57,000
Es ist eine Lernerfahrung. Yeah.

187
00:11:57,000 --> 00:12:01,000
>> Zurück zur do while-Schleife, wenn es gleich null,

188
00:12:01,000 --> 00:12:06,000
so null bedeutet nur nichts, sie einfach Enter drücken?

189
00:12:06,000 --> 00:12:12,000
Null ist eine spezielle Zeiger-Wert,

190
00:12:12,000 --> 00:12:17,000
und wir verwenden null, wenn wir sagen wollen

191
00:12:17,000 --> 00:12:23,000
haben wir einen Zeiger Variable, die nichts zeigt.

192
00:12:23,000 --> 00:12:28,000
Und so es in der Regel bedeutet, dass diese Variable, wird diese Meldung variable

193
00:12:28,000 --> 00:12:35,000
ist leer, und hier, weil wir mit dem CS50 spezielle String-Typ sind,

194
00:12:35,000 --> 00:12:37,000
was ist der CS50-String-Typ?

195
00:12:37,000 --> 00:12:42,000
Haben Sie gesehen, was es ist, wenn David wieder zog die Kapuze in der Vorlesung?

196
00:12:42,000 --> 00:12:44,000
Es ist ein funky-es ist ein Zeiger, nicht wahr?

197
00:12:44,000 --> 00:12:48,000
Okay, yeah. >> Es ist ein char *.

198
00:12:48,000 --> 00:12:52,000
Und so wirklich konnten wir ersetzen Sie diese

199
00:12:52,000 --> 00:12:56,000
hier mit char * message,

200
00:12:56,000 --> 00:13:04,000
und so die GetString-Funktion, wenn sie nicht erfolgreich zu einen String vom Benutzer

201
00:13:04,000 --> 00:13:08,000
es kann nicht analysiert eine Zeichenfolge, und der einzige Fall, in dem es nicht analysieren kann einen String

202
00:13:08,000 --> 00:13:11,000
ist, wenn der Benutzer das Ende der Datei Charakter, die Steuerung D,

203
00:13:11,000 --> 00:13:17,000
das ist nicht etwas, was Sie normalerweise tun, aber wenn das passiert,

204
00:13:17,000 --> 00:13:20,000
Dann wird die Funktion dieses Nullwert als eine Möglichkeit zu sagen, zurück

205
00:13:20,000 --> 00:13:23,000
"Hey, habe ich nicht bekommen eine Zeichenkette."

206
00:13:23,000 --> 00:13:27,000
Was würde passieren, wenn wir nichts dagegen unternehmen, message = null,

207
00:13:27,000 --> 00:13:30,000
das ist etwas, was wir bisher noch nicht da?

208
00:13:30,000 --> 00:13:32,000
Warum wäre das hier ein Problem sein?

209
00:13:32,000 --> 00:13:38,000
Weil ich weiß, dass wir ein wenig geredet in Vortrag über Speicherlecks.

210
00:13:38,000 --> 00:13:42,000
Ja, lasst uns tun, und mal sehen, was passiert.

211
00:13:42,000 --> 00:13:44,000
>> Basil Frage war, was passiert, wenn wir eigentlich gar nicht haben

212
00:13:44,000 --> 00:13:48,000
Diese Nachricht = null-Test?

213
00:13:48,000 --> 00:13:51,000
Lasst uns nach oben an die Spitze.

214
00:13:51,000 --> 00:13:53,000
You guys können diese Zeile auskommentieren.

215
00:13:53,000 --> 00:13:55,000
Eigentlich werde ich es in einer Revision zu speichern.

216
00:13:55,000 --> 00:13:58,000
Dies wird Revision 3 sein.

217
00:13:58,000 --> 00:14:02,000
Was Sie tun müssen, um dieses Programm laufen soll musst du dieses Zahnrad-Symbol oben klicken Sie hier,

218
00:14:02,000 --> 00:14:04,000
und Sie haben ein Argument, um es hinzuzufügen.

219
00:14:04,000 --> 00:14:10,000
Sie haben, um ihm den Schlüssel Argument, da wir in einer Befehlszeile Argument übergeben wollen.

220
00:14:10,000 --> 00:14:13,000
Hier werde ich ihm die Nummer 3. Ich mag 3.

221
00:14:13,000 --> 00:14:19,000
Jetzt Zoomen wieder heraus, das Programm läuft.

222
00:14:19,000 --> 00:14:24,000
Es läuft, Kompilieren, bauen.

223
00:14:24,000 --> 00:14:27,000
Here we go. Es wartet darauf, aufgefordert werden.

224
00:14:27,000 --> 00:14:33,000
Wenn ich geben in so etwas wie hallo-wo war das?

225
00:14:33,000 --> 00:14:38,000
Oh, nahm mein Programm zu lange laufen. Ich war zu lange Schlammschlachten.

226
00:14:38,000 --> 00:14:40,000
Hier geht es.

227
00:14:40,000 --> 00:14:43,000
Jetzt bin ich in hallo eingeben.

228
00:14:43,000 --> 00:14:46,000
Wir sehen, dass es angemessen verschlüsselt.

229
00:14:46,000 --> 00:14:52,000
Nun, was passiert, wenn wir prompt GetString auf null zurück tun?

230
00:14:52,000 --> 00:14:57,000
Denken Sie daran, sagte ich, dass wir das gemacht haben, indem Sie Steuerung D zur gleichen Zeit.

231
00:14:57,000 --> 00:14:59,000
Ich werde nach oben hier. Wir werden es wieder laufen.

232
00:14:59,000 --> 00:15:01,000
Building. Dort geht es.

233
00:15:01,000 --> 00:15:04,000
Nun, wenn ich die Kontrolle D getroffen

234
00:15:04,000 --> 00:15:12,000
Ich habe diese Linie, die opt/sandbox50/bin/run.sh sagt Segmentation fault.

235
00:15:12,000 --> 00:15:15,000
Habt ihr gesehen, dass vor?

236
00:15:15,000 --> 00:15:17,000
>> [Student] Warum gibt es keine->> Sorry?

237
00:15:17,000 --> 00:15:20,000
[Student] Warum gibt es keine Core-Dump in diesem Fall?

238
00:15:20,000 --> 00:15:26,000
Die Core-Dump ist-die Frage ist, warum gibt es keine Core-Dump hier?

239
00:15:26,000 --> 00:15:29,000
Die Frage ist, dass es sein kann, aber die Core-Dump ist eine Datei

240
00:15:29,000 --> 00:15:31,000
Das geht auf der Festplatte gespeichert.

241
00:15:31,000 --> 00:15:34,000
In diesem Fall haben wir Core-Dumps deaktiviert

242
00:15:34,000 --> 00:15:37,000
auf der Flucht Server, so dass wir nicht die Menschen seg fehlgeschlagenes

243
00:15:37,000 --> 00:15:40,000
und Aufbau Tonnen Core-Dumps.

244
00:15:40,000 --> 00:15:46,000
Aber man kann sich ein.

245
00:15:46,000 --> 00:15:48,000
Core-Dumps sind die Art von Dingen, die man oft deaktivieren können,

246
00:15:48,000 --> 00:15:52,000
und manchmal tun.

247
00:15:52,000 --> 00:15:55,000
Die Segmentation Fault, um Ihre Frage zu beantworten, Basilikum,

248
00:15:55,000 --> 00:16:00,000
sagt, dass wir, um einen Zeiger zuzugreifen versucht

249
00:16:00,000 --> 00:16:05,000
das war nicht auf etwas hinweisen.

250
00:16:05,000 --> 00:16:09,000
Angemeldet Binky in dem Video, wenn Binky versucht,

251
00:16:09,000 --> 00:16:12,000
GO Access einen Zeiger, der nicht in die Richtung geht, etwas zu?

252
00:16:12,000 --> 00:16:16,000
In diesem Fall, schätze ich technisch der Zeiger auf etwas zeigt.

253
00:16:16,000 --> 00:16:20,000
Es ist auf null, was technisch 0 ist zeigt,

254
00:16:20,000 --> 00:16:25,000
aber das ist so definiert, in einem Segment, welche nicht zugänglich sind

255
00:16:25,000 --> 00:16:28,000
von Ihrem Programm, so erhalten Sie einen Segmentation Fault

256
00:16:28,000 --> 00:16:31,000
weil Sie nicht zugreifen sind Speicher, das ist in einem gültigen Bereich

257
00:16:31,000 --> 00:16:38,000
wie der Heap-Segment oder den Stapel Segment oder Datensegment.

258
00:16:38,000 --> 00:16:40,000
Cool.

259
00:16:40,000 --> 00:16:48,000
Haben Sie noch Fragen zu Caesar?

260
00:16:48,000 --> 00:16:51,000
>> Lasst uns weitermachen. Lassen Sie uns Revision 2 wirklich schnell zu suchen.

261
00:16:51,000 --> 00:17:00,000
Das ist Vigenère.

262
00:17:00,000 --> 00:17:04,000
Hier in Vigenère

263
00:17:04,000 --> 00:17:06,000
wir durch dieses ein ziemlich schnell gehen, weil wieder

264
00:17:06,000 --> 00:17:10,000
Vigenère und Caesar sind ziemlich ähnlich.

265
00:17:10,000 --> 00:17:12,000
Header-Kommentar ist vor,

266
00:17:12,000 --> 00:17:17,000
# Define ist, bevor zu vermeiden, mit dieser magischen Zahlen.

267
00:17:17,000 --> 00:17:21,000
Die nette Sache ist sagen wir wollten sich zu bewegen

268
00:17:21,000 --> 00:17:23,000
ein anderes Alphabet oder so ähnlich.

269
00:17:23,000 --> 00:17:26,000
Anstatt manuell gehen ändern sich 26 der im Code

270
00:17:26,000 --> 00:17:30,000
konnten wir diese auf 27 ändern oder legen Sie es nach unten

271
00:17:30,000 --> 00:17:34,000
wenn wir mit verschiedenen Alphabete, verschiedene Sprachen.

272
00:17:34,000 --> 00:17:38,000
Auch wir haben dieses Kontrollkästchen des Arguments count,

273
00:17:38,000 --> 00:17:42,000
und wirklich kann man fast dies als Vorlage.

274
00:17:42,000 --> 00:17:46,000
So ziemlich jeder, das Sie schreiben, sollte-

275
00:17:46,000 --> 00:17:50,000
wenn es Befehlszeile auch Argumente-some Folge von Zeilen

276
00:17:50,000 --> 00:17:55,000
das liest sich wie dies am Anfang.

277
00:17:55,000 --> 00:17:59,000
Das ist eine der ersten sanity Tests, die Sie tun möchten.

278
00:17:59,000 --> 00:18:03,000
>> Hier das, was wir hatten war, dass wir dafür gesorgt, dass

279
00:18:03,000 --> 00:18:06,000
das Schlüsselwort gültig war, und das war die zweite Prüfung, dass wir es taten.

280
00:18:06,000 --> 00:18:11,000
Beachten Sie wieder, dass wir diese getrennt von argc und 2.

281
00:18:11,000 --> 00:18:14,000
Beachten Sie, dass in diesem Fall eine Sache, die wir tun mussten, war stattdessen

282
00:18:14,000 --> 00:18:18,000
der Verwendung a bis i wollten wir die gesamte Zeichenfolge zu validieren,

283
00:18:18,000 --> 00:18:21,000
und um das zu tun, Sie haben tatsächlich Zeichen für Zeichen gehen

284
00:18:21,000 --> 00:18:23,000
über der Zeichenfolge.

285
00:18:23,000 --> 00:18:29,000
Es gibt keinen guten Weg, um etwas auf es nennen

286
00:18:29,000 --> 00:18:31,000
denn auch, zum Beispiel, a bis i 0 zurück

287
00:18:31,000 --> 00:18:37,000
wenn es nicht analysieren kann eine ganze Zahl, so dass nicht einmal arbeiten.

288
00:18:37,000 --> 00:18:42,000
Wieder schöne Nachricht, die besagt, was genau passiert ist.

289
00:18:42,000 --> 00:18:45,000
Dann ist hier wieder, übernehmen wir auch den Fall, wo

290
00:18:45,000 --> 00:18:50,000
Der Benutzer gibt in einer Kontrollgruppe D zufällige Buchstabenkombination.

291
00:18:50,000 --> 00:18:54,000
>> Und dann Charlotte hatte eine Frage zuvor, wie wir es schaffen, Räume überspringen

292
00:18:54,000 --> 00:18:57,000
in unserem String hier.

293
00:18:57,000 --> 00:19:00,000
Dies war eine Art ähnlich dem, was wir taten mit dem Myspace-Programm

294
00:19:00,000 --> 00:19:04,000
dass wir das gemacht im Schnitt, und die Art und Weise dies funktioniert

295
00:19:04,000 --> 00:19:08,000
ist, dass wir die Anzahl der Briefe, die wir gesehen hatten verfolgt.

296
00:19:08,000 --> 00:19:13,000
Als wir gingen über den Meldungs-String, als wir über Charakter ging durch Charakter,

297
00:19:13,000 --> 00:19:16,000
Wir verfolgen den Index als Teil unserer for-Schleife, und dann werden wir auch verfolgt

298
00:19:16,000 --> 00:19:21,000
die Anzahl der Buchstaben, so nicht Sonderzeichen, nicht-stellig, nicht-weißen Raum

299
00:19:21,000 --> 00:19:27,000
dass wir hatten in der separaten variable gesehen.

300
00:19:27,000 --> 00:19:33,000
Und dann diese Lösung verändert die Taste

301
00:19:33,000 --> 00:19:41,000
eine eigentliche Schlüssel integer zu bekommen, und das tut sie on the fly,

302
00:19:41,000 --> 00:19:47,000
direkt vor geht es dann um die eigentliche Nachricht Charakter zu verschlüsseln.

303
00:19:47,000 --> 00:19:50,000
Es gibt einige Lösungen, die perfekt waren großartig zu

304
00:19:50,000 --> 00:19:58,000
das wäre zu ändern den Schlüssel bis bei der Prüfung auf die Gültigkeit des Schlüssels.

305
00:19:58,000 --> 00:20:01,000
Neben dafür sorgen, dass der Charakter und das Schlüsselwort

306
00:20:01,000 --> 00:20:05,000
wurde ein alphabetisches Zeichen auch gedreht, dass in einen Integer

307
00:20:05,000 --> 00:20:13,000
in der Bereichs 0 bis 25, um dann überspringen Sie mit dem später tun in dieser for-Schleife.

308
00:20:13,000 --> 00:20:18,000
Auch hier sehen Sie hier das ist wirklich das exakt gleiche Code

309
00:20:18,000 --> 00:20:22,000
dass wir verwendet Caesar an dieser Stelle.

310
00:20:22,000 --> 00:20:25,000
Du tust genau dasselbe, so der eigentliche Trick ist, herauszufinden,

311
00:20:25,000 --> 00:20:30,000
wie das Schlüsselwort in einem ganzzahligen einzuschalten.

312
00:20:30,000 --> 00:20:35,000
>> Eine Sache, die wir hier gemacht haben, die ist ein wenig dichter

313
00:20:35,000 --> 00:20:39,000
ist, dass wir diesen Satz wiederholt, ich denke, man könnte es nennen,

314
00:20:39,000 --> 00:20:45,000
3 getrennten Zeiten auf den Leitungen 58, 59 und 61.

315
00:20:45,000 --> 00:20:52,000
Kann mir jemand erklären, was genau diese Phrase tut?

316
00:20:52,000 --> 00:20:55,000
Es ist Zugriff auf einen Charakter, wie du gesagt hast.

317
00:20:55,000 --> 00:20:59,000
Ja, es ist [unverständlich] ein Zeichen in das Schlüsselwort,

318
00:20:59,000 --> 00:21:04,000
und so ist es Anzahl der Buchstaben zu sehen, weil man nur in Bewegung sind zusammen

319
00:21:04,000 --> 00:21:06,000
das Schlüsselwort wenn man einmal den Brief gesehen,

320
00:21:06,000 --> 00:21:10,000
so, das wird tatsächlich überspringen Räume und stuff like that.

321
00:21:10,000 --> 00:21:12,000
Ja, genau.

322
00:21:12,000 --> 00:21:16,000
Und dann, sobald Sie das Schlüsselwort leere sehen Sie nur mod so dass Sie wieder bewegen.

323
00:21:16,000 --> 00:21:18,000
Genau. Das ist eine perfekte Erklärung.

324
00:21:18,000 --> 00:21:23,000
Was Kevin sagte, ist, dass wir Index in der Schlüsselwort wollen.

325
00:21:23,000 --> 00:21:28,000
Wir wollen die num_letters_seen Charakter zu bekommen, wenn man so will,

326
00:21:28,000 --> 00:21:32,000
aber wenn num_letters_seen übersteigt die Länge des Schlüsselworts

327
00:21:32,000 --> 00:21:37,000
die Art und Weise erhalten wir wieder in den entsprechenden Bereich nutzen wir die mod-Operator

328
00:21:37,000 --> 00:21:40,000
um effektiv herum wickeln.

329
00:21:40,000 --> 00:21:43,000
Zum Beispiel, wie in der kurzen, ist unser Stichwort Speck,

330
00:21:43,000 --> 00:21:46,000
und es ist 5 Zeichen lang sein.

331
00:21:46,000 --> 00:21:50,000
Aber wir haben 6 Buchstaben im Klartext an dieser Stelle gesehen

332
00:21:50,000 --> 00:21:52,000
und verschlüsselte 6.

333
00:21:52,000 --> 00:21:57,000
Am Ende werden wir den Zugriff auf das num_letters_seen,

334
00:21:57,000 --> 00:22:00,000
welches 6, mod die Länge des Schlüsselworts, 5,

335
00:22:00,000 --> 00:22:04,000
und so bekommen wir ein, und so, was wir tun ist, werden wir

336
00:22:04,000 --> 00:22:14,000
Zugriff auf das erste Zeichen in unserer Keyword an diesem Punkt.

337
00:22:14,000 --> 00:22:21,000
>> Alles klar, alle Fragen zu Vigenère

338
00:22:21,000 --> 00:22:26,000
bevor wir weiter?

339
00:22:26,000 --> 00:22:31,000
You guys ein ziemlich gutes Gefühl this?

340
00:22:31,000 --> 00:22:35,000
Cool, super.

341
00:22:35,000 --> 00:22:38,000
Ich möchte sicherstellen, dass Sie Jungs sind immer die Chance, Code zu sehen

342
00:22:38,000 --> 00:22:48,000
dass wir denken, sieht gut aus und haben die Chance, daraus zu lernen.

343
00:22:48,000 --> 00:22:53,000
Das wird das letzte Mal sein wir werden mit Räumen für vorerst

344
00:22:53,000 --> 00:22:59,000
und wir den Übergang gehe jetzt, und ich werde zu cs50.net/lectures gehen

345
00:22:59,000 --> 00:23:06,000
so können wir uns ein wenig Quiz Bewertung.

346
00:23:06,000 --> 00:23:10,000
Der beste Weg, denke ich, zu tun beginnen Quiz bewerten

347
00:23:10,000 --> 00:23:15,000
ist auf diese Vorträge Seite kommen, cs50.net/lectures,

348
00:23:15,000 --> 00:23:20,000
und unter jeder der Woche Überschriften, also wenn ich hier in Woche 0,

349
00:23:20,000 --> 00:23:27,000
Ich sehe, dass wir eine Liste von Themen, die wir in Woche 0 abgedeckt haben.

350
00:23:27,000 --> 00:23:31,000
>> Wenn eines dieser Themen scheint Ihnen nicht vertraut

351
00:23:31,000 --> 00:23:34,000
Sie möchte auf jeden Fall gehen Sie zurück und durchkämmen die Vorlesungsunterlagen und möglicherweise

352
00:23:34,000 --> 00:23:39,000
auch durch die Vorträge überfliegen, sehen sie wieder, wenn Sie wollen,

353
00:23:39,000 --> 00:23:44,000
um ein Gefühl für das, was ist los mit jedem dieser Themen zu bekommen.

354
00:23:44,000 --> 00:23:49,000
Ich werde zusätzlich sagen, in diesem Jahr einer der coolen Ressourcen, die wir haben

355
00:23:49,000 --> 00:23:55,000
ist diese Shorts dass wir erstellt haben, und wenn man sich in Woche 0,

356
00:23:55,000 --> 00:24:00,000
haben wir nicht alle Themen abgedeckt, aber wir haben nicht wenige von ihnen,

357
00:24:00,000 --> 00:24:03,000
einige der schwieriger diejenigen, so beobachtete diese Shorts wieder

358
00:24:03,000 --> 00:24:08,000
ist ein guter Weg, um Sie auf dem Laufenden.

359
00:24:08,000 --> 00:24:15,000
Insbesondere werde ich in einem Stecker für den 3 gesetzt auf dem Boden, da ich die habe.

360
00:24:15,000 --> 00:24:20,000
Aber wenn Sie mit binären kämpfen, Bits, hex, solche Sachen,

361
00:24:20,000 --> 00:24:22,000
Binär ist ein großartiger Ort zu starten.

362
00:24:22,000 --> 00:24:25,000
ASCII ist eine andere, die gut, zu sehen ist.

363
00:24:25,000 --> 00:24:31,000
Sie können sogar mich 1.5x Geschwindigkeit wenn ich zu langsam bin.

364
00:24:31,000 --> 00:24:35,000
Da es sich um Kritik, fühlen Sie sich frei, das zu tun.

365
00:24:35,000 --> 00:24:40,000
>> Nur um wirklich schnell zu starten, werden wir über ein paar von diesen Quiz-Aufgaben gehen

366
00:24:40,000 --> 00:24:44,000
nur, um schnell durch diese Abwanderung.

367
00:24:44,000 --> 00:24:50,000
Zum Beispiel, lasst uns an den Problemzonen 16 schauen, dass ich hier oben auf dem Board hat.

368
00:24:50,000 --> 00:24:54,000
Wir haben diese folgende Berechnung im Binär-,

369
00:24:54,000 --> 00:24:56,000
und wir wollen keine Arbeit zu zeigen.

370
00:24:56,000 --> 00:24:59,000
Okay, ich werde geben diesem einen Schuss.

371
00:24:59,000 --> 00:25:01,000
You guys sollte folgen zusammen mit Papier,

372
00:25:01,000 --> 00:25:04,000
und wir werden dies sehr schnell tun.

373
00:25:04,000 --> 00:25:06,000
Wir wollen die folgende Berechnung in binärer durchzuführen.

374
00:25:06,000 --> 00:25:16,000
Ich habe 00110010.

375
00:25:16,000 --> 00:25:27,000
Und ich werde es 00110010 hinzuzufügen.

376
00:25:27,000 --> 00:25:30,000
Für die mathematische Genies folgenden zusammen zu Hause,

377
00:25:30,000 --> 00:25:35,000
Diese wird wirksam Multiplikation mit 2.

378
00:25:35,000 --> 00:25:37,000
Lassen Sie uns beginnen.

379
00:25:37,000 --> 00:25:39,000
Wir werden das gleiche hinaus Algorithmus, was wir tun folgen

380
00:25:39,000 --> 00:25:43,000
wenn wir Dezimalzahlen addieren.

381
00:25:43,000 --> 00:25:46,000
Wirklich der einzige Unterschied hier ist, dass wir Schleife wieder um

382
00:25:46,000 --> 00:25:51,000
einmal haben wir 1 + 1 statt, wenn wir bis 10 erhalten.

383
00:25:51,000 --> 00:25:53,000
>> Wenn wir von der rechten, starten sehr schnell, was ist die erste Ziffer?

384
00:25:53,000 --> 00:25:55,000
[Student] 0. >> [Nate H.] 0.

385
00:25:55,000 --> 00:25:58,000
Große, die zweite Ziffer?

386
00:25:58,000 --> 00:26:00,000
[Student] 1.

387
00:26:00,000 --> 00:26:02,000
[Nate H.] Ist es ein 1? 1 + 1 ist?

388
00:26:02,000 --> 00:26:04,000
[Student] 10.

389
00:26:04,000 --> 00:26:08,000
[Nate H.] Genau, so was ist die Ziffer, dass ich Recht schreibt unter den 2 diejenigen addiert?

390
00:26:08,000 --> 00:26:11,000
[Student] 1, 0 oder 0 und tragen dann das 1.

391
00:26:11,000 --> 00:26:15,000
[Nate H.] 0 und tragen eine 1, genau.

392
00:26:15,000 --> 00:26:18,000
Weiter ein up, Basil, du bist auf.

393
00:26:18,000 --> 00:26:20,000
Was ist das dritte? >> [Basil] 1.

394
00:26:20,000 --> 00:26:23,000
[Nate H.] 1, perfekt. Kevin?

395
00:26:23,000 --> 00:26:27,000
[Kevin] 0. >> [Nate H.] 0, Charlotte?

396
00:26:27,000 --> 00:26:30,000
[Charlotte] 0. >> [Nate H.] Ja, und was soll ich tun?

397
00:26:30,000 --> 00:26:32,000
[Student] Die 1.

398
00:26:32,000 --> 00:26:34,000
[Nate H.] Und was soll ich tun? Und dann trage ich das ein.

399
00:26:34,000 --> 00:26:36,000
Perfekt, SAHB? >> [SAHB] Jetzt haben Sie ein.

400
00:26:36,000 --> 00:26:40,000
[Nate H.] Und soll ich tun hier nichts?

401
00:26:40,000 --> 00:26:43,000
[SAHB] Dann für die nächsten ein Sie haben 1, weil man über 1 durchgeführt.

402
00:26:43,000 --> 00:26:49,000
[Nate H.] Great, so können wir hier es zu beenden up.

403
00:26:49,000 --> 00:26:51,000
Cool.

404
00:26:51,000 --> 00:26:54,000
[Student] Hat 0 + 0 = 0?

405
00:26:54,000 --> 00:26:56,000
0 + 0 = 0 ist.

406
00:26:56,000 --> 00:27:01,000
1 + 1, wie du gesagt hast, ist 10 oder 1, 0, eher.

407
00:27:01,000 --> 00:27:07,000
10 ist eine falsche Bezeichnung, weil mir 10 bedeutet die Zahl 10,

408
00:27:07,000 --> 00:27:12,000
und es ist die Marotte, wie wir vertreten, wenn wir es zu schreiben sind.

409
00:27:12,000 --> 00:27:20,000
Wir vertreten die Zahl 2 von 1, 0, und die Zahl 10 ist etwas anders.

410
00:27:20,000 --> 00:27:23,000
>> Was ist irgendwie schön zu binär ist, dass es wirklich nicht so viele

411
00:27:23,000 --> 00:27:25,000
Fällen müssen Sie lernen.

412
00:27:25,000 --> 00:27:30,000
Es gibt 0 + 0 = 0, 0 + 1 = 1,

413
00:27:30,000 --> 00:27:34,000
1 + 1 = 0, und dann Durchführung einer 1,

414
00:27:34,000 --> 00:27:37,000
und dann können Sie hier auf der dritten Spalte von rechts

415
00:27:37,000 --> 00:27:40,000
wir hatten dieses 1, 1 und 1.

416
00:27:40,000 --> 00:27:43,000
Und 1 + 1 + 1 eine 1 ist,

417
00:27:43,000 --> 00:27:45,000
und Sie tragen ein weiteres 1.

418
00:27:45,000 --> 00:27:48,000
Wenn du tust binäre Addition, ziemlich einfach.

419
00:27:48,000 --> 00:27:51,000
Ich tun würde, ein paar mehr von diesen zur Vernunft zu überprüfen euch

420
00:27:51,000 --> 00:27:54,000
bevor du gehst in denn dies ist

421
00:27:54,000 --> 00:28:00,000
Wahrscheinlich etwas, das wir auf dem Quiz sehen werden.

422
00:28:00,000 --> 00:28:03,000
Jetzt lasst uns diese nächste man als gut.

423
00:28:03,000 --> 00:28:06,000
Lassen Sie uns Probleme 17.

424
00:28:06,000 --> 00:28:12,000
Wir werden die folgende Binärzahl in eine Dezimalzahl umwandeln.

425
00:28:12,000 --> 00:28:28,000
Ich habe 10100111001.

426
00:28:28,000 --> 00:28:33,000
Angemeldet in der binären Video, dass ich

427
00:28:33,000 --> 00:28:36,000
Ich ging durch ein paar Beispiele, und ich zeigte, wie

428
00:28:36,000 --> 00:28:41,000
alles funktioniert, wenn du es tust in dezimal.

429
00:28:41,000 --> 00:28:45,000
Wenn Sie in dezimaler Darstellung arbeite ich denke, wir sind

430
00:28:45,000 --> 00:28:48,000
An diesem Punkt in unserem Leben so fließend, dass

431
00:28:48,000 --> 00:28:53,000
es ist ziemlich leicht zu beschönigen die Mechanik, wie es tatsächlich funktioniert.

432
00:28:53,000 --> 00:28:59,000
>> Aber dazu eine kurze Zusammenfassung, wenn ich die Nummer 137 haben

433
00:28:59,000 --> 00:29:06,000
dies wirklich bedeutet, und auch dies ist in dezimaler Darstellung-

434
00:29:06,000 --> 00:29:19,000
die Zahl 137 in Dezimal bedeutet, dass ich 1 x 100 + 3 x 10 + 7 x 1 haben.

435
00:29:19,000 --> 00:29:22,000
Dies gilt umso bleiben auf dem Bildschirm.

436
00:29:22,000 --> 00:29:29,000
Und dann, wenn man sich diese Zahlen genau hier,

437
00:29:29,000 --> 00:29:34,000
100, 10 und 1, sehen Sie, dass sie tatsächlich sind alle Potenzen von 10.

438
00:29:34,000 --> 00:29:43,000
Ich habe 10 ², 10 ¹, 10 und dem Null.

439
00:29:43,000 --> 00:29:48,000
Wir haben eine ähnliche Art der Sache im Binär-,

440
00:29:48,000 --> 00:29:55,000
außer, dass unsere Basis, wie wir es nennen, ist 2 statt 10.

441
00:29:55,000 --> 00:29:58,000
Diese 10s, dass ich mich hier schrieb am Boden,

442
00:29:58,000 --> 00:30:02,000
Diese 10 ², 10 ¹, 10 auf die Null, 10 ist unsere Basis,

443
00:30:02,000 --> 00:30:08,000
und der Exponent, 0, 1, oder 2,

444
00:30:08,000 --> 00:30:14,000
wird durch die Position der Zahl in der Nummer, die wir schreiben impliziert.

445
00:30:14,000 --> 00:30:21,000
1, wenn wir es betrachten, ist dies ein in der zweiten Position.

446
00:30:21,000 --> 00:30:27,000
Die 3 ist in der ersten Position, und die 7 ist in der 0. Position.

447
00:30:27,000 --> 00:30:35,000
Das ist, wie wir die verschiedenen Exponenten unten für unsere Basen erhalten.

448
00:30:35,000 --> 00:30:40,000
>> Nach all dieser wir kommen, eigentlich weißt du was?

449
00:30:40,000 --> 00:30:43,000
Wir tun-wo haben meine Undo-Knopf gehen?

450
00:30:43,000 --> 00:30:45,000
Dort geht es.

451
00:30:45,000 --> 00:30:47,000
Ich liebe diese rückgängig Sache.

452
00:30:47,000 --> 00:30:51,000
Danach denke ich zumindest für mich

453
00:30:51,000 --> 00:30:54,000
der einfachste Weg, die Konvertierung zu starten eine binäre Zahl

454
00:30:54,000 --> 00:30:57,000
oder eine Hexadezimalzahl, wo die Basis ist 16

455
00:30:57,000 --> 00:31:02,000
und nicht 10 oder 2 ist, gehen Sie vor und schreiben Sie

456
00:31:02,000 --> 00:31:09,000
der Basen und Exponenten für alle Zahlen in meinem Binärzahl an der Spitze.

457
00:31:09,000 --> 00:31:14,000
Wenn wir von links nach rechts wieder

458
00:31:14,000 --> 00:31:17,000
das ist Art von Intuition,

459
00:31:17,000 --> 00:31:23,000
Ich werde wieder auf schwarz Hier haben wir die 2 auf die 0. Position

460
00:31:23,000 --> 00:31:27,000
und dann haben wir 2 ¹, 2 ²,

461
00:31:27,000 --> 00:31:33,000
und dann 2 der 3, die 2 bis 4, 2 an die 5, 6,

462
00:31:33,000 --> 00:31:39,000
7, 8, 9 und 10.

463
00:31:39,000 --> 00:31:41,000
Diese Zahlen, die ich aufgeschrieben habe, sind alle Exponenten.

464
00:31:41,000 --> 00:31:48,000
Ich schrieb nur die Grundlagen hier in den ersten 3 nur für den Raum.

465
00:31:48,000 --> 00:31:50,000
>> An dieser Stelle werde ich weitermachen und ich bin eigentlich los, um zu löschen

466
00:31:50,000 --> 00:31:53,000
Die Sachen, die wir in dezimaler tat, wenn das okay ist.

467
00:31:53,000 --> 00:31:57,000
Sie haben alle, dass.

468
00:31:57,000 --> 00:32:05,000
Diejenigen von Ihnen, das Ansehen von Online Ich bin sicher in der Lage sein, mich zurückspulen, wenn Sie möchten.

469
00:32:05,000 --> 00:32:07,000
Wechseln zurück zum Stift.

470
00:32:07,000 --> 00:32:12,000
Nun, was wir tun können, wenn Sie Jungs sind nicht ganz bis auf Ihrem Potenzen von 2 zu beschleunigen,

471
00:32:12,000 --> 00:32:15,000
das ist total cool.

472
00:32:15,000 --> 00:32:18,000
Es geschieht. Ich verstehe.

473
00:32:18,000 --> 00:32:23,000
Ich hatte einmal ein Vorstellungsgespräch, wo ich wurde gesagt, ich sollte alle Potenzen von 2 weiß

474
00:32:23,000 --> 00:32:26,000
bis über 2 bis 30..

475
00:32:26,000 --> 00:32:29,000
Es war nicht ein Job, den ich bekam.

476
00:32:29,000 --> 00:32:32,000
Jedenfalls kann euch voran gehen und die Mathematik zu tun hier,

477
00:32:32,000 --> 00:32:35,000
aber mit binären es nicht wirklich Sinn machen,

478
00:32:35,000 --> 00:32:38,000
und noch macht es Sinn mit dezimal oder hexadezimal entweder

479
00:32:38,000 --> 00:32:43,000
die Mathematik, wo man Nullen zu tun.

480
00:32:43,000 --> 00:32:49,000
Sie können sehen, ich habe hier 0, hier eine 0, 0 hier hier 0, 0 hier 0 ein.

481
00:32:49,000 --> 00:32:52,000
Warum könnte es nicht sinnvoll, die tatsächliche Mathematik zu tun

482
00:32:52,000 --> 00:32:56,000
die entsprechende Potenz von 2 für diese Position berechnen?

483
00:32:56,000 --> 00:32:59,000
Genau wie Charlotte sagte, wird es 0 sein.

484
00:32:59,000 --> 00:33:05,000
Könnte genauso gut sparen Sie sich die Zeit, wenn die Berechnung Potenzen von 2 ist nicht Ihre Stärke.

485
00:33:05,000 --> 00:33:10,000
In diesem Fall brauchen wir nur, um es für 2 Berechnung der 0,-ist?

486
00:33:10,000 --> 00:33:12,000
[Student] 1.

487
00:33:12,000 --> 00:33:14,000
[H. Nate] 1, 2 bis 3, nämlich das-?

488
00:33:14,000 --> 00:33:16,000
[Student] 8. >> [Nate H.] 8.

489
00:33:16,000 --> 00:33:18,000
2 bis 4 die?

490
00:33:18,000 --> 00:33:21,000
[Student] 2. Es tut mir leid, 1.

491
00:33:21,000 --> 00:33:26,000
[Nate H.] 2 der 4 ist 16, genau.

492
00:33:26,000 --> 00:33:28,000
2 der 5, Kevin? >> 32.

493
00:33:28,000 --> 00:33:32,000
[Nate H.] 32, 2 der 8?

494
00:33:32,000 --> 00:33:38,000
[Student] 32 x 8, 256.

495
00:33:38,000 --> 00:33:41,000
[Nate H.] Perfect.

496
00:33:41,000 --> 00:33:43,000
Und 2 auf die 10?

497
00:33:43,000 --> 00:33:45,000
[Student] 1024.

498
00:33:45,000 --> 00:33:49,000
[Nate H.] Yeah, 1024.

499
00:33:49,000 --> 00:33:57,000
>> Sobald wir haben diese Zahlen, die wir sie alle Zusammenfassend kann.

500
00:33:57,000 --> 00:34:01,000
Und das ist, wo es wirklich wichtig ist, ein paar Dinge zu tun.

501
00:34:01,000 --> 00:34:07,000
Man wird langsam gehen und überprüfen Sie Ihre Arbeit.

502
00:34:07,000 --> 00:34:10,000
Man kann sagen, dass es eine 1 am Ende dieser Zahl,

503
00:34:10,000 --> 00:34:15,000
also sollte ich auf jeden Fall erhalten eine ungerade Zahl, wie mein Ergebnis

504
00:34:15,000 --> 00:34:18,000
weil alle die anderen gehen, um sogar Zahlen

505
00:34:18,000 --> 00:34:21,000
da sie eine Binärzahl ist.

506
00:34:21,000 --> 00:34:24,000
Die andere Sache zu tun ist, wenn Sie zu diesem Zeitpunkt auf dem Test zu erhalten

507
00:34:24,000 --> 00:34:27,000
und du hast es geschrieben, diese weit

508
00:34:27,000 --> 00:34:30,000
und du bist nicht mehr viel Zeit

509
00:34:30,000 --> 00:34:33,000
Blick auf die Anzahl der Punkte, dass dieses Problem wert ist.

510
00:34:33,000 --> 00:34:40,000
Dieses Problem, wie Sie sehen, wenn ich kann klappen zurück zu meinem Laptop wirklich schnell-

511
00:34:40,000 --> 00:34:44,000
Dieses Problem ist 2 Punkte wert, so ist dies nicht die Art der Addition

512
00:34:44,000 --> 00:34:47,000
Sie sollten gehen durch, wenn Sie wirklich unter Zeitdruck sind.

513
00:34:47,000 --> 00:34:52,000
Aber wir werden wieder zurück in den iPad, und wir werden durch sie wirklich schnell gehen.

514
00:34:52,000 --> 00:34:54,000
>> Ich mag dabei die kleinen Zahlen zuerst

515
00:34:54,000 --> 00:34:56,000
weil ich finde, dass einfacher.

516
00:34:56,000 --> 00:35:00,000
Ich mag 32 und 8, weil sie zusammen ziemlich leicht zu gehen, und wir bekommen 50.

517
00:35:00,000 --> 00:35:03,000
16 und 1 bekommt 17.

518
00:35:03,000 --> 00:35:05,000
Es wir 57,

519
00:35:05,000 --> 00:35:14,000
und dann können wir den Rest dieses, so können wir tun, 57, 156.

520
00:35:14,000 --> 00:35:16,000
Komm schon.

521
00:35:16,000 --> 00:35:19,000
Man gut, mal sehen.

522
00:35:19,000 --> 00:35:27,000
Wir hatten 57, 256 und 1024.

523
00:35:27,000 --> 00:35:31,000
An dieser Stelle würde ich lieber nur durchlaufen.

524
00:35:31,000 --> 00:35:35,000
Ich habe keine Ahnung. Ich brauchen eindeutig zu lesen, auf diese.

525
00:35:35,000 --> 00:35:40,000
7, 6 und 4, erhalten Sie 17.

526
00:35:40,000 --> 00:35:42,000
1, 5, 5, 2, 13.

527
00:35:42,000 --> 00:35:45,000
Dann bekommen wir 3, und dann bekommen wir ein.

528
00:35:45,000 --> 00:35:52,000
1337.

529
00:35:52,000 --> 00:35:55,000
Osterei, anybody?

530
00:35:55,000 --> 00:35:59,000
Wer erkennt diese Nummer?

531
00:35:59,000 --> 00:36:02,000
Chris erkennt die Nummer. Was bedeutet es, Chris?

532
00:36:02,000 --> 00:36:04,000
[Chris] Leet.

533
00:36:04,000 --> 00:36:11,000
Leet, also, wenn Sie dies zu betrachten, sieht es aus wie leet.

534
00:36:11,000 --> 00:36:15,000
Hacker Zeug. Watch out für diese Art von Sachen auf dem Midterm oder Quiz, eher.

535
00:36:15,000 --> 00:36:19,000
Wenn Sie diese Art von Sachen und sehen Sie sich fragen, "Huh"

536
00:36:19,000 --> 00:36:22,000
das könnte tatsächlich etwas bedeuten.

537
00:36:22,000 --> 00:36:24,000
Ich weiß nicht. David mag legt es in.

538
00:36:24,000 --> 00:36:26,000
Es ist ein guter Weg, um sanity überprüfen.

539
00:36:26,000 --> 00:36:30,000
Wie okay, kann ich sehen, was los ist.

540
00:36:30,000 --> 00:36:34,000
>> Das ist Week 0/Week 1 stuff.

541
00:36:34,000 --> 00:36:39,000
Wenn wir wieder zurück in unserem Laptop jetzt

542
00:36:39,000 --> 00:36:46,000
Verkleinern und ein paar andere Dinge.

543
00:36:46,000 --> 00:36:50,000
Es gibt ASCII, was wir getan haben eine Menge mit den Problem-Sets.

544
00:36:50,000 --> 00:36:55,000
Dieser Begriff des Kapitals A. Was ist das eigentlich?

545
00:36:55,000 --> 00:36:57,000
Zu wissen, es ist die Dezimalzahl.

546
00:36:57,000 --> 00:37:00,000
65 ist, was es ist in der ASCII-Tabelle zugeordnet,

547
00:37:00,000 --> 00:37:03,000
und das ist daher, wie der Computer schreibt er,

548
00:37:03,000 --> 00:37:06,000
und das ist, wie wir schon immer weg mit tatsächlich schriftlich

549
00:37:06,000 --> 00:37:09,000
der Charakter Kapital A und der Charakter Kleinbuchstaben a

550
00:37:09,000 --> 00:37:14,000
in einigen dieser Lösungen und Problemstellungen, die Sie getan haben.

551
00:37:14,000 --> 00:37:16,000
Ein paar andere Dinge.

552
00:37:16,000 --> 00:37:25,000
Wir haben Aussagen, boolean Ausdrücke, Bedingungen, Schleifen, Variablen und Threads.

553
00:37:25,000 --> 00:37:29,000
>> Diejenigen scheinen alle Sinne zum größten Teil machen?

554
00:37:29,000 --> 00:37:35,000
Einige dieser Terminologie ist ein wenig funky mal an.

555
00:37:35,000 --> 00:37:46,000
Ich mag an einer Aussage zum größten Teil etwas, das mit einem Semikolon endet denken.

556
00:37:46,000 --> 00:37:51,000
Aussagen wie x = 7, die eine variable setzt,

557
00:37:51,000 --> 00:37:54,000
vermutlich als x = 7.

558
00:37:54,000 --> 00:38:01,000
Vermutlich x ist auch eine Art, die die Nummer 7 speichern kann,

559
00:38:01,000 --> 00:38:05,000
so ist es ein int oder möglicherweise ein Schwimmer oder eine kurze oder eine char,

560
00:38:05,000 --> 00:38:07,000
so ähnlich.

561
00:38:07,000 --> 00:38:12,000
Ein boolescher Ausdruck verwendet diese doppelte gleich

562
00:38:12,000 --> 00:38:17,000
und der Knall gleich oder nicht gleich, kleiner als, größer als,

563
00:38:17,000 --> 00:38:22,000
weniger als oder gleich alle dieser Art von Sachen.

564
00:38:22,000 --> 00:38:28,000
AGB sind dann, wenn else-Anweisungen.

565
00:38:28,000 --> 00:38:32,000
Ich würde denken, dass man nicht einen anderen, ohne eine entsprechende if.

566
00:38:32,000 --> 00:38:37,000
Ebenso können Sie nicht über ein anderes, wenn ohne eine entsprechende if.

567
00:38:37,000 --> 00:38:40,000
Loops, erinnern an die 3 Arten von Schleifen wir in man euch hämmerte

568
00:38:40,000 --> 00:38:43,000
für die letzten paar Abschnitte und Problemstellungen.

569
00:38:43,000 --> 00:38:46,000
Der Arbeit, während, wenn Sie daran Benutzereingaben sind,

570
00:38:46,000 --> 00:38:51,000
mit while-Schleifen, bis eine bestimmte Bedingung true ist,

571
00:38:51,000 --> 00:38:56,000
und dann mit den for-Schleifen, wenn Sie benötigen

572
00:38:56,000 --> 00:39:01,000
wissen, welche Iteration der Schleife Sie sind momentan in ist, wie ich darüber denke.

573
00:39:01,000 --> 00:39:07,000
Oder wenn du tust eine für jedes Zeichen in einem String Ich möchte etwas tun,

574
00:39:07,000 --> 00:39:15,000
für jedes Element in einem Array Ich möchte etwas zu diesem Element zu tun.

575
00:39:15,000 --> 00:39:18,000
>> Themen und Veranstaltungen.

576
00:39:18,000 --> 00:39:21,000
Diese haben wir nicht so explizit in C bedeckt,

577
00:39:21,000 --> 00:39:23,000
aber nicht vergessen, das von Scratch.

578
00:39:23,000 --> 00:39:26,000
Dies ist der Begriff mit verschiedenen Skripten.

579
00:39:26,000 --> 00:39:32,000
Dies ist auch dieser Begriff des Rundfunks ein Ereignis.

580
00:39:32,000 --> 00:39:37,000
Einige Leute nicht Rundfunks in ihre Projekte zunächst

581
00:39:37,000 --> 00:39:40,000
das ist total cool,

582
00:39:40,000 --> 00:39:46,000
aber diese sind 2 verschiedene Wege im Umgang mit diesen größeres Problem als Parallelität,

583
00:39:46,000 --> 00:39:49,000
das ist, wie Sie Programme ausführen zu bekommen

584
00:39:49,000 --> 00:39:54,000
oder scheinbar zur gleichen Zeit ausführen?

585
00:39:54,000 --> 00:39:59,000
Unterschiedliche Aufgaben ausgeführt werden, während auch andere Aufgaben ausgeführt werden.

586
00:39:59,000 --> 00:40:01,000
Dies ist, wie das Betriebssystem zu funktionieren scheint.

587
00:40:01,000 --> 00:40:04,000
Deshalb ist, obwohl beispielsweise

588
00:40:04,000 --> 00:40:10,000
Ich habe meine Browser läuft, kann ich auch auf Spotify drehen und spielen ein Lied.

589
00:40:10,000 --> 00:40:14,000
Das ist eher eine begriffliche Sache zu verstehen.

590
00:40:14,000 --> 00:40:17,000
Ich würde einen Blick auf die Themen kurzen Start

591
00:40:17,000 --> 00:40:21,000
wenn Sie möchten, um mehr darüber zu erfahren, dass.

592
00:40:21,000 --> 00:40:26,000
>> Mal sehen, ich glaube, es hätte sein können

593
00:40:26,000 --> 00:40:31,000
Ein Problem auf das in einer von diesen.

594
00:40:31,000 --> 00:40:35,000
Nochmals, ich denke Themen und Ereignisse sind nicht etwas, das wir in C abdecken

595
00:40:35,000 --> 00:40:41,000
nur weil es wesentlich schwieriger als in Scratch.

596
00:40:41,000 --> 00:40:44,000
Sie sollten nicht über sie dort machen, aber auf jeden Fall verstehen die Konzepte,

597
00:40:44,000 --> 00:40:47,000
verstehen, was vor sich geht.

598
00:40:47,000 --> 00:40:52,000
Bevor wir fortfahren, werden alle Fragen zur Woche 0 Material?

599
00:40:52,000 --> 00:40:55,000
Jeder ein ziemlich gutes Gefühl?

600
00:40:55,000 --> 00:41:03,000
Understanding Variablen und was eine Variable ist?

601
00:41:03,000 --> 00:41:08,000
>> Umzug auf. Woche 1.

602
00:41:08,000 --> 00:41:12,000
Ein paar Dinge hier, die nicht besonders abgedeckt wurden

603
00:41:12,000 --> 00:41:21,000
im Quiz bewerten notwendig und auch weitere konzeptionelle Dinge zu denken.

604
00:41:21,000 --> 00:41:30,000
Die erste ist diese Vorstellung von dem, was Quellcode, Compiler und Objekt-Code sind.

605
00:41:30,000 --> 00:41:32,000
Anybody? Basil.

606
00:41:32,000 --> 00:41:37,000
Ist Objekt-Code, ich meine Quellcode ist, was Sie in Klang setzen,

607
00:41:37,000 --> 00:41:42,000
und Objekt-Code ist, was Klang setzt aus, so dass Ihr Computer kann das Programm lesen.

608
00:41:42,000 --> 00:41:44,000
Genau.

609
00:41:44,000 --> 00:41:47,000
Der Quellcode ist der C-Code, dass Sie tatsächlich geben auf.

610
00:41:47,000 --> 00:41:50,000
Object-Code ist, was du aus Klang.

611
00:41:50,000 --> 00:41:54,000
Es ist die 0 und 1 in dieser binären Format.

612
00:41:54,000 --> 00:41:59,000
Und was passiert, wenn Sie eine Reihe von Objekt-Dateien haben,

613
00:41:59,000 --> 00:42:04,000
sagen Sie kompilieren ein Projekt oder ein Programm, das mehrere Quellcode-Dateien verwendet,

614
00:42:04,000 --> 00:42:09,000
die vereinbarungsgemäß die. c-Datei Erweiterung.

615
00:42:09,000 --> 00:42:13,000
Deshalb haben wir caesar.c, vigenère.c haben.

616
00:42:13,000 --> 00:42:18,000
Wenn Sie das Schreiben von Java-Programmen sind Sie ihnen die Erweiterung. Java.

617
00:42:18,000 --> 00:42:24,000
Python-Programme haben die Erweiterung. Py oft.

618
00:42:24,000 --> 00:42:26,000
>> Sobald Sie mehrere. C Dateien haben, kompilieren Sie sie.

619
00:42:26,000 --> 00:42:29,000
Clang spuckt all diese binären Müll.

620
00:42:29,000 --> 00:42:33,000
Dann, weil Sie nur 1 Programm

621
00:42:33,000 --> 00:42:37,000
Sie haben den Linker Link alle diese Objektdateien zusammen

622
00:42:37,000 --> 00:42:40,000
in 1 ausführbare Datei.

623
00:42:40,000 --> 00:42:45,000
Dies ist auch, was passiert, wenn Sie den CS50-Bibliothek verwenden, zum Beispiel.

624
00:42:45,000 --> 00:42:50,000
Das CS50-Bibliothek ist, dass sowohl. H Header-Datei

625
00:42:50,000 --> 00:42:53,000
die Sie gelesen haben, dass # includecs50.h.

626
00:42:53,000 --> 00:42:58,000
Und dann ist es auch eine spezielle binäre Library-Datei

627
00:42:58,000 --> 00:43:02,000
Das ist zusammengestellt worden, dh 0 und 1,

628
00:43:02,000 --> 00:43:08,000
und dass Flag-l, also, wenn wir gehen zurück zu unserem Spaces und wir freuen sehr schnell

629
00:43:08,000 --> 00:43:11,000
an, was hier vor sich geht, wenn wir in unserem clang Befehl aussehen,

630
00:43:11,000 --> 00:43:15,000
Was wir haben, ist dies ist unser Quellcodedatei hier richtig.

631
00:43:15,000 --> 00:43:18,000
Dies sind ein paar Compiler-Flags.

632
00:43:18,000 --> 00:43:22,000
Und dann ganz am Ende, diese-l flags Link in

633
00:43:22,000 --> 00:43:30,000
die tatsächliche binäre Dateien für diese 2-Bibliotheken, die CS50-Bibliothek und dann die Mathematik-Bibliothek.

634
00:43:30,000 --> 00:43:35,000
>> Verstehen jede Art von Dateien 'Zweck

635
00:43:35,000 --> 00:43:38,000
bei der Zusammenstellung Prozess ist etwas, das Sie wollen in der Lage sein

636
00:43:38,000 --> 00:43:43,000
geben mindestens ein hohes Maß Überblick.

637
00:43:43,000 --> 00:43:46,000
Source code kommt in. Object-Code kommt heraus.

638
00:43:46,000 --> 00:43:53,000
Object-Code-Dateien miteinander verknüpfen, und Sie erhalten eine schöne, ausführbare Datei.

639
00:43:53,000 --> 00:43:55,000
Cool.

640
00:43:55,000 --> 00:43:58,000
Dies gilt auch, wo Sie Fehler an mehreren Stellen erhalten können

641
00:43:58,000 --> 00:44:00,000
in der Kompilierung.

642
00:44:00,000 --> 00:44:04,000
Dies ist, wo, zum Beispiel, wenn Ihnen diese Verknüpfung Flagge,

643
00:44:04,000 --> 00:44:10,000
Die CS50 Flagge, und man sie weglassen in Spaces oder wenn Sie Ihren Code ausführen möchten,

644
00:44:10,000 --> 00:44:13,000
das ist, wo Sie einen Fehler in der Verknüpfung Phase bekommen,

645
00:44:13,000 --> 00:44:18,000
und der Linker wird sagen: "Hey, du bist ein GetString genannt

646
00:44:18,000 --> 00:44:20,000
das ist in der CS50-Bibliothek. "

647
00:44:20,000 --> 00:44:25,000
"Sie sagte mir, es war in der CS50-Bibliothek, und ich kann nicht finden, den Code für sie."

648
00:44:25,000 --> 00:44:28,000
Das ist, wo Sie es in Verknüpfung haben, und das ist separaten

649
00:44:28,000 --> 00:44:33,000
von einem Compiler-Fehler, weil der Compiler wird auf Syntax und solche Sachen suchen.

650
00:44:33,000 --> 00:44:38,000
Es ist gut zu wissen, was los ist, wenn.

651
00:44:38,000 --> 00:44:42,000
>> Andere Dinge zu wissen.

652
00:44:42,000 --> 00:44:49,000
Ich würde sagen, Sie wollen auf jeden Fall einen Blick auf die kurz auf typecasting von Jordan getan zu nehmen

653
00:44:49,000 --> 00:44:55,000
zu verstehen, was ints unter der Haube sind,

654
00:44:55,000 --> 00:44:58,000
Welche Zeichen sind unter der Haube.

655
00:44:58,000 --> 00:45:02,000
Wenn wir über ASCII reden und wir tatsächlich Blick auf die ASCII-Tabelle,

656
00:45:02,000 --> 00:45:07,000
was das tut gibt uns ein unter die Haube schauen

657
00:45:07,000 --> 00:45:13,000
, wie der Computer tatsächlich stellt Kapital A und die Ziffer 7

658
00:45:13,000 --> 00:45:17,000
und ein Komma und ein Fragezeichen.

659
00:45:17,000 --> 00:45:20,000
Der Computer hat auch besondere Weise zu repräsentieren

660
00:45:20,000 --> 00:45:23,000
die Zahl 7 als integer.

661
00:45:23,000 --> 00:45:27,000
Es hat eine besondere Art und Weise, um die Zahl 7 als Gleitkommazahl darstellen,

662
00:45:27,000 --> 00:45:29,000
und diejenigen, sind sehr unterschiedlich.

663
00:45:29,000 --> 00:45:32,000
Typecasting ist, wie Sie sagen, der Computer "Hey, ich Sie konvertieren möchten

664
00:45:32,000 --> 00:45:37,000
von einer Darstellung in einer anderen Darstellung. "

665
00:45:37,000 --> 00:45:40,000
Warum gehen wir nicht einen Blick auf, dass.

666
00:45:40,000 --> 00:45:44,000
>> Ich würde auch einen Blick auf die kurz auf Bibliotheken und kurz auf Compiler.

667
00:45:44,000 --> 00:45:47,000
Diejenigen Diskussion über den Prozess der Erstellung,

668
00:45:47,000 --> 00:45:53,000
was eine Bibliothek ist, und gehen über einige dieser Fragen, die Sie gefragt kommen könnten.

669
00:45:53,000 --> 00:45:55,000
Fragen zu Woche 1 Material?

670
00:45:55,000 --> 00:46:03,000
Gibt es irgendwelche Themen hier, die abschreckend wirken Sie möchten, zu decken?

671
00:46:03,000 --> 00:46:07,000
Ich versuche, durch die meisten dieser früheren Themen zu blasen, so dass wir bekommen können, um

672
00:46:07,000 --> 00:46:13,000
Zeiger und tun ein bisschen Rekursion.

673
00:46:13,000 --> 00:46:15,000
Gedanken?

674
00:46:15,000 --> 00:46:19,000
Nichts zu decken?

675
00:46:19,000 --> 00:46:21,000
Zeit für etwas Schokolade vielleicht?

676
00:46:21,000 --> 00:46:23,000
Ihr seid durch sie arbeiten.

677
00:46:23,000 --> 00:46:26,000
Ich werde zu halten nippen an meinem Kaffee.

678
00:46:26,000 --> 00:46:31,000
Woche 2.

679
00:46:31,000 --> 00:46:34,000
Guter Ruf, guten Ruf.

680
00:46:34,000 --> 00:46:38,000
In Woche 2 sprachen wir ein wenig mehr über die Funktionen.

681
00:46:38,000 --> 00:46:43,000
>> In den ersten paar Übungsaufgaben wir nicht wirklich schreiben alle Funktionen auf allen

682
00:46:43,000 --> 00:46:45,000
andere als welcher Funktion?

683
00:46:45,000 --> 00:46:47,000
[Student] Main. >> Main, genau.

684
00:46:47,000 --> 00:46:51,000
Und so haben wir die verschiedenen Kostüme, die wichtigsten trägt gesehen.

685
00:46:51,000 --> 00:46:54,000
Es ist das einzige, in dem es keine Argumente,

686
00:46:54,000 --> 00:46:58,000
und wir nur sagen Leere zwischen den Klammern

687
00:46:58,000 --> 00:47:01,000
und dann gibt es die andere, wo wir wollen Befehlszeilenargumente nimmst,

688
00:47:01,000 --> 00:47:08,000
und wie wir gesehen haben, das ist, wo man int argc und String argv Array

689
00:47:08,000 --> 00:47:13,000
oder jetzt, dass wir tatsächlich String ausgesetzt die char *, dass es sein

690
00:47:13,000 --> 00:47:20,000
werden wir mit dem Schreiben beginnen sie als char * argv und dann Klammern.

691
00:47:20,000 --> 00:47:22,000
In Problem Set 3, sah euch eine Reihe von Funktionen,

692
00:47:22,000 --> 00:47:27,000
und Sie eine Reihe von Funktionen implementiert, zeichnen, schauen, Gerangel.

693
00:47:27,000 --> 00:47:31,000
Die Prototypen wurden alle für Sie geschrieben.

694
00:47:31,000 --> 00:47:33,000
>> Was ich schon immer über hier funktioniert wirklich schnell zu sprechen

695
00:47:33,000 --> 00:47:38,000
ist, dass es 3 Teile, um sie, wenn Sie eine Funktion zu schreiben.

696
00:47:38,000 --> 00:47:43,000
Sie müssen den Rückgabetyp der Funktion anzugeben.

697
00:47:43,000 --> 00:47:46,000
Sie müssen einen Namen für die Funktion angeben, und dann müssen Sie angeben,

698
00:47:46,000 --> 00:47:51,000
die Liste der Argumente oder Parameter-Liste.

699
00:47:51,000 --> 00:47:57,000
Zum Beispiel, wenn ich eine Funktion schreiben zu summieren ein paar Zahlen

700
00:47:57,000 --> 00:48:03,000
und dann zu mir zurück die Summe, was meine Rückgabetyp wäre

701
00:48:03,000 --> 00:48:06,000
wenn ich wollte Zahlen summieren und dann wieder die Summe?

702
00:48:06,000 --> 00:48:12,000
Dann wird der Name der Funktion.

703
00:48:12,000 --> 00:48:27,000
Wenn ich gehe voraus und schreiben im Grünen, ist dieser Teil der Rückgabetyp.

704
00:48:27,000 --> 00:48:34,000
Dieser Teil ist der Name.

705
00:48:34,000 --> 00:48:40,000
Und dann in Klammern

706
00:48:40,000 --> 00:48:46,000
ist, wo ich die Argumente zu geben,

707
00:48:46,000 --> 00:48:56,000
häufig abgekürzt als args, manchmal genannt params für Parameter.

708
00:48:56,000 --> 00:49:00,000
Und wenn Sie eine haben, müssen Sie nur angeben ein.

709
00:49:00,000 --> 00:49:06,000
Wenn Sie mehrere trennen Sie jeweils mit einem Komma.

710
00:49:06,000 --> 00:49:13,000
Und für jedes Argument geben Sie es 2 Dinge, die sind-Kevin?

711
00:49:13,000 --> 00:49:18,000
[Kevin] Sie haben die Art und dann den Namen geben.

712
00:49:18,000 --> 00:49:21,000
Und dann der Name, und der Name ist der Name, den Sie verwenden wollen

713
00:49:21,000 --> 00:49:25,000
zu diesem Argument innerhalb der Summe-Funktion beziehen,

714
00:49:25,000 --> 00:49:27,000
innerhalb der Funktion, die Sie gerade schreiben.

715
00:49:27,000 --> 00:49:32,000
>> Sie müssen nicht, zum Beispiel, wenn ich werde zu summieren,

716
00:49:32,000 --> 00:49:41,000
sagen, ein Array von Ganzzahlen-wir tun int-Array,

717
00:49:41,000 --> 00:49:46,000
und ich gebe mir ein paar geschweiften Klammern gibt-

718
00:49:46,000 --> 00:49:51,000
wenn ich dann ein Array der Summe-Funktion

719
00:49:51,000 --> 00:49:55,000
Ich gehe in die erste Position der Liste der Argumente.

720
00:49:55,000 --> 00:49:59,000
Aber das Array, dass ich übergeben muss nicht den Namen arr haben.

721
00:49:59,000 --> 00:50:07,000
Arr sein wird, wie ich auf dieses Argument beziehen innerhalb des Körpers der Funktion.

722
00:50:07,000 --> 00:50:10,000
Die andere Sache, die wir brauchen, um zu berücksichtigen,

723
00:50:10,000 --> 00:50:14,000
und das ist etwas anders funktioniert, aber ich denke, es ist ein wichtiger Punkt,

724
00:50:14,000 --> 00:50:20,000
ist, dass in C, wenn ich schreibe eine Funktion wie diese

725
00:50:20,000 --> 00:50:29,000
wie kann ich wissen, wie viele Elemente in diesem Array?

726
00:50:29,000 --> 00:50:31,000
Dies ist so etwas wie eine Fangfrage.

727
00:50:31,000 --> 00:50:35,000
Wir sprachen über diese ein wenig in der vergangenen Woche Abschnitt.

728
00:50:35,000 --> 00:50:40,000
Woher weiß ich, die Anzahl der Elemente in einem Array in C?

729
00:50:40,000 --> 00:50:44,000
Gibt es eine Möglichkeit?

730
00:50:44,000 --> 00:50:49,000
>> Es stellt sich heraus, dass es keine Möglichkeit zu wissen.

731
00:50:49,000 --> 00:50:52,000
Man muss es passieren, getrennt.

732
00:50:52,000 --> 00:50:55,000
Es gibt einen Trick, dass Sie tun können

733
00:50:55,000 --> 00:51:00,000
wenn Sie in der gleichen Funktion in dem das Array deklariert wurde,

734
00:51:00,000 --> 00:51:04,000
und du bist mit einem Stapel-Array eingesetzt.

735
00:51:04,000 --> 00:51:06,000
Aber das funktioniert nur, wenn in der gleichen Funktion sind.

736
00:51:06,000 --> 00:51:09,000
Wenn Sie ein Array mit einer anderen Funktion oder wenn Sie deklariert haben eine Reihe

737
00:51:09,000 --> 00:51:12,000
und Sie das Array setzen auf dem Heap, haben Sie malloc verwendet

738
00:51:12,000 --> 00:51:15,000
 und solche Sachen, dann sind alle Wetten ab.

739
00:51:15,000 --> 00:51:18,000
Dann haben Sie eigentlich um passieren

740
00:51:18,000 --> 00:51:21,000
ein besonderes Argument oder ein anderer Parameter

741
00:51:21,000 --> 00:51:23,000
sagen Ihnen, wie groß das Array ist.

742
00:51:23,000 --> 00:51:28,000
In diesem Fall würde ich wollen ein Komma-ich bin zu verwenden sorry, es geht aus dem Bildschirm hier-

743
00:51:28,000 --> 00:51:32,000
und ich würde in einem anderen Argument übergeben

744
00:51:32,000 --> 00:51:40,000
 und nennen es int len ​​für die Länge.

745
00:51:40,000 --> 00:51:44,000
>> Eine Sache, die kommen könnten auf der Quiz

746
00:51:44,000 --> 00:51:49,000
fragt Sie zu schreiben oder zu implementieren eine bestimmte Funktion aufgerufen etwas.

747
00:51:49,000 --> 00:51:54,000
Wenn wir nicht geben Ihnen die Prototypen, so dass diese ganze Sache hier

748
00:51:54,000 --> 00:51:58,000
dieses ganze Durcheinander wird die Funktion Erklärung oder die Funktion Prototyp namens,

749
00:51:58,000 --> 00:52:01,000
Dies ist eines der ersten Dinge, die Sie wollen festzunageln, wenn sie nicht gegeben hat

750
00:52:01,000 --> 00:52:03,000
Sie sofort auf das Quiz.

751
00:52:03,000 --> 00:52:06,000
Der andere Trick, den ich gelernt habe, ist, dass

752
00:52:06,000 --> 00:52:11,000
sagen, wir geben Ihnen einen Prototypen für eine Funktion, und wir sagen: "Hey, du hast es zu schreiben."

753
00:52:11,000 --> 00:52:16,000
Innerhalb der geschweiften Klammern, die Sie auf dem Quiz

754
00:52:16,000 --> 00:52:20,000
Wenn Sie feststellen, dass es eine Rückkehr geben und Sie bemerken, dass der Rückgabetyp

755
00:52:20,000 --> 00:52:25,000
ist etwas anderes als Leere, was bedeutet, dass die Funktion nicht wieder etwas bedeutet,

756
00:52:25,000 --> 00:52:28,000
dann, was Sie wollen auf jeden Fall tun, schreiben

757
00:52:28,000 --> 00:52:33,000
irgendeine Art von return-Anweisung am Ende der Funktion.

758
00:52:33,000 --> 00:52:40,000
Return, und in diesem Fall, wir setzen eine leere, weil wir in die leere füllen wollen.

759
00:52:40,000 --> 00:52:44,000
Aber das bekommt man das Denken in der richtigen Weise, wie werde ich dieses Problem anzugehen?

760
00:52:44,000 --> 00:52:49,000
Und es erinnert Sie gehen zu müssen, die einen Wert zurückgeben

761
00:52:49,000 --> 00:52:51,000
an den Aufrufer der Funktion.

762
00:52:51,000 --> 00:52:54,000
>> Yeah. >> [Student] Hat Stil anzuwenden, wenn wir das Schreiben von Code sind auf dem quiz?

763
00:52:54,000 --> 00:52:58,000
Wie Einrückung und solche Sachen? >> [Student] Yeah.

764
00:52:58,000 --> 00:53:00,000
Nein, nicht so viel.

765
00:53:00,000 --> 00:53:09,000
Ich denke, eine Menge, das ist etwas, was wir auf dem Quiz am Tag der werde klären,

766
00:53:09,000 --> 00:53:15,000
aber in der Regel Gedanken über # enthält und diese Art von Zeug, es ist eine Art von außen.

767
00:53:15,000 --> 00:53:17,000
[Student] Müssen Sie Ihre handschriftlichen Code zu kommentieren?

768
00:53:17,000 --> 00:53:19,000
Müssen Sie Ihre handschriftlichen Code zu kommentieren?

769
00:53:19,000 --> 00:53:24,000
Kommentierte ist immer gut, wenn man über einen Teil des Kredits sind besorgt

770
00:53:24,000 --> 00:53:29,000
oder Sie wollen Ihre Absicht, den Grader kommunizieren.

771
00:53:29,000 --> 00:53:33,000
Aber ich wieder auf dem Quiz selbst und auf das Quiz Tage klären,

772
00:53:33,000 --> 00:53:39,000
aber ich glaube nicht, dass es erforderlich werden, um Kommentare zu schreiben, nicht werden.

773
00:53:39,000 --> 00:53:42,000
Normalerweise nicht, aber es ist definitiv die Art von Dingen, wo

774
00:53:42,000 --> 00:53:45,000
Sie kommunizieren können Ihre Absicht, wie "Hey, das ist, wo ich mit ihm gehe ist."

775
00:53:45,000 --> 00:53:49,000
Und manchmal, die mit einen Teil des Kredits zu helfen.

776
00:53:49,000 --> 00:53:51,000
Cool.

777
00:53:51,000 --> 00:53:53,000
>> Basil.

778
00:53:53,000 --> 00:53:56,000
[Basil] Was ist der Unterschied zwischen dem Deklarieren, sagen wir, int lang

779
00:53:56,000 --> 00:54:03,000
in den Argumenten oder Parametern gegenüber der Deklaration einer Variablen innerhalb der Funktion?

780
00:54:03,000 --> 00:54:05,000
Wow, ging Kaffee auf der Luftröhre.

781
00:54:05,000 --> 00:54:07,000
[Basil] Wie die Dinge wollen wir in Argumente.

782
00:54:07,000 --> 00:54:09,000
Ja, das ist eine große Frage.

783
00:54:09,000 --> 00:54:11,000
Wie wählen Sie, welche Dinge Sie in den Argumenten wollen

784
00:54:11,000 --> 00:54:17,000
gegenüber, was ihr im Inneren tun sollten der Funktion?

785
00:54:17,000 --> 00:54:24,000
In diesem Fall haben wir aufgenommen beides als Argumente

786
00:54:24,000 --> 00:54:29,000
weil sie etwas, wer würde die Summe-Funktion wird

787
00:54:29,000 --> 00:54:32,000
braucht, um diese Dinge zu spezifizieren.

788
00:54:32,000 --> 00:54:35,000
>> Die Summe Funktion, wie wir darüber gesprochen, hat keine Möglichkeit zu wissen,

789
00:54:35,000 --> 00:54:40,000
wie groß das Array ist es aus seiner Anrufer oder wer auch immer ist mit der Summe-Funktion.

790
00:54:40,000 --> 00:54:44,000
Es hat keine Möglichkeit zu wissen, wie groß das Array ist.

791
00:54:44,000 --> 00:54:48,000
Der Grund gehen wir in dieser Länge hier als Argument

792
00:54:48,000 --> 00:54:51,000
Denn das ist etwas, dass wir im Grunde sagen die Aufrufer der Funktion,

793
00:54:51,000 --> 00:54:55,000
Wer wird die Summe Funktion zu nutzen, "Hey, nicht nur Sie haben, um uns eine Reihe

794
00:54:55,000 --> 00:54:59,000
von ints, müssen Sie auch, uns zu sagen, wie groß das Array, das Sie gegeben haben uns ist. "

795
00:54:59,000 --> 00:55:03,000
[Basil] Diese werden sowohl Befehlszeilenargumente sein?

796
00:55:03,000 --> 00:55:06,000
Nein, das sind aktuelle Argumente, dass Sie an die Funktion übergeben.

797
00:55:06,000 --> 00:55:10,000
>> Lass es mich tun eine neue Seite hier.

798
00:55:10,000 --> 00:55:13,000
[Basil] Wie Namen würde Pass-

799
00:55:13,000 --> 00:55:24,000
[Nate H.] Wenn ich int main (void)

800
00:55:24,000 --> 00:55:27,000
und ich werde in meinem return 0 legte hier auf dem Boden,

801
00:55:27,000 --> 00:55:31,000
und sagen, ich will die Summe-Funktion aufrufen.

802
00:55:31,000 --> 00:55:42,000
Ich möchte sagen, int x = Summe ();

803
00:55:42,000 --> 00:55:46,000
Um die Summe-Funktion Ich habe sowohl im Array übergeben, dass ich zu summieren möchten

804
00:55:46,000 --> 00:55:51,000
und die Länge der Anordnung, so ist dies in dem

805
00:55:51,000 --> 00:55:54,000
vorausgesetzt, ich hatte ein Array von ints,

806
00:55:54,000 --> 00:56:12,000
sagen, ich hatte int numbaz [] = 1, 2, 3,

807
00:56:12,000 --> 00:56:16,000
Art der Nutzung, die bis gehackt Syntax genau dort,

808
00:56:16,000 --> 00:56:21,000
was ich dann tun würde, ist in der Summe würde ich wollen in übergeben

809
00:56:21,000 --> 00:56:27,000
sowohl numbaz und die Zahl 3

810
00:56:27,000 --> 00:56:30,000
die Summe-Funktion zu sagen "Okay, hier das Array Ich möchte Sie zu summieren ist."

811
00:56:30,000 --> 00:56:34,000
"Hier ist seine Größe."

812
00:56:34,000 --> 00:56:39,000
Macht das Sinn? Beantwortet das Ihre Frage?

813
00:56:39,000 --> 00:56:42,000
>> In vielerlei Hinsicht ist es tut parallel, was wir mit den wichtigsten zu tun

814
00:56:42,000 --> 00:56:44,000
wenn wir die Argumente der Kommandozeile haben.

815
00:56:44,000 --> 00:56:47,000
Ein Programm wie Cäsar-Chiffre, zum Beispiel erforderlich, dass

816
00:56:47,000 --> 00:56:53,000
Befehlszeilenargumente nicht in der Lage, etwas zu tun.

817
00:56:53,000 --> 00:56:57,000
Es wäre nicht wissen, wie sie zu verschlüsseln, wenn Sie nicht sagen, was zu verwendenden Schlüssel

818
00:56:57,000 --> 00:57:03,000
oder wenn Sie nicht sagen, was Zeichenfolge zu verschlüsseln wollte.

819
00:57:03,000 --> 00:57:08,000
Aufforderung zur Eingabe, das ist, wo wir 2 verschiedene Mechanismen haben

820
00:57:08,000 --> 00:57:14,000
zur Aufnahme Eingabe in vom Benutzer, zum Aufnehmen Informationen in vom Benutzer.

821
00:57:14,000 --> 00:57:19,000
Für Problem Set 1 sahen wir diese GetInt, GetString, GetFloat Weg

822
00:57:19,000 --> 00:57:26,000
der Aufforderung zur Eingabe, und das ist als mit dem Standard-Input-Stream.

823
00:57:26,000 --> 00:57:28,000
Es ist ein wenig anders.

824
00:57:28,000 --> 00:57:31,000
Es ist etwas, dass Sie auf einmal tun können, im Gegensatz zu

825
00:57:31,000 --> 00:57:35,000
wenn Sie das Programm, rufen Sie, wenn Sie das Programm laufen beginnen.

826
00:57:35,000 --> 00:57:41,000
Die Befehlszeilenargumente alle sind angegeben, wenn Sie das Programm laufen beginnen.

827
00:57:41,000 --> 00:57:47,000
Wir haben das Mischen der zwei von denen.

828
00:57:47,000 --> 00:57:52,000
Wenn wir Argumenten für eine Funktion, ist es ähnlich wie Befehlszeilenargumente to main.

829
00:57:52,000 --> 00:57:56,000
Es ist, wenn Sie die Funktion, die Sie brauchen, um es zu sagen berufen

830
00:57:56,000 --> 00:58:05,000
was genau er braucht, um seine Aufgaben zu erfüllen.

831
00:58:05,000 --> 00:58:08,000
Eine weitere gute Sache an und schaue ich lasse man es betrachtet in Ihrer Freizeit,

832
00:58:08,000 --> 00:58:11,000
und es wurde in der überdachten quiz-war diese Vorstellung von Umfang

833
00:58:11,000 --> 00:58:15,000
und lokalen Variablen gegenüber globalen Variablen.

834
00:58:15,000 --> 00:58:18,000
Sie achten darauf.

835
00:58:18,000 --> 00:58:23,000
>> Nun, wir bekommen auf diesem anderen Zeug,

836
00:58:23,000 --> 00:58:27,000
in Woche 3 wir kamen ins Gespräch über das Suchen und Sortieren.

837
00:58:27,000 --> 00:58:32,000
Suchen und Sortieren, zumindest in CS50,

838
00:58:32,000 --> 00:58:39,000
ist sehr viel eine Einführung in einige der theoretischen Teile der Informatik.

839
00:58:39,000 --> 00:58:42,000
Das Problem des Suchens, das Problem des Sortierens

840
00:58:42,000 --> 00:58:46,000
sind groß, kanonische Probleme.

841
00:58:46,000 --> 00:58:52,000
Wie finden Sie eine bestimmte Anzahl in einer Reihe von Milliarden von Zahlen?

842
00:58:52,000 --> 00:58:55,000
Wie finden Sie einen bestimmten Namen in einem Telefonbuch

843
00:58:55,000 --> 00:58:59,000
Das ist auf Ihrem Laptop gespeichert?

844
00:58:59,000 --> 00:59:04,000
Und so stellen wir diesen Begriff der asymptotischen Laufzeiten

845
00:59:04,000 --> 00:59:11,000
um wirklich zu quantifizieren, wie lange, wie schwer diese Problem sind,

846
00:59:11,000 --> 00:59:14,000
wie lange sie dauern zu lösen.

847
00:59:14,000 --> 00:59:20,000
In, glaube ich, 2011-Quiz gibt es ein Problem, dass ich denke Verdienste

848
00:59:20,000 --> 00:59:27,000
Abdecken sehr schnell, was ist ein, Problem 12.

849
00:59:27,000 --> 00:59:32,000
O nein, es ist Omega.

850
00:59:32,000 --> 00:59:41,000
>> Wir reden hier über die schnellstmögliche Laufzeit reden

851
00:59:41,000 --> 00:59:46,000
für einen bestimmten Algorithmus und dann der langsamsten möglichen Laufzeit.

852
00:59:46,000 --> 00:59:52,000
Diese Omega und O sind wirklich nur Verknüpfungen.

853
00:59:52,000 --> 00:59:55,000
Sie sind notational Verknüpfungen zu sagen

854
00:59:55,000 --> 00:59:59,000
wie schnell in der besten möglichen Fall wird unser Algorithmus laufen,

855
00:59:59,000 --> 01:00:06,000
und wie langsam im schlimmsten Fall wird der Algorithmus laufen?

856
01:00:06,000 --> 01:00:10,000
Lassen Sie uns ein paar von ihnen, und diese wurden ebenfalls behandelt

857
01:00:10,000 --> 01:00:13,000
in der kurzen über asymptotische Notation, die ich sehr empfehlen.

858
01:00:13,000 --> 01:00:17,000
Jackson hat einen wirklich guten Job.

859
01:00:17,000 --> 01:00:23,000
Mit binären Suche, reden wir über binäre Suche als ein Algorithmus,

860
01:00:23,000 --> 01:00:28,000
und wir in der Regel darüber reden in Bezug auf seine großen O.

861
01:00:28,000 --> 01:00:30,000
Was ist das große O?

862
01:00:30,000 --> 01:00:34,000
Was ist die langsamste mögliche Laufzeit der binären Suche?

863
01:00:34,000 --> 01:00:36,000
[Student] N ²?

864
01:00:36,000 --> 01:00:41,000
Schließen, schätze ich ähnlich.

865
01:00:41,000 --> 01:00:43,000
Es ist viel schneller als die.

866
01:00:43,000 --> 01:00:45,000
[Student] Binary? >> Ja, binäre Suche.

867
01:00:45,000 --> 01:00:47,000
[Student] Es ist log n.

868
01:00:47,000 --> 01:00:49,000
Anmelden n, so was tut sich n das?

869
01:00:49,000 --> 01:00:51,000
Es halbiert es jede Iteration.

870
01:00:51,000 --> 01:00:56,000
Genau, so in der langsamsten möglichen Fall,

871
01:00:56,000 --> 01:01:00,000
sagen, wenn Sie eine sortierte Array

872
01:01:00,000 --> 01:01:08,000
von einer Million Zahlen und die Zahl, die Sie suchen

873
01:01:08,000 --> 01:01:14,000
entweder das allererste Element in der Matrix oder der allerletzten Element in dem Array.

874
01:01:14,000 --> 01:01:18,000
Denken Sie daran, arbeitet der binären Suchalgorithmus, indem man die mittlere Element,

875
01:01:18,000 --> 01:01:21,000
zu sehen, ob das ist das Spiel, das Sie suchen.

876
01:01:21,000 --> 01:01:23,000
Wenn es ist dann groß, finden sie ihn.

877
01:01:23,000 --> 01:01:27,000
>> Im besten Fall, wie schnell muss binäre Suche laufen?

878
01:01:27,000 --> 01:01:29,000
[Studenten] 1.

879
01:01:29,000 --> 01:01:32,000
1, ist es konstanter Zeit, big O von 1. Yeah.

880
01:01:32,000 --> 01:01:36,000
[Student] Ich habe eine Frage. Wenn Sie sagen, Sie n, du meinst mit Bezug zur Basis 2, richtig?

881
01:01:36,000 --> 01:01:40,000
Ja, das ist so, dass die andere Sache.

882
01:01:40,000 --> 01:01:44,000
Wir sagen log n, und ich denke, wenn ich in der Highschool war

883
01:01:44,000 --> 01:01:48,000
Ich habe immer angenommen, dass Log-Basis 10 war.

884
01:01:48,000 --> 01:01:57,000
Yeah, also ja, melden Basis 2 in der Regel ist das, was wir verwenden.

885
01:01:57,000 --> 01:02:02,000
Wieder geht zurück auf binäre Suche, wenn Sie sich für entweder gesuchten

886
01:02:02,000 --> 01:02:05,000
das Element am Ende oder das Element am Anfang,

887
01:02:05,000 --> 01:02:08,000
weil man in der Mitte und beginnen dann zu verwerfen

888
01:02:08,000 --> 01:02:13,000
je nachdem, welche Hälfte nicht den Kriterien entsprechen, die Sie suchen,

889
01:02:13,000 --> 01:02:15,000
und gehen Sie auf die nächste halbe und die nächste halbe und die nächste Hälfte.

890
01:02:15,000 --> 01:02:19,000
Wenn ich für die größte Element in der Millionen Integer-Array suchen

891
01:02:19,000 --> 01:02:25,000
Ich werde es höchstens log von 1 Million mal halbieren

892
01:02:25,000 --> 01:02:28,000
bevor ich endlich testen und sehen, dass das Element Ich suche

893
01:02:28,000 --> 01:02:33,000
ist in dem größten oder im höchsten Index des Arrays,

894
01:02:33,000 --> 01:02:38,000
und das wird log n zu nehmen, sich von 1 Million mal.

895
01:02:38,000 --> 01:02:40,000
>> Bubble sort.

896
01:02:40,000 --> 01:02:43,000
Do you guys erinnere mich an den Bubble-Sort-Algorithmus?

897
01:02:43,000 --> 01:02:47,000
Kevin, kannst du mir eine kurze Zusammenfassung von dem, was passiert in der Bubble-Sort-Algorithmus?

898
01:02:47,000 --> 01:02:50,000
[Kevin] Grundsätzlich geht es durch alles, was in der Liste.

899
01:02:50,000 --> 01:02:52,000
Es sieht auf den ersten beiden.

900
01:02:52,000 --> 01:02:55,000
Falls die erste größer ist als die zweite Swaps es ihnen.

901
01:02:55,000 --> 01:02:58,000
Dann vergleicht zweiten und dritten, dasselbe, Swaps

902
01:02:58,000 --> 01:03:00,000
dritten und vierten, den ganzen Weg hinunter.

903
01:03:00,000 --> 01:03:03,000
Größere Zahlen folgen bis zum Ende.

904
01:03:03,000 --> 01:03:07,000
Und nachdem wie viele Schleifen fertig.

905
01:03:07,000 --> 01:03:11,000
Genau, so was Kevin sagte, ist, dass wir größere Zahlen zu sehen

906
01:03:11,000 --> 01:03:15,000
Blase bis zum Ende des Arrays.

907
01:03:15,000 --> 01:03:19,000
Zum Beispiel, haben Sie was dagegen zu Fuß uns durch dieses Beispiel, wenn dies unser Angebot?

908
01:03:19,000 --> 01:03:21,000
[Kevin] Sie nehmen 2 und 3.

909
01:03:21,000 --> 01:03:23,000
3 ist größer als 2, so dass Sie tauschen sie.

910
01:03:23,000 --> 01:03:29,000
[Nate H.] Right, so tauschen wir diese, und so bekommen wir 2, 3, 6, 4 und 9.

911
01:03:29,000 --> 01:03:31,000
[Kevin] Dann vergleichen Sie die 3 und 6.

912
01:03:31,000 --> 01:03:33,000
3 ist kleiner als 6, so lassen Sie sie,

913
01:03:33,000 --> 01:03:37,000
und 6 und 4, würdest du tauschen sie, weil 4 ist kleiner als 6 ist.

914
01:03:37,000 --> 01:03:42,000
[Nate H.] Right, so bekomme ich 2, 3, 4, 6, 9.

915
01:03:42,000 --> 01:03:46,000
[Kevin] und 9 ist größer als 6, so dass Sie es verlassen.

916
01:03:46,000 --> 01:03:48,000
Und du würdest gehen zurück durch sie wieder.

917
01:03:48,000 --> 01:03:50,000
>> [Nate H.] Bin ich an dieser Stelle getan? >> [Kevin] Nr.

918
01:03:50,000 --> 01:03:52,000
Und warum bin ich nicht an dieser Stelle getan?

919
01:03:52,000 --> 01:03:54,000
Weil es sieht aus wie mein Array wird sortiert. Ich sehe es.

920
01:03:54,000 --> 01:03:57,000
[Kevin] Gehe durch sie wieder und stellen Sie sicher, dass es nicht mehr Swaps

921
01:03:57,000 --> 01:04:00,000
bevor Sie komplett zu stoppen.

922
01:04:00,000 --> 01:04:04,000
Genau, so dass Sie brauchen, um gehen durch und stellen Sie sicher, dass es keine Swaps

923
01:04:04,000 --> 01:04:06,000
dass man an dieser Stelle machen.

924
01:04:06,000 --> 01:04:08,000
Es war wirklich nur Glück, wie du gesagt hast, dass wir am Ende

925
01:04:08,000 --> 01:04:12,000
nur mit, um ein Durchlauf machen und wir sortiert.

926
01:04:12,000 --> 01:04:16,000
Aber um dies im allgemeinen Fall tun wir eigentlich, dies immer und immer wieder tun.

927
01:04:16,000 --> 01:04:20,000
Und in der Tat war dies ein Beispiel für die bestmögliche Fall

928
01:04:20,000 --> 01:04:24,000
wie wir sahen, in das Problem.

929
01:04:24,000 --> 01:04:28,000
Wir sahen, dass die bestmögliche Fall n wurde.

930
01:04:28,000 --> 01:04:32,000
Wir gingen durch das Array 1 mal.

931
01:04:32,000 --> 01:04:35,000
Was ist die denkbar schlechteste Fall für diesen Algorithmus?

932
01:04:35,000 --> 01:04:37,000
[Kevin] N ².

933
01:04:37,000 --> 01:04:41,000
Und was bedeutet das aussehen? Was würde ein Array aussehen, dass würde n ² Zeit?

934
01:04:41,000 --> 01:04:43,000
[Kevin] [unverständlich] sortiert.

935
01:04:43,000 --> 01:04:51,000
Genau, so hätte ich das Array 9, 7, 6, 5, 2,

936
01:04:51,000 --> 01:04:54,000
zuerst die 9 würden bubble den ganzen Weg bis.

937
01:04:54,000 --> 01:04:59,000
Nach 1 Iteration hätten wir 7, 6, 5, 2, 9.

938
01:04:59,000 --> 01:05:07,000
Dann würde das 7 sprudeln, 6, 5, 2, 7, 9, und so weiter und so fort.

939
01:05:07,000 --> 01:05:13,000
>> Wir müssten das gesamte Array durch n Zeiten gehen,

940
01:05:13,000 --> 01:05:16,000
und Sie können tatsächlich etwas präziser als dies

941
01:05:16,000 --> 01:05:23,000
denn wenn wir umgezogen den 9 den ganzen Weg bis in seine letzten möglichen Position

942
01:05:23,000 --> 01:05:26,000
wir wissen, dass wir nie gegen dieses Element wieder zu vergleichen.

943
01:05:26,000 --> 01:05:29,000
Sobald wir beginnen sprudeln die 7 bis

944
01:05:29,000 --> 01:05:35,000
wir wissen, dass wir aufhören können, wenn die 7 ist direkt vor dem 9

945
01:05:35,000 --> 01:05:37,000
da wir schon die 9, um es verglichen.

946
01:05:37,000 --> 01:05:46,000
Wenn Sie dies auf intelligente Weise zu tun, es ist nicht wirklich, ich denke, dass viel Zeit.

947
01:05:46,000 --> 01:05:49,000
Du wirst doch nicht um alle möglichen [unverständlich] Kombinationen vergleichen

948
01:05:49,000 --> 01:05:55,000
jedes einzelne Mal, wenn Sie gehen durch jede Iteration.

949
01:05:55,000 --> 01:05:59,000
Aber dennoch, wenn wir über diese Obergrenze sprechen wir sagen, dass

950
01:05:59,000 --> 01:06:04,000
Sie sind auf der Suche n ² Vergleiche ganzen Weg durch.

951
01:06:04,000 --> 01:06:12,000
>> Gehen wir zurück, und da wir fangen an, sich ein wenig zu kurz auf Zeit

952
01:06:12,000 --> 01:06:15,000
Ich würde sagen, man sollte auf jeden Fall durch den Rest dieser Tabelle gehen,

953
01:06:15,000 --> 01:06:17,000
füllen sie alle aus.

954
01:06:17,000 --> 01:06:20,000
Denken Sie an Beispiele. Denken Sie an konkreten Beispielen.

955
01:06:20,000 --> 01:06:22,000
Das ist wirklich praktisch und hilfreich zu tun.

956
01:06:22,000 --> 01:06:25,000
Zeichnen Sie es heraus.

957
01:06:25,000 --> 01:06:28,000
Dies ist die Art der Tabelle, dass, wie Sie durch in der Informatik

958
01:06:28,000 --> 01:06:32,000
Sie sollten wirklich anfangen, diese auswendig zu kennen.

959
01:06:32,000 --> 01:06:34,000
Dies sind die Arten von Fragen erhalten Sie in Interviews.

960
01:06:34,000 --> 01:06:36,000
Dies sind Arten von Dingen, die gut zu wissen sind,

961
01:06:36,000 --> 01:06:41,000
und über diese Grenzfälle denke, wirklich herauszufinden, wie man denken

962
01:06:41,000 --> 01:06:45,000
wohl wissend, dass für Bubble sortieren die denkbar schlechteste array

963
01:06:45,000 --> 01:06:52,000
mit dieser Art ist eine, die in umgekehrter Reihenfolge ist.

964
01:06:52,000 --> 01:06:58,000
>> Pointers. Sprechen wir ein wenig über Zeiger.

965
01:06:58,000 --> 01:07:03,000
In den letzten Minuten haben wir hier

966
01:07:03,000 --> 01:07:11,000
Ich weiß, das ist etwas, mit Datei-I / O, die ist ziemlich neu.

967
01:07:11,000 --> 01:07:19,000
Wenn wir reden über Zeiger den Grund wollen wir über Zeiger zu sprechen

968
01:07:19,000 --> 01:07:24,000
Denn ein, wenn wir in C arbeiten

969
01:07:24,000 --> 01:07:33,000
wir sind wirklich auf einem relativ niedrigen Niveau im Vergleich zu den meisten modernen Programmiersprachen.

970
01:07:33,000 --> 01:07:38,000
Wir sind tatsächlich in der Lage, die Variablen im Speicher zu manipulieren,

971
01:07:38,000 --> 01:07:43,000
herauszufinden, wo sie tatsächlich in unserem RAM sich befinden.

972
01:07:43,000 --> 01:07:46,000
Sobald Sie auf Betriebssystem-Klassen sehen Sie nehmen verschwunden

973
01:07:46,000 --> 01:07:48,000
, dass das ist, wieder Art von Abstraktion.

974
01:07:48,000 --> 01:07:50,000
Das ist nicht der Fall.

975
01:07:50,000 --> 01:07:52,000
Wir haben den virtuellen Speicher, die versteckt diese Details ist von uns bekommen.

976
01:07:52,000 --> 01:07:58,000
>> Aber jetzt kann man davon ausgehen, dass, wenn Sie ein Programm haben,

977
01:07:58,000 --> 01:08:02,000
zum Beispiel, wenn Sie die Schaltung Ihrer Caesar-Chiffre-Programm-

978
01:08:02,000 --> 01:08:06,000
Ich werde wieder zurück in meinem iPad wirklich schnell-

979
01:08:06,000 --> 01:08:12,000
dass am Anfang Ihres Programms, wenn Sie, sagen wir,

980
01:08:12,000 --> 01:08:15,000
4 Gigabyte RAM auf Ihrem Laptop,

981
01:08:15,000 --> 01:08:21,000
Sie erhalten neben diesen Brocken gesetzt, und wir werden dieses RAM nennen.

982
01:08:21,000 --> 01:08:25,000
Und es beginnt in einem Ort, den wir gehen auf 0 nennen wollen,

983
01:08:25,000 --> 01:08:30,000
und endet an einem Ort, dass wir 4 Gigabyte nennen.

984
01:08:30,000 --> 01:08:37,000
Ich kann wirklich nicht schreiben. Mann, das ist gehackt.

985
01:08:37,000 --> 01:08:40,000
Wenn Ihr Programm führt

986
01:08:40,000 --> 01:08:44,000
das Betriebssystem schnitzt RAM,

987
01:08:44,000 --> 01:08:51,000
und es gibt verschiedene Segmente für verschiedene Teile des Programms zu leben in.

988
01:08:51,000 --> 01:08:58,000
Hier unten in diesem Bereich ist eine Art Niemandsland.

989
01:08:58,000 --> 01:09:02,000
Wenn Sie gehen ein wenig weiter hier

990
01:09:02,000 --> 01:09:05,000
Sie haben tatsächlich bekam die Stelle, wo

991
01:09:05,000 --> 01:09:09,000
der Code für Ihr Programm lebt.

992
01:09:09,000 --> 01:09:13,000
Dass die tatsächlichen Binärcode, dass ausführbare Datei tatsächlich wird in den Speicher geladen

993
01:09:13,000 --> 01:09:17,000
wenn Sie ein Programm ausführen, und sie lebt in der Code-Segment.

994
01:09:17,000 --> 01:09:22,000
Und wie das Programm führt der Prozessor sieht in dieser Code-Segment

995
01:09:22,000 --> 01:09:24,000
um herauszufinden, was ist die nächste Anweisung?

996
01:09:24,000 --> 01:09:27,000
Was ist der nächste Codezeile muss ich ausführen?

997
01:09:27,000 --> 01:09:31,000
>> Es gibt auch ein Daten-Segment, und dies ist, wo diese String-Konstanten

998
01:09:31,000 --> 01:09:34,000
gespeichert, dass Sie schon mit bekommen.

999
01:09:34,000 --> 01:09:42,000
Und dann weiter oben gibt es diesen Ort genannt Heap.

1000
01:09:42,000 --> 01:09:46,000
Wir greifen auf Speicher in es mit malloc,

1001
01:09:46,000 --> 01:09:49,000
und dann in Richtung der Spitze des Programms

1002
01:09:49,000 --> 01:09:52,000
gibt es die Stapel,

1003
01:09:52,000 --> 01:09:57,000
und das ist, wo wir für die meisten von Anfang gespielt haben sind.

1004
01:09:57,000 --> 01:09:59,000
Dies ist nicht maßstabsgetreu oder nichts.

1005
01:09:59,000 --> 01:10:03,000
Eine Menge davon ist sehr Maschine abhängig,

1006
01:10:03,000 --> 01:10:10,000
Betriebssystem abhängig, aber dies ist vergleichsweise wie Dinge Chunked aufstehen.

1007
01:10:10,000 --> 01:10:17,000
Wenn Sie ein Programm ausführen, und Sie erklären, eine Variable namens x-

1008
01:10:17,000 --> 01:10:27,000
Ich werde ein anderes Feld unten zu ziehen, und dies wird in den RAM als gut.

1009
01:10:27,000 --> 01:10:29,000
Und ich werde sie suchen müssen.

1010
01:10:29,000 --> 01:10:34,000
Wir ziehen gezackte Linien, um anzuzeigen, das ist nur ein kleiner Teil der RAM

1011
01:10:34,000 --> 01:10:38,000
und nicht alle, wie wir ziehen an der Spitze.

1012
01:10:38,000 --> 01:10:43,000
>> Wenn ich erklären, eine Integer-Variable namens x,

1013
01:10:43,000 --> 01:10:49,000
was ich dann tatsächlich bekommen, ist eine Zuordnung

1014
01:10:49,000 --> 01:10:54,000
Das ist in der Symboltabelle mein Programm gespeichert

1015
01:10:54,000 --> 01:11:00,000
das verbindet den Namen x in dieser Region der Erinnerung, die ich gezeichnet haben

1016
01:11:00,000 --> 01:11:03,000
hier zwischen den vertikalen Balken.

1017
01:11:03,000 --> 01:11:08,000
Wenn ich eine Zeile Code in meinem Programm, x = 7 sagt

1018
01:11:08,000 --> 01:11:15,000
der Prozessor weiß "Oh, okay, ich weiß, dass x das Leben an dieser Stelle in Erinnerung."

1019
01:11:15,000 --> 01:11:25,000
"Ich werde weitermachen und schreiben Sie eine 7 gibt."

1020
01:11:25,000 --> 01:11:28,000
Woher weiß er, was Lage dies zu meinem Gedächtnis ist?

1021
01:11:28,000 --> 01:11:30,000
Nun, das ist alles bei der Kompilierung getan.

1022
01:11:30,000 --> 01:11:34,000
Der Compiler kümmert Zuteilen wobei jede der Variablen gehen, gehen

1023
01:11:34,000 --> 01:11:40,000
und die Schaffung einer speziellen Zuordnung bzw. Verbindung der Punkte

1024
01:11:40,000 --> 01:11:43,000
zwischen einem Symbol und wohin es geht, eine variable Namen

1025
01:11:43,000 --> 01:11:46,000
und wo es wird in Erinnerung bleiben.

1026
01:11:46,000 --> 01:11:50,000
Aber es stellt sich heraus, dass wir tatsächlich auf sie in unserer Programme.

1027
01:11:50,000 --> 01:11:55,000
Diese bekommt wichtig, wenn wir sprechen über einige der Datenstrukturen zu starten,

1028
01:11:55,000 --> 01:11:58,000
das ist ein Konzept, dass wir gehen zu einem späteren Zeitpunkt einzuführen.

1029
01:11:58,000 --> 01:12:09,000
>> Aber jetzt, was Sie wissen, ist, dass ich einen Zeiger auf diesen Standort zu erstellen, x.

1030
01:12:09,000 --> 01:12:12,000
Zum Beispiel kann ich eine Zeiger-Variable.

1031
01:12:12,000 --> 01:12:16,000
Wenn wir eine Zeiger-Variable erstellen wir den Stern-Notation.

1032
01:12:16,000 --> 01:12:21,000
In diesem Fall sagt das werde ich einen Zeiger auf ein int erstellen.

1033
01:12:21,000 --> 01:12:24,000
Es ist eine Art wie jede andere.

1034
01:12:24,000 --> 01:12:27,000
Wir geben ihm eine Variable wie y,

1035
01:12:27,000 --> 01:12:32,000
und dann setzen wir sie gleich an die Adresse zu einer Adresse.

1036
01:12:32,000 --> 01:12:38,000
In diesem Fall, können wir y auf x zeigen

1037
01:12:38,000 --> 01:12:43,000
indem Sie die Adresse von x, die wir mit diesem kaufmännisches,

1038
01:12:43,000 --> 01:12:55,000
und dann setzen wir y auf ihn verweisen.

1039
01:12:55,000 --> 01:12:59,000
Was dies im Wesentlichen bedeutet, wenn wir in unserem RAM aussehen

1040
01:12:59,000 --> 01:13:02,000
dies schafft eine separate Variable.

1041
01:13:02,000 --> 01:13:04,000
Es wird nennen es y,

1042
01:13:04,000 --> 01:13:06,000
und wenn diese Zeile Code ausführt

1043
01:13:06,000 --> 01:13:13,000
es ist eigentlich noch ein bisschen Zeiger, die wir üblicherweise als Pfeil zu zeichnen erstellen,

1044
01:13:13,000 --> 01:13:15,000
und es setzt y zu x verweisen.

1045
01:13:15,000 --> 01:13:17,000
Ja.

1046
01:13:17,000 --> 01:13:19,000
[Student] Wenn x ist bereits ein Zeiger, würden Sie genau das zu tun

1047
01:13:19,000 --> 01:13:22,000
int * y = x anstatt das kaufmännische?

1048
01:13:22,000 --> 01:13:24,000
Ja.

1049
01:13:24,000 --> 01:13:27,000
Wenn x ist bereits ein Zeiger, dann können Sie 2 Zeiger einander gleich,

1050
01:13:27,000 --> 01:13:30,000
In diesem Fall wäre nicht y zu x hinweisen,

1051
01:13:30,000 --> 01:13:34,000
aber es würde was x ist darauf zu Punkt.

1052
01:13:34,000 --> 01:13:37,000
Leider können wir aus der Zeit.

1053
01:13:37,000 --> 01:13:44,000
>> Was ich an dieser Stelle sagen, können wir über diese offline zu sprechen,

1054
01:13:44,000 --> 01:13:49,000
aber ich würde sagen der Arbeit beginnen über dieses Problem, # 14.

1055
01:13:49,000 --> 01:13:53,000
Sie sehen, es ist schon ein wenig für Sie ausgefüllt hier.

1056
01:13:53,000 --> 01:13:57,000
Sie können sehen, dass, wenn wir 2 Zeiger deklarieren, int * x und * y,

1057
01:13:57,000 --> 01:14:01,000
und beachten Sie, dass zeigt das * neben der Variablen war etwas, das getan im letzten Jahr.

1058
01:14:01,000 --> 01:14:05,000
Es stellt sich heraus, dass dies ähnlich zu dem, was wir tun, in diesem Jahr ist.

1059
01:14:05,000 --> 01:14:11,000
Es spielt keine Rolle, wo Sie die * schreiben, wenn Sie erklären den Zeiger sind.

1060
01:14:11,000 --> 01:14:17,000
Aber wir haben die * verfasst neben dem Typ

1061
01:14:17,000 --> 01:14:24,000
denn das macht es sehr klar, dass du Deklaration eines Zeigers variabel.

1062
01:14:24,000 --> 01:14:27,000
Sie können sehen, dass der Deklaration der 2 Zeiger gibt uns 2 Boxen.

1063
01:14:27,000 --> 01:14:31,000
Hier, wenn wir x gleich malloc

1064
01:14:31,000 --> 01:14:34,000
was dieser sagt, ist abgesehen von Speicher im Heap.

1065
01:14:34,000 --> 01:14:41,000
Diese kleine Box hier, dieser Kreis wird auf dem Heap entfernt.

1066
01:14:41,000 --> 01:14:43,000
X verbunden.

1067
01:14:43,000 --> 01:14:46,000
Beachten Sie, dass y ist immer noch nicht zeigen zu nichts.

1068
01:14:46,000 --> 01:14:50,000
Um Speicher, um die Zahl 42 in x speichern

1069
01:14:50,000 --> 01:14:55,000
wir nutzen, was Notation?

1070
01:14:55,000 --> 01:14:59,000
[Student] * x = 42.

1071
01:14:59,000 --> 01:15:01,000
Genau, * x = 42.

1072
01:15:01,000 --> 01:15:06,000
Das bedeutet, folgen Sie dem Pfeil und werfen 42 drin.

1073
01:15:06,000 --> 01:15:09,000
Hier, wo wir y und x gesetzt haben wir y zeigt auf x.

1074
01:15:09,000 --> 01:15:13,000
Auch dies ist wie, was Kevin wo wir y gleich x gesetzt ist.

1075
01:15:13,000 --> 01:15:15,000
Y verweist nicht auf x.

1076
01:15:15,000 --> 01:15:19,000
Vielmehr ist es das, was x ist so gut darauf zeigt.

1077
01:15:19,000 --> 01:15:24,000
>> Und dann endlich in dieser letzten Box gibt es 2 mögliche Dinge, die wir tun könnten.

1078
01:15:24,000 --> 01:15:28,000
Einer ist, wir könnten * x = 13 sagen.

1079
01:15:28,000 --> 01:15:33,000
Die andere Sache ist, wir könnten sagen Alex, weißt du, was wir hier tun?

1080
01:15:33,000 --> 01:15:37,000
Man könnte sagen, * x = 13 oder-

1081
01:15:37,000 --> 01:15:41,000
[Student] Man könnte sagen, int whatever.

1082
01:15:41,000 --> 01:15:45,000
[Nate H.] Wenn diese wurden als int-Variable bezeichnet konnten wir das tun.

1083
01:15:45,000 --> 01:15:49,000
Wir könnten auch sagen * y = 13, weil sie beide darauf sind an der gleichen Stelle,

1084
01:15:49,000 --> 01:15:51,000
so konnten wir verwenden entweder variable zu erhalten.

1085
01:15:51,000 --> 01:15:56,000
Yeah. >> [Student] Was würde es aussehen, wenn wir einfach sagen int x 13?

1086
01:15:56,000 --> 01:16:00,000
Das würde erklären eine neue Variable namens x, das nicht funktionieren würde.

1087
01:16:00,000 --> 01:16:04,000
Wir hätten eine Kollision, weil wir x ein Zeiger hier oben erklärt.

1088
01:16:04,000 --> 01:16:10,000
[Student] Wenn wir hatten nur diese Aussage selbst, was würde es aussehen in Bezug auf den Kreis?

1089
01:16:10,000 --> 01:16:14,000
Wenn wir x mussten = 13 dann müssten wir ein Feld, und anstatt einen Pfeil

1090
01:16:14,000 --> 01:16:16,000
Coming Out of the box, wir würden es nur als eine 13 zu ziehen.

1091
01:16:16,000 --> 01:16:19,000
[Student] In der Box. Okay.

1092
01:16:19,000 --> 01:16:24,000
>> Danke für das Aufpassen und viel Glück auf Quiz 0.

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]