1
00:00:00,000 --> 00:00:02,440
[Powered by Google Translate] [Näiturid]

2
00:00:02,440 --> 00:00:05,000
[Rob Bowden] [Harvardi Ülikool]

3
00:00:05,000 --> 00:00:07,360
[See on CS50] [CS50.TV]

4
00:00:07,360 --> 00:00:08,820
>> Räägime suunanäitajaks.

5
00:00:08,820 --> 00:00:13,710
Siiani oleme alati just nimetatud asju mälus selgelt nimepidi.

6
00:00:13,710 --> 00:00:22,610
Me oleme öelnud int n = 42; ja siis kui tahame kasutada muutuja n,

7
00:00:22,610 --> 00:00:30,640
me lihtsalt nimetame seda nime me anname seda kirjutades midagi n * 2.

8
00:00:30,640 --> 00:00:34,790
Aga see muutuja peavad elama kuskil mälus.

9
00:00:34,790 --> 00:00:37,790
Kui soovite kasutada väärtust, mis on praegu talletatud n,

10
00:00:37,790 --> 00:00:40,730
või uuendage väärtust, et n hoiab,

11
00:00:40,730 --> 00:00:44,180
Teie programm peab teadma, kus mälu otsima n.

12
00:00:44,180 --> 00:00:48,320
Kui mälu muutuv elu on kutsunud oma aadress.

13
00:00:48,320 --> 00:00:49,940
See on nagu maja aadress.

14
00:00:49,940 --> 00:00:53,080
Oskan leida kellegi maja nii kaua, kui ma tean oma kodune aadress,

15
00:00:53,080 --> 00:00:58,110
ja arvutiprogrammi leida muutuja, kui ta teab oma mälu aadressi.

16
00:00:58,110 --> 00:01:02,660
Mida vihjeid anda on viis otse suheldes nende mälu aadresse.

17
00:01:02,660 --> 00:01:06,860
>> Palju võimu C saadakse on võimalik manipuleerida mälu niimoodi.

18
00:01:06,860 --> 00:01:09,960
Aga suure võimuga kaasneb suur vastutus.

19
00:01:09,960 --> 00:01:14,670
Näiturid saab kasutada ohtlikult piisavalt, et palju programmeerimiskeeli

20
00:01:14,670 --> 00:01:16,460
peida vihjeid täielikult.

21
00:01:16,460 --> 00:01:19,440
Niisiis, miks C annab meile lähtekohad siis?

22
00:01:19,440 --> 00:01:22,680
Nagu te teate, argumente C funktsioon

23
00:01:22,680 --> 00:01:25,370
alati kopeeritakse parameetrid funktsioon.

24
00:01:25,370 --> 00:01:33,260
Niisiis, kutsudes midagi swap mõned muutujad x ja y

25
00:01:33,260 --> 00:01:38,840
ei saa vahetada väärtused x ja y helistades funktsioon,

26
00:01:38,840 --> 00:01:40,810
isegi kui see võib olla mugav.

27
00:01:40,810 --> 00:01:46,430
Nagu näeme hiljem, ümberkirjutamise swap võtta viiteid asukohad vajavad vahetasid

28
00:01:46,430 --> 00:01:49,690
võimaldab tal mõjutada oma helistaja muutujad.

29
00:01:49,690 --> 00:01:54,150
>> Vaatame läbi kõndida suhteliselt lihtne näide sellest, mida vihjeid teha.

30
00:01:54,150 --> 00:02:15,550
Oletame, et meil on int n = 4; ja int * pointer_to_n = & n.

31
00:02:15,550 --> 00:02:18,990
Vau! Natuke uus süntaks katmiseks.

32
00:02:18,990 --> 00:02:22,600
Esiteks, ärgem seda tõlgendada & n.

33
00:02:22,600 --> 00:02:27,260
Pea meeles, et kõik mälus on mingi aadress.

34
00:02:27,260 --> 00:02:30,800
Ampersand nimetatakse "aadress" operaator.

35
00:02:30,800 --> 00:02:36,470
Niisiis, & n viitab aadress mälus, kus n on salvestatud.

36
00:02:36,470 --> 00:02:41,560
Nüüd oleme ladustamiseks sellele aadressile uues muutuja, pointer_to_n.

37
00:02:41,560 --> 00:02:43,870
Mis tüüpi on selle uue muutuja?

38
00:02:43,870 --> 00:02:47,410
Tärn on muutuja tüüp,

39
00:02:47,410 --> 00:02:49,880
ja me lugeda tüübiks int *.

40
00:02:49,880 --> 00:02:56,500
Int * tähendab, et pointer_to_n on muutuja, mis salvestab aadress täisarv.

41
00:02:56,500 --> 00:03:02,970
Me teame, et & n on int * kuna n on täisarv, ja me võtame aadress n.

42
00:03:02,970 --> 00:03:06,660
Int * on näide osutiloendurid.

43
00:03:06,660 --> 00:03:10,150
Niipea kui hakkate nägema tärnid on tüüp,

44
00:03:10,150 --> 00:03:11,950
sa tead, et sul tegu on suunanäitajaks.

45
00:03:11,950 --> 00:03:16,520
Just nagu me võib kuulutada muutuja kui int x ja char y,

46
00:03:16,520 --> 00:03:20,410
võib öelda, int * z ja char * w.

47
00:03:20,410 --> 00:03:25,190
Int * ja char * on vaid uut tüüpi meie jaoks kasutada.

48
00:03:25,190 --> 00:03:29,430
Asukoht * ei lähe kuhugi enne muutuja nimi.

49
00:03:29,430 --> 00:03:34,730
Nii, nii int * pointer_to_n - koos * kõrval keskmine, nagu meil siin -

50
00:03:34,730 --> 00:03:45,210
ja int * pointer_to_n koos * kõrval pointer_to_n kehtivad.

51
00:03:45,210 --> 00:03:56,470
Aga siin, ma panna * kõrval int.

52
00:03:56,470 --> 00:04:00,600
See ei ole tähtis, mis sulle meeldib, lihtsalt olla järjekindel.

53
00:04:00,600 --> 00:04:02,810
>> Joonistame skeem selle eest.

54
00:04:02,810 --> 00:04:07,590
Me kõigepealt muutuja n, mis me teha nii väikest kasti mälu.

55
00:04:07,590 --> 00:04:15,400
Selle näite, oletame, et see kast asub aadressil 100.

56
00:04:15,400 --> 00:04:18,820
Toas see ruut, me ladustamiseks väärtus 4.

57
00:04:18,820 --> 00:04:23,730
Nüüd on meil uus muutuja, pointer_to_n.

58
00:04:23,730 --> 00:04:27,030
Tal on oma kasti mälu,

59
00:04:27,030 --> 00:04:32,900
mis me ütleme on aadressil 200.

60
00:04:32,900 --> 00:04:37,220
Toas see ruut, oleme ladustamiseks aadress n,

61
00:04:37,220 --> 00:04:39,890
mis me enne ütlesin oli 100.

62
00:04:39,890 --> 00:04:44,710
Korduma skeemidel, näete seda näidatakse sõnasõnaline nool

63
00:04:44,710 --> 00:04:48,730
jättes pointer_to_n kasti osutades kast, mis salvestab n.

64
00:04:48,730 --> 00:04:54,620
Nüüd, mida me saame tegelikult teha pointer_to_n?

65
00:04:54,620 --> 00:05:10,400
Noh, kui me ütleme midagi sellist * pointer_to_n = 8, see on erinev kasutus, tärniga

66
00:05:10,400 --> 00:05:14,830
see on täiesti eraldi kasutada tärniga deklareerimisel muutuja

67
00:05:14,830 --> 00:05:16,790
kohta osutiloendurid.

68
00:05:16,790 --> 00:05:21,130
Siin tärniga nimetatakse dereference operaator.

69
00:05:21,130 --> 00:05:26,860
Meie diagramm, mis * pointer_to_n = 8 vahenditega on

70
00:05:26,860 --> 00:05:32,220
minna sisaldav kast pointer_to_n, järgige noolt

71
00:05:32,220 --> 00:05:38,160
ja siis määrata kasti lõpus nool väärtus 8.

72
00:05:38,160 --> 00:05:45,960
See tähendab, et pärast seda joont, kui me püüame kasutada n see on väärtus 8.

73
00:05:45,960 --> 00:05:51,600
Sõna "osuti" kasutatakse palju eri kontekstides.

74
00:05:51,600 --> 00:05:54,380
Siin püüan olla järjekindel.

75
00:05:54,380 --> 00:05:58,330
Osutiloendurid on midagi int *.

76
00:05:58,330 --> 00:06:04,630
Selles videos osuti kasutatakse vaid tähendab väärtus osutiloendurid,

77
00:06:04,630 --> 00:06:08,180
nagu pointer_to_n mis on tüüpi int *.

78
00:06:08,180 --> 00:06:15,140
Kõikjal me harjunud lihtsalt öelda, n, saame nüüd selle asemel öelda * pointer_to_n,

79
00:06:15,140 --> 00:06:18,020
ja kõik töötab sama hästi.

80
00:06:18,020 --> 00:06:21,120
>> Kõnni läbi teise lihtsa näite.

81
00:06:21,120 --> 00:06:50,390
Oletame, et meil on int n = 14; int * pointer = &n; n + + ja (* pointer) + +.

82
00:06:50,390 --> 00:06:59,830
Esimene rida loob uue kasti mälu märgistatud n.

83
00:06:59,830 --> 00:07:05,400
Seekord me ei märgistama kasti selgesõnalise aadress, kuid see on veel üks.

84
00:07:05,400 --> 00:07:11,810
Kasti sisemus, me ladustamiseks number 14.

85
00:07:11,810 --> 00:07:22,290
Järgmisel real loob teise kasti osuti.

86
00:07:22,290 --> 00:07:27,210
Ja seest see kast, me talletamiseks viit kasti n.

87
00:07:27,210 --> 00:07:33,170
Niisiis, oletame, joonistada noole kursor n.

88
00:07:33,170 --> 00:07:37,790
Nüüd, n + + kaupa väärtuse väljal n,

89
00:07:37,790 --> 00:07:45,420
nii me läheme 14-15.

90
00:07:45,420 --> 00:07:53,330
Lõpuks (* pointer) + + läheb kasti Kursori

91
00:07:53,330 --> 00:08:02,660
dereferences kasti väärtus, mis tähendab Järgige noolt, kus ta märgib,

92
00:08:02,660 --> 00:08:11,690
ja kaupa salvestatud väärtus olemas, nii et me läheme 15-16.

93
00:08:11,690 --> 00:08:13,480
Ja ongi kõik.

94
00:08:13,480 --> 00:08:18,480
N nüüd salvestab number 16 pärast seda, kui suurendatakse kaks korda -

95
00:08:18,480 --> 00:08:25,050
kui otse, kasutades muutuja nimi n ja teine ​​läbi pointer_to_n.

96
00:08:25,050 --> 00:08:33,360
>> Kiire viktoriin. Mis sa arvad, see tähendab, et kui ma üritan öelda midagi && n?

97
00:08:33,360 --> 00:08:41,350
Noh, selle ümber kirjutada kui & (& n), mis saavutatakse sama asi.

98
00:08:41,350 --> 00:08:47,030
(& N) tagastab aadress muutuja n mällu.

99
00:08:47,030 --> 00:08:53,110
Aga siis siis välimine ampersand üritab naasta aadress aadress.

100
00:08:53,110 --> 00:08:56,600
See on nagu üritab teha & 2.

101
00:08:56,600 --> 00:09:00,550
See ei ole mõtet saada aadress vaid mõned arv

102
00:09:00,550 --> 00:09:03,260
kuna see ei ole mälus.

103
00:09:03,260 --> 00:09:07,090
Kasutades kahte ampersandid järjest ei ole kunagi õige mõte.

104
00:09:07,090 --> 00:09:28,960
Aga nüüd, mida see tähendab, kui ma üritan öelda int ** double_pointer = & pointer?

105
00:09:28,960 --> 00:09:40,750
Nüüd ma loon uue kasti double_pointer,

106
00:09:40,750 --> 00:09:44,590
ja sees, et kast Ma ladustamiseks aadress pointer,

107
00:09:44,590 --> 00:09:50,810
mis tähendab, et ma joonistada noole double_pointer kasti osuti kasti.

108
00:09:50,810 --> 00:09:56,640
Teade tüüpi double_pointer, int **.

109
00:09:56,640 --> 00:10:03,700
N oli täisarv, osuti salvestatud aadress n, ja nii see on tüüpi int *.

110
00:10:03,700 --> 00:10:10,550
Nüüd double_pointer salvestab aadress pointer, nii et see on tüüpi int **.

111
00:10:10,550 --> 00:10:15,070
>> Niisiis, mida me arvame, see tähendab -

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

113
00:10:24,490 --> 00:10:28,630
Pange tähele, et ma olen nüüd viite mahavõtmine kaks korda.

114
00:10:28,630 --> 00:10:32,030
Jälgi kasti-ja nool skeemil oleme juba loonud.

115
00:10:32,030 --> 00:10:36,400
Esiteks, me läheme kasti double_pointer.

116
00:10:36,400 --> 00:10:40,550
Esimene * tähendab Järgige noolt korraga.

117
00:10:40,550 --> 00:10:44,110
Nüüd oleme väljal kursor.

118
00:10:44,110 --> 00:10:49,940
Teine täht ütleb Järgige noolt uuesti,

119
00:10:49,940 --> 00:10:58,230
ja nüüd me oleme kasti n, ja seadsime väärtus selle lahtri 23.

120
00:10:58,230 --> 00:11:05,940
Pange tähele, et dereference ja "aadress" operaatorid on pöördvõrdelised üksteist.

121
00:11:05,940 --> 00:11:16,990
See võimaldab mul teha midagi sellist * & * & n = 42.

122
00:11:16,990 --> 00:11:22,550
Kuigi see töötab, sa ei tohi kunagi midagi sellist teha praktikas.

123
00:11:22,550 --> 00:11:24,840
Mida me tegelikult siin teed?

124
00:11:24,840 --> 00:11:28,700
Esimene märk haarab aadress muutuja n.

125
00:11:28,700 --> 00:11:34,660
Siis on meil dereference operaator, mis tähendab, et me ei kavatse sellele aadressile mälu,

126
00:11:34,660 --> 00:11:36,910
nii et me oleme tagasi n.

127
00:11:36,910 --> 00:11:40,910
Nüüd haarata aadress n jälle ja kohe dereference,

128
00:11:40,910 --> 00:11:50,780
nii et me oleme tagasi n ja pood 42.

129
00:11:50,780 --> 00:11:55,490
Niisiis, iga paari * ja lihtsalt tühjaks.

130
00:11:55,490 --> 00:11:59,980
>> On olemas spetsiaalne osuti nimetatakse nullviit.

131
00:11:59,980 --> 00:12:03,140
See on kursor, et me ei tohiks kunagi dereference.

132
00:12:03,140 --> 00:12:07,130
Selline osuti on oluline, sest see annab meile viis eristada

133
00:12:07,130 --> 00:12:10,220
pointer, mis peaks ja ei tohiks dereferenced.

134
00:12:10,220 --> 00:12:13,050
Kui üritate dereference nullviida,

135
00:12:13,050 --> 00:12:17,150
tavaliselt oma programmi krahhi koos killustatust süü,

136
00:12:17,150 --> 00:12:19,210
mis olete näinud.

137
00:12:19,210 --> 00:12:30,490
Niisiis, oletame, et meil on kood int * x = null; * x = 4.

138
00:12:30,490 --> 00:12:36,190
Selles näites, see võib tunduda ilmselge, et me teeme midagi halba,

139
00:12:36,190 --> 00:12:40,650
kuid pea meeles, et null võiks tõesti olla raha tagastatud kõne funktsioon

140
00:12:40,650 --> 00:12:45,930
nagu malloc, kui malloc pole suuteline eraldama mälu kutsuma kasutaja.

141
00:12:45,930 --> 00:12:50,200
Seetõttu, kui selle asemel seadsime x väärtus alates kõne malloc,

142
00:12:50,200 --> 00:13:12,050
nagu int * x = malloc (sizeof (int)), siis peaksime alati selgelt näha

143
00:13:12,050 --> 00:13:15,280
et näha, kas null tagastati.

144
00:13:15,280 --> 00:13:43,250
Kui (x == null) / / uhoh! tagasipöördumist; muidu saame jätkata ja öelda * x = 4.

145
00:13:43,250 --> 00:13:47,780
>> Nii et jällegi, miks peaks me kunagi kasutada viiteid?

146
00:13:47,780 --> 00:13:51,910
Vaatame näiteks programm, kus me peame kasutama viiteid -

147
00:13:51,910 --> 00:13:54,110
lihtne swap funktsiooni.

148
00:13:54,110 --> 00:14:08,270
Oletame, et mul on kaks täisarvu, int x = 4; ja int y = 15;

149
00:14:08,270 --> 00:14:21,220
ja ma tahan kirjutada funktsioon nimega swap, et saan kasutada nii: swap (x, y).

150
00:14:21,220 --> 00:14:28,270
Pärast seda joont, väärtused sees muutuja x peaks olema 15,

151
00:14:28,270 --> 00:14:32,360
ja väärtus sees muutuja y peaks olema 4.

152
00:14:32,360 --> 00:14:36,510
Väärtused sees x ja y on vahetatud.

153
00:14:36,510 --> 00:14:53,040
Ilma suunanäitajaks, me võiksime proovida midagi tühine swap (int, int b);

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

155
00:15:09,750 --> 00:15:12,960
Aga, kas te märkate sellega probleem?

156
00:15:12,960 --> 00:15:19,000
Pea meeles, et salvestatud väärtuse muutuja on lihtsalt koopia x väärtus,

157
00:15:19,000 --> 00:15:22,000
ja väärtus b kopeeritakse y.

158
00:15:22,000 --> 00:15:28,000
Tehtud muudatusi ja b ei kajastu x ja y.

159
00:15:28,000 --> 00:15:32,050
Seega, kui väärtused a ja b on korrektselt vahetatud,

160
00:15:32,050 --> 00:15:35,810
x ja y ei ole muutunud üldse.

161
00:15:35,810 --> 00:15:38,480
Nüüd saab muuta swap funktsiooni nii, et selle argumentideks

162
00:15:38,480 --> 00:15:42,180
on viiteid, et muutujad tuleb vahetada, näiteks nii:

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

164
00:15:56,880 --> 00:16:00,140
Pea meeles, et vahetustehingud argumendid on nüüd suunanäitajaks,

165
00:16:00,140 --> 00:16:05,670
ja seega peame läbima aadress x ja y kõne vahetada, näiteks nii:

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

167
00:16:15,280 --> 00:16:20,520
See nüüd õigesti vahetuslepingud väärtused x ja y.

168
00:16:20,520 --> 00:16:24,310
>> Joonistame kasti-ja nool skeemil näha, miks see töötab.

169
00:16:24,310 --> 00:16:28,520
Alustame meie kaks karpi mälestuseks, x ja y.

170
00:16:28,520 --> 00:16:35,780
Kasti sisemus x on number 4 ja sisemust jaoks y meil on 15.

171
00:16:35,780 --> 00:16:41,200
Nüüd, sees kõne swap funktsiooni, meil on veel kaks kasti

172
00:16:41,200 --> 00:16:45,140
jaoks argumendid a ja b;

173
00:16:45,140 --> 00:16:50,960
osutab kasti x, ja b võrra kasti y.

174
00:16:50,960 --> 00:16:58,070
Uus kast on loodud muutuja tmp,

175
00:16:58,070 --> 00:17:01,470
ja sees on meil salvestada tulemus viite mahavõtmine b,

176
00:17:01,470 --> 00:17:04,980
mis tähendab "Järgige noolt alates kast b."

177
00:17:04,980 --> 00:17:09,880
Niisiis, me Kauplusse 15 sees tmp.

178
00:17:09,880 --> 00:17:20,560
Siis me järgime nool b ja salvestada siit tulemus viite mahavõtmine,

179
00:17:20,560 --> 00:17:24,569
mis on väärtus 4.

180
00:17:24,569 --> 00:17:35,590
Lõpuks me järgime noolt ja kauplus milline on hetkel sees tmp, mis on 15.

181
00:17:35,590 --> 00:17:42,440
Pange tähele, et ruudud x ja y on õigesti vahetasid väärtused.

182
00:17:42,440 --> 00:17:46,290
>> Kui me õpime paremini tundma malloc ja dünaamiline mälu haldamine,

183
00:17:46,290 --> 00:17:49,610
me näeme, et meil pole muud valikut kui kasutada viiteid.

184
00:17:49,610 --> 00:17:52,690
Jalutuskäik läbi kasti-ja nool skeemil ühegi programmi

185
00:17:52,690 --> 00:17:55,980
aitab teil aru saada, mida programm tegelikult teeb.

186
00:17:55,980 --> 00:17:59,680
>> Minu nimi on Rob Bowden, ja see on CS50.

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

188
00:18:02,500 --> 00:18:06,070
>> See on erinev kasutamiseks Tärn - Bleah, ma vihkan seda sõna.

189
00:18:06,070 --> 00:18:13,960
Kõikjal me harjunud lihtsalt öelda, n, saame nüüd öelda pointer_to_n - no sa ei saa - * pointer_to_n.