1
00:00:00,000 --> 00:00:03,388
>> [MUSIK SPELA]

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

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

4
00:00:06,020 --> 00:00:07,680
Att arbeta med enkel
variabler är ganska kul.

5
00:00:07,680 --> 00:00:09,500
Men vad händer om vi vill arbeta
med många variabler,

6
00:00:09,500 --> 00:00:12,760
men vi vill inte ha en massa
olika namn flyger runt vår kod?

7
00:00:12,760 --> 00:00:15,980
I detta fall, arrayer är
kommer att komma i riktigt händig.

8
00:00:15,980 --> 00:00:19,510
Arrayer är en riktigt grundläggande uppgifter
struktur för alla programmeringsspråk

9
00:00:19,510 --> 00:00:20,260
att du kommer att använda.

10
00:00:20,260 --> 00:00:24,450
Och de är riktigt, riktigt bra,
särskilt som vi får se i CS 50.

11
00:00:24,450 --> 00:00:27,870
>> Vi använder arrayer för att hålla
värden av samma datatyp

12
00:00:27,870 --> 00:00:29,830
på intilliggande minnesplatser.

13
00:00:29,830 --> 00:00:32,430
Det vill säga, det är en
sätt som vi kan gruppera

14
00:00:32,430 --> 00:00:35,430
ett gäng heltal tillsammans
minne eller ett gäng tecken

15
00:00:35,430 --> 00:00:38,270
eller flyter i minnet verkligen
nära varandra och arbeta

16
00:00:38,270 --> 00:00:41,930
med dem utan att behöva ge varje
ett eget unikt namn, som kan

17
00:00:41,930 --> 00:00:44,500
få besvärligt efter en liten stund.

18
00:00:44,500 --> 00:00:48,130
>> Nu, ett sätt att analogize arrayer
är att tänka på din lokal postar

19
00:00:48,130 --> 00:00:49,000
kontor för en sekund.

20
00:00:49,000 --> 00:00:51,820
Så steg bort från programmering
och bara blunda

21
00:00:51,820 --> 00:00:54,120
och visualisera i ditt sinne
ditt lokala postkontor.

22
00:00:54,120 --> 00:00:57,160
Vanligtvis i de flesta inlägg
kontor, det finns en stor bank

23
00:00:57,160 --> 00:01:00,490
en postboxar på väggen.

24
00:01:00,490 --> 00:01:03,510
>> En array är en jätte-block
sammanhängande minne,

25
00:01:03,510 --> 00:01:06,120
på samma sätt som en post
bank i postkontoret

26
00:01:06,120 --> 00:01:11,230
är ett stort utrymme på
vägg av postkontoret.

27
00:01:11,230 --> 00:01:15,750
Arrayer har uppdelad i små,
identiskt stora block av utrymme,

28
00:01:15,750 --> 00:01:19,930
vilka var och en kallas ett element, i
på samma sätt att väggen av stolpen

29
00:01:19,930 --> 00:01:23,840
kontor har uppdelad i små,
identiskt stora block av utrymme,

30
00:01:23,840 --> 00:01:27,560
som vi kallar en postbox.

31
00:01:27,560 --> 00:01:31,650
Varje element i arrayen kan
lagra en viss mängd data,

32
00:01:31,650 --> 00:01:37,540
precis som varje postbox kan
att hålla en viss mängd post.

33
00:01:37,540 --> 00:01:41,540
>> Vad som kan lagras i varje element i
matrisen är variabler av samma data

34
00:01:41,540 --> 00:01:45,300
typ, såsom int eller char, bara
som i ditt postbox,

35
00:01:45,300 --> 00:01:47,300
du kan bara passa saker
av en liknande typ,

36
00:01:47,300 --> 00:01:50,430
såsom bokstäver eller små förpackningar.

37
00:01:50,430 --> 00:01:55,050
Slutligen kan vi komma åt varje del av
arrayen direkt efter indexvärde,

38
00:01:55,050 --> 00:01:59,770
precis som vi kan få tillgång till vår postkontoret
box genom att känna sin brevlåda.

39
00:01:59,770 --> 00:02:02,750
Förhoppningsvis analogi som
hjälper dig att få ditt huvud

40
00:02:02,750 --> 00:02:05,540
kring idén om matriser av
analogizing till något annat

41
00:02:05,540 --> 00:02:08,400
att du förmodligen
redan är bekant med.

42
00:02:08,400 --> 00:02:13,182
>> I C, elementen i en array är
indexeras med utgångspunkt från 0, inte från en.

43
00:02:13,182 --> 00:02:14,390
Och det är verkligen viktigt.

44
00:02:14,390 --> 00:02:18,530
Och i själva verket är detta anledningen till att vi, i CS 50,
och varför datavetare ofta

45
00:02:18,530 --> 00:02:22,150
kommer att räknas från 0, är
på grund av C: s array

46
00:02:22,150 --> 00:02:24,660
indexering, som alltid börjar på 0.

47
00:02:24,660 --> 00:02:28,730
Så om en matris består av n element,
det första elementet i den matris

48
00:02:28,730 --> 00:02:32,960
ligger på index 0, och
det sista elementet i arrayen

49
00:02:32,960 --> 00:02:36,610
ligger vid index n minus ett.

50
00:02:36,610 --> 00:02:43,160
Återigen, om det finns n element i vår
array, är det sista indexet n minus 1.

51
00:02:43,160 --> 00:02:46,820
>> Så om vår array har 50 element, de
första elementet ligger på index 0,

52
00:02:46,820 --> 00:02:51,060
och det sista elementet
ligger på index 49.

53
00:02:51,060 --> 00:02:53,940
Tyvärr, eller lyckligtvis,
beroende på ditt perspektiv,

54
00:02:53,940 --> 00:02:56,170
C är mycket mildare här.

55
00:02:56,170 --> 00:02:59,480
Det kommer inte att hindra dig från att
gå out of bounds på din array.

56
00:02:59,480 --> 00:03:03,080
Du kan komma åt minus
3 del av din samling

57
00:03:03,080 --> 00:03:07,400
eller den 59: e del av din samling,
Om din array har endast 50 element.

58
00:03:07,400 --> 00:03:11,060
Det kommer inte att sluta ditt program från
sammanställa, men vid körning,

59
00:03:11,060 --> 00:03:14,350
du kan stöta på en
fruktade segmente fel

60
00:03:14,350 --> 00:03:17,460
Om du börjar att få tillgång till minne
som ligger utanför gränserna för vad

61
00:03:17,460 --> 00:03:19,260
du bad ditt program för att ge dig.

62
00:03:19,260 --> 00:03:21,250
Så var försiktig.

63
00:03:21,250 --> 00:03:23,120
>> Vad gör en array
deklaration ser ut?

64
00:03:23,120 --> 00:03:26,940
Hur kan vi koda en array till existens
som vi koda någon annan variabel?

65
00:03:26,940 --> 00:03:31,250
Det finns tre delar till en matris
declaration-- en typ, ett namn,

66
00:03:31,250 --> 00:03:31,880
och en storlek.

67
00:03:31,880 --> 00:03:34,088
Detta är mycket likt en
variabel deklaration, som

68
00:03:34,088 --> 00:03:36,970
är bara en typ och ett namn,
storleken elementet är

69
00:03:36,970 --> 00:03:39,860
specialfallet för en array,
eftersom vi får ett gäng av dem

70
00:03:39,860 --> 00:03:41,830
på samma gång.

71
00:03:41,830 --> 00:03:45,560
>> Så typen är vilken typ av variabel du
vill att varje element i arrayen att vara.

72
00:03:45,560 --> 00:03:47,150
Vill att det ska en rad heltal?

73
00:03:47,150 --> 00:03:49,010
Då bör din datatyp vara int.

74
00:03:49,010 --> 00:03:51,760
Vill du att det ska vara en
uppsättning av dubblar eller flyter?

75
00:03:51,760 --> 00:03:54,545
Datatyp bör vara dubbelt eller flyta.

76
00:03:54,545 --> 00:03:56,420
Namnet är vad du
vill ringa din array.

77
00:03:56,420 --> 00:04:00,970
Vad vill du namnge denna jätte
bank av heltal eller flöten eller tecken

78
00:04:00,970 --> 00:04:03,250
eller dubbel, eller vad har du?

79
00:04:03,250 --> 00:04:04,700
Vad vill du kalla det?

80
00:04:04,700 --> 00:04:06,110
Ganska självförklarande.

81
00:04:06,110 --> 00:04:08,610
>> Slutligen, storlek, som går
insidan av hakparenteser,

82
00:04:08,610 --> 00:04:12,180
är hur många element som du skulle
som din array för att innehålla.

83
00:04:12,180 --> 00:04:13,530
Hur många heltal vill du ha?

84
00:04:13,530 --> 00:04:15,570
Hur många flottar vill du ha?

85
00:04:15,570 --> 00:04:19,070
>> Så till exempel, int student kvaliteter 40.

86
00:04:19,070 --> 00:04:26,020
Detta förklarar en array med namnet Student
kvaliteter, som består av 40 heltal.

87
00:04:26,020 --> 00:04:28,180
Ganska självförklarande, hoppas jag.

88
00:04:28,180 --> 00:04:29,330
Här är ett annat exempel.

89
00:04:29,330 --> 00:04:31,560
Dubbla priser meny 8.

90
00:04:31,560 --> 00:04:34,610
Detta skapar en array med namnet
Menyn priser, som består

91
00:04:34,610 --> 00:04:38,300
om utrymme i minne för åtta dubbelrum.

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

93
00:04:42,000 --> 00:04:45,750
>> Om du tänker på varje element
av en matris av datatyp-typ,

94
00:04:45,750 --> 00:04:49,860
så till exempel, en enda del av
en rad av typen int, på samma sätt som du

95
00:04:49,860 --> 00:04:52,770
skulle tänka på något annat
variabel av typen int,

96
00:04:52,770 --> 00:04:56,440
alla de välkända verksamheter som vi
diskuterats tidigare i drift

97
00:04:56,440 --> 00:04:58,270
video är meningsfullt.

98
00:04:58,270 --> 00:05:01,620
Så här kan vi förklara en array
av Booleans kallas Truthtable,

99
00:05:01,620 --> 00:05:05,590
som består av rum för 10 Booleans.

100
00:05:05,590 --> 00:05:09,650
>> Och sedan, precis som vi kunde bara tilldela
ett värde till varje annan variabel av typen

101
00:05:09,650 --> 00:05:13,470
Boolean, vi kunde säga något
liknande Truthtable hakparentes

102
00:05:13,470 --> 00:05:18,040
2, vilket är hur vi ange
vilket element av sanningstabellen?

103
00:05:18,040 --> 00:05:20,350
Den tredje delen av den
sanningstabell, eftersom kom ihåg,

104
00:05:20,350 --> 00:05:21,800
vi räknar från 0.

105
00:05:21,800 --> 00:05:25,690
Så det är hur vi anger
tredje delen av sanningstabellen.

106
00:05:25,690 --> 00:05:28,680
Truthtable 2 är lika med falsk,
precis som vi kunde declare--

107
00:05:28,680 --> 00:05:33,560
eller vi kunde överlåta snarare alla
Boolean typ variabel för att vara falsk.

108
00:05:33,560 --> 00:05:35,050
>> Vi kan också använda den under förhållanden.

109
00:05:35,050 --> 00:05:39,000
if (truthtable 7 ==
sant), det vill säga,

110
00:05:39,000 --> 00:05:42,370
om den åttonde elementet
av Truthtable är sant,

111
00:05:42,370 --> 00:05:46,760
kanske vi vill skriva ut ett meddelande
till användaren, printf ("SANT n!") ;.

112
00:05:46,760 --> 00:05:50,290
Det ger oss anledning att säga Truthtable
10 är lika sant, eller hur?

113
00:05:50,290 --> 00:05:53,590
Tja, jag kan, men det är ganska
farlig, eftersom kom ihåg,

114
00:05:53,590 --> 00:05:56,260
vi har en matris med 10 Booleans.

115
00:05:56,260 --> 00:06:02,340
Så den högsta index som
kompilator har gett oss är 9.

116
00:06:02,340 --> 00:06:06,010
>> Detta program kommer att sammanställa, men
om något annat i minnet

117
00:06:06,010 --> 00:06:09,110
föreligger när vi skulle
förväntar Truthtable 10 att gå,

118
00:06:09,110 --> 00:06:13,980
vi kunde drabbas av en segmentering fel. Vi
kan komma undan med det, men i allmänhet,

119
00:06:13,980 --> 00:06:14,710
ganska farligt.

120
00:06:14,710 --> 00:06:19,759
Så vad jag gör här är lagligt C,
men inte nödvändigtvis det bästa draget.

121
00:06:19,759 --> 00:06:22,300
Nu, när du deklarerar och
initiera en array samtidigt,

122
00:06:22,300 --> 00:06:23,960
det finns faktiskt en ganska
speciell syntax som du

123
00:06:23,960 --> 00:06:26,250
kan använda för att fylla upp arrayen
med dess utgångsvärden.

124
00:06:26,250 --> 00:06:30,130
Det kan bli besvärligt att
deklarerar en matris med storlek 100,

125
00:06:30,130 --> 00:06:33,430
och sedan har att säga, element 0
motsvarar detta; elementet 1 motsvarar detta;

126
00:06:33,430 --> 00:06:34,850
elementet 2 är lika med den.

127
00:06:34,850 --> 00:06:36,370
Vad är poängen, eller hur?

128
00:06:36,370 --> 00:06:39,470
>> Om det är en liten samling, du
kunde göra något sånt här.

129
00:06:39,470 --> 00:06:44,360
Bool truthtable tre lika öppen
klammerparentes och sedan komma

130
00:06:44,360 --> 00:06:48,060
separera listan av element
som du vill sätta i matrisen.

131
00:06:48,060 --> 00:06:50,520
Stäng sedan klammerparentes semikolon.

132
00:06:50,520 --> 00:06:53,910
Detta skapar en array av
storlek tre kallas Truthtable,

133
00:06:53,910 --> 00:06:56,090
med inslag falskt, sant och riktigt.

134
00:06:56,090 --> 00:06:59,270
Och i själva verket exemplifiering
syntax jag har här är

135
00:06:59,270 --> 00:07:03,350
exakt samma som att göra den
individuellt element syntax.

136
00:07:03,350 --> 00:07:09,380
Dessa två sätt att kodning skulle
producera exakt samma matris.

137
00:07:09,380 --> 00:07:11,740
>> På liknande sätt skulle vi iterera
över alla element

138
00:07:11,740 --> 00:07:15,400
av en array med användning av en slinga, som i
Faktum är ett mycket starkt rekommenderat

139
00:07:15,400 --> 00:07:16,790
at-home träning.

140
00:07:16,790 --> 00:07:20,720
Hur skapar du en array
av 100 heltal, där

141
00:07:20,720 --> 00:07:23,477
varje element i arrayen är dess index?

142
00:07:23,477 --> 00:07:26,560
Så till exempel har vi en samling av 100
heltal, och i det första elementet,

143
00:07:26,560 --> 00:07:27,790
Vi vill sätta 0.

144
00:07:27,790 --> 00:07:29,810
I den andra delen, vill vi sätta ett.

145
00:07:29,810 --> 00:07:33,319
I den tredje delen, vi vill ha
att sätta 2; och så vidare och så vidare.

146
00:07:33,319 --> 00:07:35,360
Det är en riktigt bra
at-home motion för att göra det.

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

148
00:07:38,190 --> 00:07:40,220
>> Här ser det inte
som alltför mycket har förändrats.

149
00:07:40,220 --> 00:07:44,170
Men märker att mellan
hakparenteser, den här gången,

150
00:07:44,170 --> 00:07:45,830
Jag har faktiskt utelämnas numret.

151
00:07:45,830 --> 00:07:48,000
Om du använder detta mycket
speciell instansiering

152
00:07:48,000 --> 00:07:50,380
syntax för att skapa en
array, du faktiskt inte

153
00:07:50,380 --> 00:07:53,491
behöva ange storleken
av uppsättningen i förväg.

154
00:07:53,491 --> 00:07:55,740
Kompilatorn är smart nog
att veta att du faktiskt

155
00:07:55,740 --> 00:07:58,980
vill ha en rad storlek 3,
eftersom du sätter tre element

156
00:07:58,980 --> 00:08:00,640
till höger om likhetstecknet.

157
00:08:00,640 --> 00:08:04,140
Om du hade lagt fyra, skulle det ha
gett dig en sanningstabell storlek fyra;

158
00:08:04,140 --> 00:08:06,270
och så vidare och så vidare.

159
00:08:06,270 --> 00:08:09,380
>> Arrayer är inte begränsade till en enda
dimension, som är ganska coolt.

160
00:08:09,380 --> 00:08:12,000
Du kan faktiskt ha så många
sidospecifice som du önskar.

161
00:08:12,000 --> 00:08:16,470
Så till exempel, om du vill skapa
en styrelse för spelet Battleship, som

162
00:08:16,470 --> 00:08:20,910
Om du någonsin spelat, är ett spel som är
lekte med pinnar på 10 av 10 rutnät,

163
00:08:20,910 --> 00:08:22,450
du kan skapa en array som denna.

164
00:08:22,450 --> 00:08:26,030
Man kan säga Bool
slagskepp hakparentes 10

165
00:08:26,030 --> 00:08:29,590
sluten hakparentes kvadrat
konsol 10 stängd hakparentes.

166
00:08:29,590 --> 00:08:32,710
>> Och sedan kan du välja att
tolka detta i ditt sinne som en 10

167
00:08:32,710 --> 00:08:35,576
med 10 rutnät av celler.

168
00:08:35,576 --> 00:08:37,409
Nu, i själva verket, i minne,
det verkligen bara

169
00:08:37,409 --> 00:08:42,440
förbli ett 100 element,
enda dimensionell array.

170
00:08:42,440 --> 00:08:46,070
Och detta i själva verket gäller om du
har tre dimensioner eller fyra eller fem.

171
00:08:46,070 --> 00:08:49,420
Det är verkligen bara inte föröka
alla av indices--

172
00:08:49,420 --> 00:08:51,130
eller alla av storleken
specifiers-- tillsammans,

173
00:08:51,130 --> 00:08:53,480
och du bara få en endimensionell
array med den storleken.

174
00:08:53,480 --> 00:08:57,090
>> Men när det gäller organisation och
visualisering och mänsklig perception,

175
00:08:57,090 --> 00:08:59,240
det kan vara en mycket enklare
att arbeta med ett rutnät

176
00:08:59,240 --> 00:09:02,980
Om du arbetar på ett spel
som Tre i rad eller slagskepp,

177
00:09:02,980 --> 00:09:05,179
eller något sådant.

178
00:09:05,179 --> 00:09:06,970
Det är en stor abstraktion,
istället för att ha

179
00:09:06,970 --> 00:09:09,340
att tänka på en Tre i rad
styrelsen som en linje av nio

180
00:09:09,340 --> 00:09:13,810
torg eller en slagskepp styrelse
som en linje av 100 rutor.

181
00:09:13,810 --> 00:09:16,010
En 10 av 10 rutnät eller tre
genom tre rutnät är förmodligen

182
00:09:16,010 --> 00:09:17,225
mycket lättare att uppfatta.

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

184
00:09:19,820 --> 00:09:22,280
>> Nu, något riktigt
viktigt om arrayer.

185
00:09:22,280 --> 00:09:25,950
Vi kan behandla varje enskild
element i arrayen som en variabel.

186
00:09:25,950 --> 00:09:27,700
Vi såg att tidigare
när vi tilldelar

187
00:09:27,700 --> 00:09:32,240
värdet True för vissa Booleans
eller testa dem i villkors.

188
00:09:32,240 --> 00:09:35,960
Men vi kan inte behandla hela
samlingama sig som variabler.

189
00:09:35,960 --> 00:09:41,760
Vi kan till exempel inte tilldela en array
till en annan array med uppdraget

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

191
00:09:42,930 --> 00:09:44,640
Det är inte lagligt C.

192
00:09:44,640 --> 00:09:47,920
>> Om vi ​​vill, för example-- vad
vi skulle göra i detta exempel

193
00:09:47,920 --> 00:09:50,200
skulle vara att kopiera en matris till en annan.

194
00:09:50,200 --> 00:09:53,810
Om vi ​​vill göra det, vi faktiskt
behöver använda en slinga för att kopiera över

195
00:09:53,810 --> 00:09:56,550
varje enskilt element en i taget.

196
00:09:56,550 --> 00:09:58,700
Jag vet att det är lite tidskrävande.

197
00:09:58,700 --> 00:10:04,022
>> Så till exempel, om vi hade dessa par
rader kod, skulle detta arbete?

198
00:10:04,022 --> 00:10:05,230
Tja, nej, skulle det inte, eller hur?

199
00:10:05,230 --> 00:10:07,860
Eftersom vi försöker
att tilldela mat till baren.

200
00:10:07,860 --> 00:10:09,860
Det kommer inte att fungera,
eftersom det är en array,

201
00:10:09,860 --> 00:10:13,130
och vi just beskrivit
att det inte är lagligt C.

202
00:10:13,130 --> 00:10:15,580
>> Istället, om vi vill
kopiera innehållet i livsmedel

203
00:10:15,580 --> 00:10:18,070
i bar, vilket är vad
vi försöker göra här,

204
00:10:18,070 --> 00:10:19,970
Vi skulle behöva en syntax som denna.

205
00:10:19,970 --> 00:10:24,170
Vi har en for-loop som går
från J är lika med 0 till 5,

206
00:10:24,170 --> 00:10:28,390
och vi inkrementera J på varje iteration av
slingan och tilldela element som.

207
00:10:28,390 --> 00:10:33,360
Detta skulle resultera i bar också
vara en, två, tre, fyra, fem,

208
00:10:33,360 --> 00:10:36,730
men vi måste göra det här mycket
långsam inslag-by-elementet sätt,

209
00:10:36,730 --> 00:10:40,009
i stället för genom att bara
kopiera hela uppsättningen.

210
00:10:40,009 --> 00:10:42,050
I andra program
språk, modernare,

211
00:10:42,050 --> 00:10:45,610
du kan faktiskt göra just
Så enkelt är lika med syntax.

212
00:10:45,610 --> 00:10:49,620
Men C, tyvärr, vi är
inte tillåtet att göra det.

213
00:10:49,620 --> 00:10:52,026
>> Nu finns det en annan
jag vill nämna

214
00:10:52,026 --> 00:10:54,650
om arrayer som kan vara lite
lite knepigt första gången du

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

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

217
00:10:59,860 --> 00:11:04,940
att de flesta variabler i C, när du ringer
dem funktioner, passeras av värde.

218
00:11:04,940 --> 00:11:08,620
Minns du vad det betyder
att passera något av värde?

219
00:11:08,620 --> 00:11:12,570
Det betyder att vi gör en kopia av
variabel som är passeras i.

220
00:11:12,570 --> 00:11:16,290
Den uppringda funktionen, funktionen
som är mottagande variabeln,

221
00:11:16,290 --> 00:11:17,730
inte får variabeln själv.

222
00:11:17,730 --> 00:11:20,850
Det blir en egen lokal
kopia av den att arbeta med.

223
00:11:20,850 --> 00:11:24,070
>> Arrayer, naturligtvis, göra
inte följa denna regel.

224
00:11:24,070 --> 00:11:27,600
Snarare, vad vi kallar detta
passerar genom hänvisning.

225
00:11:27,600 --> 00:11:31,360
Den uppringda faktiskt
tar emot uppsättningen.

226
00:11:31,360 --> 00:11:34,207
Det tar inte emot sin
egen lokal kopia av det.

227
00:11:34,207 --> 00:11:36,040
Och om du tycker om
det, gör denna mening.

228
00:11:36,040 --> 00:11:39,750
Om arrayer är riktigt stora, det
tar så mycket tid och ansträngning

229
00:11:39,750 --> 00:11:44,470
att göra en kopia av en grupp av
100 eller 1000 eller 10.000 element,

230
00:11:44,470 --> 00:11:48,290
att det inte är värt det för en
fungera för att få en kopia av det,

231
00:11:48,290 --> 00:11:51,037
göra en del arbete med det, och sedan
bara göras med kopian;

232
00:11:51,037 --> 00:11:53,120
Det behöver inte ha
det hängande runt längre.

233
00:11:53,120 --> 00:11:54,710
>> Eftersom matriser är några
skrymmande och besvärliga,

234
00:11:54,710 --> 00:11:56,001
vi bara förbi dem som referens.

235
00:11:56,001 --> 00:12:01,210
Vi litar bara denna funktion
att inte bryta något.

236
00:12:01,210 --> 00:12:03,010
Så det gör faktiskt få arrayen.

237
00:12:03,010 --> 00:12:05,290
Det kan inte bli sin egen lokala kopia av den.

238
00:12:05,290 --> 00:12:07,170
>> Så vad betyder det,
då, när den uppringda

239
00:12:07,170 --> 00:12:08,970
manipulerar uppsättningens element?

240
00:12:08,970 --> 00:12:10,780
Vad händer?

241
00:12:10,780 --> 00:12:13,210
Nu ska vi glans
över varför just denna

242
00:12:13,210 --> 00:12:15,320
händer, varför arrayer
förs genom hänvisning

243
00:12:15,320 --> 00:12:17,810
och allt annat passeras av värde.

244
00:12:17,810 --> 00:12:20,470
Men jag lovar dig, vi kommer
tillbaka och ge dig svaret

245
00:12:20,470 --> 00:12:23,750
till detta i ett senare video.

246
00:12:23,750 --> 00:12:28,110
>> Här är en mer motion för dig
innan vi avsluta saker på arrayer.

247
00:12:28,110 --> 00:12:31,400
Den massa kod här, det är
inte särskilt bra stil,

248
00:12:31,400 --> 00:12:33,400
bara att jag ska göra det varning.

249
00:12:33,400 --> 00:12:36,660
Det finns inga kommentarer här,
vilket är ganska dålig form.

250
00:12:36,660 --> 00:12:39,750
Men det är bara för att jag ville vara
kunna passa allt på skärmen.

251
00:12:39,750 --> 00:12:44,360
>> På toppen kan du se att jag har
två funktionsdeklarationer för areal array

252
00:12:44,360 --> 00:12:45,820
och ställa in int.

253
00:12:45,820 --> 00:12:49,680
Ställ array tar tydligen en array
av fyra heltal som dess ingång.

254
00:12:49,680 --> 00:12:52,767
Och set int tydligen tar
en enda heltal som dess ingång.

255
00:12:52,767 --> 00:12:54,350
Men båda av dem inte har en utgång.

256
00:12:54,350 --> 00:12:57,689
Utgången avkastningen
typ av var och en är ogiltig.

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

258
00:12:59,480 --> 00:13:02,730
Vi förklarar en heltalsvariabel
kallad A och tilldela det värdet 10.

259
00:13:02,730 --> 00:13:07,080
Vi deklarerar en matris med fyra heltal
kallas B och tilldela elementen 0, 1,

260
00:13:07,080 --> 00:13:08,730
2, och 3, respektive.

261
00:13:08,730 --> 00:13:12,190
Då har vi ett samtal för att ställa in
int och en uppmaning att ställa array.

262
00:13:12,190 --> 00:13:15,910
Definitionerna av set array och set
int är nere på botten.

263
00:13:15,910 --> 00:13:17,640
>> Och så, återigen, jag ber er frågan.

264
00:13:17,640 --> 00:13:20,770
Vad får skrivas ut
här i slutet av Main?

265
00:13:20,770 --> 00:13:23,020
Det finns en utskrift col. Jag är
utskrift av två heltal.

266
00:13:23,020 --> 00:13:28,010
Jag skriva ut innehållet i A och
innehållet i B hakparentes 0.

267
00:13:28,010 --> 00:13:29,880
Pausa videon här och ta en minut.

268
00:13:29,880 --> 00:13:35,482
Kan du räkna ut vad detta
Funktionen kommer ut i slutet?

269
00:13:35,482 --> 00:13:38,190
Förhoppningsvis, om du minns
åtskillnad mellan passerar värde

270
00:13:38,190 --> 00:13:41,680
och passerar genom hänvisning, detta
Problemet var inte alltför svårt för dig.

271
00:13:41,680 --> 00:13:44,130
Och svaret du skulle
har funnit är det här.

272
00:13:44,130 --> 00:13:47,660
Om du inte är riktigt säker på att
varför så är fallet, ta en andra,

273
00:13:47,660 --> 00:13:50,620
gå tillbaka, gå igenom vad jag var bara
diskuterar om passerande arrayer

274
00:13:50,620 --> 00:13:53,450
genom hänvisning, jämfört med att passera
andra variabler av värde,

275
00:13:53,450 --> 00:13:56,680
och förhoppningsvis kommer det göra
lite mer meningsfullt.

276
00:13:56,680 --> 00:13:59,760
>> Jag är Doug Lloyd, och detta är CS50.

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