1
00:00:00,000 --> 00:00:03,388
>> [RIPRODUZIONE DI BRANI MUSICALI]

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

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

4
00:00:06,020 --> 00:00:07,680
Lavorare con singolo
variabili è piuttosto divertente.

5
00:00:07,680 --> 00:00:09,500
Ma cosa succede se si vuole lavorare
con un sacco di variabili,

6
00:00:09,500 --> 00:00:12,760
ma noi non vogliamo avere un gruppo di
nomi diversi che volano intorno il nostro codice?

7
00:00:12,760 --> 00:00:15,980
In questo caso, gli array sono
andando a venire in veramente utile.

8
00:00:15,980 --> 00:00:19,510
Gli array sono un dato davvero fondamentale
Struttura per qualsiasi linguaggio di programmazione

9
00:00:19,510 --> 00:00:20,260
che si intende utilizzare.

10
00:00:20,260 --> 00:00:24,450
E sono molto, molto utile,
In particolare, come vedremo, in CS 50.

11
00:00:24,450 --> 00:00:27,870
>> Usiamo gli array di tenere
valori dello stesso tipo di dati

12
00:00:27,870 --> 00:00:29,830
a locazioni di memoria contigue.

13
00:00:29,830 --> 00:00:32,430
Vale a dire, è un
modo che possiamo raggruppare

14
00:00:32,430 --> 00:00:35,430
un gruppo di interi insieme a
memoria o un gruppo di personaggi

15
00:00:35,430 --> 00:00:38,270
o galleggianti in memoria davvero
ravvicinati e lavoro

16
00:00:38,270 --> 00:00:41,930
con loro senza dover dare ogni
un suo proprio nome unico, che può

17
00:00:41,930 --> 00:00:44,500
ottenere ingombrante dopo un po 'di tempo.

18
00:00:44,500 --> 00:00:48,130
>> Ora, un modo per analogize array
è quello di pensare al vostro alberino locale

19
00:00:48,130 --> 00:00:49,000
carica per un secondo.

20
00:00:49,000 --> 00:00:51,820
Così passo dalla programmazione
e basta chiudere gli occhi

21
00:00:51,820 --> 00:00:54,120
e visualizzare nella vostra mente
il vostro ufficio postale locale.

22
00:00:54,120 --> 00:00:57,160
Solitamente, in più alberino
uffici, c'è una grande banca

23
00:00:57,160 --> 00:01:00,490
a caselle postali sul muro.

24
00:01:00,490 --> 00:01:03,510
>> Un array è un blocco gigante
di memoria contigua,

25
00:01:03,510 --> 00:01:06,120
allo stesso modo che una e-mail
banca nel vostro ufficio postale

26
00:01:06,120 --> 00:01:11,230
è un grande spazio sulla
parete dell'ufficio postale.

27
00:01:11,230 --> 00:01:15,750
Gli array sono stati partizionati in piccolo,
identicamente blocchi di dimensioni di spazio,

28
00:01:15,750 --> 00:01:19,930
ciascuno dei quali è chiamato un elemento, in
allo stesso modo che la parete del post

29
00:01:19,930 --> 00:01:23,840
ufficio è stato partizionato in piccolo,
identicamente blocchi di dimensioni di spazio,

30
00:01:23,840 --> 00:01:27,560
che noi chiamiamo una casella postale.

31
00:01:27,560 --> 00:01:31,650
Ciascun elemento della matrice può
memorizzare una certa quantità di dati,

32
00:01:31,650 --> 00:01:37,540
proprio come ogni casella postale è in grado
per contenere una certa quantità di posta.

33
00:01:37,540 --> 00:01:41,540
>> Quali possono essere memorizzati in ogni elemento di
l'array è variabili degli stessi dati

34
00:01:41,540 --> 00:01:45,300
tipo, come int o char, semplicemente
come nella vostra casella postale,

35
00:01:45,300 --> 00:01:47,300
si può andare bene solo le cose
di tipo analogo,

36
00:01:47,300 --> 00:01:50,430
quali lettere o piccoli pacchi.

37
00:01:50,430 --> 00:01:55,050
Infine, si può accedere a ogni elemento di
la matrice direttamente in base al numero di indice,

38
00:01:55,050 --> 00:01:59,770
così come possiamo accedere al nostro ufficio postale
box conoscendo il suo numero di casella vocale.

39
00:01:59,770 --> 00:02:02,750
Si spera, che l'analogia
ti aiuta a ottenere la testa

40
00:02:02,750 --> 00:02:05,540
intorno all'idea tra array
in analogia a qualcos'altro

41
00:02:05,540 --> 00:02:08,400
che siete probabilmente
già familiarità.

42
00:02:08,400 --> 00:02:13,182
>> In C, gli elementi di un array sono
indicizzato a partire da 0, non da 1.

43
00:02:13,182 --> 00:02:14,390
E questo è molto importante.

44
00:02:14,390 --> 00:02:18,530
E in effetti, questo è il motivo per cui, in CS 50,
e perché gli informatici frequentemente

45
00:02:18,530 --> 00:02:22,150
conterà da 0, è
a causa della matrice di C

46
00:02:22,150 --> 00:02:24,660
indicizzazione, che inizia sempre a 0.

47
00:02:24,660 --> 00:02:28,730
Quindi, se un array consiste di n elementi,
il primo elemento di tale matrice

48
00:02:28,730 --> 00:02:32,960
è situato in corrispondenza dell'indice 0, e
l'ultimo elemento dell'array

49
00:02:32,960 --> 00:02:36,610
si trova nella posizione di indice n meno 1.

50
00:02:36,610 --> 00:02:43,160
Anche in questo caso, se ci sono n elementi nel nostro
matrice, l'ultimo indice è n meno 1.

51
00:02:43,160 --> 00:02:46,820
>> Quindi, se il nostro array ha 50 elementi, i
primo elemento si trova in corrispondenza dell'indice 0,

52
00:02:46,820 --> 00:02:51,060
e l'ultimo elemento
si trova a 49 dell'indice.

53
00:02:51,060 --> 00:02:53,940
Purtroppo, o per fortuna,
a seconda della prospettiva,

54
00:02:53,940 --> 00:02:56,170
C è molto indulgente qui.

55
00:02:56,170 --> 00:02:59,480
Non ti impedirà di
uscire dai limiti della propria matrice.

56
00:02:59,480 --> 00:03:03,080
Si potrebbe accedere al meno
3 elemento dell'array

57
00:03:03,080 --> 00:03:07,400
o l'elemento 59a dell'array,
se la matrice ha solo 50 elementi.

58
00:03:07,400 --> 00:03:11,060
Essa non si fermerà il vostro programma da
compilazione, ma in fase di esecuzione,

59
00:03:11,060 --> 00:03:14,350
si potrebbe incontrare un
segmentation fault temuto

60
00:03:14,350 --> 00:03:17,460
se si inizia a accedere alla memoria
cioè al di fuori dei limiti di ciò che

61
00:03:17,460 --> 00:03:19,260
lei ha chiesto il vostro programma per darvi.

62
00:03:19,260 --> 00:03:21,250
Quindi state attenti.

63
00:03:21,250 --> 00:03:23,120
>> Che cosa fa di un array
dichiarazione simile?

64
00:03:23,120 --> 00:03:26,940
Come facciamo a codifichiamo un array in esistenza
come codifichiamo qualsiasi altra variabile?

65
00:03:26,940 --> 00:03:31,250
Ci sono tre parti ad un array
declaration-- un tipo, un nome,

66
00:03:31,250 --> 00:03:31,880
e una dimensione.

67
00:03:31,880 --> 00:03:34,088
Questo è molto simile a un
dichiarazione di variabile, che

68
00:03:34,088 --> 00:03:36,970
è solo un tipo e un nome,
l'elemento di dimensioni essere

69
00:03:36,970 --> 00:03:39,860
il caso particolare di un array,
perché stiamo ottenendo un po 'di loro

70
00:03:39,860 --> 00:03:41,830
allo stesso tempo.

71
00:03:41,830 --> 00:03:45,560
>> Così il tipo è che tipo di variabile
vuole ogni elemento della matrice di essere.

72
00:03:45,560 --> 00:03:47,150
Non voglio che un array di interi?

73
00:03:47,150 --> 00:03:49,010
Poi, il tipo di dati dovrebbe essere int.

74
00:03:49,010 --> 00:03:51,760
Vuoi che sia un
serie di doppie o galleggianti?

75
00:03:51,760 --> 00:03:54,545
Tipo di dati dovrebbe essere doppia o galleggiare.

76
00:03:54,545 --> 00:03:56,420
Il nome è quello che
desidera chiamare l'array.

77
00:03:56,420 --> 00:04:00,970
Che cosa si desidera denominare questo gigante
banca di numeri interi o galleggianti o caratteri

78
00:04:00,970 --> 00:04:03,250
o doppie, o qualsiasi altra cosa hai?

79
00:04:03,250 --> 00:04:04,700
Che cosa si voglia chiamare?

80
00:04:04,700 --> 00:04:06,110
Piuttosto auto esplicativo.

81
00:04:06,110 --> 00:04:08,610
>> Infine, le dimensioni, che va
all'interno di parentesi quadre,

82
00:04:08,610 --> 00:04:12,180
è quanti elementi si farebbe
come l'array per contenere.

83
00:04:12,180 --> 00:04:13,530
Quanti interi vuoi?

84
00:04:13,530 --> 00:04:15,570
Quanti galleggianti vuoi?

85
00:04:15,570 --> 00:04:19,070
>> Così, per esempio, int voti degli studenti 40.

86
00:04:19,070 --> 00:04:26,020
Questo dichiara un array chiamato Student
gradi, che consiste di 40 numeri interi.

87
00:04:26,020 --> 00:04:28,180
Piuttosto auto esplicativo, spero.

88
00:04:28,180 --> 00:04:29,330
Ecco un altro esempio.

89
00:04:29,330 --> 00:04:31,560
Prezzi del menu doppie 8.

90
00:04:31,560 --> 00:04:34,610
Questo crea un array chiamato
Menu a prezzo fisso, che consiste

91
00:04:34,610 --> 00:04:38,300
di spazio in memoria per otto doppie.

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

93
00:04:42,000 --> 00:04:45,750
>> Se si pensa di ogni elemento
di una matrice di tipo-tipo di dati,

94
00:04:45,750 --> 00:04:49,860
così, per esempio, un singolo elemento di
un array di tipo int, allo stesso modo si

95
00:04:49,860 --> 00:04:52,770
potrebbe pensare a qualsiasi altra
variabile di tipo int,

96
00:04:52,770 --> 00:04:56,440
tutte le operazioni noti che
discusso in precedenza nelle operazioni

97
00:04:56,440 --> 00:04:58,270
il video avrà un senso.

98
00:04:58,270 --> 00:05:01,620
Così qui, potremmo dichiarare un array
di booleani chiamati Truthtable,

99
00:05:01,620 --> 00:05:05,590
che consiste di spazio per 10 booleani.

100
00:05:05,590 --> 00:05:09,650
>> E poi, proprio come potremmo assegnare
un valore a qualsiasi altra variabile di tipo

101
00:05:09,650 --> 00:05:13,470
Booleano, potremmo dire qualcosa
come Truthtable parentesi quadra

102
00:05:13,470 --> 00:05:18,040
2, che è come indichiamo,
quale elemento della tabella di verità?

103
00:05:18,040 --> 00:05:20,350
Il terzo elemento del
tabella di verità, perché ricordate,

104
00:05:20,350 --> 00:05:21,800
contiamo da 0.

105
00:05:21,800 --> 00:05:25,690
Ecco, questo è il modo in cui viene indicato il
terzo elemento della tabella di verità.

106
00:05:25,690 --> 00:05:28,680
Truthtable 2 è uguale a falso,
proprio come potremmo declare--

107
00:05:28,680 --> 00:05:33,560
o potremmo cedere, anzi, qualsiasi
Variabile di tipo booleano di essere falso.

108
00:05:33,560 --> 00:05:35,050
>> Possiamo anche usarlo in condizioni.

109
00:05:35,050 --> 00:05:39,000
if (truthtable 7 ==
true), vale a dire,

110
00:05:39,000 --> 00:05:42,370
se l'ottavo elemento
di Truthtable è vero,

111
00:05:42,370 --> 00:05:46,760
forse si vuole stampare un messaggio
per l'utente, printf ("TRUE! n") ;.

112
00:05:46,760 --> 00:05:50,290
Questo ci induce a dire Truthtable
10 è uguale a vero, giusto?

113
00:05:50,290 --> 00:05:53,590
Beh, posso, ma è abbastanza
pericoloso, perché ricordate,

114
00:05:53,590 --> 00:05:56,260
abbiamo un array di 10 booleani.

115
00:05:56,260 --> 00:06:02,340
Così il più alto indice che il
compilatore ci ha dato è 9.

116
00:06:02,340 --> 00:06:06,010
>> Questo programma verrà compilato, ma
se qualcosa in memoria

117
00:06:06,010 --> 00:06:09,110
esiste dove ci sarebbe
aspettano Truthtable 10 per andare,

118
00:06:09,110 --> 00:06:13,980
potremmo subire un segmentation fault. Noi
potrebbe farla franca, ma in generale,

119
00:06:13,980 --> 00:06:14,710
abbastanza pericoloso.

120
00:06:14,710 --> 00:06:19,759
Quindi quello che sto facendo qui è C legale,
ma non necessariamente la migliore mossa.

121
00:06:19,759 --> 00:06:22,300
Ora, quando si dichiara e
inizializzare un array contemporaneamente,

122
00:06:22,300 --> 00:06:23,960
c'è in realtà una bella
sintassi speciale che si

123
00:06:23,960 --> 00:06:26,250
possono utilizzare per riempire l'array
con i suoi valori di partenza.

124
00:06:26,250 --> 00:06:30,130
Si può ottenere ingombrante per
dichiarare un array di dimensioni 100,

125
00:06:30,130 --> 00:06:33,430
e poi devo dire, elemento 0
è uguale a questo; Elemento 1 è uguale a questo;

126
00:06:33,430 --> 00:06:34,850
elemento 2 è uguale a quello.

127
00:06:34,850 --> 00:06:36,370
Qual è il punto, giusto?

128
00:06:36,370 --> 00:06:39,470
>> Se si tratta di un piccolo array, si
potrebbe fare qualcosa di simile.

129
00:06:39,470 --> 00:06:44,360
Bool truthtable 3 è uguale aperto
parentesi graffa e quindi virgola

130
00:06:44,360 --> 00:06:48,060
separare la lista di elementi
che si desidera inserire nella matrice.

131
00:06:48,060 --> 00:06:50,520
Quindi chiudere riccio brace e virgola.

132
00:06:50,520 --> 00:06:53,910
Questo crea una serie di
tre dimensioni chiamato Truthtable,

133
00:06:53,910 --> 00:06:56,090
con elementi falso, vero, e vero.

134
00:06:56,090 --> 00:06:59,270
Ed infatti, l'istanziazione
sintassi che ho qui è

135
00:06:59,270 --> 00:07:03,350
esattamente lo stesso di fare il
sintassi singolo elemento sotto.

136
00:07:03,350 --> 00:07:09,380
Questi due modi di codifica sarebbe
produrre la stessa matrice.

137
00:07:09,380 --> 00:07:11,740
>> Allo stesso modo, si potrebbe iterare
su tutti gli elementi

138
00:07:11,740 --> 00:07:15,400
di un array usando un ciclo, che,
Infatti, è fortemente consigliata

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

140
00:07:16,790 --> 00:07:20,720
Come si fa a creare un array
di 100 numeri interi, dove

141
00:07:20,720 --> 00:07:23,477
ogni elemento dell'array è proprio indice?

142
00:07:23,477 --> 00:07:26,560
Così, per esempio, abbiamo una gamma di 100
interi, e nel primo elemento,

143
00:07:26,560 --> 00:07:27,790
vogliamo mettere 0.

144
00:07:27,790 --> 00:07:29,810
Nel secondo elemento, vogliamo mettere 1.

145
00:07:29,810 --> 00:07:33,319
Nel terzo elemento, vogliamo
mettere 2; e così via e così via.

146
00:07:33,319 --> 00:07:35,360
Questo è davvero un buon
at-home esercizio per farlo.

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

148
00:07:38,190 --> 00:07:40,220
>> Qui, non sembra
come troppo è cambiato.

149
00:07:40,220 --> 00:07:44,170
Meno di notare che tra il
parentesi quadre, questa volta,

150
00:07:44,170 --> 00:07:45,830
In realtà ho omesso il numero.

151
00:07:45,830 --> 00:07:48,000
Se si sta utilizzando questo molto
istanziazione speciale

152
00:07:48,000 --> 00:07:50,380
sintassi per creare un
array, in realtà non lo fanno

153
00:07:50,380 --> 00:07:53,491
necessario per indicare la dimensione
dell'array anticipo.

154
00:07:53,491 --> 00:07:55,740
Il compilatore è abbastanza intelligente
a sapere che in realtà

155
00:07:55,740 --> 00:07:58,980
vuole un array di dimensione 3,
perché si mette tre elementi

156
00:07:58,980 --> 00:08:00,640
alla destra del segno uguale.

157
00:08:00,640 --> 00:08:04,140
Se tu avessi messo quattro, avrebbe
dato una tabella di verità di dimensioni quattro;

158
00:08:04,140 --> 00:08:06,270
e così via e così via.

159
00:08:06,270 --> 00:08:09,380
>> Gli array non sono limitati ad un unico
dimensione, che è piuttosto fresco.

160
00:08:09,380 --> 00:08:12,000
Si può effettivamente avere come molti
prescrittori laterali come si desidera.

161
00:08:12,000 --> 00:08:16,470
Così, per esempio, se si desidera creare
una scheda per il gioco Battleship, il quale,

162
00:08:16,470 --> 00:08:20,910
Se avete mai giocato, è un gioco che è
giocato con pioli sul 10 per 10 griglia,

163
00:08:20,910 --> 00:08:22,450
è possibile creare un array come questo.

164
00:08:22,450 --> 00:08:26,030
Si potrebbe dire Bool
corazzata parentesi quadra 10

165
00:08:26,030 --> 00:08:29,590
chiuso square Parentesi quadra
staffa 10 chiusa parentesi quadra.

166
00:08:29,590 --> 00:08:32,710
>> E poi, si può scegliere di
interpretare questo nella vostra mente come 10

167
00:08:32,710 --> 00:08:35,576
da 10 griglia di celle.

168
00:08:35,576 --> 00:08:37,409
Ora, infatti, nella memoria,
lo fa davvero solo

169
00:08:37,409 --> 00:08:42,440
rimanere un elemento 100,
unico array bidimensionale.

170
00:08:42,440 --> 00:08:46,070
E questo, infatti, va per se
avere tre dimensioni o quattro o cinque.

171
00:08:46,070 --> 00:08:49,420
E 'davvero solo fa moltiplicare
tutti i indices--

172
00:08:49,420 --> 00:08:51,130
o tutte le dimensioni
specifiers-- insieme,

173
00:08:51,130 --> 00:08:53,480
e basta avere un unidimensionale
array di dimensioni.

174
00:08:53,480 --> 00:08:57,090
>> Ma in termini di organizzazione e di
visualizzazione e percezione umana,

175
00:08:57,090 --> 00:08:59,240
può essere molto più facile
lavorare con una griglia

176
00:08:59,240 --> 00:09:02,980
se stai lavorando su un gioco
come Tic-tac-toe o Battleship,

177
00:09:02,980 --> 00:09:05,179
o qualcosa di simile.

178
00:09:05,179 --> 00:09:06,970
E 'una grande astrazione,
invece di avere

179
00:09:06,970 --> 00:09:09,340
pensare a un Tic-tac-toe
bordo come una linea di nove

180
00:09:09,340 --> 00:09:13,810
quadrati o una scheda di Battleship
come una linea di 100 quadrati.

181
00:09:13,810 --> 00:09:16,010
A 10 da 10 griglia o tre
per tre griglia è probabilmente

182
00:09:16,010 --> 00:09:17,225
molto più facile da percepire.

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

184
00:09:19,820 --> 00:09:22,280
>> Ora, qualcosa di veramente
importante sugli array.

185
00:09:22,280 --> 00:09:25,950
Siamo in grado di trattare ogni individuo
elemento dell'array come variabile.

186
00:09:25,950 --> 00:09:27,700
Abbiamo visto che in precedenza
quando stavamo assegnando

187
00:09:27,700 --> 00:09:32,240
il valore True per certi booleani
o testarli in condizionali.

188
00:09:32,240 --> 00:09:35,960
Ma non possiamo trattare tutto
a loro volta array come variabili.

189
00:09:35,960 --> 00:09:41,760
Non possiamo, per esempio, assegnare un array
ad un altro array utilizzando l'assegnazione

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

191
00:09:42,930 --> 00:09:44,640
Non è C. legale

192
00:09:44,640 --> 00:09:47,920
>> Se vogliamo, per quanto example--
avremmo fatto in questo esempio

193
00:09:47,920 --> 00:09:50,200
sarebbe copiare un array in un altro.

194
00:09:50,200 --> 00:09:53,810
Se vogliamo fare questo, abbiamo in realtà
necessario utilizzare un ciclo per copiare

195
00:09:53,810 --> 00:09:56,550
ogni singolo elemento alla volta.

196
00:09:56,550 --> 00:09:58,700
So che è un po 'di tempo.

197
00:09:58,700 --> 00:10:04,022
>> Così, per esempio, se avessimo questi coppia
di linee di codice, sarebbe questo lavoro?

198
00:10:04,022 --> 00:10:05,230
Beh, no, non sarebbe, giusto?

199
00:10:05,230 --> 00:10:07,860
Perché noi stiamo cercando
per assegnare cibo per bar.

200
00:10:07,860 --> 00:10:09,860
Che non sta andando a lavorare,
perché è un array,

201
00:10:09,860 --> 00:10:13,130
e abbiamo appena descritto
che questo non è legale C.

202
00:10:13,130 --> 00:10:15,580
>> Invece, se vogliamo
copiare il contenuto di cibo

203
00:10:15,580 --> 00:10:18,070
in bar, che è ciò che
stiamo cercando di fare qui,

204
00:10:18,070 --> 00:10:19,970
avremmo bisogno di una sintassi del genere.

205
00:10:19,970 --> 00:10:24,170
Abbiamo un ciclo for che va
da J è uguale a 0 fino a 5,

206
00:10:24,170 --> 00:10:28,390
e incrementiamo J su ogni iterazione
il ciclo e gli elementi assegnare genere.

207
00:10:28,390 --> 00:10:33,360
Ciò si tradurrebbe in bar anche
essendo uno, due, tre, quattro, cinque,

208
00:10:33,360 --> 00:10:36,730
ma dobbiamo farlo in questo molto
modo lento elemento per elemento,

209
00:10:36,730 --> 00:10:40,009
anziché semplicemente
copiare l'intero array.

210
00:10:40,009 --> 00:10:42,050
In altri programmi
lingue, quelle più moderne,

211
00:10:42,050 --> 00:10:45,610
è possibile, infatti, fare proprio
che equivale semplice sintassi.

212
00:10:45,610 --> 00:10:49,620
Ma C, purtroppo, siamo
non ha permesso di farlo.

213
00:10:49,620 --> 00:10:52,026
>> Ora, c'è un altro
cosa che voglio citare

214
00:10:52,026 --> 00:10:54,650
sugli array che può essere un po '
po 'complicato la prima volta che si

215
00:10:54,650 --> 00:10:55,990
lavorare con loro.

216
00:10:55,990 --> 00:10:59,860
Abbiamo discusso in un video
su scope delle variabili,

217
00:10:59,860 --> 00:11:04,940
che la maggior parte delle variabili in C, quando si chiama
loro funzioni, sono passati per valore.

218
00:11:04,940 --> 00:11:08,620
Ti ricordi che cosa significa
di passare qualcosa per valore?

219
00:11:08,620 --> 00:11:12,570
Significa che stiamo facendo una copia del
variabile che viene passata in.

220
00:11:12,570 --> 00:11:16,290
La funzione callee, la funzione
che sta ricevendo la variabile,

221
00:11:16,290 --> 00:11:17,730
non ottiene la variabile stessa.

222
00:11:17,730 --> 00:11:20,850
Ottiene il suo locale
copia di esso per lavorare con.

223
00:11:20,850 --> 00:11:24,070
>> Array, naturalmente, fanno
non seguire questa regola.

224
00:11:24,070 --> 00:11:27,600
Piuttosto, ciò che noi chiamiamo questo
è il passaggio per riferimento.

225
00:11:27,600 --> 00:11:31,360
Il chiamato in realtà
non riceve l'array.

226
00:11:31,360 --> 00:11:34,207
Non riceve la sua
copia locale di esso.

227
00:11:34,207 --> 00:11:36,040
E se ci pensate
esso, questo ha un senso.

228
00:11:36,040 --> 00:11:39,750
Se gli array sono molto grandi, è
prende così tanto tempo e fatica

229
00:11:39,750 --> 00:11:44,470
per fare una copia di una serie di
100 o 1.000 o 10.000 elementi,

230
00:11:44,470 --> 00:11:48,290
che non vale la pena di
funzione per ricevere una copia di esso,

231
00:11:48,290 --> 00:11:51,037
fare un certo lavoro con esso, e poi
solo essere fatto con la copia;

232
00:11:51,037 --> 00:11:53,120
non ha bisogno di avere
appeso più in giro.

233
00:11:53,120 --> 00:11:54,710
>> Perché gli array sono alcuni
voluminosi e ingombranti,

234
00:11:54,710 --> 00:11:56,001
ci passiamo per riferimento.

235
00:11:56,001 --> 00:12:01,210
Abbiamo appena Confidiamo che la funzione
a, non rompere nulla.

236
00:12:01,210 --> 00:12:03,010
In modo che effettivamente ottenere la matrice.

237
00:12:03,010 --> 00:12:05,290
Non ottiene la propria copia locale di esso.

238
00:12:05,290 --> 00:12:07,170
>> Che cosa significa questo,
poi, quando il chiamato

239
00:12:07,170 --> 00:12:08,970
manipola elementi dell'array?

240
00:12:08,970 --> 00:12:10,780
Che succede?

241
00:12:10,780 --> 00:12:13,210
Per ora, ci ignoreremo
sul perché esattamente questo

242
00:12:13,210 --> 00:12:15,320
accade, perché gli array
sono passati per riferimento

243
00:12:15,320 --> 00:12:17,810
e tutto il resto è passato per valore.

244
00:12:17,810 --> 00:12:20,470
Ma vi prometto, ci sarà
tornare e vi darà la risposta

245
00:12:20,470 --> 00:12:23,750
a questo in un video successiva.

246
00:12:23,750 --> 00:12:28,110
>> Qui è un altro esercizio per voi
prima di concludere le cose su array.

247
00:12:28,110 --> 00:12:31,400
Il mucchio di codice qui, che è
non particolarmente buono stile,

248
00:12:31,400 --> 00:12:33,400
solo Farò che caveat.

249
00:12:33,400 --> 00:12:36,660
Non ci sono commenti qui,
che è piuttosto male modulo.

250
00:12:36,660 --> 00:12:39,750
Ma è solo perché volevo essere
in grado di adattare tutto sullo schermo.

251
00:12:39,750 --> 00:12:44,360
>> Nella parte superiore, si può vedere che ho
due dichiarazioni di funzione per matrice set

252
00:12:44,360 --> 00:12:45,820
e impostare int.

253
00:12:45,820 --> 00:12:49,680
Set matrice prende apparentemente un array
di quattro interi come il suo ingresso.

254
00:12:49,680 --> 00:12:52,767
E insieme int prende apparentemente
un singolo intero come input.

255
00:12:52,767 --> 00:12:54,350
Ma entrambi non hanno un output.

256
00:12:54,350 --> 00:12:57,689
L'uscita, il ritorno
tipo, di ognuno è nullo.

257
00:12:57,689 --> 00:12:59,480
In principale, abbiamo un
paio di linee di codice.

258
00:12:59,480 --> 00:13:02,730
Noi dichiariamo una variabile intera
chiamato A e assegnare il valore 10.

259
00:13:02,730 --> 00:13:07,080
Noi dichiariamo un array di quattro interi
chiamato B e assegnare gli elementi 0, 1,

260
00:13:07,080 --> 00:13:08,730
2 e 3, rispettivamente.

261
00:13:08,730 --> 00:13:12,190
Poi, abbiamo una chiamata per impostare
int e un appello per impostare array.

262
00:13:12,190 --> 00:13:15,910
Le definizioni di matrice set e set
int è basso, in basso.

263
00:13:15,910 --> 00:13:17,640
>> E così, di nuovo, vi chiedo la domanda.

264
00:13:17,640 --> 00:13:20,770
Che cosa viene stampato
qui alla fine del Main?

265
00:13:20,770 --> 00:13:23,020
C'è una col stampa. sono
stampare due interi.

266
00:13:23,020 --> 00:13:28,010
Sto stampare il contenuto di A e
il contenuto di B piazza staffa 0.

267
00:13:28,010 --> 00:13:29,880
Mettere in pausa il video qui e prendere un minuto.

268
00:13:29,880 --> 00:13:35,482
Riuscite a capire cosa questo
funzione di stampa alla fine?

269
00:13:35,482 --> 00:13:38,190
Speriamo che, se vi ricordate la
distinzione tra passaggio per valore

270
00:13:38,190 --> 00:13:41,680
e il passaggio per riferimento, questo
problema non era troppo difficile per voi.

271
00:13:41,680 --> 00:13:44,130
E la risposta si farebbe
ho trovato è questa.

272
00:13:44,130 --> 00:13:47,660
Se non siete veramente sicuri come a
perché questo è il caso, prendere un secondo,

273
00:13:47,660 --> 00:13:50,620
tornare indietro, rivedere quello che ero solo
discutere di passaggio di array

274
00:13:50,620 --> 00:13:53,450
per riferimento, rispetto passando
altre variabili per valore,

275
00:13:53,450 --> 00:13:56,680
e, si spera, farà
un po 'più senso.

276
00:13:56,680 --> 00:13:59,760
>> Sono Doug Lloyd, e questo è CS50.

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