1
00:00:00,000 --> 00:00:03,388
>> [Musik spiller]

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

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

4
00:00:06,020 --> 00:00:07,680
Arbejde med enkelt
variabler er temmelig sjovt.

5
00:00:07,680 --> 00:00:09,500
Men hvad nu, hvis vi ønsker at arbejde
med en masse af variabler,

6
00:00:09,500 --> 00:00:12,760
men vi ønsker ikke at have en flok
forskellige navne flyver rundt vores kode?

7
00:00:12,760 --> 00:00:15,980
I dette tilfælde er arrays
vil komme i virkelig handy.

8
00:00:15,980 --> 00:00:19,510
Arrays er en virkelig grundlæggende data
struktur for alle programmeringssprog

9
00:00:19,510 --> 00:00:20,260
at du vil bruge.

10
00:00:20,260 --> 00:00:24,450
Og de er virkelig, virkelig nyttige,
især, som vi vil se, i CS 50.

11
00:00:24,450 --> 00:00:27,870
>> Vi bruger arrays til at holde
værdier af samme datatype

12
00:00:27,870 --> 00:00:29,830
på tilgrænsende lagerpladser.

13
00:00:29,830 --> 00:00:32,430
Det vil sige, det er en
måde, at vi kan gruppere

14
00:00:32,430 --> 00:00:35,430
en flok af heltal sammen i
hukommelse eller en flok tegn

15
00:00:35,430 --> 00:00:38,270
eller flyder i hukommelsen virkelig
tæt sammen og arbejde

16
00:00:38,270 --> 00:00:41,930
med dem uden at skulle give hver
man sit eget unikke navn, som kan

17
00:00:41,930 --> 00:00:44,500
få besværlige efter et lille stykke tid.

18
00:00:44,500 --> 00:00:48,130
>> Nu, at én måde analogize arrays
er at tænke over dit lokale indlæg

19
00:00:48,130 --> 00:00:49,000
kontor for en anden.

20
00:00:49,000 --> 00:00:51,820
Så skridt væk fra programmering
og bare lukke øjnene

21
00:00:51,820 --> 00:00:54,120
og visualisere i dit sind
dit lokale posthus.

22
00:00:54,120 --> 00:00:57,160
Normalt i de fleste indlæg
kontorer, der er en stor bank

23
00:00:57,160 --> 00:01:00,490
et postkontor bokse på væggen.

24
00:01:00,490 --> 00:01:03,510
>> Et array er en kæmpe blok
af sammenhængende hukommelse,

25
00:01:03,510 --> 00:01:06,120
på samme måde som en e-mail
bank i dit posthus

26
00:01:06,120 --> 00:01:11,230
er en stor plads på
mur af posthuset.

27
00:01:11,230 --> 00:01:15,750
Arrays er blevet opdelt i små,
identisk størrelse blokke af rummet,

28
00:01:15,750 --> 00:01:19,930
der hver især kaldes et element i
på samme måde, at væggen af ​​posten

29
00:01:19,930 --> 00:01:23,840
kontor er blevet opdelt i små,
identisk størrelse blokke af rummet,

30
00:01:23,840 --> 00:01:27,560
som vi kalder en postboks.

31
00:01:27,560 --> 00:01:31,650
Hvert element i arrayet kan
lagre en vis mængde data,

32
00:01:31,650 --> 00:01:37,540
ligesom hver postboks er i stand
at holde en vis mængde af post.

33
00:01:37,540 --> 00:01:41,540
>> Hvad kan lagres i hvert element i
arrayet er variabler af de samme data

34
00:01:41,540 --> 00:01:45,300
type, såsom int eller char, lige
ligesom i din postboks,

35
00:01:45,300 --> 00:01:47,300
du kan kun passer tingene
af en lignende type,

36
00:01:47,300 --> 00:01:50,430
såsom bogstaver eller små pakker.

37
00:01:50,430 --> 00:01:55,050
Endelig kan vi få adgang til hvert element i
array direkte ved indeksnummer,

38
00:01:55,050 --> 00:01:59,770
ligesom vi kan få adgang til vores posthus
kasse ved at vide sin mailboks nummer.

39
00:01:59,770 --> 00:02:02,750
Forhåbentlig denne analogi
hjælper dig med at få dit hoved

40
00:02:02,750 --> 00:02:05,540
omkring ideen om arrays af
analogizing til noget andet

41
00:02:05,540 --> 00:02:08,400
at du er sandsynligvis
allerede er bekendt med.

42
00:02:08,400 --> 00:02:13,182
>> I C, elementerne i et array er
indekseret startende fra 0, ikke fra en.

43
00:02:13,182 --> 00:02:14,390
Og det er virkelig vigtigt.

44
00:02:14,390 --> 00:02:18,530
Og i virkeligheden, det er derfor, vi i CS 50,
og hvorfor dataloger ofte

45
00:02:18,530 --> 00:02:22,150
vil tælle fra 0, er
på grund af C'er matrix

46
00:02:22,150 --> 00:02:24,660
indeksering, som altid starter ved 0.

47
00:02:24,660 --> 00:02:28,730
Så hvis en matrix består af n elementer,
det første element i denne matrix

48
00:02:28,730 --> 00:02:32,960
ligger ved indeks 0, og
det sidste element i arrayet

49
00:02:32,960 --> 00:02:36,610
ligger ved indeks n minus 1.

50
00:02:36,610 --> 00:02:43,160
Igen, hvis der er n elementer i vores
array, sidste indekset er n minus 1.

51
00:02:43,160 --> 00:02:46,820
>> Så hvis vores matrix har 50 elementer, de
første element ligger ved indeks 0,

52
00:02:46,820 --> 00:02:51,060
og det sidste element
ligger ved indeks 49.

53
00:02:51,060 --> 00:02:53,940
Desværre, eller heldigvis,
afhængig af dit perspektiv,

54
00:02:53,940 --> 00:02:56,170
C er meget mildere her.

55
00:02:56,170 --> 00:02:59,480
Det vil ikke forhindre dig i at
gå ud af grænserne for dit array.

56
00:02:59,480 --> 00:03:03,080
Du kunne få adgang til minus
3 element i dit array

57
00:03:03,080 --> 00:03:07,400
eller den 59. element i dit array,
hvis dit array kun har 50 elementer.

58
00:03:07,400 --> 00:03:11,060
Det vil ikke stoppe dit program fra
kompilering, men under kørslen,

59
00:03:11,060 --> 00:03:14,350
du kan støde på en
frygtede segmentering fejl

60
00:03:14,350 --> 00:03:17,460
hvis du begynder at få adgang til hukommelsen
der ligger uden for rammerne af, hvad

61
00:03:17,460 --> 00:03:19,260
du bedt om dit program til at give dig.

62
00:03:19,260 --> 00:03:21,250
Så vær forsigtig.

63
00:03:21,250 --> 00:03:23,120
>> Hvad betyder et array
erklæring ud?

64
00:03:23,120 --> 00:03:26,940
Hvordan kan vi kode et array i eksistens
ligesom vi kode enhver anden variabel?

65
00:03:26,940 --> 00:03:31,250
Der er tre dele til en matrix
declaration-- en type, et navn,

66
00:03:31,250 --> 00:03:31,880
og en størrelse.

67
00:03:31,880 --> 00:03:34,088
Dette er meget lig en
variabel erklæring, som

68
00:03:34,088 --> 00:03:36,970
er bare en type og et navn,
størrelsen element er

69
00:03:36,970 --> 00:03:39,860
det særlige tilfælde for et array,
fordi vi får en masse af dem

70
00:03:39,860 --> 00:03:41,830
på samme tid.

71
00:03:41,830 --> 00:03:45,560
>> Så den type er, hvad slags variabel, du
ønsker hvert element i array til at være.

72
00:03:45,560 --> 00:03:47,150
Må vil have det til et array af heltal?

73
00:03:47,150 --> 00:03:49,010
Derefter skal din datatype være int.

74
00:03:49,010 --> 00:03:51,760
Har du ønsker det skal være et
vifte af doubler eller flåd?

75
00:03:51,760 --> 00:03:54,545
Datatype skal være dobbelt eller flyde.

76
00:03:54,545 --> 00:03:56,420
Navnet er, hvad du
ønsker at ringe til din array.

77
00:03:56,420 --> 00:04:00,970
Hvad ønsker du at navngive denne kæmpe
bank af heltal eller flåd eller chars

78
00:04:00,970 --> 00:04:03,250
eller doubler, eller hvad har du?

79
00:04:03,250 --> 00:04:04,700
Hvad vil du kalde det?

80
00:04:04,700 --> 00:04:06,110
Temmelig selvforklarende.

81
00:04:06,110 --> 00:04:08,610
>> Endelig størrelse, der går
indersiden af ​​firkantede parenteser,

82
00:04:08,610 --> 00:04:12,180
er, hvor mange elementer du ville
ligesom din array til at indeholde.

83
00:04:12,180 --> 00:04:13,530
Hvor mange heltal vil du have?

84
00:04:13,530 --> 00:04:15,570
Hvor mange flydere vil du have?

85
00:04:15,570 --> 00:04:19,070
>> Så for eksempel, int studerendes kvaliteter 40.

86
00:04:19,070 --> 00:04:26,020
Dette erklærer et array kaldet Student
kvaliteter, som består af 40 tal.

87
00:04:26,020 --> 00:04:28,180
Temmelig selvforklarende, håber jeg.

88
00:04:28,180 --> 00:04:29,330
Her er et andet eksempel.

89
00:04:29,330 --> 00:04:31,560
Dobbelt menuen priser 8.

90
00:04:31,560 --> 00:04:34,610
Dette skaber et array kaldet
Priser menu, som består

91
00:04:34,610 --> 00:04:38,300
af plads i hukommelsen til otte dobbeltværelser.

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

93
00:04:42,000 --> 00:04:45,750
>> Hvis du tænker på hvert element
af et array af typen data-type,

94
00:04:45,750 --> 00:04:49,860
så for eksempel, et enkelt element i
en vifte af typen int, på samme måde du

95
00:04:49,860 --> 00:04:52,770
ville tænke på noget andet
variabel af typen int,

96
00:04:52,770 --> 00:04:56,440
alle de velkendte operationer, vi
omtalt tidligere i Operations

97
00:04:56,440 --> 00:04:58,270
video vil give mening.

98
00:04:58,270 --> 00:05:01,620
Så her kunne vi erklære et array
af Booleans kaldet Truthtable,

99
00:05:01,620 --> 00:05:05,590
som består af plads til 10 Booleans.

100
00:05:05,590 --> 00:05:09,650
>> Og så, ligesom vi kunne bare tildele
en værdi til en anden variabel af typen

101
00:05:09,650 --> 00:05:13,470
Boolean, vi kunne sige noget
ligesom Truthtable firkantet beslag

102
00:05:13,470 --> 00:05:18,040
2, som er, hvordan vi angiver,
hvilket element af sandheden bordet?

103
00:05:18,040 --> 00:05:20,350
Det tredje element i
sandhedstabel, fordi huske,

104
00:05:20,350 --> 00:05:21,800
vi tælle fra 0.

105
00:05:21,800 --> 00:05:25,690
Så det er, hvordan vi angiver
tredje element af sandheden bordet.

106
00:05:25,690 --> 00:05:28,680
Truthtable 2 er lig med falsk,
ligesom vi kunne declare--

107
00:05:28,680 --> 00:05:33,560
eller vi kunne tildele snarere, enhver
Boolean typen variabel til at være falske.

108
00:05:33,560 --> 00:05:35,050
>> Vi kan også bruge det i forhold.

109
00:05:35,050 --> 00:05:39,000
if (truthtable 7 ==
sand), hvilket vil sige,

110
00:05:39,000 --> 00:05:42,370
hvis den ottende element
af Truthtable er sandt,

111
00:05:42,370 --> 00:05:46,760
måske vi ønsker at udskrive en besked
til brugeren, printf ("SAND! n") ;.

112
00:05:46,760 --> 00:05:50,290
Det får os til at sige Truthtable
10 lig sandt, ikke?

113
00:05:50,290 --> 00:05:53,590
Tja, jeg kan, men det er temmelig
farligt, fordi huske,

114
00:05:53,590 --> 00:05:56,260
Vi har en vifte af 10 Booleans.

115
00:05:56,260 --> 00:06:02,340
Så det højeste indeks, at
compiler har givet os er 9.

116
00:06:02,340 --> 00:06:06,010
>> Dette program vil kompilere, men
hvis noget andet i hukommelsen

117
00:06:06,010 --> 00:06:09,110
foreligger, når vi ville
forventer Truthtable 10 til at gå,

118
00:06:09,110 --> 00:06:13,980
vi kunne lide en segmentering fejl. Vi
kunne slippe afsted med det, men generelt,

119
00:06:13,980 --> 00:06:14,710
temmelig farlige.

120
00:06:14,710 --> 00:06:19,759
Så hvad jeg laver her er lovlig C,
men ikke nødvendigvis det bedste spil.

121
00:06:19,759 --> 00:06:22,300
Nu, når du erklærer og
initialisere et array samtidigt,

122
00:06:22,300 --> 00:06:23,960
der er faktisk en temmelig
speciel syntaks, som du

123
00:06:23,960 --> 00:06:26,250
kan bruge til at fylde array
med sine startværdier.

124
00:06:26,250 --> 00:06:30,130
Det kan få besværlige at
erklære en bred vifte af størrelse 100,

125
00:06:30,130 --> 00:06:33,430
og derefter er nødt til at sige, element 0
lig dette; element 1 er lig dette;

126
00:06:33,430 --> 00:06:34,850
element 2 er lig med det.

127
00:06:34,850 --> 00:06:36,370
Hvad er pointen, ikke?

128
00:06:36,370 --> 00:06:39,470
>> Hvis det er et lille array, du
kunne gøre noget som dette.

129
00:06:39,470 --> 00:06:44,360
Bool truthtable 3 lig åben
krøllede klammeparentes og derefter komma

130
00:06:44,360 --> 00:06:48,060
adskille liste over elementer,
at du ønsker at sætte i arrayet.

131
00:06:48,060 --> 00:06:50,520
Luk derefter krøllet tandbøjle semikolon.

132
00:06:50,520 --> 00:06:53,910
Dette skaber et array af
størrelse tre kaldet Truthtable,

133
00:06:53,910 --> 00:06:56,090
med elementer falsk, sandt, og sandt.

134
00:06:56,090 --> 00:06:59,270
Og faktisk instantiering
syntaks jeg har her, er

135
00:06:59,270 --> 00:07:03,350
nøjagtigt det samme som at gøre det
enkelt element syntaks nedenfor.

136
00:07:03,350 --> 00:07:09,380
Disse to måder at kodning ville
producere nøjagtig samme array.

137
00:07:09,380 --> 00:07:11,740
>> Tilsvarende kunne vi gentage
over hele elementerne

138
00:07:11,740 --> 00:07:15,400
af et array ved hjælp af en løkke, som i
Faktisk er en meget stærkt anbefalet

139
00:07:15,400 --> 00:07:16,790
at-home øvelse.

140
00:07:16,790 --> 00:07:20,720
Hvordan skaber man et array
af 100 heltal, hvor

141
00:07:20,720 --> 00:07:23,477
hvert element i array er sit indeks?

142
00:07:23,477 --> 00:07:26,560
Så for eksempel, har vi en vifte af 100
heltal, og i det første element,

143
00:07:26,560 --> 00:07:27,790
Vi ønsker at sætte 0.

144
00:07:27,790 --> 00:07:29,810
I det andet element, vi ønsker at sætte 1.

145
00:07:29,810 --> 00:07:33,319
I det tredje element, vi ønsker
at sætte 2; og så videre og så videre.

146
00:07:33,319 --> 00:07:35,360
Det er en rigtig god
at-home øvelse at gøre det.

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

148
00:07:38,190 --> 00:07:40,220
>> Her ser det ikke
som for meget har ændret sig.

149
00:07:40,220 --> 00:07:44,170
Men se, at i mellem
kantede parenteser, denne gang,

150
00:07:44,170 --> 00:07:45,830
Jeg har faktisk udeladt nummeret.

151
00:07:45,830 --> 00:07:48,000
Hvis du bruger denne meget
særlige instantiering

152
00:07:48,000 --> 00:07:50,380
syntaks for at skabe en
array, du faktisk ikke

153
00:07:50,380 --> 00:07:53,491
skal angive størrelsen
af opstillingen på forhånd.

154
00:07:53,491 --> 00:07:55,740
Den compiler er smart nok
at vide, at du rent faktisk

155
00:07:55,740 --> 00:07:58,980
ønsker en bred vifte af størrelse 3,
fordi du lægger tre elementer

156
00:07:58,980 --> 00:08:00,640
til højre for lighedstegnet.

157
00:08:00,640 --> 00:08:04,140
Hvis du havde sat fire, ville det have
givet dig en sandhed tabel med størrelsen fire;

158
00:08:04,140 --> 00:08:06,270
og så videre og så videre.

159
00:08:06,270 --> 00:08:09,380
>> Arrays er ikke begrænset til en enkelt
dimension, som er ret cool.

160
00:08:09,380 --> 00:08:12,000
Du kan faktisk have så mange
side beregnere, som du ønsker.

161
00:08:12,000 --> 00:08:16,470
Så for eksempel, hvis du vil oprette
en bestyrelse for spillet Battleship, som,

162
00:08:16,470 --> 00:08:20,910
hvis du nogensinde spillet, er et spil, der er
legede med pinde på 10 med 10 grid,

163
00:08:20,910 --> 00:08:22,450
man kunne skabe en række som denne.

164
00:08:22,450 --> 00:08:26,030
Man kan sige Bool
slagskib firkantede beslag 10

165
00:08:26,030 --> 00:08:29,590
lukket firkantet beslag firkantet
beslag 10 lukket firkantet beslag.

166
00:08:29,590 --> 00:08:32,710
>> Og så kan du vælge at
fortolke dette i dit sind som en 10

167
00:08:32,710 --> 00:08:35,576
med 10 gitter af celler.

168
00:08:35,576 --> 00:08:37,409
Nu, i virkeligheden, i hukommelsen,
det virkelig bare

169
00:08:37,409 --> 00:08:42,440
forbliver en 100 element,
enkelt dimensionelle array.

170
00:08:42,440 --> 00:08:46,070
Og det i virkeligheden går efter, hvis du
har tre dimensioner eller fire eller fem.

171
00:08:46,070 --> 00:08:49,420
Det er virkelig bare gør formere
alle de indices--

172
00:08:49,420 --> 00:08:51,130
eller alle størrelse
specifiers-- sammen,

173
00:08:51,130 --> 00:08:53,480
og du bare få en endimensional
array af denne størrelse.

174
00:08:53,480 --> 00:08:57,090
>> Men med hensyn til organisation og
visualisering og menneskelig perception,

175
00:08:57,090 --> 00:08:59,240
det kan være en hel del lettere
at arbejde med et gitter

176
00:08:59,240 --> 00:09:02,980
Hvis du arbejder på et spil
ligesom Kryds og bolle eller slagskib,

177
00:09:02,980 --> 00:09:05,179
eller sådan noget.

178
00:09:05,179 --> 00:09:06,970
Det er en stor abstraktion,
i stedet for at

179
00:09:06,970 --> 00:09:09,340
at tænke på en Kryds og bolle
bestyrelsen som en linje af ni

180
00:09:09,340 --> 00:09:13,810
firkanter eller et slagskib bord
som en linje af 100 kvadrater.

181
00:09:13,810 --> 00:09:16,010
En 10 ved 10 gitter eller en tre
med tre gitter er sandsynligvis

182
00:09:16,010 --> 00:09:17,225
meget mere let at opfatte.

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

184
00:09:19,820 --> 00:09:22,280
>> Nu noget virkelig
vigtigt om arrays.

185
00:09:22,280 --> 00:09:25,950
Vi kan behandle hver enkelt
element i arrayet som en variabel.

186
00:09:25,950 --> 00:09:27,700
Vi så, at tidligere
da vi tildele

187
00:09:27,700 --> 00:09:32,240
værdien Sand til visse Booleans
eller teste dem i betingede.

188
00:09:32,240 --> 00:09:35,960
Men vi kan ikke behandle hele
arrays sig som variable.

189
00:09:35,960 --> 00:09:41,760
Vi kan for eksempel ikke, tildele en vifte
til et andet array ved hjælp af opgaven

190
00:09:41,760 --> 00:09:42,930
operatør.

191
00:09:42,930 --> 00:09:44,640
Det er ikke lovligt C.

192
00:09:44,640 --> 00:09:47,920
>> Hvis vi vil, for example-- hvad
vi ville gøre i dette eksempel

193
00:09:47,920 --> 00:09:50,200
ville være muligt at kopiere en matrix til en anden.

194
00:09:50,200 --> 00:09:53,810
Hvis vi ønsker at gøre det, vi faktisk
nødt til at bruge en løkke til at kopiere løbet

195
00:09:53,810 --> 00:09:56,550
hvert enkelt element én ad gangen.

196
00:09:56,550 --> 00:09:58,700
Jeg ved det er lidt tidskrævende.

197
00:09:58,700 --> 00:10:04,022
>> Så for eksempel, hvis vi havde disse par
af linjer kode, ville dette arbejde?

198
00:10:04,022 --> 00:10:05,230
Nå, nej, ville det ikke, vel?

199
00:10:05,230 --> 00:10:07,860
Fordi vi prøver
at tildele mad til bar.

200
00:10:07,860 --> 00:10:09,860
Det kommer ikke til at fungere,
fordi det er et array,

201
00:10:09,860 --> 00:10:13,130
og vi lige har beskrevet
at det ikke er lovligt C.

202
00:10:13,130 --> 00:10:15,580
>> I stedet hvis vi ønsker at
kopiere indholdet af mad

203
00:10:15,580 --> 00:10:18,070
i bar, som er det
vi prøver at gøre her,

204
00:10:18,070 --> 00:10:19,970
Vi ville have en syntaks som denne.

205
00:10:19,970 --> 00:10:24,170
Vi har en for-løkke, der går
fra J er lig med 0 til 5,

206
00:10:24,170 --> 00:10:28,390
og vi tilvækst J på hver iteration af
løkken og tildele elementer som.

207
00:10:28,390 --> 00:10:33,360
Dette ville resultere i bar også
være en, to, tre, fire, fem,

208
00:10:33,360 --> 00:10:36,730
men vi er nødt til at gøre det på denne meget
langsom element-by-element måde,

209
00:10:36,730 --> 00:10:40,009
i stedet for ved blot
kopiere hele array.

210
00:10:40,009 --> 00:10:42,050
I andre programmering
sprog, mere moderne dem,

211
00:10:42,050 --> 00:10:45,610
du kan faktisk gøre netop
så simpelt er lig syntaks.

212
00:10:45,610 --> 00:10:49,620
Men C, desværre, vi er
ikke lov til at gøre det.

213
00:10:49,620 --> 00:10:52,026
>> Nu er der er en anden
ting, jeg vil nævne

214
00:10:52,026 --> 00:10:54,650
om arrays, der kan være lidt
smule tricky, første gang du

215
00:10:54,650 --> 00:10:55,990
arbejde med dem.

216
00:10:55,990 --> 00:10:59,860
Vi diskuterede i en video
om variabel rækkevidde,

217
00:10:59,860 --> 00:11:04,940
at de fleste variabler i C, når du kalder
dem i funktioner, træffes ved værdi.

218
00:11:04,940 --> 00:11:08,620
Kan du huske, hvad det betyder
at passere noget ved værdi?

219
00:11:08,620 --> 00:11:12,570
Det betyder, at vi laver en kopi af
variabel, der bliver vedtaget i.

220
00:11:12,570 --> 00:11:16,290
Kalderlisten funktion, funktionen
der er modtager den variable,

221
00:11:16,290 --> 00:11:17,730
ikke får den variable selv.

222
00:11:17,730 --> 00:11:20,850
Det får sin egen lokale
kopi af det at arbejde med.

223
00:11:20,850 --> 00:11:24,070
>> Arrays, selvfølgelig, gøre
ikke følger denne regel.

224
00:11:24,070 --> 00:11:27,600
Snarere, hvad vi kalder det
passerer som reference.

225
00:11:27,600 --> 00:11:31,360
Callee faktisk
ikke modtager array.

226
00:11:31,360 --> 00:11:34,207
Det betyder ikke modtager sin
egen lokale kopi af den.

227
00:11:34,207 --> 00:11:36,040
Og hvis du tænker over
det, det giver mening.

228
00:11:36,040 --> 00:11:39,750
Hvis arrays er virkelig store, det
tager så meget tid og kræfter

229
00:11:39,750 --> 00:11:44,470
at lave en kopi af en vifte af
100 eller 1000 eller 10.000 elementer,

230
00:11:44,470 --> 00:11:48,290
at det ikke er værd for en
funktion til at modtage en kopi af det,

231
00:11:48,290 --> 00:11:51,037
gøre noget arbejde med det, og derefter
bare gøres med kopien;

232
00:11:51,037 --> 00:11:53,120
det behøver ikke at have
det hængende rundt længere.

233
00:11:53,120 --> 00:11:54,710
>> Fordi arrays er nogle
klodsede og besværlige,

234
00:11:54,710 --> 00:11:56,001
vi bare videregive dem som reference.

235
00:11:56,001 --> 00:12:01,210
Vi har lige tillid til, at funktionen
til, ikke bryder noget.

236
00:12:01,210 --> 00:12:03,010
Så det gør faktisk få array.

237
00:12:03,010 --> 00:12:05,290
Det bliver ikke sin egen lokale kopi af den.

238
00:12:05,290 --> 00:12:07,170
>> Så hvad betyder det,
så, når callee

239
00:12:07,170 --> 00:12:08,970
manipulerer elementer i array?

240
00:12:08,970 --> 00:12:10,780
Hvad der sker?

241
00:12:10,780 --> 00:12:13,210
For nu, vil vi glans
løbet hvorfor netop dette

242
00:12:13,210 --> 00:12:15,320
sker, hvorfor arrays
videregives ved henvisning

243
00:12:15,320 --> 00:12:17,810
og alt andet er gået i værdi.

244
00:12:17,810 --> 00:12:20,470
Men jeg lover dig, vil vi
vende tilbage og give dig svaret

245
00:12:20,470 --> 00:12:23,750
til dette i en senere video.

246
00:12:23,750 --> 00:12:28,110
>> Her er endnu en øvelse for dig
før vi wrap op ting på arrays.

247
00:12:28,110 --> 00:12:31,400
Bundt af koden her, det er
ikke særlig god stil,

248
00:12:31,400 --> 00:12:33,400
bare jeg vil gøre, at advarsel.

249
00:12:33,400 --> 00:12:36,660
Der er ingen kommentarer herinde,
som er temmelig dårlig form.

250
00:12:36,660 --> 00:12:39,750
Men det er kun fordi jeg ønskede at være
stand til at passe alt på skærmen.

251
00:12:39,750 --> 00:12:44,360
>> Øverst kan du se, at jeg har
to funktions angivelser til sæt-array

252
00:12:44,360 --> 00:12:45,820
og sæt int.

253
00:12:45,820 --> 00:12:49,680
Set matrix tilsyneladende tager et array
fire heltal som sit input.

254
00:12:49,680 --> 00:12:52,767
Og sæt int tilsyneladende tager
en enkelt heltal som sit input.

255
00:12:52,767 --> 00:12:54,350
Men begge af dem har ikke en udgang.

256
00:12:54,350 --> 00:12:57,689
Udgangen, afkastet
skriver, af hver enkelt er ugyldig.

257
00:12:57,689 --> 00:12:59,480
I Main, har vi en
par linjer kode.

258
00:12:59,480 --> 00:13:02,730
Vi erklærer en heltalsvariabel
kaldet A og tildele den værdien 10.

259
00:13:02,730 --> 00:13:07,080
Vi erklærer en vifte af fire heltal
kaldet B og tildele elementerne 0, 1,

260
00:13:07,080 --> 00:13:08,730
2 og 3, henholdsvis.

261
00:13:08,730 --> 00:13:12,190
Så har vi en opfordring til at indstille
int og en opfordring til at indstille array.

262
00:13:12,190 --> 00:13:15,910
Definitionerne af sæt array og sæt
int er nede, nederst.

263
00:13:15,910 --> 00:13:17,640
>> Og så, igen, jeg spørger dig spørgsmålet.

264
00:13:17,640 --> 00:13:20,770
Hvad der bliver udskrevet
her i slutningen af ​​Main?

265
00:13:20,770 --> 00:13:23,020
Der er en udskrift col. Jeg er
udskrive to heltal.

266
00:13:23,020 --> 00:13:28,010
Jeg udskrive indholdet af A og
indholdet af B firkantede beslag 0.

267
00:13:28,010 --> 00:13:29,880
Pause videoen her og tage et minut.

268
00:13:29,880 --> 00:13:35,482
Kan du regne ud, hvad dette
funktion udskrives i slutningen?

269
00:13:35,482 --> 00:13:38,190
Forhåbentlig hvis du husker den
skelnen mellem forbifarten efter værdi

270
00:13:38,190 --> 00:13:41,680
og passerer som reference, dette
problemet ikke var for svært for dig.

271
00:13:41,680 --> 00:13:44,130
Og det svar, du ville
har fundet er dette.

272
00:13:44,130 --> 00:13:47,660
Hvis du ikke er helt sikker på at
hvorfor det er tilfældet, tage et andet,

273
00:13:47,660 --> 00:13:50,620
gå tilbage, gennemgå, hvad jeg var bare
diskutere om passerer arrays

274
00:13:50,620 --> 00:13:53,450
som reference, versus passerer
andre variable ved værdi,

275
00:13:53,450 --> 00:13:56,680
og forhåbentlig vil det gøre
lidt mere mening.

276
00:13:56,680 --> 00:13:59,760
>> Jeg Doug Lloyd, og det er CS50.

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