1
00:00:00,000 --> 00:00:06,030
>> [Musikwiedergabe]

2
00:00:06,030 --> 00:00:08,390
>> DOUG LLOYD: Zeiger, hier sind wir.

3
00:00:08,390 --> 00:00:11,080
Dies ist wahrscheinlich zu
das schwierigste Thema

4
00:00:11,080 --> 00:00:12,840
dass wir etwa in CS50 sprechen.

5
00:00:12,840 --> 00:00:15,060
Und wenn Sie gelesen haben,
etwas über Zeiger

6
00:00:15,060 --> 00:00:19,080
bevor Sie vielleicht ein kleines bisschen zu sein
Einschüchterungen gehen in diesem Video.

7
00:00:19,080 --> 00:00:21,260
Es ist wahr, die Zeiger
Sie ermöglichen Ihnen die Möglichkeit,

8
00:00:21,260 --> 00:00:23,740
vielleicht vermasseln
ziemlich schlecht, wenn Sie

9
00:00:23,740 --> 00:00:27,450
Arbeiten mit Variablen und Daten,
und was Ihr Programm zum Absturz bringen.

10
00:00:27,450 --> 00:00:30,490
Aber sie sind wirklich sehr nützlich,
und sie haben uns eine wirklich gute Möglichkeit zulassen

11
00:00:30,490 --> 00:00:33,340
In den Datendurchlauf zurück und
her zwischen Funktionen,

12
00:00:33,340 --> 00:00:35,490
dass wir nichts anderes sind nicht in der Lage zu tun.

13
00:00:35,490 --> 00:00:37,750
>> Und so, was wir wirklich
will hier tun, ist Zug

14
00:00:37,750 --> 00:00:41,060
Sie gute Zeiger Disziplin haben, so
dass man Zeiger effektiv zu nutzen

15
00:00:41,060 --> 00:00:43,850
um Ihre Programme, die viel besser.

16
00:00:43,850 --> 00:00:48,220
Wie ich schon sagte Zeiger geben uns eine andere
Weg, um Daten zwischen Funktionen übergeben.

17
00:00:48,220 --> 00:00:50,270
Nun, wenn Sie von erinnern
eine frühere Video, wenn

18
00:00:50,270 --> 00:00:53,720
wir sprachen
Geltungsbereich von Variablen, erwähnte ich

19
00:00:53,720 --> 00:01:00,610
dass alle Daten, die wir zwischen übergeben
Funktionen in C wird als Wert übergeben.

20
00:01:00,610 --> 00:01:03,070
Und ich kann nicht verwendet haben, dass
tigen, was ich dort gemeint

21
00:01:03,070 --> 00:01:07,170
war, dass wir vorbei Kopien von Daten.

22
00:01:07,170 --> 00:01:12,252
Wenn wir eine Variable an eine Funktion,
wir sind nicht wirklich das Bestehen der variable

23
00:01:12,252 --> 00:01:13,210
auf die Funktion, nicht wahr?

24
00:01:13,210 --> 00:01:17,670
Wir Weitergabe einer Kopie
daß Daten an die Funktion.

25
00:01:17,670 --> 00:01:20,760
Die Funktion tut, was sie will
und es berechnet einen Wert,

26
00:01:20,760 --> 00:01:23,180
und vielleicht setzen wir diesen Wert
wenn es gibt sie zurück.

27
00:01:23,180 --> 00:01:26,700
>> Es gab eine Ausnahme
diese Regel der Übergabe als Wert,

28
00:01:26,700 --> 00:01:31,210
und wir werden uns auf das, was kommt, dass
ist ein wenig später in diesem Video.

29
00:01:31,210 --> 00:01:34,880
Wenn wir statt Zeigern
der Verwendung von Variablen,

30
00:01:34,880 --> 00:01:38,180
oder anstelle der Verwendung der Variablen
selbst oder Kopien der Variablen,

31
00:01:38,180 --> 00:01:43,790
Wir können nun die Variablen in der Umgebung übergeben
zwischen Funktionen in einer anderen Weise.

32
00:01:43,790 --> 00:01:46,550
Dies bedeutet, dass, wenn wir
eine Änderung in einer Funktion,

33
00:01:46,550 --> 00:01:49,827
diese Änderung tatsächlich statt
Effekt in einer anderen Funktion.

34
00:01:49,827 --> 00:01:52,160
Auch dies ist etwas, das
wir konnten nicht vorher tun,

35
00:01:52,160 --> 00:01:56,979
und wenn Sie jemals versucht haben, der Swap-
Wert von zwei Variablen in einer Funktion,

36
00:01:56,979 --> 00:01:59,270
Sie dieses Problem aufgefallen,
Art kroch, nicht wahr?

37
00:01:59,270 --> 00:02:04,340
>> Wenn wir X und Y, und wir tauschen wollen
leiten sie an eine Funktion namens swap,

38
00:02:04,340 --> 00:02:08,680
innerhalb der Funktion Swap-
Variablen zu tun Tauschwerten.

39
00:02:08,680 --> 00:02:12,600
Man wird zwei, zwei wird
, aber wir nicht wirklich

40
00:02:12,600 --> 00:02:16,890
etwas zu ändern in der Original
Funktion in dem Anrufer.

41
00:02:16,890 --> 00:02:19,550
Denn wir können nicht, wir sind nur
Arbeiten mit Kopien von ihnen.

42
00:02:19,550 --> 00:02:24,760
Mit Zeigern wenn, können wir
tatsächlich passieren X und Y auf eine Funktion.

43
00:02:24,760 --> 00:02:26,960
Diese Funktion tun können
etwas mit ihnen.

44
00:02:26,960 --> 00:02:29,250
Und die Variablen-Werte
kann tatsächlich zu ändern.

45
00:02:29,250 --> 00:02:33,710
Also das ist ganz eine Änderung
unsere Fähigkeit, mit den Daten zu arbeiten.

46
00:02:33,710 --> 00:02:36,100
>> Bevor wir uns in die
Zeiger, ich denke, es lohnt sich

47
00:02:36,100 --> 00:02:38,580
nehmen einige Minuten, um
gehen Sie zurück zu den Grundlagen hier.

48
00:02:38,580 --> 00:02:41,000
Und haben einen Blick auf, wie
Computer-Speicher-Werke

49
00:02:41,000 --> 00:02:45,340
weil diese beiden Themen gehen
tatsächlich ziemlich miteinander verknüpft.

50
00:02:45,340 --> 00:02:48,480
Wie Sie wahrscheinlich wissen,
auf Ihrem Computersystem

51
00:02:48,480 --> 00:02:51,310
Sie eine Festplatte haben, oder
vielleicht ein Solid State Drive,

52
00:02:51,310 --> 00:02:54,430
eine Art von Datei Lagerort.

53
00:02:54,430 --> 00:02:57,950
Es ist in der Regel irgendwo in der
Nachbarschaft von 250 Gigabyte

54
00:02:57,950 --> 00:02:59,810
um vielleicht ein paar Terabyte jetzt.

55
00:02:59,810 --> 00:03:02,270
Und es ist, wo alle Ihre
Dateien letztendlich zu leben,

56
00:03:02,270 --> 00:03:04,870
selbst dann, wenn der Computer herunter
off, können Sie es wieder einschalten

57
00:03:04,870 --> 00:03:09,190
und du wirst finden Sie Ihre Dateien vorhanden sind
wieder, wenn Sie Ihr System neu starten.

58
00:03:09,190 --> 00:03:14,820
Aber der Plattenlaufwerke, wie ein Festplattenlaufwerk,
eine Festplatte oder ein Solid State Drive, SSD,

59
00:03:14,820 --> 00:03:16,050
sind nur Stauraum.

60
00:03:16,050 --> 00:03:20,400
>> Wir können nichts mit tatsächlich tun
die Daten, die in der Festplatte ist,

61
00:03:20,400 --> 00:03:22,080
oder in einem Solid State Drive.

62
00:03:22,080 --> 00:03:24,950
Um tatsächlich ändern
Daten oder bewegen Sie es,

63
00:03:24,950 --> 00:03:28,800
wir müssen es sich zu bewegen
RAM Direktzugriffsspeicher.

64
00:03:28,800 --> 00:03:31,170
Jetzt RAM, eine Menge müssen Sie
weniger in Ihrem Computer.

65
00:03:31,170 --> 00:03:34,185
Sie können irgendwo in der haben
Nachbarschaft von 512 Megabyte

66
00:03:34,185 --> 00:03:38,850
wenn Sie einen älteren Computer haben,
um vielleicht zwei, vier, acht, 16,

67
00:03:38,850 --> 00:03:41,820
vielleicht sogar ein wenig
mehr Gigabyte RAM.

68
00:03:41,820 --> 00:03:46,390
Also das ist viel kleiner, aber das ist
wobei alle flüchtigen Daten vorhanden sind.

69
00:03:46,390 --> 00:03:48,270
Das ist, wo wir die Dinge ändern.

70
00:03:48,270 --> 00:03:53,350
Aber wenn wir uns unserem Computer aus,
alle Daten im RAM zerstört wird.

71
00:03:53,350 --> 00:03:57,150
>> Also das ist, warum wir auf der Festplatte haben,
für die dauerhafte Position der es,

72
00:03:57,150 --> 00:03:59,720
so dass es exists- wäre es
wirklich schlecht, wenn wir jedes Mal

73
00:03:59,720 --> 00:04:03,310
wandte sich unser Computer ausgeschaltet, jeder
Datei in unserem System wurde ausgelöscht.

74
00:04:03,310 --> 00:04:05,600
So arbeiten wir innerhalb des RAM.

75
00:04:05,600 --> 00:04:09,210
Und jedesmal, wenn wir sprechen
Speicher, ziemlich viel, in CS50,

76
00:04:09,210 --> 00:04:15,080
wir über RAM, nicht Festplatte sprechen.

77
00:04:15,080 --> 00:04:18,657
>> Also, wenn wir die Dinge in den Speicher zu verschieben,
es nimmt eine bestimmte Menge an Speicherplatz.

78
00:04:18,657 --> 00:04:20,740
Alle Datentypen,
wir haben mit gearbeitet

79
00:04:20,740 --> 00:04:23,480
nehmen verschiedene
Mengen an Speicherplatz im RAM.

80
00:04:23,480 --> 00:04:27,600
Also jedes Mal, wenn Sie eine ganze Zahl erstellen
Variable vier Byte,

81
00:04:27,600 --> 00:04:30,750
beiseite im RAM gesetzt, so dass Sie
kann mit dieser ganzen Zahl zu arbeiten.

82
00:04:30,750 --> 00:04:34,260
Sie können die ganze Zahl zu erklären,
ändern, weisen Sie

83
00:04:34,260 --> 00:04:36,700
auf einen Wert 10 inkrementiert
nach dem anderen, so weiter und so fort.

84
00:04:36,700 --> 00:04:39,440
Alles, was im passieren, braucht
RAM, und Sie erhalten vier Bytes

85
00:04:39,440 --> 00:04:42,550
, mit für jeden arbeiten
Ganzzahl, die Sie erstellen.

86
00:04:42,550 --> 00:04:45,410
>> Jedes Zeichen, das Sie
erstellen bekommt ein Byte.

87
00:04:45,410 --> 00:04:48,160
Das ist nur, wie viel Platz
erforderlich, um ein Zeichen zu speichern.

88
00:04:48,160 --> 00:04:51,310
Jeder Schwimmer, ein echter
Nummer, bekommt vier Bytes

89
00:04:51,310 --> 00:04:53,390
es sei denn, es ist ein Doppel
precision floating point

90
00:04:53,390 --> 00:04:56,510
Nummer, unter der Sie erlaubt
haben genauere oder mehrere Ziffern

91
00:04:56,510 --> 00:04:59,300
nach dem Komma
ohne dabei Präzision,

92
00:04:59,300 --> 00:05:01,820
was nehmen acht Byte Speicher.

93
00:05:01,820 --> 00:05:06,730
Lang ersehnt, wirklich großen Zahlen,
auch bis acht Byte Speicher.

94
00:05:06,730 --> 00:05:09,000
Wie viele Byte Speicher
Sie Zeichenfolgen aufnehmen?

95
00:05:09,000 --> 00:05:12,990
Nun lassen wir einen Stift in dieser Frage
für jetzt, aber wir werden wieder zurückkommen können.

96
00:05:12,990 --> 00:05:17,350
>> Also zurück zu dieser Idee der Speicher als
ein großes Array von Byte großen Zellen.

97
00:05:17,350 --> 00:05:20,871
Das ist wirklich alles ist, ist es
nur eine riesige Anordnung von Zellen,

98
00:05:20,871 --> 00:05:23,370
wie jedes andere Array,
Sie vertraut sind und sehen,

99
00:05:23,370 --> 00:05:26,430
mit der Ausnahme, jedes Element ist ein Byte breit.

100
00:05:26,430 --> 00:05:30,030
Und genau wie ein Array,
Jedes Element hat eine Adresse.

101
00:05:30,030 --> 00:05:32,120
Jedes Element eines Arrays
hat einen Index, und wir

102
00:05:32,120 --> 00:05:36,302
kann diesen Index verwenden, um zu tun sogenannten
Direktzugriff auf das Array.

103
00:05:36,302 --> 00:05:38,510
Wir haben nicht zu starten
der Anfang des Arrays,

104
00:05:38,510 --> 00:05:40,569
durchlaufen Sie jeden
Einzelelement davon,

105
00:05:40,569 --> 00:05:41,860
zu finden, was wir suchen.

106
00:05:41,860 --> 00:05:45,790
Wir können nur sagen, ich will, um das zu bekommen
15. Element oder das 100. Element.

107
00:05:45,790 --> 00:05:49,930
Und Sie können nur in dieser Zahl übergeben
und erhalten Sie den Wert Sie suchen.

108
00:05:49,930 --> 00:05:54,460
>> Ähnlich jeder Ort
im Speicher hat eine Adresse.

109
00:05:54,460 --> 00:05:57,320
So könnte Ihr Gedächtnis
etwa so aussehen.

110
00:05:57,320 --> 00:06:01,420
Hier ist ein sehr kleines Stück
Speicher ist diese 20 Byte Speicherplatz.

111
00:06:01,420 --> 00:06:04,060
Die ersten 20 Bytes, weil mein
-Adressen gibt am unteren

112
00:06:04,060 --> 00:06:08,890
sind 0, 1, 2, 3 usw.
auf dem ganzen Weg bis zu 19.

113
00:06:08,890 --> 00:06:13,190
Und wenn ich erklären, Variablen und
wenn ich anfange, mit ihnen zu arbeiten,

114
00:06:13,190 --> 00:06:15,470
das System wird sich gesetzt
beiseite etwas Platz für mich

115
00:06:15,470 --> 00:06:17,595
in diesem Speicher, um zu arbeiten
mit meinem Variablen.

116
00:06:17,595 --> 00:06:21,610
So könnte ich sagen, char c gleich der Hauptstadt
H. Und was wird passieren?

117
00:06:21,610 --> 00:06:23,880
Nun ist das System zu gehen
beiseite stellen für mich ein Byte.

118
00:06:23,880 --> 00:06:27,870
In diesem Fall wählte Bytenummer
vier, wird das Byte an der Adresse vier,

119
00:06:27,870 --> 00:06:31,310
und es wird in den Laden
Buchstaben H Hauptstadt in für mich da.

120
00:06:31,310 --> 00:06:34,350
Wenn ich dann sage int Geschwindigkeit
Grenze gleich 65, ist es

121
00:06:34,350 --> 00:06:36,806
werde beiseite vier
Byte Speicher für mich.

122
00:06:36,806 --> 00:06:39,180
Und es geht um diejenigen zu behandeln
vier Bytes als eine Einheit

123
00:06:39,180 --> 00:06:41,305
weil das, was wir arbeiten
mit eine ganze Zahl hier.

124
00:06:41,305 --> 00:06:44,350
Und es geht um 65 dort zu speichern.

125
00:06:44,350 --> 00:06:47,000
>> Jetzt schon Ich bin eine Art
Erzählen Sie ein bisschen eine Lüge,

126
00:06:47,000 --> 00:06:50,150
richtig, denn wir wissen, dass
Computern in binärer.

127
00:06:50,150 --> 00:06:53,100
Sie verstehen nicht,
unbedingt das, was eine Kapital H ist

128
00:06:53,100 --> 00:06:57,110
oder, was ein 65 ist, nur sie
verstehen, Binär-, Nullen und Einsen.

129
00:06:57,110 --> 00:06:59,000
Und so wirklich, was
wir speichern es in

130
00:06:59,000 --> 00:07:03,450
ist nicht die Buchstaben H und die Zahl 65,
sondern die Binärdarstellungen

131
00:07:03,450 --> 00:07:06,980
davon, die aussehen
wenig so etwas wie dieses.

132
00:07:06,980 --> 00:07:10,360
Und insbesondere in der
Rahmen der ganzzahligen Variablen,

133
00:07:10,360 --> 00:07:13,559
es wird nicht nur spucken es in,
es wird nicht, es als ein Vier behandeln

134
00:07:13,559 --> 00:07:15,350
Byte-Chunk unbedingt,
es ist eigentlich los

135
00:07:15,350 --> 00:07:19,570
um es als vier Ein-Byte-Blöcken zu behandeln,
die wie folgt aussehen könnte.

136
00:07:19,570 --> 00:07:22,424
Und auch das ist nicht
vollständig entweder wahr,

137
00:07:22,424 --> 00:07:24,840
wegen der so genannten
ein Endian, die wir nicht

138
00:07:24,840 --> 00:07:26,965
werde in jetzt zu bekommen, aber
Wenn Sie neugierig sind,

139
00:07:26,965 --> 00:07:29,030
können Sie auf etwas zu lesen
und Big Endian.

140
00:07:29,030 --> 00:07:31,640
Aber aus Gründen dieses Arguments
für die Zwecke dieser Video-,

141
00:07:31,640 --> 00:07:34,860
lassen Sie uns einfach davon ausgehen, dass es in
der Tat, wie die Zahl 65 würde

142
00:07:34,860 --> 00:07:36,970
in dargestellt werden
Speicher auf jedem System,

143
00:07:36,970 --> 00:07:38,850
obwohl es nicht ganz richtig.

144
00:07:38,850 --> 00:07:41,700
>> Aber lassen Sie uns eigentlich nur erhalten
aller binären loswerden vollständig,

145
00:07:41,700 --> 00:07:44,460
und nur etwa so denken, H
und 65, ist es viel einfacher

146
00:07:44,460 --> 00:07:47,900
um darüber nachzudenken, wie
daß als Mensch.

147
00:07:47,900 --> 00:07:51,420
Na gut, so scheint es auch vielleicht ein
kleine zufällige dass I've- mein System

148
00:07:51,420 --> 00:07:55,130
hat mich nicht Byte 5, 6, 7 zu geben,
und 8 den Integer gespeichert.

149
00:07:55,130 --> 00:07:58,580
Es gibt einen Grund für das auch, die
Wir werden nicht in diesem Augenblick zu bekommen, aber es genügt

150
00:07:58,580 --> 00:08:00,496
zu sagen, dass, was die
Computer ist hier zu suchen

151
00:08:00,496 --> 00:08:02,810
ist wahrscheinlich ein guter Schritt auf seinem Teil.

152
00:08:02,810 --> 00:08:06,020
Um mich nicht Speicher, der ist zu geben
unbedingt zurück zurück.

153
00:08:06,020 --> 00:08:10,490
Obwohl, es wird es jetzt tun
wenn ich will eine andere Zeichenfolge zu erhalten,

154
00:08:10,490 --> 00:08:13,080
genannt Familienname, und ich möchte,
Lloyd in es gesetzt.

155
00:08:13,080 --> 00:08:18,360
Werde ich brauchen, um einen passen
Charakter, ist jeder Buchstabe, dass

156
00:08:18,360 --> 00:08:21,330
werde ein fordern
Charakter, ein Byte Speicher.

157
00:08:21,330 --> 00:08:26,230
Also, wenn ich konnte Lloyd in mein Array setzen
so bin ich ziemlich gut zu gehen, nicht wahr?

158
00:08:26,230 --> 00:08:28,870
Was fehlt?

159
00:08:28,870 --> 00:08:31,840
>> Denken Sie daran, dass jeder String arbeiten wir
mit in C endet mit umgekehrten Schrägstrich Null,

160
00:08:31,840 --> 00:08:33,339
und wir können es nicht unterlassen, das hier auch nicht.

161
00:08:33,339 --> 00:08:36,090
Wir müssen ein Byte beiseite
des Speichers, dass wir halten,

162
00:08:36,090 --> 00:08:39,130
wissen, wann unsere String beendet ist.

163
00:08:39,130 --> 00:08:41,049
Also noch einmal diese Anordnung
der Lauf der Dinge

164
00:08:41,049 --> 00:08:42,799
erscheint im Speicher Macht
ein wenig zufällig,

165
00:08:42,799 --> 00:08:44,870
aber es ist eigentlich, wie
die meisten Systeme ausgelegt sind.

166
00:08:44,870 --> 00:08:48,330
Um sie reihen sich auf ein Vielfaches
aus vier Gründen wieder

167
00:08:48,330 --> 00:08:50,080
dass wir nicht müssen
erhalten in diesem Augenblick.

168
00:08:50,080 --> 00:08:53,060
Aber dies, so genügt es zu sagen, dass
Nach diesen drei Zeilen von Code,

169
00:08:53,060 --> 00:08:54,810
das ist, was Speicher aussehen könnte.

170
00:08:54,810 --> 00:08:58,930
Wenn ich Speicherplätze
4, 8 und 12, um meine Daten zu halten,

171
00:08:58,930 --> 00:09:01,100
das ist, was mein Gedächtnis aussehen könnte.

172
00:09:01,100 --> 00:09:04,062
>> Und vor allem sein
Wenn hier pedantisch

173
00:09:04,062 --> 00:09:06,020
wir über Speicher sprechen
Adressen wir in der Regel

174
00:09:06,020 --> 00:09:08,390
dies unter Anwendung hexadezimale Notationen.

175
00:09:08,390 --> 00:09:12,030
Also, warum nicht wir konvertieren alle diese
von dezimal in hexadezimal

176
00:09:12,030 --> 00:09:15,010
nur weil das ist in der Regel
wie wir beziehen sich auf Speicher.

177
00:09:15,010 --> 00:09:17,880
Also anstatt 0 bis
19, was wir haben, ist Null

178
00:09:17,880 --> 00:09:20,340
x Null durch Null x1 drei.

179
00:09:20,340 --> 00:09:23,790
Das sind die 20 Byte Speicher, dass wir
haben oder die wir bei in diesem Bild suchen

180
00:09:23,790 --> 00:09:25,540
genau hier.

181
00:09:25,540 --> 00:09:29,310
>> So dass alle von diesem wird gesagt, lassen Sie uns
Schritt weg von Speicher für eine zweite

182
00:09:29,310 --> 00:09:30,490
und zurück nach Zeigern.

183
00:09:30,490 --> 00:09:32,420
Hier ist der wichtigste
Sache zu erinnern,

184
00:09:32,420 --> 00:09:34,070
wie wir die Arbeit mit Zeigern.

185
00:09:34,070 --> 00:09:36,314
Ein Zeiger ist nichts
mehr als eine Adresse.

186
00:09:36,314 --> 00:09:38,230
Ich sage es noch einmal, weil sagen
es ist so wichtig,

187
00:09:38,230 --> 00:09:42,730
ein Zeiger ist nichts
mehr als eine Adresse.

188
00:09:42,730 --> 00:09:47,760
Zeiger sind Adressen, die Stellen
im Speicher, wo Variablen leben.

189
00:09:47,760 --> 00:09:52,590
Zu wissen, dass es hoffentlich wird
wenig einfacher, mit ihnen zu arbeiten.

190
00:09:52,590 --> 00:09:54,550
Eine andere Sache, Ich mag
zu tun ist, sort haben

191
00:09:54,550 --> 00:09:58,510
von Diagrammen visuellen Darstellung, was
geschieht mit verschiedenen Codezeilen.

192
00:09:58,510 --> 00:10:00,660
Und wir werden dies ein paar zu tun
Mal in Zeigern

193
00:10:00,660 --> 00:10:03,354
und wenn wir über die Dynamik sprechen
Speicherzuweisung als auch.

194
00:10:03,354 --> 00:10:06,020
Weil ich denke, dass diese Diagramme
kann besonders hilfreich sein.

195
00:10:06,020 --> 00:10:09,540
>> Also, wenn ich zum Beispiel sagen, int k
in meinem Code, was geschieht?

196
00:10:09,540 --> 00:10:12,524
Nun, was ist im Grunde geschieht
Ich bekomme Speicher beiseite für mich gesetzt,

197
00:10:12,524 --> 00:10:14,690
aber ich weiß nicht einmal gerne
denken Sie darüber so, ich

198
00:10:14,690 --> 00:10:16,300
gerne darüber wie ein Kasten denken.

199
00:10:16,300 --> 00:10:20,090
Ich habe eine Schachtel und es ist
grün gefärbt, weil ich

200
00:10:20,090 --> 00:10:21,750
können ganze Zahlen im grünen Kästchen setzen.

201
00:10:21,750 --> 00:10:23,666
Wenn es ein Charakter, den ich
könnte einen blauen Kasten.

202
00:10:23,666 --> 00:10:27,290
Aber ich sage immer, wenn ich die Schaffung
eine Box, die Zahlen zu halten, kann

203
00:10:27,290 --> 00:10:28,950
dass das Feld grün gefärbt.

204
00:10:28,950 --> 00:10:33,020
Und ich einen Permanentmarker nehmen
und ich schreibe k auf der Seite davon.

205
00:10:33,020 --> 00:10:37,590
So habe ich eine Box genannt k,
in dem ich ganze Zahlen gesetzt.

206
00:10:37,590 --> 00:10:41,070
Wenn ich also sage int k, das ist,
was passiert in meinem Kopf.

207
00:10:41,070 --> 00:10:43,140
Wenn ich sage, k gleich fünf, was mache ich?

208
00:10:43,140 --> 00:10:45,110
Nun, ich bin Putting fünf
in der Box, rechts.

209
00:10:45,110 --> 00:10:48,670
Das ist ziemlich einfach, wenn
Ich sage int k, erstellen Sie ein Feld namens k.

210
00:10:48,670 --> 00:10:52,040
Wenn ich sage, k gleich 5,
legte fünf in die Box.

211
00:10:52,040 --> 00:10:53,865
Hoffentlich ist das nicht zu viel von einem Sprung.

212
00:10:53,865 --> 00:10:55,990
Hier findest Dinge ein
wenig interessant aber.

213
00:10:55,990 --> 00:11:02,590
Wenn ich sage, int * pk, gut, auch wenn ich nicht
wissen, was das bedeutet notwendigerweise,

214
00:11:02,590 --> 00:11:06,150
es ist klar habe etwas
mit einer ganzen Zahl zu tun.

215
00:11:06,150 --> 00:11:08,211
Also werde ich auf Farbe
dieses Feld grün-ish,

216
00:11:08,211 --> 00:11:10,210
Ich weiß, es ist etwas, bekam
mit einer Ganzzahl machen,

217
00:11:10,210 --> 00:11:13,400
aber es ist nicht eine ganze Zahl selbst,
weil es ein int Sterne.

218
00:11:13,400 --> 00:11:15,390
Es gibt etwas, leicht
anders darüber.

219
00:11:15,390 --> 00:11:17,620
So involviert ist eine ganze Zahl,
aber ansonsten ist es

220
00:11:17,620 --> 00:11:19,830
nicht allzu verschieden von
was wir redeten.

221
00:11:19,830 --> 00:11:24,240
Es ist ein Kasten, seine bekam ein Etikett,
sie trägt ein Etikett pk,

222
00:11:24,240 --> 00:11:27,280
und es ist in der Lage, Halte
int Sternen, was auch immer das sind.

223
00:11:27,280 --> 00:11:29,894
Sie haben etwas zu tun
mit ganzen Zahlen, deutlich.

224
00:11:29,894 --> 00:11:31,060
Hier ist die letzte Zeile aber.

225
00:11:31,060 --> 00:11:37,650
Wenn ich sage, pk = & k, whoa,
was gerade passiert ist, oder?

226
00:11:37,650 --> 00:11:41,820
Also diese Zufallszahl, scheinbar zufällige
Nummer, wird es in den Kasten geworfen.

227
00:11:41,820 --> 00:11:44,930
Alles, was ist, ist pk
erhält die Adresse des k.

228
00:11:44,930 --> 00:11:52,867
Also ich bleibe, wo k lebt im Gedächtnis,
seine Adresse, die Adresse seines Bytes.

229
00:11:52,867 --> 00:11:55,200
Alles, was ich tue, ist was ich sage
dieser Wert ist, was ich

230
00:11:55,200 --> 00:11:59,430
um in meiner Box genannt pk setzen.

231
00:11:59,430 --> 00:12:02,080
Und weil diese Dinge
Zeiger und da suchen

232
00:12:02,080 --> 00:12:04,955
bei einem String wie Null-x
acht null c sieben vier Acht

233
00:12:04,955 --> 00:12:07,790
zwei Null ist wahrscheinlich
nicht sehr aussagekräftig.

234
00:12:07,790 --> 00:12:12,390
Wenn wir in der Regel Hinweise zu visualisieren,
wir tatsächlich so zu tun als Zeiger.

235
00:12:12,390 --> 00:12:17,000
Pk gibt uns die Informationen
wir brauchen, um k im Speicher zu finden.

236
00:12:17,000 --> 00:12:19,120
Also im Grunde pk hat einen Pfeil in ihm.

237
00:12:19,120 --> 00:12:21,670
Und wenn wir zu Fuß die Länge
dieser Pfeil, sich vorstellen,

238
00:12:21,670 --> 00:12:25,280
es ist etwas, das Sie zu Fuß auf, wenn wir
Spaziergang entlang der Länge des Pfeils,

239
00:12:25,280 --> 00:12:29,490
an der Spitze dieses Pfeils wir
wird die Stelle im Speicher zu finden

240
00:12:29,490 --> 00:12:31,390
wobei k lebt.

241
00:12:31,390 --> 00:12:34,360
Und das ist wirklich wichtig,
denn wenn wir wissen, wo k lebt,

242
00:12:34,360 --> 00:12:37,870
wir beginnen können, um mit den Daten zu arbeiten
innerhalb dieser Speicherstelle.

243
00:12:37,870 --> 00:12:40,780
Obwohl wir bekommen einen teeny
Bit vorgreifen für jetzt.

244
00:12:40,780 --> 00:12:42,240
>> Also, was ist ein Zeiger?

245
00:12:42,240 --> 00:12:45,590
Ein Zeiger ist eine Dateneinheit, deren
Wert ist eine Speicheradresse.

246
00:12:45,590 --> 00:12:49,740
Das war, dass die Null x acht Null Zeug
los, das war eine Speicheradresse.

247
00:12:49,740 --> 00:12:52,060
Das war eine Stelle im Speicher.

248
00:12:52,060 --> 00:12:55,080
Und den Typ eines Zeigers
beschreibt die Art

249
00:12:55,080 --> 00:12:56,930
von Daten finden Sie am zu finden
dass Speicheradresse.

250
00:12:56,930 --> 00:12:58,810
So gibt es den int-Sterne-Teil rechts.

251
00:12:58,810 --> 00:13:03,690
Wenn ich folgen dieser Pfeil, ist es
wird mich an einen Ort führen.

252
00:13:03,690 --> 00:13:06,980
Und das Lage, was ich
wird in meinem Beispiel dort,

253
00:13:06,980 --> 00:13:08,240
ist eine grüne farbigen Feld.

254
00:13:08,240 --> 00:13:12,650
Es ist eine ganze Zahl, das ist, was ich
finden, wenn ich an diese Adresse.

255
00:13:12,650 --> 00:13:14,830
Der Datentyp ein
Zeiger beschreibt, was

256
00:13:14,830 --> 00:13:17,936
Sie werden an dieser Speicheradresse zu finden.

257
00:13:17,936 --> 00:13:19,560
Also hier ist die wirklich coole Sache aber.

258
00:13:19,560 --> 00:13:25,090
Pointers es uns ermöglichen, übergeben
Variablen zwischen Funktionen.

259
00:13:25,090 --> 00:13:28,520
Und tatsächlich Variablen übergeben
und nicht passieren Kopien davon.

260
00:13:28,520 --> 00:13:32,879
Denn wenn wir genau wissen, wo
im Speicher, um eine Variable zu finden,

261
00:13:32,879 --> 00:13:35,670
wir nicht brauchen, um eine Kopie zu machen
, können wir nur zu diesem Standort gehen

262
00:13:35,670 --> 00:13:37,844
und die Arbeit mit dieser Variablen.

263
00:13:37,844 --> 00:13:40,260
Also im Grunde Zeiger sort
der einen Computer-Umgebung

264
00:13:40,260 --> 00:13:42,360
viel mehr wie der realen Welt, nicht wahr.

265
00:13:42,360 --> 00:13:44,640
>> Also hier ist eine Analogie.

266
00:13:44,640 --> 00:13:48,080
Lassen Sie uns sagen, dass ich ein Notizbuch,
richtig, und es ist voll von Notizen.

267
00:13:48,080 --> 00:13:50,230
Und ich möchte, dass Sie es zu aktualisieren.

268
00:13:50,230 --> 00:13:53,960
Sie sind eine Funktion,
Aktuelles Notizen, richtig.

269
00:13:53,960 --> 00:13:56,390
In der Art, wie wir schon seit
Bisher arbeiten, was

270
00:13:56,390 --> 00:14:02,370
passiert, wird Sie mein Notizbuch zu nehmen,
Sie werden an der Kopie Laden gehen,

271
00:14:02,370 --> 00:14:06,410
finden Sie eine Xerox Kopie machen
jede Seite des Notebooks.

272
00:14:06,410 --> 00:14:09,790
Du wirst mein Notebook wieder zu verlassen
auf meinem Schreibtisch, wenn Sie fertig sind,

273
00:14:09,790 --> 00:14:14,600
Sie gehen und streiche Dinge in meinem
Notebook, das veraltet oder falsch sind,

274
00:14:14,600 --> 00:14:19,280
und dann werden Sie zurück zu übergeben
mir die Stapel von Xerox Seiten

275
00:14:19,280 --> 00:14:22,850
das ist eine Replik mein Notizbuch mit
die Änderungen, die Sie haben es geschafft.

276
00:14:22,850 --> 00:14:27,040
Und an diesem Punkt, ist es an mir, als
die aufrufende Funktion, da der Anrufer,

277
00:14:27,040 --> 00:14:30,582
zu entscheiden, um Ihre Notizen zu machen und
integrieren sie zurück in mein Notizbuch.

278
00:14:30,582 --> 00:14:32,540
So gibt es eine Menge von Schritten
hier geht, nicht wahr.

279
00:14:32,540 --> 00:14:34,850
Wie wäre es nicht besser,
wenn ich einfach sagen, hey, können Sie

280
00:14:34,850 --> 00:14:38,370
mein Notebook für zu aktualisieren
mir, Hand, die Sie meinem Notebook,

281
00:14:38,370 --> 00:14:40,440
und Sie die Dinge zu nehmen und
buchstäblich überqueren sie aus

282
00:14:40,440 --> 00:14:42,810
und aktualisieren meine Notizen in mein Notizbuch.

283
00:14:42,810 --> 00:14:45,140
Und dann geben Sie mir mein Notebook zurück.

284
00:14:45,140 --> 00:14:47,320
Das ist irgendwie was
Zeiger erlauben uns, zu tun,

285
00:14:47,320 --> 00:14:51,320
sie diese Umgebung viel zu machen
eher wie wir arbeiten in der Realität.

286
00:14:51,320 --> 00:14:54,640
>> Na gut, so dass das, was
ein Zeiger, lass uns reden

287
00:14:54,640 --> 00:14:58,040
darüber, wie Zeigern arbeiten in C, und
wie wir beginnen können, um mit ihnen zu arbeiten.

288
00:14:58,040 --> 00:15:02,550
Es gibt also eine sehr einfache Zeiger
in C genannte Null-Zeiger.

289
00:15:02,550 --> 00:15:04,830
Die Null-Zeiger zeigt auf nichts.

290
00:15:04,830 --> 00:15:08,310
Das scheint wohl, wie es ist
eigentlich nicht eine sehr nützliche Sache,

291
00:15:08,310 --> 00:15:10,500
aber wie wir sehen ein
etwas später auf die Tatsache,

292
00:15:10,500 --> 00:15:15,410
, dass diese Null-Zeiger vorhanden ist
tatsächlich kann wirklich nützlich sein.

293
00:15:15,410 --> 00:15:19,090
Und immer, wenn Sie einen Zeiger zu erstellen und
Sie seinen Wert unverzüglich einen nicht festlegen

294
00:15:19,090 --> 00:15:21,060
ein Beispiel für die Einstellung
sein Wert sofort

295
00:15:21,060 --> 00:15:25,401
wird ein paar Dias wieder
wo ich sagte pk gleich & k,

296
00:15:25,401 --> 00:15:28,740
pk erhält Adresse k ist, wie
wir werden sehen, was das bedeutet,

297
00:15:28,740 --> 00:15:32,990
wir werden sehen, wie das zu codieren shortly-
wenn wir nicht den Wert auf etwas festgelegt

298
00:15:32,990 --> 00:15:35,380
sofort aussagekräftige,
sollten Sie immer

299
00:15:35,380 --> 00:15:37,480
stellen Sie Ihren Zeiger auf Punkt auf null gesetzt.

300
00:15:37,480 --> 00:15:40,260
Sie sollten setzen Sie ihn auf, nichts zu zeigen.

301
00:15:40,260 --> 00:15:43,614
>> Das ist ganz anders als
verlässt gerade den Wert, wie es ist

302
00:15:43,614 --> 00:15:45,530
und dann über die Vereinbarkeit eines
Zeiger und nur unter der Annahme,

303
00:15:45,530 --> 00:15:48,042
es ist null, weil das ist selten wahr.

304
00:15:48,042 --> 00:15:50,000
So sollten Sie immer eingestellt
der Wert eines Pointers

305
00:15:50,000 --> 00:15:55,690
auf Null, wenn Sie ihren Wert nicht festlegen
etwas Sinnvolles sofort.

306
00:15:55,690 --> 00:15:59,090
Sie können überprüfen, ob der Wert eines Zeigers
null mit dem Gleichheitsoperator

307
00:15:59,090 --> 00:16:05,450
(==), So wie du jede Integer-Vergleich
Werten oder Zeichenwerte unter Verwendung von (==)

308
00:16:05,450 --> 00:16:06,320
auch.

309
00:16:06,320 --> 00:16:10,994
Es ist eine besondere Art von Konstante
Wert, den Sie verwenden können, um zu testen.

310
00:16:10,994 --> 00:16:13,160
Das war also eine sehr einfache
Zeiger, der Null-Zeiger.

311
00:16:13,160 --> 00:16:15,320
Eine weitere Möglichkeit zu schaffen
ein Zeiger zu extrahieren

312
00:16:15,320 --> 00:16:18,240
die Adresse eines variablen
die Sie bereits erstellt haben,

313
00:16:18,240 --> 00:16:22,330
und Sie dies mit der DO &
Operator-Adresse Extraktion.

314
00:16:22,330 --> 00:16:26,720
Die wir schon zuvor gesehen habe,
im ersten Diagramm Beispiel I zeigten.

315
00:16:26,720 --> 00:16:31,450
Also, wenn x eine Variable, die wir
bereits vom Typ integer erstellt,

316
00:16:31,450 --> 00:16:35,110
dann & x ist ein Zeiger auf eine Ganzzahl.

317
00:16:35,110 --> 00:16:39,810
& x ist- erinnern, und wird zu extrahieren
die Adresse der Sache auf der rechten Seite.

318
00:16:39,810 --> 00:16:45,350
Und da ein Zeiger ist nur eine Adresse,
als & x ist ein Zeiger auf einen ganzzahligen

319
00:16:45,350 --> 00:16:48,560
deren Wert in dem im Speicher x Leben.

320
00:16:48,560 --> 00:16:50,460
Es ist x die Adresse.

321
00:16:50,460 --> 00:16:53,296
So & x ist die Adresse x.

322
00:16:53,296 --> 00:16:55,670
Werfen wir noch einen Schritt
weitere und eine Verbindung zu etwas,

323
00:16:55,670 --> 00:16:58,380
Ich spielte auf in einem früheren Video.

324
00:16:58,380 --> 00:17:06,730
Wenn arr ist ein Array aus Doppelzimmer, dann
& arr eckige Klammer i ist ein Zeiger

325
00:17:06,730 --> 00:17:08,109
zu einem Doppel.

326
00:17:08,109 --> 00:17:08,970
OK.

327
00:17:08,970 --> 00:17:12,160
arr eckige Klammer i, wenn
arr ist ein Array aus Doppelzimmer,

328
00:17:12,160 --> 00:17:19,069
dann arr eckige Klammer i
das i-te Element des Arrays,

329
00:17:19,069 --> 00:17:29,270
und & arr eckige Klammer i ist, wo in
Speicher das i-te Element von arr existiert.

330
00:17:29,270 --> 00:17:31,790
>> Also, was ist die Implikation hier?

331
00:17:31,790 --> 00:17:34,570
Ein Array Namen, die Implikation
von dieser ganzen Sache,

332
00:17:34,570 --> 00:17:39,290
ist, dass der Name eines Arrays
tatsächlich selbst ein Zeiger.

333
00:17:39,290 --> 00:17:41,170
Sie gearbeitet haben
mit Zeigern entlang

334
00:17:41,170 --> 00:17:45,290
jedes Mal, wenn Sie ein Array benutzt habe.

335
00:17:45,290 --> 00:17:49,090
Denken Sie daran, aus dem beispielsweise
auf den Geltungsbereich von Variablen,

336
00:17:49,090 --> 00:17:53,420
in der Nähe des Ende des Video-I präsentieren
ein Beispiel, wo wir eine Funktion haben

337
00:17:53,420 --> 00:17:56,890
genannte Satz int und eine
Funktion namens Satz-Array.

338
00:17:56,890 --> 00:18:00,490
Und Ihre Aufgabe zu bestimmen,
ob oder nicht, oder welche

339
00:18:00,490 --> 00:18:03,220
Werte, die wir gedruckt
das Ende der Funktion,

340
00:18:03,220 --> 00:18:05,960
am Ende des Hauptprogramms.

341
00:18:05,960 --> 00:18:08,740
>> Wenn Sie von diesem Beispiel erinnern
oder wenn Sie das Video gesehen haben,

342
00:18:08,740 --> 00:18:13,080
Sie wissen, dass, wenn Sie- den Anruf an
set int effektiv tut nichts.

343
00:18:13,080 --> 00:18:16,390
Aber der Aufruf gesetzt Array tut.

344
00:18:16,390 --> 00:18:19,280
Und ich Art von beschönigt, warum
Das war der Fall bei der Zeit.

345
00:18:19,280 --> 00:18:22,363
Ich habe nur gesagt, gut, es ist ein Array, ist es
spezielle, wissen Sie, es gibt einen Grund.

346
00:18:22,363 --> 00:18:25,020
Der Grund dafür ist, dass ein Array von
Name ist wirklich nur ein Zeiger,

347
00:18:25,020 --> 00:18:28,740
und es gibt diese besondere
eckigen Klammer-Syntax,

348
00:18:28,740 --> 00:18:30,510
die Dinge viel schöner, mit zu arbeiten.

349
00:18:30,510 --> 00:18:34,410
Und sie machen die Idee einer
Zeiger viel weniger einschüchternd,

350
00:18:34,410 --> 00:18:36,800
und das ist, warum sie sort
der auf diese Weise dargestellt.

351
00:18:36,800 --> 00:18:38,600
Aber wirklich Arrays sind nur Hinweise.

352
00:18:38,600 --> 00:18:41,580
Und deshalb, wenn wir
einen Wechsel zu dem Array,

353
00:18:41,580 --> 00:18:44,880
wenn wir übergeben ein Array als Parameter
zu einer Funktion als Argument

354
00:18:44,880 --> 00:18:50,110
einer Funktion, die Inhalte der Arrays
tatsächlich sowohl in der Angerufene verändert

355
00:18:50,110 --> 00:18:51,160
und in dem Anrufer.

356
00:18:51,160 --> 00:18:55,846
Die für jede andere Art von
variable wir sahen, war nicht der Fall.

357
00:18:55,846 --> 00:18:58,970
Also das ist nur etwas, was in zu halten
dagegen, wenn Sie mit Zeigern arbeiten,

358
00:18:58,970 --> 00:19:01,610
ist, dass der Name eines
Array tatsächlich ein Zeiger

359
00:19:01,610 --> 00:19:04,750
auf das erste Element des Arrays.

360
00:19:04,750 --> 00:19:08,930
>> OK, so jetzt haben wir alle diese
Fakten, lassen Sie uns weitermachen, richtig.

361
00:19:08,930 --> 00:19:11,370
Warum müssen wir über Pflege
wo etwas lebt.

362
00:19:11,370 --> 00:19:14,120
Nun, wie ich sagte, es ist ziemlich
nützlich zu wissen, wo etwas lebt

363
00:19:14,120 --> 00:19:17,240
so dass Sie dorthin gehen und zu verändern.

364
00:19:17,240 --> 00:19:19,390
Mit ihr arbeiten und tatsächlich
haben die Sache, die Sie

365
00:19:19,390 --> 00:19:23,710
wollen auf diese Variable wirksam zu tun,
und nicht wirksam auf einigen Kopie davon.

366
00:19:23,710 --> 00:19:26,150
Dies nennt man Dereferenzierung.

367
00:19:26,150 --> 00:19:28,690
Wir gehen auf die Referenz und
wir dort den Wert zu ändern.

368
00:19:28,690 --> 00:19:32,660
Wenn wir also einen Zeiger und es heißt
pc, und es zu einem Zeichen weist,

369
00:19:32,660 --> 00:19:40,610
dann können wir sagen * * PC und PC ist das
Namen von dem, was wir finden, wenn wir gehen,

370
00:19:40,610 --> 00:19:42,910
an die Adresse PC.

371
00:19:42,910 --> 00:19:47,860
Was wir dort finden, ist ein Charakter und
* pc ist, wie wir beziehen sich auf die Daten, dass

372
00:19:47,860 --> 00:19:48,880
Lage.

373
00:19:48,880 --> 00:19:54,150
So konnten wir etwas sagen
* pc = D oder so ähnlich,

374
00:19:54,150 --> 00:19:59,280
und das bedeutet, dass alles, was
war an der Speicheradresse pc,

375
00:19:59,280 --> 00:20:07,040
was auch immer Zeichen vorher war
gibt, ist jetzt D, wenn wir sagen, * PC-= D.

376
00:20:07,040 --> 00:20:10,090
>> So hier gehen wir wieder mit
einige seltsame C Zeug, richtig.

377
00:20:10,090 --> 00:20:14,560
Also haben wir zuvor als gesehen habe *
irgendwie Teil der Datentyp,

378
00:20:14,560 --> 00:20:17,160
und jetzt ist es in verwendet
einen etwas anderen Kontext

379
00:20:17,160 --> 00:20:19,605
um die Daten an einer Stelle, zuzugreifen.

380
00:20:19,605 --> 00:20:22,480
Ich weiß, es ist ein wenig verwirrend und
Das ist eigentlich Teil dieses ganzen

381
00:20:22,480 --> 00:20:25,740
wie, warum Zeigern haben diese Mythologie
um sie als so komplex,

382
00:20:25,740 --> 00:20:28,250
ist eine Art Syntax Problem, ehrlich.

383
00:20:28,250 --> 00:20:31,810
Aber * in beiden Zusammenhängen verwendet,
sowohl als Teil der Typenbezeichnung,

384
00:20:31,810 --> 00:20:34,100
und wir werden ein wenig zu sehen
später etwas anderes, auch.

385
00:20:34,100 --> 00:20:36,490
Und gerade jetzt ist die
Dereferenzierungsoperator.

386
00:20:36,490 --> 00:20:38,760
So geht es mit dem Referenz
er die Daten zugreift,

387
00:20:38,760 --> 00:20:43,000
an der Position des Zeigers und
können Sie ihn nach Belieben zu manipulieren.

388
00:20:43,000 --> 00:20:45,900
>> Nun ist dies sehr ähnlich
besuchen Ihre Nachbarn, rechts.

389
00:20:45,900 --> 00:20:48,710
Wenn Sie wissen, was Ihre
Nachbarn lebt, du bist

390
00:20:48,710 --> 00:20:50,730
nicht hängen mit Ihren Nachbarn.

391
00:20:50,730 --> 00:20:53,510
Sie wissen, Sie passieren
wissen, wo sie leben,

392
00:20:53,510 --> 00:20:56,870
aber das bedeutet nicht, dass durch
kraft mit, dass das Wissen

393
00:20:56,870 --> 00:20:59,170
Sie sind mit ihnen interagieren.

394
00:20:59,170 --> 00:21:01,920
Wenn Sie mit ihnen zu interagieren möchten,
müssen Sie, um ihr Haus zu gehen,

395
00:21:01,920 --> 00:21:03,760
Sie müssen auf dem sie leben zu gehen.

396
00:21:03,760 --> 00:21:07,440
Und wenn Sie das tun,
dann haben Sie interagieren können

397
00:21:07,440 --> 00:21:09,420
mit ihnen genau wie Sie würde wollen.

398
00:21:09,420 --> 00:21:12,730
Und in ähnlicher Weise mit Variablen,
Sie brauchen, um ihre Adresse zu gehen

399
00:21:12,730 --> 00:21:15,320
wenn du ihnen zu interagieren möchten,
können Sie nicht nur wissen, die Adresse.

400
00:21:15,320 --> 00:21:21,495
Und so, wie Sie an die Adresse gehen
zu verwenden *, die Dereferenzierungsoperator.

401
00:21:21,495 --> 00:21:23,620
Was glauben Sie, geschieht,
wenn wir versuchen, dereferenzieren

402
00:21:23,620 --> 00:21:25,260
ein Zeiger, deren Wert null?

403
00:21:25,260 --> 00:21:28,470
Daran erinnern, dass die Null-
Zeiger zeigt auf nichts.

404
00:21:28,470 --> 00:21:34,110
Also, wenn Sie versuchen, dereferenzieren
nichts oder zu einer Adresse nichts zu gehen,

405
00:21:34,110 --> 00:21:36,800
was glauben Sie, passiert?

406
00:21:36,800 --> 00:21:39,630
Nun, wenn Sie erraten Segmentierung
Schuld, hätten Sie recht.

407
00:21:39,630 --> 00:21:41,390
Wenn Sie versuchen, dereferenzieren
ein Nullzeiger,

408
00:21:41,390 --> 00:21:43,140
Sie eine Segmentierung leiden
Fehler. Aber warte,

409
00:21:43,140 --> 00:21:45,820
nicht ich sage euch, daß
wenn du nicht gehst,

410
00:21:45,820 --> 00:21:49,220
um Ihren Wert bestimmen Sie Ihren
Zeiger auf etwas Sinnvolles,

411
00:21:49,220 --> 00:21:51,000
Sie sollten auf Null gesetzt?

412
00:21:51,000 --> 00:21:55,290
Ich habe und eigentlich die Segmentierung
Schuld ist eine Art gutes Verhalten.

413
00:21:55,290 --> 00:21:58,680
>> Haben Sie jemals eine Variable deklariert und
dessen Wert nicht sofort zugeordnet?

414
00:21:58,680 --> 00:22:02,680
So können Sie einfach sagen, int x; Sie dies nicht tun
eigentlich nichts zuweisen

415
00:22:02,680 --> 00:22:05,340
und dann später in Ihrem Code,
Sie den Wert von x aus zu drucken,

416
00:22:05,340 --> 00:22:07,650
mit immer noch nicht
es nichts zugewiesen.

417
00:22:07,650 --> 00:22:10,370
Häufig erhalten Sie
Null, aber manchmal

418
00:22:10,370 --> 00:22:15,000
könnte einige Zufallszahl zu erhalten, und
Sie haben keine Ahnung, woher es kam.

419
00:22:15,000 --> 00:22:16,750
Ebenso können die Dinge
geschieht mit Zeigern.

420
00:22:16,750 --> 00:22:20,110
Wenn Sie einen Zeiger deklarieren
int * pk B.

421
00:22:20,110 --> 00:22:23,490
und Sie haben nicht zuweisen er auf einen Wert,
Sie erhalten vier Byte für Speicher.

422
00:22:23,490 --> 00:22:25,950
Was auch immer vier Byte
Speicher kann das System

423
00:22:25,950 --> 00:22:28,970
feststellen, dass einige sinnvollen Wert.

424
00:22:28,970 --> 00:22:31,760
Und es hätte sein können
etwas schon da, dass

425
00:22:31,760 --> 00:22:34,190
wird nicht mehr durch eine andere benötigte
Funktion, so dass Sie nur noch

426
00:22:34,190 --> 00:22:35,900
was auch immer Daten war da.

427
00:22:35,900 --> 00:22:40,570
>> Was, wenn man versucht zu dereferenzieren tun
einige Adresse, die Sie nicht- gab es

428
00:22:40,570 --> 00:22:43,410
bereits Bytes und Informationen
gibt, das ist jetzt in Ihren Zeiger.

429
00:22:43,410 --> 00:22:47,470
Wenn Sie versuchen, diesen Zeiger dereferenzieren,
Sie könnte mit einigen Speicher messing werden

430
00:22:47,470 --> 00:22:49,390
dass Sie nicht die Absicht
mit Zohan an allem.

431
00:22:49,390 --> 00:22:51,639
Und in der Tat, die Sie tun können
etwas wirklich verheerend,

432
00:22:51,639 --> 00:22:54,880
wie brechen ein anderes Programm,
oder brechen eine andere Funktion,

433
00:22:54,880 --> 00:22:58,289
oder etwas zu tun, dass böswillige
Sie hatte nicht vor, zu tun.

434
00:22:58,289 --> 00:23:00,080
Und damit ist, warum es
eigentlich eine gute Idee

435
00:23:00,080 --> 00:23:04,030
um Ihren Zeiger setzen, wenn Sie auf null
sie nicht gesetzt, etwas Sinnvolles.

436
00:23:04,030 --> 00:23:06,760
Es ist wahrscheinlich auf die bessere
Ende des Tages für Ihr Programm

437
00:23:06,760 --> 00:23:09,840
um dann zum Absturz bringen, damit es zu tun
etwas, das Schrauben bis

438
00:23:09,840 --> 00:23:12,400
ein anderes Programm oder eine andere Funktion.

439
00:23:12,400 --> 00:23:15,207
Das Verhalten ist wahrscheinlich sogar
weniger ideal als nur abstürzt.

440
00:23:15,207 --> 00:23:17,040
Und damit ist, warum es
eigentlich eine gute Angewohnheit,

441
00:23:17,040 --> 00:23:20,920
um in die zu Ihren Zeigern gesetzt
auf Null, wenn Sie sie nicht setzen

442
00:23:20,920 --> 00:23:24,540
zu einem sinnvollen Wert
sofort, ein Wert, der Sie wissen,

443
00:23:24,540 --> 00:23:27,260
und dass Sie sicher das dereferenzieren.

444
00:23:27,260 --> 00:23:32,240
>> Lassen Sie uns so kommen nun zurück, und werfen Sie einen Blick
auf Gesamt Syntax der Situation.

445
00:23:32,240 --> 00:23:37,400
Wenn ich sage, int * p ;, was habe ich nur getan?

446
00:23:37,400 --> 00:23:38,530
Was ich getan habe, ist dies.

447
00:23:38,530 --> 00:23:43,290
Ich weiß, dass der Wert von p ist eine Adresse,
da alle Zeiger sind nur

448
00:23:43,290 --> 00:23:44,660
Adressen.

449
00:23:44,660 --> 00:23:47,750
Ich kann dereferenzieren p
mit dem * Operator.

450
00:23:47,750 --> 00:23:51,250
In diesem Zusammenhang hier, zumin
top erinnern die * ist Teil der Art.

451
00:23:51,250 --> 00:23:53,510
Int * ist der Datentyp.

452
00:23:53,510 --> 00:23:56,150
Aber ich kann dereferenzieren
p mit dem * Operator,

453
00:23:56,150 --> 00:24:01,897
und wenn ich dies tun, wenn ich an diese Adresse,
was werde ich an dieser Adresse finden?

454
00:24:01,897 --> 00:24:02,855
Ich werde eine ganze Zahl zu finden.

455
00:24:02,855 --> 00:24:05,910
So int * p ist im Grunde
sagen, p eine Adresse.

456
00:24:05,910 --> 00:24:09,500
Ich kann dereferenzieren p und wenn
Ich tue, ich werde eine ganze Zahl zu finden

457
00:24:09,500 --> 00:24:11,920
an dieser Speicherstelle.

458
00:24:11,920 --> 00:24:14,260
>> OK, so sagte ich gab es eine weitere
ärgerliche Sache mit Sternen

459
00:24:14,260 --> 00:24:17,060
und hier ist, wo das
ärgerliche Sache mit Sternen ist.

460
00:24:17,060 --> 00:24:21,640
Haben Sie jemals versucht zu erklären,
mehrere Variablen des gleichen Typs

461
00:24:21,640 --> 00:24:24,409
auf der gleichen Zeile des Codes?

462
00:24:24,409 --> 00:24:27,700
Also für eine Sekunde, so tun, dass die Linie,
der Code habe ich eigentlich gibt es in grün

463
00:24:27,700 --> 00:24:29,366
ist nicht da, und es sagt nur int x, y, z ;.

464
00:24:29,366 --> 00:24:31,634

465
00:24:31,634 --> 00:24:34,550
Was tun würde tatsächlich zu erstellen
drei Integer-Variablen für Sie,

466
00:24:34,550 --> 00:24:36,930
eine namens x, nannte man
y, und man nannte z.

467
00:24:36,930 --> 00:24:41,510
Es ist ein Weg, um es zu tun, ohne
dass auf drei Linien aufgeteilt.

468
00:24:41,510 --> 00:24:43,890
>> Hier findest Sternen erhalten
wieder ärgerlich, obwohl,

469
00:24:43,890 --> 00:24:49,200
weil die * ist eigentlich ein Teil
sowohl der Typnamen und ein Teil

470
00:24:49,200 --> 00:24:50,320
der Variablennamen.

471
00:24:50,320 --> 00:24:56,430
Und so, wenn ich sage, int * px, py, pz, was ich
tatsächlich ist ein Zeiger auf einen ganzzahligen

472
00:24:56,430 --> 00:25:01,650
genannt px und zwei ganzen Zahlen, py und pz.

473
00:25:01,650 --> 00:25:04,950
Und das ist wahrscheinlich nicht das, was
wir wollen, das ist nicht gut.

474
00:25:04,950 --> 00:25:09,290
>> Also, wenn ich mehrere Zeiger zu erstellen
auf der gleichen Linie, des gleichen Typs,

475
00:25:09,290 --> 00:25:12,140
und die Sterne, was ich wirklich brauchen
zu tun ist, sagen, int * pa, pb *, * pc.

476
00:25:12,140 --> 00:25:17,330

477
00:25:17,330 --> 00:25:20,300
Jetzt nachdem er gerade gesagt, dass
und jetzt sage Ihnen das,

478
00:25:20,300 --> 00:25:22,170
werden Sie wahrscheinlich nie tun.

479
00:25:22,170 --> 00:25:25,170
Und es ist wahrscheinlich eine gute Sache ehrlich gesagt,
weil Sie versehentlich

480
00:25:25,170 --> 00:25:26,544
weglassen einen Stern, so ähnlich.

481
00:25:26,544 --> 00:25:29,290
Es ist wahrscheinlich am besten, vielleicht erklären,
Hinweise zu den einzelnen Zeilen,

482
00:25:29,290 --> 00:25:31,373
aber es ist nur ein weiterer
diese nervigen Syntax

483
00:25:31,373 --> 00:25:35,310
Dinge, mit Sternen, die machen
Zeiger so schwierig, mit zu arbeiten.

484
00:25:35,310 --> 00:25:39,480
Denn es ist gerade diese syntaktische
Einander muss man durch zu arbeiten.

485
00:25:39,480 --> 00:25:41,600
Mit etwas Übung es funktioniert
wirklich zur zweiten Natur geworden.

486
00:25:41,600 --> 00:25:45,410
Ich immer noch Fehler machen, mit ihm noch
nach der Programmierung für 10 Jahre,

487
00:25:45,410 --> 00:25:49,630
so nicht böse sein, wenn etwas passiert
, dann ist es ehrlich gesagt ziemlich häufig.

488
00:25:49,630 --> 00:25:52,850
Es ist wirklich Art von
ein Fehler der Syntax.

489
00:25:52,850 --> 00:25:54,900
>> OK, damit ich Art versprochen
dass wir überdenken würde,

490
00:25:54,900 --> 00:25:59,370
das Konzept, wie groß ist eine Zeichenfolge.

491
00:25:59,370 --> 00:26:02,750
Nun, wenn ich Ihnen sagte, dass ein
string, haben wir wirklich Art von

492
00:26:02,750 --> 00:26:04,140
worden, um Ihnen liegen die ganze Zeit.

493
00:26:04,140 --> 00:26:06,181
Es gibt keinen Datentyp mit dem Namen
string, und in der Tat I

494
00:26:06,181 --> 00:26:09,730
dies erwähnt in einem unserer
frühesten Videos auf Datentypen,

495
00:26:09,730 --> 00:26:13,820
dass String war ein Datentyp,
wurde für Sie in CS50.h. erstellt

496
00:26:13,820 --> 00:26:17,050
Man muss # include
CS50.h, um es zu benutzen.

497
00:26:17,050 --> 00:26:19,250
>> Gut Saite ist wirklich nur
ein Alias ​​für etwas,

498
00:26:19,250 --> 00:26:23,600
genannt char *, a
Zeiger auf ein Zeichen.

499
00:26:23,600 --> 00:26:26,010
Nun Zeigern, Rückruf,
sind nur Adressen.

500
00:26:26,010 --> 00:26:28,780
Also, was ist die Größe
in Bytes einer Schnur?

501
00:26:28,780 --> 00:26:29,796
Nun, es ist vier oder acht.

502
00:26:29,796 --> 00:26:32,170
Und der Grund, warum ich sagen, vier oder
acht ist, weil es tatsächlich

503
00:26:32,170 --> 00:26:36,730
hängt von dem System, wenn Sie verwenden
CS50 ide ist char * der Größe eines char

504
00:26:36,730 --> 00:26:39,340
* Acht ist, ist es ein 64-Bit-System.

505
00:26:39,340 --> 00:26:43,850
Jede Adresse im Speicher ist 64 Bit lang.

506
00:26:43,850 --> 00:26:48,270
Wenn Sie mit CS50-Appliance sind
oder mit einem beliebigen 32-Bit-Maschine,

507
00:26:48,270 --> 00:26:51,640
und Sie haben diesen Begriff 32-Bit gehört,
Maschine, was ist ein 32-Bit-Maschine?

508
00:26:51,640 --> 00:26:56,090
Nun, es bedeutet nur, dass jeder
Adresse im Speicher ist 32 Bit lang.

509
00:26:56,090 --> 00:26:59,140
Usw. 32 Bits von vier Byte.

510
00:26:59,140 --> 00:27:02,710
Also ein char * ist vier oder acht
Bytes abhängig von Ihrem System.

511
00:27:02,710 --> 00:27:06,100
Und in der Tat alle Datentypen,
und einen Zeiger zu jedem Daten

512
00:27:06,100 --> 00:27:12,030
geben, da alle Zeiger sind nur
Adressen, vier oder acht Bytes.

513
00:27:12,030 --> 00:27:14,030
Lassen Sie uns also erneut diese
Diagramm und lassen Sie uns abschließen

514
00:27:14,030 --> 00:27:18,130
Dieses Video mit ein wenig Übung hier.

515
00:27:18,130 --> 00:27:21,600
Also hier ist die Diagramm wir aufgehört haben mit
am Anfang des Videos.

516
00:27:21,600 --> 00:27:23,110
So was passiert nun, wenn ich sage * pk = 35?

517
00:27:23,110 --> 00:27:26,370

518
00:27:26,370 --> 00:27:30,530
Also, was bedeutet es, wenn ich sage, * pk = 35?

519
00:27:30,530 --> 00:27:32,420
Nehmen Sie eine Sekunde.

520
00:27:32,420 --> 00:27:34,990
* pk.

521
00:27:34,990 --> 00:27:39,890
In Zusammenhang hier ist *
Dereferenzierungsoperator.

522
00:27:39,890 --> 00:27:42,110
Also, wenn die Dereferenzierung
Operator wird verwendet,

523
00:27:42,110 --> 00:27:48,520
Wir gehen auf die Adresse, auf
von pk, und wir ändern, was wir finden.

524
00:27:48,520 --> 00:27:55,270
So * pk = 35 wirksam
tut dies, um das Bild.

525
00:27:55,270 --> 00:27:58,110
So ist es im Grunde syntaktisch
identisch mit der gesagt haben k = 35.

526
00:27:58,110 --> 00:28:00,740

527
00:28:00,740 --> 00:28:01,930
>> Einer noch.

528
00:28:01,930 --> 00:28:05,510
Wenn ich sage, int m, ich erstellen
eine neue Variable namens m.

529
00:28:05,510 --> 00:28:08,260
Eine neue Box, es ist eine grüne Box, weil
es geht um eine ganze Zahl zu halten,

530
00:28:08,260 --> 00:28:09,840
und es ist m gekennzeichnet.

531
00:28:09,840 --> 00:28:14,960
Wenn ich sage, m = 4, habe ich ein
Ganzzahl in diesem Feld.

532
00:28:14,960 --> 00:28:20,290
Wenn sagen wir pk = & m, wie funktioniert
Dieses Diagramm Veränderung?

533
00:28:20,290 --> 00:28:28,760
Pk = & m, zu tun, was der Rückruf
Operator & tut oder aufgerufen wird?

534
00:28:28,760 --> 00:28:34,430
Beachten Sie, dass & einige Variablennamen
ist die Adresse eines variablen Namens.

535
00:28:34,430 --> 00:28:38,740
Also, was wir sagen ist,
pk erhält die Adresse m.

536
00:28:38,740 --> 00:28:42,010
Und so effektiv, was passiert, die
Diagramm ist, dass nicht mehr Punkten pk

537
00:28:42,010 --> 00:28:46,420
zu, weist jedoch auf m k.

538
00:28:46,420 --> 00:28:48,470
>> Wieder Zeiger sind sehr
tricky, mit zu arbeiten

539
00:28:48,470 --> 00:28:50,620
und sie haben eine Menge zu nehmen
Praxis, sondern weil

540
00:28:50,620 --> 00:28:54,150
ihrer Fähigkeit, Ihnen zu ermöglichen
um Daten zwischen Funktionen übergeben

541
00:28:54,150 --> 00:28:56,945
und tatsächlich haben diejenigen,
Änderungen wirksam werden,

542
00:28:56,945 --> 00:28:58,820
immer Ihren Kopf herum
ist wirklich wichtig.

543
00:28:58,820 --> 00:29:02,590
Es ist wahrscheinlich das komplizierteste
Thema, das wir in CS50 zu diskutieren,

544
00:29:02,590 --> 00:29:05,910
aber der Wert, den Sie
erhalten aus mit Zeigern

545
00:29:05,910 --> 00:29:09,200
überwiegt bei weitem die Komplikationen
dass das Erlernen von ihnen kommen.

546
00:29:09,200 --> 00:29:12,690
So wünsche ich Ihnen das Beste aus
Glück Lernen über Zeiger.

547
00:29:12,690 --> 00:29:15,760
Ich bin Doug Lloyd, ist dies CS50.

548
00:29:15,760 --> 00:29:17,447