1
00:00:00,000 --> 00:00:02,440
[Powered by Google Translate] [Pointers]

2
00:00:02,440 --> 00:00:05,000
[Rob Bowden] [Harvard University]

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

4
00:00:07,360 --> 00:00:08,820
>> Lassen Sie uns über Hinweise sprechen.

5
00:00:08,820 --> 00:00:13,710
Bis jetzt haben wir immer nur um die Dinge in Erinnerung explizit beim Namen genannt.

6
00:00:13,710 --> 00:00:22,610
Wir haben gesagt, int n = 42, und dann, wenn wir die Variable n verwenden möchten,

7
00:00:22,610 --> 00:00:30,640
wir nennen es einfach unter dem Namen wir ihm schriftlich etwas wie n * 2.

8
00:00:30,640 --> 00:00:34,790
Aber das Variable muss irgendwo im Speicher zu leben.

9
00:00:34,790 --> 00:00:37,790
Wenn Sie den Wert, der zurzeit im n gespeichert ist zu verwenden,

10
00:00:37,790 --> 00:00:40,730
oder aktualisieren Sie den Wert, den n hält,

11
00:00:40,730 --> 00:00:44,180
Ihr Programm muss wissen, wo im Speicher für n aussehen.

12
00:00:44,180 --> 00:00:48,320
Wo im Speicher eine Variable Leben nennt seine Adresse.

13
00:00:48,320 --> 00:00:49,940
Es ist wie ein Haus-Adresse.

14
00:00:49,940 --> 00:00:53,080
Ich kann jemandem zu Hause finden, solange ich ihre Wohnadresse kennen,

15
00:00:53,080 --> 00:00:58,110
und ein Computerprogramm, das eine variable, solange es seine Speicheradresse kennt finden.

16
00:00:58,110 --> 00:01:02,660
Was Zeiger bereitzustellen ist eine Möglichkeit der direkten Umgang mit diesen Speicheradressen.

17
00:01:02,660 --> 00:01:06,860
>> Ein großer Teil der Macht in C kommt von der Lage in den Speicher wie diese zu manipulieren.

18
00:01:06,860 --> 00:01:09,960
Aber mit großer Macht kommt große Verantwortung.

19
00:01:09,960 --> 00:01:14,670
Zeiger können gefährlich genug verwendet werden, dass eine Menge von Programmiersprachen

20
00:01:14,670 --> 00:01:16,460
verbergen Zeigern ganz.

21
00:01:16,460 --> 00:01:19,440
Also, warum C geben uns Hinweise dann?

22
00:01:19,440 --> 00:01:22,680
Wie Sie wissen, Argumente für eine C-Funktion

23
00:01:22,680 --> 00:01:25,370
immer in die Parameter der Funktion kopiert.

24
00:01:25,370 --> 00:01:33,260
So rief etwas wie Swap auf einigen Variablen x und y

25
00:01:33,260 --> 00:01:38,840
können nicht vertauscht werden die Werte von x und y in der aufrufenden Funktion,

26
00:01:38,840 --> 00:01:40,810
obwohl das könnte nützlich sein.

27
00:01:40,810 --> 00:01:46,430
Wie wir später sehen werden, Umschreiben Swap Zeiger auf die Standorte zu müssen getauscht werden dauern

28
00:01:46,430 --> 00:01:49,690
ermöglicht es, ihre Anrufers Variablen beeinflussen.

29
00:01:49,690 --> 00:01:54,150
>> Lassen Sie uns durch eine relativ einfache Beispiel dafür, was Zeiger können nicht gehen.

30
00:01:54,150 --> 00:02:15,550
Lassen Sie uns sagen, wir haben int n = 4 und int * pointer_to_n = & n.

31
00:02:15,550 --> 00:02:18,990
Whoa! Ein bisschen neue Syntax zu decken.

32
00:02:18,990 --> 00:02:22,600
Lassen Sie uns zuerst interpretieren dies & n.

33
00:02:22,600 --> 00:02:27,260
Beachten Sie, dass alles, was im Speicher eine Adresse hat.

34
00:02:27,260 --> 00:02:30,800
Das kaufmännische wird als "Adresse"-Operator.

35
00:02:30,800 --> 00:02:36,470
So bezieht & n auf die Adresse im Speicher, wo n gespeichert ist.

36
00:02:36,470 --> 00:02:41,560
Nun sind wir Speichern Sie diese Adresse in eine neue Variable, pointer_to_n.

37
00:02:41,560 --> 00:02:43,870
Was ist die Art dieser neuen Variablen?

38
00:02:43,870 --> 00:02:47,410
Der Stern ist ein Teil der Variablen-Typ,

39
00:02:47,410 --> 00:02:49,880
und wir lesen den Typ als int *.

40
00:02:49,880 --> 00:02:56,500
Int * bedeutet, dass pointer_to_n eine Variable, die die Adresse eines ganzzahligen speichert ist.

41
00:02:56,500 --> 00:03:02,970
Wir wissen, dass & n eine int * ist seit n eine ganze Zahl, und wir nehmen die Adresse des n.

42
00:03:02,970 --> 00:03:06,660
Int * ist ein Beispiel für ein Zeigertyp.

43
00:03:06,660 --> 00:03:10,150
Sobald Sie sehen Sternchen in der Art zu starten,

44
00:03:10,150 --> 00:03:11,950
Sie wissen, dass Sie mit Zeigern zu tun haben.

45
00:03:11,950 --> 00:03:16,520
Genau wie wir können eine Variable als int x und y char zu deklarieren,

46
00:03:16,520 --> 00:03:20,410
können wir sagen, int * z und char * w.

47
00:03:20,410 --> 00:03:25,190
Int * und char * sind nur neue Arten für uns zu nutzen.

48
00:03:25,190 --> 00:03:29,430
Die Lage des * kann überall hingehen vor dem Variablennamen.

49
00:03:29,430 --> 00:03:34,730
Also, sowohl int * pointer_to_n - mit dem * next int, wie wir hier haben -

50
00:03:34,730 --> 00:03:45,210
und int * pointer_to_n mit dem * neben pointer_to_n gültig sind.

51
00:03:45,210 --> 00:03:56,470
Aber hier werde ich legen Sie die * neben int.

52
00:03:56,470 --> 00:04:00,600
Es spielt keine Rolle, welche Sie bevorzugen, nur konsequent sein.

53
00:04:00,600 --> 00:04:02,810
>> Ziehen wir ein Diagramm für diese.

54
00:04:02,810 --> 00:04:07,590
Wir müssen zuerst die Variable n, die wir als eine kleine Schachtel mit dem Gedächtnis zeichnen werde.

55
00:04:07,590 --> 00:04:15,400
Für dieses Beispiel, sagen wir, dass dieses Feld an der Adresse 100 befindet.

56
00:04:15,400 --> 00:04:18,820
Innerhalb von dieser Box, wir speichern den Wert 4.

57
00:04:18,820 --> 00:04:23,730
Jetzt haben wir eine neue Variable, pointer_to_n.

58
00:04:23,730 --> 00:04:27,030
Es hat seine eigene Box in Erinnerung,

59
00:04:27,030 --> 00:04:32,900
was wir sagen, ist an der Adresse 200.

60
00:04:32,900 --> 00:04:37,220
Innerhalb dieses Feldes sind wir Speichern der Adresse n,

61
00:04:37,220 --> 00:04:39,890
denen wir zuvor gesagt war 100.

62
00:04:39,890 --> 00:04:44,710
Häufig in Diagrammen, werden Sie sehen dies als eine wörtliche Pfeil dargestellt

63
00:04:44,710 --> 00:04:48,730
Verlassen der pointer_to_n box zeigt auf das Feld, das n speichert.

64
00:04:48,730 --> 00:04:54,620
Nun, was können wir tatsächlich mit pointer_to_n tun?

65
00:04:54,620 --> 00:05:10,400
Nun, wenn wir so etwas wie * pointer_to_n = 8 sagen, dies ist eine andere Verwendung für das Sternchen

66
00:05:10,400 --> 00:05:14,830
das ist völlig unabhängig von der Verwendung des Sterns in der Deklaration einer Variablen

67
00:05:14,830 --> 00:05:16,790
eines Zeigers Typ.

68
00:05:16,790 --> 00:05:21,130
Hier wird das Sternchen als Dereferenzierungsoperator.

69
00:05:21,130 --> 00:05:26,860
In unserem Diagramm, was * pointer_to_n = 8 Mittel ist,

70
00:05:26,860 --> 00:05:32,220
gehen Sie zu dem Feld mit pointer_to_n, folgen Sie dem Pfeil,

71
00:05:32,220 --> 00:05:38,160
und anschließend in die Schachtel zuordnen am Ende des Pfeils der Wert 8.

72
00:05:38,160 --> 00:05:45,960
Dies bedeutet, dass nach dieser Zeile, wenn wir versuchen, mit n wird es den Wert 8 haben.

73
00:05:45,960 --> 00:05:51,600
Das Wort 'Zeiger' wird in vielen verschiedenen Zusammenhängen verwendet.

74
00:05:51,600 --> 00:05:54,380
Hier werden wir versuchen, konsequent zu sein.

75
00:05:54,380 --> 00:05:58,330
Ein Zeiger-Typ ist so etwas wie int *.

76
00:05:58,330 --> 00:06:04,630
In diesem Video wird ein Zeiger nur verwendet werden, um einen Wert mit einer Pointer-Typ verstanden werden,

77
00:06:04,630 --> 00:06:08,180
wie pointer_to_n die den Typ int *.

78
00:06:08,180 --> 00:06:15,140
Überall, wo wir nur sagen n verwendet werden, können wir nun stattdessen sagen * pointer_to_n,

79
00:06:15,140 --> 00:06:18,020
und alles wird genauso gut funktionieren.

80
00:06:18,020 --> 00:06:21,120
>> Lassen Sie uns durch ein anderes einfaches Beispiel zu gehen.

81
00:06:21,120 --> 00:06:50,390
Lassen Sie uns sagen, wir haben int n = 14; int * pointer = &n; n + +, und (* Zeiger) + +.

82
00:06:50,390 --> 00:06:59,830
Die erste Zeile erzeugt eine neue Box im Speicher bezeichnet n.

83
00:06:59,830 --> 00:07:05,400
Dieses Mal werden wir nicht beschriften Sie die Box mit einer expliziten Adresse, aber es hat immer noch ein.

84
00:07:05,400 --> 00:07:11,810
Im Inneren der Box, wir Speichern der Nummer 14.

85
00:07:11,810 --> 00:07:22,290
Die nächste Zeile erstellt eine zweite Kontrollkästchen Zeiger.

86
00:07:22,290 --> 00:07:27,210
Und innerhalb dieser Box, wir speichern einen Zeiger auf das Feld n.

87
00:07:27,210 --> 00:07:33,170
Also, lasst uns ziehen den Pfeil von Zeiger auf n.

88
00:07:33,170 --> 00:07:37,790
Nun n + + inkrementiert den Wert in das Feld n,

89
00:07:37,790 --> 00:07:45,420
so dass wir 14 bis 15 gehen.

90
00:07:45,420 --> 00:07:53,330
Schließlich (* Zeiger) + + geht auf das Feld Zeiger,

91
00:07:53,330 --> 00:08:02,660
dereferences der Wert in der Box, die folgen Sie dem Pfeil, wo es Punkte bedeutet,

92
00:08:02,660 --> 00:08:11,690
und inkrementiert den Wert dort gespeichert, so dass wir von 15 bis 16 gehen.

93
00:08:11,690 --> 00:08:13,480
Und das ist es.

94
00:08:13,480 --> 00:08:18,480
N speichert nun die Nummer 16, nachdem sie bereits zweimal erhöht -

95
00:08:18,480 --> 00:08:25,050
einmal direkt über die Variablennamen n, und die andere durch eine pointer_to_n.

96
00:08:25,050 --> 00:08:33,360
>> Schnelle Quiz. Was bedeutet es wohl, wenn ich so etwas wie && sagen versuchen n?

97
00:08:33,360 --> 00:08:41,350
Nun, lassen Sie dies als & (& n), die die gleiche Sache erreicht umzuschreiben.

98
00:08:41,350 --> 00:08:47,030
Die (& n) gibt die Adresse der Variablen n im Speicher.

99
00:08:47,030 --> 00:08:53,110
Aber dann anschließend äußeren kaufmännisches versucht, die Adresse der Adresse zurück.

100
00:08:53,110 --> 00:08:56,600
Das ist wie zu tun versuchen & 2.

101
00:08:56,600 --> 00:09:00,550
Es macht keinen Sinn, um die Adresse nur eine Zahl zu erhalten

102
00:09:00,550 --> 00:09:03,260
da es nicht im Speicher abgelegt.

103
00:09:03,260 --> 00:09:07,090
Mit zwei kaufmännische in einer Reihe ist nie die richtige Idee.

104
00:09:07,090 --> 00:09:28,960
Aber jetzt, was bedeutet es, wenn ich int ** double_pointer = & Zeiger sagen versuchen?

105
00:09:28,960 --> 00:09:40,750
Nun, ich bin ein neues Feld mit der Bezeichnung double_pointer,

106
00:09:40,750 --> 00:09:44,590
und innerhalb dieser Box Ich bin Speichern der Adresse des Zeigers,

107
00:09:44,590 --> 00:09:50,810
was bedeutet, dass ich einen Pfeil aus dem double_pointer box auf den Zeiger angezeigt.

108
00:09:50,810 --> 00:09:56,640
Beachten Sie die Art der double_pointer, ein int **.

109
00:09:56,640 --> 00:10:03,700
N war eine ganze Zahl, Zeiger gespeichert die Adresse n, und so hat es den Typ int *.

110
00:10:03,700 --> 00:10:10,550
Nun speichert double_pointer die Adresse des Zeigers, so hat es den Typ int **.

111
00:10:10,550 --> 00:10:15,070
>> Also, was wir denken, bedeutet dies -

112
00:10:15,070 --> 00:10:24,490
** Double_pointer = 23?

113
00:10:24,490 --> 00:10:28,630
Beachten Sie, dass ich jetzt Dereferenzierung zweimal.

114
00:10:28,630 --> 00:10:32,030
Befolgen Sie einfach die Box-and-Pfeil-Diagramm haben wir bereits eingerichtet haben.

115
00:10:32,030 --> 00:10:36,400
Zuerst gehen wir in das Feld double_pointer.

116
00:10:36,400 --> 00:10:40,550
Der erste * bedeutet folgen Sie dem Pfeil einmal.

117
00:10:40,550 --> 00:10:44,110
Jetzt sind wir an der Box mit einem Zeiger.

118
00:10:44,110 --> 00:10:49,940
Der zweite Stern, sagt folgen erneut auf den Pfeil,

119
00:10:49,940 --> 00:10:58,230
und jetzt sind wir an der Box mit n, und wir setzen den Wert dieser Box bis 23.

120
00:10:58,230 --> 00:11:05,940
Feststellen, dass die dereference und "Adresse" Betreiber Inversen voneinander.

121
00:11:05,940 --> 00:11:16,990
Dies ermöglicht es mir, so etwas wie * & * & n = 42 zu tun.

122
00:11:16,990 --> 00:11:22,550
Während dies funktioniert, sollten Sie nie etwas tun, wie dies in der Praxis.

123
00:11:22,550 --> 00:11:24,840
Was machen wir eigentlich hier?

124
00:11:24,840 --> 00:11:28,700
Der erste kaufmännische packt die Adresse der Variablen n.

125
00:11:28,700 --> 00:11:34,660
Dann haben wir eine Dereferenzierungsoperator, die wir an diese Adresse gehen im Speicher bedeutet,

126
00:11:34,660 --> 00:11:36,910
so sind wir wieder bei n.

127
00:11:36,910 --> 00:11:40,910
Jetzt greifen wir die Adresse von n immer sofort Dereferenzierung,

128
00:11:40,910 --> 00:11:50,780
so sind wir wieder bei n und speichern 42.

129
00:11:50,780 --> 00:11:55,490
Also, jedes Paar von * & just aufhebt.

130
00:11:55,490 --> 00:11:59,980
>> Es gibt einen speziellen Zeiger namens der Null-Zeiger.

131
00:11:59,980 --> 00:12:03,140
Dies ist ein Zeiger, dass wir nie dereferenzieren.

132
00:12:03,140 --> 00:12:07,130
Solch ein Zeiger ist wichtig, weil sie uns einen Weg zu unterscheiden zwischen

133
00:12:07,130 --> 00:12:10,220
ein Zeiger, und sollte nicht aufgelöst werden.

134
00:12:10,220 --> 00:12:13,050
Wenn Sie versuchen, Dereferenzierung eines Null-Zeiger,

135
00:12:13,050 --> 00:12:17,150
typischerweise Ihr Programm mit einem Segmentation Fault abstürzen,

136
00:12:17,150 --> 00:12:19,210
die Sie vielleicht schon einmal gesehen zu haben.

137
00:12:19,210 --> 00:12:30,490
Also, lasst uns sagen, wir haben den Code int * x = null; * x = 4.

138
00:12:30,490 --> 00:12:36,190
In diesem Beispiel kann es scheint offensichtlich, dass wir etwas Schlechtes tut,

139
00:12:36,190 --> 00:12:40,650
aber denken Sie daran, dass null könnte wirklich ein Wert von einem Aufruf einer Funktion zurückgegeben werden

140
00:12:40,650 --> 00:12:45,930
wie malloc ist, wenn malloc kann den Speicher vom Benutzer angeforderten zuzuteilen.

141
00:12:45,930 --> 00:12:50,200
Aus diesem Grund, wenn wir stattdessen den Wert von x von einem Aufruf von malloc,

142
00:12:50,200 --> 00:13:12,050
wie in int * x = malloc (sizeof (int)), dann sollten wir uns immer explizit zu überprüfen

143
00:13:12,050 --> 00:13:15,280
zu sehen, ob null zurückgegeben wurde.

144
00:13:15,280 --> 00:13:43,250
If (x == null) / / uhoh! return; sonst können wir weiter auf und sagen * x = 4.

145
00:13:43,250 --> 00:13:47,780
>> Also, noch einmal, warum sollten wir jemals benutzen Zeigern?

146
00:13:47,780 --> 00:13:51,910
Lassen Sie uns ein Beispiel für ein Programm, wo wir brauchen, um Zeiger zu verwenden aussehen -

147
00:13:51,910 --> 00:13:54,110
ein einfacher Swap-Funktion.

148
00:13:54,110 --> 00:14:08,270
Lassen Sie uns sagen, ich habe zwei Zahlen, int x = 4, und int y = 15;

149
00:14:08,270 --> 00:14:21,220
und ich möchte eine Funktion namens Swap, dass ich wie so verwenden, schreiben: swap (x, y).

150
00:14:21,220 --> 00:14:28,270
Nach dieser Zeile sind die Werte im Inneren der Variablen x 15 sein,

151
00:14:28,270 --> 00:14:32,360
und der Wert innerhalb variable y sollte 4.

152
00:14:32,360 --> 00:14:36,510
Die Werte innerhalb von x und y sind vertauscht.

153
00:14:36,510 --> 00:14:53,040
Ohne Zeiger, könnten wir so etwas wie void swap versuchen (int a, int b);

154
00:14:53,040 --> 00:15:09,750
int tmp = b, b = a; a = tmp.

155
00:15:09,750 --> 00:15:12,960
Aber bemerken Sie das Problem mit diesen?

156
00:15:12,960 --> 00:15:19,000
Beachten Sie, dass der Wert in der Variable gespeichert a nur eine Kopie des Wertes von x,

157
00:15:19,000 --> 00:15:22,000
und der Wert von b ist von y kopiert.

158
00:15:22,000 --> 00:15:28,000
Alle Änderungen an a und b nicht in x und y reflektiert.

159
00:15:28,000 --> 00:15:32,050
Während also die Werte von a und b vertauscht sind korrekt,

160
00:15:32,050 --> 00:15:35,810
x und y sind überhaupt nicht verändert.

161
00:15:35,810 --> 00:15:38,480
Jetzt ändern wir die Swap-Funktion, so dass ihre Argumente

162
00:15:38,480 --> 00:15:42,180
sind Zeiger auf die Variablen, die es tauschen, möchte so:

163
00:15:42,180 --> 00:15:56,880
void swap (int * a, int * b); int tmp = * b, * b = * a; * a = tmp.

164
00:15:56,880 --> 00:16:00,140
Beachten Sie, dass Swaps Argumente sind nun Zeiger,

165
00:16:00,140 --> 00:16:05,670
und so müssen wir die Adresse von x und y in dem Aufruf zu tauschen, wie so übergeben:

166
00:16:05,670 --> 00:16:15,280
swap (& x, & y).

167
00:16:15,280 --> 00:16:20,520
Dies nun korrekt vertauscht die Werte von x und y.

168
00:16:20,520 --> 00:16:24,310
>> Ziehen wir eine Box-and-Pfeil-Diagramm, warum diese Werke zu sehen.

169
00:16:24,310 --> 00:16:28,520
Wir beginnen mit unseren beiden Boxen in dem Speicher, x und y.

170
00:16:28,520 --> 00:16:35,780
Innere des Kastens für x die Zahl 4 und Innenraum des Kastens für y haben wir 15.

171
00:16:35,780 --> 00:16:41,200
Jetzt, innerhalb der Aufruf an die Swap-Funktion, haben wir zwei weitere Boxen

172
00:16:41,200 --> 00:16:45,140
für die Argumente a und b;

173
00:16:45,140 --> 00:16:50,960
ein Zug an der Box für x und b zeigt auf der Box für y.

174
00:16:50,960 --> 00:16:58,070
Ein neues Feld für die Variable tmp erstellt,

175
00:16:58,070 --> 00:17:01,470
und nach innen von ihm speichern wir das Ergebnis der Dereferenzierung b,

176
00:17:01,470 --> 00:17:04,980
was bedeutet, "folgen Sie dem Pfeil aus dem Feld mit der Bezeichnung b.

177
00:17:04,980 --> 00:17:09,880
So speichern wir 15 innerhalb des tmp.

178
00:17:09,880 --> 00:17:20,560
Dann folgen wir den Pfeil b und speichern Sie hier das Ergebnis der Dereferenzierung a,

179
00:17:20,560 --> 00:17:24,569
das ist der Wert 4.

180
00:17:24,569 --> 00:17:35,590
Schließlich folgen wir dem Pfeil auf ein und speichern, was derzeit innerhalb tmp ist die 15.

181
00:17:35,590 --> 00:17:42,440
Beachten Sie, dass die Kästen markiert x und y Werte korrekt vertauscht.

182
00:17:42,440 --> 00:17:46,290
>> Sobald wir mehr über malloc und dynamische Speicherverwaltung,

183
00:17:46,290 --> 00:17:49,610
wir werden sehen, dass wir keine andere Wahl haben, als Zeiger verwenden.

184
00:17:49,610 --> 00:17:52,690
Ein Spaziergang durch die Box-and-Pfeil-Diagramm für jedes Programm

185
00:17:52,690 --> 00:17:55,980
kann Ihnen helfen, herauszufinden, was das Programm wirklich tut.

186
00:17:55,980 --> 00:17:59,680
>> Mein Name ist Rob Bowden, und dies ist CS50.

187
00:18:00,000 --> 00:18:02,500
[CS50.TV]

188
00:18:02,500 --> 00:18:06,070
>> Dies ist eine andere Verwendung für die asterisk - bleah, ich hasse dieses Wort.

189
00:18:06,070 --> 00:18:13,960
Überall, wo wir nur sagen n verwendet werden, können wir jetzt sagen pointer_to_n - nein, du kann nicht - * pointer_to_n.