1
00:00:00,000 --> 00:00:03,388
>> [MUSIC SPILLE]

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

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

4
00:00:06,020 --> 00:00:07,680
Arbeide med singel
variabler er ganske morsomt.

5
00:00:07,680 --> 00:00:09,500
Men hva hvis vi ønsker å jobbe
med en rekke variabler,

6
00:00:09,500 --> 00:00:12,760
men vi ønsker ikke å ha en haug med
forskjellige navn flyr rundt vår kode?

7
00:00:12,760 --> 00:00:15,980
I dette tilfellet, arrays er
skal komme i virkelig hendig.

8
00:00:15,980 --> 00:00:19,510
Arrays er en veldig grunnleggende data
struktur for alle programmeringsspråk

9
00:00:19,510 --> 00:00:20,260
som du vil bruke.

10
00:00:20,260 --> 00:00:24,450
Og de er veldig, veldig nyttig,
spesielt, så vi får se, i CS 50.

11
00:00:24,450 --> 00:00:27,870
>> Vi bruker arrays for å holde
verdier av de samme datatype

12
00:00:27,870 --> 00:00:29,830
på sammenhengende minnesteder.

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

14
00:00:32,430 --> 00:00:35,430
en haug av heltall sammen i
minne eller en haug med karakterer

15
00:00:35,430 --> 00:00:38,270
eller flyter i minnet egentlig
tett sammen og arbeid

16
00:00:38,270 --> 00:00:41,930
med dem uten å måtte gi hver
man sin egen unike navn, som kan

17
00:00:41,930 --> 00:00:44,500
får etter en liten stund tungvint.

18
00:00:44,500 --> 00:00:48,130
>> Nå, en måte å analogize arrays
er å tenke på din lokale post

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

20
00:00:49,000 --> 00:00:51,820
Så gå bort fra programmering
og bare lukke øynene

21
00:00:51,820 --> 00:00:54,120
og visualisere i tankene dine
ditt lokale postkontor.

22
00:00:54,120 --> 00:00:57,160
Vanligvis, i de fleste post
kontorer, det er en stor bank

23
00:00:57,160 --> 00:01:00,490
Et postkontor bokser på veggen.

24
00:01:00,490 --> 00:01:03,510
>> En matrise er en gigantisk blokk
av sammenhengende minne,

25
00:01:03,510 --> 00:01:06,120
på samme måte som en post
bank i ditt postkontor

26
00:01:06,120 --> 00:01:11,230
er en stor plass på
vegg av postkontoret.

27
00:01:11,230 --> 00:01:15,750
Arrays har blitt delt opp i små,
identisk store blokker med plass,

28
00:01:15,750 --> 00:01:19,930
som hver er kalt et element, i
på samme måte som veggen av stolpen

29
00:01:19,930 --> 00:01:23,840
Kontoret har blitt delt opp i små,
identisk store blokker med plass,

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

31
00:01:27,560 --> 00:01:31,650
Hvert element i matrisen kan
å lagre en viss mengde data,

32
00:01:31,650 --> 00:01:37,540
akkurat som hver postboks er i stand
å holde en viss mengde av e-post.

33
00:01:37,540 --> 00:01:41,540
>> Hva som kan lagres i hvert element av
matrisen er variable med samme data

34
00:01:41,540 --> 00:01:45,300
type, for eksempel int eller røye, bare
som i ditt postkontor boksen,

35
00:01:45,300 --> 00:01:47,300
du kan bare passe ting
av lignende type,

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

37
00:01:50,430 --> 00:01:55,050
Endelig kan vi få tilgang til hvert element i
matrisen direkte av indeksnummer,

38
00:01:55,050 --> 00:01:59,770
akkurat som vi kan få tilgang til vår postkontor
boksen ved å kjenne sin postkasse.

39
00:01:59,770 --> 00:02:02,750
Forhåpentligvis, som analogi
hjelper deg å få hodet

40
00:02:02,750 --> 00:02:05,540
rundt tanken på matriser av
analogizing til noe annet

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

42
00:02:08,400 --> 00:02:13,182
>> I C, elementene i en matrise er
indeksert fra 0, og ikke fra en.

43
00:02:13,182 --> 00:02:14,390
Og dette er veldig viktig.

44
00:02:14,390 --> 00:02:18,530
Og faktisk, dette er grunnen til at vi, i CS 50,
Og hvorfor dataforskere ofte

45
00:02:18,530 --> 00:02:22,150
vil telle fra 0, er
på grunn av C fylking

46
00:02:22,150 --> 00:02:24,660
indeksering, som alltid starter på 0.

47
00:02:24,660 --> 00:02:28,730
Så hvis en matrise består av n elementer,
det første elementet i den oppstillingen

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

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

50
00:02:36,610 --> 00:02:43,160
Igjen, hvis det er n elementer i vår
array, er den siste indeksen n minus en.

51
00:02:43,160 --> 00:02:46,820
>> Så hvis vår rekke har 50 elementer, de
første element er plassert ved indeks 0,

52
00:02:46,820 --> 00:02:51,060
og det siste elementet
ligger på indeks 49.

53
00:02:51,060 --> 00:02:53,940
Dessverre, eller heldigvis,
avhengig av perspektiv,

54
00:02:53,940 --> 00:02:56,170
C er svært skånsom her.

55
00:02:56,170 --> 00:02:59,480
Det vil ikke hindre deg fra
går ut over grensene for ditt array.

56
00:02:59,480 --> 00:03:03,080
Du kan få tilgang til minus
3 element av klyngen

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

58
00:03:07,400 --> 00:03:11,060
Det vil ikke stoppe programmet fra
kompilering, men under kjøring,

59
00:03:11,060 --> 00:03:14,350
du kan støte på en
fryktede segmentering feil

60
00:03:14,350 --> 00:03:17,460
hvis du begynner å få tilgang til minne
som er utenfor grensene for hva

61
00:03:17,460 --> 00:03:19,260
du spurte programmet å gi deg.

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

63
00:03:21,250 --> 00:03:23,120
>> Hva gjør en matrise
erklæring se ut?

64
00:03:23,120 --> 00:03:26,940
Hvordan kode vi en matrise til eksistens
som vi kode noen annen variabel?

65
00:03:26,940 --> 00:03:31,250
Det er tre deler til en matrise
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 svært lik en
variabeldeklarasjon, som

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

69
00:03:36,970 --> 00:03:39,860
det spesielle tilfellet for en matrise,
fordi vi får en haug av dem

70
00:03:39,860 --> 00:03:41,830
samtidig.

71
00:03:41,830 --> 00:03:45,560
>> Så den typen er hva slags variable deg
vil hvert element i matrisen skal være.

72
00:03:45,560 --> 00:03:47,150
Vil det til en rekke heltall?

73
00:03:47,150 --> 00:03:49,010
Deretter bør du datatypen være int.

74
00:03:49,010 --> 00:03:51,760
Ønsker du at det skal være en
utvalg av doble eller flyter?

75
00:03:51,760 --> 00:03:54,545
Datatype bør være dobbelt eller flyte.

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

77
00:03:56,420 --> 00:04:00,970
Hva vil du kalle denne giganten
bank av heltall eller flyter eller chars

78
00:04:00,970 --> 00:04:03,250
eller dobler, eller hva har du?

79
00:04:03,250 --> 00:04:04,700
Hva vil du kalle det?

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

81
00:04:06,110 --> 00:04:08,610
>> Til slutt, størrelse, som går
innsiden av hakeparenteser,

82
00:04:08,610 --> 00:04:12,180
er hvor mange elementer du ville
som din array å inneholde.

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

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

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

86
00:04:19,070 --> 00:04:26,020
Dette erklærer en matrise som heter Student
karakterer, som består av 40 tall.

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

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

89
00:04:29,330 --> 00:04:31,560
Doble menyen priser 8.

90
00:04:31,560 --> 00:04:34,610
Dette skaper en matrise som kalles
Menyen priser, som består

91
00:04:34,610 --> 00:04:38,300
plass i minnet for åtte dobles.

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

93
00:04:42,000 --> 00:04:45,750
>> Hvis du tenker på hvert element
av en oppstilling av type data-typen,

94
00:04:45,750 --> 00:04:49,860
så for eksempel, et enkelt element av
en rekke av type int, på samme måte som du

95
00:04:49,860 --> 00:04:52,770
ville tenke på noe annet
variabel av type int,

96
00:04:52,770 --> 00:04:56,440
alle de kjente operasjoner som vi
diskutert tidligere i drifts

97
00:04:56,440 --> 00:04:58,270
Videoen vil være fornuftig.

98
00:04:58,270 --> 00:05:01,620
Så her, kan vi erklære en matrise
av Booleans kalt Truthtable,

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

100
00:05:05,590 --> 00:05:09,650
>> Og så, akkurat som vi bare kunne tildele
en verdi til en annen variabel av typen

101
00:05:09,650 --> 00:05:13,470
Boolean, vi kunne si noe
som Truthtable hakeparentes

102
00:05:13,470 --> 00:05:18,040
2, som er hvordan vi viser,
som element av sannhet bordet?

103
00:05:18,040 --> 00:05:20,350
Det tredje element i
sannhet tabellen, fordi husk,

104
00:05:20,350 --> 00:05:21,800
vi teller fra 0.

105
00:05:21,800 --> 00:05:25,690
Så det er hvordan vi angir
tredje element i sannhetstabellen.

106
00:05:25,690 --> 00:05:28,680
Truthtable to lik falske,
akkurat som vi kunne declare--

107
00:05:28,680 --> 00:05:33,560
eller vi kan tildele, heller, noe
Boolsk type variabel å være falsk.

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

109
00:05:35,050 --> 00:05:39,000
if (truthtable 7 ==
true), det vil si,

110
00:05:39,000 --> 00:05:42,370
hvis den åttende element
av Truthtable er sant,

111
00:05:42,370 --> 00:05:46,760
kanskje vi ønsker å skrive ut en melding
for brukeren, printf ("TRUE! n") ;.

112
00:05:46,760 --> 00:05:50,290
Det får oss til å si Truthtable
10 lik sant, ikke sant?

113
00:05:50,290 --> 00:05:53,590
Vel, jeg kan, men det er ganske
farlig, fordi husk,

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

115
00:05:56,260 --> 00:06:02,340
Så den høyeste indeksen at
kompilatoren har gitt oss er ni.

116
00:06:02,340 --> 00:06:06,010
>> Dette programmet vil kompilere, men
hvis noe annet i minnet

117
00:06:06,010 --> 00:06:09,110
finnes der vi ville
forvente Truthtable 10 for å gå,

118
00:06:09,110 --> 00:06:13,980
vi kunne lide en segmentering feil. Vi
kan komme unna med det, men generelt,

119
00:06:13,980 --> 00:06:14,710
ganske farlig.

120
00:06:14,710 --> 00:06:19,759
Så det jeg gjør her er lovlig C,
men ikke nødvendigvis det beste trekket.

121
00:06:19,759 --> 00:06:22,300
Nå, når du deklarerer og
initial en rekke samtidig,

122
00:06:22,300 --> 00:06:23,960
det er faktisk en ganske
spesiell syntaks som du

123
00:06:23,960 --> 00:06:26,250
kan brukes til å fylle opp matrisen
med sine startverdier.

124
00:06:26,250 --> 00:06:30,130
Det kan bli tungvint å
erklære en rekke størrelse 100,

125
00:06:30,130 --> 00:06:33,430
og deretter har å si, element 0
tilsvarer dette; element 1 tilsvarer dette;

126
00:06:33,430 --> 00:06:34,850
element 2 tilsvarer det.

127
00:06:34,850 --> 00:06:36,370
Hva er poenget, ikke sant?

128
00:06:36,370 --> 00:06:39,470
>> Hvis det er et lite utvalg, du
kunne gjøre noe sånt som dette.

129
00:06:39,470 --> 00:06:44,360
Bool truthtable tre lik åpen
klammeparentes og deretter komma

130
00:06:44,360 --> 00:06:48,060
skille liste av elementer
som du ønsker å sette i rekken.

131
00:06:48,060 --> 00:06:50,520
Deretter lukker krøllete brace semikolon.

132
00:06:50,520 --> 00:06:53,910
Dette skaper en rekke
størrelse tre kalt Truthtable,

133
00:06:53,910 --> 00:06:56,090
med elementer falske, ekte og sann.

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

135
00:06:59,270 --> 00:07:03,350
nøyaktig det samme som gjør
enkelt element syntaksen nedenfor.

136
00:07:03,350 --> 00:07:09,380
Disse to måtene å koding would
produsere den samme matrisen.

137
00:07:09,380 --> 00:07:11,740
>> På samme måte kan vi veksle
i løpet av alle elementene

138
00:07:11,740 --> 00:07:15,400
i en matrise ved hjelp av en løkke, som i sin
Faktisk er et meget sterkt anbefalt

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

140
00:07:16,790 --> 00:07:20,720
Hvordan skaper du en matrise
100 heltall, der

141
00:07:20,720 --> 00:07:23,477
hvert element i matrisen er indeksen?

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

143
00:07:26,560 --> 00:07:27,790
vi ønsker å sette 0.

144
00:07:27,790 --> 00:07:29,810
I det andre elementet, ønsker vi å sette en.

145
00:07:29,810 --> 00:07:33,319
I den tredje element, vi ønsker
å sette to; og så videre og så videre.

146
00:07:33,319 --> 00:07:35,360
Det er en virkelig god
hjemme-trening for å gjø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 mye har forandret seg.

149
00:07:40,220 --> 00:07:44,170
Men legg merke til at i mellom
hakeparenteser, denne gangen

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

151
00:07:45,830 --> 00:07:48,000
Hvis du bruker dette svært
spesiell oppretting

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

153
00:07:50,380 --> 00:07:53,491
behov for å indikere størrelsen
i matrisen på forhånd.

154
00:07:53,491 --> 00:07:55,740
Kompilatoren er smart nok
å vite at du faktisk

155
00:07:55,740 --> 00:07:58,980
vil en rekke størrelse 3,
fordi du putter tre elementer

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

157
00:08:00,640 --> 00:08:04,140
Hvis du hadde satt fire, ville det ha
gitt deg en sannhet tabell med størrelse 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 begrenset til en enkelt
dimensjon, som er ganske kult.

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

161
00:08:12,000 --> 00:08:16,470
Så for eksempel, hvis du ønsker å opprette
et bord for spillet Battleship, som,

162
00:08:16,470 --> 00:08:20,910
hvis du noen gang spilt, er et spill som er
spilt med knagger på 10 av 10 rutenett,

163
00:08:20,910 --> 00:08:22,450
du kan lage en matrise som dette.

164
00:08:22,450 --> 00:08:26,030
Du kan si Bool
slaghakeparentes 10

165
00:08:26,030 --> 00:08:29,590
lukket hakeparentes torget
brakett 10 stengt hakeparentes.

166
00:08:29,590 --> 00:08:32,710
>> Og så kan du velge å
tolke dette i tankene dine som en 10

167
00:08:32,710 --> 00:08:35,576
ved 10 rutenett av celler.

168
00:08:35,576 --> 00:08:37,409
Nå, i virkeligheten, i minnet,
det virkelig bare

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

170
00:08:42,440 --> 00:08:46,070
Og dette, faktisk, går for hvis du
har tre dimensjoner eller fire eller fem.

171
00:08:46,070 --> 00:08:49,420
Det egentlig bare ikke formere
alle de indices--

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

173
00:08:51,130 --> 00:08:53,480
og du bare få en endimensjonal
utvalg av denne størrelsen.

174
00:08:53,480 --> 00:08:57,090
>> Men når det gjelder organisering og
visualisering og menneskelig persepsjon,

175
00:08:57,090 --> 00:08:59,240
det kan være mye enklere
å arbeide med et rutenett

176
00:08:59,240 --> 00:09:02,980
hvis du jobber med et spill
som Tic-tac-toe eller Battleship,

177
00:09:02,980 --> 00:09:05,179
eller noe sånt.

178
00:09:05,179 --> 00:09:06,970
Det er en flott abstraksjon,
i stedet for å måtte

179
00:09:06,970 --> 00:09:09,340
å tenke på en Tic-Tac-Toe
Styret som en linje av ni

180
00:09:09,340 --> 00:09:13,810
firkanter eller en Battleship bord
som en linje på 100 kvadrater.

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

182
00:09:16,010 --> 00:09:17,225
mye mer lett å oppfatte.

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

184
00:09:19,820 --> 00:09:22,280
>> Nå, noe virkelig
viktig om arrays.

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

186
00:09:25,950 --> 00:09:27,700
Vi så at tidligere
når vi tilordner

187
00:09:27,700 --> 00:09:32,240
verdien True til visse Booleans
eller teste dem i conditionals.

188
00:09:32,240 --> 00:09:35,960
Men vi kan ikke behandle hele
Arrays seg som variabler.

189
00:09:35,960 --> 00:09:41,760
Vi kan for eksempel ikke, tildele ett array
til en annen array ved hjelp av oppdraget

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

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

192
00:09:44,640 --> 00:09:47,920
>> Hvis vi vil, for example-- hva
vi skulle gjøre i det eksemplet

193
00:09:47,920 --> 00:09:50,200
ville være å kopiere ett array til et annet.

194
00:09:50,200 --> 00:09:53,810
Hvis vi ønsker å gjøre det, vi faktisk
trenger å bruke en løkke til å kopiere over

195
00:09:53,810 --> 00:09:56,550
hvert enkelt element en av gangen.

196
00:09:56,550 --> 00:09:58,700
Jeg vet det er litt tidkrevende.

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

198
00:10:04,022 --> 00:10:05,230
Vel, nei, det ville ikke, ikke sant?

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

200
00:10:07,860 --> 00:10:09,860
Det kommer ikke til å fungere,
fordi det er en matrise,

201
00:10:09,860 --> 00:10:13,130
og vi nettopp beskrev
at det ikke er lovlig C.

202
00:10:13,130 --> 00:10:15,580
>> I stedet, hvis vi ønsker å
kopiere innholdet i maten

203
00:10:15,580 --> 00:10:18,070
inn i baren, som er hva
vi prøver å gjøre her,

204
00:10:18,070 --> 00:10:19,970
vi trenger en syntaks som dette.

205
00:10:19,970 --> 00:10:24,170
Vi har en for loop som går
fra J er lik 0 til 5,

206
00:10:24,170 --> 00:10:28,390
og vi øke J på hver iterasjon av
løkken og tilordne elementer sånn.

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

208
00:10:33,360 --> 00:10:36,730
men vi må gjøre det på denne svært
langsom element-til-element måte,

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

210
00:10:40,009 --> 00:10:42,050
I annen programmering
språk, mer moderne seg,

211
00:10:42,050 --> 00:10:45,610
du kan faktisk gjøre akkurat
Så enkelt er lik syntaks.

212
00:10:45,610 --> 00:10:49,620
Men C, dessverre, vi er
ikke lov til å gjøre det.

213
00:10:49,620 --> 00:10:52,026
>> Nå er det en annen
ting jeg vil nevne

214
00:10:52,026 --> 00:10:54,650
om arrays som kan være litt
litt vanskelig den første gangen du

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

216
00:10:55,990 --> 00:10:59,860
Vi diskuterte i en video
om variabel omfang,

217
00:10:59,860 --> 00:11:04,940
at de fleste variabler i C, når du ringer
dem i funksjoner, er vedtatt av verdi.

218
00:11:04,940 --> 00:11:08,620
Husker du hva det betyr
å passere noe av verdi?

219
00:11:08,620 --> 00:11:12,570
Det betyr at vi gjør en kopi av
variabel som blir vedtatt i.

220
00:11:12,570 --> 00:11:16,290
Callee funksjon, funksjonen
som er mottatt variabel,

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

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

223
00:11:20,850 --> 00:11:24,070
>> Arrays, selvfølgelig, gjør
ikke følger denne regelen.

224
00:11:24,070 --> 00:11:27,600
Snarere, det vi kaller dette
passerer ved henvisning.

225
00:11:27,600 --> 00:11:31,360
Callee faktisk
mottar den array.

226
00:11:31,360 --> 00:11:34,207
Det ikke får sin
egen lokal kopi av den.

227
00:11:34,207 --> 00:11:36,040
Og hvis du tenker på
det, dette er fornuftig.

228
00:11:36,040 --> 00:11:39,750
Hvis arrays er virkelig store, det
tar så mye tid og krefter

229
00:11:39,750 --> 00:11:44,470
å lage en kopi av en rekke
100 eller 1000 eller 10.000 elementer,

230
00:11:44,470 --> 00:11:48,290
at det ikke er verdt det for en
funksjon for å motta en kopi av den,

231
00:11:48,290 --> 00:11:51,037
gjøre noe arbeid med det, og deretter
bare gjøres med copy;

232
00:11:51,037 --> 00:11:53,120
det trenger ikke å ha
den hengende rundt lenger.

233
00:11:53,120 --> 00:11:54,710
>> Fordi arrays er noen
klumpete og tungvint,

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

235
00:11:56,001 --> 00:12:01,210
Vi stoler på at funksjonen
å ikke ødelegge noe.

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

237
00:12:03,010 --> 00:12:05,290
Det blir ikke en egen lokal kopi av den.

238
00:12:05,290 --> 00:12:07,170
>> Så hva betyr dette,
så, når callee

239
00:12:07,170 --> 00:12:08,970
manipulerer elementene i matrisen?

240
00:12:08,970 --> 00:12:10,780
Hva skjer?

241
00:12:10,780 --> 00:12:13,210
For nå, vil vi glans
om hvorfor akkurat dette

242
00:12:13,210 --> 00:12:15,320
skjer, hvorfor arrays
føres ved referanse

243
00:12:15,320 --> 00:12:17,810
og alt annet er vedtatt av verdi.

244
00:12:17,810 --> 00:12:20,470
Men jeg lover deg, vil vi
tilbake og gi deg 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 enda en øvelse for deg
før vi pakke inn ting på arrays.

247
00:12:28,110 --> 00:12:31,400
Haug av koden her, det er
ikke spesielt god stil,

248
00:12:31,400 --> 00:12:33,400
bare jeg skal gjøre det forbeholdet.

249
00:12:33,400 --> 00:12:36,660
Det finnes ingen kommentarer her inne,
som er ganske dårlig form.

250
00:12:36,660 --> 00:12:39,750
Men det er bare fordi jeg ønsket å være
stand til å passe alt på skjermen.

251
00:12:39,750 --> 00:12:44,360
>> På toppen kan du se at jeg har
to funksjonserklæringer for set utvalg

252
00:12:44,360 --> 00:12:45,820
og satt int.

253
00:12:45,820 --> 00:12:49,680
Set rekke tar tydeligvis en matrise
av fire heltall som sin inngang.

254
00:12:49,680 --> 00:12:52,767
Og sett int tar tilsynelatende
et enkelt heltall som sin inngang.

255
00:12:52,767 --> 00:12:54,350
Men begge har en utgang.

256
00:12:54,350 --> 00:12:57,689
Utgangen, retur
skriver, for hver og en er ugyldig.

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

258
00:12:59,480 --> 00:13:02,730
Vi erklærer et heltall variabel
kalt A og tilordne den verdien 10.

259
00:13:02,730 --> 00:13:07,080
Vi erklærer en rekke fire heltall
kalt B og tildele elementene 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 samtale for å sette
int og en oppfordring til å sette array.

262
00:13:12,190 --> 00:13:15,910
Definisjonene av settet array og sett
int er nede, på bunnen.

263
00:13:15,910 --> 00:13:17,640
>> Og så, igjen, spør jeg deg spørsmålet.

264
00:13:17,640 --> 00:13:20,770
Hva blir skrevet ut
her på slutten av Main?

265
00:13:20,770 --> 00:13:23,020
Det er en utskrift col. Jeg er
skrive ut to heltall.

266
00:13:23,020 --> 00:13:28,010
Jeg skriver ut innholdet av A og
innholdet av B hakeparentes 0.

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

268
00:13:29,880 --> 00:13:35,482
Kan du finne ut hva dette
funksjonen vil skrive ut på slutten?

269
00:13:35,482 --> 00:13:38,190
Forhåpentligvis, hvis du husker
Skillet mellom bestått av verdi

270
00:13:38,190 --> 00:13:41,680
og passerer ved referanse, denne
Problemet var ikke så vanskelig for deg.

271
00:13:41,680 --> 00:13:44,130
Og svaret du ville
har funnet er denne.

272
00:13:44,130 --> 00:13:47,660
Hvis du ikke er helt sikker på at det
hvorfor det er tilfelle, ta en andre,

273
00:13:47,660 --> 00:13:50,620
gå tilbake, se hva jeg var bare
diskutere om bestått arrays

274
00:13:50,620 --> 00:13:53,450
ved referanse, versus passerer
andre variabler av verdi,

275
00:13:53,450 --> 00:13:56,680
og forhåpentligvis vil det gjøre
en litt mer fornuftig.

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

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