1
00:00:00,000 --> 00:00:06,030
>> [MUSIC SPILLE]

2
00:00:06,030 --> 00:00:08,390
>> DOUG LLOYD: Pekere, her er vi.

3
00:00:08,390 --> 00:00:11,080
Dette er trolig kommer til å
være den mest vanskelig tema

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

5
00:00:12,840 --> 00:00:15,060
Og hvis du har lest
noe om pekere

6
00:00:15,060 --> 00:00:19,080
før du kan være litt
skremmende å gå inn i denne videoen.

7
00:00:19,080 --> 00:00:21,260
Det er sant pekere
tillater deg muligheten

8
00:00:21,260 --> 00:00:23,740
å kanskje skru opp
ganske dårlig når du er

9
00:00:23,740 --> 00:00:27,450
arbeider med variabler og data,
og forårsaker programmet til å krasje.

10
00:00:27,450 --> 00:00:30,490
Men de er faktisk veldig nyttig
og de tillater oss en virkelig flott måte

11
00:00:30,490 --> 00:00:33,340
å sende data tilbake og
tilbake mellom funksjoner,

12
00:00:33,340 --> 00:00:35,490
at vi er ellers ute av stand til å gjøre.

13
00:00:35,490 --> 00:00:37,750
>> Og så hva vi egentlig
ønsker å gjøre her er toget

14
00:00:37,750 --> 00:00:41,060
du ha god pekeren disiplin, så
som du kan bruke pekere effektivt

15
00:00:41,060 --> 00:00:43,850
å lage dine programmer som mye bedre.

16
00:00:43,850 --> 00:00:48,220
Som jeg sa pekere gi oss et annet
måte å overføre data mellom funksjoner.

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

18
00:00:50,270 --> 00:00:53,720
vi snakket om
variabel omfang, nevnte jeg

19
00:00:53,720 --> 00:01:00,610
at alle data som vi passerer mellom
funksjoner i C er vedtatt av verdi.

20
00:01:00,610 --> 00:01:03,070
Og jeg kan ikke ha brukt som
sikt, det jeg mente det

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

22
00:01:07,170 --> 00:01:12,252
Når vi passerer en variabel til en funksjon,
vi faktisk ikke bestått variabelen

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

24
00:01:13,210 --> 00:01:17,670
Vi sender en kopi av
at data til funksjonen.

25
00:01:17,670 --> 00:01:20,760
Funksjonen gjør det de vil
og den beregner noen verdi,

26
00:01:20,760 --> 00:01:23,180
og kanskje vi bruker denne verdien
da det gir den tilbake.

27
00:01:23,180 --> 00:01:26,700
>> Det var ett unntak
denne regelen for overføring av verdi,

28
00:01:26,700 --> 00:01:31,210
og vi vil komme tilbake til hva som
er litt senere i denne videoen.

29
00:01:31,210 --> 00:01:34,880
Hvis vi bruker pekere stedet
for å bruke variabler,

30
00:01:34,880 --> 00:01:38,180
eller i stedet for ved hjelp av de variable
seg selv eller kopier av variablene,

31
00:01:38,180 --> 00:01:43,790
kan vi nå passerer variablene rundt
mellom funksjoner på en annen måte.

32
00:01:43,790 --> 00:01:46,550
Dette betyr at hvis vi gjør
en endring av en funksjon,

33
00:01:46,550 --> 00:01:49,827
at endringen vil faktisk ta
effekt i en annen funksjon.

34
00:01:49,827 --> 00:01:52,160
Igjen, dette er noe som
vi ikke kunne gjøre tidligere,

35
00:01:52,160 --> 00:01:56,979
og hvis du har prøvd å bytte
Verdien av to variabler i en funksjon,

36
00:01:56,979 --> 00:01:59,270
du har lagt merke til dette problemet
slags snikende opp, ikke sant?

37
00:01:59,270 --> 00:02:04,340
>> Hvis vi ønsker å bytte X og Y, og vi
sende dem til en funksjon som kalles swap,

38
00:02:04,340 --> 00:02:08,680
innsiden av funksjon bytte
variabler gjør utvekslings verdier.

39
00:02:08,680 --> 00:02:12,600
Man blir to, to blir
en, men vi gjør faktisk ikke

40
00:02:12,600 --> 00:02:16,890
endre noe i den opprinnelige
funksjon, i den som ringer.

41
00:02:16,890 --> 00:02:19,550
Fordi vi ikke kan, er vi bare
arbeider med kopier av dem.

42
00:02:19,550 --> 00:02:24,760
Med pekere skjønt, kan vi
faktisk passere X og Y til en funksjon.

43
00:02:24,760 --> 00:02:26,960
Den funksjonen kan gjøre
noe med dem.

44
00:02:26,960 --> 00:02:29,250
Og disse variablene verdier
kan faktisk endre.

45
00:02:29,250 --> 00:02:33,710
Så det er litt av en endring i
vår evne til å arbeide med data.

46
00:02:33,710 --> 00:02:36,100
>> Før vi dykke inn
pekere, jeg tror det er verdt

47
00:02:36,100 --> 00:02:38,580
tar et par minutter til
gå tilbake til grunnleggende her.

48
00:02:38,580 --> 00:02:41,000
Og ta en titt på hvordan
datamaskinminne verk

49
00:02:41,000 --> 00:02:45,340
fordi disse to fagene skal
å faktisk være ganske henger sammen.

50
00:02:45,340 --> 00:02:48,480
Som du sikkert vet,
på datasystemet

51
00:02:48,480 --> 00:02:51,310
du har en harddisk eller
kanskje en solid state drive,

52
00:02:51,310 --> 00:02:54,430
noen form for fillagring plassering.

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

54
00:02:57,950 --> 00:02:59,810
til kanskje et par terabyte nå.

55
00:02:59,810 --> 00:03:02,270
Og det er der alle dine
filer til slutt leve,

56
00:03:02,270 --> 00:03:04,870
selv om datamaskinen er slått
av, kan du slå den på igjen

57
00:03:04,870 --> 00:03:09,190
og du vil finne filene dine er der
igjen når du starter maskinen på nytt.

58
00:03:09,190 --> 00:03:14,820
Men disker, som en harddisk,
en HDD eller en Solid State Drive, en SSD,

59
00:03:14,820 --> 00:03:16,050
er bare lagringsplass.

60
00:03:16,050 --> 00:03:20,400
>> Vi kan faktisk ikke gjøre noe med
dataene som er i harddisken,

61
00:03:20,400 --> 00:03:22,080
eller i en solid state drive.

62
00:03:22,080 --> 00:03:24,950
For å faktisk endre
data eller flytte den rundt,

63
00:03:24,950 --> 00:03:28,800
vi må flytte den til
RAM, random access memory.

64
00:03:28,800 --> 00:03:31,170
Nå RAM, har du mye
mindre av på datamaskinen.

65
00:03:31,170 --> 00:03:34,185
Du kan ha et sted i
nabolaget på 512 megabyte

66
00:03:34,185 --> 00:03:38,850
hvis du har en eldre datamaskin,
til kanskje to, fire, åtte, 16,

67
00:03:38,850 --> 00:03:41,820
muligens enda litt
mer, gigabyte RAM.

68
00:03:41,820 --> 00:03:46,390
Så det er mye mindre, men det er
hvor alle de flyktige data eksisterer.

69
00:03:46,390 --> 00:03:48,270
Det er der vi kan forandre ting.

70
00:03:48,270 --> 00:03:53,350
Men når vi slår vår datamaskin av,
alle data i RAM er ødelagt.

71
00:03:53,350 --> 00:03:57,150
>> Så det er derfor vi må ha harddisk
for mer permanent plassering av det,

72
00:03:57,150 --> 00:03:59,720
slik at det exists- det ville
være veldig ille hvis hver gang vi

73
00:03:59,720 --> 00:04:03,310
slått vår datamaskin av, hver
fil i vårt system ble utslettet.

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

75
00:04:05,600 --> 00:04:09,210
Og hver gang vi snakker om
minne, ganske mye, i CS50,

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

77
00:04:15,080 --> 00:04:18,657
>> Så når vi flytter ting inn i minnet,
den tar opp en viss mengde plass.

78
00:04:18,657 --> 00:04:20,740
Alle datatyper som
vi har jobbet med

79
00:04:20,740 --> 00:04:23,480
ta opp forskjellige
mengder plass i RAM.

80
00:04:23,480 --> 00:04:27,600
Så hver gang du oppretter et heltall
variable, fire byte minne

81
00:04:27,600 --> 00:04:30,750
er satt til side i RAM slik at du
kan arbeide med det heltall.

82
00:04:30,750 --> 00:04:34,260
Du kan erklære heltall,
endre det, tilordne den

83
00:04:34,260 --> 00:04:36,700
til en verdi 10 inkrementert
av en, så videre og så videre.

84
00:04:36,700 --> 00:04:39,440
Alt som må skje i
RAM, og du får fire bytes

85
00:04:39,440 --> 00:04:42,550
å arbeide med for hvert
heltall som du oppretter.

86
00:04:42,550 --> 00:04:45,410
>> Hver karakter du
skape får én byte.

87
00:04:45,410 --> 00:04:48,160
Det er bare hvor mye plass er
er nødvendig for å lagre et tegn.

88
00:04:48,160 --> 00:04:51,310
Hver float, en real
nummer, får fire bytes

89
00:04:51,310 --> 00:04:53,390
med mindre det er en dobbel
presisjon flyttall

90
00:04:53,390 --> 00:04:56,510
nummer, som lar deg
har mer presise eller flere sifre

91
00:04:56,510 --> 00:04:59,300
etter desimaltegnet
uten å miste presisjon,

92
00:04:59,300 --> 00:05:01,820
som tar opp åtte byte minne.

93
00:05:01,820 --> 00:05:06,730
Lange lengter, virkelig store heltall,
også ta opp åtte byte minne.

94
00:05:06,730 --> 00:05:09,000
Hvor mange byte minne
trenger strenger ta opp?

95
00:05:09,000 --> 00:05:12,990
Vel la oss sette en nål i det spørsmålet
for nå, men vi vil komme tilbake til det.

96
00:05:12,990 --> 00:05:17,350
>> Så tilbake til denne ideen om minnet som
et stort utvalg av byte-sized celler.

97
00:05:17,350 --> 00:05:20,871
Det er egentlig alt det er, er det
bare et stort utvalg av celler,

98
00:05:20,871 --> 00:05:23,370
akkurat som alle andre matrise som
du er kjent med og se,

99
00:05:23,370 --> 00:05:26,430
bortsett fra hver element er en byte bred.

100
00:05:26,430 --> 00:05:30,030
Og akkurat som en matrise,
hvert element har en adresse.

101
00:05:30,030 --> 00:05:32,120
Hvert element av en matrise
har en indeks, og vi

102
00:05:32,120 --> 00:05:36,302
kan bruke denne indeksen til å gjøre såkalte
random access på matrisen.

103
00:05:36,302 --> 00:05:38,510
Vi trenger ikke å starte på
begynnelsen av rekken,

104
00:05:38,510 --> 00:05:40,569
iterere gjennom hver
enkelt element derav,

105
00:05:40,569 --> 00:05:41,860
å finne det vi leter etter.

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

107
00:05:45,790 --> 00:05:49,930
Og du kan bare bestå i at antall
og få verdien du leter etter.

108
00:05:49,930 --> 00:05:54,460
>> Tilsvar hvert sted
minne har en adresse.

109
00:05:54,460 --> 00:05:57,320
Så din hukommelse makt
se omtrent slik ut.

110
00:05:57,320 --> 00:06:01,420
Her er en veldig liten del av
hukommelse, er det 20 byte minne.

111
00:06:01,420 --> 00:06:04,060
De første 20 bytes fordi min
løser det på bunnen

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

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

114
00:06:13,190 --> 00:06:15,470
at systemet kommer til å sette
avsett noen plass for meg

115
00:06:15,470 --> 00:06:17,595
i dette minnet til å jobbe
med mine variabler.

116
00:06:17,595 --> 00:06:21,610
Så jeg kan si, char c tilsvarer kapital
H. Og hva kommer til å skje?

117
00:06:21,610 --> 00:06:23,880
Godt systemet kommer til å
satt til side for meg en byte.

118
00:06:23,880 --> 00:06:27,870
I dette tilfellet valgte det byte nummer
fire, byte på adressen fire,

119
00:06:27,870 --> 00:06:31,310
og det kommer til å lagre
bokstav stor H i det for meg.

120
00:06:31,310 --> 00:06:34,350
Hvis jeg da si int hastighet
grense lik 65, er det

121
00:06:34,350 --> 00:06:36,806
kommer til å sette av fire
byte minne for meg.

122
00:06:36,806 --> 00:06:39,180
Og det kommer til å behandle dem
fire byte som en enkelt enhet

123
00:06:39,180 --> 00:06:41,305
fordi det vi jobber
med er et tall her.

124
00:06:41,305 --> 00:06:44,350
Og det kommer til å lagre 65 i der.

125
00:06:44,350 --> 00:06:47,000
>> Nå allerede Jeg er litt
fortelle deg litt av en løgn,

126
00:06:47,000 --> 00:06:50,150
rett, fordi vi vet at
datamaskiner fungerer i binær.

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

128
00:06:53,100 --> 00:06:57,110
eller hva en 65 er, bare de
forstår binære, nuller og enere.

129
00:06:57,110 --> 00:06:59,000
Og så faktisk hva
vi lagring i det

130
00:06:59,000 --> 00:07:03,450
er ikke bokstaven H og tallet 65,
men heller de binære representasjoner

131
00:07:03,450 --> 00:07:06,980
derav, som ser en
litt noe sånt som dette.

132
00:07:06,980 --> 00:07:10,360
Og spesielt i
sammenheng med heltallsvariabelen,

133
00:07:10,360 --> 00:07:13,559
det er ikke til å bare spytte den inn,
det er ikke til å behandle det som en fire

134
00:07:13,559 --> 00:07:15,350
byte blings nødvendigvis,
det er faktisk kommer

135
00:07:15,350 --> 00:07:19,570
å behandle det som fire én byte biter,
som kan se omtrent slik ut.

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

137
00:07:22,424 --> 00:07:24,840
på grunn av noe som kalles
en endianness, som vi ikke

138
00:07:24,840 --> 00:07:26,965
kommer til å komme inn nå, men
Hvis du er nysgjerrig på,

139
00:07:26,965 --> 00:07:29,030
du kan lese opp på litt
og stor endianness.

140
00:07:29,030 --> 00:07:31,640
Men for å få til dette argumentet,
for å få til denne videoen

141
00:07:31,640 --> 00:07:34,860
la oss bare anta at er, i
Faktisk, hvordan nummer 65 ville

142
00:07:34,860 --> 00:07:36,970
være representert i
minne på hvert system,

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

144
00:07:38,850 --> 00:07:41,700
>> Men la oss faktisk bare få
kvitt alle binære helt,

145
00:07:41,700 --> 00:07:44,460
og bare tenke på som H
og 65, er det mye enklere

146
00:07:44,460 --> 00:07:47,900
å tenke på det som
det som et menneske.

147
00:07:47,900 --> 00:07:51,420
All right, så det også virker kanskje en
Litt tilfeldig at I've- systemet mitt

148
00:07:51,420 --> 00:07:55,130
ikke gi meg bytes 5, 6, 7,
og 8 for å lagre heltall.

149
00:07:55,130 --> 00:07:58,580
Det er en grunn for det, også, som
vi vil ikke komme inn på nå, men nok

150
00:07:58,580 --> 00:08:00,496
det å si at det som
Datamaskinen gjør her

151
00:08:00,496 --> 00:08:02,810
er sannsynligvis et godt trekk på sin side.

152
00:08:02,810 --> 00:08:06,020
Å ikke gi meg minne som er
nødvendigvis rygg mot rygg.

153
00:08:06,020 --> 00:08:10,490
Selv om det kommer til å gjøre det nå
hvis jeg ønsker å få en annen streng,

154
00:08:10,490 --> 00:08:13,080
heter etternavn, og jeg vil ha
å sette Lloyd der.

155
00:08:13,080 --> 00:08:18,360
Jeg kommer til å trenge å passe en
karakter, er hver bokstav som

156
00:08:18,360 --> 00:08:21,330
kommer til å kreve en
karakter, en byte minne.

157
00:08:21,330 --> 00:08:26,230
Så hvis jeg kunne sette Lloyd inn i mitt utvalg
som dette jeg er ganske god til å gå, ikke sant?

158
00:08:26,230 --> 00:08:28,870
Hva er det som mangler?

159
00:08:28,870 --> 00:08:31,840
>> Husk at hver streng vi jobber
med i C slutter med backslash null,

160
00:08:31,840 --> 00:08:33,339
og vi kan ikke utelate det her, heller.

161
00:08:33,339 --> 00:08:36,090
Vi trenger å sette av én byte
minne til å holde det slik at vi

162
00:08:36,090 --> 00:08:39,130
vet når vår strengen er avsluttet.

163
00:08:39,130 --> 00:08:41,049
Så igjen denne ordningen
av hvordan ting

164
00:08:41,049 --> 00:08:42,799
vises i minnet makt
være litt tilfeldig,

165
00:08:42,799 --> 00:08:44,870
men det er faktisk hvordan
de fleste systemer er utformet.

166
00:08:44,870 --> 00:08:48,330
Å stille dem opp på multipler
av fire, av grunner igjen

167
00:08:48,330 --> 00:08:50,080
at vi ikke trenger å
komme inn akkurat nå.

168
00:08:50,080 --> 00:08:53,060
Men dette, så det er nok å si at
etter disse tre linjer med kode,

169
00:08:53,060 --> 00:08:54,810
dette er hva minnet kan se ut.

170
00:08:54,810 --> 00:08:58,930
Hvis jeg trenger minnesteder
4, 8 og 12 for å holde mine data,

171
00:08:58,930 --> 00:09:01,100
Dette er hva min hukommelse kan se ut.

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

173
00:09:04,062 --> 00:09:06,020
vi snakker om minne
adresser vi vanligvis

174
00:09:06,020 --> 00:09:08,390
gjøre det ved hjelp heksadesimale merknader.

175
00:09:08,390 --> 00:09:12,030
Så hvorfor ikke vi konvertere alle disse
fra desimal til heksadesimale notasjon

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

177
00:09:15,010 --> 00:09:17,880
Så i stedet for å være 0 gjennom
19, det vi har er null

178
00:09:17,880 --> 00:09:20,340
x null gjennom null x1 tre.

179
00:09:20,340 --> 00:09:23,790
De er 20 byte minne om at vi
har eller vi ser på i dette bildet

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

181
00:09:25,540 --> 00:09:29,310
>> Så alt som blir sagt, la oss
gå bort fra minnet for andre

182
00:09:29,310 --> 00:09:30,490
og tilbake til pekere.

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

184
00:09:32,420 --> 00:09:34,070
som vi begynne å jobbe med pekere.

185
00:09:34,070 --> 00:09:36,314
En peker er ingenting
mer enn en adresse.

186
00:09:36,314 --> 00:09:38,230
Jeg sier det igjen fordi
det er så viktig,

187
00:09:38,230 --> 00:09:42,730
en peker er ingenting
mer enn en adresse.

188
00:09:42,730 --> 00:09:47,760
Pekere er adresser til steder
i minnet der variabler bor.

189
00:09:47,760 --> 00:09:52,590
Å vite at det blir forhåpentligvis en
litt lettere å jobbe med dem.

190
00:09:52,590 --> 00:09:54,550
En annen ting jeg liker
å gjøre er å ha sort

191
00:09:54,550 --> 00:09:58,510
diagrammer visuelt representerer hva som er
skjer med ulike linjer med kode.

192
00:09:58,510 --> 00:10:00,660
Og vi vil gjøre dette et par
ganger i pekere,

193
00:10:00,660 --> 00:10:03,354
og når vi snakker om dynamisk
minnetildeling også.

194
00:10:03,354 --> 00:10:06,020
Fordi jeg tror at disse diagrammene
kan være spesielt nyttig.

195
00:10:06,020 --> 00:10:09,540
>> Så hvis jeg sier for eksempel int k
i koden min, hva skjer?

196
00:10:09,540 --> 00:10:12,524
Vel hva som egentlig skjer er
Jeg får minne avsatt til meg,

197
00:10:12,524 --> 00:10:14,690
men jeg vet ikke engang liker å
tenker på det sånn, jeg

198
00:10:14,690 --> 00:10:16,300
liker å tenke på det som en boks.

199
00:10:16,300 --> 00:10:20,090
Jeg har en boks, og det er
farget grønn fordi jeg

200
00:10:20,090 --> 00:10:21,750
kan sette heltall i grønne bokser.

201
00:10:21,750 --> 00:10:23,666
Hvis det var en karakter jeg
kan ha en blå boks.

202
00:10:23,666 --> 00:10:27,290
Men jeg alltid sier, hvis jeg skaper
en boks som kan holde heltall

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

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

205
00:10:33,020 --> 00:10:37,590
Så jeg har en boks kalt k,
der jeg kan sette heltall.

206
00:10:37,590 --> 00:10:41,070
Så når jeg sier int k, det er
hva som skjer i hodet mitt.

207
00:10:41,070 --> 00:10:43,140
Hvis jeg sier k lik fem, hva gjør jeg?

208
00:10:43,140 --> 00:10:45,110
Vel, jeg setter five
i boksen, ikke sant.

209
00:10:45,110 --> 00:10:48,670
Dette er ganske grei, hvis
Jeg sier int k, skape en boks som heter k.

210
00:10:48,670 --> 00:10:52,040
Hvis jeg sier k er lik 5,
satte fem inn i boksen.

211
00:10:52,040 --> 00:10:53,865
Forhåpentligvis det er ikke for mye av et sprang.

212
00:10:53,865 --> 00:10:55,990
Her er der ting går
Litt interessant skjønt.

213
00:10:55,990 --> 00:11:02,590
Hvis jeg sier int * pk, godt selv om jeg ikke gjør det
vet hva dette nødvendigvis betyr,

214
00:11:02,590 --> 00:11:06,150
Det er helt klart har noe
å gjøre med et heltall.

215
00:11:06,150 --> 00:11:08,211
Så jeg kommer til å farge
denne boksen grønn-ish,

216
00:11:08,211 --> 00:11:10,210
Jeg vet det har noe
å gjøre med et heltall,

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

218
00:11:13,400 --> 00:11:15,390
Det er noe litt
annerledes om det.

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

220
00:11:17,620 --> 00:11:19,830
ikke så forskjellig fra
hva vi snakket om.

221
00:11:19,830 --> 00:11:24,240
Det er en boks, de har en etikett,
det har på seg en etikett pk,

222
00:11:24,240 --> 00:11:27,280
og det er i stand til beholdning
int stjerner, uansett hva de er.

223
00:11:27,280 --> 00:11:29,894
De har noe å gjøre
med heltall, tydelig.

224
00:11:29,894 --> 00:11:31,060
Her er den siste linjen skjønt.

225
00:11:31,060 --> 00:11:37,650
Hvis jeg sier pk = & k, whoa,
hva skjedde, ikke sant?

226
00:11:37,650 --> 00:11:41,820
Så dette tilfeldig tall, tilsynelatende tilfeldig
nummer, blir kastet inn i boksen der.

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

228
00:11:44,930 --> 00:11:52,867
Så jeg stikker hvor k lever i minnet,
sin adresse, adressen til dens bytes.

229
00:11:52,867 --> 00:11:55,200
Alt jeg gjør er jeg sier
denne verdien er hva jeg skal

230
00:11:55,200 --> 00:11:59,430
å sette innsiden av boksen min heter pk.

231
00:11:59,430 --> 00:12:02,080
Og fordi disse tingene er
pekere, og fordi jakt

232
00:12:02,080 --> 00:12:04,955
på en streng som null x
eight zero c sju fireåtte

233
00:12:04,955 --> 00:12:07,790
Two Zero er trolig
ikke veldig meningsfylt.

234
00:12:07,790 --> 00:12:12,390
Når vi vanligvis visual pekere,
vi faktisk gjøre det som pekere.

235
00:12:12,390 --> 00:12:17,000
Pk gir oss informasjon
vi trenger å finne k i minnet.

236
00:12:17,000 --> 00:12:19,120
Så i utgangspunktet pk har en pil i den.

237
00:12:19,120 --> 00:12:21,670
Og hvis vi gå lengden
av at pilen, tenk

238
00:12:21,670 --> 00:12:25,280
det er noe du kan gå på, hvis vi
går langs lengden av pilen

239
00:12:25,280 --> 00:12:29,490
helt på tuppen av at pilen, vi
vil finne sted i minnet

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

241
00:12:31,390 --> 00:12:34,360
Og det er veldig viktig
fordi når vi vet hvor k lever,

242
00:12:34,360 --> 00:12:37,870
vi kan begynne å jobbe med data
Innsiden av den minnelokasjon.

243
00:12:37,870 --> 00:12:40,780
Selv om vi får en teeny
Litt i forkant av oss selv for nå.

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

245
00:12:42,240 --> 00:12:45,590
En peker er et dataelement som
Verdien er en lageradresse.

246
00:12:45,590 --> 00:12:49,740
Det var det null x eight zero stuff
skjer, det var en minneadresse.

247
00:12:49,740 --> 00:12:52,060
Det var et sted i minnet.

248
00:12:52,060 --> 00:12:55,080
Og typen av en peker
beskriver hva slags

249
00:12:55,080 --> 00:12:56,930
av data du vil finne på
at minneadresse.

250
00:12:56,930 --> 00:12:58,810
Så det er den int stjerners del rett.

251
00:12:58,810 --> 00:13:03,690
Hvis jeg følger den pilen, er det
kommer til å føre meg til et sted.

252
00:13:03,690 --> 00:13:06,980
Og det stedet, hva jeg
vil finne det i mitt eksempel,

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

254
00:13:08,240 --> 00:13:12,650
Det er et tall, det er det jeg
vil finne hvis jeg går til denne adressen.

255
00:13:12,650 --> 00:13:14,830
Datatypen til en
pekeren beskriver hva

256
00:13:14,830 --> 00:13:17,936
du finner på at minneadresse.

257
00:13:17,936 --> 00:13:19,560
Så her er det virkelig kule ting om.

258
00:13:19,560 --> 00:13:25,090
Pekere tillate oss å passere
variabler mellom funksjoner.

259
00:13:25,090 --> 00:13:28,520
Og faktisk passere variabler
og ikke passere kopier av dem.

260
00:13:28,520 --> 00:13:32,879
Fordi hvis vi vet nøyaktig hvor
i minnet for å finne en variabel,

261
00:13:32,879 --> 00:13:35,670
vi trenger ikke å lage en kopi av
det, kan vi bare gå til det stedet

262
00:13:35,670 --> 00:13:37,844
og arbeide med den variabelen.

263
00:13:37,844 --> 00:13:40,260
Så i essensen pekere slags
av gjøre en datamaskin miljø

264
00:13:40,260 --> 00:13:42,360
mye mer som den virkelige verden, ikke sant.

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

266
00:13:44,640 --> 00:13:48,080
La oss si at jeg har en bærbar PC,
rett, og den er full av notater.

267
00:13:48,080 --> 00:13:50,230
Og jeg vil gjerne at du skal oppdatere den.

268
00:13:50,230 --> 00:13:53,960
Du er en funksjon som
oppdateringer notater, høyre.

269
00:13:53,960 --> 00:13:56,390
På den måten har vi vært
arbeider så langt, hva

270
00:13:56,390 --> 00:14:02,370
skjer er at du vil ta min bærbare,
du vil gå til kopien butikken,

271
00:14:02,370 --> 00:14:06,410
du vil gjøre en Xerox kopi av
hver side av maskinen.

272
00:14:06,410 --> 00:14:09,790
Du vil forlate min bærbare tilbake
på pulten min når du er ferdig,

273
00:14:09,790 --> 00:14:14,600
vil du gå og krysse ut ting i mitt
bærbar PC som er utdatert eller galt,

274
00:14:14,600 --> 00:14:19,280
og deretter vil du passere tilbake til
meg bunken med Xerox-sider

275
00:14:19,280 --> 00:14:22,850
som er en kopi av min bærbare med
endringene du har gjort i det.

276
00:14:22,850 --> 00:14:27,040
Og på det punktet, er det opp til meg som
kallet funksjon, som den som ringer,

277
00:14:27,040 --> 00:14:30,582
å bestemme seg for å ta notater og
integrere dem tilbake til min bærbare.

278
00:14:30,582 --> 00:14:32,540
Så det er mange trinn
involvert her, ikke sant.

279
00:14:32,540 --> 00:14:34,850
Som ville det ikke være bedre
hvis jeg bare si hei, kan du

280
00:14:34,850 --> 00:14:38,370
oppdatere min bærbare for
meg, hånd du min bærbare,

281
00:14:38,370 --> 00:14:40,440
og du tar ting og
bokstavelig krysse dem ut

282
00:14:40,440 --> 00:14:42,810
og oppdatere mine notater i notatboken min.

283
00:14:42,810 --> 00:14:45,140
Og deretter gi meg min bærbare tilbake.

284
00:14:45,140 --> 00:14:47,320
Det er litt av hva
pekere tillate oss å gjøre,

285
00:14:47,320 --> 00:14:51,320
de gjør dette miljøet mye
mer som hvordan vi opererer i virkeligheten.

286
00:14:51,320 --> 00:14:54,640
>> Greit så det er hva
en peker er, la oss snakke

287
00:14:54,640 --> 00:14:58,040
om hvordan pekere jobbe i C, og
hvordan vi kan begynne å jobbe med dem.

288
00:14:58,040 --> 00:15:02,550
Så det er en veldig enkel peker
i C kalles nullpeker.

289
00:15:02,550 --> 00:15:04,830
Nullpilen peker ingenting.

290
00:15:04,830 --> 00:15:08,310
Dette virker nok som det er
faktisk ikke en veldig nyttig ting,

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

292
00:15:10,500 --> 00:15:15,410
at dette nullpeker finnes
faktisk virkelig kan komme til nytte.

293
00:15:15,410 --> 00:15:19,090
Og når du oppretter en peker, og
du trenger ikke sette verdien immediately-

294
00:15:19,090 --> 00:15:21,060
et eksempel på innstilling
sin verdi umiddelbart

295
00:15:21,060 --> 00:15:25,401
vil være et par lysbilder tilbake
der jeg sa pk lik & k,

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

297
00:15:28,740 --> 00:15:32,990
vi får se hvordan koden som shortly-
hvis vi ikke sette verdien til noe

298
00:15:32,990 --> 00:15:35,380
menings umiddelbart,
Du bør alltid

299
00:15:35,380 --> 00:15:37,480
satt pekeren til å peke til null.

300
00:15:37,480 --> 00:15:40,260
Du bør sette den til å peke på noe.

301
00:15:40,260 --> 00:15:43,614
>> Det er veldig annerledes enn
bare forlate den verdi som det er

302
00:15:43,614 --> 00:15:45,530
og deretter erklære en
pekeren og bare antar

303
00:15:45,530 --> 00:15:48,042
det er null fordi det er sjelden sant.

304
00:15:48,042 --> 00:15:50,000
Så du bør alltid sette
verdien av en peker

305
00:15:50,000 --> 00:15:55,690
til null hvis du ikke sette verdien
til noe meningsfylt umiddelbart.

306
00:15:55,690 --> 00:15:59,090
Du kan sjekke om en peker verdi
er null hjelp av likestilling operator

307
00:15:59,090 --> 00:16:05,450
(==), Akkurat som du sammenligner alle heltall
verdier eller tegn verdier ved hjelp av (==)

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

309
00:16:06,320 --> 00:16:10,994
Det er en spesiell form for konstant
verdi som du kan bruke til å teste.

310
00:16:10,994 --> 00:16:13,160
Så det var en veldig enkel
pekeren, nullpeker.

311
00:16:13,160 --> 00:16:15,320
En annen måte å lage
en peker er å trekke ut

312
00:16:15,320 --> 00:16:18,240
adressen til en variabel
du allerede har opprettet,

313
00:16:18,240 --> 00:16:22,330
og du gjør dette ved hjelp av &
operatør adresse utvinning.

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

315
00:16:26,720 --> 00:16:31,450
Så hvis x er en variabel som vi har
allerede opprettet av type heltall,

316
00:16:31,450 --> 00:16:35,110
deretter og x er en peker til et heltall.

317
00:16:35,110 --> 00:16:39,810
& x er- huske, og kommer til å trekke ut
adressen til den tingen til høyre.

318
00:16:39,810 --> 00:16:45,350
Og siden en peker er bare en adresse,
enn & x er en peker til et heltall

319
00:16:45,350 --> 00:16:48,560
der verdien er hvor i minnet x liv.

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

321
00:16:50,460 --> 00:16:53,296
So & x er adressen til x.

322
00:16:53,296 --> 00:16:55,670
La oss ta dette ett skritt
videre og koble til noe

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

324
00:16:58,380 --> 00:17:06,730
Hvis arr er en rekke dobles, deretter
& arr hakeparentes jeg er en peker

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

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

327
00:17:08,970 --> 00:17:12,160
arr hakeparentes i, hvis
arr er en rekke dobles,

328
00:17:12,160 --> 00:17:19,069
deretter arr hakeparentes jeg er
i-te element i den oppstillingen,

329
00:17:19,069 --> 00:17:29,270
og & arr hakeparentes jeg er der i
hukommelse i-te element av arr eksisterer.

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

331
00:17:31,790 --> 00:17:34,570
En arrays navn, implikasjonen
av hele greia,

332
00:17:34,570 --> 00:17:39,290
er at en rekke navn er
faktisk selv en peker.

333
00:17:39,290 --> 00:17:41,170
Du har jobbet
med pekere langs

334
00:17:41,170 --> 00:17:45,290
hver gang du har brukt en matrise.

335
00:17:45,290 --> 00:17:49,090
Husk fra eksempelet
på variabel omfang,

336
00:17:49,090 --> 00:17:53,420
nær slutten av video I frem
et eksempel der vi har en funksjon

337
00:17:53,420 --> 00:17:56,890
heter sett int og en
Funksjonen kalles set array.

338
00:17:56,890 --> 00:18:00,490
Og din utfordring å bestemme
hvorvidt eller ikke, eller hva

339
00:18:00,490 --> 00:18:03,220
verdier som vi trykte ut
slutten av funksjon,

340
00:18:03,220 --> 00:18:05,960
ved enden av hovedprogrammet.

341
00:18:05,960 --> 00:18:08,740
>> Hvis du husker fra det eksemplet
eller hvis du har sett videoen,

342
00:18:08,740 --> 00:18:13,080
du vet at når deg-kallet til
sett int effektivt gjør ingenting.

343
00:18:13,080 --> 00:18:16,390
Men kallet til å sette utvalg gjør.

344
00:18:16,390 --> 00:18:19,280
Og jeg liksom glattet over hvorfor
det var tilfelle på den tiden.

345
00:18:19,280 --> 00:18:22,363
Jeg bare sa, vel det er en matrise, er det
spesielt, du vet, det er en grunn.

346
00:18:22,363 --> 00:18:25,020
Årsaken er at en matrise s
Navnet er egentlig bare en peker,

347
00:18:25,020 --> 00:18:28,740
og det er denne spesielle
hakeparentes syntaks som

348
00:18:28,740 --> 00:18:30,510
gjøre ting mye bedre å jobbe med.

349
00:18:30,510 --> 00:18:34,410
Og de gjør ideen om en
pekeren mye mindre skremmende,

350
00:18:34,410 --> 00:18:36,800
og det er derfor de er liksom
av presentert på den måten.

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

352
00:18:38,600 --> 00:18:41,580
Og det er grunnen til at når vi
gjort en endring i rekken,

353
00:18:41,580 --> 00:18:44,880
når vi passerte en rekke som et parameter
til en funksjon eller som et argument

354
00:18:44,880 --> 00:18:50,110
til en funksjon, og innholdet i matrisen
faktisk endret i både callee

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

356
00:18:51,160 --> 00:18:55,846
Som for alle andre slags
variabel vi så ikke var tilfelle.

357
00:18:55,846 --> 00:18:58,970
Så det er bare noe å holde i
tankene når du arbeider med pekere,

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

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

360
00:19:04,750 --> 00:19:08,930
>> OK, så nå har vi alle disse
fakta, la oss holde det gående, ikke sant.

361
00:19:08,930 --> 00:19:11,370
Hvorfor bryr vi oss om
hvor noe liv.

362
00:19:11,370 --> 00:19:14,120
Vel som jeg sa, det er ganske
nyttig å vite hvor noe liv

363
00:19:14,120 --> 00:19:17,240
slik at du kan gå dit og endre det.

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

365
00:19:19,390 --> 00:19:23,710
ønsker å gjøre til den variabelen tre i kraft,
og ikke tre i kraft på noen kopi av den.

366
00:19:23,710 --> 00:19:26,150
Dette kalles dereferencing.

367
00:19:26,150 --> 00:19:28,690
Vi går til referanse og
vi endre verdien der.

368
00:19:28,690 --> 00:19:32,660
Så hvis vi har en peker og det heter
pc, og det peker på en karakter,

369
00:19:32,660 --> 00:19:40,610
så kan vi si * pc og * pc er
Navnet på hva vi finner 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
Hva vi vil finne det er en karakter og
* pc er hvordan vi refererer til dataene på den

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

373
00:19:48,880 --> 00:19:54,150
Så vi kan si noe sånt
* pc = D eller noe sånt,

374
00:19:54,150 --> 00:19:59,280
og det betyr at uansett
var på minneadresse pc,

375
00:19:59,280 --> 00:20:07,040
uansett karakter var tidligere
der, er nå D, hvis vi sier * pc = D.

376
00:20:07,040 --> 00:20:10,090
>> Så her går vi igjen med
noen rare C ting, ikke sant.

377
00:20:10,090 --> 00:20:14,560
Så vi har sett * tidligere som
en eller annen måte en del av datatypen,

378
00:20:14,560 --> 00:20:17,160
og nå er det som blir brukt i
en litt annen sammenheng

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

380
00:20:19,605 --> 00:20:22,480
Jeg vet det er litt forvirrende og
det er faktisk en del av hele denne

381
00:20:22,480 --> 00:20:25,740
like, hvorfor pekere har denne mytologien
rundt dem som er så komplisert,

382
00:20:25,740 --> 00:20:28,250
er en slags syntaks problem, ærlig.

383
00:20:28,250 --> 00:20:31,810
Men * brukes i begge sammenhenger
både som en del av typenavn,

384
00:20:31,810 --> 00:20:34,100
og vi får se litt
senere noe annet, også.

385
00:20:34,100 --> 00:20:36,490
Og akkurat nå er det
dereferanseoperator.

386
00:20:36,490 --> 00:20:38,760
Så det går til referansen,
Den har tilgang til dataene

387
00:20:38,760 --> 00:20:43,000
ved stedet for pekeren, og
gjør det mulig å manipulere det på vilje.

388
00:20:43,000 --> 00:20:45,900
>> Nå er dette svært lik
besøker naboen din, ikke sant.

389
00:20:45,900 --> 00:20:48,710
Hvis du vet hva din
nabo lever, du er

390
00:20:48,710 --> 00:20:50,730
ikke henger ut med din nabo.

391
00:20:50,730 --> 00:20:53,510
Du vet du tilfeldigvis
vet hvor de bor,

392
00:20:53,510 --> 00:20:56,870
men det betyr ikke at ved
kraft av å ha denne kunnskapen

393
00:20:56,870 --> 00:20:59,170
du er i samspill med dem.

394
00:20:59,170 --> 00:21:01,920
Hvis du ønsker å samhandle med dem,
du må gå til huset deres,

395
00:21:01,920 --> 00:21:03,760
du må gå til hvor de bor.

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

397
00:21:07,440 --> 00:21:09,420
med dem akkurat som du ønsker å.

398
00:21:09,420 --> 00:21:12,730
Og på samme måte med variabler,
du trenger å gå til deres adresse

399
00:21:12,730 --> 00:21:15,320
Hvis du ønsker å samhandle dem,
du kan ikke bare vet adressen.

400
00:21:15,320 --> 00:21:21,495
Og måten du går til adressen er
å bruke *, den dereferanseoperator.

401
00:21:21,495 --> 00:21:23,620
Hva tror du skjer
hvis vi prøver og dereference

402
00:21:23,620 --> 00:21:25,260
en peker som har en verdi er null?

403
00:21:25,260 --> 00:21:28,470
Husker at null
pekeren peker til ingenting.

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

405
00:21:34,110 --> 00:21:36,800
hva tror du skjer?

406
00:21:36,800 --> 00:21:39,630
Vel, hvis du gjettet segmentering
utsette, ville du ha rett.

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

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

409
00:21:43,140 --> 00:21:45,820
det gjorde jeg ikke fortelle deg, at
hvis du ikke kommer

410
00:21:45,820 --> 00:21:49,220
å sette verdien av
Peker til noe meningsfylt,

411
00:21:49,220 --> 00:21:51,000
bør du sette til null?

412
00:21:51,000 --> 00:21:55,290
Jeg gjorde det og faktisk segmentering
feil er en slags god oppførsel.

413
00:21:55,290 --> 00:21:58,680
>> Har du noen gang erklært en variabel og
ikke tildelt sin verdi umiddelbart?

414
00:21:58,680 --> 00:22:02,680
Så du bare si int x; du ikke gjør det
faktisk tilordne den til noe

415
00:22:02,680 --> 00:22:05,340
og deretter senere i koden din,
du skrive ut verdien av x,

416
00:22:05,340 --> 00:22:07,650
har fortsatt ikke
tildelt den til noe.

417
00:22:07,650 --> 00:22:10,370
Ofte vil du få
null, men noen ganger

418
00:22:10,370 --> 00:22:15,000
kanskje få litt tilfeldig tall, og
du aner ikke hvor det kom fra.

419
00:22:15,000 --> 00:22:16,750
Tilsvarende kan ting
skje med pekere.

420
00:22:16,750 --> 00:22:20,110
Når du deklarerer en peker
int * pk for eksempel

421
00:22:20,110 --> 00:22:23,490
og du ikke tilordne den til en verdi,
du får fire byte for minnet.

422
00:22:23,490 --> 00:22:25,950
Uansett fire byte av
hukommelse kan systemet

423
00:22:25,950 --> 00:22:28,970
finner ut at har noen meningsfull verdi.

424
00:22:28,970 --> 00:22:31,760
Og det kan ha vært
noe som allerede er der som

425
00:22:31,760 --> 00:22:34,190
er ikke lenger nødvendig med en annen
funksjon, så du må bare

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

427
00:22:35,900 --> 00:22:40,570
>> Hva om du prøvde å gjøre dereference
noen adresse som du don't- det var

428
00:22:40,570 --> 00:22:43,410
allerede bytes og informasjon i
der, det er nå på pekeren.

429
00:22:43,410 --> 00:22:47,470
Hvis du prøver og deferanseoperasjon som peker,
du kan rote med noe minne

430
00:22:47,470 --> 00:22:49,390
at du ikke hadde tenkt
å rote med det hele.

431
00:22:49,390 --> 00:22:51,639
Og faktisk kan du gjøre
noe virkelig ødeleggende,

432
00:22:51,639 --> 00:22:54,880
som bryter et annet program,
eller bryte en annen funksjon,

433
00:22:54,880 --> 00:22:58,289
eller gjøre noe ondsinnet som
du har ikke tenkt å gjøre i det hele tatt.

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
å sette dine pekere til null hvis du
ikke sette dem til noe meningsfylt.

436
00:23:04,030 --> 00:23:06,760
Det er nok bedre på
slutten av dagen for programmet

437
00:23:06,760 --> 00:23:09,840
til å krasje da for at den skal gjøre
Noe som skruer opp

438
00:23:09,840 --> 00:23:12,400
et annet program eller en annen funksjon.

439
00:23:12,400 --> 00:23:15,207
At atferd er sannsynligvis enda
mindre ideelt enn bare å krasje.

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
å komme inn å sette dine pekere
til null hvis du ikke setter dem

442
00:23:20,920 --> 00:23:24,540
til en meningsfull verdi
umiddelbart, en verdi som du vet

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

444
00:23:27,260 --> 00:23:32,240
>> Så la oss komme tilbake nå og ta en titt
på den generelle syntaksen av situasjonen.

445
00:23:32,240 --> 00:23:37,400
Hvis jeg sier int * p ;, hva har jeg bare gjort?

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

447
00:23:38,530 --> 00:23:43,290
Jeg kjenner verdien av p er en adresse
fordi alle pekere er bare

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

449
00:23:44,660 --> 00:23:47,750
Jeg kan dereference p
bruker * operatøren.

450
00:23:47,750 --> 00:23:51,250
I denne sammenheng her, helt
top husker * er en del av den typen.

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

452
00:23:53,510 --> 00:23:56,150
Men jeg kan dereference
p bruke * operatør,

453
00:23:56,150 --> 00:24:01,897
og hvis jeg gjør det, hvis jeg går til denne adressen,
hva skal jeg finne på denne adressen?

454
00:24:01,897 --> 00:24:02,855
Jeg vil finne et heltall.

455
00:24:02,855 --> 00:24:05,910
Så int * p er i utgangspunktet
sier, er p en adresse.

456
00:24:05,910 --> 00:24:09,500
Jeg kan deferanseoperasjon p og hvis
Jeg gjør det, vil jeg finne et heltall

457
00:24:09,500 --> 00:24:11,920
på den minnelokasjon.

458
00:24:11,920 --> 00:24:14,260
>> OK, så jeg sa det var en annen
irriterende ting med stjerner

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

460
00:24:17,060 --> 00:24:21,640
Har du noen gang prøvd å erklære
flere variabler av samme type

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

462
00:24:24,409 --> 00:24:27,700
Så for en andre, late som linjen,
koden jeg faktisk har det i grønt

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

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

465
00:24:31,634 --> 00:24:34,550
Hva som ville gjøre er å faktisk lage
tre heltallsvariabler for deg,

466
00:24:34,550 --> 00:24:36,930
en som heter x, en som heter
y, og en som heter z.

467
00:24:36,930 --> 00:24:41,510
Det er en måte å gjøre det uten
å måtte dele på tre linjer.

468
00:24:41,510 --> 00:24:43,890
>> Her er der stjerner får
irriterende igjen skjønt,

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

470
00:24:49,200 --> 00:24:50,320
av variabelnavnet.

471
00:24:50,320 --> 00:24:56,430
Og så hvis jeg sier int * px, py, pz, hva jeg
faktisk får er en peker til et heltall

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

473
00:25:01,650 --> 00:25:04,950
Og det er nok ikke det
vi vil ha, det er ikke bra.

474
00:25:04,950 --> 00:25:09,290
>> Så hvis jeg ønsker å opprette flere pekere
på samme linje, av samme type,

475
00:25:09,290 --> 00:25:12,140
og stjerner, hva jeg faktisk trenger
å gjøre er å si int * pa, * pb, * pc.

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

477
00:25:17,330 --> 00:25:20,300
Nå har nettopp sagt at
og nå forteller deg dette,

478
00:25:20,300 --> 00:25:22,170
du sannsynligvis aldri vil gjøre dette.

479
00:25:22,170 --> 00:25:25,170
Og det er nok en god ting ærlig,
fordi du kanskje utilsiktet

480
00:25:25,170 --> 00:25:26,544
utelate en stjerne, noe sånt.

481
00:25:26,544 --> 00:25:29,290
Det er nok best å kanskje erklære
pekere på enkelte linjer,

482
00:25:29,290 --> 00:25:31,373
men det er bare en annen
av disse irriterende syntaks

483
00:25:31,373 --> 00:25:35,310
ting med stjerner som gjør
pekere så vanskelig å jobbe med.

484
00:25:35,310 --> 00:25:39,480
Fordi det er nettopp dette syntaktisk
rotet du må jobbe gjennom.

485
00:25:39,480 --> 00:25:41,600
Med praksis gjør det
virkelig blir andre natur.

486
00:25:41,600 --> 00:25:45,410
Jeg fortsatt gjør feil med det fortsatt
etter programmering i 10 år,

487
00:25:45,410 --> 00:25:49,630
så ikke bli opprørt hvis noe skjer
til deg, det er ganske vanlig ærlig.

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

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

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

491
00:25:59,370 --> 00:26:02,750
Vel, hvis jeg fortalte deg at en
string, har vi virkelig slags

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

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

494
00:26:06,181 --> 00:26:09,730
nevnte dette i et av våre
tidligste videoer på datatyper,

495
00:26:09,730 --> 00:26:13,820
at strengen var en datatype som
ble opprettet for deg i CS50.h.

496
00:26:13,820 --> 00:26:17,050
Du må #include
CS50.h for å bruke den.

497
00:26:17,050 --> 00:26:19,250
>> Vel streng er egentlig bare
et alias for noe

498
00:26:19,250 --> 00:26:23,600
kalt char *, en
Pekeren til en karakter.

499
00:26:23,600 --> 00:26:26,010
Vel pekere, husker,
er bare adresser.

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

501
00:26:28,780 --> 00:26:29,796
Vel det er fire eller åtte.

502
00:26:29,796 --> 00:26:32,170
Og grunnen til at jeg sier fire eller
åtte er fordi det faktisk

503
00:26:32,170 --> 00:26:36,730
avhenger av systemet, hvis du bruker
CS50 ide, char * er på størrelse med en char

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

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

506
00:26:43,850 --> 00:26:48,270
Hvis du bruker CS50 apparatet
eller bruker noen 32-bits maskin,

507
00:26:48,270 --> 00:26:51,640
og du har hørt det uttrykket 32-bit
maskin, hva er en 32-bits maskin?

508
00:26:51,640 --> 00:26:56,090
Vel det betyr bare at hver
adresse i minnet er 32 bits lang.

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

510
00:26:59,140 --> 00:27:02,710
Så en char * er fire eller åtte
byte avhengig av systemet.

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

512
00:27:06,100 --> 00:27:12,030
skriver, siden alle pekere er bare
adresser, er fire eller åtte byte.

513
00:27:12,030 --> 00:27:14,030
Så la oss se dette
diagram og la oss konkludere

514
00:27:14,030 --> 00:27:18,130
denne videoen med litt trening her.

515
00:27:18,130 --> 00:27:21,600
Så her er diagrammet vi slapp med
helt i begynnelsen av videoen.

516
00:27:21,600 --> 00:27:23,110
Så hva skjer nå hvis jeg sier * pk = 35?

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

518
00:27:26,370 --> 00:27:30,530
Så hva betyr det når jeg sier, * pk = 35?

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

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

521
00:27:34,990 --> 00:27:39,890
I sammenheng her, * er
dereferanseoperator.

522
00:27:39,890 --> 00:27:42,110
Så når dereferanse
operator benyttes,

523
00:27:42,110 --> 00:27:48,520
vi går til adressen pekte
av pk, og vi endrer hva vi finner.

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

525
00:27:55,270 --> 00:27:58,110
Så det er i utgangspunktet syntaktisk
identisk for å ha sagt k = 35.

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

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

528
00:28:01,930 --> 00:28:05,510
Hvis jeg sier int m, jeg skaper
en ny variabel kalt m.

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

530
00:28:08,260 --> 00:28:09,840
og den er merket m.

531
00:28:09,840 --> 00:28:14,960
Hvis jeg sier m = 4, satte jeg en
heltall inn i den boksen.

532
00:28:14,960 --> 00:28:20,290
Hvis si pk = & m, hvordan
dette diagrammet endringen?

533
00:28:20,290 --> 00:28:28,760
Pk = & m, du husker hva
& Operatør gjør eller heter?

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

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

536
00:28:38,740 --> 00:28:42,010
Og så effektivt hva som skjer den
diagram er at pk ikke lenger poeng

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

538
00:28:46,420 --> 00:28:48,470
>> Igjen pekere er svært
vanskelig å jobbe med

539
00:28:48,470 --> 00:28:50,620
og de tar mye av
praksis, men på grunn

540
00:28:50,620 --> 00:28:54,150
av deres evne til å tillate deg
å overføre data mellom funksjoner

541
00:28:54,150 --> 00:28:56,945
og faktisk har de
Endringene trer i kraft,

542
00:28:56,945 --> 00:28:58,820
å få hodet rundt
er veldig viktig.

543
00:28:58,820 --> 00:29:02,590
Det er trolig den mest kompliserte
tema vi diskuterer i CS50,

544
00:29:02,590 --> 00:29:05,910
men verdien du
få fra å bruke pekere

545
00:29:05,910 --> 00:29:09,200
langt oppveier komplikasjoner
som kommer fra å lære dem.

546
00:29:09,200 --> 00:29:12,690
Så jeg ønsker deg det beste av
Lykke til å lære om pekere.

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

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