1
00:00:00,000 --> 00:00:03,388
>> [Muziek]

2
00:00:03,388 --> 00:00:05,104

3
00:00:05,104 --> 00:00:06,020
DOUG LLOYD: Oké.

4
00:00:06,020 --> 00:00:07,680
Werken met enkele
variabelen is best leuk.

5
00:00:07,680 --> 00:00:09,500
Maar wat als we willen werken
met veel variabelen,

6
00:00:09,500 --> 00:00:12,760
maar we willen niet een stelletje hebben
verschillende namen vliegen rond onze code?

7
00:00:12,760 --> 00:00:15,980
In dit geval zijn arrays
gaan om binnen te komen echt handig.

8
00:00:15,980 --> 00:00:19,510
Arrays zijn een echt fundamentele data
structuur voor elke programmeertaal

9
00:00:19,510 --> 00:00:20,260
die u wilt gebruiken.

10
00:00:20,260 --> 00:00:24,450
En ze zijn echt, echt nuttig,
in het bijzonder, zoals we zullen zien, in CS 50.

11
00:00:24,450 --> 00:00:27,870
>> We maken gebruik van arrays te houden
waarden van hetzelfde gegevenstype

12
00:00:27,870 --> 00:00:29,830
in aaneengesloten geheugenlocaties.

13
00:00:29,830 --> 00:00:32,430
Dat wil zeggen, het is een
manier dat we kunnen groeperen

14
00:00:32,430 --> 00:00:35,430
een bos van gehele getallen samen in
geheugen of een stel tekens

15
00:00:35,430 --> 00:00:38,270
of drijft in het geheugen echt
dicht bij elkaar en werken

16
00:00:38,270 --> 00:00:41,930
mee zonder elkaar te
een eigen unieke naam, die kan

17
00:00:41,930 --> 00:00:44,500
krijgt lastig na een tijdje.

18
00:00:44,500 --> 00:00:48,130
>> Nu, een manier om arrays analogize
is na te denken over uw lokale post

19
00:00:48,130 --> 00:00:49,000
kantoor voor een tweede.

20
00:00:49,000 --> 00:00:51,820
Dus stap uit de buurt van de programmering
en gewoon je ogen dicht

21
00:00:51,820 --> 00:00:54,120
en visualiseren in je geest
uw plaatselijke postkantoor.

22
00:00:54,120 --> 00:00:57,160
Meestal, in de meeste bericht
kantoren, er is een grote bank

23
00:00:57,160 --> 00:01:00,490
een postkantoor dozen op de muur.

24
00:01:00,490 --> 00:01:03,510
>> Een array is een gigantische blok
aaneengesloten geheugen,

25
00:01:03,510 --> 00:01:06,120
op dezelfde manier dat een e-
bank in uw postkantoor

26
00:01:06,120 --> 00:01:11,230
is een grote ruimte op de
wand van het postkantoor.

27
00:01:11,230 --> 00:01:15,750
Arrays zijn verdeeld in kleine,
identiek gerangschikte blokken van de ruimte,

28
00:01:15,750 --> 00:01:19,930
die elk genoemd element, in
Net zoals de wand van de paal

29
00:01:19,930 --> 00:01:23,840
office is verdeeld in kleine,
identiek gerangschikte blokken van de ruimte,

30
00:01:23,840 --> 00:01:27,560
die noemen we een postbus.

31
00:01:27,560 --> 00:01:31,650
Elk element van de array
slaan een aantal gegevens,

32
00:01:31,650 --> 00:01:37,540
net zoals elke postbus staat
een zekere post houden.

33
00:01:37,540 --> 00:01:41,540
>> Wat kan worden opgeslagen in elk element van
de array variabelen dezelfde gegevens

34
00:01:41,540 --> 00:01:45,300
type, zoals int of char, gewoon
zoals in uw postbus,

35
00:01:45,300 --> 00:01:47,300
je kunt alleen fit dingen
van een soortgelijk type,

36
00:01:47,300 --> 00:01:50,430
zoals brieven en kleine pakketten.

37
00:01:50,430 --> 00:01:55,050
Tenslotte kunnen we toegang elk element van
de array direct per index nummer,

38
00:01:55,050 --> 00:01:59,770
net zoals we kunnen toegang tot onze postkantoor
vak door te weten het postbusnummer.

39
00:01:59,770 --> 00:02:02,750
Hopelijk die analogie
helpt je je hoofd te krijgen

40
00:02:02,750 --> 00:02:05,540
rond het idee van arrays door
analogizing naar iets anders

41
00:02:05,540 --> 00:02:08,400
dat je waarschijnlijk
al vertrouwd met.

42
00:02:08,400 --> 00:02:13,182
>> In C, de elementen van een array
geïndexeerd vanaf 0, niet 1.

43
00:02:13,182 --> 00:02:14,390
En dit is echt belangrijk.

44
00:02:14,390 --> 00:02:18,530
En in feite is dit de reden waarom we, in CS 50,
en waarom informatici vaak

45
00:02:18,530 --> 00:02:22,150
zal tellen van 0, is
door de matrix C

46
00:02:22,150 --> 00:02:24,660
indexering, die altijd begint bij 0.

47
00:02:24,660 --> 00:02:28,730
Als een matrix bestaat uit n elementen,
het eerste element van die array

48
00:02:28,730 --> 00:02:32,960
zich op index 0, en
het laatste element van de array

49
00:02:32,960 --> 00:02:36,610
zich op index n 1 min.

50
00:02:36,610 --> 00:02:43,160
Opnieuw, als er n elementen in onze
matrix, de laatste index n minus 1.

51
00:02:43,160 --> 00:02:46,820
>> Als onze array elementen 50, de
eerste element zich op index 0,

52
00:02:46,820 --> 00:02:51,060
en het laatste element
zich op index 49.

53
00:02:51,060 --> 00:02:53,940
Helaas, of gelukkig,
afhankelijk van uw perspectief,

54
00:02:53,940 --> 00:02:56,170
C is hier erg soepel.

55
00:02:56,170 --> 00:02:59,480
Het zal u niet verhinderen
uit te gaan van de grenzen van de array.

56
00:02:59,480 --> 00:03:03,080
Je zou kunnen openen de min
3 element van de array

57
00:03:03,080 --> 00:03:07,400
of de 59ste element van de array,
Als uw array slechts 50 elementen.

58
00:03:07,400 --> 00:03:11,060
Het zal je programma niet stoppen
compileren, maar tijdens runtime,

59
00:03:11,060 --> 00:03:14,350
u kunt tegenkomen een
gevreesde segmentation fault

60
00:03:14,350 --> 00:03:17,460
als je begint om toegang tot het geheugen
die buiten de grenzen van het

61
00:03:17,460 --> 00:03:19,260
vroeg je je programma om u te geven.

62
00:03:19,260 --> 00:03:21,250
Dus wees voorzichtig.

63
00:03:21,250 --> 00:03:23,120
>> Wat doet een array
verklaring eruit?

64
00:03:23,120 --> 00:03:26,940
Hoe kunnen we de code een array in bestaan
zoals wij coderen elke andere variabele?

65
00:03:26,940 --> 00:03:31,250
Er zijn drie delen van een array
declaration-- een type, een naam,

66
00:03:31,250 --> 00:03:31,880
en een grootte.

67
00:03:31,880 --> 00:03:34,088
Dit is vergelijkbaar met een
variabele verklaring, die

68
00:03:34,088 --> 00:03:36,970
is slechts een type en een naam,
de grootte element

69
00:03:36,970 --> 00:03:39,860
het speciale geval van een array,
want we krijgen een bos van hen

70
00:03:39,860 --> 00:03:41,830
op hetzelfde moment.

71
00:03:41,830 --> 00:03:45,560
>> Dus het type is wat voor soort variabele die u
wil elk element van de matrix zijn.

72
00:03:45,560 --> 00:03:47,150
Wil dat het een array van gehele getallen?

73
00:03:47,150 --> 00:03:49,010
Daarna moet uw gegevens type int zijn.

74
00:03:49,010 --> 00:03:51,760
Wilt u er een te zijn
reeks van dubbels of praalwagens?

75
00:03:51,760 --> 00:03:54,545
Soort gegevens moeten dubbel zijn of zweven.

76
00:03:54,545 --> 00:03:56,420
De naam is wat je
wilt u uw serie noemen.

77
00:03:56,420 --> 00:04:00,970
Wat wil je met deze reusachtige naam
bank van gehele getallen of vlotters of chars

78
00:04:00,970 --> 00:04:03,250
of dubbelspel, of wat je hebt?

79
00:04:03,250 --> 00:04:04,700
Wat wil je ook wilt noemen?

80
00:04:04,700 --> 00:04:06,110
Vrij duidelijk.

81
00:04:06,110 --> 00:04:08,610
>> Tenslotte grootte, die gaat
binnenkant van vierkante haken,

82
00:04:08,610 --> 00:04:12,180
is hoeveel elementen je zou
als je array bevatten.

83
00:04:12,180 --> 00:04:13,530
Hoeveel gehele getallen wil je?

84
00:04:13,530 --> 00:04:15,570
Hoeveel wagens wil je?

85
00:04:15,570 --> 00:04:19,070
>> Dus bijvoorbeeld, int student rangen 40.

86
00:04:19,070 --> 00:04:26,020
Dit verklaart een array genaamd Student
rangen, die bestaat uit 40 getallen.

87
00:04:26,020 --> 00:04:28,180
Mooie duidelijk, hoop ik.

88
00:04:28,180 --> 00:04:29,330
Hier is een ander voorbeeld.

89
00:04:29,330 --> 00:04:31,560
Dubbele menuprijzen 8.

90
00:04:31,560 --> 00:04:34,610
Dit creëert een array met de naam
Menuprijzen, dat bestaat uit

91
00:04:34,610 --> 00:04:38,300
ruimte in het geheugen voor acht tweepersoonskamers.

92
00:04:38,300 --> 00:04:42,000

93
00:04:42,000 --> 00:04:45,750
>> Als u denkt dat van elk element
van een array van het type data-type,

94
00:04:45,750 --> 00:04:49,860
dus bijvoorbeeld een enkel element van
een array van het type int, op dezelfde manier

95
00:04:49,860 --> 00:04:52,770
zou denken van een ander
variabele van het type int,

96
00:04:52,770 --> 00:04:56,440
alle bekende bewerkingen die we
eerder besproken in de Operations

97
00:04:56,440 --> 00:04:58,270
video zal zinvol.

98
00:04:58,270 --> 00:05:01,620
Dus hier kunnen we een array te verklaren
van Booleans genaamd Truthtable,

99
00:05:01,620 --> 00:05:05,590
die bestaat uit ruimte voor 10 Booleans.

100
00:05:05,590 --> 00:05:09,650
>> En dan, net als we konden alleen maar te wijzen
een waarde aan andere variabele van het type

101
00:05:09,650 --> 00:05:13,470
Boolean, kunnen we iets zeggen
zoals Truthtable vierkant haakje

102
00:05:13,470 --> 00:05:18,040
2, dat is hoe we aangeven
welk element van de waarheid tafel?

103
00:05:18,040 --> 00:05:20,350
Het derde element van het
waarheid tafel, want vergeet niet,

104
00:05:20,350 --> 00:05:21,800
we tellen vanaf 0.

105
00:05:21,800 --> 00:05:25,690
Dus dat is hoe we geven de
derde element van de waarheid tafel.

106
00:05:25,690 --> 00:05:28,680
Truthtable 2 is gelijk aan vals,
net alsof we konden declare--

107
00:05:28,680 --> 00:05:33,560
of we zouden kunnen wijzen veeleer eventuele
Boolean variabel te zijn vals.

108
00:05:33,560 --> 00:05:35,050
>> We kunnen het ook gebruiken bij aandoeningen.

109
00:05:35,050 --> 00:05:39,000
if (truthtable 7 ==
true), dat wil zeggen,

110
00:05:39,000 --> 00:05:42,370
Als het achtste element
van Truthtable is waar,

111
00:05:42,370 --> 00:05:46,760
Misschien willen we een boodschap af te drukken
aan de gebruiker, printf ("WAAR! n") ;.

112
00:05:46,760 --> 00:05:50,290
Dat doet ons Truthtable zeggen
10 gelijk waar, toch?

113
00:05:50,290 --> 00:05:53,590
Nou, dat kan ik, maar het is vrij
gevaarlijk, want vergeet niet,

114
00:05:53,590 --> 00:05:56,260
hebben we een reeks van 10 Booleans.

115
00:05:56,260 --> 00:06:02,340
Dus de hoogste index die de
compiler heeft ons is 9.

116
00:06:02,340 --> 00:06:06,010
>> Dit programma zal compileren, maar
als er iets anders in het geheugen

117
00:06:06,010 --> 00:06:09,110
bestaat waar we zouden
verwachten Truthtable 10 te gaan,

118
00:06:09,110 --> 00:06:13,980
we een segmentatie fout zou kunnen lijden. We
misschien wegkomen met het, maar in het algemeen,

119
00:06:13,980 --> 00:06:14,710
behoorlijk gevaarlijk.

120
00:06:14,710 --> 00:06:19,759
Dus wat ik hier doe is legaal C,
maar niet noodzakelijkerwijs de beste zet.

121
00:06:19,759 --> 00:06:22,300
Nu, als je te verklaren en
initialiseren een array gelijktijdig,

122
00:06:22,300 --> 00:06:23,960
er is eigenlijk een vrij
speciale syntax die u

123
00:06:23,960 --> 00:06:26,250
kan gebruiken om vullen de array
met beginwaarden.

124
00:06:26,250 --> 00:06:30,130
Het kan omslachtig om
verklaren een array van grootte 100,

125
00:06:30,130 --> 00:06:33,430
en dan zeggen, element 0
gelijk aan dit; element 1 is gelijk aan dit;

126
00:06:33,430 --> 00:06:34,850
element 2 is gelijk aan dat.

127
00:06:34,850 --> 00:06:36,370
Wat is het punt, toch?

128
00:06:36,370 --> 00:06:39,470
>> Als het een kleine array, u
zou zoiets doen.

129
00:06:39,470 --> 00:06:44,360
Bool truthtable 3 evenaart geopend
accolade en dan komma

130
00:06:44,360 --> 00:06:48,060
scheiden de lijst van de elementen
die u in de array te zetten.

131
00:06:48,060 --> 00:06:50,520
Sluit accolade puntkomma.

132
00:06:50,520 --> 00:06:53,910
Dit creëert een scala aan
grootte drie zogenaamde Truthtable,

133
00:06:53,910 --> 00:06:56,090
met elementen vals, waar, en waar.

134
00:06:56,090 --> 00:06:59,270
En inderdaad, het starten
syntax Ik heb hier

135
00:06:59,270 --> 00:07:03,350
precies hetzelfde als doen
individueel element syntax hieronder.

136
00:07:03,350 --> 00:07:09,380
Deze twee manieren codering zou
produceren exact dezelfde array.

137
00:07:09,380 --> 00:07:11,740
>> Ook konden we herhalen
over alle elementen

138
00:07:11,740 --> 00:07:15,400
van een array via een lus, die in
Sterker nog, is een zeer sterk aanbevolen

139
00:07:15,400 --> 00:07:16,790
thuis te oefenen.

140
00:07:16,790 --> 00:07:20,720
Hoe maak je een array
van 100 integers, waarbij

141
00:07:20,720 --> 00:07:23,477
elk element van de array zijn index?

142
00:07:23,477 --> 00:07:26,560
Dus bijvoorbeeld, hebben we een reeks van 100
integers, en in het eerste element,

143
00:07:26,560 --> 00:07:27,790
we willen zetten 0.

144
00:07:27,790 --> 00:07:29,810
In het tweede element, willen we zetten 1.

145
00:07:29,810 --> 00:07:33,319
In het derde element, we willen
2 te dienen; enzovoort, enzovoort.

146
00:07:33,319 --> 00:07:35,360
Dat is een heel goed
at-home oefening om dat te doen.

147
00:07:35,360 --> 00:07:38,190

148
00:07:38,190 --> 00:07:40,220
>> Hier, ziet het er niet
als te veel veranderd.

149
00:07:40,220 --> 00:07:44,170
Maar merken dat tussen de
vierkante haken, ditmaal,

150
00:07:44,170 --> 00:07:45,830
Ik heb eigenlijk weggelaten het nummer.

151
00:07:45,830 --> 00:07:48,000
Als je met behulp van deze zeer
speciale instantiatie

152
00:07:48,000 --> 00:07:50,380
syntax om een ​​te creëren
array, je eigenlijk niet

153
00:07:50,380 --> 00:07:53,491
moet de grootte duiden
van de matrix vooraf.

154
00:07:53,491 --> 00:07:55,740
De compiler is slim genoeg
om daadwerkelijk te weten dat u

155
00:07:55,740 --> 00:07:58,980
wil een array van grootte 3,
omdat je drie elementen

156
00:07:58,980 --> 00:08:00,640
rechts van het gelijkteken.

157
00:08:00,640 --> 00:08:04,140
Als je vier had gezet, zou het
krijgt u een waarheid tabel van grootte vier;

158
00:08:04,140 --> 00:08:06,270
enzovoort, enzovoort.

159
00:08:06,270 --> 00:08:09,380
>> Arrays zijn niet beperkt tot één
dimensie, die is vrij cool.

160
00:08:09,380 --> 00:08:12,000
Je kunt eigenlijk zo veel
side voorschrijvers als u wilt.

161
00:08:12,000 --> 00:08:16,470
Dus bijvoorbeeld, als je wilt maken
een bord voor het spel Battleship, waarin,

162
00:08:16,470 --> 00:08:20,910
Als je ooit gespeeld, is een spel dat is
gespeeld met pinnen op de 10 bij 10 rooster,

163
00:08:20,910 --> 00:08:22,450
kon je een array als deze te maken.

164
00:08:22,450 --> 00:08:26,030
Je zou kunnen zeggen Bool
slagschip vierkante beugel 10

165
00:08:26,030 --> 00:08:29,590
gesloten vierkant vierkant haakje
beugel 10 gesloten square bracket.

166
00:08:29,590 --> 00:08:32,710
>> En dan kun je ervoor kiezen om
interpreteren dit in je geest als een 10

167
00:08:32,710 --> 00:08:35,576
van 10 raster van cellen.

168
00:08:35,576 --> 00:08:37,409
Nu, in feite, in geheugen,
het doet echt gewoon

169
00:08:37,409 --> 00:08:42,440
blijft een element 100,
eendimensionale matrix.

170
00:08:42,440 --> 00:08:46,070
En dit in feite geldt voor als je
hebben drie dimensies of vier of vijf.

171
00:08:46,070 --> 00:08:49,420
Het is echt gewoon niet vermenigvuldigen
alle indices--

172
00:08:49,420 --> 00:08:51,130
of alle afmetingen
specifiers-- samen,

173
00:08:51,130 --> 00:08:53,480
en krijg je alleen maar een eendimensionale
matrix van die grootte.

174
00:08:53,480 --> 00:08:57,090
>> Maar in termen van organisatie en
visualisatie en de menselijke waarneming,

175
00:08:57,090 --> 00:08:59,240
het kan een stuk makkelijker
werken met een rooster

176
00:08:59,240 --> 00:09:02,980
als je werkt aan een spel
zoals Boter-kaas-en-eieren of Battleship,

177
00:09:02,980 --> 00:09:05,179
of zoiets.

178
00:09:05,179 --> 00:09:06,970
Het is een grote abstractie,
in plaats van

179
00:09:06,970 --> 00:09:09,340
na te denken over een Boter-kaas-en-eieren
board als een lijn van negen

180
00:09:09,340 --> 00:09:13,810
vierkanten of een Battleship board
als een lijn van 100 pleinen.

181
00:09:13,810 --> 00:09:16,010
Een 10 bij 10 rooster of een drie-
door drie raster is waarschijnlijk

182
00:09:16,010 --> 00:09:17,225
veel gemakkelijker te zien.

183
00:09:17,225 --> 00:09:19,820

184
00:09:19,820 --> 00:09:22,280
>> Nu, iets echt
belangrijks over arrays.

185
00:09:22,280 --> 00:09:25,950
We kunnen elke individuele behandeling
element van de array variabele.

186
00:09:25,950 --> 00:09:27,700
We zagen dat eerder
toen we het toewijzen

187
00:09:27,700 --> 00:09:32,240
de waarde True bepaalde Booleans
of te testen in conditionals.

188
00:09:32,240 --> 00:09:35,960
Maar we kunnen volledige niet behandelen
arrays zelf als variabelen.

189
00:09:35,960 --> 00:09:41,760
We kunnen bijvoorbeeld wijzen ene array
een andere matrix met de opdracht

190
00:09:41,760 --> 00:09:42,930
operator.

191
00:09:42,930 --> 00:09:44,640
Het is niet legaal C.

192
00:09:44,640 --> 00:09:47,920
>> Als we willen, voor wat example--
we zouden moeten doen in dat voorbeeld

193
00:09:47,920 --> 00:09:50,200
zou een matrix kopiëren naar een andere.

194
00:09:50,200 --> 00:09:53,810
Als we dat willen, we eigenlijk doen
zou een lus over te kopiëren

195
00:09:53,810 --> 00:09:56,550
elk element één tegelijk.

196
00:09:56,550 --> 00:09:58,700
Ik weet dat het een beetje tijd in beslag.

197
00:09:58,700 --> 00:10:04,022
>> Dus bijvoorbeeld, als we deze paar
regels code, zou dit werk?

198
00:10:04,022 --> 00:10:05,230
Nou, nee, zou het niet, toch?

199
00:10:05,230 --> 00:10:07,860
Omdat we proberen
om voedsel toe te wijzen aan de bar.

200
00:10:07,860 --> 00:10:09,860
Dat gaat niet werken,
omdat het een array,

201
00:10:09,860 --> 00:10:13,130
en we zojuist beschreven
dat is niet legaal C.

202
00:10:13,130 --> 00:10:15,580
>> In plaats daarvan, als we willen
kopieert u de inhoud van het voedsel

203
00:10:15,580 --> 00:10:18,070
in de bar, die is wat
we proberen te doen hier,

204
00:10:18,070 --> 00:10:19,970
we zouden een syntax als dit nodig hebben.

205
00:10:19,970 --> 00:10:24,170
We hebben een lus die gaat
van J is gelijk aan 0 tot 5,

206
00:10:24,170 --> 00:10:28,390
en verhogen we J op elke iteratie van
de lus en toewijzen elementen als dat.

207
00:10:28,390 --> 00:10:33,360
Dit zou resulteren in de bar ook
waarbij één, twee, drie, vier, vijf,

208
00:10:33,360 --> 00:10:36,730
maar we moeten het op deze zeer doen
slow element-voor-element weg,

209
00:10:36,730 --> 00:10:40,009
in plaats van gewoon
kopiëren van de gehele array.

210
00:10:40,009 --> 00:10:42,050
In andere programmeertalen
talen, meer moderne degenen,

211
00:10:42,050 --> 00:10:45,610
kunt u, in feite, gewoon doen
Zo simpel is gelijk aan de syntaxis.

212
00:10:45,610 --> 00:10:49,620
Maar C, helaas, we zijn
niet toegestaan ​​om dat te doen.

213
00:10:49,620 --> 00:10:52,026
>> Nu, er is een andere
wat ik wil noemen

214
00:10:52,026 --> 00:10:54,650
over arrays die een beetje kan zijn
beetje lastig de eerste keer dat u

215
00:10:54,650 --> 00:10:55,990
werken met hen.

216
00:10:55,990 --> 00:10:59,860
We bespraken in een video
over variabele reikwijdte,

217
00:10:59,860 --> 00:11:04,940
dat de meeste variabelen in C, wanneer u belt
ze in functies, worden doorgegeven door de waarde.

218
00:11:04,940 --> 00:11:08,620
Weet je nog wat het betekent
om iets van waarde passeren?

219
00:11:08,620 --> 00:11:12,570
Het betekent dat we het maken van een kopie van de
variabele dat wordt doorgegeven.

220
00:11:12,570 --> 00:11:16,290
De callee functie, de functie
dat is het ontvangen van de variabele,

221
00:11:16,290 --> 00:11:17,730
niet de variabele zelf te krijgen.

222
00:11:17,730 --> 00:11:20,850
Het krijgt zijn eigen lokale
kopie ervan mee te werken.

223
00:11:20,850 --> 00:11:24,070
>> Arrays, natuurlijk doen
niet aan deze regel.

224
00:11:24,070 --> 00:11:27,600
Integendeel, wat wij noemen dit
is het passeren door middel van verwijzing.

225
00:11:27,600 --> 00:11:31,360
De callee eigenlijk
ontvangt de array.

226
00:11:31,360 --> 00:11:34,207
Het maakt niet ontvangen zijn
eigen lokale kopie van het.

227
00:11:34,207 --> 00:11:36,040
En als je erover nadenkt
het, dit is logisch.

228
00:11:36,040 --> 00:11:39,750
Als arrays zijn erg groot, het
kost zoveel tijd en moeite

229
00:11:39,750 --> 00:11:44,470
om een ​​kopie van een serie van te maken
100 of 1000 of 10.000 elementen,

230
00:11:44,470 --> 00:11:48,290
dat het niet de moeite waard voor een
functie om een ​​kopie ontvangen van het,

231
00:11:48,290 --> 00:11:51,037
wat werk te doen, en dan
alleen worden gedaan met copy;

232
00:11:51,037 --> 00:11:53,120
het niet nodig te hebben
Het opknoping rond meer.

233
00:11:53,120 --> 00:11:54,710
>> Omdat sommige arrays
omvangrijk en omslachtig,

234
00:11:54,710 --> 00:11:56,001
we ze gewoon passeren door middel van verwijzing.

235
00:11:56,001 --> 00:12:01,210
We vertrouwen erop dat de functie
om, niets breken.

236
00:12:01,210 --> 00:12:03,010
Het maakt dus eigenlijk de array.

237
00:12:03,010 --> 00:12:05,290
Het heeft geen eigen lokale kopie van krijgen.

238
00:12:05,290 --> 00:12:07,170
>> Dus wat betekent dit,
Vervolgens, toen de callee

239
00:12:07,170 --> 00:12:08,970
manipuleert elementen van de serie?

240
00:12:08,970 --> 00:12:10,780
Wat gebeurt?

241
00:12:10,780 --> 00:12:13,210
Voor nu, zullen we glans
dan waarom juist dit

242
00:12:13,210 --> 00:12:15,320
gebeurt, waarom arrays
worden doorgegeven door middel van verwijzing

243
00:12:15,320 --> 00:12:17,810
en al het andere wordt doorgegeven door de waarde.

244
00:12:17,810 --> 00:12:20,470
Maar ik beloof je, zullen we
terug en geven u het antwoord

245
00:12:20,470 --> 00:12:23,750
om deze in een later video.

246
00:12:23,750 --> 00:12:28,110
>> Hier is nog een oefening voor u
voordat we wrap up dingen op arrays.

247
00:12:28,110 --> 00:12:31,400
Het bos van de code hier, dat is
niet bijzonder goede stijl,

248
00:12:31,400 --> 00:12:33,400
alleen ik die waarschuwing te maken.

249
00:12:33,400 --> 00:12:36,660
Er is geen commentaar hier,
dat is vrij slechte vorm.

250
00:12:36,660 --> 00:12:39,750
Maar dat is alleen omdat ik wilde zijn
in staat om alles op het scherm past.

251
00:12:39,750 --> 00:12:44,360
>> Op de top, kun je zien dat ik heb
twee functie verklaringen voor set-array

252
00:12:44,360 --> 00:12:45,820
en stel int.

253
00:12:45,820 --> 00:12:49,680
Set-array neemt blijkbaar een array
vier integers als invoer.

254
00:12:49,680 --> 00:12:52,767
En set int neemt blijkbaar
een integer als invoer.

255
00:12:52,767 --> 00:12:54,350
Maar beiden hebben geen uitgang.

256
00:12:54,350 --> 00:12:57,689
De uitvoer, de terugkeer
typen, van een ieder is nietig.

257
00:12:57,689 --> 00:12:59,480
In Main, hebben we een
paar regels code.

258
00:12:59,480 --> 00:13:02,730
Wij verklaren een integer variabele
genaamd A en wijs de waarde 10.

259
00:13:02,730 --> 00:13:07,080
Wij verklaren een array van vier getallen
B genoemd en de elementen 0, 1 toewijzen

260
00:13:07,080 --> 00:13:08,730
2 en 3 resp.

261
00:13:08,730 --> 00:13:12,190
Dan hebben we een oproep om
int en een oproep tot scala stellen.

262
00:13:12,190 --> 00:13:15,910
De definities van de set-array en set
int zijn beneden, aan de onderkant.

263
00:13:15,910 --> 00:13:17,640
>> En dus, nogmaals, vraag ik u de vraag.

264
00:13:17,640 --> 00:13:20,770
Wat wordt afgedrukt
hier aan het einde van Main?

265
00:13:20,770 --> 00:13:23,020
Er is een afdruk col. Ik m
afdrukken van twee gehele getallen.

266
00:13:23,020 --> 00:13:28,010
Ik ben het afdrukken van de inhoud van A en
de inhoud van B square bracket 0.

267
00:13:28,010 --> 00:13:29,880
Pauzeer de video hier en neem een ​​minuut.

268
00:13:29,880 --> 00:13:35,482
Kun je uitzoeken wat dit
functie wordt afgedrukt op het einde?

269
00:13:35,482 --> 00:13:38,190
Hopelijk, als je herinneren aan de
onderscheid tussen passerende waarde

270
00:13:38,190 --> 00:13:41,680
en langs referentie, deze
probleem was niet te lastig voor u.

271
00:13:41,680 --> 00:13:44,130
En het antwoord dat je zou
heb gevonden is dit.

272
00:13:44,130 --> 00:13:47,660
Als je niet echt zeker als aan
waarom dat het geval is, neem dan een tweede,

273
00:13:47,660 --> 00:13:50,620
ga terug, bekijk wat ik was gewoon
bespreking over het passeren van arrays

274
00:13:50,620 --> 00:13:53,450
referentie, versus passeren
andere variabelen van de waarde,

275
00:13:53,450 --> 00:13:56,680
en hopelijk, zal het maken
een beetje meer zin.

276
00:13:56,680 --> 00:13:59,760
>> Ik ben Doug Lloyd, en dit is CS50.

277
00:13:59,760 --> 00:14:01,467