1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Review] [Quiz 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Joseph Ong] [Harvard University]

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

4
00:00:08,000 --> 00:00:10,000
>> Hey, everyone.

5
00:00:10,000 --> 00:00:15,000
Willkommen in der Review-Sitzung für Quiz 0, die stattfindet am Mittwoch.

6
00:00:15,000 --> 00:00:19,000
Was wir heute Abend zu tun, bin ich mit 3 anderen TFs,

7
00:00:19,000 --> 00:00:24,000
und zusammen werden wir durch eine Überprüfung dessen, was wir im Laufe getan so weit gehen.

8
00:00:24,000 --> 00:00:27,000
Es wird nicht zu 100% umfassende, aber es sollte Ihnen eine bessere Vorstellung

9
00:00:27,000 --> 00:00:31,000
von dem, was Sie bereits nach unten und was Sie noch brauchen, um vor Mittwoch zu studieren.

10
00:00:31,000 --> 00:00:34,000
Und fühlen Sie sich frei, um Ihre Hand mit Fragen aufwerfen, wie wir zusammen sind,

11
00:00:34,000 --> 00:00:38,000
aber im Kopf behalten, dass wir auch ein wenig Zeit am Ende-

12
00:00:38,000 --> 00:00:41,000
wenn wir durch ein paar Minuten, um Ersatz-auf allgemeine Fragen zu tun,

13
00:00:41,000 --> 00:00:47,000
so man im Hinterkopf behalten, und so werden wir am Anfang mit Week 0 beginnen.

14
00:00:47,000 --> 00:00:50,000
>> [Quiz 0 Bewertung!] [Part 0] [Lexi Ross] Aber bevor wir das tun, lassen Sie uns darüber reden

15
00:00:50,000 --> 00:00:53,000
die Logistik des Quiz.

16
00:00:53,000 --> 00:00:55,000
>> [Logistik] [Quiz findet am Mittwoch 10/10 statt der Vortrag]

17
00:00:55,000 --> 00:00:57,000
>> [(Siehe http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf für Details)] Es ist am Mittwoch, 10. Oktober.

18
00:00:57,000 --> 00:01:00,000
>> Das ist an diesem Mittwoch, und wenn man auf diese URL hier

19
00:01:00,000 --> 00:01:03,000
das ist auch von CS50.net-gibt 's einen Link zu it-

20
00:01:03,000 --> 00:01:06,000
können Sie Informationen darüber, wo auf der Basis gehen

21
00:01:06,000 --> 00:01:10,000
Ihren Nachnamen oder Schule Zugehörigkeit sowie

22
00:01:10,000 --> 00:01:14,000
er erzählt, was genau das Quiz deckt und die Arten von Fragen, die Sie bekommen werden.

23
00:01:14,000 --> 00:01:19,000
Denken Sie daran, dass Sie auch die Möglichkeit haben, für das Quiz im Abschnitt zu überprüfen,

24
00:01:19,000 --> 00:01:21,000
so dass Ihre TFs sollten über einige Praxis Probleme gehen,

25
00:01:21,000 --> 00:01:29,000
und das ist eine andere gute Chance zu sehen, wo Sie noch brauchen, um zu studieren für das Quiz.

26
00:01:29,000 --> 00:01:32,000
Lassen Sie uns am Anfang mit Bits 'n' Bytes beginnen.

27
00:01:32,000 --> 00:01:35,000
Angemeldet etwas ist nur eine 0 oder eine 1,

28
00:01:35,000 --> 00:01:38,000
und ein Byte ist eine Sammlung von 8 dieser Bits.

29
00:01:38,000 --> 00:01:42,000
Lassen Sie uns an dieser Sammlung von Bits nach rechts hier.

30
00:01:42,000 --> 00:01:44,000
Wir sollten in der Lage sein, um herauszufinden, wie viele Bits sind.

31
00:01:44,000 --> 00:01:48,000
Wo wir zählen es gibt nur 8 von ihnen, acht 0 oder 1 Einheiten.

32
00:01:48,000 --> 00:01:51,000
Und da gibt es 8 Bits, also 1 Byte ist,

33
00:01:51,000 --> 00:01:53,000
und lasst uns wandeln es in hexadezimal.

34
00:01:53,000 --> 00:01:58,000
Hexadezimal ist die Basis 16, und es ist ziemlich einfach zu konvertieren

35
00:01:58,000 --> 00:02:01,000
eine Zahl in binäre, ist das, was das ist, um eine Zahl in hexadezimal.

36
00:02:01,000 --> 00:02:04,000
Alles, was wir tun, ist, dass wir schauen Gruppen von 4,

37
00:02:04,000 --> 00:02:07,000
und wir wandeln sie in die entsprechende Hexadezimalzahl.

38
00:02:07,000 --> 00:02:11,000
Wir beginnen mit dem am weitesten rechts Gruppe von 4, so 0011.

39
00:02:11,000 --> 00:02:16,000
Das wird ein 1 und ein 2 sein, so zusammen, dass macht 3.

40
00:02:16,000 --> 00:02:19,000
Und dann schauen wir uns den anderen Block von 4 aussehen.

41
00:02:19,000 --> 00:02:24,000
1101. Das wird ein 1, ein 4 und ein 8 sein.

42
00:02:24,000 --> 00:02:28,000
Gemeinsam das wird, 13 zu sein, das macht D.

43
00:02:28,000 --> 00:02:32,000
Und wir werden daran erinnern, dass in hexadezimaler wir nicht einfach hingehen 0 bis 9 enthalten.

44
00:02:32,000 --> 00:02:36,000
Wir gehen von 0 bis F, also nach 9, 10 entspricht A,

45
00:02:36,000 --> 00:02:40,000
11 bis B, et cetera wobei F 15.

46
00:02:40,000 --> 00:02:44,000
Hier 13 ist ein D,

47
00:02:44,000 --> 00:02:49,000
so wandeln sie in Dezimalzahlen alles, was wir tun, ist, dass wir eigentlich

48
00:02:49,000 --> 00:02:52,000
behandeln jede Position als einer Potenz von 2.

49
00:02:52,000 --> 00:02:58,000
Das ist ein 1, eine 2, Null 4s, Null 8s, ein 16, et cetera,

50
00:02:58,000 --> 00:03:03,000
und es ist ein wenig schwer zu in deinem Kopf zu berechnen, aber wenn wir gehen, um die nächste Folie

51
00:03:03,000 --> 00:03:05,000
können wir die Antwort darauf zu sehen.

52
00:03:05,000 --> 00:03:09,000
>> Im Grunde sind wir ganz von rechts zurück nach links,

53
00:03:09,000 --> 00:03:14,000
und wir Multiplizieren jede Ziffer durch die entsprechende Potenz von 2.

54
00:03:14,000 --> 00:03:19,000
Und denken Sie daran, für hexadezimale bezeichnen wir diese Zahlen mit 0x am Anfang

55
00:03:19,000 --> 00:03:23,000
so dass wir nicht zu verwechseln mit einer Dezimalzahl.

56
00:03:23,000 --> 00:03:29,000
Weiter auf, ist dies ein ASCII-Tabelle,

57
00:03:29,000 --> 00:03:35,000
und was wir ASCII verwenden für ist aus Zeichen in numerische Werte zuzuordnen.

58
00:03:35,000 --> 00:03:39,000
Angemeldet in der Kryptographie pset haben wir umfangreiche Nutzung des ASCII-Tabelle

59
00:03:39,000 --> 00:03:43,000
um verschiedene Methoden der Kryptographie,

60
00:03:43,000 --> 00:03:47,000
der Cäsar und die Vigenère Chiffre, um verschiedene Buchstaben umwandeln

61
00:03:47,000 --> 00:03:52,000
in einer Zeichenfolge gemäß der Taste durch den Benutzer gegeben.

62
00:03:52,000 --> 00:03:56,000
Lassen Sie uns ein wenig von ASCII Mathematik aussehen.

63
00:03:56,000 --> 00:04:02,000
Mit Blick auf 'P' + 1, im Charakter Formular Q wäre,

64
00:04:02,000 --> 00:04:07,000
und denken Sie daran, dass '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
Und wie genau wollen wir zwischen diesen zwei Formen zu konvertieren?

66
00:04:10,000 --> 00:04:13,000
Es ist nicht wirklich zu hart.

67
00:04:13,000 --> 00:04:16,000
Um 5 erhalten wir subtrahieren '0 '

68
00:04:16,000 --> 00:04:20,000
denn es gibt 5 Plätze zwischen 0 'und der '5.

69
00:04:20,000 --> 00:04:23,000
Um in die andere Richtung geht das einfach mit 0 zu gehen,

70
00:04:23,000 --> 00:04:25,000
so ist es ein bisschen wie regelmäßige Arithmetik.

71
00:04:25,000 --> 00:04:29,000
Denken Sie daran, dass, wenn etwas Zitate hat um ihn herum es ein Zeichen ist

72
00:04:29,000 --> 00:04:37,000
und entspricht damit dem Wert in der ASCII-Tabelle.

73
00:04:37,000 --> 00:04:40,000
Umzug in allgemeiner Informatik Themen.

74
00:04:40,000 --> 00:04:43,000
Wir haben gelernt, was ein Algorithmus ist und wie wir die Programmierung verwenden

75
00:04:43,000 --> 00:04:45,000
Algorithmen zu implementieren.

76
00:04:45,000 --> 00:04:48,000
Einige Beispiele von Algorithmen sind etwas ganz Einfaches wie

77
00:04:48,000 --> 00:04:51,000
Prüfen, ob eine gerade oder ungerade Zahl ist.

78
00:04:51,000 --> 00:04:54,000
Dafür erinnern wir uns mod die Nummer 2 und überprüfen, ob das Ergebnis 0 ist.

79
00:04:54,000 --> 00:04:57,000
Wenn dem so ist, ist es noch. Wenn nicht, ist es seltsam.

80
00:04:57,000 --> 00:04:59,000
Und das ist ein Beispiel für eine wirklich grundlegende Algorithmus.

81
00:04:59,000 --> 00:05:02,000
>> Ein wenig von einem mehr beteiligt ist man binäre Suche,

82
00:05:02,000 --> 00:05:05,000
die wir gehen über später in der Review-Sitzung.

83
00:05:05,000 --> 00:05:09,000
Und Programmierung ist der Begriff verwenden wir für die Aufnahme eines Algorithmus

84
00:05:09,000 --> 00:05:15,000
und Umwandeln desselben in den Computercode lesen kann.

85
00:05:15,000 --> 00:05:20,000
2 Beispiele für die Programmierung Scratch,

86
00:05:20,000 --> 00:05:22,000
das ist, was wir in Woche 0 taten.

87
00:05:22,000 --> 00:05:25,000
Obwohl wir eigentlich gar nicht geben Sie den Code, es ist ein Weg zur Umsetzung

88
00:05:25,000 --> 00:05:29,000
Dieser Algorithmus, welches das Drucken der Nummern 1 bis 10 ist,

89
00:05:29,000 --> 00:05:32,000
und hier haben wir das Gleiche tun in der C-Programmiersprache.

90
00:05:32,000 --> 00:05:41,000
Dies sind funktionell gleichwertig, nur in verschiedenen Sprachen oder Syntax geschrieben.

91
00:05:41,000 --> 00:05:44,000
Wir haben dann gelernt, über boolesche Ausdrücke,

92
00:05:44,000 --> 00:05:48,000
und ein boolean ist ein Wert, der entweder wahr oder falsch ist,

93
00:05:48,000 --> 00:05:51,000
und hier oft boolesche Ausdrücke

94
00:05:51,000 --> 00:05:55,000
reingehen von Bedingungen, so if (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
gut, wir bereits eingestellt x = 5, so dass diese Bedingung wird als wahr ausgewertet.

96
00:06:00,000 --> 00:06:03,000
Und wenn es wahr ist, was auch immer-Code unter der Bedingung,

97
00:06:03,000 --> 00:06:08,000
wird durch den Computer ausgewertet werden, so dass die String-los zu druckenden

98
00:06:08,000 --> 00:06:12,000
auf die Standardausgabe und der Begriff Zustand

99
00:06:12,000 --> 00:06:16,000
bezieht sich auf alles, was in den Klammern der if-Anweisung.

100
00:06:16,000 --> 00:06:20,000
Erinnere mich an all die Betreiber.

101
00:06:20,000 --> 00:06:26,000
Angemeldet es && und | |, wenn wir versuchen zu kombinieren 2 oder mehrere Bedingungen,

102
00:06:26,000 --> 00:06:30,000
== Nicht = zu prüfen, ob 2 Dinge gleich sind.

103
00:06:30,000 --> 00:06:36,000
Beachten Sie, dass = für die Zuordnung ist, während == ist ein boolean Operator.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ und dann die letzten 2 sind selbsterklärend.

105
00:06:41,000 --> 00:06:45,000
Eine allgemeine Übersicht über boolesche Logik hier.

106
00:06:45,000 --> 00:06:48,000
Und boolean Ausdrücke sind auch in Schleifen wichtig,

107
00:06:48,000 --> 00:06:50,000
die wir gehen jetzt vorbei.

108
00:06:50,000 --> 00:06:56,000
Wir erfuhren von 3 Arten von Schleifen bisher CS50, for, while, und zu tun, während.

109
00:06:56,000 --> 00:06:59,000
Und es ist wichtig zu wissen, dass, während für die meisten Zwecke

110
00:06:59,000 --> 00:07:02,000
können wir tatsächlich nutzen jede Art von Schleife in der Regel

111
00:07:02,000 --> 00:07:06,000
Es gibt bestimmte Arten von Zwecke oder gemeinsame Muster

112
00:07:06,000 --> 00:07:09,000
in der Programmierung, die speziell für eine dieser Schleifen rufen

113
00:07:09,000 --> 00:07:13,000
dass es die effizienteste oder elegant, es auf diese Weise zu codieren.

114
00:07:13,000 --> 00:07:18,000
Lasst uns über das, was jeder dieser Schleifen um am häufigsten verwendeten neigt.

115
00:07:18,000 --> 00:07:21,000
>> In einer for-Schleife, die wir in der Regel bereits wissen, wie oft wir zu durchlaufen wollen.

116
00:07:21,000 --> 00:07:24,000
Das ist, was wir in die Lage versetzt.

117
00:07:24,000 --> 00:07:28,000
Für i = 0, i <10, zum Beispiel.

118
00:07:28,000 --> 00:07:31,000
Wir wissen bereits, dass wir etwas 10-mal tun wollen.

119
00:07:31,000 --> 00:07:34,000
Nun, für eine while-Schleife, in der Regel wir nicht unbedingt

120
00:07:34,000 --> 00:07:36,000
wissen, wie viele Male wir die Schleife ausgeführt werden soll.

121
00:07:36,000 --> 00:07:39,000
Aber wir wissen, irgendeine Art von Bedingung, dass wir es wollen

122
00:07:39,000 --> 00:07:41,000
immer wahr oder immer falsch sein.

123
00:07:41,000 --> 00:07:44,000
Zum Beispiel wird während eingestellt.

124
00:07:44,000 --> 00:07:46,000
Lassen Sie uns sagen, das ist eine boolsche Variable.

125
00:07:46,000 --> 00:07:48,000
Während das ist wahr, wir wollen, dass die Codes zu bewerten,

126
00:07:48,000 --> 00:07:52,000
so ein bisschen mehr erweiterbar, ein wenig allgemeiner als eine for-Schleife,

127
00:07:52,000 --> 00:07:55,000
aber jede for-Schleife kann auch zu einer while-Schleife umgewandelt werden.

128
00:07:55,000 --> 00:08:00,000
Schließlich tun while-Schleifen, die der schwierigste sein kann, um sofort zu begreifen,

129
00:08:00,000 --> 00:08:04,000
werden oft verwendet, wenn wir den Code zuerst auswerten wollen

130
00:08:04,000 --> 00:08:06,000
vor dem ersten Mal, wenn wir den Zustand.

131
00:08:06,000 --> 00:08:09,000
Eine gemeinsame Nutzung Fall für eine do while-Schleife

132
00:08:09,000 --> 00:08:12,000
ist, wenn Sie Benutzereingaben erhalten wollen, und Sie wissen, dass Sie den Benutzer zu fragen

133
00:08:12,000 --> 00:08:15,000
für die Eingabe mindestens einmal, aber wenn sie nicht geben Ihnen gute Eingang rechts weg

134
00:08:15,000 --> 00:08:18,000
Sie behalten möchten, fragen sie, bis sie Ihnen die guten Input.

135
00:08:18,000 --> 00:08:21,000
Das ist die häufigste Verwendung einer Do While-Schleife,

136
00:08:21,000 --> 00:08:23,000
und lasst uns an der tatsächlichen Struktur dieser Schleifen aussehen.

137
00:08:23,000 --> 00:08:27,000
Sie in der Regel immer dazu neigen, diese Muster zu folgen.

138
00:08:27,000 --> 00:08:30,000
>> Auf der for-Schleife im Inneren haben Sie 3 Komponenten:

139
00:08:30,000 --> 00:08:35,000
Initialisierung der Regel so etwas wie int i = 0, wo i ist der Zähler,

140
00:08:35,000 --> 00:08:40,000
Zustand, wo wir sagen wollen laufen diese for-Schleife, solange dieser Zustand noch besitzt,

141
00:08:40,000 --> 00:08:44,000
wie i <10, und schließlich, Update, das, wie wir Inkrement

142
00:08:44,000 --> 00:08:47,000
die Zählvariable an jedem Punkt in der Schleife.

143
00:08:47,000 --> 00:08:50,000
Eine gemeinsame Sache zu sehen gibt ist nur i + +,

144
00:08:50,000 --> 00:08:52,000
was bedeutet, erhöhen i um 1 jedesmal.

145
00:08:52,000 --> 00:08:55,000
Sie können auch etwas tun, wie i + = 2,

146
00:08:55,000 --> 00:08:58,000
was bedeutet, fügen 2 bis i jedes Mal, wenn Sie durch die Schlaufe.

147
00:08:58,000 --> 00:09:03,000
Und dann das tun dies nur auf jede Code, der tatsächlich läuft als Teil der Schleife.

148
00:09:03,000 --> 00:09:09,000
Und für eine while-Schleife, diesmal haben wir eigentlich die Initialisierung außerhalb der Schleife,

149
00:09:09,000 --> 00:09:12,000
so zum Beispiel, sagen wir, wir versuchen, die gleiche Art von Schleife als ich gerade beschrieben habe zu tun.

150
00:09:12,000 --> 00:09:16,000
Wir würden sagen, int i = 0, bevor die Schleife beginnt.

151
00:09:16,000 --> 00:09:20,000
Dann könnten wir sagen, während i <10 dies zu tun,

152
00:09:20,000 --> 00:09:22,000
so dass die gleiche Codeblock wie zuvor,

153
00:09:22,000 --> 00:09:26,000
und diesmal ist die Aktualisierung Teil des Codes, zum Beispiel i + +,

154
00:09:26,000 --> 00:09:29,000
tatsächlich geht im Inneren der Schleife.

155
00:09:29,000 --> 00:09:33,000
Und schließlich, für eine zu tun, während es ähnlich wie die while-Schleife ist,

156
00:09:33,000 --> 00:09:36,000
aber wir müssen uns daran erinnern, dass der Code einmal bewerten

157
00:09:36,000 --> 00:09:40,000
bevor die Bedingung geprüft wird, so macht es viel mehr Sinn

158
00:09:40,000 --> 00:09:44,000
wenn man es in der Reihenfolge der von oben nach unten.

159
00:09:44,000 --> 00:09:49,000
In einer do while-Schleife der Code evaluiert, bevor Sie an der während der Zustand auch aussehen,

160
00:09:49,000 --> 00:09:55,000
während eine while-Schleife, prüft es zuerst.

161
00:09:55,000 --> 00:09:59,000
Statements und Variablen.

162
00:09:59,000 --> 00:10:04,000
Wenn wir eine neue Variable erstellen möchten wollen wir zuerst zu initialisieren.

163
00:10:04,000 --> 00:10:07,000
>> Zum Beispiel, initialisiert int bar die Variable bar,

164
00:10:07,000 --> 00:10:10,000
aber es gibt es nicht einen Wert, so was ist bar den Wert jetzt?

165
00:10:10,000 --> 00:10:12,000
Wir wissen es nicht.

166
00:10:12,000 --> 00:10:14,000
Es könnte einige Müll Wert, der zuvor im Speicher wurde dort gespeichert sein,

167
00:10:14,000 --> 00:10:16,000
und wir wollen nicht, dass die Variable verwenden

168
00:10:16,000 --> 00:10:19,000
bis wir tatsächlich geben sie einen Wert,

169
00:10:19,000 --> 00:10:21,000
so erklären wir es hier.

170
00:10:21,000 --> 00:10:24,000
Dann initialisieren wir es bis 42 darunter.

171
00:10:24,000 --> 00:10:28,000
Nun, natürlich wissen wir dies getan werden kann auf einer Linie, int bar = 42 werden.

172
00:10:28,000 --> 00:10:30,000
Aber nur klar zu sein, die mehrere Schritte, los werden,

173
00:10:30,000 --> 00:10:34,000
die Erklärung und die Initialisierung werden separat hier passiert.

174
00:10:34,000 --> 00:10:38,000
Es geschieht auf eine Stufe, und das nächste, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
diese Aussage unter, dass Schritten baz, so dass am Ende dieser Code-Block

176
00:10:44,000 --> 00:10:48,000
wenn wir den Wert der baz gedruckt waren es 44 sein

177
00:10:48,000 --> 00:10:52,000
weil wir deklarieren und initialisieren es auf 1> bar sein,

178
00:10:52,000 --> 00:10:58,000
und dann erhöhen wir es einmal mehr mit dem + +.

179
00:10:58,000 --> 00:11:02,000
Wir gingen dieser hübschen kurz, aber es ist gut, einen allgemeinen haben

180
00:11:02,000 --> 00:11:04,000
Verständnis dessen, was Themen und Ereignisse sind.

181
00:11:04,000 --> 00:11:06,000
Wir hauptsächlich tat dies in Scratch,

182
00:11:06,000 --> 00:11:09,000
so können Sie von Threads als mehrere Codesequenzen denken

183
00:11:09,000 --> 00:11:11,000
laufen gleichzeitig.

184
00:11:11,000 --> 00:11:14,000
In Wirklichkeit ist es wahrscheinlich nicht laufen zur gleichen Zeit,

185
00:11:14,000 --> 00:11:17,000
aber irgendwie abstrakt können wir es auf diese Weise zu denken.

186
00:11:17,000 --> 00:11:20,000
>> In Scratch, zum Beispiel, hatten wir die vielfältigen Sprites.

187
00:11:20,000 --> 00:11:22,000
Man könnte die Ausführung unterschiedlicher Code zur gleichen Zeit.

188
00:11:22,000 --> 00:11:26,000
Man könnte zu Fuß, während der andere etwas zu sagen

189
00:11:26,000 --> 00:11:29,000
in einem anderen Teil des Bildschirms.

190
00:11:29,000 --> 00:11:34,000
Ereignisse sind eine weitere Möglichkeit der Trennung die Logik

191
00:11:34,000 --> 00:11:37,000
zwischen den verschiedenen Elementen des Codes,

192
00:11:37,000 --> 00:11:40,000
und im Scratch konnten wir Ereignisse simulieren mit dem Broadcast,

193
00:11:40,000 --> 00:11:43,000
und das ist eigentlich, wenn ich erhalten, nicht, wenn ich höre,

194
00:11:43,000 --> 00:11:47,000
aber im Wesentlichen ist es ein Weg, um Informationen zu übertragen

195
00:11:47,000 --> 00:11:49,000
von einem Sprite zu einem anderen.

196
00:11:49,000 --> 00:11:52,000
Zum Beispiel möchten Sie vielleicht zu Spiel zu übertragen vorbei,

197
00:11:52,000 --> 00:11:56,000
und wenn ein anderes Sprite erhält game over,

198
00:11:56,000 --> 00:11:58,000
antwortet er in einer bestimmten Weise.

199
00:11:58,000 --> 00:12:03,000
Es ist ein wichtiges Modell für die Programmierung zu verstehen.

200
00:12:03,000 --> 00:12:07,000
Nur um über die grundlegenden Woche 0 gehen, was wir in so weit gegangen,

201
00:12:07,000 --> 00:12:10,000
Lassen Sie uns in diesem einfachen C-Programm zu suchen.

202
00:12:10,000 --> 00:12:14,000
Der Text kann ein wenig klein von hier sein, aber ich werde über sie gehen wirklich schnell.

203
00:12:14,000 --> 00:12:20,000
Wir inklusive 2 Header-Dateien an der Spitze, cs50.h und stdio.h.

204
00:12:20,000 --> 00:12:23,000
Wir nehmen dann eine Konstante zu definieren als Limit auf 100 sein.

205
00:12:23,000 --> 00:12:26,000
Wir nehmen dann die Umsetzung unserer Hauptfunktion.

206
00:12:26,000 --> 00:12:29,000
Da wir nicht verwenden Befehlszeilenargumente hier brauchen wir für nichtig gesetzt

207
00:12:29,000 --> 00:12:32,000
wie die Argumente für main.

208
00:12:32,000 --> 00:12:38,000
Wir sehen int vor main. Das ist der Rückgabetyp, daher 0 zurück an der Unterseite.

209
00:12:38,000 --> 00:12:41,000
Und wir verwenden CS50-Bibliothek function get int

210
00:12:41,000 --> 00:12:45,000
um den Benutzer zur Eingabe fragen, und wir speichern sie in dieser Variablen x,

211
00:12:45,000 --> 00:12:51,000
so erklären wir x oben, und initialisieren wir es mit x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Wir überprüfen dann, wenn der Benutzer gaben uns gute Eingang.

213
00:12:53,000 --> 00:12:59,000
Wenn es ≥ LIMIT ist wollen wir einen Fehlercode 1 zurück und drucken eine Fehlermeldung.

214
00:12:59,000 --> 00:13:02,000
Und schließlich, wenn der Benutzer hat uns gute Eingabe

215
00:13:02,000 --> 00:13:08,000
wir gehen, um die Zahl zu quadrieren und ausdrucken dieses Ergebnis.

216
00:13:08,000 --> 00:13:11,000
Nur um sicherzugehen, dass die alle Treffer Hause

217
00:13:11,000 --> 00:13:17,000
können Sie die Etiketten der verschiedenen Teile des Codes hier.

218
00:13:17,000 --> 00:13:19,000
Ich erwähnte Konstante, Header-Dateien.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Achten Sie darauf, sich daran zu erinnern, dass es eine lokale Variable.

220
00:13:21,000 --> 00:13:24,000
Das kontrastiert sie von einer globalen Variablen, die wir reden

221
00:13:24,000 --> 00:13:27,000
ein wenig später in der Review-Sitzung

222
00:13:27,000 --> 00:13:30,000
und wir sind dem Aufruf der Bibliotheksfunktion printf,

223
00:13:30,000 --> 00:13:34,000
so dass, wenn wir nicht die stdio.h Header-Datei enthalten

224
00:13:34,000 --> 00:13:37,000
wären wir nicht in der Lage sein printf nennen.

225
00:13:37,000 --> 00:13:42,000
Und ich glaube, der Pfeil, der ab hier wurde geschnitten wird, um die% d zeigt,

226
00:13:42,000 --> 00:13:45,000
die eine Format-String in printf.

227
00:13:45,000 --> 00:13:52,000
Er sagt, drucken Sie diese Variable als eine Zahl,% d.

228
00:13:52,000 --> 00:13:58,000
Und das ist es für Woche 0.

229
00:13:58,000 --> 00:14:06,000
Jetzt Lucas wird sich fortsetzen.

230
00:14:06,000 --> 00:14:08,000
Hey, guys. Mein Name ist Lucas.

231
00:14:08,000 --> 00:14:10,000
Ich bin im zweiten Jahr in der besten Haus auf dem Campus, Mather,

232
00:14:10,000 --> 00:14:14,000
und ich werde ein wenig darüber Woche 1 und 2,1 zu sprechen.

233
00:14:14,000 --> 00:14:16,000
[Woche 1 und 2,1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Als Lexi sagte, wenn wir übersetzen den Code von Grund auf C begonnen

235
00:14:19,000 --> 00:14:23,000
Eines der Dinge, die wir bemerkt ist, dass man nicht nur

236
00:14:23,000 --> 00:14:26,000
Ihren Code schreiben, und führen Sie es mit einer grünen Flagge mehr.

237
00:14:26,000 --> 00:14:30,000
Eigentlich haben Sie einige Schritte, um Ihre C-Programm zu machen

238
00:14:30,000 --> 00:14:33,000
zu einer ausführbaren Datei.

239
00:14:33,000 --> 00:14:36,000
Im Grunde, was Sie tun, wenn Sie ein Programm schreiben, sind ist, dass

240
00:14:36,000 --> 00:14:40,000
Sie übersetzen Ihre Idee in einer Sprache, die ein Compiler verstehen können,

241
00:14:40,000 --> 00:14:44,000
so, wenn Sie ein Programm schreiben, in C

242
00:14:44,000 --> 00:14:47,000
was du tust ist tatsächlich etwas zu schreiben, dass Ihr Compiler wird zu verstehen,

243
00:14:47,000 --> 00:14:50,000
und dann der Compiler wird diesen Code zu übersetzen

244
00:14:50,000 --> 00:14:53,000
in etwas, dass Ihr Computer zu verstehen.

245
00:14:53,000 --> 00:14:55,000
>> Und die Sache ist, ist Ihr Computer wirklich sehr dumm.

246
00:14:55,000 --> 00:14:57,000
Ihr Computer kann nur verstehen, 0 und 1,

247
00:14:57,000 --> 00:15:01,000
so tatsächlich in den ersten Computer Menschen in der Regel programmiert

248
00:15:01,000 --> 00:15:04,000
mit 0 und 1, aber nicht mehr, Gott sei Dank.

249
00:15:04,000 --> 00:15:07,000
Wir müssen nicht die Sequenzen für 0 und 1 merken

250
00:15:07,000 --> 00:15:10,000
für eine for-Schleife oder einer while-Schleife und so weiter.

251
00:15:10,000 --> 00:15:13,000
Deshalb haben wir einen Compiler haben.

252
00:15:13,000 --> 00:15:17,000
Was für ein Compiler tut, ist es im Grunde übersetzt den C-Code,

253
00:15:17,000 --> 00:15:21,000
in unserem Fall, einer Sprache, die Computer verstehen wird,

254
00:15:21,000 --> 00:15:25,000
das ist der Objekt-Code, und der Compiler, dass wir mit

255
00:15:25,000 --> 00:15:30,000
wird als Klang, so ist dies eigentlich das Symbol für Klang.

256
00:15:30,000 --> 00:15:33,000
Wenn Sie Ihr Programm haben, müssen Sie 2 Dinge tun.

257
00:15:33,000 --> 00:15:37,000
Zuerst müssen Sie Ihr Programm zu kompilieren, und dann wirst du um das Programm auszuführen.

258
00:15:37,000 --> 00:15:41,000
Um Ihr Programm kompilieren Sie haben eine Menge von Optionen, um dies zu tun.

259
00:15:41,000 --> 00:15:44,000
Die erste besteht darin, clang program.c tun

260
00:15:44,000 --> 00:15:47,000
in welchem ​​Programm ist der Name des Programms.

261
00:15:47,000 --> 00:15:51,000
In diesem Fall können Sie sehen, dass sie nur sagen: "Hey, kompilieren mein Programm."

262
00:15:51,000 --> 00:15:56,000
Du bist nicht sagen: "Ich will diesen Namen für mein Programm" oder so etwas.

263
00:15:56,000 --> 00:15:58,000
>> Die zweite Option ist einen Namen zu geben Ihrem Programm.

264
00:15:58,000 --> 00:16:02,000
Man kann sagen, Klang-o und dann den Namen, die Sie

265
00:16:02,000 --> 00:16:06,000
die ausführbare Datei, die als und dann program.c benannt werden.

266
00:16:06,000 --> 00:16:11,000
Und Sie können auch das Programm make, und sehen, wie in den ersten 2 Fällen

267
00:16:11,000 --> 00:16:15,000
Ich lege. C, und im dritten ein Ich habe nur Programme?

268
00:16:15,000 --> 00:16:18,000
Ja, Sie sollten eigentlich nicht gestellt. C, wenn Sie nutzen.

269
00:16:18,000 --> 00:16:22,000
Andernfalls wird der Compiler ist eigentlich los, um dich zu schreien.

270
00:16:22,000 --> 00:16:24,000
Und auch, ich weiß nicht, ob euch erinnern,

271
00:16:24,000 --> 00:16:29,000
aber viele Male haben wir auch-LCS50 oder-lm.

272
00:16:29,000 --> 00:16:31,000
Das nennt man Verkettung.

273
00:16:31,000 --> 00:16:35,000
Es ist einfach sagt dem Compiler, dass Sie diese Bibliotheken genau dort zu verwenden,

274
00:16:35,000 --> 00:16:39,000
Wenn Sie also cs50.h verwenden wollen Sie haben tatsächlich zu geben

275
00:16:39,000 --> 00:16:43,000
clang program.c-LCS50.

276
00:16:43,000 --> 00:16:45,000
Wenn Sie das nicht tun, wird der Compiler nicht zu wissen,

277
00:16:45,000 --> 00:16:50,000
dass Sie mit diesen Funktionen in cs50.h.

278
00:16:50,000 --> 00:16:52,000
Und wenn Sie Ihr Programm haben Sie 2 Möglichkeiten wollen.

279
00:16:52,000 --> 00:16:57,000
Wenn Sie clang program.c hast du nicht einen Namen geben zu Ihrem Programm.

280
00:16:57,000 --> 00:17:01,000
Sie haben, um es auszuführen mit. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out ist ein Standard-Name, den Klang Ihres Programms gibt, wenn Sie nicht geben ihm einen Namen.

282
00:17:06,000 --> 00:17:11,000
Sonst wirst du. / Programm zu tun, wenn Sie einen Namen gab, um Ihr Programm,

283
00:17:11,000 --> 00:17:15,000
und auch, wenn Sie Programm den Namen hat, dass ein Programm gehen, um

284
00:17:15,000 --> 00:17:23,000
geht schon programmiert den gleichen Namen wie der c-Datei werden.

285
00:17:23,000 --> 00:17:26,000
Dann sprachen wir über Datentypen und Daten.

286
00:17:26,000 --> 00:17:31,000
>> Grundsätzlich Datentypen sind die gleiche Sache wie kleine Boxen verwenden sie

287
00:17:31,000 --> 00:17:35,000
um Werte zu speichern, so Datentypen sind eigentlich genauso wie Pokémons.

288
00:17:35,000 --> 00:17:39,000
Sie kommen in allen Größen und Ausführungen.

289
00:17:39,000 --> 00:17:43,000
Ich weiß nicht, ob diese Analogie macht Sinn.

290
00:17:43,000 --> 00:17:46,000
Die Datengröße tatsächlich abhängig von der Maschinen-Architektur.

291
00:17:46,000 --> 00:17:49,000
Alle Daten Größen, ich werde hier zeigen

292
00:17:49,000 --> 00:17:53,000
sind eigentlich für ein 32-Bit-Maschine, die bei unserem Gerät ist,

293
00:17:53,000 --> 00:17:56,000
aber wenn Sie tatsächlich Kodierung Ihrer Mac oder einem Windows auch

294
00:17:56,000 --> 00:17:59,000
Wahrscheinlich wirst du um eine 64-Bit-Rechner haben,

295
00:17:59,000 --> 00:18:03,000
so daran erinnern, dass die Daten Größen, ich werde hier zeigen

296
00:18:03,000 --> 00:18:06,000
sind für die 32-Bit-Maschine.

297
00:18:06,000 --> 00:18:08,000
Die erste, die wir sahen, war ein int,

298
00:18:08,000 --> 00:18:10,000
das ist ziemlich einfach.

299
00:18:10,000 --> 00:18:13,000
Sie verwenden int um eine ganze Zahl zu speichern.

300
00:18:13,000 --> 00:18:16,000
Wir sahen auch den Charakter, die char.

301
00:18:16,000 --> 00:18:20,000
Wenn Sie einen Brief oder ein kleines Symbol verwenden möchten Sie wahrscheinlich eine char verwenden.

302
00:18:20,000 --> 00:18:26,000
Ein char hat 1 Byte, das 8 Bits, wie Lexi das Mittel.

303
00:18:26,000 --> 00:18:31,000
Grundsätzlich haben wir eine ASCII-Tabelle, die 256 hat

304
00:18:31,000 --> 00:18:34,000
möglichen Kombinationen von 0 und 1,

305
00:18:34,000 --> 00:18:37,000
und dann, wenn Sie eine char geben, es wird übersetzt

306
00:18:37,000 --> 00:18:44,000
das Zeichen, dass Eingänge Sie eine Nummer, die Sie in der ASCII-Tabelle haben, wie Lexi sagte.

307
00:18:44,000 --> 00:18:48,000
Wir haben auch die Schwimmer, die wir verwenden, um Dezimalzahlen zu speichern.

308
00:18:48,000 --> 00:18:53,000
Wenn Sie 3,14 wählen möchten, zum Beispiel, wirst du einen Schwimmer verwenden

309
00:18:53,000 --> 00:18:55,000
oder eine doppelte, die mehr Präzision hat.

310
00:18:55,000 --> 00:18:57,000
Ein Schwimmer hat 4 Bytes.

311
00:18:57,000 --> 00:19:01,000
Eine doppelte verfügt über 8 Bytes, so dass der einzige Unterschied ist die Präzision.

312
00:19:01,000 --> 00:19:04,000
Wir haben auch eine lange, die für ganze Zahlen verwendet wird,

313
00:19:04,000 --> 00:19:09,000
und Sie können eine 32-Bit-Maschine zu sehen ein int und eine lange haben die gleiche Größe,

314
00:19:09,000 --> 00:19:13,000
so dass es nicht wirklich Sinn, eine lange Zeit in einem 32-Bit-Maschine zu verwenden.

315
00:19:13,000 --> 00:19:17,000
>> Aber wenn Sie einen Mac verwenden und 64-Bit-Rechner sind, eigentlich eine lange hat die Größe 8,

316
00:19:17,000 --> 00:19:19,000
so dass es hängt wirklich von der Architektur.

317
00:19:19,000 --> 00:19:22,000
Für die 32-Bit-Maschine ist es nicht sinnvoll, eine lange wirklich nutzen.

318
00:19:22,000 --> 00:19:25,000
Und dann eine lange langen, auf der anderen Seite hat 8 Byte,

319
00:19:25,000 --> 00:19:30,000
so ist es sehr gut, wenn man eine längere Zahl haben wollen.

320
00:19:30,000 --> 00:19:34,000
Und schließlich haben wir string, was ist eigentlich ein char *,

321
00:19:34,000 --> 00:19:37,000
das ist ein Zeiger auf eine char.

322
00:19:37,000 --> 00:19:40,000
Es ist sehr einfach zu denken, dass die Größe der Zeichenfolge wird wohl sein

323
00:19:40,000 --> 00:19:42,000
die Anzahl der Zeichen, dass Sie es haben,

324
00:19:42,000 --> 00:19:45,000
sondern tatsächlich die char * selbst

325
00:19:45,000 --> 00:19:49,000
hat die Größe von einem Zeiger auf eine char, der 4 Bytes ist.

326
00:19:49,000 --> 00:19:52,000
Die Größe eines char * 4 Byte.

327
00:19:52,000 --> 00:19:56,000
Es spielt keine Rolle, ob Sie ein kleines Wort oder einen Brief oder irgendetwas haben.

328
00:19:56,000 --> 00:19:58,000
Es wird 4 Bytes.

329
00:19:58,000 --> 00:20:01,000
Wir haben auch gelernt, ein wenig über Gießen,

330
00:20:01,000 --> 00:20:04,000
so wie Sie sehen können, wenn Sie zum Beispiel ein Programm, das sagt,

331
00:20:04,000 --> 00:20:08,000
int x = 3 und dann printf ("% d", x / 2)

332
00:20:08,000 --> 00:20:12,000
tun Sie Jungs wissen, was es wird auf dem Bildschirm zu drucken?

333
00:20:12,000 --> 00:20:14,000
>> Jemand? >> [Studenten] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, yeah.

335
00:20:16,000 --> 00:20:20,000
Wenn Sie 3/2 zu tun, es wird 1,5 zu erhalten,

336
00:20:20,000 --> 00:20:24,000
aber da wir mit einem Integer sind es geht um die Dezimalstellen zu ignorieren,

337
00:20:24,000 --> 00:20:26,000
und du wirst bis 1 haben.

338
00:20:26,000 --> 00:20:29,000
Wenn Sie nicht möchten, dass das passiert, was Sie tun können, zum Beispiel,

339
00:20:29,000 --> 00:20:33,000
ist ein float deklarieren y = x.

340
00:20:33,000 --> 00:20:40,000
Dann x, die 3 früher wird jetzt 3,000 werden in y.

341
00:20:40,000 --> 00:20:44,000
Und dann können Sie ausdrucken y / 2.

342
00:20:44,000 --> 00:20:50,000
Eigentlich sollte ich eine 2. dort drüben.

343
00:20:50,000 --> 00:20:55,000
Es wird 3.00/2.00 tun,

344
00:20:55,000 --> 00:20:58,000
und du wirst bis 1,5 erhalten.

345
00:20:58,000 --> 00:21:06,000
Und wir haben dieses .2 f nur für 2 Dezimalstellen Einheiten in den Dezimalteil fragen.

346
00:21:06,000 --> 00:21:12,000
Wenn Sie .3 f haben, es wird tatsächlich 1,500.

347
00:21:12,000 --> 00:21:16,000
Wenn es 2 es geht um 1,50 sein.

348
00:21:16,000 --> 00:21:18,000
Wir haben auch diesen Fall hier.

349
00:21:18,000 --> 00:21:22,000
Wenn Sie das tun float x = 3,14 und dann printf x

350
00:21:22,000 --> 00:21:24,000
Sie gehen bis 3,14 erhalten.

351
00:21:24,000 --> 00:21:29,000
Und wenn Sie x = int x,

352
00:21:29,000 --> 00:21:34,000
was bedeutet, zu behandeln x als int und drucken Sie x jetzt

353
00:21:34,000 --> 00:21:36,000
Sie gehen bis 3,00 haben.

354
00:21:36,000 --> 00:21:38,000
Macht das Sinn?

355
00:21:38,000 --> 00:21:41,000
Weil du ersten Behandlung sind x als ganze Zahl, so dass Sie ignorieren die Dezimalstellen,

356
00:21:41,000 --> 00:21:45,000
und dann bist du Bedrucken x.

357
00:21:45,000 --> 00:21:47,000
Und schließlich können Sie dies auch,

358
00:21:47,000 --> 00:21:52,000
int x = 65, und dann erklären, eine char c = x,

359
00:21:52,000 --> 00:21:56,000
und dann, wenn Sie die c Drucken Sie tatsächlich gehen, um

360
00:21:56,000 --> 00:21:59,000
A, so dass im Grunde, was Sie hier tun

361
00:21:59,000 --> 00:22:02,000
wird die Übersetzung der Zahl in den Charakter,

362
00:22:02,000 --> 00:22:05,000
ebenso wie die ASCII-Tabelle tut.

363
00:22:05,000 --> 00:22:08,000
Wir sprachen auch über mathematische Operatoren.

364
00:22:08,000 --> 00:22:14,000
Die meisten von ihnen sind ziemlich eindeutig, so +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
und auch wir sprachen über mod, die der Rest einer Division von 2 Zahlen.

366
00:22:20,000 --> 00:22:23,000
Wenn Sie 10% 3, zum Beispiel,

367
00:22:23,000 --> 00:22:27,000
es bedeutet zu teilen 10 durch 3, und was ist der Rest?

368
00:22:27,000 --> 00:22:30,000
Es wird 1 sein, so ist es eigentlich sehr nützlich für viele der Programme.

369
00:22:30,000 --> 00:22:38,000
Für Vigenère und Caesar Ich bin mir ziemlich sicher, dass alle von euch mod verwendet.

370
00:22:38,000 --> 00:22:43,000
Über mathematische Operatoren, sehr vorsichtig sein, wenn die Kombination * und /.

371
00:22:43,000 --> 00:22:48,000
>> Zum Beispiel, wenn Sie (3/2) * 2, was wirst du bekommen?

372
00:22:48,000 --> 00:22:50,000
[Studenten] 2.

373
00:22:50,000 --> 00:22:54,000
Ja, 2, da 3/2 ist werde 1,5 betragen,

374
00:22:54,000 --> 00:22:57,000
aber da du tust Operationen zwischen 2 Zahlen

375
00:22:57,000 --> 00:22:59,000
Sie tatsächlich gerade dabei, ein betrachten,

376
00:22:59,000 --> 00:23:03,000
und dann 1 * 2 wird 2 sein, so sehr, sehr vorsichtig

377
00:23:03,000 --> 00:23:07,000
wenn Rechnen mit ganzen Zahlen, weil

378
00:23:07,000 --> 00:23:12,000
erhalten Sie möglicherweise, dass 2 = 3 in diesem Fall.

379
00:23:12,000 --> 00:23:14,000
Und auch sehr vorsichtig sein Vorrang.

380
00:23:14,000 --> 00:23:21,000
Normalerweise sollten Sie Klammern verwenden, um sicher sein, dass Sie wissen, was du tust.

381
00:23:21,000 --> 00:23:27,000
Einige nützliche Shortcuts, ist natürlich ein i + + oder i + = 1

382
00:23:27,000 --> 00:23:30,000
oder mit + =.

383
00:23:30,000 --> 00:23:34,000
Das ist das gleiche wie zu tun i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Sie können auch i - oder i - = 1,

385
00:23:39,000 --> 00:23:42,000
das ist das gleiche wie i = i -1,

386
00:23:42,000 --> 00:23:46,000
etwas, das man Leute verwenden eine Menge in for-Schleifen, mindestens.

387
00:23:46,000 --> 00:23:52,000
Auch für *, wenn Sie * = und wenn Sie das tun, zum Beispiel,

388
00:23:52,000 --> 00:23:57,000
i * = 2 ist das dasselbe wie zu sagen i = i * 2,

389
00:23:57,000 --> 00:23:59,000
und dasselbe für die Teilung.

390
00:23:59,000 --> 00:24:08,000
Wenn Sie i / = 2 zu tun, es ist das gleiche wie i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Nun zu den Funktionen.

392
00:24:10,000 --> 00:24:13,000
You guys gelernt, dass Funktionen eine sehr gute Strategie, um Code zu retten

393
00:24:13,000 --> 00:24:16,000
während der Programmierung sind, wenn Sie so wollen, um die gleiche Aufgabe zu erfüllen

394
00:24:16,000 --> 00:24:20,000
im Code immer und immer wieder, wahrscheinlich Sie eine Funktion verwenden

395
00:24:20,000 --> 00:24:25,000
nur damit du nicht zu kopieren und fügen Sie den Code immer und immer wieder.

396
00:24:25,000 --> 00:24:28,000
Eigentlich ist Haupt eine Funktion, und wenn ich Ihnen zeigen, das Format einer Funktion

397
00:24:28,000 --> 00:24:32,000
Sie gehen, um zu sehen, dass dies ziemlich offensichtlich ist.

398
00:24:32,000 --> 00:24:35,000
Wir verwenden auch Funktionen aus einigen Bibliotheken,

399
00:24:35,000 --> 00:24:39,000
beispielsweise printf, Getin, die aus der Bibliothek CS50 ist,

400
00:24:39,000 --> 00:24:43,000
und andere Funktionen wie toupper.

401
00:24:43,000 --> 00:24:46,000
Alle diese Funktionen sind eigentlich in anderen Bibliotheken implementiert,

402
00:24:46,000 --> 00:24:49,000
und wenn Sie setzen diese Leine Dateien im Anfang des Programms

403
00:24:49,000 --> 00:24:53,000
Sie sagen, können Sie mir den Code für diese Funktionen finden

404
00:24:53,000 --> 00:24:57,000
so dass ich nicht haben, um sie von mir zu implementieren?

405
00:24:57,000 --> 00:25:00,000
Und Sie können auch Ihre eigenen Funktionen, so dass, wenn Sie mit dem Programmieren beginnen

406
00:25:00,000 --> 00:25:04,000
Sie erkennen, dass Bibliotheken nicht alle Funktionen, die Sie benötigen.

407
00:25:04,000 --> 00:25:10,000
Für den letzten pset, zum Beispiel, schrieben wir zeichnen, Gerangel, und Lookup,

408
00:25:10,000 --> 00:25:13,000
und es ist sehr, sehr wichtig, um in der Lage sein, Funktionen zu schreiben

409
00:25:13,000 --> 00:25:17,000
weil sie nützlich sind, und wir nutzen sie die ganze Zeit in der Programmierung,

410
00:25:17,000 --> 00:25:19,000
und es spart eine Menge Code.

411
00:25:19,000 --> 00:25:21,000
Das Format einer Funktion ist dies ein.

412
00:25:21,000 --> 00:25:24,000
Wir haben Rückgabetyp in der Anfang. Was ist der Rückgabetyp?

413
00:25:24,000 --> 00:25:27,000
Es ist nur, wenn Ihre Funktion wird zurückkehren.

414
00:25:27,000 --> 00:25:29,000
Wenn Sie eine Funktion haben, zum Beispiel, Fakultät,

415
00:25:29,000 --> 00:25:31,000
das wird eine Fakultät einer Ganzzahl berechnen,

416
00:25:31,000 --> 00:25:34,000
wahrscheinlich, es wird eine ganze Zahl auch wieder.

417
00:25:34,000 --> 00:25:37,000
Dann wird der Rückgabetyp sein wird int.

418
00:25:37,000 --> 00:25:41,000
Printf hat tatsächlich einen Rückgabetyp void

419
00:25:41,000 --> 00:25:43,000
weil du nicht wieder nichts.

420
00:25:43,000 --> 00:25:45,000
Du bist nur gedruckt, was auf dem Bildschirm

421
00:25:45,000 --> 00:25:48,000
und Beenden der Funktion danach.

422
00:25:48,000 --> 00:25:51,000
Dann haben Sie den Namen der Funktion, die Sie wählen können.

423
00:25:51,000 --> 00:25:55,000
Sie sollten ein wenig vernünftig, wie nicht wählen Sie einen Namen wie xyz

424
00:25:55,000 --> 00:25:58,000
oder wie X2f.

425
00:25:58,000 --> 00:26:02,000
Versuchen Sie, einen Namen, die Sinn macht.

426
00:26:02,000 --> 00:26:04,000
>> Zum Beispiel, wenn es faktorielle ist, sagen faktorielle.

427
00:26:04,000 --> 00:26:08,000
Wenn es eine Funktion, die gehen, um etwas zu zeichnen ist es, nennen Sie es ziehen.

428
00:26:08,000 --> 00:26:11,000
Und dann haben wir die Parameter, die man auch als Argumente

429
00:26:11,000 --> 00:26:14,000
welche sind wie die Ressourcen, die Ihre Funktion muss

430
00:26:14,000 --> 00:26:17,000
aus dem Code zur Erfüllung ihrer Aufgabe.

431
00:26:17,000 --> 00:26:20,000
Wenn Sie die Fakultät einer Zahl zu berechnen

432
00:26:20,000 --> 00:26:23,000
Wahrscheinlich müssen Sie eine Nummer haben, um einen faktoriellen berechnen.

433
00:26:23,000 --> 00:26:27,000
Eines der Argumente, dass Sie gehen zu müssen sind die Zahl selber.

434
00:26:27,000 --> 00:26:31,000
Und dann wird es etwas zu tun und den Wert am Ende

435
00:26:31,000 --> 00:26:35,000
es sei denn, es ist eine void-Funktion.

436
00:26:35,000 --> 00:26:37,000
Mal sehen, ein Beispiel.

437
00:26:37,000 --> 00:26:40,000
Wenn ich will, um eine Funktion, die alle Zahlen addiert in einem Array von ganzen Zahlen zu schreiben,

438
00:26:40,000 --> 00:26:43,000
Zunächst wird die Rückgabetyp sein wird int

439
00:26:43,000 --> 00:26:46,000
denn ich habe ein Array von Ganzzahlen.

440
00:26:46,000 --> 00:26:51,000
Und dann werde ich den Namen der Funktion, wie sumArray haben,

441
00:26:51,000 --> 00:26:54,000
und dann es geht um das Array selbst zu nehmen, int nums,

442
00:26:54,000 --> 00:26:58,000
und dann die Länge des Arrays, damit ich weiß, wie viele Zahlen, die ich auf den Punkt haben.

443
00:26:58,000 --> 00:27:02,000
Dann muss ich eine Variable namens Summe, zum Beispiel auf 0 zu initialisieren,

444
00:27:02,000 --> 00:27:08,000
und jedes Mal, wenn ich ein Element im Array sollte ich es Summe addieren, also tat ich eine for-Schleife.

445
00:27:08,000 --> 00:27:15,000
Genau wie Lexi, tun Sie int i = 0, i <Länge und i + +.

446
00:27:15,000 --> 00:27:20,000
Und für jedes Element im Array Ich habe sum + = nums [i],

447
00:27:20,000 --> 00:27:24,000
und dann habe ich die Summe zurück, so ist es sehr einfach, und es spart eine Menge Code

448
00:27:24,000 --> 00:27:28,000
wenn Sie mit dieser Funktion eine Menge Zeit.

449
00:27:28,000 --> 00:27:32,000
Dann nahmen wir einen Blick auf Bedingungen.

450
00:27:32,000 --> 00:27:38,000
Wir haben if, else und else if.

451
00:27:38,000 --> 00:27:42,000
Mal sehen, was ist der Unterschied zwischen diesen.

452
00:27:42,000 --> 00:27:45,000
Werfen Sie einen Blick auf diese zwei Codes. Was ist der Unterschied zwischen ihnen?

453
00:27:45,000 --> 00:27:49,000
Die erste hat-im Grunde die Codes möchten, dass Sie sagen,

454
00:27:49,000 --> 00:27:51,000
wenn eine Zahl +, -, oder 0 ist.

455
00:27:51,000 --> 00:27:55,000
Der erste sagt, wenn es> 0 ist dann positiv ist.

456
00:27:55,000 --> 00:28:00,000
Wenn es = auf 0 ist dann ist es 0, und wenn es <0 ist dann ist es negativ.

457
00:28:00,000 --> 00:28:04,000
>> Und das andere tut, wenn sonst wenn, sonst.

458
00:28:04,000 --> 00:28:07,000
Der Unterschied zwischen beiden ist, dass dies tatsächlich ein werde

459
00:28:07,000 --> 00:28:13,000
überprüfen, ob> 0, <0 oder = 0 dreimal

460
00:28:13,000 --> 00:28:17,000
Wenn Sie also die Nummer 2 haben, zum Beispiel, es geht um hierher zu kommen und zu sagen

461
00:28:17,000 --> 00:28:21,000
if (x> 0), und es sich auf sage ja, so drucke ich positiv.

462
00:28:21,000 --> 00:28:25,000
Aber auch wenn ich weiß, dass es> 0 ist und es wird nicht auf 0 oder <0 sein

463
00:28:25,000 --> 00:28:29,000
Ich bin immer noch zu tun ist es 0, ist es <0,

464
00:28:29,000 --> 00:28:33,000
so bin ich eigentlich los Innenseite ifs, dass ich nicht haben

465
00:28:33,000 --> 00:28:38,000
weil ich schon weiß, dass es nicht zu einer dieser Bedingungen erfüllen.

466
00:28:38,000 --> 00:28:41,000
Ich kann die if, else if, else-Anweisung.

467
00:28:41,000 --> 00:28:45,000
Es ist im Grunde sagt, wenn x = 0 ich die positive drucken.

468
00:28:45,000 --> 00:28:48,000
Wenn es nicht ist, werde ich auch diesen Test.

469
00:28:48,000 --> 00:28:51,000
Wenn es 2 ist nicht werde ich das tun.

470
00:28:51,000 --> 00:28:54,000
Grundsätzlich, wenn ich x = 2 hätten, würden Sie sagen,

471
00:28:54,000 --> 00:28:57,000
if (x> 0), ja, so drucken Sie diese.

472
00:28:57,000 --> 00:29:00,000
Jetzt, wo ich weiß, dass es> 0 ist und dass sie sich vergewissert das erste, wenn

473
00:29:00,000 --> 00:29:02,000
Ich bin nicht mal diesen Code ausführen.

474
00:29:02,000 --> 00:29:09,000
Der Code läuft schneller, eigentlich 3 mal schneller, wenn Sie diese verwenden.

475
00:29:09,000 --> 00:29:11,000
Wir haben auch gelernt, über AND und OR.

476
00:29:11,000 --> 00:29:15,000
Ich werde mich nicht durch diese gehen, weil Lexi sprachen bereits darüber.

477
00:29:15,000 --> 00:29:17,000
Es ist nur die && und | | Operator.

478
00:29:17,000 --> 00:29:21,000
>> Das einzige, was ich sage ist, vorsichtig sein, wenn Sie 3 Bedingungen haben.

479
00:29:21,000 --> 00:29:24,000
Verwenden Sie Klammern, weil es sehr verwirrend, wenn Sie eine Erkrankung haben

480
00:29:24,000 --> 00:29:27,000
und eine andere oder ein anderes.

481
00:29:27,000 --> 00:29:30,000
Verwenden Sie Klammern, um nur sicher sein, dass Ihre Bedingungen Sinn machen

482
00:29:30,000 --> 00:29:34,000
weil in diesem Fall, zum Beispiel, können Sie sich vorstellen, dass

483
00:29:34,000 --> 00:29:38,000
es könnte die erste Bedingung und die eine oder andere sein

484
00:29:38,000 --> 00:29:41,000
oder die 2 Bedingungen in einem kombiniert und

485
00:29:41,000 --> 00:29:45,000
oder die dritte ein, so sollte man vorsichtig sein.

486
00:29:45,000 --> 00:29:48,000
Und schließlich sprachen wir über Schalter.

487
00:29:48,000 --> 00:29:53,000
Ein Schalter ist sehr nützlich, wenn Sie eine Variable haben.

488
00:29:53,000 --> 00:29:55,000
Lassen Sie uns sagen, dass Sie eine Variable wie n

489
00:29:55,000 --> 00:29:59,000
das kann 0, 1 oder 2 sein, und für jeden dieser Fälle

490
00:29:59,000 --> 00:30:01,000
Sie gehen, um eine Aufgabe zu erledigen.

491
00:30:01,000 --> 00:30:04,000
Man kann sagen, schalten Sie die Variable, und es zeigt, dass

492
00:30:04,000 --> 00:30:08,000
der Wert dann ist wie value1 Ich werde dies tun,

493
00:30:08,000 --> 00:30:12,000
und dann habe ich zu brechen, was bedeutet, dass ich nicht an einem der anderen Fälle betrachten

494
00:30:12,000 --> 00:30:15,000
weil wir bereits diesen Fall zufrieden

495
00:30:15,000 --> 00:30:20,000
und dann value2 und so weiter, und ich kann auch über eine Standard-Schalter.

496
00:30:20,000 --> 00:30:24,000
Das heißt, wenn sie nicht zu befriedigen keinem der Fälle, die ich hatte

497
00:30:24,000 --> 00:30:29,000
dass ich gehe, um etwas anderes zu tun, aber das ist optional.

498
00:30:29,000 --> 00:30:36,000
Das ist alles für mich. Lassen Sie uns nun Tommy.

499
00:30:36,000 --> 00:30:41,000
Alles klar, das wird Woche 3-ish sein.

500
00:30:41,000 --> 00:30:45,000
Dies sind einige der Themen, die wir werden abdeckt, crypto, Umfang, Arrays, et cetera werden.

501
00:30:45,000 --> 00:30:49,000
Just a quick Wort Krypto. Wir gehen nicht auf dieses Haus zu hämmern.

502
00:30:49,000 --> 00:30:52,000
>> Wir taten dies in pset 2, aber für das Quiz stellen Sie sicher, Sie kennen den Unterschied

503
00:30:52,000 --> 00:30:54,000
zwischen der Caesar-Chiffre und der Vigenère Chiffre,

504
00:30:54,000 --> 00:30:57,000
Wie diese beiden Chiffren Arbeit und wie es ist, zu verschlüsseln

505
00:30:57,000 --> 00:30:59,000
und Entschlüsseln von Text über die 2 Ziffern.

506
00:30:59,000 --> 00:31:03,000
Denken Sie daran, die Caesar-Chiffre einfach dreht jedes Zeichen durch den gleichen Betrag,

507
00:31:03,000 --> 00:31:06,000
dafür, dass Sie mod durch die Anzahl der Buchstaben im Alphabet.

508
00:31:06,000 --> 00:31:09,000
Und die Vigenère Chiffre, auf der anderen Seite dreht sich jedes Zeichen

509
00:31:09,000 --> 00:31:12,000
um einen anderen Betrag, so anstatt zu sagen

510
00:31:12,000 --> 00:31:15,000
Jeder Charakter gedreht 3 Vigenère dreht jedes Zeichen

511
00:31:15,000 --> 00:31:17,000
um einen unterschiedlichen Betrag abhängig von irgendeiner Schlüsselwort

512
00:31:17,000 --> 00:31:20,000
wo jeder Brief in dem Schlüsselwort repräsentiert eine unterschiedliche Menge

513
00:31:20,000 --> 00:31:26,000
die klare Text zu drehen.

514
00:31:26,000 --> 00:31:28,000
Lassen Sie uns zuerst über den Geltungsbereich von Variablen.

515
00:31:28,000 --> 00:31:30,000
Es gibt 2 verschiedene Arten von Variablen.

516
00:31:30,000 --> 00:31:33,000
Wir haben lokale Variablen, und diese gehen zu definieren

517
00:31:33,000 --> 00:31:36,000
außerhalb der Haupt-oder außerhalb einer Funktion oder Block,

518
00:31:36,000 --> 00:31:39,000
und diese werden überall zugänglich in Ihrem Programm.

519
00:31:39,000 --> 00:31:41,000
Wenn Sie eine Funktion haben und in dieser Funktion ist eine while-Schleife

520
00:31:41,000 --> 00:31:44,000
die große globale Variable ist überall zugänglich.

521
00:31:44,000 --> 00:31:48,000
Eine lokale Variable, auf der anderen Seite, ist Gültigkeitsbereich der Stelle, wo sie definiert ist.

522
00:31:48,000 --> 00:31:53,000
>> Wenn Sie eine Funktion hier zu haben, zum Beispiel, haben wir diese Funktion g,

523
00:31:53,000 --> 00:31:56,000
und Innenseite g es eine variable hier als y,

524
00:31:56,000 --> 00:31:58,000
und das bedeutet, dass diese eine lokale Variable ist.

525
00:31:58,000 --> 00:32:00,000
Auch wenn diese Variable heißt y

526
00:32:00,000 --> 00:32:03,000
Diese Variable wird als Y diese 2 Funktionen

527
00:32:03,000 --> 00:32:06,000
keine Ahnung, was jeweils anderen lokalen Variablen sind.

528
00:32:06,000 --> 00:32:10,000
Auf der anderen Seite, bis wir hier sagen, int x = 5,

529
00:32:10,000 --> 00:32:12,000
und dies ist nicht Gegenstand irgendeiner Funktion.

530
00:32:12,000 --> 00:32:16,000
Es ist außerhalb des Geltungsbereichs der wichtigsten, so ist dies eine globale Variable.

531
00:32:16,000 --> 00:32:20,000
Das bedeutet, dass innerhalb dieser 2 Funktionen, wenn ich x sagen - oder x + +

532
00:32:20,000 --> 00:32:26,000
Ich bin auf das gleiche x, wobei diese y und das y verschiedene Variablen.

533
00:32:26,000 --> 00:32:30,000
Das ist der Unterschied zwischen einer globalen Variable und eine lokale Variable.

534
00:32:30,000 --> 00:32:33,000
Soweit Design betrifft, manchmal ist es wahrscheinlich eine bessere Idee

535
00:32:33,000 --> 00:32:37,000
zu halten lokale Variablen, wenn Sie können möglicherweise

536
00:32:37,000 --> 00:32:39,000
da mit ein paar globale Variablen kann man wirklich verwirrend.

537
00:32:39,000 --> 00:32:42,000
Wenn Sie eine Reihe von Funktionen haben alle Änderung die gleiche Sache

538
00:32:42,000 --> 00:32:45,000
Sie vielleicht vergessen, was, wenn diese Funktion versehentlich verändert diese globale,

539
00:32:45,000 --> 00:32:47,000
und diese andere Funktion nicht darüber wissen,

540
00:32:47,000 --> 00:32:50,000
und es ist ziemlich verwirrend, da Sie mehr Code zu erhalten.

541
00:32:50,000 --> 00:32:53,000
Halten Sie lokale Variablen, wenn Sie können möglicherweise

542
00:32:53,000 --> 00:32:56,000
ist nur gutes Design.

543
00:32:56,000 --> 00:33:00,000
Arrays, denken Sie daran, einfach Listen von Elementen des gleichen Typs.

544
00:33:00,000 --> 00:33:04,000
Innerhalb von CI kann nicht über eine Liste wie 1, 2,0, hallo.

545
00:33:04,000 --> 00:33:06,000
Wir können einfach nicht tun.

546
00:33:06,000 --> 00:33:11,000
>> Wenn wir ein Array deklarieren in C alle Elemente müssen vom gleichen Typ sein.

547
00:33:11,000 --> 00:33:14,000
Hier habe ich eine Reihe von 3 Zahlen.

548
00:33:14,000 --> 00:33:18,000
Hier habe ich die Länge des Arrays, aber wenn ich mich nur Deklaration in dieser Syntax

549
00:33:18,000 --> 00:33:21,000
wo ich angeben, welche alle Elemente sind ich technisch nicht brauchen diese 3.

550
00:33:21,000 --> 00:33:25,000
Der Compiler ist intelligent genug, um herauszufinden, wie groß das Array sein sollte.

551
00:33:25,000 --> 00:33:28,000
Nun, wenn ich zu bekommen oder setzen Sie den Wert eines Arrays auswählen möchten

552
00:33:28,000 --> 00:33:30,000
Dies ist die Syntax zu tun.

553
00:33:30,000 --> 00:33:33,000
Dies wird tatsächlich modifizieren das zweite Element des Arrays weil erinnern,

554
00:33:33,000 --> 00:33:36,000
Nummerierung beginnt bei 0, nicht bei 1.

555
00:33:36,000 --> 00:33:42,000
Wenn ich diesen Wert lesen wollen, kann ich sagen, so etwas wie int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Oder wenn ich diesen Wert gesetzt werden soll, wie ich hier mache,

557
00:33:44,000 --> 00:33:47,000
Ich kann sagen, array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Diese Zeit Zugriff auf Elemente über ihren Index

559
00:33:50,000 --> 00:33:52,000
oder deren Position bzw. wo sie sich in dem Array,

560
00:33:52,000 --> 00:33:57,000
und dass Auflistung beginnt bei 0.

561
00:33:57,000 --> 00:34:00,000
Wir können auch Arrays von Arrays,

562
00:34:00,000 --> 00:34:03,000
und dies ist ein mehrdimensionales Array aufgerufen.

563
00:34:03,000 --> 00:34:05,000
Wenn wir einen mehrdimensionalen Arrays

564
00:34:05,000 --> 00:34:07,000
Das heißt, wir können so etwas wie Zeilen und Spalten,

565
00:34:07,000 --> 00:34:11,000
und dies ist nur eine Möglichkeit der Visualisierung dieser oder darüber nachzudenken.

566
00:34:11,000 --> 00:34:14,000
Wenn ich ein mehrdimensionales Array das heißt, ich werde anfangen brauchen

567
00:34:14,000 --> 00:34:17,000
mehr als 1 Index, weil, wenn ich ein Gitter

568
00:34:17,000 --> 00:34:19,000
nur sagen, welche Zeile Sie sich befinden nicht geben uns eine Nummer.

569
00:34:19,000 --> 00:34:22,000
Das ist wirklich nur gehen, um uns eine Liste von Zahlen.

570
00:34:22,000 --> 00:34:25,000
Lassen Sie uns sagen, ich habe dieses Array hier.

571
00:34:25,000 --> 00:34:30,000
Ich habe ein Array namens Grid, und ich sage es 2 Zeilen und 3 Spalten,

572
00:34:30,000 --> 00:34:32,000
und so ist dies ein Weg, zu visualisieren.

573
00:34:32,000 --> 00:34:37,000
Wenn ich sage, ich will das Element an [1] zu [2]

574
00:34:37,000 --> 00:34:41,000
das bedeutet, dass, weil diese Zeilen sind und dann Spalten

575
00:34:41,000 --> 00:34:44,000
Ich werde direkt zum 1 rudern, da ich 1 sagte.

576
00:34:44,000 --> 00:34:49,000
>> Dann werde ich hierher kommen bis Spalte 2, und ich werde, um den Wert 6.

577
00:34:49,000 --> 00:34:51,000
Sinn?

578
00:34:51,000 --> 00:34:55,000
Multi-dimensionale Arrays, denken Sie daran, sind technisch nur ein Array von Arrays.

579
00:34:55,000 --> 00:34:57,000
Wir können Arrays von Arrays von Arrays.

580
00:34:57,000 --> 00:35:00,000
Wir können weitermachen, aber wirklich ein Weg, um darüber nachzudenken,

581
00:35:00,000 --> 00:35:03,000
wie diese wird angelegt und was los ist, sie zu visualisieren

582
00:35:03,000 --> 00:35:09,000
in einem Raster wie diese.

583
00:35:09,000 --> 00:35:12,000
Wenn wir Arrays an Funktionen übergeben, werden sie sich zu verhalten

584
00:35:12,000 --> 00:35:16,000
ein wenig anders, als wenn wir an reguläre Variablen, Funktionen

585
00:35:16,000 --> 00:35:18,000
wie die Übergabe eines int oder float.

586
00:35:18,000 --> 00:35:21,000
Wenn wir an in ein int oder char oder eines dieser anderen Datentypen

587
00:35:21,000 --> 00:35:24,000
wir nahmen einen Blick auf, wenn die Funktion ändert

588
00:35:24,000 --> 00:35:28,000
der Wert dieser Variablen, die Veränderung ist nicht zu propagieren up

589
00:35:28,000 --> 00:35:32,000
an die aufrufende Funktion.

590
00:35:32,000 --> 00:35:35,000
Mit einer Anordnung, auf der anderen Seite, wird das geschehen.

591
00:35:35,000 --> 00:35:39,000
Wenn ich gehe in einem Array in einer Funktion und die Funktion ändert einige der Elemente,

592
00:35:39,000 --> 00:35:43,000
wenn ich komme zurück auf die Funktion, die sie aufgerufen

593
00:35:43,000 --> 00:35:47,000
mein Array wird nun anders zu sein, und das Vokabular für die

594
00:35:47,000 --> 00:35:50,000
ist Arrays per Referenz übergeben, wie wir später sehen werden.

595
00:35:50,000 --> 00:35:53,000
Dies wird, wie Zeiger Arbeit, wo diese grundlegenden Datentypen verwandt,

596
00:35:53,000 --> 00:35:55,000
Auf der anderen Seite werden als Wert übergeben.

597
00:35:55,000 --> 00:35:59,000
>> Wir können dass Sie eine Kopie einer Variablen und dann Leiten in der Kopie zu denken.

598
00:35:59,000 --> 00:36:01,000
Es spielt keine Rolle, was wir mit dieser Variablen zu tun.

599
00:36:01,000 --> 00:36:06,000
Die aufrufende Funktion nicht bewusst sein, dass es geändert wurde.

600
00:36:06,000 --> 00:36:10,000
Arrays sind nur ein bisschen anders in dieser Hinsicht.

601
00:36:10,000 --> 00:36:13,000
Zum Beispiel, wie wir gerade gesehen haben, Hauptsache einfach eine Funktion

602
00:36:13,000 --> 00:36:15,000
das kann in 2 Argumente.

603
00:36:15,000 --> 00:36:20,000
Das erste Argument der Funktion main ist argc, oder die Anzahl der Argumente,

604
00:36:20,000 --> 00:36:23,000
und das zweite Argument wird als argv,

605
00:36:23,000 --> 00:36:27,000
und das sind die tatsächlichen Werte dieser Argumente.

606
00:36:27,000 --> 00:36:30,000
Lassen Sie uns sagen, ich habe ein Programm namens this.c,

607
00:36:30,000 --> 00:36:34,000
und ich sage zu machen, und ich werde dies auf der Kommandozeile ausgeführt werden.

608
00:36:34,000 --> 00:36:38,000
Nun, in einigen Argumenten zu meinem Programm übergeben nannte dies,

609
00:36:38,000 --> 00:36:42,000
Ich könnte so etwas sagen wie. / Das ist cs 50.

610
00:36:42,000 --> 00:36:45,000
Dies ist, was wir David zu tun vorstellen jeden Tag am Terminal.

611
00:36:45,000 --> 00:36:48,000
Aber jetzt ist die wichtigste Funktion innerhalb des Programms

612
00:36:48,000 --> 00:36:52,000
hat diese Werte, so argc ist 4.

613
00:36:52,000 --> 00:36:56,000
Es könnte ein wenig verwirrend, weil wir wirklich nur auf der Durchreise sind in ist cs 50.

614
00:36:56,000 --> 00:36:58,000
Das ist nur 3.

615
00:36:58,000 --> 00:37:02,000
Aber denken Sie daran, dass das erste Element von argv oder das erste Argument

616
00:37:02,000 --> 00:37:05,000
ist der Name der Funktion selbst.

617
00:37:05,000 --> 00:37:07,190
Das heißt also, dass wir 4 Dinge hier haben,

618
00:37:07,190 --> 00:37:10,530
und das erste Element wird. / dies sein.

619
00:37:10,530 --> 00:37:12,970
Und dies wird als Zeichenfolge dargestellt werden.

620
00:37:12,970 --> 00:37:18,590
Dann werden die restlichen Elemente sind, was wir in nach dem Namen des Programms eingegeben.

621
00:37:18,590 --> 00:37:22,720
Also nur so nebenbei, wie wir sahen wohl in pset 2,

622
00:37:22,720 --> 00:37:28,780
erinnern, dass die Zeichenfolge 50 die Zahl 50 ist ≠.

623
00:37:28,780 --> 00:37:32,520
So können wir nicht sagen etwas wie: 'int x = argv 3.

624
00:37:32,520 --> 00:37:36,470
>> Das ist einfach nicht sinnvoll, denn dies ist ein String, und das ist eine ganze Zahl.

625
00:37:36,470 --> 00:37:38,510
Also, wenn Sie zwischen den 2 konvertieren möchten, denken Sie daran, wir sind zu gehen

626
00:37:38,510 --> 00:37:40,810
haben diese magische Funktion namens atoi.

627
00:37:40,810 --> 00:37:46,270
Das nimmt einen String und gibt die Zahl innerhalb dieser Zeichenkette repräsentiert.

628
00:37:46,270 --> 00:37:48,360
Also das ist eine einfache Fehler, auf das Quiz zu machen,

629
00:37:48,360 --> 00:37:51,590
nur denken, dass dies automatisch der richtige Typ sein.

630
00:37:51,590 --> 00:37:53,860
Aber wissen nur, dass diese immer Strings

631
00:37:53,860 --> 00:38:00,920
auch wenn die Zeichenfolge enthält nur eine ganze Zahl oder ein Zeichen oder einen Schwimmer.

632
00:38:00,920 --> 00:38:03,380
So, jetzt lassen Sie uns über Laufzeit reden.

633
00:38:03,380 --> 00:38:06,700
Wenn wir alle diese Algorithmen, die all diese verrückten Dinge zu tun haben,

634
00:38:06,700 --> 00:38:11,580
wird es wirklich sinnvoll, die Frage zu stellen: "Wie lange sie dauern?"

635
00:38:11,580 --> 00:38:15,500
Wir vertreten, dass mit einem so genannten asymptotischen Notation.

636
00:38:15,500 --> 00:38:18,430
So bedeutet dies, dass - nun, sagen wir, wir geben unser Algorithmus

637
00:38:18,430 --> 00:38:20,840
einige wirklich, wirklich, wirklich großen Eingang.

638
00:38:20,840 --> 00:38:23,840
Wir wollen die Frage stellen: "Wie lange wird es dauern?

639
00:38:23,840 --> 00:38:26,370
Wie viele Schritte wird es dauern, unser Algorithmus zu laufen

640
00:38:26,370 --> 00:38:29,980
in Abhängigkeit von der Größe des Eingangssignals? "

641
00:38:29,980 --> 00:38:33,080
So ist die erste Art, wie wir die Zeit beschreiben kann, ist mit großen O.

642
00:38:33,080 --> 00:38:35,380
Und das ist unser Worst-Case-Laufzeit.

643
00:38:35,380 --> 00:38:38,590
Wenn wir also ein Array sortieren möchten, und wir geben unser Algorithmus eine Reihe

644
00:38:38,590 --> 00:38:41,000
das ist in absteigender Reihenfolge, wenn es in aufsteigender Reihenfolge sein sollte,

645
00:38:41,000 --> 00:38:43,130
das wird sich im schlimmsten Fall zu sein.

646
00:38:43,130 --> 00:38:49,800
Dies ist unsere im oberen maximale Zeitdauer der Algorithmus nimmt gebunden.

647
00:38:49,800 --> 00:38:54,740
Auf der anderen Seite wird diese Ω werde besten Fall Laufzeit beschreiben.

648
00:38:54,740 --> 00:38:58,210
Also, wenn wir geben eine bereits sortierte Array zu einem Sortieralgorithmus,

649
00:38:58,210 --> 00:39:00,940
wie lange wird es dauern, sie zu sortieren?

650
00:39:00,940 --> 00:39:06,610
Und dies, dann beschreibt eine untere Schranke für Laufzeit.

651
00:39:06,610 --> 00:39:10,980
Also hier sind nur einige Wörter, die einige gemeinsame Laufzeiten beschreiben.

652
00:39:10,980 --> 00:39:13,120
Dies sind in aufsteigender Reihenfolge.

653
00:39:13,120 --> 00:39:16,060
Die schnellste Laufzeit haben wir genannt konstant.

654
00:39:16,060 --> 00:39:19,800
>> Das bedeutet, egal wie viele Elemente, die wir unseren Algorithmus geben,

655
00:39:19,800 --> 00:39:22,280
egal wie groß unser Angebot ist sortieren sie

656
00:39:22,280 --> 00:39:26,510
oder zu tun, was wir auf das Array zu tun wird immer die gleiche Menge an Zeit.

657
00:39:26,510 --> 00:39:30,270
So können wir, dass nur mit einer 1, die eine Konstante ist repräsentieren.

658
00:39:30,270 --> 00:39:32,410
Wir haben uns auch logarithmische Laufzeit.

659
00:39:32,410 --> 00:39:34,800
So etwas wie binäre Suche ist logarithmisch,

660
00:39:34,800 --> 00:39:37,140
wo wir schneiden das Problem in der Hälfte jedes Mal

661
00:39:37,140 --> 00:39:40,970
und dann die Dinge einfach höher zu von dort.

662
00:39:40,970 --> 00:39:43,580
Und wenn Sie jemals das Schreiben eines O jeder factorial Algorithmus

663
00:39:43,580 --> 00:39:47,850
sollten Sie wahrscheinlich nicht sehen dies als Ihren Job.

664
00:39:47,850 --> 00:39:53,910
Wenn wir Laufzeiten zu vergleichen ist es wichtig, im Hinterkopf behalten, diese Dinge.

665
00:39:53,910 --> 00:39:57,760
Also, wenn ich einen Algorithmus, der O (n) ist, und jemand anderes

666
00:39:57,760 --> 00:40:03,590
wurde ein Algorithmus von O (2n) sind tatsächlich asymptotisch äquivalent.

667
00:40:03,590 --> 00:40:06,590
Also, wenn wir uns vorstellen, n, um eine große Zahl wie eleventy Milliarden sein:

668
00:40:06,590 --> 00:40:13,090
so, wenn wir den Vergleich eleventy Milliarden so etwas wie eleventy Milliarden + 3,

669
00:40:13,090 --> 00:40:17,640
plötzlich, dass drei nicht wirklich einen großen Unterschied mehr.

670
00:40:17,640 --> 00:40:20,980
Das ist, warum wir beginnen bedenkt diese Dinge gleichwertig sind.

671
00:40:20,980 --> 00:40:24,220
So Dinge wie diese Konstanten hier gibt es 2 x dies oder das Hinzufügen eines 3,

672
00:40:24,220 --> 00:40:27,180
dies sind nur Konstanten, und diese werden würde sinken auf.

673
00:40:27,180 --> 00:40:32,480
Also das ist, warum alle 3 dieser Laufzeiten dasselbe wie zu sagen, sie sind O (n) sind.

674
00:40:32,480 --> 00:40:37,490
Ebenso, wenn wir 2 weitere Laufzeiten haben, sagen wir O (n ³ + 2n ²), können wir hinzufügen

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, und dann haben wir eine andere Laufzeit, die nur O ist (n ³).

676
00:40:42,070 --> 00:40:46,290
Auch diese dasselbe, da diese - diese nicht gleich sind.

677
00:40:46,290 --> 00:40:49,840
Dies sind die gleichen Dinge, sorry. Das sind also gleich, weil

678
00:40:49,840 --> 00:40:53,090
Diese n ³ wird diesen 2n ² dominieren.

679
00:40:53,090 --> 00:40:59,130
>> Was ist nicht dasselbe ist, wenn wir Zeiten wie O (n ³) und O ausgeführt haben (n ²)

680
00:40:59,130 --> 00:41:02,820
weil diese n ³ ist viel größer als dieser n ².

681
00:41:02,820 --> 00:41:05,470
Also, wenn wir Exponenten haben, plötzlich diese beginnt Rolle,

682
00:41:05,470 --> 00:41:08,280
aber wenn wir nur den Umgang mit Faktoren wie wir hier sind,

683
00:41:08,280 --> 00:41:12,810
dann ist es nicht die Materie, weil sie sich nur noch herausfallen.

684
00:41:12,810 --> 00:41:16,760
Werfen wir einen Blick auf einige der Algorithmen, die wir bisher gesehen haben

685
00:41:16,760 --> 00:41:19,260
und über ihre Laufzeit zu sprechen.

686
00:41:19,260 --> 00:41:23,850
Der erste Weg auf der Suche nach einer Nummer in einer Liste, die wir sahen, war lineare Suche.

687
00:41:23,850 --> 00:41:26,950
Und die Umsetzung der linearen Suche ist super einfach.

688
00:41:26,950 --> 00:41:30,490
Wir haben eine Liste, und wir werden auf jedem einzelnen Element in der Liste zu suchen

689
00:41:30,490 --> 00:41:34,260
bis wir die Anzahl finden wir suchen.

690
00:41:34,260 --> 00:41:38,370
Das heißt also, daß im schlimmsten Fall diese O (n).

691
00:41:38,370 --> 00:41:40,860
Und der schlechteste Fall hier sein könnte, wenn das Element

692
00:41:40,860 --> 00:41:45,710
das letzte Element, dann mit linearer Suche müssen wir bei jedem einzelnen Element zu betrachten

693
00:41:45,710 --> 00:41:50,180
bis wir das letzte zu bekommen, um zu wissen, dass es eigentlich in der Liste.

694
00:41:50,180 --> 00:41:52,910
Wir können nicht einfach aufgeben halbem Weg und sagen: "Es ist wahrscheinlich nicht dort."

695
00:41:52,910 --> 00:41:55,980
Mit lineare Suche haben wir an der ganzen Sache zu suchen.

696
00:41:55,980 --> 00:41:59,090
Die besten Fall Laufzeiten, eine auf der anderen Seite, ist konstant

697
00:41:59,090 --> 00:42:04,200
weil im besten Fall das Element, das wir suchen, ist nur der erste in der Liste.

698
00:42:04,200 --> 00:42:08,930
So, es wird nehmen uns genau 1 Schritt, egal wie groß die Liste ist

699
00:42:08,930 --> 00:42:12,140
wenn wir für das erste Element suchen jedesmal.

700
00:42:12,140 --> 00:42:15,390
>> Also, wenn Sie suchen, denken Sie daran, ist es nicht erforderlich, dass unsere Liste sortiert werden.

701
00:42:15,390 --> 00:42:19,430
Weil wir einfach gehen zu über jedes einzelne Element zu betrachten, und es ist nicht wirklich wichtig

702
00:42:19,430 --> 00:42:23,560
welcher Reihenfolge diese Elemente sind in.

703
00:42:23,560 --> 00:42:28,110
Eine intelligente Suchalgorithmus ist so etwas wie binäre Suche.

704
00:42:28,110 --> 00:42:31,500
Denken Sie daran, ist die Umsetzung der binären Suche, wenn Sie gehst

705
00:42:31,500 --> 00:42:34,320
halten Sie auf die Mitte der Liste.

706
00:42:34,320 --> 00:42:38,000
Und weil wir in der Mitte suchen, verlangen wir, dass die Liste sortiert ist

707
00:42:38,000 --> 00:42:40,580
sonst werden wir nicht wissen, wo die Mitte ist, und wir müssen schauen über

708
00:42:40,580 --> 00:42:44,480
die ganze Liste, um sie zu finden, und dann an diesem Punkt sind wir nur Zeit verschwenden.

709
00:42:44,480 --> 00:42:48,480
Also, wenn wir eine sortierte Liste und haben wir in der Mitte, wir gehen, um die Mitte zu vergleichen

710
00:42:48,480 --> 00:42:51,590
dem Element, das wir suchen.

711
00:42:51,590 --> 00:42:54,640
Ist sie zu hoch ist, dann können wir vergessen, die rechte Hälfte

712
00:42:54,640 --> 00:42:57,810
weil wir wissen, dass, wenn unsere Element ist bereits zu hoch

713
00:42:57,810 --> 00:43:01,080
und alles, was auf der rechten Seite dieses Elements ist sogar noch höher,

714
00:43:01,080 --> 00:43:02,760
dann brauchen wir nicht mehr dort zu suchen.

715
00:43:02,760 --> 00:43:05,430
Wo auf der anderen Seite, wenn unser Element zu niedrig ist,

716
00:43:05,430 --> 00:43:08,700
Wir wissen alles links dieses Elements ist auch zu gering,

717
00:43:08,700 --> 00:43:11,390
so dass es nicht wirklich Sinn, dort zu suchen, entweder.

718
00:43:11,390 --> 00:43:15,760
Auf diese Weise, mit jedem Schritt und jeder Zeit schauen wir in der Mitte der Liste,

719
00:43:15,760 --> 00:43:19,060
werden wir unser Problem in zwei Hälften geschnitten, weil plötzlich wissen wir,

720
00:43:19,060 --> 00:43:23,040
eine ganze Reihe von Zahlen, die nicht das, was wir suchen können.

721
00:43:23,040 --> 00:43:26,950
>> In Pseudocode würde dies so aussehen,

722
00:43:26,950 --> 00:43:30,990
und weil wir schneiden die Liste in der Hälfte jedes einzelne Mal,

723
00:43:30,990 --> 00:43:34,920
unseren worst-case Laufzeit Sprünge von linear auf logarithmisch.

724
00:43:34,920 --> 00:43:39,260
So haben wir plötzlich log-in Schritte, um ein Element in einer Liste zu finden.

725
00:43:39,260 --> 00:43:42,460
Das Best-Case-Laufzeiten, aber ist noch konstant

726
00:43:42,460 --> 00:43:45,180
denn jetzt, lasst uns einfach sagen, dass das Element, das wir suchen, ist

727
00:43:45,180 --> 00:43:48,380
immer die genaue Mitte der ursprünglichen Liste.

728
00:43:48,380 --> 00:43:52,080
So können wir unsere Liste so groß, wie wir wollen wachsen, aber wenn das Element wir suchen, ist in der Mitte,

729
00:43:52,080 --> 00:43:54,910
dann ist es nur noch zu nehmen uns ein Schritt.

730
00:43:54,910 --> 00:44:00,920
Also das ist, warum wir O (log n) und Ω (1) oder konstant sind.

731
00:44:00,920 --> 00:44:04,510
Lasst uns tatsächlich ausgeführt binäre Suche auf dieser Liste.

732
00:44:04,510 --> 00:44:08,020
Also lasst uns sagen, dass wir für das Element 164 suchen.

733
00:44:08,020 --> 00:44:11,650
Das erste, was wir tun werden, ist zu finden den Mittelpunkt dieser Liste.

734
00:44:11,650 --> 00:44:15,060
Es passiert einfach so, dass der Mittelpunkt wird fallen zwischen diesen 2 Zahlen,

735
00:44:15,060 --> 00:44:18,960
so lasst uns einfach willkürlich sagen, jedes Mal, wenn der Mittelpunkt liegt zwischen 2 Zahlen,

736
00:44:18,960 --> 00:44:21,150
lasst uns einfach aufrunden.

737
00:44:21,150 --> 00:44:24,330
Wir müssen nur sicherstellen, dass wir dies tun bei jedem Schritt des Weges.

738
00:44:24,330 --> 00:44:29,040
So werden wir zu runden, und wir gehen zu sagen, dass 161 der Mitte unserer Liste ist.

739
00:44:29,040 --> 00:44:34,640
So 161 <164, und jedes Element auf der linken Seite 161

740
00:44:34,640 --> 00:44:39,120
ist auch <164, so wissen wir, dass es nicht geht, um uns überhaupt helfen

741
00:44:39,120 --> 00:44:42,690
damit zu beginnen, über hier, weil das Element wir nicht dabei sein kann suchen.

742
00:44:42,690 --> 00:44:47,060
Also, was wir tun können ist, können wir nur über diese ganze linke Hälfte der Liste vergessen,

743
00:44:47,060 --> 00:44:51,700
und jetzt nur von der rechten Seite des 161 weiter zu betrachten.

744
00:44:51,700 --> 00:44:54,050
>> Also noch einmal, das ist der Mittelpunkt; lasst uns einfach aufrunden.

745
00:44:54,050 --> 00:44:56,260
Jetzt 175 ist zu groß.

746
00:44:56,260 --> 00:44:59,180
So wissen wir, es ist nicht zu helfen, uns suchen hier oder hier,

747
00:44:59,180 --> 00:45:06,610
so können wir nur, dass wegwerfen, und schließlich werden wir die 164 getroffen.

748
00:45:06,610 --> 00:45:10,560
Haben Sie Fragen zum binäre Suche?

749
00:45:10,560 --> 00:45:14,180
Gehen wir von der Suche durch ein bereits sortierte Liste

750
00:45:14,180 --> 00:45:17,660
tatsächlich unter eine Liste von Zahlen in beliebiger Reihenfolge

751
00:45:17,660 --> 00:45:20,960
und macht diese Liste in aufsteigender Reihenfolge.

752
00:45:20,960 --> 00:45:24,060
Der erste Algorithmus, den wir betrachtet hieß bubble sort.

753
00:45:24,060 --> 00:45:27,300
Und das wäre einfacher der Algorithmen, die wir sahen.

754
00:45:27,300 --> 00:45:32,970
Bubble sort sagt, dass, wenn alle 2 Elemente innerhalb der Liste fehl am Platze sind,

755
00:45:32,970 --> 00:45:36,500
dh es ist eine höhere Zahl links von einer niedrigeren Anzahl,

756
00:45:36,500 --> 00:45:40,190
dann werden wir, um sie auszutauschen, weil das bedeutet, dass die Liste wird

757
00:45:40,190 --> 00:45:42,860
"Mehr sortiert", als es vorher war.

758
00:45:42,860 --> 00:45:45,180
Und wir gerade dabei, diesen Prozess wieder fortgesetzt und immer wieder

759
00:45:45,180 --> 00:45:52,100
bis schließlich die Elemente Art Blase an den richtigen Ort, und wir haben eine sortierte Liste.

760
00:45:52,100 --> 00:45:57,230
>> Die Laufzeit dies wird O (n ²). Warum?

761
00:45:57,230 --> 00:46:00,370
Nun, weil im schlimmsten Fall, werden wir jedes Element zu nehmen, und

762
00:46:00,370 --> 00:46:04,570
wir gehen, um am Ende den Vergleich mit jedem anderen Element in der Liste.

763
00:46:04,570 --> 00:46:08,030
Aber im besten Fall haben wir eine bereits sortierte Liste, bubble sort die

764
00:46:08,030 --> 00:46:12,230
gerade dabei, einmal durch zu gehen, sagen: "Nope. Ich machte keine Swaps, so bin ich fertig."

765
00:46:12,230 --> 00:46:17,410
Also haben wir ein best-case Laufzeit von Ω (n).

766
00:46:17,410 --> 00:46:20,680
Laufen wir bubble sort auf einer Liste.

767
00:46:20,680 --> 00:46:23,560
Oder zuerst herausfinden, lasst uns einfach irgendwann Pseudocode wirklich schnell zu suchen.

768
00:46:23,560 --> 00:46:28,160
Wir wollen sagen, wir wollen, um zu verfolgen, in jeder Iteration der Schleife,

769
00:46:28,160 --> 00:46:32,190
im Auge behalten, ob wir nicht verändert keine Elemente.

770
00:46:32,190 --> 00:46:37,610
So der Grund dafür ist, werden wir aufhören, wenn wir keine Elemente vertauscht.

771
00:46:37,610 --> 00:46:41,980
So am Anfang unserer Schleife haben wir nichts getauscht, so dass wir sagen, das ist falsch.

772
00:46:41,980 --> 00:46:47,170
Nun, wir gehen durch die Liste gehen und vergleichen Element i zu Element i + 1

773
00:46:47,170 --> 00:46:50,310
und wenn es der Fall ist, dass es eine größere Zahl links von einer kleineren Anzahl,

774
00:46:50,310 --> 00:46:52,310
dann sind wir gerade dabei, sie zu tauschen.

775
00:46:52,310 --> 00:46:54,490
>> Und dann werden wir daran erinnern, dass wir ein Element ausgetauscht.

776
00:46:54,490 --> 00:46:58,900
Das bedeutet, dass wir durch die Liste gehen mindestens 1 mehr Zeit benötigen

777
00:46:58,900 --> 00:47:02,160
weil der Zustand, in dem wir anhielten, wenn die gesamte Liste bereits sortiert ist,

778
00:47:02,160 --> 00:47:04,890
dh wir haben keine Swaps.

779
00:47:04,890 --> 00:47:09,960
Also das ist, warum unsere Lage hier unten ist ", während einige Elemente vertauscht worden."

780
00:47:09,960 --> 00:47:13,720
So, jetzt lass uns einfach an dieser läuft auf einer Liste zu suchen.

781
00:47:13,720 --> 00:47:16,640
Ich habe die Liste 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Bubble-Sort wird den ganzen Weg auf der linken Seite beginnen, und es wird zu vergleichen

783
00:47:19,850 --> 00:47:24,700
i die Elemente, so 0 bis i + 1, wobei das Element 1 ist.

784
00:47:24,700 --> 00:47:29,020
Es wird gesagt, gut 5> 0, aber im Moment 5 ist auf der linken Seite

785
00:47:29,020 --> 00:47:32,500
so brauche ich, um die 5 und die 0 zu tauschen.

786
00:47:32,500 --> 00:47:35,470
Als ich sie zu tauschen, plötzlich bekomme ich diese andere Liste.

787
00:47:35,470 --> 00:47:38,260
Jetzt 5> 1, so werden wir sie zu tauschen.

788
00:47:38,260 --> 00:47:42,160
5 ist nicht> 6, so brauchen wir nicht, hier etwas zu tun.

789
00:47:42,160 --> 00:47:46,690
Aber 6> 4, so müssen wir tauschen.

790
00:47:46,690 --> 00:47:49,740
Auch hier müssen wir durch die ganze Liste, um schließlich zu entdecken laufen

791
00:47:49,740 --> 00:47:52,330
dass diese sind nicht in Ordnung, und wir tauschen sie,

792
00:47:52,330 --> 00:47:57,120
und an diesem Punkt müssen wir durch die Liste laufen 1 mehr Zeit

793
00:47:57,120 --> 00:48:05,390
um sicherzustellen, dass alles in seiner Ordnung ist, und an diesem Punkt bubble sort beendet wurde.

794
00:48:05,390 --> 00:48:10,720
Ein anderer Algorithmus für die Aufnahme einige Elemente und sortiert sie ist die Auswahl sort.

795
00:48:10,720 --> 00:48:15,740
Die Idee hinter Auswahl Art ist, dass wir gehen zum Aufbau einer sortierten Teil der Liste

796
00:48:15,740 --> 00:48:18,150
Ein Element zu einem Zeitpunkt.

797
00:48:18,150 --> 00:48:23,170
>> Und die Art und Weise wir, dass tun, ist durch den Aufbau der linken Segment der Liste.

798
00:48:23,170 --> 00:48:27,510
Und im Grunde jeden - auf jedem Schritt werden wir das kleinste Element, das wir verlassen haben nehmen

799
00:48:27,510 --> 00:48:32,310
das wurde noch nicht sortiert, und wir werden ihn in dieser sortierten Segment bewegen.

800
00:48:32,310 --> 00:48:35,850
Das heißt, wir müssen ständig finden die minimale unsortierten Element

801
00:48:35,850 --> 00:48:40,720
und dann, dass die kleinste Element und tauschen Sie ihn mit dem, was

802
00:48:40,720 --> 00:48:45,090
links am Element, das ist nicht sortiert.

803
00:48:45,090 --> 00:48:50,890
Die Laufzeit dieser wird O (n ²), da im schlimmsten Fall

804
00:48:50,890 --> 00:48:55,070
wir brauchen, um jedes einzelne Element mit jedem anderen Element zu vergleichen.

805
00:48:55,070 --> 00:48:59,250
Denn wir sagen, dass, wenn wir auf der linken Hälfte der Liste zu starten, müssen wir

806
00:48:59,250 --> 00:49:02,970
durch die gesamte rechte Segment gehen, um das kleinste Element finden.

807
00:49:02,970 --> 00:49:05,430
Und dann wieder, müssen wir gehen über die gesamte rechte Segment und

808
00:49:05,430 --> 00:49:08,210
keep going auf, dass immer und immer und immer wieder.

809
00:49:08,210 --> 00:49:11,350
Das wird n ² sein. Wir werden eine for-Schleife innerhalb einer anderen for-Schleife muss

810
00:49:11,350 --> 00:49:13,350
was darauf hindeutet, n ².

811
00:49:13,350 --> 00:49:16,530
Im besten Fall Gedanken, sagen wir, wir geben ihm eine bereits sortierte Liste;

812
00:49:16,530 --> 00:49:19,270
wir eigentlich nicht besser als n ².

813
00:49:19,270 --> 00:49:21,730
Weil Auswahl Art hat keine Möglichkeit zu wissen, dass

814
00:49:21,730 --> 00:49:25,540
das kleinste Element ist nur die, die ich gerade am suchen.

815
00:49:25,540 --> 00:49:28,970
Es muss noch dafür sorgen, dass dies tatsächlich das Minimum.

816
00:49:28,970 --> 00:49:31,670
>> Und der einzige Weg, um sicherzustellen, dass es das Minimum ist, mit diesem Algorithmus,

817
00:49:31,670 --> 00:49:34,640
ist es, an jedem einzelnen Element wieder anzusehen.

818
00:49:34,640 --> 00:49:38,420
Also wirklich, wenn Sie ihm - wenn Sie geben Auswahl sort eine bereits sortierte Liste,

819
00:49:38,420 --> 00:49:42,720
es wird nicht zu einem besseren zu tun, als ihm eine Liste, die nicht sortiert ist leer.

820
00:49:42,720 --> 00:49:46,320
By the way, wenn es der Fall zu sein passiert, dass etwas O (etwas)

821
00:49:46,320 --> 00:49:50,640
und das Omega von etwas, können wir nur kurz und bündig, dass es θ etwas sagen.

822
00:49:50,640 --> 00:49:52,760
Also, wenn Sie sehen, dass kommen überall, das ist, was das bedeutet nur.

823
00:49:52,760 --> 00:49:57,580
>> Wenn etwas Theta von n ² ist es sowohl big O (n ²) und Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
So best case und worst case, ist es nicht einen Unterschied machen,

825
00:49:59,790 --> 00:50:04,400
Der Algorithmus wird dasselbe tun jedesmal.

826
00:50:04,400 --> 00:50:06,610
Also das ist, was Pseudocode zur Auswahl Art aussehen könnte.

827
00:50:06,610 --> 00:50:10,630
Wir sind im Grunde zu sagen, dass ich durchlaufen die Liste wollen,

828
00:50:10,630 --> 00:50:15,180
von links nach rechts, und bei jeder Iteration der Schleife, ich werde zu bewegen

829
00:50:15,180 --> 00:50:19,780
die minimale Element in dieser sortierten Teil der Liste.

830
00:50:19,780 --> 00:50:23,260
Und wenn ich etwas bewegen gibt, habe ich nie brauchen, um dieses Element noch einmal an.

831
00:50:23,260 --> 00:50:28,600
Denn sobald ich ein Element auszutauschen, auf der linken Segment der Liste, es sortiert

832
00:50:28,600 --> 00:50:32,600
weil wir alles tun, in aufsteigender Reihenfolge, indem Minima.

833
00:50:32,600 --> 00:50:38,740
Also sagten wir, okay, wir an der Position i sind, und wir müssen schauen alle Elemente

834
00:50:38,740 --> 00:50:42,260
nach rechts von i, um die Minimum zu finden.

835
00:50:42,260 --> 00:50:46,150
So daß heißt, wir wollen von i + 1 bis zum Ende der Liste zu suchen.

836
00:50:46,150 --> 00:50:51,610
Und jetzt, wenn das Element, das wir derzeit auf der Suche bei weniger als unseren Mindestbestellwert so weit,

837
00:50:51,610 --> 00:50:54,190
die denken Sie daran, wir beginnen das Minimum aus, um nur sein,

838
00:50:54,190 --> 00:50:57,020
unabhängig Element sind wir derzeit auf, ich nehme an, das ist das Minimum.

839
00:50:57,020 --> 00:51:00,270
Wenn ich ein Element, das kleiner als das ist zu finden, dann werde ich sagen, okay,

840
00:51:00,270 --> 00:51:02,700
gut, ich habe ein neues Minimum gefunden.

841
00:51:02,700 --> 00:51:06,080
Ich werde daran zu erinnern, wo das Minimum lag.

842
00:51:06,080 --> 00:51:09,560
>> So, jetzt, nachdem ich habe durch dieses Recht unsortierten Segment gegangen,

843
00:51:09,560 --> 00:51:16,690
Ich kann sagen, ich werde das kleinste Element mit dem Element, das in Position i vertauschen.

844
00:51:16,690 --> 00:51:21,100
Das wird für den Aufbau meiner Liste, meine sortierten Teil der Liste von links nach rechts,

845
00:51:21,100 --> 00:51:25,190
und wir wissen nicht immer müssen zu einem Element wieder zu sehen, wenn es in diesem Teil ist.

846
00:51:25,190 --> 00:51:27,930
Sobald wir es getauscht.

847
00:51:27,930 --> 00:51:30,260
Also lasst uns laufen Auswahl Art auf dieser Liste.

848
00:51:30,260 --> 00:51:38,220
Das blaue Element hier wird das i zu sein, und die rote Element wird die minimale Element sein.

849
00:51:38,220 --> 00:51:41,570
So i beginnt den ganzen Weg auf der linken Seite der Liste, so bei 5.

850
00:51:41,570 --> 00:51:44,610
Jetzt müssen wir die minimale unsortierten Element zu finden.

851
00:51:44,610 --> 00:51:49,480
Also sagen wir 0 <5, so 0 mein neues minimal ist.

852
00:51:49,480 --> 00:51:53,820
>> Aber ich kann es nicht bleiben, denn auch wenn wir erkennen können, dass 0 die kleinste ist,

853
00:51:53,820 --> 00:51:59,390
wir brauchen, um durch jedes andere Element der Liste, um sicherzustellen, laufen.

854
00:51:59,390 --> 00:52:01,760
So 1 ist größer, 6 größer ist, ist 4 größer.

855
00:52:01,760 --> 00:52:05,850
Das bedeutet, dass nach einem Blick auf all diese Elemente, ich habe bestimmt 0 ist der kleinste.

856
00:52:05,850 --> 00:52:09,800
Also werde ich die 5 und die 0 zu tauschen.

857
00:52:09,800 --> 00:52:15,480
Sobald ich das tauschen, werde ich eine neue Liste zu bekommen, und ich weiß, dass ich nie brauchen, um die 0 wieder zu sehen

858
00:52:15,480 --> 00:52:19,380
denn wenn ich tauschte es habe, habe ich sie sortiert und wir sind fertig.

859
00:52:19,380 --> 00:52:22,730
Jetzt ist es einfach so passiert, dass das blaue Element ist wieder die 5,

860
00:52:22,730 --> 00:52:26,030
und wir müssen in der 1 zu sehen, die 6 und die 4 bis daß 1 zu bestimmen

861
00:52:26,030 --> 00:52:31,520
ist die kleinste kleinste Element, so dass wir die 1 und die 5 tauschen.

862
00:52:31,520 --> 00:52:36,890
Auch hier müssen wir zu sehen - vergleichen Sie die 5 auf die 6 und 4,

863
00:52:36,890 --> 00:52:39,830
und wir werden die 4 und die 5 wechseln und schließlich zu vergleichen

864
00:52:39,830 --> 00:52:45,740
diese 2 Zahlen und tauschen sie, bis wir unsere sortierte Liste zu bekommen.

865
00:52:45,740 --> 00:52:49,730
Haben Sie Fragen zur Auswahl Art?

866
00:52:49,730 --> 00:52:56,420
Okay. Lasst uns bis zum letzten Thema hier zu bewegen, und das ist Rekursion.

867
00:52:56,420 --> 00:52:59,810
>> Rekursion, denken Sie daran, das ist wirklich Meta Sache, wo eine Funktion

868
00:52:59,810 --> 00:53:02,740
ruft wiederholt sich.

869
00:53:02,740 --> 00:53:05,620
So an einem gewissen Punkt, während unsere fuction wiederholt, die sich selbst,

870
00:53:05,620 --> 00:53:10,100
es muss irgendwann an dem wir aufhören, uns selbst zu sein.

871
00:53:10,100 --> 00:53:13,670
Denn wenn wir das nicht tun, dann sind wir gerade dabei, dies auch weiterhin immer tun,

872
00:53:13,670 --> 00:53:16,660
und unser Programm ist einfach nicht zu kündigen.

873
00:53:16,660 --> 00:53:19,200
Wir nennen diesen Zustand der Base-Case.

874
00:53:19,200 --> 00:53:22,570
Und die Base-Case sagt, anstatt den Aufruf einer Funktion wieder

875
00:53:22,570 --> 00:53:25,330
Ich werde einfach einen Wert zurückgeben.

876
00:53:25,330 --> 00:53:28,080
Also, wenn wir einen Wert zurückgegeben haben, haben wir aufgehört ruft uns,

877
00:53:28,080 --> 00:53:32,550
und der Rest der Anrufe, die wir bisher gemacht haben können auch zurück.

878
00:53:32,550 --> 00:53:36,050
Das Gegenteil von dem Basisfall ist die rekursive Fall.

879
00:53:36,050 --> 00:53:39,050
Und das ist, wenn wir einen weiteren Aufruf der Funktion, dass wir momentan in. machen wollen

880
00:53:39,050 --> 00:53:44,690
Und wir wahrscheinlich, wenn auch nicht immer, wollen verschiedene Argumente verwenden.

881
00:53:44,690 --> 00:53:48,940
>> Also, wenn wir eine Funktion namens f, und f hat gerade angerufen nehmen Sie 1 Argument,

882
00:53:48,940 --> 00:53:52,010
und wir halten gerade Aufruf f (1), f (1), f (1), und es passiert einfach so, dass

883
00:53:52,010 --> 00:53:56,510
das Argument 1 fällt in rekursiven Fall sind wir noch nie zu stoppen.

884
00:53:56,510 --> 00:54:01,620
Selbst wenn wir ein Base-Case haben, müssen wir sicherstellen, dass wir schließlich wirst, dass base case getroffen.

885
00:54:01,620 --> 00:54:04,250
Wir wollen nicht nur zu halten Aufenthalt in diesem rekursiven Fall.

886
00:54:04,250 --> 00:54:09,870
Im Allgemeinen, wenn wir uns anrufen, wir wahrscheinlich zu haben, ein anderes Argument jeder Zeit.

887
00:54:09,870 --> 00:54:12,700
Hier ist eine wirklich einfache rekursive Funktion.

888
00:54:12,700 --> 00:54:15,090
So wird dies berechnet die Fakultät einer Zahl.

889
00:54:15,090 --> 00:54:17,790
Top-hier haben wir unsere Basis Fall.

890
00:54:17,790 --> 00:54:22,330
In dem Fall, dass n ≤ 1, werden wir nicht zu nennen factorial wieder.

891
00:54:22,330 --> 00:54:26,490
Wir gehen zu stoppen, wir sind gerade dabei, einen Wert zurückzugeben.

892
00:54:26,490 --> 00:54:30,170
Ist dies nicht wahr ist, dann werden wir unsere rekursive Fall getroffen.

893
00:54:30,170 --> 00:54:33,550
Beachten Sie hier, dass wir nicht nur fordern factorial (n), denn das wäre nicht sehr hilfreich.

894
00:54:33,550 --> 00:54:36,810
Wir gehen zu nennen Fakultät etwas anderes.

895
00:54:36,810 --> 00:54:40,850
>> Und damit Sie sehen können, schließlich, wenn wir ein factorial (5) oder etwas passieren,

896
00:54:40,850 --> 00:54:45,900
wir gehen zu nennen factorial (4) und so weiter, und schließlich werden wir dieses base case getroffen.

897
00:54:45,900 --> 00:54:51,730
Also das sieht gut aus. Mal sehen, was passiert, wenn wir laufen tatsächlich diese.

898
00:54:51,730 --> 00:54:57,840
Dies ist der Stapel, und lassen Sie uns sagen, dass Haupt wird diese Funktion mit einem Argument (4) nennen.

899
00:54:57,840 --> 00:55:02,200
Also, wenn factorial sieht und = 4, factorial wird selbst anruft.

900
00:55:02,200 --> 00:55:05,010
Jetzt, plötzlich, haben wir factorial (3).

901
00:55:05,010 --> 00:55:10,780
So sind diese Funktionen werde weiter wachsen, bis wir schließlich unsere Basis bei getroffen.

902
00:55:10,780 --> 00:55:17,830
An diesem Punkt ist der Rückgabewert dieser die Rückkehr (nx der Rückgabewert this),

903
00:55:17,830 --> 00:55:21,290
der Rückgabewert ist nx der Rückgabewert dafür.

904
00:55:21,290 --> 00:55:23,290
Schließlich müssen wir eine gewisse Anzahl getroffen.

905
00:55:23,290 --> 00:55:26,560
An der Spitze hier, sagen wir return 1.

906
00:55:26,560 --> 00:55:30,650
Das bedeutet, dass, wenn wir diese Zahl zurück, können wir dies aus dem Stapel Pop.

907
00:55:30,650 --> 00:55:36,570
Also das factorial (1) durchgeführt wird.

908
00:55:36,570 --> 00:55:41,190
Wenn 1 zurückkehrt, dies factorial (1) gibt, diese Rückkehr zum 1.

909
00:55:41,190 --> 00:55:46,910
Der Rückgabewert dieser, erinnere, war nx der Rückgabewert dafür.

910
00:55:46,910 --> 00:55:50,720
So plötzlich, weiß dieser Kerl, dass ich 2 zurückkehren wollen.

911
00:55:50,720 --> 00:55:55,910
>> Also denken Sie daran, zurückzukehren Wert dies ist nur nx der Rückgabewert hier oben.

912
00:55:55,910 --> 00:56:01,160
So, jetzt können wir sagen, 3 x 2, und schließlich, hier können wir sagen,

913
00:56:01,160 --> 00:56:04,010
dies ist gerade dabei, 4 x 3 x 2 sein.

914
00:56:04,010 --> 00:56:09,570
Und sobald dieser wieder erhalten wir auf eine einzige Zahl innerhalb von main.

915
00:56:09,570 --> 00:56:15,460
Haben Sie Fragen zu Rekursion?

916
00:56:15,460 --> 00:56:17,090
Gut. Es gibt also mehr Zeit für die Fragen am Ende,

917
00:56:17,090 --> 00:56:23,360
aber jetzt Joseph deckt die restlichen Themen.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Alles klar. So, jetzt haben wir über Rekursionen gesprochen,

919
00:56:25,590 --> 00:56:27,840
Reden wir ein wenig über das, was Mergesort ist.

920
00:56:27,840 --> 00:56:31,740
Mergesort ist im Grunde eine andere Art der Sortierung eine Liste von Zahlen.

921
00:56:31,740 --> 00:56:36,430
Und wie es funktioniert, mit Mergesort haben Sie eine Liste, und was wir tun, ist

922
00:56:36,430 --> 00:56:39,120
wir sagen, lasst uns aufgeteilt dies in 2 Hälften.

923
00:56:39,120 --> 00:56:42,750
Wir zum ersten Mal ausgeführt Mergesort wieder auf der linken Hälfte,

924
00:56:42,750 --> 00:56:45,040
dann werden wir laufen Mergesort auf der rechten Hälfte,

925
00:56:45,040 --> 00:56:50,240
und das gibt uns jetzt 2 Hälften, die sortiert werden, und jetzt werden wir diese Hälften miteinander zu kombinieren.

926
00:56:50,240 --> 00:56:55,010
Es ist ein bisschen schwer, ohne ein Beispiel zu sehen, so dass wir durch die Bewegungen gehen und sehen, was passiert.

927
00:56:55,010 --> 00:56:59,590
So starten Sie mit dieser Liste, wir haben es aufgeteilt in 2 Hälften.

928
00:56:59,590 --> 00:57:02,300
Wir laufen Mergesort auf der linken Hälfte erste.

929
00:57:02,300 --> 00:57:06,660
Damit ist die linke Hälfte, und jetzt laufen wir ihnen durch diese Liste wieder

930
00:57:06,660 --> 00:57:09,800
welches wird in Mergesort vergangen, und dann schauen wir wieder,

931
00:57:09,800 --> 00:57:13,270
auf der linken Seite der Liste und wir laufen Mergesort auf sie.

932
00:57:13,270 --> 00:57:15,880
Jetzt erhält man bis in eine Liste von Nummern 2,

933
00:57:15,880 --> 00:57:19,010
und nun die linke Hälfte ist nur 1 Element lang, und wir können nicht

934
00:57:19,010 --> 00:57:23,380
Aufgeteilt eine Liste, die nur 1 Element in die Hälfte ist, so dass wir nur sagen, wenn wir 50 haben,

935
00:57:23,380 --> 00:57:26,400
das ist nur ein Element, es ist bereits sortiert.

936
00:57:26,400 --> 00:57:29,860
>> Sobald wir damit fertig sind, können wir sehen, dass wir

937
00:57:29,860 --> 00:57:32,230
fahren Sie mit der rechten Hälfte dieser Liste

938
00:57:32,230 --> 00:57:36,480
und 3 ist auch sortiert, und so jetzt, dass beide Hälften dieser Liste sortiert werden

939
00:57:36,480 --> 00:57:39,080
können wir diese Zahlen wieder miteinander zu verbinden.

940
00:57:39,080 --> 00:57:45,320
So betrachten wir 50 und 3; 3 ist kleiner als 50, so geht es in einer ersten und dann 50 hereinkommt

941
00:57:45,320 --> 00:57:49,340
Nun, das ist geschehen, wir gehen wieder auf dieser Liste und sortieren es rechte Hälfte.

942
00:57:49,340 --> 00:57:52,440
42 ist eine eigene Nummer, so ist es bereits sortiert.

943
00:57:52,440 --> 00:57:57,850
So jetzt haben wir vergleichen diese 2 und 3 ist kleiner als 42, so dass wird in erster Stelle,

944
00:57:57,850 --> 00:58:02,340
Jetzt 42 wird in gesetzt, und 50 wird gesetzt in.

945
00:58:02,340 --> 00:58:07,220
Nun, das ist sortiert, gehen wir den ganzen Weg zurück an die Spitze, 1337 und 15.

946
00:58:07,220 --> 00:58:14,560
Nun, schauen wir jetzt auf der linken Hälfte dieser Liste 1337 ist an sich so ist es sortiert und gleichzeitig mit 15.

947
00:58:14,560 --> 00:58:19,020
So, jetzt kombinieren wir diese 2 Zahlen, um die ursprüngliche Liste, 15 <1337 zu sortieren,

948
00:58:19,020 --> 00:58:23,060
so ist es in erster geht, dann 1337 geht in.

949
00:58:23,060 --> 00:58:26,640
Und jetzt haben wir sortiert beide Hälften der ursprünglichen Liste oben.

950
00:58:26,640 --> 00:58:30,440
Und alles, was wir tun müssen, ist diese kombinieren.

951
00:58:30,440 --> 00:58:36,890
Wir schauen uns die ersten 2 Zahlen dieser Liste, 3 <15, so geht es in der Art Array zuerst.

952
00:58:36,890 --> 00:58:44,460
15 <42, so geht es in. Jetzt, 42 <1337, das geht in.

953
00:58:44,460 --> 00:58:51,010
50 <1337, so geht es in. Und feststellen, dass wir nahmen 2 Zahlen aus dieser Liste.

954
00:58:51,010 --> 00:58:53,640
So sind wir nicht nur abwechselnd zwischen den 2 Listen.

955
00:58:53,640 --> 00:58:56,050
Wir suchen nur am Anfang, und wir nehmen das Element

956
00:58:56,050 --> 00:59:00,270
das ist kleiner und dann setzen sie in unser Angebot.

957
00:59:00,270 --> 00:59:04,080
Jetzt haben wir alle die Hälften zusammengeführt und wir sind fertig.

958
00:59:04,080 --> 00:59:07,780
>> Haben Sie Fragen zu Mergesort? Ja?

959
00:59:07,780 --> 00:59:14,190
[Student] Wenn es Aufspaltung ist in verschiedene Gruppen, warum sie nicht einfach aufgeteilt es einmal

960
00:59:14,190 --> 00:59:19,970
und Sie haben 3 und 2 in einer Gruppe? [Rest der Frage unverständlich]

961
00:59:19,970 --> 00:59:24,940
Der Grund - so stellt sich die Frage, warum können wir nicht einfach verschmelzen sie zu diesem ersten Schritt, nachdem wir sie haben?

962
00:59:24,940 --> 00:59:29,530
Der Grund warum wir dies tun können, auf der linken die meisten Elemente beider Seiten beginnen,

963
00:59:29,530 --> 00:59:33,040
und nehmen Sie dann die kleinere und steckte es in, ist, dass wir, dass diese wissen,

964
00:59:33,040 --> 00:59:35,290
einzelnen Listen sind in sortierter Aufträge.

965
00:59:35,290 --> 00:59:37,290
Also, wenn ich an den äußersten linken Elemente der beiden Hälften suchen,

966
00:59:37,290 --> 00:59:40,490
Ich weiß, sie werden die kleinsten Elemente dieser Listen sein.

967
00:59:40,490 --> 00:59:43,930
So kann ich sie in die kleinste Element Flecken dieser großen Liste zu setzen.

968
00:59:43,930 --> 00:59:47,810
Auf der anderen Seite, wenn ich mir diese 2 Listen in der zweiten Ebene drüben,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 und 15, sind diejenigen nicht sortiert.

970
00:59:51,640 --> 00:59:55,770
Also, wenn ich bei 50 und 1337 schauen, ich werde 50 in meiner Liste an erster Stelle.

971
00:59:55,770 --> 01:00:00,130
Aber das macht nicht wirklich Sinn, weil 3 das kleinste Element aus allen von ihnen ist.

972
01:00:00,130 --> 01:00:04,390
So ist die einzige Grund, warum wir diese Kombination Schritt tun können, ist, weil unsere Listen bereits sortiert sind.

973
01:00:04,390 --> 01:00:07,010
Deshalb haben wir, um den ganzen Weg nach unten haben

974
01:00:07,010 --> 01:00:09,800
denn wenn wir nur eine einzige Nummer haben, wissen Sie, dass eine einzelne Zahl

975
01:00:09,800 --> 01:00:14,120
an und für sich ist bereits eine sortierte Liste.

976
01:00:14,120 --> 01:00:19,360
>> Haben Sie Fragen? Nein?

977
01:00:19,360 --> 01:00:24,260
Komplexität? Nun, man kann sehen, dass bei jedem Schritt gibt es Endzahlen

978
01:00:24,260 --> 01:00:27,590
und wir teilen kann eine Liste in der Hälfte log n Zeiten,

979
01:00:27,590 --> 01:00:31,700
das ist, wo wir diese n x log n Komplexität erhalten.

980
01:00:31,700 --> 01:00:34,940
Und du wirst sehen, im besten Fall für Mergesort ist n log n, und es passiert einfach so,

981
01:00:34,940 --> 01:00:39,340
, dass der schlimmste Fall, oder die Ω drüben, ist auch n log n.

982
01:00:39,340 --> 01:00:42,480
Etwas im Auge zu behalten.

983
01:00:42,480 --> 01:00:45,750
Umzug auf, lasst uns gehen auf einige super grundlegenden Datei-I / O.

984
01:00:45,750 --> 01:00:48,830
Wenn Sie an Scramble sah, werden Sie feststellen, hatten wir eine Art von System

985
01:00:48,830 --> 01:00:51,270
wo man in eine Protokolldatei zu schreiben, wenn Sie durch den Code zu lesen.

986
01:00:51,270 --> 01:00:53,730
Mal sehen, wie Sie das tun.

987
01:00:53,730 --> 01:00:57,450
Nun, wir haben fprintf, die Sie kann nur als printf denken,

988
01:00:57,450 --> 01:01:01,720
aber gerade Drucken auf einem Datei anstelle und damit die f zu Beginn.

989
01:01:01,720 --> 01:01:07,570
Diese Art von Code bis hier, was sie tut, ist, wie Sie in Scramble gesehen haben könnte,

990
01:01:07,570 --> 01:01:12,310
geht es durch Ihre 2-dimensionalen Array Druck zeilenweise, was die Zahlen sind.

991
01:01:12,310 --> 01:01:17,850
In diesem Fall printf druckt Ihr Terminal oder was wir die Standard-Ausgabe des Abschnitts.

992
01:01:17,850 --> 01:01:22,170
>> Und jetzt, in diesem Fall ist alles, was wir zu tun haben, zu ersetzen printf mit fprintf,

993
01:01:22,170 --> 01:01:26,770
sagen, was Datei, die Sie drucken möchten, und in diesem Fall ist es nur druckt sie auf diese Datei

994
01:01:26,770 --> 01:01:32,230
statt es auszudrucken Ihr Terminal.

995
01:01:32,230 --> 01:01:36,500
Na, dann, dass die Frage aufwirft: Wo bekommen wir diese Art von Datei von, richtig?

996
01:01:36,500 --> 01:01:39,840
Wir passierten Anmeldung bei diesem fprintf fuction aber wir hatten keine Ahnung, woher es kam.

997
01:01:39,840 --> 01:01:43,980
Nun, in den frühen Code, was wir hatten, war diese Stück Code hier rüber,

998
01:01:43,980 --> 01:01:48,340
die im Grunde sagt, dass Öffnen Sie die Datei log.txt nennt.

999
01:01:48,340 --> 01:01:53,220
Was wir danach ist zu tun, müssen wir sicherstellen, dass die Datei tatsächlich erfolgreich geöffnet.

1000
01:01:53,220 --> 01:01:57,070
So könnte es aus mehreren Gründen scheitern, Sie haben nicht genug Speicherplatz auf Ihrem Computer, zum Beispiel.

1001
01:01:57,070 --> 01:01:59,790
So ist es immer wichtig, bevor Sie Vorgänge mit der Datei machen

1002
01:01:59,790 --> 01:02:03,300
dass wir prüfen, ob die Datei erfolgreich geöffnet wurde.

1003
01:02:03,300 --> 01:02:09,330
Also, was, dass ein, das ist ein Argument für fopen, na ja, können wir eine Datei in vielerlei Hinsicht zu öffnen.

1004
01:02:09,330 --> 01:02:13,510
Was wir können, ist zu tun, können wir sie weitergeben w, was bedeutet, überschreiben Sie die Datei, wenn sie bereits existiert,

1005
01:02:13,510 --> 01:02:18,070
Wir können das Bestehen einer a, die sie bis zum Ende der Datei angehängt, anstatt zu überschreiben,

1006
01:02:18,070 --> 01:02:22,730
oder wir können r geben, was bedeutet, öffnen wir die Datei als schreibgeschützt.

1007
01:02:22,730 --> 01:02:24,890
Also, wenn das Programm versucht, Änderungen an der Datei vornehmen,

1008
01:02:24,890 --> 01:02:30,140
schreien sie und lassen Sie sie nicht tun.

1009
01:02:30,140 --> 01:02:33,320
Schließlich, wenn wir mit der Datei gemacht, fertig machen Operationen darauf,

1010
01:02:33,320 --> 01:02:35,860
Wir müssen sicherstellen, dass wir die Datei zu schließen.

1011
01:02:35,860 --> 01:02:38,830
Und so am Ende des Programms, wirst du sie wieder vorbei

1012
01:02:38,830 --> 01:02:42,120
Diese Datei, die Sie öffnen und schließen Sie es.

1013
01:02:42,120 --> 01:02:44,650
Das ist also etwas wichtig, dass Sie sicherstellen, dass Sie zu tun haben.

1014
01:02:44,650 --> 01:02:47,180
Also denken Sie daran können Sie eine Datei öffnen, dann können Sie die Datei zu schreiben,

1015
01:02:47,180 --> 01:02:51,270
tun Operationen in der Datei, aber dann müssen Sie die Datei am Ende zu schließen.

1016
01:02:51,270 --> 01:02:53,270
>> Haben Sie Fragen zu den grundlegenden Datei-I / O? Ja?

1017
01:02:53,270 --> 01:02:58,050
[Studenten Frage unverständlich]

1018
01:02:58,050 --> 01:03:02,480
Genau hier. Die Frage ist, wo diese Datei log.txt erscheinen?

1019
01:03:02,480 --> 01:03:07,890
Nun, wenn man ihnen nur das log.txt, schafft er es im selben Verzeichnis wie die ausführbare Datei.

1020
01:03:07,890 --> 01:03:10,500
Also, wenn du bist - >> [Studentische Frage unverständlich]

1021
01:03:10,500 --> 01:03:18,830
Ja. In dem gleichen Ordner oder im gleichen Verzeichnis, wie Sie es nennen.

1022
01:03:18,830 --> 01:03:21,400
Jetzt Speicher, Stack und Heap.

1023
01:03:21,400 --> 01:03:23,400
Also, wie ist der Speicher in den Computer verlegt?

1024
01:03:23,400 --> 01:03:26,270
Nun, Sie können Speicher als eine Art dieser Block hier vorstellen.

1025
01:03:26,270 --> 01:03:30,260
Und in Erinnerung haben wir, was den Haufen dort stecken, und den Stapel, die unten ist dort abgerufen werden.

1026
01:03:30,260 --> 01:03:34,480
Und die Heap wächst nach unten und der Stapel wächst nach oben.

1027
01:03:34,480 --> 01:03:38,620
So wie Tommy erwähnt - oh, gut, und wir haben diese 4 Segmente, die ich in einem zweiten bekommen -

1028
01:03:38,620 --> 01:03:42,890
Als Tommy vorhin gesagt, Sie wissen, wie seine Funktionen selbst nennen und rufen einander?

1029
01:03:42,890 --> 01:03:44,930
Sie bauen diese Art von Stack-Frame.

1030
01:03:44,930 --> 01:03:47,360
Nun, wenn Haupt Anrufe foo, foo wird auf den Stapel gelegt.

1031
01:03:47,360 --> 01:03:52,430
Foo ruft bar, bar erhalten die auf den Stapel gelegt, und das wird auf dem Stapel nach setzen.

1032
01:03:52,430 --> 01:03:57,040
Und als sie zurück, sie jeweils Aussteigen aus dem Stapel entnommen.

1033
01:03:57,040 --> 01:04:00,140
Was jeder dieser Standorte und Speicher zu halten?

1034
01:04:00,140 --> 01:04:03,110
Nun, enthält die oberste, die der Text-Segment ist, das Programm selber.

1035
01:04:03,110 --> 01:04:06,390
So den Maschinen-Code, das ist es, wenn Sie kompilieren Sie Ihr Programm.

1036
01:04:06,390 --> 01:04:08,520
Weiter, alle globalen Variablen initialisiert.

1037
01:04:08,520 --> 01:04:12,660
>> So haben Sie globale Variablen in Ihrem Programm, und Sie sagen, wie, a = 5,

1038
01:04:12,660 --> 01:04:15,260
das wird in diesem Segment setzen, und rechts unter, dass

1039
01:04:15,260 --> 01:04:18,990
Sie haben keine initialisierte globale Daten, die nur INT a,

1040
01:04:18,990 --> 01:04:20,990
aber nicht sagen, es ist gleich nichts.

1041
01:04:20,990 --> 01:04:23,870
Verwirklichen Sie sind globale Variablen, so dass sie außerhalb der main.

1042
01:04:23,870 --> 01:04:28,560
Dies bedeutet also keine globalen Variablen, die deklariert, aber werden nicht initialisiert.

1043
01:04:28,560 --> 01:04:32,310
Also, was ist in der Halde? Speicher zugewiesen werden, indem malloc, die wir in ein wenig bekommen.

1044
01:04:32,310 --> 01:04:35,990
Und schließlich, mit dem Stapel haben Sie keine lokalen Variablen

1045
01:04:35,990 --> 01:04:39,950
und alle Funktionen, die Sie vielleicht in einem der ihren Parametern aufrufen.

1046
01:04:39,950 --> 01:04:43,720
Die letzte Sache, die Sie nicht wirklich wissen, was die Umgebungsvariablen zu tun,

1047
01:04:43,720 --> 01:04:46,700
aber wenn Sie das Programm ausführen, es ist etwas verbunden, wie

1048
01:04:46,700 --> 01:04:49,550
Dies ist der Benutzername der Person, die das Programm lief.

1049
01:04:49,550 --> 01:04:51,550
Und das geht zu Art werden an der Unterseite.

1050
01:04:51,550 --> 01:04:54,540
Im Hinblick auf die Speicheradressen, die hexadezimalen Werte sind,

1051
01:04:54,540 --> 01:04:58,170
die Werte an der Spitze beginnen bei 0, und sie gehen den ganzen Weg hinunter auf den Boden.

1052
01:04:58,170 --> 01:05:00,440
In diesem Fall, wenn Sie auf der 32-Bit-System,

1053
01:05:00,440 --> 01:05:05,390
die Adresse, an der Unterseite sein wird 0x, gefolgt von af, denn das ist 32 Bit,

1054
01:05:05,390 --> 01:05:10,890
welches 8 Byte, und in diesem Fall 8 Byte entspricht 8 Hexadezimalzahlen.

1055
01:05:10,890 --> 01:05:20,110
So hier unten wirst du haben, mögen, 0xffffff und dort wirst du 0 haben.

1056
01:05:20,110 --> 01:05:23,660
Also, was sind Zeiger? Einige von Ihnen mögen dies nicht in Abschnitt behandelt zuvor.

1057
01:05:23,660 --> 01:05:26,660
aber wir haben darüber in der Vorlesung zu gehen, so ist ein Zeiger nur ein Datentyp

1058
01:05:26,660 --> 01:05:34,030
die Geschäfte, anstatt irgendeine Art von Wert wie 50, die Adresse des irgendeiner Stelle im Speicher speichert.

1059
01:05:34,030 --> 01:05:36,020
Wie dieser Speicher [unverständlich].

1060
01:05:36,020 --> 01:05:41,120
Also in diesem Fall, was wir haben, ist, wir haben ein Zeiger auf einen Integer oder int *,

1061
01:05:41,120 --> 01:05:46,210
und es enthält dieses hexadezimale Adresse 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Also, was wir haben, ist, jetzt, diese Zeiger an irgendeiner Stelle im Speicher,

1063
01:05:50,880 --> 01:05:56,020
und dass nur ein, sich der Wert 50 in dieser Speicherstelle.

1064
01:05:56,020 --> 01:06:01,810
Auf einigen 32-Bit-Systemen auf allen 32-Bit-Systeme, nehmen Zeiger bis 32 Bits oder 4 Bytes.

1065
01:06:01,810 --> 01:06:06,020
Aber beispielsweise auf einem 64-Bit-System sind Zeiger 64 Bits.

1066
01:06:06,020 --> 01:06:08,040
Also das ist etwas, was Sie wollen, im Auge zu behalten werde.

1067
01:06:08,040 --> 01:06:12,310
So auf einer Ende-Bit-System ist ein Zeiger Ende Bit lang.

1068
01:06:12,310 --> 01:06:17,320
Zeiger sind eine Art schwer zu verdauen, ohne zusätzliche Dinge,

1069
01:06:17,320 --> 01:06:20,300
also lasst uns durch ein Beispiel dynamische Speicherzuweisung gehen.

1070
01:06:20,300 --> 01:06:25,130
Was dynamische Speicherzuweisung für Sie tut, oder wie wir es nennen malloc,

1071
01:06:25,130 --> 01:06:29,280
es lässt Sie zuordnen irgendeine Art von Daten außerhalb des Sets.

1072
01:06:29,280 --> 01:06:31,830
So werden diese Daten ist eine Art dauerhafter für die Dauer des Programms.

1073
01:06:31,830 --> 01:06:36,430
Denn wie Sie wissen, wenn Sie erklären, x innerhalb einer Funktion, und dass Funktion zurückkehrt,

1074
01:06:36,430 --> 01:06:40,910
Sie haben keinen Zugriff mehr auf die Daten, die in x gespeichert wurde.

1075
01:06:40,910 --> 01:06:44,420
Was Zeigern wir tun, ist sie uns speichern Speicher oder Speicher-Werte

1076
01:06:44,420 --> 01:06:46,840
in einem anderen Segment des Speichers, nämlich des Heap.

1077
01:06:46,840 --> 01:06:49,340
Nun, wenn wir wieder außer Funktion, solange wir einen Zeiger haben

1078
01:06:49,340 --> 01:06:54,960
an diesem Ort im Speicher, dann das, was wir tun können ist, können wir nur auf die Werte dort zu suchen.

1079
01:06:54,960 --> 01:06:58,020
Lassen Sie uns ein Beispiel an: Das ist unser Speicher-Layout wieder.

1080
01:06:58,020 --> 01:07:00,050
Und wir haben diese Funktion main.

1081
01:07:00,050 --> 01:07:06,870
Was sie tut, ist - okay, so einfach, nicht wahr? - Int x = 5, das ist nur eine Variable auf dem Stack in main.

1082
01:07:06,870 --> 01:07:12,450
>> Auf der anderen Seite, jetzt haben wir einen Zeiger deklarieren, die die Funktion giveMeThreeInts nennt.

1083
01:07:12,450 --> 01:07:16,800
Und nun haben wir in dieser Funktion gehen und wir erstellen eine neue Stack-Frame für sie.

1084
01:07:16,800 --> 01:07:20,440
Allerdings ist in diesem Stack-Frame, erklären wir int * temp,

1085
01:07:20,440 --> 01:07:23,210
die in mallocs 3 Zahlen für uns.

1086
01:07:23,210 --> 01:07:25,880
So Größe int wird uns, wie viele Bytes diesem int ist,

1087
01:07:25,880 --> 01:07:29,620
und malloc gibt uns, dass viele Byte an Speicherplatz auf dem Heap.

1088
01:07:29,620 --> 01:07:32,890
Also in diesem Fall haben wir genug Platz für 3 Zahlen erstellt,

1089
01:07:32,890 --> 01:07:36,830
und der Haufen ist da oben, das ist, warum ich es gezeichnet haben höher.

1090
01:07:36,830 --> 01:07:42,900
Sobald wir fertig sind, wir kommen wieder hier, brauchen Sie nur 3 ints zurückgekehrt,

1091
01:07:42,900 --> 01:07:47,000
und es gibt die Adresse, in diesem Fall über wenn dieser Speicher ist.

1092
01:07:47,000 --> 01:07:51,250
Und wir setzen pointer = Schalter, und dort haben wir nur einen weiteren Zeiger.

1093
01:07:51,250 --> 01:07:54,550
Aber was diese Funktion kehrt hier gestapelt und verschwindet.

1094
01:07:54,550 --> 01:07:59,250
So Temp verschwindet, aber wir behalten trotzdem die Adresse, wo

1095
01:07:59,250 --> 01:08:01,850
diese 3 Zahlen sind innerhalb Netz.

1096
01:08:01,850 --> 01:08:06,180
So in diesem Set sind die Zeiger scoped lokal für die gestapelten Rahmen,

1097
01:08:06,180 --> 01:08:09,860
aber der Speicher, auf den sie sich beziehen, ist in der Halde.

1098
01:08:09,860 --> 01:08:12,190
>> Macht das Sinn?

1099
01:08:12,190 --> 01:08:14,960
[Student] Könnten Sie das wiederholen? >> [Joseph] Ja.

1100
01:08:14,960 --> 01:08:20,270
Also, wenn ich wieder nur ein wenig gehen, sehen Sie, dass temporäre zugeordnet

1101
01:08:20,270 --> 01:08:23,500
einige Speicher auf dem Heap up there.

1102
01:08:23,500 --> 01:08:28,680
Also, wenn diese Funktion, giveMeThreeInts zurückkehrt, dieser Stapel hier wird verschwinden.

1103
01:08:28,680 --> 01:08:35,819
Und mit ihm jede der Variablen, in diesem Fall, diese Zeiger, der in gestapelter Rahmen zugewiesen wurde.

1104
01:08:35,819 --> 01:08:39,649
Das wird verschwinden, aber da wir Temp zurück

1105
01:08:39,649 --> 01:08:46,330
und wir setzen pointer = temp, Zeiger ist nun den gleichen Speicher Speicherort wie Temperatur war zu zeigen.

1106
01:08:46,330 --> 01:08:50,370
So, jetzt, auch wenn wir verlieren, temp, dass lokale Zeiger,

1107
01:08:50,370 --> 01:08:59,109
wir immer noch die Speicheradresse, was es wurde innerhalb dieser Variablen Zeiger.

1108
01:08:59,109 --> 01:09:03,740
Haben Sie Fragen? Das kann eine Art verwirrendes Thema sein, wenn man nicht über sie in Abschnitt gegangen.

1109
01:09:03,740 --> 01:09:09,240
Wir können Ihre TF definitiv vorbei zu gehen und natürlich können wir Fragen beantworten

1110
01:09:09,240 --> 01:09:11,500
am Ende der Überprüfung Session für diese.

1111
01:09:11,500 --> 01:09:14,220
Aber dies ist eine Art komplexes Thema, und ich habe weitere Beispiele, die gehen zu zeigen, bis sich

1112
01:09:14,220 --> 01:09:18,790
das hilft zu klären, was Zeiger tatsächlich sind.

1113
01:09:18,790 --> 01:09:22,500
>> In diesem Fall sind Zeiger entspricht Arrays,

1114
01:09:22,500 --> 01:09:25,229
so kann ich nur diesen Zeiger verwenden, als die gleiche Sache wie ein int-Array.

1115
01:09:25,229 --> 01:09:29,840
Also bin ich in 0 Indizierung und das Ändern der ersten Ganzzahl 1,

1116
01:09:29,840 --> 01:09:39,689
Ändern des zweiten ganzzahligen bis 2, und die dritte ganze Zahl bis 3 ist.

1117
01:09:39,689 --> 01:09:44,210
So mehr auf Zeigern. Nun, Binky erinnern.

1118
01:09:44,210 --> 01:09:48,319
In diesem Fall haben wir einen Zeiger zugeordnet, oder erklärten wir einen Zeiger,

1119
01:09:48,319 --> 01:09:52,760
aber zunächst, wenn ich gerade erklärt einen Zeiger, ist es nicht zeigen, um überall im Speicher.

1120
01:09:52,760 --> 01:09:54,930
Es ist nur Müll Werte darin.

1121
01:09:54,930 --> 01:09:56,470
Also ich habe keine Ahnung, wo dieser Zeiger auf zeigt.

1122
01:09:56,470 --> 01:10:01,630
Es hat eine Adresse, die nur mit 0 und 1 ist, wo es zunächst erklärt wurde gefüllt ist.

1123
01:10:01,630 --> 01:10:04,810
Ich kann nichts mit, bis ich malloc dafür aufrufen

1124
01:10:04,810 --> 01:10:08,390
und dann gibt es mir ein wenig Platz auf dem Heap, wo ich Werte setzen können innen.

1125
01:10:08,390 --> 01:10:11,980
Dann wieder, ich weiß nicht, was drin ist dieser Speicher.

1126
01:10:11,980 --> 01:10:16,780
Also das erste, was ich tun müssen, ist zu prüfen, ob das System genügend Speicher hatten

1127
01:10:16,780 --> 01:10:20,850
zu geben, mich zurück 1 integer in erster Linie, weshalb ich das überprüfen möchte, ist.

1128
01:10:20,850 --> 01:10:25,020
Wenn Zeiger ist null, das heißt, dass es nicht genug Platz oder eine andere Fehler aufgetreten ist,

1129
01:10:25,020 --> 01:10:26,320
also sollte ich Ausfahrt aus meinem Programm.

1130
01:10:26,320 --> 01:10:29,400
 Aber wenn es gelänge, jetzt kann ich mit diesem Zeiger

1131
01:10:29,400 --> 01:10:35,020
und was * Zeiger tut, ist es folgt, wo die Adresse

1132
01:10:35,020 --> 01:10:38,480
dorthin, wo dieser Wert ist, und setzt es gleich 1 ist.

1133
01:10:38,480 --> 01:10:41,850
So hier, wir überprüfen, ob diese Erinnerung existierte.

1134
01:10:41,850 --> 01:10:45,380
>> Sobald Sie wissen, es existiert, kann man hineinsteckt

1135
01:10:45,380 --> 01:10:50,460
welchen Wert Sie hineinsteckt, in diesem Fall ein.

1136
01:10:50,460 --> 01:10:53,060
Sobald wir damit fertig sind, müssen Sie, dass Zeiger befreien

1137
01:10:53,060 --> 01:10:57,160
weil wir, um wieder auf das System, dass der Speicher, die Sie für in erster Linie gefragt, benötigen.

1138
01:10:57,160 --> 01:10:59,690
Da der Computer nicht wissen, wann wir damit fertig sind.

1139
01:10:59,690 --> 01:11:02,510
In diesem Fall werden wir explizit sagen Sie es durch, okay, wir sind mit dieser Erinnerung getan.

1140
01:11:02,510 --> 01:11:10,780
Wenn ein anderer Prozess braucht es, ein anderes Programm braucht, fühlen Sie sich frei, gehen Sie vor und nehmen Sie es.

1141
01:11:10,780 --> 01:11:15,110
Was wir auch tun, ist, können wir nur erhalten, die Adresse der lokalen Variablen auf dem Set.

1142
01:11:15,110 --> 01:11:19,080
So int x innerhalb des gestapelten Rahmen main.

1143
01:11:19,080 --> 01:11:23,060
Und wenn wir dieses kaufmännisches verwenden, dies und Betreiber, was sie tut, ist

1144
01:11:23,060 --> 01:11:27,310
es dauert x und x ist nur einige Daten im Speicher, aber es hat eine Adresse.

1145
01:11:27,310 --> 01:11:33,790
Es ist irgendwo befindet. So unter der Telefonnummer & x, was dieser tut, ist, es gibt uns die Adresse von x.

1146
01:11:33,790 --> 01:11:38,430
Auf diese Weise machen wir Zeiger Punkt, wo x im Speicher befindet.

1147
01:11:38,430 --> 01:11:41,710
Jetzt müssen wir nur noch so etwas wie * x, wir gehen bis 5 zurück.

1148
01:11:41,710 --> 01:11:43,820
Der Stern heißt Dereferenzierung es.

1149
01:11:43,820 --> 01:11:46,640
Sie folgen der Adresse ein und Sie erhalten den Wert von ihm dort gespeichert.

1150
01:11:51,000 --> 01:11:53,310
>> Haben Sie Fragen? Ja?

1151
01:11:53,310 --> 01:11:56,500
[Student] Wenn Sie das nicht tun die 3-spitzen Sache, dauert es noch kompilieren?

1152
01:11:56,500 --> 01:11:59,490
Ja. Wenn Sie das nicht tun die 3-Zeiger Sache, es ist immer noch zu kompilieren,

1153
01:11:59,490 --> 01:12:02,720
aber ich werde Ihnen zeigen, was passiert, in einem zweiten, und ohne das tun,

1154
01:12:02,720 --> 01:12:04,860
das ist, was wir ein Speicherverlust nennen. Sie geben nicht auf das System

1155
01:12:04,860 --> 01:12:07,850
Sichern seinem Speicher, so dass nach einer Weile das Programm wird zu akkumulieren

1156
01:12:07,850 --> 01:12:10,940
Erinnerung, dass es nicht mit, und nichts anderes kann es benutzen.

1157
01:12:10,940 --> 01:12:15,750
Wenn Sie jemals Firefox mit 1,5 Millionen Kilobyte auf Ihrem Computer gesehen haben,

1158
01:12:15,750 --> 01:12:17,840
im Task-Manager ist das, was vor sich geht.

1159
01:12:17,840 --> 01:12:20,760
Sie haben einen Speicherverlust in dem Programm, dass sie nicht die Handhabung.

1160
01:12:23,080 --> 01:12:26,240
Also, wie funktioniert Zeigerarithmetik Arbeit?

1161
01:12:26,240 --> 01:12:29,480
Nun, das ist Zeigerarithmetik Art wie die Indizierung in einem Array.

1162
01:12:29,480 --> 01:12:36,370
In diesem Fall habe ich einen Zeiger, und was ich mache ist, dass ich einen Zeiger auf das erste Element

1163
01:12:36,370 --> 01:12:42,100
dieses Arrays von 3 Zahlen, die ich zugewiesen.

1164
01:12:42,100 --> 01:12:46,670
So, jetzt, was ich tue, Stern Mauszeiger ändert nur das erste Element in der Liste.

1165
01:12:46,670 --> 01:12:49,140
Star Pointer +1 Punkte hier.

1166
01:12:49,140 --> 01:12:53,140
So Mauszeiger über hier ist, Zeiger ein Ende ist hier, ist Zeiger 2 hier.

1167
01:12:53,140 --> 01:12:56,610
>> Also nur die Zugabe von 1 ist die gleiche wie die sich entlang dieses Arrays.

1168
01:12:56,610 --> 01:12:59,880
Was wir tun müssen, ist, wenn wir Zeiger ein bekommt man die Adresse hier rüber,

1169
01:12:59,880 --> 01:13:04,180
und um den Wert in hier zu bekommen, setzen Sie einen Stern in der gesamten Ausdrucks

1170
01:13:04,180 --> 01:13:05,990
um es dereferenzieren.

1171
01:13:05,990 --> 01:13:09,940
Also, in diesem Fall, ich Einstellen der ersten Stelle in diesem Array Anspruch 1,

1172
01:13:09,940 --> 01:13:13,970
zweiten Stelle bis 2 und dritten Stelle bis 3 ist.

1173
01:13:13,970 --> 01:13:18,180
Dann, was ich tue hier ist, dass ich zum Ausdrucken unserer Zeiger +1,

1174
01:13:18,180 --> 01:13:19,970
das gibt mir nur 2.

1175
01:13:19,970 --> 01:13:23,650
Jetzt bin ich Inkrementieren Zeiger, so Zeiger gleich Zeiger +1,

1176
01:13:23,650 --> 01:13:26,780
was bewegt sie sich vorwärts.

1177
01:13:26,780 --> 01:13:30,810
Und jetzt, wenn ich ausdrucken Zeiger +1, ist Zeiger ein nun 3,

1178
01:13:30,810 --> 01:13:33,990
die in diesem Fall drei druckt.

1179
01:13:33,990 --> 01:13:36,560
Und um kostenlos etwas, der Zeiger, dass ich es geben

1180
01:13:36,560 --> 01:13:40,540
muss am Anfang des Arrays, die ich zurück von malloc zeigen.

1181
01:13:40,540 --> 01:13:43,430
Also, in diesem Fall, wenn ich 3 rechts hier nennen würde, wäre dies nicht richtig sein,

1182
01:13:43,430 --> 01:13:45,070
denn es ist in der Mitte des Arrays.

1183
01:13:45,070 --> 01:13:48,820
Ich habe zu subtrahieren, um zum ursprünglichen Standort zu erhalten

1184
01:13:48,820 --> 01:13:50,420
die anfängliche erste Stelle vor, ich kann es zu befreien.

1185
01:13:56,300 --> 01:13:58,450
So, hier ist ein komplizierteres Beispiel.

1186
01:13:58,450 --> 01:14:03,360
In diesem Fall sind wir Zuteilung 7 Zeichen in einer Zeichen-Array.

1187
01:14:03,360 --> 01:14:06,480
>> Und in diesem Fall, was wir tun ist, dass wir über die ersten 6 von ihnen Looping,

1188
01:14:06,480 --> 01:14:09,900
und wir setzen sie Z.

1189
01:14:09,900 --> 01:14:13,350
Also, für int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
So, Zeiger + i wird nur uns, in diesem Fall,

1191
01:14:16,220 --> 01:14:20,860
Zeiger, Zeiger 1, 2 Zeiger, Zeiger 3, und so weiter und so fort in der Schleife.

1192
01:14:20,860 --> 01:14:24,040
Was es tun werden, ist es kommt, dass die Adresse, dereferenziert es um den Wert zu erhalten,

1193
01:14:24,040 --> 01:14:27,440
und Änderungen, die Wert auf einen Z.

1194
01:14:27,440 --> 01:14:30,350
Dann am Ende vergessen, das ist eine Zeichenkette, nicht wahr?

1195
01:14:30,350 --> 01:14:33,560
Alle Strings müssen mit dem null abschließende Zeichen enden.

1196
01:14:33,560 --> 01:14:38,620
Also, was ich tue, ist in Zeiger 6 ich die null Endzeichen setzen in.

1197
01:14:38,620 --> 01:14:43,980
Und jetzt, was ich im Grunde tun als hier printf Umsetzung für eine Zeichenfolge, nicht wahr?

1198
01:14:43,980 --> 01:14:46,190
>> Also, wenn printf jetzt, wenn es das Ende eines Strings erreicht?

1199
01:14:46,190 --> 01:14:48,230
Wenn es die null abschließende Zeichen trifft.

1200
01:14:48,230 --> 01:14:52,030
Also, in diesem Fall, meine ursprünglichen Zeiger zeigt auf den Anfang dieses Arrays.

1201
01:14:52,030 --> 01:14:56,410
Ich drucke das erste Zeichen aus. Ich bewege sie über ein.

1202
01:14:56,410 --> 01:14:58,420
Ich drucke diesen Charakter aus. Ich bewege es vorbei.

1203
01:14:58,420 --> 01:15:02,180
Und ich halte dies zu tun, bis ich das Ende zu erreichen.

1204
01:15:02,180 --> 01:15:07,750
Und nun ist das Ende * Zeiger dereferenzieren dies und nutzen Sie die null abschließende Zeichen zurück.

1205
01:15:07,750 --> 01:15:11,780
Und so meine while-Schleife läuft nur, wenn dieser Wert nicht die null abschließende Zeichen.

1206
01:15:11,780 --> 01:15:13,770
So, jetzt beende ich aus dieser Schleife.

1207
01:15:18,780 --> 01:15:21,180
Und so, wenn ich subtrahieren 6 von diesem Zeiger,

1208
01:15:21,180 --> 01:15:22,860
Ich gehe den ganzen Weg zurück an den Anfang.

1209
01:15:22,860 --> 01:15:27,880
Denken Sie daran, ich tue dies, weil ich an den Anfang zu gehen, um sie zu befreien.

1210
01:15:27,880 --> 01:15:30,270
>> Also, ich weiß, das war eine Menge. Gibt es irgendwelche Fragen?

1211
01:15:30,270 --> 01:15:31,870
Bitte, ja?

1212
01:15:31,870 --> 01:15:36,610
[Studenten Frage unverständlich]

1213
01:15:36,610 --> 01:15:38,190
Können Sie sagen, dass lauter? Entschuldigung.

1214
01:15:38,190 --> 01:15:44,140
[Student] Auf der letzten Folie rechts, bevor Sie den Mauszeiger befreit,

1215
01:15:44,140 --> 01:15:47,300
wo waren Sie tatsächlich ändern Sie den Wert des Zeigers?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] So, genau hier. >> [Student] Oh, okay.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Also, ich habe einen Zeiger minus minus, rechts,

1218
01:15:51,890 --> 01:15:54,140
was bewegt die Sache wieder ein, und dann bin ich frei, damit,

1219
01:15:54,140 --> 01:15:57,000
weil diese Zeiger hat, um zum Anfang des Arrays hingewiesen werden.

1220
01:15:57,000 --> 01:16:00,420
[Student] Aber das wäre nicht nötig hatten Sie nach dieser Zeile gestoppt werden.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Also, wenn ich nach dieser aufgehört hatte, wäre dies als ein Speicherverlust werden,

1222
01:16:03,130 --> 01:16:04,810
weil ich nicht laufen frei.

1223
01:16:04,810 --> 01:16:11,290
[Student] I [unverständlich] nach den ersten drei Zeilen, wo Sie hatte Zeiger +1 [unverständlich].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-huh. Also, was ist die Frage da?

1225
01:16:13,140 --> 01:16:14,780
Entschuldigung. Nein nein. Geh, geh, bitte.

1226
01:16:14,780 --> 01:16:16,870
[Student] So, du bist nicht ändern Sie den Wert von Zeigern.

1227
01:16:16,870 --> 01:16:19,130
Sie hätte nicht Zeiger minus minus tun haben.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Ja, genau.

1229
01:16:19,730 --> 01:16:21,890
Also, wenn ich Zeiger 1 und Zeiger 2 zu tun,

1230
01:16:21,890 --> 01:16:24,410
Ich mache das nicht Zeigers entspricht Zeiger +1.

1231
01:16:24,410 --> 01:16:27,260
So bleibt der Zeiger gerade zu Beginn des Arrays verbunden.

1232
01:16:27,260 --> 01:16:31,460
Es ist nur, wenn I plus zu tun und dass es setzt den Wert wieder in den Zeiger,

1233
01:16:31,460 --> 01:16:33,550
dass es tatsächlich bewegt diese entlang.

1234
01:16:36,860 --> 01:16:37,780
Gut.

1235
01:16:40,550 --> 01:16:42,030
Noch Fragen?

1236
01:16:44,680 --> 01:16:47,790
>> Auch wenn dies ist eine Art von überwältigender, wird dies in der Sitzung abgedeckt werden.

1237
01:16:47,790 --> 01:16:50,710
Fragen Sie Ihren Unterricht Kollegen darüber, und wir können Fragen am Ende beantworten.

1238
01:16:53,510 --> 01:16:56,600
Und in der Regel die wir nicht mögen, um dieses minus tun.

1239
01:16:56,600 --> 01:16:59,760
Dies hat zu verlangen, mich zu verfolgen, wie viel ich in der Array-Offset.

1240
01:16:59,760 --> 01:17:04,520
Also, in der Regel ist dies nur, wie Zeigerarithmetik Werke erklären.

1241
01:17:04,520 --> 01:17:07,970
Aber was wir normalerweise tun möchte ist, dass wir gerne eine Kopie des Zeigers zu schaffen,

1242
01:17:07,970 --> 01:17:11,640
und dann werden wir diese Kopie, wenn wir bewegen uns in die Zeichenkette.

1243
01:17:11,640 --> 01:17:14,660
Also, in diesen Fall verwenden Sie die Kopie, um die gesamte Zeichenfolge zu drucken,

1244
01:17:14,660 --> 01:17:19,040
aber wir wissen nicht wie Zeiger minus 6 zu tun oder zu verfolgen, wie viel wir zogen in diesem,

1245
01:17:19,040 --> 01:17:22,700
nur weil wir wissen, dass unsere ursprünglichen Punkt noch an den Anfang der Liste hingewiesen

1246
01:17:22,700 --> 01:17:25,340
und alles, was wir verändert war diese Kopie.

1247
01:17:25,340 --> 01:17:28,250
So im Allgemeinen, zu verändern Kopien Ihrer ursprünglichen Zeiger.

1248
01:17:28,250 --> 01:17:32,350
Versuchen Sie nicht, der, wie zu sortieren - tun nicht verändern ursprünglichen Exemplaren.

1249
01:17:32,350 --> 01:17:35,290
Der Versuch, nur Kopien der ursprünglichen verändern.

1250
01:17:41,540 --> 01:17:44,870
So stellen Sie fest, wenn wir den String in printf übergeben

1251
01:17:44,870 --> 01:17:48,990
Sie müssen nicht um einen Stern vor sich legte, wie wir mit all den anderen dereferences getan, nicht wahr?

1252
01:17:48,990 --> 01:17:54,180
Also, wenn Sie drucken die gesamte Zeichenfolge% s erwartet, ist eine Adresse,

1253
01:17:54,180 --> 01:17:57,610
und in diesem Fall ein Zeiger oder in diesem Fall wie ein Array von Zeichen.

1254
01:17:57,610 --> 01:18:00,330
>> Characters, char * s, und Arrays sind ein und dasselbe.

1255
01:18:00,330 --> 01:18:03,690
Pointer ist Zeichen und Zeichen-Arrays sind ein und dasselbe.

1256
01:18:03,690 --> 01:18:05,720
Und so ist alles, was wir zu tun haben, in Zeiger übergeben.

1257
01:18:05,720 --> 01:18:08,150
Wir müssen nicht in gleicher * Zeiger oder so etwas passieren.

1258
01:18:13,110 --> 01:18:14,930
So sind Arrays und Zeiger die gleiche Sache.

1259
01:18:14,930 --> 01:18:19,160
Wenn du tust so etwas wie x [y] hier für ein Array,

1260
01:18:19,160 --> 01:18:21,960
was es unter der Haube tut, ist es zu sagen, okay, es ist ein Zeichen-Array,

1261
01:18:21,960 --> 01:18:23,690
es ist also ein Zeiger.

1262
01:18:23,690 --> 01:18:26,510
Und so x sind die gleiche Sache,

1263
01:18:26,510 --> 01:18:28,650
und so, was es tut, ist es fügt y nach x,

1264
01:18:28,650 --> 01:18:31,820
das ist das gleiche wie vorwärts in Erinnerung, dass viel.

1265
01:18:31,820 --> 01:18:34,930
Und jetzt x + y gibt uns irgendeine Art von Adresse,

1266
01:18:34,930 --> 01:18:37,570
und wir dereferenzieren die Adresse oder folgen Sie dem Pfeil

1267
01:18:37,570 --> 01:18:41,640
, wo dieser Ort im Speicher ist, und wir erhalten den Wert aus dieser Stelle im Speicher.

1268
01:18:41,640 --> 01:18:43,720
So, so sind diese beiden genau die gleiche Sache.

1269
01:18:43,720 --> 01:18:45,840
Es ist nur ein syntaktischer Zucker.

1270
01:18:45,840 --> 01:18:48,090
Sie tun das gleiche. Sie sind einfach anders Syntaktik für einander.

1271
01:18:51,500 --> 01:18:57,590
>> Also, gehen kann, was mit Zeigern falsch? Wie, eine Menge. Okay. Also, schlechte Dinge.

1272
01:18:57,590 --> 01:19:02,410
Einige schlechte Dinge, die Sie tun können, werden nicht überprüft, wenn Ihr malloc Aufruf liefert null, nicht wahr?

1273
01:19:02,410 --> 01:19:06,560
In diesem Fall bitte ich das System mir zu geben - was ist diese Zahl?

1274
01:19:06,560 --> 01:19:11,200
Wie 2 Milliarden Mal 4, da die Größe eines ganzzahligen 4 Bytes ist.

1275
01:19:11,200 --> 01:19:13,810
Ich frage es wie 8 Milliarde Bytes.

1276
01:19:13,810 --> 01:19:17,270
Natürlich mein Computer ist nicht in der Lage sein, mir so viel Speicher zurück.

1277
01:19:17,270 --> 01:19:20,960
Und wir haben nicht überprüfen, ob diese null ist, so dass, wenn wir zu dereferenzieren es dort zu versuchen -

1278
01:19:20,960 --> 01:19:24,270
folgen Sie dem Pfeil, wo es wird - haben wir nicht, dass der Speicher.

1279
01:19:24,270 --> 01:19:27,150
Dies ist, was wir Dereferenzierung eines Null-Zeiger aufrufen.

1280
01:19:27,150 --> 01:19:29,710
Und dies im Wesentlichen verursacht Sie segfault.

1281
01:19:29,710 --> 01:19:31,790
Dies ist eine der Möglichkeiten, wie Sie segfault.

1282
01:19:34,090 --> 01:19:38,090
Andere schlechte Dinge, die Sie tun können - oh well.

1283
01:19:38,090 --> 01:19:40,650
Das war Dereferenzierung eines NULL-Zeiger. Okay.

1284
01:19:40,650 --> 01:19:45,160
Andere schlechte Dinge - ja, zu beheben, dass Sie nur ein Häkchen drin

1285
01:19:45,160 --> 01:19:46,980
dass überprüft, ob der Zeiger NULL ist

1286
01:19:46,980 --> 01:19:51,000
und verlassen Sie aus dem Programm, wenn es passiert, dass malloc gibt ein NULL-Zeiger.

1287
01:19:55,110 --> 01:19:59,850
Das ist die xkcd Comic. Die Leute verstehen es jetzt. Irgendwie.

1288
01:20:06,120 --> 01:20:09,350
>> So Speicher. Und ich ging über diese.

1289
01:20:09,350 --> 01:20:12,000
Wir nennen malloc in einer Schleife, aber jedes Mal, wir rufen malloc

1290
01:20:12,000 --> 01:20:14,370
wir verlieren den Überblick, wo diese Zeiger verweist,

1291
01:20:14,370 --> 01:20:15,750
weil wir verprügeln sie.

1292
01:20:15,750 --> 01:20:18,410
So gibt der erste Aufruf von malloc mich Speicher über hier.

1293
01:20:18,410 --> 01:20:19,990
Meine Zeiger Zeiger auf diese.

1294
01:20:19,990 --> 01:20:23,020
Nun, ich weiß nicht befreien sie, so dass ich jetzt rufen malloc wieder.

1295
01:20:23,020 --> 01:20:26,070
Nun weist hier. Jetzt mein Gedächtnis zeigen hier.

1296
01:20:26,070 --> 01:20:27,640
Pointing hier. Pointing hier.

1297
01:20:27,640 --> 01:20:31,820
Aber ich habe den Überblick über die Adressen aller dem Speicher über hier, dass ich zugeteilt verloren.

1298
01:20:31,820 --> 01:20:35,100
Und so jetzt habe ich keinen Bezug auf sie nicht mehr.

1299
01:20:35,100 --> 01:20:37,230
Also, ich kann nicht befreien sie außerhalb dieser Schleife.

1300
01:20:37,230 --> 01:20:39,390
Und so, um zu beheben etwas wie dieses,

1301
01:20:39,390 --> 01:20:42,250
wenn Sie vergessen, um Speicher frei und Sie erhalten diesen Speicherverlust,

1302
01:20:42,250 --> 01:20:45,810
Sie müssen den Speicher innerhalb dieser Schleife zu befreien, wenn Sie damit fertig sind.

1303
01:20:45,810 --> 01:20:51,400
Nun, das ist, was passiert. Ich weiß, viele von euch hasse es.

1304
01:20:51,400 --> 01:20:55,270
Aber jetzt - yay! Sie erhalten wie 44.000 Kilobyte.

1305
01:20:55,270 --> 01:20:57,110
So befreien Sie es am Ende der Schleife

1306
01:20:57,110 --> 01:20:59,770
und dass geht nur den Speicher frei jeder Zeit.

1307
01:20:59,770 --> 01:21:03,620
Im Wesentlichen ist das Programm nicht zu einem Speicherverlust mehr.

1308
01:21:03,620 --> 01:21:08,150
>> Und jetzt etwas, was Sie tun können, ist zu befreien etwas Speicher, die Sie für zweimal bitten.

1309
01:21:08,150 --> 01:21:11,060
In diesem Fall müssen Sie malloc etwas, ändern Sie den Wert.

1310
01:21:11,060 --> 01:21:13,140
Sie befreien es einmal, weil Sie sagten, Sie mit ihm fertig waren.

1311
01:21:13,140 --> 01:21:14,940
Aber dann haben wir befreit ihn wieder.

1312
01:21:14,940 --> 01:21:16,730
Dies ist etwas, das ziemlich schlecht ist.

1313
01:21:16,730 --> 01:21:18,820
Es wird nicht zunächst segfault,

1314
01:21:18,820 --> 01:21:23,350
aber nach einer Weile, was dies ist doppelt die Freigabe der korrumpiert Ihren Heap-Struktur,

1315
01:21:23,350 --> 01:21:27,200
und du wirst ein wenig mehr darüber zu erfahren dies, wenn Sie eine Klasse wie CS61 nehmen möchten.

1316
01:21:27,200 --> 01:21:30,000
Aber im Grunde nach einer Weile Ihren Computer wird verwirrt

1317
01:21:30,000 --> 01:21:33,010
Über das, was Speicherplätze, wo und wo sie gespeichert -

1318
01:21:33,010 --> 01:21:34,800
wo Daten im Speicher abgelegt.

1319
01:21:34,800 --> 01:21:38,080
Und so befreiend einen Zeiger zweimal eine schlechte Sache ist, dass Sie nicht wollen, zu tun.

1320
01:21:38,080 --> 01:21:41,600
>> Andere Dinge, die schief gehen können, ist nicht mit sizeof.

1321
01:21:41,600 --> 01:21:44,460
Also, in diesem Fall, dass Sie malloc 8 Bytes,

1322
01:21:44,460 --> 01:21:46,700
und das ist das Gleiche wie zwei Zahlen, nicht wahr?

1323
01:21:46,700 --> 01:21:49,580
Also, das ist vollkommen sicher, aber ist es?

1324
01:21:49,580 --> 01:21:52,160
Nun, wie Lucas sprach über auf verschiedenen Architekturen,

1325
01:21:52,160 --> 01:21:54,220
Ganzzahlen sind unterschiedlich lang.

1326
01:21:54,220 --> 01:21:57,970
So, auf das Gerät, dass Sie verwenden, sind ganze Zahlen etwa 4 Bytes,

1327
01:21:57,970 --> 01:22:02,370
aber auf einem anderen System, das sie vielleicht 8 Byte sein oder sie könnte 16 Byte sein.

1328
01:22:02,370 --> 01:22:05,680
Also, wenn ich nur diese Nummer hier,

1329
01:22:05,680 --> 01:22:07,310
Dieses Programm könnte auf dem Gerät zu arbeiten,

1330
01:22:07,310 --> 01:22:10,360
aber es ist nicht genug Speicher auf einem anderen System zuzuweisen.

1331
01:22:10,360 --> 01:22:14,020
In diesem Fall ist das, was die sizeof Operator verwendet wird.

1332
01:22:14,020 --> 01:22:16,880
Wenn wir nennen sizeof (int), was diese tut, ist

1333
01:22:16,880 --> 01:22:21,910
 es gibt uns die Größe eines Integer auf dem System, dass das Programm läuft.

1334
01:22:21,910 --> 01:22:25,490
Also, in diesem Fall wird sizeof (int) 4 auf etwas wie das Gerät zurückzukehren,

1335
01:22:25,490 --> 01:22:29,980
und jetzt dieser Wille 4 * 2, die 8 ist,

1336
01:22:29,980 --> 01:22:32,330
das ist genau die Menge an notwendigen Raum für zwei Ganzzahlen.

1337
01:22:32,330 --> 01:22:36,710
Auf einem anderen System, wenn ein int ist wie 16 Byte oder 8 Byte,

1338
01:22:36,710 --> 01:22:39,380
ist es nur geht, um genügend Bytes zurück, diesen Betrag zu speichern.

1339
01:22:41,830 --> 01:22:45,310
>> Und schließlich Strukturen.

1340
01:22:45,310 --> 01:22:48,340
Also, wenn Sie ein sudoku Bord im Speicher ablegen wollte, könnte, wie wir das tun?

1341
01:22:48,340 --> 01:22:51,570
Sie können sich wie eine Variable für das erste, was zu denken,

1342
01:22:51,570 --> 01:22:53,820
eine Variable für die zweite Sache, eine Variable für die dritte Sache,

1343
01:22:53,820 --> 01:22:56,420
eine Variable für die vierte Sache - schlecht, oder?

1344
01:22:56,420 --> 01:23:00,750
Also, das ist ein Verbesserung, die Sie oben auf dieser machen kann, um eine 9 x 9 Gitter machen.

1345
01:23:00,750 --> 01:23:04,480
Das ist in Ordnung, aber was, wenn Sie wollte andere Dinge mit dem Sudoku Bord zu verknüpfen

1346
01:23:04,480 --> 01:23:06,490
wie das, was die Schwierigkeit der Karte ist,

1347
01:23:06,490 --> 01:23:11,740
oder, zum Beispiel, was Ihre Gäste ist, oder wie viel Zeit es genommen Sie dieses Board zu lösen?

1348
01:23:11,740 --> 01:23:14,970
Nun, was Sie tun können, ist, können Sie eine Struktur erstellen.

1349
01:23:14,970 --> 01:23:18,910
Was ich im Grunde sagen, ist, dass ich die Definition dieser Struktur über hier

1350
01:23:18,910 --> 01:23:23,230
und ich bin Definieren eines Sudoku Bord, die aus einer Platine, die 9 ist x 9 besteht.

1351
01:23:23,230 --> 01:23:26,650
>> Und was hat es hat es Zeiger auf den Namen der Ebene.

1352
01:23:26,650 --> 01:23:30,730
Es hat auch x und y, die die Koordinaten, wo ich bin gerade sind.

1353
01:23:30,730 --> 01:23:35,980
Es hat auch Zeit [unverständlich] verbracht, und es hat die Gesamtzahl der Züge, die ich bisher eingegeben.

1354
01:23:35,980 --> 01:23:40,010
Und so in diesem Fall kann ich eine ganze Reihe von Daten in nur einer Konzernstruktur

1355
01:23:40,010 --> 01:23:42,790
anstatt es wie herumfliegen wie verschiedene Variablen

1356
01:23:42,790 --> 01:23:44,540
dass ich nicht wirklich im Auge behalten.

1357
01:23:44,540 --> 01:23:49,720
Und das lässt uns haben nur nette Syntax für Art verweisen verschiedene Dinge in dieser Struktur.

1358
01:23:49,720 --> 01:23:53,430
Ich kann nur tun board.board, und ich bekomme das Sudoku Bord zurück.

1359
01:23:53,430 --> 01:23:56,320
Board.level, bekomme ich, wie hart es ist.

1360
01:23:56,320 --> 01:24:00,540
Board.x und board.y mir die Koordinaten, wo ich vielleicht in der Bord sein.

1361
01:24:00,540 --> 01:24:04,730
Und so bin ich Zugriff auf das, was wir Felder in der Struktur nennen.

1362
01:24:04,730 --> 01:24:08,840
Dies definiert sudokuBoard, die eine Art, die ich habe ist.

1363
01:24:08,840 --> 01:24:14,800
Und jetzt sind wir hier. Ich habe eine Variable namens "board" vom Typ sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
Und so kann ich jetzt Zugriff auf alle Felder, die diese Struktur hier.

1365
01:24:20,830 --> 01:24:22,450
>> Fragen über Strukturen? Ja?

1366
01:24:22,450 --> 01:24:25,890
[Student] Für int x, y, erklärte sie beide auf einer Linie? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Student] So könnte man nur tun, dass mit ihnen allen?

1368
01:24:27,400 --> 01:24:31,200
Wie in x, y Komma mal, dass insgesamt?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Ja, man könnte auf jeden Fall tun, aber der Grund, ich habe x-und y auf der gleichen Linie -

1370
01:24:34,460 --> 01:24:36,330
und die Frage ist, warum können wir nur tun dies auf der gleichen Linie?

1371
01:24:36,330 --> 01:24:38,600
Warum gehen wir nicht gerade auf all diese auf der gleichen Linie liegt

1372
01:24:38,600 --> 01:24:42,090
x und y sind miteinander verwandt,

1373
01:24:42,090 --> 01:24:44,780
und dies ist nur stilistisch richtig, in gewissem Sinne,

1374
01:24:44,780 --> 01:24:46,600
weil es Gruppierung zwei Dinge auf der gleichen Linie

1375
01:24:46,600 --> 01:24:49,340
dass wie Art auf dasselbe beziehen.

1376
01:24:49,340 --> 01:24:51,440
Und ich aufgeteilt diese auseinander. Es ist nur ein Stil Sache.

1377
01:24:51,440 --> 01:24:53,720
Es funktional macht überhaupt keinen Unterschied.

1378
01:24:58,150 --> 01:24:59,270
Alle anderen Fragen über Strukturen?

1379
01:25:03,030 --> 01:25:06,620
Sie können einen Pokédex mit einem struct definieren.

1380
01:25:06,620 --> 01:25:11,720
Ein Pokémon hat eine Reihe und es hat einen Brief, ein Besitzer, ein Typ.

1381
01:25:11,720 --> 01:25:16,990
Und dann, wenn Sie eine Reihe von Pokémon haben, können Sie machen einen Pokédex, nicht wahr?

1382
01:25:16,990 --> 01:25:20,810
Okay, cool. Also Fragen über Strukturen. Das sind im Zusammenhang mit Strukturen.

1383
01:25:20,810 --> 01:25:25,270
>> Schließlich GDB. Was bedeutet GDB können Sie tun? Damit können Sie Ihr Programm testen.

1384
01:25:25,270 --> 01:25:27,650
Und wenn Sie nicht GDB verwendet haben, würde ich empfehlen gerade die kurzen

1385
01:25:27,650 --> 01:25:31,250
und gerade gehen über das, was GDB ist, wie man mit ihr arbeiten, wie Sie es benutzen,

1386
01:25:31,250 --> 01:25:32,900
und testen Sie es an einem Programm.

1387
01:25:32,900 --> 01:25:37,400
Und so was GDB können Sie tun, ist es lässt Pause die [unverständlich] Ihr Programm

1388
01:25:37,400 --> 01:25:38,920
und eine praktische Linie.

1389
01:25:38,920 --> 01:25:42,600
Zum Beispiel möchte ich eine Pause Ausführung an wie Linie 3 von meinem Programm,

1390
01:25:42,600 --> 01:25:46,010
und während ich in Zeile 3 bin ich ausdrucken können alle Werte, die es gibt.

1391
01:25:46,010 --> 01:25:49,710
Und so wie wir es nennen, wie Pause in einer Linie

1392
01:25:49,710 --> 01:25:52,350
wird nennen wir diese setzen einen Haltepunkt an dieser Linie

1393
01:25:52,350 --> 01:25:55,920
und dann können wir drucken Sie die Variablen auf den Zustand des Programms zu diesem Zeitpunkt.

1394
01:25:55,920 --> 01:25:58,990
>> Wir können dann von dort fort durch das Programm Zeile-für-Zeile.

1395
01:25:58,990 --> 01:26:03,200
Und dann können wir im Zustand des Stapels zu der Zeit zu sehen.

1396
01:26:03,200 --> 01:26:08,600
Und so, um zu benutzen GDB, was wir tun, wir nennen Klang auf der C-Datei,

1397
01:26:08,600 --> 01:26:11,290
aber wir müssen weitergeben the-ggdb Flagge.

1398
01:26:11,290 --> 01:26:15,850
Und wenn wir fertig sind mit, dass wir nur laufen gdb auf die resultierende Ausgabedatei.

1399
01:26:15,850 --> 01:26:18,810
Und so erhalten Sie eine Masse von Texten wie diesem,

1400
01:26:18,810 --> 01:26:21,990
aber wirklich alles, was Sie tun müssen, ist in Befehle an den Anfang geben.

1401
01:26:21,990 --> 01:26:24,250
Break main setzt einen Haltepunkt an main.

1402
01:26:24,250 --> 01:26:28,470
Liste 400 listet die Zeilen Code um Zeile 400.

1403
01:26:28,470 --> 01:26:31,410
Und so in diesem Fall können Sie einfach umschauen und sagen, oh,

1404
01:26:31,410 --> 01:26:34,360
Ich möchte einen Breakpoint in Zeile 397, die diese Zeile gesetzt,

1405
01:26:34,360 --> 01:26:37,170
und Ihr Programm läuft in diesem Schritt und es geht zu brechen.

1406
01:26:37,170 --> 01:26:41,120
Es ist zu pausieren dort vor sich geht, und Sie können drucken, zum Beispiel mit einem Wert von niedrig oder hoch.

1407
01:26:41,120 --> 01:26:46,410
Und so gibt es eine Reihe von Befehlen, die Sie wissen müssen,

1408
01:26:46,410 --> 01:26:48,660
und diese Slideshow gehen bis auf der Website,

1409
01:26:48,660 --> 01:26:54,000
so wenn Sie nur wollen, um diese zu verweisen oder wie sie auf Ihrem Spickzettel, sich frei fühlen.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Das war Quiz Bewertung 0, und wir werden bleiben, um, wenn Sie irgendwelche Fragen haben.

1411
01:27:00,650 --> 01:27:03,850
Gut.

1412
01:27:03,850 --> 01:27:09,030
>>  [Applaus]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]