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

2
00:00:06,030 --> 00:00:08,390
>> DOUG LLOYD: Pointers, hier zijn we.

3
00:00:08,390 --> 00:00:11,080
Dit is waarschijnlijk gaan om
de meest moeilijke onderwerp

4
00:00:11,080 --> 00:00:12,840
dat we praten over in CS50.

5
00:00:12,840 --> 00:00:15,060
En als je hebt gelezen
iets over pointers

6
00:00:15,060 --> 00:00:19,080
voordat u een beetje zou kunnen zijn
intimiderend te gaan op deze video.

7
00:00:19,080 --> 00:00:21,260
Het is waar de pointers
toestaan ​​dat u de capaciteit

8
00:00:21,260 --> 00:00:23,740
tot misschien verknallen
vrij slecht als je

9
00:00:23,740 --> 00:00:27,450
werken met variabelen, en data,
en het veroorzaken van het programma crasht.

10
00:00:27,450 --> 00:00:30,490
Maar ze zijn eigenlijk heel nuttig
en ze ons echt een geweldige manier toe

11
00:00:30,490 --> 00:00:33,340
om gegevens terug te passeren en
weer tussen functies

12
00:00:33,340 --> 00:00:35,490
die we anders niet in staat zijn te doen.

13
00:00:35,490 --> 00:00:37,750
>> En dus wat we echt
hier wil doen is de trein

14
00:00:37,750 --> 00:00:41,060
u goede pointer discipline, dus
dat je pointers effectief kan gebruiken

15
00:00:41,060 --> 00:00:43,850
om uw programma's die veel beter te maken.

16
00:00:43,850 --> 00:00:48,220
Zoals ik al zei pointers geven ons een andere
manier om gegevens tussen functies passeren.

17
00:00:48,220 --> 00:00:50,270
Nu als je herinneren van
een eerdere video, als

18
00:00:50,270 --> 00:00:53,720
we hadden het over
variabele reikwijdte, ik noemde

19
00:00:53,720 --> 00:01:00,610
dat alle gegevens die we passeren tussen
functies in C wordt doorgegeven door de waarde.

20
00:01:00,610 --> 00:01:03,070
En ik mag niet gebruikt dat
term, wat ik daar betekende

21
00:01:03,070 --> 00:01:07,170
was dat we passeren exemplaren van gegevens.

22
00:01:07,170 --> 00:01:12,252
Toen we langs een variabele aan een functie,
we zijn niet echt het passeren van de variabele

23
00:01:12,252 --> 00:01:13,210
om de functie, toch?

24
00:01:13,210 --> 00:01:17,670
We passeren een kopie van
die gegevens naar de functie.

25
00:01:17,670 --> 00:01:20,760
De functie doet wat het wil
en berekent een bepaalde waarde,

26
00:01:20,760 --> 00:01:23,180
en misschien gebruiken we die waarde
wanneer geeft het weer.

27
00:01:23,180 --> 00:01:26,700
>> Er was één uitzondering
deze regel van het doorgeven van de waarde,

28
00:01:26,700 --> 00:01:31,210
en we zullen terug naar wat die komen
is een beetje verderop in deze video.

29
00:01:31,210 --> 00:01:34,880
Als we gebruik maken van pointers plaats
gebruik van variabelen,

30
00:01:34,880 --> 00:01:38,180
of plaats van de variabelen
zelf of kopieën van de variabelen,

31
00:01:38,180 --> 00:01:43,790
kunnen we nu langs de variabelen rond
tussen functies op een andere manier.

32
00:01:43,790 --> 00:01:46,550
Dit betekent dat als we
een verandering in een functie,

33
00:01:46,550 --> 00:01:49,827
die verandering ook daadwerkelijk te nemen
effect in een andere functie.

34
00:01:49,827 --> 00:01:52,160
Nogmaals, dit is iets dat
we konden niet eerder doen,

35
00:01:52,160 --> 00:01:56,979
en als je ooit hebt geprobeerd om de swap
waarde van twee variabelen in functie,

36
00:01:56,979 --> 00:01:59,270
u dit probleem hebt gemerkt
soort omhoog kruipen, toch?

37
00:01:59,270 --> 00:02:04,340
>> Willen we X en Y, en we wisselen
geef ze een functie genaamd swap,

38
00:02:04,340 --> 00:02:08,680
binnenkant van de functie van de swap
variabelen doen uitwisseling waarden.

39
00:02:08,680 --> 00:02:12,600
Men wordt twee, twee wordt
één, maar we eigenlijk niet

40
00:02:12,600 --> 00:02:16,890
iets veranderen in de oorspronkelijke
functie van de beller.

41
00:02:16,890 --> 00:02:19,550
Want we kunnen niet, we zijn alleen
werken met kopieën van hen.

42
00:02:19,550 --> 00:02:24,760
Met verwijzingen hoewel, we kunnen
eigenlijk passeren X en Y om een ​​functie.

43
00:02:24,760 --> 00:02:26,960
Die functie kan doen
iets mee.

44
00:02:26,960 --> 00:02:29,250
En die variabelen waarden
daadwerkelijk kan veranderen.

45
00:02:29,250 --> 00:02:33,710
Dus dat is nogal een verandering in
ons vermogen om te werken met data.

46
00:02:33,710 --> 00:02:36,100
>> Voordat we een duik in
pointers, ik denk dat het de moeite waard

47
00:02:36,100 --> 00:02:38,580
het nemen van een paar minuten om
ga terug naar de basis hier.

48
00:02:38,580 --> 00:02:41,000
En hebben een blik op hoe
computergeheugen werken

49
00:02:41,000 --> 00:02:45,340
omdat deze twee onderwerpen gaan
eigenlijk behoorlijk met elkaar verbonden.

50
00:02:45,340 --> 00:02:48,480
Zoals u waarschijnlijk weet,
op uw computersysteem

51
00:02:48,480 --> 00:02:51,310
heb je een harde schijf of
misschien een solid state drive,

52
00:02:51,310 --> 00:02:54,430
een soort van opslag van bestanden locatie.

53
00:02:54,430 --> 00:02:57,950
Het is meestal ergens in de
nabijheid van 250 gigabyte

54
00:02:57,950 --> 00:02:59,810
om misschien een paar terabytes nu.

55
00:02:59,810 --> 00:03:02,270
En het is waar al je
bestanden uiteindelijk wonen,

56
00:03:02,270 --> 00:03:04,870
zelfs wanneer de computer wordt afgesloten
off, kunt u het weer inschakelen

57
00:03:04,870 --> 00:03:09,190
en u vindt uw bestanden er
weer wanneer u uw systeem opnieuw op te starten.

58
00:03:09,190 --> 00:03:14,820
Maar harde schijven, zoals een harde schijf,
een harde schijf of een solid state drive, een SSD,

59
00:03:14,820 --> 00:03:16,050
zijn slechts opslagruimte.

60
00:03:16,050 --> 00:03:20,400
>> We kunnen niet echt iets te doen met
de gegevens die op de harde schijf,

61
00:03:20,400 --> 00:03:22,080
of in een solid state drive.

62
00:03:22,080 --> 00:03:24,950
Om daadwerkelijk veranderen
gegevens of het rond bewegen,

63
00:03:24,950 --> 00:03:28,800
we hebben om het te verplaatsen naar
RAM, random access memory.

64
00:03:28,800 --> 00:03:31,170
Nu RAM, heb je een heleboel
minder op je computer.

65
00:03:31,170 --> 00:03:34,185
U kunt ergens in het hebben
nabijheid van 512 megabytes

66
00:03:34,185 --> 00:03:38,850
als je een oudere computer,
tot misschien twee, vier, acht, 16,

67
00:03:38,850 --> 00:03:41,820
misschien zelfs een beetje
meer, gigabytes aan RAM.

68
00:03:41,820 --> 00:03:46,390
Dus dat is veel kleiner, maar dat is
waarbij alle vluchtige gegevens bestaan.

69
00:03:46,390 --> 00:03:48,270
Dat is waar we dingen kunnen veranderen.

70
00:03:48,270 --> 00:03:53,350
Maar wanneer we onze computer uit,
alle data in het RAM wordt vernietigd.

71
00:03:53,350 --> 00:03:57,150
>> Dus dat is waarom we nodig hebben om de harde schijf hebt
voor de meer permanente locatie ervan,

72
00:03:57,150 --> 00:03:59,720
zodat het zou exists-
echt slecht als elke keer als we

73
00:03:59,720 --> 00:04:03,310
draaide onze computer uit, elke
bestand in ons systeem werd uitgewist.

74
00:04:03,310 --> 00:04:05,600
Dus werken we binnen RAM.

75
00:04:05,600 --> 00:04:09,210
En elke keer als we het over
geheugen, vrij veel, in CS50,

76
00:04:09,210 --> 00:04:15,080
we praten over RAM, geen harde schijf.

77
00:04:15,080 --> 00:04:18,657
>> Dus als we de dingen te verplaatsen in het geheugen,
neemt hij een bepaalde hoeveelheid ruimte.

78
00:04:18,657 --> 00:04:20,740
Alle data types die
We hebben gewerkt met

79
00:04:20,740 --> 00:04:23,480
nemen verschillende
hoeveelheid ruimte in RAM.

80
00:04:23,480 --> 00:04:27,600
Dus elke keer dat u een integer maken
variabele vier bytes geheugen

81
00:04:27,600 --> 00:04:30,750
zijn gereserveerd in het RAM-geheugen, zodat u
kan met die integer.

82
00:04:30,750 --> 00:04:34,260
U kunt de integer verklaren,
veranderen, toe te wijzen

83
00:04:34,260 --> 00:04:36,700
tot een waarde 10 opgehoogd
een, enzovoort, enzovoort.

84
00:04:36,700 --> 00:04:39,440
Alles wat moet gebeuren
RAM, en je krijgt vier bytes

85
00:04:39,440 --> 00:04:42,550
werken voor elke
integer die u maakt.

86
00:04:42,550 --> 00:04:45,410
>> Elk teken dat u
maken krijgt één byte.

87
00:04:45,410 --> 00:04:48,160
Dat is gewoon hoeveel ruimte
nodig om een ​​teken te slaan.

88
00:04:48,160 --> 00:04:51,310
Elke vlotter, een echte
nummer, krijgt vier bytes

89
00:04:51,310 --> 00:04:53,390
tenzij het een double
precision floating point

90
00:04:53,390 --> 00:04:56,510
nummer, die u toelaat om
hebben meer nauwkeurige of meer cijfers

91
00:04:56,510 --> 00:04:59,300
na de komma
zonder verlies van precisie,

92
00:04:59,300 --> 00:05:01,820
die nemen acht bytes aan geheugen.

93
00:05:01,820 --> 00:05:06,730
Lange longs, echt grote getallen,
nemen ook acht bytes aan geheugen.

94
00:05:06,730 --> 00:05:09,000
Hoeveel bytes geheugen
do strijkers nemen?

95
00:05:09,000 --> 00:05:12,990
Nou laten we een speld in die vraag
voor nu, maar we zullen terug te komen.

96
00:05:12,990 --> 00:05:17,350
>> Dus terug naar het idee van het geheugen
een groot scala aan byte-sized cellen.

97
00:05:17,350 --> 00:05:20,871
Dat is echt alles wat het is, het is
gewoon een enorm scala aan cellen,

98
00:05:20,871 --> 00:05:23,370
net als elke andere array
je bekend bent en te zien,

99
00:05:23,370 --> 00:05:26,430
met uitzondering van elk element is een byte breed.

100
00:05:26,430 --> 00:05:30,030
En net als een array,
elk element heeft een adres.

101
00:05:30,030 --> 00:05:32,120
Elk element van een array
heeft een index, en we

102
00:05:32,120 --> 00:05:36,302
kan die index gebruiken doen zogenoemde
willekeurige toegang op de array.

103
00:05:36,302 --> 00:05:38,510
We hoeven niet te beginnen bij
het begin van de array,

104
00:05:38,510 --> 00:05:40,569
doorloopt elke
enkel element daarvan,

105
00:05:40,569 --> 00:05:41,860
om te vinden wat we zoeken.

106
00:05:41,860 --> 00:05:45,790
We kunnen alleen maar zeggen, ik wil het te krijgen
15 element of de 100-element.

107
00:05:45,790 --> 00:05:49,930
En je kunt gewoon passeren in dat nummer
en ontvang de waarde die u zoekt.

108
00:05:49,930 --> 00:05:54,460
>> Evenzo elke locatie
in het geheugen heeft een adres.

109
00:05:54,460 --> 00:05:57,320
Zodat uw geheugen macht
kijken iets als dit.

110
00:05:57,320 --> 00:06:01,420
Hier is een zeer klein deel van
geheugen, dat is 20 bytes geheugen.

111
00:06:01,420 --> 00:06:04,060
De eerste 20 bytes omdat mijn
richt daar onderaan

112
00:06:04,060 --> 00:06:08,890
zijn 0, 1, 2, 3, enzovoort
Op de weg naar 19.

113
00:06:08,890 --> 00:06:13,190
En toen ik verklaar variabelen en
als ik begin te werken met hen,

114
00:06:13,190 --> 00:06:15,470
het systeem gaat ingesteld
wat ruimte gereserveerd voor mij

115
00:06:15,470 --> 00:06:17,595
in dit geheugen werkt
mijn variabelen.

116
00:06:17,595 --> 00:06:21,610
Dus ik zou zeggen, char c is gelijk aan het kapitaal
H. En wat gaat er gebeuren?

117
00:06:21,610 --> 00:06:23,880
Goed het systeem gaat
gereserveerd voor mij een byte.

118
00:06:23,880 --> 00:06:27,870
In dit geval gekozen bytenummer
vier, de byte op het adres van vier,

119
00:06:27,870 --> 00:06:31,310
en het gaat om het op te slaan
letter hoofdletter H daar voor mij.

120
00:06:31,310 --> 00:06:34,350
Als ik dan zeg int snelheid
limiet bedraagt ​​65, het

121
00:06:34,350 --> 00:06:36,806
gaat om vernietiging van vier
bytes van het geheugen voor mij.

122
00:06:36,806 --> 00:06:39,180
En het gaat om die te behandelen
vier bytes als een eenheid

123
00:06:39,180 --> 00:06:41,305
want wat we werken
met een geheel getal in.

124
00:06:41,305 --> 00:06:44,350
En het gaat te slaan 65 in.

125
00:06:44,350 --> 00:06:47,000
>> Nu al ben ik soort
vertel je een beetje een leugen,

126
00:06:47,000 --> 00:06:50,150
recht, omdat we weten dat
computers werken in binaire.

127
00:06:50,150 --> 00:06:53,100
Ze begrijpen niet
noodzakelijk wat een hoofdletter H is

128
00:06:53,100 --> 00:06:57,110
of wat een 65 is, maar ze
begrijpen binair, nullen en enen.

129
00:06:57,110 --> 00:06:59,000
En dus eigenlijk wat
we opslaan daar

130
00:06:59,000 --> 00:07:03,450
niet de letter H en nummer 65,
maar de binaire voorstellingen

131
00:07:03,450 --> 00:07:06,980
daarvan, die ziet er een
iets als dit.

132
00:07:06,980 --> 00:07:10,360
Met name in het
context van de integer variabele

133
00:07:10,360 --> 00:07:13,559
het gaat niet om gewoon spuug het in,
het gaat niet om het te behandelen als een vier

134
00:07:13,559 --> 00:07:15,350
byte brok per se,
het is eigenlijk gaat

135
00:07:15,350 --> 00:07:19,570
te behandelen als een vier byte stukken,
die zoiets zou kunnen zien.

136
00:07:19,570 --> 00:07:22,424
En zelfs dit is niet
helemaal waar ofwel,

137
00:07:22,424 --> 00:07:24,840
vanwege iets genaamd
een endianness, die we niet

138
00:07:24,840 --> 00:07:26,965
van plan om in nu, maar
Als je benieuwd bent,

139
00:07:26,965 --> 00:07:29,030
u kunt lezen op kleine
en grote endianness.

140
00:07:29,030 --> 00:07:31,640
Maar omwille van dit argument
terwille van de video,

141
00:07:31,640 --> 00:07:34,860
laten we aannemen dat is, in
feit, dat het getal 65 zou

142
00:07:34,860 --> 00:07:36,970
in worden vertegenwoordigd
geheugen op elk systeem,

143
00:07:36,970 --> 00:07:38,850
maar het is niet helemaal waar.

144
00:07:38,850 --> 00:07:41,700
>> Maar laten we eigenlijk gewoon
ontdoen van alle binaire geheel,

145
00:07:41,700 --> 00:07:44,460
en denk maar als H
en 65, het is een stuk makkelijker

146
00:07:44,460 --> 00:07:47,900
na te denken over het als
die als mens.

147
00:07:47,900 --> 00:07:51,420
Oké, dus het lijkt ook misschien een
kleine willekeurige dat I've- mijn systeem

148
00:07:51,420 --> 00:07:55,130
gaf me geen bytes 5, 6, 7,
en 8 op de integer slaan.

149
00:07:55,130 --> 00:07:58,580
Er is een reden voor dat ook, die
zullen we niet krijgen op dit moment, maar het volstaat

150
00:07:58,580 --> 00:08:00,496
te zeggen dat wat de
computer is hier aan het doen

151
00:08:00,496 --> 00:08:02,810
is waarschijnlijk een goede zet op zijn kant.

152
00:08:02,810 --> 00:08:06,020
Om niet geven me geheugen dat is
noodzakelijkerwijs rug aan rug.

153
00:08:06,020 --> 00:08:10,490
Hoewel het gaat om het nu te doen
als ik wil andere string te krijgen,

154
00:08:10,490 --> 00:08:13,080
riep achternaam, en ik wil
Lloyd in daar te zetten.

155
00:08:13,080 --> 00:08:18,360
Ik ga nodig hebben om een ​​fit
karakter, elke letter van die

156
00:08:18,360 --> 00:08:21,330
gaat naar een vereisen
karakter, een byte geheugen.

157
00:08:21,330 --> 00:08:26,230
Dus als ik Lloyd in mijn reeks kon zetten
als deze Ik ben er vrij goed om te gaan, toch?

158
00:08:26,230 --> 00:08:28,870
Wat ontbreekt er?

159
00:08:28,870 --> 00:08:31,840
>> Vergeet niet dat elke snaar we werken
met in C eindigt met een backslash nul,

160
00:08:31,840 --> 00:08:33,339
en we kunnen hier niet weg te laten die, hetzij.

161
00:08:33,339 --> 00:08:36,090
We moeten opzij één byte ingesteld
van het geheugen zo houden we dat

162
00:08:36,090 --> 00:08:39,130
weten wanneer onze reeks is beëindigd.

163
00:08:39,130 --> 00:08:41,049
Dus nogmaals deze regeling
van de gang van zaken

164
00:08:41,049 --> 00:08:42,799
verschijnen in het geheugen macht
een beetje willekeurig,

165
00:08:42,799 --> 00:08:44,870
maar eigenlijk is hoe
de meeste zijn ontworpen.

166
00:08:44,870 --> 00:08:48,330
Om hen line-up op een veelvoud
vier, om redenen weer

167
00:08:48,330 --> 00:08:50,080
dat we niet hoeven te
krijgen nu.

168
00:08:50,080 --> 00:08:53,060
Maar dit, zodat het volstaat om te zeggen dat
Na deze drie regels code,

169
00:08:53,060 --> 00:08:54,810
dit is wat het geheugen eruit zou kunnen zien.

170
00:08:54,810 --> 00:08:58,930
Als ik het nodig het geheugen locaties
4, 8 en 12 om mijn gegevens te houden,

171
00:08:58,930 --> 00:09:01,100
dit is wat mijn geheugen eruit zou kunnen zien.

172
00:09:01,100 --> 00:09:04,062
>> En gewoon bijzonder zijn
pedant hier, wanneer

173
00:09:04,062 --> 00:09:06,020
we praten over het geheugen
adressen we meestal

174
00:09:06,020 --> 00:09:08,390
dit doen met behulp van hexadecimale notaties.

175
00:09:08,390 --> 00:09:12,030
Dus waarom niet we zetten al deze
van decimaal naar hexadecimale notatie

176
00:09:12,030 --> 00:09:15,010
gewoon omdat dat is over het algemeen
hoe verwijzen we naar het geheugen.

177
00:09:15,010 --> 00:09:17,880
Dus in plaats van 0 tot
19, wat we hebben is nul

178
00:09:17,880 --> 00:09:20,340
x nul tot nul x1 drie.

179
00:09:20,340 --> 00:09:23,790
Dat zijn de 20 bytes geheugen die we
hebben of we kijken naar in dit beeld

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

181
00:09:25,540 --> 00:09:29,310
>> Dus al dat gezegd zijnde, laten we
stap weg van het geheugen voor een tweede

182
00:09:29,310 --> 00:09:30,490
en terug naar pointers.

183
00:09:30,490 --> 00:09:32,420
Hier is het belangrijkste
om te onthouden

184
00:09:32,420 --> 00:09:34,070
als we beginnen werken met pointers.

185
00:09:34,070 --> 00:09:36,314
Een pointer is niets
meer dan een adres.

186
00:09:36,314 --> 00:09:38,230
Ik zal het nogmaals zeggen, want
Het is zo belangrijk,

187
00:09:38,230 --> 00:09:42,730
een pointer is niets
meer dan een adres.

188
00:09:42,730 --> 00:09:47,760
Pointers zijn adressen aan locaties
in het geheugen waar de variabelen wonen.

189
00:09:47,760 --> 00:09:52,590
Wetende dat het wordt hopelijk een
beetje gemakkelijker om te werken met hen.

190
00:09:52,590 --> 00:09:54,550
Een ander ding dat ik graag
te doen is om een ​​soort hebben

191
00:09:54,550 --> 00:09:58,510
diagrammen visueel vertegenwoordigen wat
gebeurt met diverse regels code.

192
00:09:58,510 --> 00:10:00,660
En we zullen dit een paar te doen
keer in pointers,

193
00:10:00,660 --> 00:10:03,354
en als we praten over dynamische
toewijzing van het geheugen ook.

194
00:10:03,354 --> 00:10:06,020
Omdat ik denk dat deze diagrammen
kan bijzonder nuttig.

195
00:10:06,020 --> 00:10:09,540
>> Dus als ik zeg bijvoorbeeld, int k
in mijn code, wat gebeurt er?

196
00:10:09,540 --> 00:10:12,524
Nou wat er eigenlijk gebeurt is
Ik krijg het geheugen gereserveerd voor mij,

197
00:10:12,524 --> 00:10:14,690
maar ik weet niet eens graag
denken als dat, ik

198
00:10:14,690 --> 00:10:16,300
graag over na te denken als een doos.

199
00:10:16,300 --> 00:10:20,090
Ik heb een doos en het
gekleurde groen omdat ik

200
00:10:20,090 --> 00:10:21,750
kan integers in groene vakjes te zetten.

201
00:10:21,750 --> 00:10:23,666
Als het een karakter I
misschien een blauw vak.

202
00:10:23,666 --> 00:10:27,290
Maar ik zeg altijd, als ik het creëren
een doos die getallen kan houden

203
00:10:27,290 --> 00:10:28,950
die doos is groen gekleurd.

204
00:10:28,950 --> 00:10:33,020
En ik neem een ​​permanent marker
Ik schrijf k aan de kant ervan.

205
00:10:33,020 --> 00:10:37,590
Dus ik heb een doos genoemd k,
waarin ik integers kan zetten.

206
00:10:37,590 --> 00:10:41,070
Dus als ik zeg int k, dat is
wat gebeurt er in mijn hoofd.

207
00:10:41,070 --> 00:10:43,140
Als ik zeg dat k gelijk aan vijf, wat doe ik?

208
00:10:43,140 --> 00:10:45,110
Nou, ik ben om vijf
in het vak, rechts.

209
00:10:45,110 --> 00:10:48,670
Dit is vrij eenvoudig, als
Ik zeg int k, maak een doos genoemd k.

210
00:10:48,670 --> 00:10:52,040
Als ik zeg dat k gelijk aan 5,
zet vijf in de doos.

211
00:10:52,040 --> 00:10:53,865
Hopelijk is dat niet te veel van een sprong.

212
00:10:53,865 --> 00:10:55,990
Hier is waar de dingen gaan een
weinig interessant hoor.

213
00:10:55,990 --> 00:11:02,590
Als ik zeg int * pk, goed, zelfs als ik niet
weet wat dit noodzakelijkerwijs betekent,

214
00:11:02,590 --> 00:11:06,150
het is duidelijk iets
te maken met een integer.

215
00:11:06,150 --> 00:11:08,211
Dus ik ga om te kleuren
dit vakje groen-ish,

216
00:11:08,211 --> 00:11:10,210
Ik weet dat het iets
te maken met een integer,

217
00:11:10,210 --> 00:11:13,400
maar het is niet een geheel getal zelf,
want het is een int ster.

218
00:11:13,400 --> 00:11:15,390
Er is iets lichtjes
anders over.

219
00:11:15,390 --> 00:11:17,620
Dus in een geheel getal is,
maar anders is

220
00:11:17,620 --> 00:11:19,830
niet te verschillend van
waar we het over hadden.

221
00:11:19,830 --> 00:11:24,240
Het is een doos, het heeft een label,
Het draagt ​​een label pk,

222
00:11:24,240 --> 00:11:27,280
en het is in staat van het bedrijf
int sterren, welke dat zijn.

223
00:11:27,280 --> 00:11:29,894
Ze hebben iets te doen
met getallen, duidelijk.

224
00:11:29,894 --> 00:11:31,060
Hier is de laatste regel wel.

225
00:11:31,060 --> 00:11:37,650
Als ik zeg pk = & k, whoa,
wat er net gebeurd, toch?

226
00:11:37,650 --> 00:11:41,820
Dus dit willekeurig getal, schijnbaar willekeurige
nummer, wordt geworpen in de doos daar.

227
00:11:41,820 --> 00:11:44,930
Dat alles is, is pk
krijgt het adres van k.

228
00:11:44,930 --> 00:11:52,867
Dus ik ben steken waarbij k woont in het geheugen,
zijn adres, het adres van haar bytes.

229
00:11:52,867 --> 00:11:55,200
Alles wat ik doe is wat ik zeg
die waarde is wat ik ga

230
00:11:55,200 --> 00:11:59,430
binnenkant van mijn doos genoemd pk te zetten.

231
00:11:59,430 --> 00:12:02,080
En omdat deze dingen zijn
pointers en omdat kijken

232
00:12:02,080 --> 00:12:04,955
in een string als nul x
acht nul c zeven vier acht

233
00:12:04,955 --> 00:12:07,790
twee nul is waarschijnlijk
niet erg zinvol.

234
00:12:07,790 --> 00:12:12,390
Toen we over het algemeen te visualiseren pointers,
we eigenlijk doen als pointers.

235
00:12:12,390 --> 00:12:17,000
Pk geeft ons de informatie
moeten we k vinden in het geheugen.

236
00:12:17,000 --> 00:12:19,120
Dus eigenlijk pk heeft een pijl in.

237
00:12:19,120 --> 00:12:21,670
En als we lopen de lengte
van die pijl, stel

238
00:12:21,670 --> 00:12:25,280
het is iets wat je kunt lopen, als we
wandelen langs de lengte van de pijl,

239
00:12:25,280 --> 00:12:29,490
op het uiterste puntje van die pijl, we
zal de locatie in het geheugen vinden

240
00:12:29,490 --> 00:12:31,390
waarbij k woont.

241
00:12:31,390 --> 00:12:34,360
En dat is echt belangrijk
want zodra we weten waar k woont,

242
00:12:34,360 --> 00:12:37,870
kunnen we beginnen te werken met de data
binnenkant van dat geheugen locatie.

243
00:12:37,870 --> 00:12:40,780
Hoewel we krijgen een piepklein
beetje vooruit onszelf voor nu.

244
00:12:40,780 --> 00:12:42,240
>> Dus wat is een pointer?

245
00:12:42,240 --> 00:12:45,590
Een pointer is een data-item waarvan
waarde is een geheugen adres.

246
00:12:45,590 --> 00:12:49,740
Dat was dat nul x acht nul stuff
er aan de hand, dat was een geheugen adres.

247
00:12:49,740 --> 00:12:52,060
Dat was een locatie in het geheugen.

248
00:12:52,060 --> 00:12:55,080
En het type van een pointer
beschrijft het soort

249
00:12:55,080 --> 00:12:56,930
van de gegevens die u kunt vinden op
dat het geheugen adres.

250
00:12:56,930 --> 00:12:58,810
Dus er is de int ster deel rechts.

251
00:12:58,810 --> 00:13:03,690
Als ik volg dat de pijl, het is
gaat me te leiden naar een locatie.

252
00:13:03,690 --> 00:13:06,980
En die locatie, wat ik
vindt er in mijn voorbeeld,

253
00:13:06,980 --> 00:13:08,240
is een groen gekleurd vak.

254
00:13:08,240 --> 00:13:12,650
Het is een geheel getal, dat is wat ik
zal vinden als ik naar dat adres.

255
00:13:12,650 --> 00:13:14,830
De data type van een
wijzer beschrijft wat

256
00:13:14,830 --> 00:13:17,936
vindt u op dat het geheugen adres.

257
00:13:17,936 --> 00:13:19,560
Dus hier is het echt cool ding.

258
00:13:19,560 --> 00:13:25,090
Pointers ons toelaten te passeren
variabelen tussen functies.

259
00:13:25,090 --> 00:13:28,520
En eigenlijk passeren variabelen
en niet kopieën van hen passeren.

260
00:13:28,520 --> 00:13:32,879
Want als we precies weten waar
geheugen naar een variabele vinden

261
00:13:32,879 --> 00:13:35,670
we hoeven niet om een ​​kopie van te maken
, kunnen we gewoon naar die locatie

262
00:13:35,670 --> 00:13:37,844
en werken met die variabele.

263
00:13:37,844 --> 00:13:40,260
Dus in wezen pointers soort
te maken van een computer-omgeving

264
00:13:40,260 --> 00:13:42,360
veel meer als de echte wereld, rechts.

265
00:13:42,360 --> 00:13:44,640
>> Dus hier is een analogie.

266
00:13:44,640 --> 00:13:48,080
Laten we zeggen dat ik een notebook,
rechts, en het is vol met aantekeningen.

267
00:13:48,080 --> 00:13:50,230
En ik zou graag willen dat u te werken.

268
00:13:50,230 --> 00:13:53,960
Je bent een functie die
updates notities, rechts.

269
00:13:53,960 --> 00:13:56,390
In de manier waarop we hebben geweest
dusver werken, wat

270
00:13:56,390 --> 00:14:02,370
gebeurt wordt u mijn notebook te nemen,
ga je naar de kopie op te slaan,

271
00:14:02,370 --> 00:14:06,410
je een Xerox kopie van maken
elke pagina van de notebook.

272
00:14:06,410 --> 00:14:09,790
Je zal mijn laptop terug te verlaten
op mijn bureau als je klaar bent,

273
00:14:09,790 --> 00:14:14,600
je zult gaan en doorhalen dingen in mijn
notebook die verouderd zijn of fout,

274
00:14:14,600 --> 00:14:19,280
en dan zul je terug te geven aan
me de stapel Xerox pagina's

275
00:14:19,280 --> 00:14:22,850
dat is een replica van mijn notebook
de wijzigingen die u hebt aangebracht.

276
00:14:22,850 --> 00:14:27,040
En op dat moment, het is aan mij als
de roeping functie, als de beller,

277
00:14:27,040 --> 00:14:30,582
om te beslissen om uw notities te nemen en
integreren ze terug in mijn notebook.

278
00:14:30,582 --> 00:14:32,540
Dus er is veel trappen
hier gaat, rechts.

279
00:14:32,540 --> 00:14:34,850
Als zou het niet beter zijn
als ik alleen maar zeggen, hey, kunt u

280
00:14:34,850 --> 00:14:38,370
update mijn notebook voor
me, geef je mijn notebook,

281
00:14:38,370 --> 00:14:40,440
en je dingen te nemen en
ze letterlijk doorhalen

282
00:14:40,440 --> 00:14:42,810
en update mijn aantekeningen in mijn notebook.

283
00:14:42,810 --> 00:14:45,140
En dan geef ik mijn notebook terug.

284
00:14:45,140 --> 00:14:47,320
Dat is een soort van wat
pointers ons in staat om te doen,

285
00:14:47,320 --> 00:14:51,320
ze maken deze omgeving veel
meer zoals hoe we in werkelijkheid opereren.

286
00:14:51,320 --> 00:14:54,640
>> Oké dus dat is wat
een pointer is, laten we praten

287
00:14:54,640 --> 00:14:58,040
hoe pointers werken C, en
hoe we kunnen beginnen te werken met hen.

288
00:14:58,040 --> 00:15:02,550
Dus er is een zeer eenvoudige pointer
in C genaamd de null pointer.

289
00:15:02,550 --> 00:15:04,830
De null pointer verwijst naar niets.

290
00:15:04,830 --> 00:15:08,310
Dit waarschijnlijk lijkt alsof het
eigenlijk niet een zeer nuttig ding,

291
00:15:08,310 --> 00:15:10,500
maar zoals we zullen zien een
even later, het feit

292
00:15:10,500 --> 00:15:15,410
dat dit null pointer bestaat
eigenlijk echt kan van pas komen.

293
00:15:15,410 --> 00:15:19,090
En wanneer u een wijzer te maken, en
u niet de waarde immediately- ingesteld

294
00:15:19,090 --> 00:15:21,060
een voorbeeld van de instelling
onmiddellijk de waarde

295
00:15:21,060 --> 00:15:25,401
zal een paar dia's terug
waar ik zei pk evenaart & K,

296
00:15:25,401 --> 00:15:28,740
pk krijgt adres k, zoals
we zullen zien wat dat betekent,

297
00:15:28,740 --> 00:15:32,990
we zullen zien hoe de code die shortly-
als we niet de waarde om iets te stellen

298
00:15:32,990 --> 00:15:35,380
onmiddellijk zinvol,
Je moet altijd

299
00:15:35,380 --> 00:15:37,480
stel je pointer te wijzen op null.

300
00:15:37,480 --> 00:15:40,260
Je moet instellen om te wijzen op niets.

301
00:15:40,260 --> 00:15:43,614
>> Dat is heel anders dan
verlaat de waarde is

302
00:15:43,614 --> 00:15:45,530
en waarbij een
pointer en gewoon in de veronderstelling

303
00:15:45,530 --> 00:15:48,042
het is null, want dat is zelden waar.

304
00:15:48,042 --> 00:15:50,000
Dus je moet altijd ingesteld
de waarde van pointer

305
00:15:50,000 --> 00:15:55,690
op null als u niet de waarde in te stellen
om iets zinvols onmiddellijk.

306
00:15:55,690 --> 00:15:59,090
U kunt controleren of de waarde van een pointer's
null is met behulp van de operator gelijkheid

307
00:15:59,090 --> 00:16:05,450
(==), Net als je het vergelijkt elke integer
waarden of karakter waarden met (==)

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

309
00:16:06,320 --> 00:16:10,994
Het is een speciale soort van constante
waarde die u kunt gebruiken om te testen.

310
00:16:10,994 --> 00:16:13,160
Dus dat was een zeer eenvoudige
wijzer, de null pointer.

311
00:16:13,160 --> 00:16:15,320
Een andere manier voor het creëren
een pointer te extraheren

312
00:16:15,320 --> 00:16:18,240
het adres van een variabele
u al hebt gemaakt,

313
00:16:18,240 --> 00:16:22,330
en je doet dit met behulp van de &
operator adres extractie.

314
00:16:22,330 --> 00:16:26,720
Die hebben we al eerder gezien
in het eerste diagram voorbeeld toonde ik.

315
00:16:26,720 --> 00:16:31,450
Dus als x een variabele die we hebben
al gemaakt van het type integer,

316
00:16:31,450 --> 00:16:35,110
dan en x een pointer naar een integer.

317
00:16:35,110 --> 00:16:39,810
& x is- herinneren, en gaat te extraheren
het adres van het ding aan de rechterkant.

318
00:16:39,810 --> 00:16:45,350
En omdat een pointer is gewoon een adres,
dan en x een pointer naar een integer

319
00:16:45,350 --> 00:16:48,560
waarvan de waarde is waar in het geheugen x leven.

320
00:16:48,560 --> 00:16:50,460
Het is het adres x's.

321
00:16:50,460 --> 00:16:53,296
Dus is en x het adres van x.

322
00:16:53,296 --> 00:16:55,670
Laten we dit een stap
verder en verbinding iets

323
00:16:55,670 --> 00:16:58,380
Ik gezinspeeld in een eerdere video.

324
00:16:58,380 --> 00:17:06,730
Als arr is een array van doubles, dan
& arr square bracket i is een pointer

325
00:17:06,730 --> 00:17:08,109
om een ​​dubbele.

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

327
00:17:08,970 --> 00:17:12,160
arr vierkante haak ik, als
arr is een array van doubles,

328
00:17:12,160 --> 00:17:19,069
dan arr square bracket i
het i-de element van de matrix,

329
00:17:19,069 --> 00:17:29,270
en & arr vierkante haken i is waar in
geheugen van de i-de element van arr bestaat.

330
00:17:29,270 --> 00:17:31,790
>> Dus wat is de implicatie hier?

331
00:17:31,790 --> 00:17:34,570
Een arrays naam, de implicatie
van dit hele ding,

332
00:17:34,570 --> 00:17:39,290
is dat de naam van een array is
in feite zelf een pointer.

333
00:17:39,290 --> 00:17:41,170
Je hebt gewerkt
met verwijzingen langs

334
00:17:41,170 --> 00:17:45,290
elke keer dat u een array hebt gebruikt.

335
00:17:45,290 --> 00:17:49,090
Vergeet niet uit het voorbeeld
op variabele reikwijdte,

336
00:17:49,090 --> 00:17:53,420
in de buurt van het einde van de video presenteer ik
een voorbeeld waar we een functie

337
00:17:53,420 --> 00:17:56,890
riep set int en een
functie genaamd set array.

338
00:17:56,890 --> 00:18:00,490
En uw uitdaging om te bepalen
of, of welke

339
00:18:00,490 --> 00:18:03,220
waarden die we uitgeprint
het einde van de functie,

340
00:18:03,220 --> 00:18:05,960
aan het einde van het hoofdprogramma.

341
00:18:05,960 --> 00:18:08,740
>> Misschien herinner je je van dat voorbeeld
of als u de video hebt bekeken,

342
00:18:08,740 --> 00:18:13,080
je weet dat wanneer je- de oproep om
set int effectief doet niets.

343
00:18:13,080 --> 00:18:16,390
Maar het gesprek op te zetten serie doet.

344
00:18:16,390 --> 00:18:19,280
En ik soort van verbloemd waarom
dat het geval op dat moment.

345
00:18:19,280 --> 00:18:22,363
Ik zei gewoon, nou het is een array, het is
speciale, weet je, er is een reden.

346
00:18:22,363 --> 00:18:25,020
De reden is dat een array
naam is eigenlijk gewoon een pointer,

347
00:18:25,020 --> 00:18:28,740
en er is deze speciale
syntax beugel plein dat

348
00:18:28,740 --> 00:18:30,510
dingen veel leuker om mee te werken.

349
00:18:30,510 --> 00:18:34,410
En ze maken het idee van een
pointer een stuk minder intimiderend,

350
00:18:34,410 --> 00:18:36,800
en dat is waarom ze sorteren
van gepresenteerd op die manier.

351
00:18:36,800 --> 00:18:38,600
Maar echt arrays zijn pointers.

352
00:18:38,600 --> 00:18:41,580
En dat is waarom wanneer we
een wijziging aan de array

353
00:18:41,580 --> 00:18:44,880
toen we voorbij een array als parameter
een functie of als argument

354
00:18:44,880 --> 00:18:50,110
een functie van de inhoud van de array
in zowel de aangeroepene eigenlijk veranderd

355
00:18:50,110 --> 00:18:51,160
en de beller.

356
00:18:51,160 --> 00:18:55,846
Die voor elke andere vorm van
variabele we zagen was niet het geval.

357
00:18:55,846 --> 00:18:58,970
Dus dat is gewoon iets om in te houden
geest als je werkt met pointers,

358
00:18:58,970 --> 00:19:01,610
is de naam van een
serie eigenlijk een pointer

359
00:19:01,610 --> 00:19:04,750
het eerste element van de matrix.

360
00:19:04,750 --> 00:19:08,930
>> OK dus nu hebben we al deze
feiten, laten we gaan, rechts.

361
00:19:08,930 --> 00:19:11,370
Waarom hebben we de zorg over
waar iets leeft.

362
00:19:11,370 --> 00:19:14,120
Nou zoals ik al zei, het is vrij
handig om te weten waar iets leeft

363
00:19:14,120 --> 00:19:17,240
dus je kunt er naartoe te gaan en te wijzigen.

364
00:19:17,240 --> 00:19:19,390
Ermee werken en eigenlijk
hebben het ding dat je

365
00:19:19,390 --> 00:19:23,710
willen doen om die variabele take effect,
en geen effect op sommige kopie ervan.

366
00:19:23,710 --> 00:19:26,150
Dit heet dereferentie.

367
00:19:26,150 --> 00:19:28,690
We gaan naar de referentie en
we de waarde te wijzigen daar.

368
00:19:28,690 --> 00:19:32,660
Dus als we een pointer en het heet
pc, en het wijst op een teken,

369
00:19:32,660 --> 00:19:40,610
dan kunnen we zeggen * PC en * pc is de
naam van wat we vinden als we gaan

370
00:19:40,610 --> 00:19:42,910
het adres pc.

371
00:19:42,910 --> 00:19:47,860
Wat zullen we daar vinden is een karakter en
* pc is hoe we verwijzen naar de gegevens op dat

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

373
00:19:48,880 --> 00:19:54,150
Dus konden we iets zeggen
* PC = D of iets dergelijks,

374
00:19:54,150 --> 00:19:59,280
en dat betekent dat wat
was in het geheugen adres pc,

375
00:19:59,280 --> 00:20:07,040
welke aard was eerder
er is nu D, als we zeggen dat * st = D.

376
00:20:07,040 --> 00:20:10,090
>> Dus hier gaan we weer met
wat rare C spullen, rechts.

377
00:20:10,090 --> 00:20:14,560
Dus hebben we eerder gezien * als
ergens deel van het gegevenstype,

378
00:20:14,560 --> 00:20:17,160
en nu is het gebruikt in
een iets andere context

379
00:20:17,160 --> 00:20:19,605
om de gegevens op een locatie.

380
00:20:19,605 --> 00:20:22,480
Ik weet dat het een beetje verwarrend en
dat is eigenlijk een deel van dit hele

381
00:20:22,480 --> 00:20:25,740
zoals, waarom pointers hebben dit mythologie
om hen als zo complex,

382
00:20:25,740 --> 00:20:28,250
is een soort van een syntax probleem, eerlijk gezegd.

383
00:20:28,250 --> 00:20:31,810
Maar * wordt gebruikt in zowel contexten
zowel als onderdeel van het type naam

384
00:20:31,810 --> 00:20:34,100
en we zullen zien wat
later iets anders, ook.

385
00:20:34,100 --> 00:20:36,490
En op dit moment is de
dereference operator.

386
00:20:36,490 --> 00:20:38,760
Zo gaat de verwijzing,
het toegang Gegevens

387
00:20:38,760 --> 00:20:43,000
ter plaatse van de aanwijzer en
stelt u in staat om het te manipuleren naar believen.

388
00:20:43,000 --> 00:20:45,900
>> Nu is deze vergelijkbaar met
het bezoeken van uw buurman, rechts.

389
00:20:45,900 --> 00:20:48,710
Als u weet wat uw
buurman woont, je bent

390
00:20:48,710 --> 00:20:50,730
niet opknoping uit met je buurman.

391
00:20:50,730 --> 00:20:53,510
Je weet dat je toevallig
weten waar ze wonen,

392
00:20:53,510 --> 00:20:56,870
maar dat betekent niet dat door
Krachtens hebben die kennis

393
00:20:56,870 --> 00:20:59,170
je interactie met hen.

394
00:20:59,170 --> 00:21:01,920
Als u wilt communiceren met hen,
je moet naar hun huis,

395
00:21:01,920 --> 00:21:03,760
je moet gaan naar de plaats waar ze wonen.

396
00:21:03,760 --> 00:21:07,440
En zodra je dat doet,
dan kunt u communiceren

397
00:21:07,440 --> 00:21:09,420
met hen net zoals je zou willen.

398
00:21:09,420 --> 00:21:12,730
En ook met variabelen
je nodig hebt om naar hun adres

399
00:21:12,730 --> 00:21:15,320
Als je ze wilt communiceren,
je kunt niet zomaar kennen het adres.

400
00:21:15,320 --> 00:21:21,495
En de manier waarop je naar het adres
te gebruiken *, de dereference operator.

401
00:21:21,495 --> 00:21:23,620
Wat denk je dat er gebeurt
als we proberen en dereferentie

402
00:21:23,620 --> 00:21:25,260
een pointer waarvan de waarde is nul?

403
00:21:25,260 --> 00:21:28,470
Bedenk dat de null
pointer verwijst naar niets.

404
00:21:28,470 --> 00:21:34,110
Dus als je probeert en dereferentie
niets of ga naar een adres niets,

405
00:21:34,110 --> 00:21:36,800
wat denk je dat er gebeurt?

406
00:21:36,800 --> 00:21:39,630
Nou als je raadt segmentatie
fout, zou je gelijk hebben.

407
00:21:39,630 --> 00:21:41,390
Als je probeert en dereferentie
een null pointer,

408
00:21:41,390 --> 00:21:43,140
u last heeft van een segmentatie
fout. Maar wacht,

409
00:21:43,140 --> 00:21:45,820
heb ik niet vertellen, dat
als je niet van plan

410
00:21:45,820 --> 00:21:49,220
uw waarde van uw set
pointer naar iets zinvols,

411
00:21:49,220 --> 00:21:51,000
je moet instellen op nul?

412
00:21:51,000 --> 00:21:55,290
Ik deed en eigenlijk de segmentatie
fout is een soort van een goed gedrag.

413
00:21:55,290 --> 00:21:58,680
>> Heb je ooit uitgeroepen tot een variabele en
de waarde niet onmiddellijk toegekend?

414
00:21:58,680 --> 00:22:02,680
Dus je gewoon int x zeggen; je dat niet doet
het eigenlijk niets toewijzen

415
00:22:02,680 --> 00:22:05,340
en dan later in uw code,
u uitprinten de waarde van x,

416
00:22:05,340 --> 00:22:07,650
die nog steeds niet
toegewezen aan iets.

417
00:22:07,650 --> 00:22:10,370
Vaak krijg je
nul, maar soms moet je

418
00:22:10,370 --> 00:22:15,000
misschien nog wat willekeurig getal, en
je hebt geen idee waar het vandaan kwam.

419
00:22:15,000 --> 00:22:16,750
Op dezelfde manier kunnen dingen
gebeuren met pointers.

420
00:22:16,750 --> 00:22:20,110
Wanneer u verklaren een pointer
int * pk bijvoorbeeld,

421
00:22:20,110 --> 00:22:23,490
en je het niet toewijzen aan een waarde,
je krijgt vier bytes voor het geheugen.

422
00:22:23,490 --> 00:22:25,950
Wat vier bytes
het geheugen van het systeem kan

423
00:22:25,950 --> 00:22:28,970
vinden dat sommige zinvolle waarde hebben.

424
00:22:28,970 --> 00:22:31,760
En er zou zijn geweest
iets wat er al die

425
00:22:31,760 --> 00:22:34,190
niet langer nodig een andere
functie, dus je hoeft alleen

426
00:22:34,190 --> 00:22:35,900
welke gegevens er was.

427
00:22:35,900 --> 00:22:40,570
>> Wat als je probeerde te dereferentie doen
sommige-mailadres dat u don't- er

428
00:22:40,570 --> 00:22:43,410
al bytes en informatie in
er zijn, dat is nu in uw pointer.

429
00:22:43,410 --> 00:22:47,470
Als u probeert en dereferentie dat wijzer,
je zou kunnen knoeien met wat geheugen

430
00:22:47,470 --> 00:22:49,390
dat u niet van plan
te knoeien met het allemaal.

431
00:22:49,390 --> 00:22:51,639
En in feite je zou kunnen doen
iets echt verwoestende,

432
00:22:51,639 --> 00:22:54,880
zoals breken een ander programma,
of breken een andere functie,

433
00:22:54,880 --> 00:22:58,289
of iets kwaadaardige doen
u niet van plan om helemaal te doen.

434
00:22:58,289 --> 00:23:00,080
En dus dat is waarom het
eigenlijk een goed idee

435
00:23:00,080 --> 00:23:04,030
om uw pointers ingesteld op null als u
ze niet ingesteld op iets zinvols.

436
00:23:04,030 --> 00:23:06,760
Het is waarschijnlijk beter in de
eind van de dag van uw programma

437
00:23:06,760 --> 00:23:09,840
te crashen dan voor het te doen
iets dat verknoeit

438
00:23:09,840 --> 00:23:12,400
ander programma of een andere functie.

439
00:23:12,400 --> 00:23:15,207
Dat gedrag is waarschijnlijk zelfs
minder ideaal dan crashen.

440
00:23:15,207 --> 00:23:17,040
En dus dat is waarom het
eigenlijk een goede gewoonte

441
00:23:17,040 --> 00:23:20,920
te krijgen in uw pointers set
null als je ze niet instellen

442
00:23:20,920 --> 00:23:24,540
een zinvolle waarde
onmiddellijk, een waarde die je kent

443
00:23:24,540 --> 00:23:27,260
en dat kunt u veilig de dereference.

444
00:23:27,260 --> 00:23:32,240
>> Dus laten we komen nu terug en neem een ​​kijkje
de algemene syntax van de situatie.

445
00:23:32,240 --> 00:23:37,400
Als ik zeg int * p ;, wat heb ik net gedaan?

446
00:23:37,400 --> 00:23:38,530
Wat ik heb gedaan is dit.

447
00:23:38,530 --> 00:23:43,290
Ik weet dat de waarde van p is een adres
omdat alle aanwijzingen zijn

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

449
00:23:44,660 --> 00:23:47,750
Ik kan dereference p
* met de operator.

450
00:23:47,750 --> 00:23:51,250
In dit verband hier op zijn
top herinneren aan de * is onderdeel van het type.

451
00:23:51,250 --> 00:23:53,510
Int * is het type data.

452
00:23:53,510 --> 00:23:56,150
Maar ik kan dereference
p het gebruik van de * operator,

453
00:23:56,150 --> 00:24:01,897
en als ik dat doe, als ik naar dat adres,
wat zal ik op dat adres?

454
00:24:01,897 --> 00:24:02,855
Ik zal een integer vinden.

455
00:24:02,855 --> 00:24:05,910
Dus int * p fundamenteel
zeggende: p is een adres.

456
00:24:05,910 --> 00:24:09,500
Ik kan dereference p en als
Ik doe, zal ik een integer vinden

457
00:24:09,500 --> 00:24:11,920
op dat het geheugen locatie.

458
00:24:11,920 --> 00:24:14,260
>> OK, dus ik zei dat er was een andere
vervelende met sterren

459
00:24:14,260 --> 00:24:17,060
en hier is waar dat
vervelende met sterren is.

460
00:24:17,060 --> 00:24:21,640
Heb je ooit geprobeerd te verklaren
meerdere variabelen van hetzelfde type

461
00:24:21,640 --> 00:24:24,409
op dezelfde lijn van code?

462
00:24:24,409 --> 00:24:27,700
Dus voor een tweede, beweren dat de lijn,
de code die ik heb er eigenlijk in het groen

463
00:24:27,700 --> 00:24:29,366
is er niet en zegt het enkel int x, y, z ;.

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

465
00:24:31,634 --> 00:24:34,550
Wat dat zou doen is eigenlijk te creëren
drie integer variabelen voor u,

466
00:24:34,550 --> 00:24:36,930
een zogenaamde x, een zogenaamde
y, en een zogenaamde z.

467
00:24:36,930 --> 00:24:41,510
Het is een manier om het te doen zonder
hoeven te splitsen op drie lijnen.

468
00:24:41,510 --> 00:24:43,890
>> Hier is waar sterren krijgen
vervelend weer wel,

469
00:24:43,890 --> 00:24:49,200
omdat de * is eigenlijk een deel
van zowel de naam en een deel het type

470
00:24:49,200 --> 00:24:50,320
van de variabele naam.

471
00:24:50,320 --> 00:24:56,430
En dus als ik zeg int * px, py, pz, wat ik
eigenlijk is een pointer naar een integer

472
00:24:56,430 --> 00:25:01,650
riep px en twee getallen, py en pz.

473
00:25:01,650 --> 00:25:04,950
En dat is waarschijnlijk niet wat
we willen, dat is niet goed.

474
00:25:04,950 --> 00:25:09,290
>> Dus als ik wil meerdere pointers maken
op dezelfde lijn, van hetzelfde type,

475
00:25:09,290 --> 00:25:12,140
en sterren, wat ik eigenlijk nodig
te doen is zeggen int * pa, pb *, * pc.

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

477
00:25:17,330 --> 00:25:20,300
Nu alleen dat gezegd hebbende
en nu vertel je dit,

478
00:25:20,300 --> 00:25:22,170
zal je waarschijnlijk nooit doen.

479
00:25:22,170 --> 00:25:25,170
En het is waarschijnlijk een goede zaak eerlijk,
omdat je misschien per ongeluk

480
00:25:25,170 --> 00:25:26,544
weglaten een ster, zoiets.

481
00:25:26,544 --> 00:25:29,290
Het is waarschijnlijk het beste om misschien te verklaren
tips over individuele lijnen,

482
00:25:29,290 --> 00:25:31,373
maar het is gewoon een ander
van die vervelende syntaxis

483
00:25:31,373 --> 00:25:35,310
dingen met sterren die te maken
pointers zo moeilijk om mee te werken.

484
00:25:35,310 --> 00:25:39,480
Want het is gewoon dit syntactische
puinhoop je doorheen moet werken.

485
00:25:39,480 --> 00:25:41,600
Met de praktijk doet
echt een tweede natuur geworden.

486
00:25:41,600 --> 00:25:45,410
Ik fouten maken nog steeds met het nog steeds
Na programmering voor 10 jaar,

487
00:25:45,410 --> 00:25:49,630
dus wees niet boos worden als er iets gebeurt
aan u, het is vrij normaal eerlijk.

488
00:25:49,630 --> 00:25:52,850
Het is echt een soort van
een fout van de syntaxis.

489
00:25:52,850 --> 00:25:54,900
>> OK dus ik soort beloofd
dat we zouden terugkomen

490
00:25:54,900 --> 00:25:59,370
het begrip van hoe groot een tekenreeks.

491
00:25:59,370 --> 00:26:02,750
Nou als ik je vertelde dat er een
touwtje, hebben we echt een soort van

492
00:26:02,750 --> 00:26:04,140
gelogen om u de hele tijd.

493
00:26:04,140 --> 00:26:06,181
Er is geen datatype genoemd
snaar, en in feite I

494
00:26:06,181 --> 00:26:09,730
vertelde dit in een van onze
vroegste video's op data types,

495
00:26:09,730 --> 00:26:13,820
dat koord een gegevenstype dat
is gemaakt voor u in CS50.h.

496
00:26:13,820 --> 00:26:17,050
Je moet #include
CS50.h om het te gebruiken.

497
00:26:17,050 --> 00:26:19,250
>> Nou reeks is eigenlijk gewoon
een alias iets

498
00:26:19,250 --> 00:26:23,600
genaamd de char *, een
pointer naar een karakter.

499
00:26:23,600 --> 00:26:26,010
Nou pointers, recall,
zijn slechts adressen.

500
00:26:26,010 --> 00:26:28,780
Dus wat is de grootte
in bytes van een string?

501
00:26:28,780 --> 00:26:29,796
Nou het is vier of acht.

502
00:26:29,796 --> 00:26:32,170
En de reden dat ik zeg vier of
acht omdat het eigenlijk

503
00:26:32,170 --> 00:26:36,730
afhankelijk van het systeem, Als u
CS50 ide, char * is de grootte van een char

504
00:26:36,730 --> 00:26:39,340
* Acht, het is een 64-bits systeem.

505
00:26:39,340 --> 00:26:43,850
Elk adres in het geheugen is 64 bits lang.

506
00:26:43,850 --> 00:26:48,270
Als u gebruik CS50 apparaat
of het gebruik van een 32-bit machine,

507
00:26:48,270 --> 00:26:51,640
en je hebt die term 32-bit gehoord
machine, wat is een 32-bit machine?

508
00:26:51,640 --> 00:26:56,090
Nou, het betekent alleen dat elke
adres in het geheugen is 32 bits lang.

509
00:26:56,090 --> 00:26:59,140
En dus 32 bits is vier bytes.

510
00:26:59,140 --> 00:27:02,710
Dus een char * is vier of acht
bytes afhankelijk van uw systeem.

511
00:27:02,710 --> 00:27:06,100
En inderdaad alle data types,
en een pointer naar gegevens

512
00:27:06,100 --> 00:27:12,030
typt, omdat alle aanwijzingen zijn
adressen, vier of acht bytes.

513
00:27:12,030 --> 00:27:14,030
Dus laten we dit opnieuw
diagram en laten we concluderen

514
00:27:14,030 --> 00:27:18,130
deze video met een kleine oefening hier.

515
00:27:18,130 --> 00:27:21,600
Dus hier is het schema we gebleven met
aan het begin van de video.

516
00:27:21,600 --> 00:27:23,110
Dus wat gebeurt er nu als ik zeg * pk = 35?

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

518
00:27:26,370 --> 00:27:30,530
Dus wat betekent het als ik zeg, * pk = 35?

519
00:27:30,530 --> 00:27:32,420
Neem een ​​tweede.

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

521
00:27:34,990 --> 00:27:39,890
In verband hier, * is
dereference operator.

522
00:27:39,890 --> 00:27:42,110
Dus toen de dereference
operator wordt gebruikt,

523
00:27:42,110 --> 00:27:48,520
we gaan naar het adres wees op
door pk, en we veranderen wat we vinden.

524
00:27:48,520 --> 00:27:55,270
Dus * pk = 35 effectief
doet dit om de afbeelding.

525
00:27:55,270 --> 00:27:58,110
Dus het is eigenlijk syntactisch
identiek is aan die van de genoemde k = 35.

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

527
00:28:00,740 --> 00:28:01,930
>> Nog een.

528
00:28:01,930 --> 00:28:05,510
Als ik zeg int m, ik maak
een nieuwe variabele genaamd m.

529
00:28:05,510 --> 00:28:08,260
Een nieuwe doos, het is een groene doos, omdat
het gaat om een ​​geheel getal te houden,

530
00:28:08,260 --> 00:28:09,840
en het is gelabeld m.

531
00:28:09,840 --> 00:28:14,960
Als ik zeg m = 4, heb ik een
integer in die box.

532
00:28:14,960 --> 00:28:20,290
Als we zeggen pk = & m, hoe werkt
dit diagram verandering?

533
00:28:20,290 --> 00:28:28,760
Pk = & m, heb je herinneren aan wat de
& Operator doet of wordt genoemd?

534
00:28:28,760 --> 00:28:34,430
Vergeet niet dat en een aantal variabele naam
is het adres van een variabele naam.

535
00:28:34,430 --> 00:28:38,740
Dus wat we zeggen is
pk krijgt het adres van m.

536
00:28:38,740 --> 00:28:42,010
En zo effectief wat er gebeurt de
diagram is dat niet meer punten pk

537
00:28:42,010 --> 00:28:46,420
k, maar wijst op m.

538
00:28:46,420 --> 00:28:48,470
>> Weer pointers zijn zeer
lastig om mee te werken

539
00:28:48,470 --> 00:28:50,620
en ze nemen veel
praktijk, maar omdat

540
00:28:50,620 --> 00:28:54,150
van hun vermogen om u te laten
om gegevens tussen functies passeren

541
00:28:54,150 --> 00:28:56,945
en eigenlijk degenen
wijzigingen van kracht,

542
00:28:56,945 --> 00:28:58,820
krijgen van uw hoofd rond
is echt belangrijk.

543
00:28:58,820 --> 00:29:02,590
Het is waarschijnlijk de meest ingewikkelde
onderwerp bespreken we in CS50,

544
00:29:02,590 --> 00:29:05,910
maar de waarde die u
krijgen van het gebruik pointers

545
00:29:05,910 --> 00:29:09,200
veel zwaarder weegt dan de complicaties
die afkomstig zijn van het leren van hen.

546
00:29:09,200 --> 00:29:12,690
Dus ik wens u het beste van
geluk leren over pointers.

547
00:29:12,690 --> 00:29:15,760
Ik ben Doug Lloyd, dit is CS50.

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