1
00:00:00,000 --> 00:00:06,030
>> [Musik spiller]

2
00:00:06,030 --> 00:00:08,390
>> DOUG Lloyd: Pointers, her er vi.

3
00:00:08,390 --> 00:00:11,080
Dette er sandsynligvis vil
være det vanskeligste emne

4
00:00:11,080 --> 00:00:12,840
at vi taler om i CS50.

5
00:00:12,840 --> 00:00:15,060
Og hvis du har læst
noget om pointers

6
00:00:15,060 --> 00:00:19,080
før du kan være en lille smule
skræmmende at gå ind i denne video.

7
00:00:19,080 --> 00:00:21,260
Det er sandt at pointere
tillader dig mulighed

8
00:00:21,260 --> 00:00:23,740
til måske skrue op
temmelig dårligt, når du er

9
00:00:23,740 --> 00:00:27,450
arbejder med variabler, og data,
og forårsager dit program til at gå ned.

10
00:00:27,450 --> 00:00:30,490
Men de er faktisk virkelig nyttige
og de giver os mulighed for en virkelig god måde

11
00:00:30,490 --> 00:00:33,340
at videregive data frem og
tilbage mellem funktioner,

12
00:00:33,340 --> 00:00:35,490
at vi ellers ikke kan gøre.

13
00:00:35,490 --> 00:00:37,750
>> Og så hvad vi virkelig
ønsker at gøre her er toget

14
00:00:37,750 --> 00:00:41,060
at du har gode pointer disciplin, så
at du kan bruge pegepinde effektivt

15
00:00:41,060 --> 00:00:43,850
at gøre dine programmer, der meget bedre.

16
00:00:43,850 --> 00:00:48,220
Som jeg sagde pegepinde give os en anden
måde at videregive data mellem funktioner.

17
00:00:48,220 --> 00:00:50,270
Nu, hvis du husker fra
en tidligere video, når

18
00:00:50,270 --> 00:00:53,720
vi talte om
variabel rækkevidde, nævnte jeg

19
00:00:53,720 --> 00:01:00,610
at alle de data, vi passerer mellem
funktioner i C forbi værdi.

20
00:01:00,610 --> 00:01:03,070
Og jeg kan ikke har brugt, at
sigt, hvad jeg mente der

21
00:01:03,070 --> 00:01:07,170
var, at vi passerer kopier af data.

22
00:01:07,170 --> 00:01:12,252
Når vi passerer en variabel til en funktion,
Vi er faktisk ikke passerer den variable

23
00:01:12,252 --> 00:01:13,210
til funktionen, ikke?

24
00:01:13,210 --> 00:01:17,670
Vi passerer en kopi af
at data til funktionen.

25
00:01:17,670 --> 00:01:20,760
Funktionen gør, hvad den vil
og beregner en vis værdi,

26
00:01:20,760 --> 00:01:23,180
og måske bruger vi denne værdi
når det giver det tilbage.

27
00:01:23,180 --> 00:01:26,700
>> Der var en undtagelse til
denne regel passere efter værdi,

28
00:01:26,700 --> 00:01:31,210
og vi vil komme tilbage til, hvad det
er lidt senere i denne video.

29
00:01:31,210 --> 00:01:34,880
Hvis vi bruger pegepinde stedet
for at anvende variable,

30
00:01:34,880 --> 00:01:38,180
eller i stedet for ved hjælp af variabler
selv eller kopier af de variabler,

31
00:01:38,180 --> 00:01:43,790
Vi kan nu passere variablerne rundt
mellem funktioner på en anden måde.

32
00:01:43,790 --> 00:01:46,550
Det betyder, at hvis vi gør
en ændring i en funktion,

33
00:01:46,550 --> 00:01:49,827
at ændringen vil faktisk tage
virkning i en anden funktion.

34
00:01:49,827 --> 00:01:52,160
Igen, det er noget,
vi ikke kunne gøre tidligere,

35
00:01:52,160 --> 00:01:56,979
og hvis du nogensinde har prøvet at bytte
værdien af ​​to variabler i en funktion,

36
00:01:56,979 --> 00:01:59,270
du har bemærket, dette problem
slags snigende op, ikke?

37
00:01:59,270 --> 00:02:04,340
>> Hvis vi ønsker at bytte X og Y, og vi
videregive dem til en funktion kaldet swap,

38
00:02:04,340 --> 00:02:08,680
indersiden af ​​funktionen swap
variabler gør bytteværdier.

39
00:02:08,680 --> 00:02:12,600
Man bliver to, to bliver
en, men vi faktisk ikke

40
00:02:12,600 --> 00:02:16,890
ændre noget i den oprindelige
funktion, i den, der ringer.

41
00:02:16,890 --> 00:02:19,550
Fordi vi ikke kan, vi er kun
arbejder med kopier af dem.

42
00:02:19,550 --> 00:02:24,760
Med pointere selv, vi kan
faktisk passerer X og Y til en funktion.

43
00:02:24,760 --> 00:02:26,960
Denne funktion kan gøre
noget med dem.

44
00:02:26,960 --> 00:02:29,250
Og disse variabler værdier
kan faktisk ændre.

45
00:02:29,250 --> 00:02:33,710
Så det er noget af en ændring i
vores evne til at arbejde med data.

46
00:02:33,710 --> 00:02:36,100
>> Før vi dykke ned i
pointere, jeg synes det er værd

47
00:02:36,100 --> 00:02:38,580
tage et par minutter til
gå tilbage til basics her.

48
00:02:38,580 --> 00:02:41,000
Og have et kig på, hvordan
computer hukommelse værker

49
00:02:41,000 --> 00:02:45,340
fordi disse to emner vil
faktisk være temmelig indbyrdes.

50
00:02:45,340 --> 00:02:48,480
Som du sikkert ved,
på din computer system

51
00:02:48,480 --> 00:02:51,310
du har en harddisk eller
måske et SSD-drev,

52
00:02:51,310 --> 00:02:54,430
en slags fil opbevaring placering.

53
00:02:54,430 --> 00:02:57,950
Det er normalt et sted i
kvarter på 250 gigabyte

54
00:02:57,950 --> 00:02:59,810
til måske et par terabytes nu.

55
00:02:59,810 --> 00:03:02,270
Og det er hvor alle dine
filer i sidste ende lever,

56
00:03:02,270 --> 00:03:04,870
selv når computeren er lukket
fra, kan du slå det til igen

57
00:03:04,870 --> 00:03:09,190
og du vil finde dine filer er der
igen, når du genstarter dit system.

58
00:03:09,190 --> 00:03:14,820
Men diskdrev, ligesom en harddisk,
en harddisk eller et SSD-drev, en SSD,

59
00:03:14,820 --> 00:03:16,050
er blot lagerplads.

60
00:03:16,050 --> 00:03:20,400
>> Vi kan faktisk ikke gøre noget med
de data, der er i harddisken,

61
00:03:20,400 --> 00:03:22,080
eller i en SSD-drev.

62
00:03:22,080 --> 00:03:24,950
For at rent faktisk at ændre
data eller flytte den rundt,

63
00:03:24,950 --> 00:03:28,800
vi er nødt til at flytte det til
RAM, random access memory.

64
00:03:28,800 --> 00:03:31,170
Nu RAM, du har en masse
mindre af på din computer.

65
00:03:31,170 --> 00:03:34,185
Du har måske et eller andet sted i
kvarter af 512 megabyte

66
00:03:34,185 --> 00:03:38,850
hvis du har en ældre computer,
til måske to, fire, otte, 16,

67
00:03:38,850 --> 00:03:41,820
måske endda lidt
mere, gigabyte RAM.

68
00:03:41,820 --> 00:03:46,390
Så det er meget mindre, men det er
hvor alle de flygtige data findes.

69
00:03:46,390 --> 00:03:48,270
Det er, hvor vi kan ændre tingene.

70
00:03:48,270 --> 00:03:53,350
Men når vi vende vores computer slukket,
alle data i RAM er ødelagt.

71
00:03:53,350 --> 00:03:57,150
>> Så det er derfor vi har brug for harddisk
for mere permanent placering af det,

72
00:03:57,150 --> 00:03:59,720
så det exists- det ville
være virkelig dårligt, hvis hver gang vi

73
00:03:59,720 --> 00:04:03,310
vendte vores computer slukket, hver
fil i vores system blev udslettet.

74
00:04:03,310 --> 00:04:05,600
Så arbejder vi inde RAM.

75
00:04:05,600 --> 00:04:09,210
Og hver gang vi taler om
hukommelse, temmelig meget, i CS50,

76
00:04:09,210 --> 00:04:15,080
vi taler om RAM, ikke harddisk.

77
00:04:15,080 --> 00:04:18,657
>> Så når vi flytte ting ind i hukommelsen,
det tager en vis mængde plads.

78
00:04:18,657 --> 00:04:20,740
Alle de datatyper, der
vi har arbejdet med

79
00:04:20,740 --> 00:04:23,480
tage forskellige
mængder af plads i RAM.

80
00:04:23,480 --> 00:04:27,600
Så hver gang du opretter et heltal
variable, fire bytes hukommelse

81
00:04:27,600 --> 00:04:30,750
er afsat i RAM, så du
kan arbejde med at heltal.

82
00:04:30,750 --> 00:04:34,260
Du kan erklære heltal,
ændre det, tildele den

83
00:04:34,260 --> 00:04:36,700
til en værdi 10 inkrementeres
efter én, så videre og så videre.

84
00:04:36,700 --> 00:04:39,440
Alt, der skal ske i
RAM, og du får fire bytes

85
00:04:39,440 --> 00:04:42,550
at arbejde med for hver
heltal, du opretter.

86
00:04:42,550 --> 00:04:45,410
>> Hvert tegn, du
skaber får én byte.

87
00:04:45,410 --> 00:04:48,160
Det er bare, hvor meget plads er
for at kunne rumme et tegn.

88
00:04:48,160 --> 00:04:51,310
Hver svømmer, en reel
nummer, får fire bytes

89
00:04:51,310 --> 00:04:53,390
medmindre det er en dobbelt
præcision floating point

90
00:04:53,390 --> 00:04:56,510
nummer, som giver dig mulighed for at
har mere præcise eller flere cifre

91
00:04:56,510 --> 00:04:59,300
efter kommaet
uden at miste præcision,

92
00:04:59,300 --> 00:05:01,820
som optager otte bytes hukommelse.

93
00:05:01,820 --> 00:05:06,730
Lange længes, virkelig store heltal,
også tage otte bytes hukommelse.

94
00:05:06,730 --> 00:05:09,000
Hvor mange bytes hukommelse
gør strygere tage op?

95
00:05:09,000 --> 00:05:12,990
Jamen så lad os sætte en stift i dette spørgsmål
for nu, men vi vil vende tilbage til det.

96
00:05:12,990 --> 00:05:17,350
>> Så tilbage til denne idé om hukommelse som
en stor vifte af byte-størrelse celler.

97
00:05:17,350 --> 00:05:20,871
Det er virkelig alt, hvad det er, det er
bare en enorm matrix af celler,

98
00:05:20,871 --> 00:05:23,370
ligesom enhver anden array, der
du er fortrolig med og se,

99
00:05:23,370 --> 00:05:26,430
undtagen hvert element er en byte bred.

100
00:05:26,430 --> 00:05:30,030
Og ligesom et array,
hvert element har en adresse.

101
00:05:30,030 --> 00:05:32,120
Hvert element i et array
har et indeks, og vi

102
00:05:32,120 --> 00:05:36,302
kan bruge dette indeks til at gøre såkaldte
random access på arrayet.

103
00:05:36,302 --> 00:05:38,510
Vi behøver ikke at starte ved
begyndelsen af ​​grupperingen,

104
00:05:38,510 --> 00:05:40,569
gentage gennem hver
enkelt element heraf,

105
00:05:40,569 --> 00:05:41,860
at finde, hvad vi leder efter.

106
00:05:41,860 --> 00:05:45,790
Vi kan bare sige, jeg ønsker at komme til
15. element eller 100-element.

107
00:05:45,790 --> 00:05:49,930
Og du kan bare passere i dette nummer
og få den værdi, du leder efter.

108
00:05:49,930 --> 00:05:54,460
>> Tilsvarende hver placering
i hukommelsen har en adresse.

109
00:05:54,460 --> 00:05:57,320
Så din hukommelse måske
se noget som dette.

110
00:05:57,320 --> 00:06:01,420
Her er en meget lille luns af
hukommelse, det er 20 bytes hukommelse.

111
00:06:01,420 --> 00:06:04,060
De første 20 byte, fordi min
adresser der nederst

112
00:06:04,060 --> 00:06:08,890
er 0, 1, 2, 3, og så
på hele vejen op til 19.

113
00:06:08,890 --> 00:06:13,190
Og når jeg erklærer variabler og
når jeg begynder at arbejde med dem,

114
00:06:13,190 --> 00:06:15,470
systemet vil sætte
afsat nogle plads til mig

115
00:06:15,470 --> 00:06:17,595
i denne hukommelse til at arbejde
med mine variabler.

116
00:06:17,595 --> 00:06:21,610
Så jeg kan sige, char c lig kapital
H. Og hvad der vil ske?

117
00:06:21,610 --> 00:06:23,880
Godt systemet kommer til at
afsat til mig en byte.

118
00:06:23,880 --> 00:06:27,870
I dette tilfælde valgte byte nummer
fire, byte på adresse fire,

119
00:06:27,870 --> 00:06:31,310
og det kommer til at gemme
bogstavet kapital H i ​​der for mig.

120
00:06:31,310 --> 00:06:34,350
Hvis jeg så sige int hastighed
grænse er lig med 65, er det

121
00:06:34,350 --> 00:06:36,806
kommer til at afsætte fire
bytes hukommelse for mig.

122
00:06:36,806 --> 00:06:39,180
Og det kommer til at behandle dem,
fire bytes som en enkelt enhed

123
00:06:39,180 --> 00:06:41,305
fordi det, vi arbejder
med, er et helt tal her.

124
00:06:41,305 --> 00:06:44,350
Og det kommer til at gemme 65 derinde.

125
00:06:44,350 --> 00:06:47,000
>> Nu allerede Jeg er lidt
fortæller dig lidt af en løgn,

126
00:06:47,000 --> 00:06:50,150
ret, fordi vi ved, at
computere arbejde i binær.

127
00:06:50,150 --> 00:06:53,100
De forstår ikke
nødvendigvis, hvad en kapital H er

128
00:06:53,100 --> 00:06:57,110
eller hvad en 65 er, at de kun
forstår binære, nuller og ettaller.

129
00:06:57,110 --> 00:06:59,000
Og så faktisk, hvad
vi opbevaring derinde

130
00:06:59,000 --> 00:07:03,450
er ikke bogstavet H og antallet 65,
men snarere de binære repræsentationer

131
00:07:03,450 --> 00:07:06,980
heraf, som ser et
lidt noget som dette.

132
00:07:06,980 --> 00:07:10,360
Og især i
forbindelse med heltalsvariablen,

133
00:07:10,360 --> 00:07:13,559
Det kommer ikke til at bare spytte det ind,
Det kommer ikke til at behandle det som en fire

134
00:07:13,559 --> 00:07:15,350
byte chunk nødvendigvis,
Det er faktisk at gå

135
00:07:15,350 --> 00:07:19,570
at behandle det som fire én byte bidder,
som kunne se noget som dette.

136
00:07:19,570 --> 00:07:22,424
Og selv dette ikke er
helt rigtigt enten,

137
00:07:22,424 --> 00:07:24,840
på grund af noget, der hedder
en endethed, som vi ikke

138
00:07:24,840 --> 00:07:26,965
vil komme ind nu, men
hvis du er nysgerrig efter at vide,

139
00:07:26,965 --> 00:07:29,030
du kan læse op på lidt
og store endethed.

140
00:07:29,030 --> 00:07:31,640
Men af ​​hensyn til dette argument,
af hensyn til denne video,

141
00:07:31,640 --> 00:07:34,860
lad os bare antage, at er i
Faktisk hvordan antallet 65 ville

142
00:07:34,860 --> 00:07:36,970
være repræsenteret i
hukommelse på ethvert system,

143
00:07:36,970 --> 00:07:38,850
selv om det ikke er helt rigtigt.

144
00:07:38,850 --> 00:07:41,700
>> Men lad os faktisk bare få
komme af med alle binære helt,

145
00:07:41,700 --> 00:07:44,460
og bare tænke som H
og 65, det er meget nemmere

146
00:07:44,460 --> 00:07:47,900
til at tænke over det som
at som et menneske.

147
00:07:47,900 --> 00:07:51,420
Okay, så det også virker måske en
lidt tilfældigt, at I've- mit system

148
00:07:51,420 --> 00:07:55,130
gav mig ikke byte 5, 6, 7,
og 8 for at gemme heltal.

149
00:07:55,130 --> 00:07:58,580
Der er en grund til det, også, hvilket
Vi vil ikke komme ind lige nu, men tilstrækkeligt

150
00:07:58,580 --> 00:08:00,496
Det vil sige, at det,
computer gør her

151
00:08:00,496 --> 00:08:02,810
er nok et godt træk på sin side.

152
00:08:02,810 --> 00:08:06,020
Hvis du ikke vil give mig hukommelse, der er
nødvendigvis ryg mod ryg.

153
00:08:06,020 --> 00:08:10,490
Selvom det kommer til at gøre det nu
hvis jeg ønsker at få en anden streng,

154
00:08:10,490 --> 00:08:13,080
kaldet efternavn, og jeg vil
at sætte Lloyd derinde.

155
00:08:13,080 --> 00:08:18,360
Jeg har tænkt mig at brug for at passe en
karakter, hvert bogstav i det er

156
00:08:18,360 --> 00:08:21,330
vil kræve en
karakter, en byte hukommelse.

157
00:08:21,330 --> 00:08:26,230
Så hvis jeg kunne sætte Lloyd i min matrix
som dette Jeg er temmelig god til at gå, ikke?

158
00:08:26,230 --> 00:08:28,870
Hvad mangler?

159
00:08:28,870 --> 00:08:31,840
>> Husk, at hver streng vi arbejder
med i C slutter med omvendt skråstreg nul,

160
00:08:31,840 --> 00:08:33,339
og vi kan ikke udelade at her, enten.

161
00:08:33,339 --> 00:08:36,090
Vi er nødt til at afsætte én byte
hukommelse til at fastslå, at så vi

162
00:08:36,090 --> 00:08:39,130
vide, når vores strengen er afsluttet.

163
00:08:39,130 --> 00:08:41,049
Så igen dette arrangement
af den måde, tingene

164
00:08:41,049 --> 00:08:42,799
vises i hukommelsen magt
være lidt tilfældigt,

165
00:08:42,799 --> 00:08:44,870
men det faktisk er sådan,
de fleste systemer er konstrueret.

166
00:08:44,870 --> 00:08:48,330
At line dem op på multipler
af fire grunde igen

167
00:08:48,330 --> 00:08:50,080
at vi ikke behøver at
komme ind lige nu.

168
00:08:50,080 --> 00:08:53,060
Men dette, så er det tilstrækkeligt at sige, at
efter disse tre linjer kode,

169
00:08:53,060 --> 00:08:54,810
dette er, hvad hukommelse kunne se ud.

170
00:08:54,810 --> 00:08:58,930
Hvis jeg har brug for hukommelsespladser
4, 8 og 12 for at holde mine data,

171
00:08:58,930 --> 00:09:01,100
dette er hvad min hukommelse kunne se ud.

172
00:09:01,100 --> 00:09:04,062
>> Og bare være særlig
pedantiske her, når

173
00:09:04,062 --> 00:09:06,020
vi taler om hukommelse
adresser vi normalt

174
00:09:06,020 --> 00:09:08,390
gøre det ved hjælp hexadecimale notationer.

175
00:09:08,390 --> 00:09:12,030
Så hvorfor gør vi ikke konvertere alle disse
fra decimal til hexadecimal notation

176
00:09:12,030 --> 00:09:15,010
bare fordi det er generelt
hvordan vi henvise til hukommelsen.

177
00:09:15,010 --> 00:09:17,880
Så i stedet for at være 0 ved
19, hvad vi har, er nul

178
00:09:17,880 --> 00:09:20,340
x nul gennem nul x1 tre.

179
00:09:20,340 --> 00:09:23,790
Det er de 20 bytes hukommelse, som vi
har eller vi kigger på i dette billede

180
00:09:23,790 --> 00:09:25,540
lige her.

181
00:09:25,540 --> 00:09:29,310
>> Så alt dette er sagt, så lad os
skridt væk fra hukommelse til en anden

182
00:09:29,310 --> 00:09:30,490
og tilbage til pointere.

183
00:09:30,490 --> 00:09:32,420
Her er det vigtigste
ting at huske

184
00:09:32,420 --> 00:09:34,070
da vi begynder at arbejde med pointere.

185
00:09:34,070 --> 00:09:36,314
En pointer er intet
mere end en adresse.

186
00:09:36,314 --> 00:09:38,230
Jeg vil sige det igen, fordi
det er så vigtigt,

187
00:09:38,230 --> 00:09:42,730
en pointer er intet
mere end en adresse.

188
00:09:42,730 --> 00:09:47,760
Pegepinde er adresser til steder
i hukommelsen, hvor variabler bor.

189
00:09:47,760 --> 00:09:52,590
Vel vidende, at det bliver forhåbentlig en
lidt lettere at arbejde med dem.

190
00:09:52,590 --> 00:09:54,550
En anden ting jeg kan lide
at gøre, er at have sortering

191
00:09:54,550 --> 00:09:58,510
diagrammer visuelt repræsenterer, hvad der er
sker med forskellige linjer kode.

192
00:09:58,510 --> 00:10:00,660
Og vi vil gøre det et par
gange i pointere,

193
00:10:00,660 --> 00:10:03,354
og når vi taler om dynamisk
hukommelse tildeling så godt.

194
00:10:03,354 --> 00:10:06,020
Fordi jeg tror, ​​at disse diagrammer
kan være særligt nyttigt.

195
00:10:06,020 --> 00:10:09,540
>> Så hvis jeg siger for eksempel, int k
i min kode, hvad der sker?

196
00:10:09,540 --> 00:10:12,524
Nå, hvad der dybest set sker der
Jeg får hukommelse afsat til mig,

197
00:10:12,524 --> 00:10:14,690
men jeg ved ikke engang lide at
tænker over det på den måde, jeg

198
00:10:14,690 --> 00:10:16,300
lide at tænke på det som en æske.

199
00:10:16,300 --> 00:10:20,090
Jeg har en kasse, og det er
farvet grøn fordi jeg

200
00:10:20,090 --> 00:10:21,750
kan sætte tal i grønne kasser.

201
00:10:21,750 --> 00:10:23,666
Hvis det var et tegn I
kan have en blå boks.

202
00:10:23,666 --> 00:10:27,290
Men jeg siger altid, hvis jeg opretter
en boks, der kan rumme hele tal

203
00:10:27,290 --> 00:10:28,950
at kassen er farvet grønt.

204
00:10:28,950 --> 00:10:33,020
Og jeg tager en permanent markør
og jeg skriver k på siden af ​​den.

205
00:10:33,020 --> 00:10:37,590
Så jeg har en kasse kaldet k,
ind som jeg kan sætte heltal.

206
00:10:37,590 --> 00:10:41,070
Så når jeg siger int k, der er
hvad der sker i mit hoved.

207
00:10:41,070 --> 00:10:43,140
Hvis jeg siger k lig fem, hvad gør jeg?

208
00:10:43,140 --> 00:10:45,110
Nå, jeg lægger fem
i boksen, højre.

209
00:10:45,110 --> 00:10:48,670
Dette er temmelig ligetil, hvis
Jeg siger int k, skal du oprette en boks kaldet k.

210
00:10:48,670 --> 00:10:52,040
Hvis jeg siger k lig 5,
lægge fem ind i feltet.

211
00:10:52,040 --> 00:10:53,865
Forhåbentlig det er ikke for meget af et spring.

212
00:10:53,865 --> 00:10:55,990
Her er hvor tingene går en
lidt interessant selvom.

213
00:10:55,990 --> 00:11:02,590
Hvis jeg siger int * pk, godt selv om jeg ikke
ved, hvad det nødvendigvis betyder,

214
00:11:02,590 --> 00:11:06,150
det er klart fået noget
at gøre med et heltal.

215
00:11:06,150 --> 00:11:08,211
Så jeg har tænkt mig at farve
dette felt grøn-ish,

216
00:11:08,211 --> 00:11:10,210
Jeg ved, det har noget
at gøre med et heltal,

217
00:11:10,210 --> 00:11:13,400
men det er ikke et heltal selv,
fordi det er en int stjerne.

218
00:11:13,400 --> 00:11:15,390
Der er noget lidt
anderledes om det.

219
00:11:15,390 --> 00:11:17,620
Så et heltal er involveret,
men ellers er det

220
00:11:17,620 --> 00:11:19,830
ikke alt for forskellige fra
hvad vi taler om.

221
00:11:19,830 --> 00:11:24,240
Det er en boks, dens fik en etiket,
det er iført en etiket pk,

222
00:11:24,240 --> 00:11:27,280
og det er stand til at holde
int stjerner, uanset hvad de er.

223
00:11:27,280 --> 00:11:29,894
De har noget at gøre
med heltal, klart.

224
00:11:29,894 --> 00:11:31,060
Her er den sidste linje selv.

225
00:11:31,060 --> 00:11:37,650
Hvis jeg siger pk = & k, whoa,
hvad der lige skete, ikke?

226
00:11:37,650 --> 00:11:41,820
Så denne tilfældige tal, tilsyneladende tilfældig
nummer, bliver kastet ind i feltet der.

227
00:11:41,820 --> 00:11:44,930
Alt det er, er pk
får adressen på k.

228
00:11:44,930 --> 00:11:52,867
Så jeg stikning hvor k bor i hukommelsen,
dens adresse, adressen på dens bytes.

229
00:11:52,867 --> 00:11:55,200
Alt jeg gør er jeg siger
denne værdi er, hvad jeg har tænkt mig

230
00:11:55,200 --> 00:11:59,430
at sætte indersiden af ​​min boks kaldes pk.

231
00:11:59,430 --> 00:12:02,080
Og fordi disse ting er
pegepinde, og fordi at kigge

232
00:12:02,080 --> 00:12:04,955
ved en streng som nul x
otte nul c syv fire otte

233
00:12:04,955 --> 00:12:07,790
to nul er sandsynligvis
ikke meget mening.

234
00:12:07,790 --> 00:12:12,390
Når vi generelt visualisere pointere,
vi rent faktisk gøre det så pointere.

235
00:12:12,390 --> 00:12:17,000
Pk giver os oplysninger
vi nødt til at finde k i hukommelsen.

236
00:12:17,000 --> 00:12:19,120
Så dybest set pk har en pil i det.

237
00:12:19,120 --> 00:12:21,670
Og hvis vi gå længden
af denne pil, forestille sig

238
00:12:21,670 --> 00:12:25,280
det er noget du kan gå på, hvis vi
gå langs længden af ​​pilen,

239
00:12:25,280 --> 00:12:29,490
på selve spidsen af ​​denne pil, vi
vil finde sted i hukommelsen

240
00:12:29,490 --> 00:12:31,390
hvor k bor.

241
00:12:31,390 --> 00:12:34,360
Og det er virkelig vigtigt
fordi når vi ved, hvor k lever,

242
00:12:34,360 --> 00:12:37,870
Vi kan begynde at arbejde med data
indersiden af ​​den hukommelsesposition.

243
00:12:37,870 --> 00:12:40,780
Selvom vi får en teeny
bit foran os selv for nu.

244
00:12:40,780 --> 00:12:42,240
>> Så hvad er en pointer?

245
00:12:42,240 --> 00:12:45,590
En pointer er et dataelement, hvis
værdi er en lageradresse.

246
00:12:45,590 --> 00:12:49,740
Det var, at nul x otte nul kram
foregår, det kunne lageradresse.

247
00:12:49,740 --> 00:12:52,060
Det var en placering i hukommelsen.

248
00:12:52,060 --> 00:12:55,080
Og typen af ​​en pegepind
beskriver den type

249
00:12:55,080 --> 00:12:56,930
af data, du finder på
at hukommelsen adresse.

250
00:12:56,930 --> 00:12:58,810
Så der er den int stjernede del til højre.

251
00:12:58,810 --> 00:13:03,690
Hvis jeg følger, at pilen, er det
kommer til at føre mig til en placering.

252
00:13:03,690 --> 00:13:06,980
Og at placering, hvad jeg
vil finde der i mit eksempel,

253
00:13:06,980 --> 00:13:08,240
er en grøn farvet boks.

254
00:13:08,240 --> 00:13:12,650
Det er et heltal, det er hvad jeg
vil finde, hvis jeg går til denne adresse.

255
00:13:12,650 --> 00:13:14,830
De data type af en
pointer beskriver, hvad

256
00:13:14,830 --> 00:13:17,936
du vil finde på at hukommelsen adresse.

257
00:13:17,936 --> 00:13:19,560
Så her er virkelig cool ting selv.

258
00:13:19,560 --> 00:13:25,090
Pointers tillade os at passere
variable mellem funktioner.

259
00:13:25,090 --> 00:13:28,520
Og faktisk videregive variable
og ikke passere kopier af dem.

260
00:13:28,520 --> 00:13:32,879
For hvis vi ved præcis, hvor
i hukommelsen for at finde en variabel,

261
00:13:32,879 --> 00:13:35,670
Vi behøver ikke at lave en kopi af
det, kan vi bare gå til denne placering

262
00:13:35,670 --> 00:13:37,844
og arbejde med denne variabel.

263
00:13:37,844 --> 00:13:40,260
Så i det væsentlige pejlemærker sortere
af gøre en computer miljø

264
00:13:40,260 --> 00:13:42,360
meget mere som den virkelige verden, højre.

265
00:13:42,360 --> 00:13:44,640
>> Så her er en analogi.

266
00:13:44,640 --> 00:13:48,080
Lad os sige, at jeg har en notesbog,
højre, og det er fuld af noter.

267
00:13:48,080 --> 00:13:50,230
Og jeg vil gerne have dig til at opdatere den.

268
00:13:50,230 --> 00:13:53,960
Du er en funktion, der
opdateringer noter, højre.

269
00:13:53,960 --> 00:13:56,390
På den måde har vi været
arbejder så videre, hvad

270
00:13:56,390 --> 00:14:02,370
sker, er, du vil tage min notesbog,
du vil gå til kopien butikken,

271
00:14:02,370 --> 00:14:06,410
du vil gøre en Xerox kopi af
hver side af den bærbare computer.

272
00:14:06,410 --> 00:14:09,790
Du vil forlade min notesbog tilbage
på mit skrivebord, når du er færdig,

273
00:14:09,790 --> 00:14:14,600
du vil gå og krydse ud ting i mit
notesbog, der er forældede eller forkert,

274
00:14:14,600 --> 00:14:19,280
og så vil du passerer tilbage til
mig stakken af ​​Xerox-sider

275
00:14:19,280 --> 00:14:22,850
der er en kopi af min notesbog med
de ændringer, du har foretaget på det.

276
00:14:22,850 --> 00:14:27,040
Og på det tidspunkt, er det op til mig som
den kaldende funktion, som den, der ringer,

277
00:14:27,040 --> 00:14:30,582
at beslutte at tage dine noter og
integrere dem tilbage i min notesbog.

278
00:14:30,582 --> 00:14:32,540
Så der er en masse trin
involveret her, lige.

279
00:14:32,540 --> 00:14:34,850
Lignende ville det ikke være bedre
hvis jeg bare sige, hey, kan du

280
00:14:34,850 --> 00:14:38,370
opdatere min notebook til
mig, hånd du min notesbog,

281
00:14:38,370 --> 00:14:40,440
og du tager ting og
bogstaveligt krydse dem ud

282
00:14:40,440 --> 00:14:42,810
og opdatere mine noter i min notesbog.

283
00:14:42,810 --> 00:14:45,140
Og derefter give mig min notesbog tilbage.

284
00:14:45,140 --> 00:14:47,320
Det er lidt af, hvad
pointere tillade os at gøre,

285
00:14:47,320 --> 00:14:51,320
de gør dette miljø en masse
mere ligesom hvordan vi opererer i virkeligheden.

286
00:14:51,320 --> 00:14:54,640
>> Okay, så det er, hvad
en pointer er, lad os tale

287
00:14:54,640 --> 00:14:58,040
om, hvordan pegepinde fungerer i C, og
hvordan vi kan begynde at arbejde med dem.

288
00:14:58,040 --> 00:15:02,550
Så der er en meget enkel pointer
i C kaldet nulhenvisning.

289
00:15:02,550 --> 00:15:04,830
De null pointer peger på ingenting.

290
00:15:04,830 --> 00:15:08,310
Dette formentlig ser ud som det er
faktisk ikke en meget nyttig ting,

291
00:15:08,310 --> 00:15:10,500
men som vi vil se en
lidt senere, det faktum

292
00:15:10,500 --> 00:15:15,410
at denne null-pointer eksisterer
faktisk rigtig kan komme i handy.

293
00:15:15,410 --> 00:15:19,090
Og når du opretter en pegepind, og
behøver du ikke indstille sin værdi straks-

294
00:15:19,090 --> 00:15:21,060
et eksempel på indstilling
dens værdi straks

295
00:15:21,060 --> 00:15:25,401
vil være et par glider tilbage
hvor jeg sagde pk lig & k,

296
00:15:25,401 --> 00:15:28,740
pk får k adresse, som
vi vil se, hvad det betyder,

297
00:15:28,740 --> 00:15:32,990
vi vil se, hvordan man kode det shortly-
hvis vi ikke sætte værdien til noget

298
00:15:32,990 --> 00:15:35,380
meningsfuld samme,
Du bør altid

299
00:15:35,380 --> 00:15:37,480
indstille din pointer til at pege til null.

300
00:15:37,480 --> 00:15:40,260
Du bør indstille den til at pege på ingenting.

301
00:15:40,260 --> 00:15:43,614
>> Det er meget anderledes end
bare overlade værdien, som det er

302
00:15:43,614 --> 00:15:45,530
og derefter om en
pointer og blot antager

303
00:15:45,530 --> 00:15:48,042
det er null, fordi det er sjældent sandt.

304
00:15:48,042 --> 00:15:50,000
Så du bør altid indstillet
værdien af ​​en pegepind

305
00:15:50,000 --> 00:15:55,690
til null hvis du ikke indstiller sin værdi
til noget meningsfuldt med det samme.

306
00:15:55,690 --> 00:15:59,090
Du kan kontrollere, om en pegepind værdi
er nul ved hjælp af lighed operatøren

307
00:15:59,090 --> 00:16:05,450
(==), Ligesom du sammenligner ethvert heltal
værdier eller tegn værdier ved hjælp (==)

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

309
00:16:06,320 --> 00:16:10,994
Det er en særlig slags konstant
værdi, som du kan bruge til at teste.

310
00:16:10,994 --> 00:16:13,160
Så det var en meget enkel
pointer, null pointer.

311
00:16:13,160 --> 00:16:15,320
En anden måde at skabe
en pointer er at udvinde

312
00:16:15,320 --> 00:16:18,240
adressen på en variabel
du allerede har oprettet,

313
00:16:18,240 --> 00:16:22,330
og du gør dette ved brug af &
operatør adresse ekstraktion.

314
00:16:22,330 --> 00:16:26,720
Som vi allerede har set tidligere
i det første diagram eksempel jeg viste.

315
00:16:26,720 --> 00:16:31,450
Så hvis x er en variabel, vi har
allerede skabt af typen heltal,

316
00:16:31,450 --> 00:16:35,110
derefter & x er en pointer til et heltal.

317
00:16:35,110 --> 00:16:39,810
& x er-huske, og kommer til at udtrække
adressen på ting til højre.

318
00:16:39,810 --> 00:16:45,350
Og da en pointer er blot en adresse,
end & x er en pointer til et heltal

319
00:16:45,350 --> 00:16:48,560
hvis værdi er, hvor i hukommelsen x liv.

320
00:16:48,560 --> 00:16:50,460
Det er x adresse.

321
00:16:50,460 --> 00:16:53,296
Så & x er adressen på x.

322
00:16:53,296 --> 00:16:55,670
Lad os tage et skridt
videre og oprette forbindelse til noget

323
00:16:55,670 --> 00:16:58,380
Jeg hentydede til i en tidligere video.

324
00:16:58,380 --> 00:17:06,730
Hvis arr er en vifte af doubler, så
& arr firkantede beslag i er en pointer

325
00:17:06,730 --> 00:17:08,109
til en dobbelt.

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

327
00:17:08,970 --> 00:17:12,160
arr firkantede beslag i, hvis
arr er en vifte af doubler,

328
00:17:12,160 --> 00:17:19,069
derefter arr firkantede beslag i er
den i'te element i denne matrix,

329
00:17:19,069 --> 00:17:29,270
og & arr firkantede beslag i er hvor i
hukommelse den i'te element i arr eksisterer.

330
00:17:29,270 --> 00:17:31,790
>> Så hvad er konsekvenserne her?

331
00:17:31,790 --> 00:17:34,570
En arrays navn, implikation
af hele denne ting,

332
00:17:34,570 --> 00:17:39,290
er, at et array navn er
faktisk selv en pegepind.

333
00:17:39,290 --> 00:17:41,170
Du har arbejdet
med pointere langs

334
00:17:41,170 --> 00:17:45,290
hver gang du har brugt et array.

335
00:17:45,290 --> 00:17:49,090
Husk fra eksempel
om variabel rækkevidde,

336
00:17:49,090 --> 00:17:53,420
nær slutningen af ​​videoen jeg præsentere
et eksempel, hvor vi har en funktion

337
00:17:53,420 --> 00:17:56,890
kaldes sæt int og en
funktion kaldet sæt array.

338
00:17:56,890 --> 00:18:00,490
Og din udfordring at bestemme
hvorvidt eller hvad

339
00:18:00,490 --> 00:18:03,220
værdier, som vi udskrives
udgangen af ​​funktionen,

340
00:18:03,220 --> 00:18:05,960
ved udgangen af ​​hovedprogrammet.

341
00:18:05,960 --> 00:18:08,740
>> Hvis du husker fra eksempel
eller hvis du har set videoen,

342
00:18:08,740 --> 00:18:13,080
du ved, at når Dem for-opkaldet til
sæt int effektivt gør ingenting.

343
00:18:13,080 --> 00:18:16,390
Men opfordringen til at indstille vifte gør.

344
00:18:16,390 --> 00:18:19,280
Og jeg slags tilsløres hvorfor
det var tilfældet på det tidspunkt.

345
00:18:19,280 --> 00:18:22,363
Jeg sagde bare, godt det er et array, er det
særligt, du ved, der er en grund.

346
00:18:22,363 --> 00:18:25,020
Årsagen er, at en arrayets
navn er egentlig bare en pointer,

347
00:18:25,020 --> 00:18:28,740
og der er denne særlige
firkantede beslag syntaks,

348
00:18:28,740 --> 00:18:30,510
gøre tingene meget pænere at arbejde med.

349
00:18:30,510 --> 00:18:34,410
Og de gør tanken om en
pointer meget mindre skræmmende,

350
00:18:34,410 --> 00:18:36,800
og det er derfor de er sortering
af præsenteres på den måde.

351
00:18:36,800 --> 00:18:38,600
Men virkelig arrays er bare pointere.

352
00:18:38,600 --> 00:18:41,580
Og det er derfor, når vi
foretaget en ændring til array,

353
00:18:41,580 --> 00:18:44,880
når vi passerede en matrix som en parameter
til en funktion eller som et argument

354
00:18:44,880 --> 00:18:50,110
til en funktion, indholdet af arrayet
faktisk ændret i både callee

355
00:18:50,110 --> 00:18:51,160
og i den, der ringer.

356
00:18:51,160 --> 00:18:55,846
Hvilket for enhver anden form for
variabel vi så ikke var tilfældet.

357
00:18:55,846 --> 00:18:58,970
Så det er bare noget at holde i
tænke på, når du arbejder med pointere,

358
00:18:58,970 --> 00:19:01,610
er, at navnet på en
matrix faktisk en pointer

359
00:19:01,610 --> 00:19:04,750
til det første element i denne matrix.

360
00:19:04,750 --> 00:19:08,930
>> OK, så nu har vi alle disse
fakta, lad os holde ud, til højre.

361
00:19:08,930 --> 00:19:11,370
Hvorfor skal vi bekymre sig om
hvor noget bor.

362
00:19:11,370 --> 00:19:14,120
Nå som jeg sagde, er det temmelig
nyttigt at vide, hvor noget bor

363
00:19:14,120 --> 00:19:17,240
så du kan gå der og ændre det.

364
00:19:17,240 --> 00:19:19,390
Arbejde med det, og faktisk
har den ting, som du

365
00:19:19,390 --> 00:19:23,710
ønsker at gøre til denne variabel får virkning,
og ikke i kraft på nogle kopi af den.

366
00:19:23,710 --> 00:19:26,150
Dette kaldes dereferere.

367
00:19:26,150 --> 00:19:28,690
Vi går til referencen og
vi ændre værdien der.

368
00:19:28,690 --> 00:19:32,660
Så hvis vi har en pegepind og det hedder
pc, og den peger på et tegn,

369
00:19:32,660 --> 00:19:40,610
så kan vi sige * pc og * pc er den
navn på, hvad vi kan finde, hvis vi går

370
00:19:40,610 --> 00:19:42,910
til adressen pc.

371
00:19:42,910 --> 00:19:47,860
Det, vi finder der er en karakter og
* pc er, hvordan vi henvise til de data, der

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

373
00:19:48,880 --> 00:19:54,150
Så vi kunne sige noget lignende
* pc = D eller noget lignende,

374
00:19:54,150 --> 00:19:59,280
og det betyder, at uanset
var på hukommelsesadresse pc,

375
00:19:59,280 --> 00:20:07,040
uanset karakter var tidligere
der, nu er D, hvis vi siger * PC = D.

376
00:20:07,040 --> 00:20:10,090
>> Så her går vi igen med
nogle underlige C ting, højre.

377
00:20:10,090 --> 00:20:14,560
Så vi har set * tidligere som værende
en eller anden måde en del af den datatype,

378
00:20:14,560 --> 00:20:17,160
og nu er det bliver brugt i
en lidt anden sammenhæng

379
00:20:17,160 --> 00:20:19,605
at få adgang til data på et sted.

380
00:20:19,605 --> 00:20:22,480
Jeg ved det er lidt forvirrende og
der er faktisk en del af hele denne

381
00:20:22,480 --> 00:20:25,740
lignende, hvorfor pointers har denne mytologi
omkring dem som værende så kompliceret,

382
00:20:25,740 --> 00:20:28,250
er lidt af en syntaks problem, ærligt.

383
00:20:28,250 --> 00:20:31,810
Men * anvendes i begge sammenhænge,
både som en del af navnet type,

384
00:20:31,810 --> 00:20:34,100
og vi vil se lidt
senere noget andet, også.

385
00:20:34,100 --> 00:20:36,490
Og lige nu er det
dereference operatør.

386
00:20:36,490 --> 00:20:38,760
Så det går til referencen,
det får adgang til data

387
00:20:38,760 --> 00:20:43,000
ved placeringen af ​​markøren, og
giver dig mulighed for at manipulere det efter behag.

388
00:20:43,000 --> 00:20:45,900
>> Nu er meget lig
besøger din nabo, højre.

389
00:20:45,900 --> 00:20:48,710
Hvis du ved, hvad din
nabo bor, er du

390
00:20:48,710 --> 00:20:50,730
ikke hænge ud med din nabo.

391
00:20:50,730 --> 00:20:53,510
Du ved du tilfældigvis
ved, hvor de bor,

392
00:20:53,510 --> 00:20:56,870
men det betyder ikke, at ved
i kraft af at have denne viden

393
00:20:56,870 --> 00:20:59,170
du interagerer med dem.

394
00:20:59,170 --> 00:21:01,920
Hvis du ønsker at interagere med dem,
du nødt til at gå til deres hus,

395
00:21:01,920 --> 00:21:03,760
du er nødt til at gå til, hvor de bor.

396
00:21:03,760 --> 00:21:07,440
Og når du gør det,
så kan du interagere

397
00:21:07,440 --> 00:21:09,420
med dem ligesom du gerne vil.

398
00:21:09,420 --> 00:21:12,730
Og tilsvarende med variabler,
du nødt til at gå til deres adresse

399
00:21:12,730 --> 00:21:15,320
hvis du ønsker at interagere dem,
du kan ikke bare kender adressen.

400
00:21:15,320 --> 00:21:21,495
Og den måde, du går til adressen
at bruge *, de dereference operatøren.

401
00:21:21,495 --> 00:21:23,620
Hvad tror du der sker
hvis vi prøver og dereference

402
00:21:23,620 --> 00:21:25,260
en pegepind, hvis værdi er nul?

403
00:21:25,260 --> 00:21:28,470
Husk på, at null
pointer peger på ingenting.

404
00:21:28,470 --> 00:21:34,110
Så hvis du prøver og dereference
intet eller gå til en adresse ingenting,

405
00:21:34,110 --> 00:21:36,800
hvad tror du der sker?

406
00:21:36,800 --> 00:21:39,630
Tja, hvis du gættede segmentering
skyld, ville du have ret.

407
00:21:39,630 --> 00:21:41,390
Hvis du prøver og dereference
en null-pointer,

408
00:21:41,390 --> 00:21:43,140
du lider en segmentering
fejl. Men vent,

409
00:21:43,140 --> 00:21:45,820
ikke jeg fortælle dig, at
Hvis du ikke kommer

410
00:21:45,820 --> 00:21:49,220
at indstille værdien af ​​din
pointer til noget meningsfuldt,

411
00:21:49,220 --> 00:21:51,000
du skal sætte til null?

412
00:21:51,000 --> 00:21:55,290
Jeg gjorde, og faktisk segmenteringen
skyld er lidt af en god opførsel.

413
00:21:55,290 --> 00:21:58,680
>> Har du nogensinde erklæret en variabel og
ikke er tildelt sin værdi med det samme?

414
00:21:58,680 --> 00:22:02,680
Så du bare sige int x; du ikke
faktisk tildele den til noget

415
00:22:02,680 --> 00:22:05,340
og så senere i din kode,
du udskrive værdien af ​​x,

416
00:22:05,340 --> 00:22:07,650
der stadig ikke
tildelt det til noget.

417
00:22:07,650 --> 00:22:10,370
Ofte får du
nul, men nogle gange er du

418
00:22:10,370 --> 00:22:15,000
måske få nogle tilfældige tal, og
du har ingen idé om, hvor det kom fra.

419
00:22:15,000 --> 00:22:16,750
Ligeledes kan ting
ske med pointere.

420
00:22:16,750 --> 00:22:20,110
Når du erklærer en pegepind
int * pk f.eks

421
00:22:20,110 --> 00:22:23,490
og du behøver ikke tildele den til en værdi,
du får fire bytes for hukommelse.

422
00:22:23,490 --> 00:22:25,950
Uanset fire bytes
hukommelse kan systemet

423
00:22:25,950 --> 00:22:28,970
finder, at have en vis meningsfuld værdi.

424
00:22:28,970 --> 00:22:31,760
Og der kunne have været
noget der allerede, at

425
00:22:31,760 --> 00:22:34,190
ikke længere er nødvendig af en anden
funktion, så du bare nødt

426
00:22:34,190 --> 00:22:35,900
uanset data var der.

427
00:22:35,900 --> 00:22:40,570
>> Hvad hvis du forsøgte at gøre dereference
nogle adresse, du don't- der var

428
00:22:40,570 --> 00:22:43,410
allerede bytes og information i
der, det er nu i markøren.

429
00:22:43,410 --> 00:22:47,470
Hvis du prøver og dereference den pointer,
du måske rode med noget hukommelse

430
00:22:47,470 --> 00:22:49,390
at du ikke havde til hensigt
at rode med det hele.

431
00:22:49,390 --> 00:22:51,639
Og i virkeligheden, du kunne gøre
noget virkelig ødelæggende,

432
00:22:51,639 --> 00:22:54,880
ligesom bryde et andet program,
eller bryde en anden funktion,

433
00:22:54,880 --> 00:22:58,289
eller gøre noget ondsindet, at
du ikke havde til hensigt at gøre overhovedet.

434
00:22:58,289 --> 00:23:00,080
Og så det er derfor, det er
faktisk en god idé

435
00:23:00,080 --> 00:23:04,030
til at indstille dine pegepinde til null, hvis du
ikke sætte dem til noget meningsfuldt.

436
00:23:04,030 --> 00:23:06,760
Det er nok bedre på
slutningen af ​​dagen til dit program

437
00:23:06,760 --> 00:23:09,840
til at gå ned og derefter for det at gøre
Noget der skruer op

438
00:23:09,840 --> 00:23:12,400
et andet program eller en anden funktion.

439
00:23:12,400 --> 00:23:15,207
Denne adfærd er sandsynligvis endnu
mindre ideel end bare at styrte ned.

440
00:23:15,207 --> 00:23:17,040
Og så det er derfor, det er
faktisk en god vane

441
00:23:17,040 --> 00:23:20,920
at komme ind for at indstille din pegepinde
til null hvis du ikke sætte dem

442
00:23:20,920 --> 00:23:24,540
til en meningsfuld værdi
straks, er en værdi, som du kender

443
00:23:24,540 --> 00:23:27,260
og at du kan sikkert den dereference.

444
00:23:27,260 --> 00:23:32,240
>> Så lad os komme tilbage nu, og tage et kig
på den overordnede syntaks af situationen.

445
00:23:32,240 --> 00:23:37,400
Hvis jeg siger int * p ;, hvad har jeg lige gjort?

446
00:23:37,400 --> 00:23:38,530
Hvad jeg har gjort, er dette.

447
00:23:38,530 --> 00:23:43,290
Jeg kender værdien af ​​p er en adresse
fordi alle pointere er lige

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

449
00:23:44,660 --> 00:23:47,750
Jeg kan dereference p
ved hjælp af * operatøren.

450
00:23:47,750 --> 00:23:51,250
I denne sammenhæng her i det
top huske * er en del af den type.

451
00:23:51,250 --> 00:23:53,510
Int * er den datatype.

452
00:23:53,510 --> 00:23:56,150
Men jeg kan dereference
p ved hjælp af * operatøren,

453
00:23:56,150 --> 00:24:01,897
og hvis jeg gør det, hvis jeg går til denne adresse,
hvad vil jeg finde på denne adresse?

454
00:24:01,897 --> 00:24:02,855
Jeg vil finde et heltal.

455
00:24:02,855 --> 00:24:05,910
Så int * p er dybest set
sagde: p er en adresse.

456
00:24:05,910 --> 00:24:09,500
Jeg kan dereference p og hvis
Jeg gør, vil jeg finde et heltal

457
00:24:09,500 --> 00:24:11,920
på denne hukommelsesplads.

458
00:24:11,920 --> 00:24:14,260
>> OK, så jeg sagde, at der var en anden
irriterende ting med stjerner

459
00:24:14,260 --> 00:24:17,060
og her er hvor der
irriterende ting med stjerner er.

460
00:24:17,060 --> 00:24:21,640
Har du nogensinde prøvet at erklære
flere variabler af samme type

461
00:24:21,640 --> 00:24:24,409
på den samme linje kode?

462
00:24:24,409 --> 00:24:27,700
Så for en anden, foregive, at linien,
koden jeg faktisk har der i grøn

463
00:24:27,700 --> 00:24:29,366
er der ikke, og det bare siger int x, y, z ;.

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

465
00:24:31,634 --> 00:24:34,550
Hvad der ville gøre er faktisk at skabe
tre heltalsvariabler for dig,

466
00:24:34,550 --> 00:24:36,930
én kaldet x, en kaldet
y og en kaldet z.

467
00:24:36,930 --> 00:24:41,510
Det er en måde at gøre det uden
skulle opdeles på tre linjer.

468
00:24:41,510 --> 00:24:43,890
>> Her er, hvor stjerner får
irriterende igen dog,

469
00:24:43,890 --> 00:24:49,200
fordi * er faktisk en del
både navn og Deltype

470
00:24:49,200 --> 00:24:50,320
af den variable navn.

471
00:24:50,320 --> 00:24:56,430
Og så hvis jeg siger int * px, py, pz, hvad jeg
faktisk får, er en pointer til et heltal

472
00:24:56,430 --> 00:25:01,650
kaldes px og to heltal, py og pz.

473
00:25:01,650 --> 00:25:04,950
Og det er nok det, der ikke
vi ønsker, det er ikke godt.

474
00:25:04,950 --> 00:25:09,290
>> Så hvis jeg ønsker at oprette flere pointers
på samme linje, af samme type,

475
00:25:09,290 --> 00:25:12,140
og stjerner, hvad jeg rent faktisk har brug for
at gøre, er at sige int * pa, * PB, * pc.

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

477
00:25:17,330 --> 00:25:20,300
Nu har netop sagt, at
og nu fortæller dig dette,

478
00:25:20,300 --> 00:25:22,170
du sandsynligvis vil aldrig gøre dette.

479
00:25:22,170 --> 00:25:25,170
Og det er nok en god ting ærligt,
fordi du måske uforvarende

480
00:25:25,170 --> 00:25:26,544
udelade en stjerne, noget lignende.

481
00:25:26,544 --> 00:25:29,290
Det er nok bedst at måske erklære
fingerpeg om de enkelte linjer,

482
00:25:29,290 --> 00:25:31,373
men det er bare en anden
af de irriterende syntaks

483
00:25:31,373 --> 00:25:35,310
ting med stjerner, der gør
pointers så svært at arbejde med.

484
00:25:35,310 --> 00:25:39,480
Fordi det er netop denne syntaktiske
rod, du nødt til at arbejde igennem.

485
00:25:39,480 --> 00:25:41,600
Med praksis gør
virkelig bliver anden karakter.

486
00:25:41,600 --> 00:25:45,410
Jeg stadig lave fejl med det stadig
efter programmering i 10 år,

487
00:25:45,410 --> 00:25:49,630
så du skal ikke være ked af, hvis der sker noget
til dig, er det temmelig almindeligt ærligt.

488
00:25:49,630 --> 00:25:52,850
Det er virkelig slags
en fejl i syntaksen.

489
00:25:52,850 --> 00:25:54,900
>> OK, så jeg slags lovet
at vi ville revidere

490
00:25:54,900 --> 00:25:59,370
begrebet hvor stor er en streng.

491
00:25:59,370 --> 00:26:02,750
Tja, hvis jeg fortalte dig, at en
streng, har vi virkelig slags

492
00:26:02,750 --> 00:26:04,140
ligget til dig hele tiden.

493
00:26:04,140 --> 00:26:06,181
Der er ingen datatype kaldet
streng, og faktisk jeg

494
00:26:06,181 --> 00:26:09,730
nævnt dette i en af ​​vores
tidligste videoer på datatyper,

495
00:26:09,730 --> 00:26:13,820
at strengen var en datatype,
blev oprettet for dig i CS50.h.

496
00:26:13,820 --> 00:26:17,050
Du er nødt til at # include
CS50.h for at bruge det.

497
00:26:17,050 --> 00:26:19,250
>> Nå streng er virkelig bare
et alias for noget

498
00:26:19,250 --> 00:26:23,600
kaldet char *, en
pointer til et tegn.

499
00:26:23,600 --> 00:26:26,010
Nå pointere, tilbagekaldelse,
er blot adresser.

500
00:26:26,010 --> 00:26:28,780
Så hvad er størrelsen
i byte af en streng?

501
00:26:28,780 --> 00:26:29,796
Jamen det er fire eller otte.

502
00:26:29,796 --> 00:26:32,170
Og grunden til at jeg siger fire eller
otte er fordi det faktisk

503
00:26:32,170 --> 00:26:36,730
afhænger af det system, Hvis du bruger
CS50 ide, char * er størrelsen af ​​en char

504
00:26:36,730 --> 00:26:39,340
* Er otte, er det en 64-bit system.

505
00:26:39,340 --> 00:26:43,850
Hver adresse i hukommelsen er 64 bit lang.

506
00:26:43,850 --> 00:26:48,270
Hvis du bruger CS50 apparatet
eller ved hjælp af en 32-bit maskine,

507
00:26:48,270 --> 00:26:51,640
og du har hørt, at udtrykket 32-bit
maskine, hvad er en 32-bit maskine?

508
00:26:51,640 --> 00:26:56,090
Jamen det betyder bare, at hver
adresse i hukommelsen er 32 bit lang.

509
00:26:56,090 --> 00:26:59,140
Og så 32 bit er fire bytes.

510
00:26:59,140 --> 00:27:02,710
Så en char * er fire eller otte
bytes afhængigt af dit system.

511
00:27:02,710 --> 00:27:06,100
Og faktisk nogen datatyper,
og en pointer til en hvilken som helst data

512
00:27:06,100 --> 00:27:12,030
skriver, da alle pejlemærker er blot
adresser, er fire eller otte bytes.

513
00:27:12,030 --> 00:27:14,030
Så lad os revidere denne
diagram og lad os slutte

514
00:27:14,030 --> 00:27:18,130
denne video med lidt øvelse her.

515
00:27:18,130 --> 00:27:21,600
Så her er diagrammet vi slap med
i begyndelsen af ​​videoen.

516
00:27:21,600 --> 00:27:23,110
Så hvad sker der nu, hvis jeg siger * pk = 35?

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

518
00:27:26,370 --> 00:27:30,530
Så hvad betyder det, når jeg siger, * pk = 35?

519
00:27:30,530 --> 00:27:32,420
Tag et sekund.

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

521
00:27:34,990 --> 00:27:39,890
I sammenhæng her, * er
dereference operatør.

522
00:27:39,890 --> 00:27:42,110
Så når dereference
operatøren anvendes,

523
00:27:42,110 --> 00:27:48,520
vi gå til adressen pegede på
ved pk, og vi ændre, hvad vi finder.

524
00:27:48,520 --> 00:27:55,270
Så * pk = 35 effektivt
gør dette til billedet.

525
00:27:55,270 --> 00:27:58,110
Så det er dybest set syntaktisk
identisk med for at have sagt k = 35.

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

527
00:28:00,740 --> 00:28:01,930
>> En mere.

528
00:28:01,930 --> 00:28:05,510
Hvis jeg siger int m, jeg skaber
en ny variabel kaldet m.

529
00:28:05,510 --> 00:28:08,260
En ny boks, er det en grøn boks, fordi
det kommer til at holde et heltal,

530
00:28:08,260 --> 00:28:09,840
og det er mærket m.

531
00:28:09,840 --> 00:28:14,960
Hvis jeg siger m = 4, sætter jeg en
heltal ind i denne boks.

532
00:28:14,960 --> 00:28:20,290
Hvis sige pk = & m, hvordan gør
dette diagram forandring?

533
00:28:20,290 --> 00:28:28,760
Pk = & m, gør du huske, hvad den
& Operatør gør eller kaldes?

534
00:28:28,760 --> 00:28:34,430
Husk, at & nogle variabelnavn
er adressen på en variabel navn.

535
00:28:34,430 --> 00:28:38,740
Så det, vi siger, er
pk får adressen på m.

536
00:28:38,740 --> 00:28:42,010
Og så effektivt hvad der sker den
diagrammet er der pk ikke længere peger

537
00:28:42,010 --> 00:28:46,420
til k, men peger på m.

538
00:28:46,420 --> 00:28:48,470
>> Igen pointere er meget
vanskelig at arbejde med

539
00:28:48,470 --> 00:28:50,620
og de tager en masse af
praksis, men på grund

540
00:28:50,620 --> 00:28:54,150
af deres evne til at give dig
overføres data mellem funktioner

541
00:28:54,150 --> 00:28:56,945
og faktisk har de,
ændringerne træder i kraft,

542
00:28:56,945 --> 00:28:58,820
få dit hoved omkring
er virkelig vigtigt.

543
00:28:58,820 --> 00:29:02,590
Det sandsynligvis er den mest komplicerede
emne, vi diskuterer i CS50,

544
00:29:02,590 --> 00:29:05,910
men den værdi, du
får fra at bruge pointers

545
00:29:05,910 --> 00:29:09,200
langt opvejer de komplikationer
der kommer fra at lære dem.

546
00:29:09,200 --> 00:29:12,690
Så jeg ønsker dig det bedste af
held at lære om pointere.

547
00:29:12,690 --> 00:29:15,760
Jeg er Doug Lloyd, det er CS50.

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