1
00:00:00,000 --> 00:00:03,388
>> [Jouer de la musique]

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

3
00:00:05,104 --> 00:00:06,020
DOUG LLOYD: Très bien.

4
00:00:06,020 --> 00:00:07,680
Travailler avec un seul
variables est assez amusant.

5
00:00:07,680 --> 00:00:09,500
Mais que faire si nous voulons travailler
avec un grand nombre de variables,

6
00:00:09,500 --> 00:00:12,760
mais nous ne voulons pas avoir un tas de
des noms différents qui volent autour de notre code?

7
00:00:12,760 --> 00:00:15,980
Dans ce cas, les tableaux sont
va venir très pratique.

8
00:00:15,980 --> 00:00:19,510
Les tableaux sont une donnée fondamentale vraiment
la structure pour tout langage de programmation

9
00:00:19,510 --> 00:00:20,260
que vous allez utiliser.

10
00:00:20,260 --> 00:00:24,450
Et ils sont vraiment, vraiment utile,
en particulier, comme nous le verrons, dans CS 50.

11
00:00:24,450 --> 00:00:27,870
>> Nous utilisons des tableaux de tenir
valeurs du même type de données

12
00:00:27,870 --> 00:00:29,830
à des emplacements de mémoire contigus.

13
00:00:29,830 --> 00:00:32,430
Cela revient à dire, il est un
façon que nous pouvons groupe

14
00:00:32,430 --> 00:00:35,430
un tas de entiers ensemble dans
mémoire ou un tas de personnages

15
00:00:35,430 --> 00:00:38,270
ou flotte dans la mémoire vraiment
rapprochées et le travail

16
00:00:38,270 --> 00:00:41,930
avec eux, sans avoir à donner à chaque
un son propre nom unique, qui peut

17
00:00:41,930 --> 00:00:44,500
obtenir lourde après un peu de temps.

18
00:00:44,500 --> 00:00:48,130
>> Maintenant, une façon d'assimiler les tableaux
est de penser à votre poste local

19
00:00:48,130 --> 00:00:49,000
bureau pour une seconde.

20
00:00:49,000 --> 00:00:51,820
Donc, pas loin de la programmation
et il suffit de fermer les yeux

21
00:00:51,820 --> 00:00:54,120
et de visualiser dans votre esprit
votre bureau de poste local.

22
00:00:54,120 --> 00:00:57,160
Habituellement, dans la plupart poste
bureaux, il ya une grande banque

23
00:00:57,160 --> 00:01:00,490
une des boîtes de bureau de poste sur le mur.

24
00:01:00,490 --> 00:01:03,510
>> Un tableau est un bloc géant
de mémoire contiguë,

25
00:01:03,510 --> 00:01:06,120
de la même manière qu'un courrier
banque à votre bureau de poste

26
00:01:06,120 --> 00:01:11,230
est un grand espace sur la
mur du bureau de poste.

27
00:01:11,230 --> 00:01:15,750
Les tableaux ont été partitionné en petite,
blocs de taille identique de l'espace,

28
00:01:15,750 --> 00:01:19,930
dont chacun est appelé un élément, en
de la même manière que la paroi du poteau

29
00:01:19,930 --> 00:01:23,840
bureau a été partitionné en petite,
blocs de taille identique de l'espace,

30
00:01:23,840 --> 00:01:27,560
que nous appelons une boîte postale.

31
00:01:27,560 --> 00:01:31,650
Chaque élément du tableau peut
stocker une certaine quantité de données,

32
00:01:31,650 --> 00:01:37,540
de même que chaque boîte de bureau de poste est en mesure
de tenir un certain nombre de messages.

33
00:01:37,540 --> 00:01:41,540
>> Ce qui peut être stockée dans chaque élément de
le tableau est des variables de même des données

34
00:01:41,540 --> 00:01:45,300
type, comme int ou char, juste
comme dans votre boîte de bureau de poste,

35
00:01:45,300 --> 00:01:47,300
vous ne pouvez ajuster les choses
d'un type similaire,

36
00:01:47,300 --> 00:01:50,430
tels que des lettres ou des petits paquets.

37
00:01:50,430 --> 00:01:55,050
Enfin, nous pouvons accéder à chaque élément du
le tableau directement par numéro d'index,

38
00:01:55,050 --> 00:01:59,770
tout comme nous pouvons accéder à notre bureau de poste
Box par connaître son numéro de boîte aux lettres.

39
00:01:59,770 --> 00:02:02,750
Espérons que, cette analogie
vous aide à obtenir votre tête

40
00:02:02,750 --> 00:02:05,540
autour de l'idée de tableaux par
une analogie à autre chose

41
00:02:05,540 --> 00:02:08,400
que vous êtes probablement
déjà familier avec.

42
00:02:08,400 --> 00:02:13,182
>> En C, les éléments d'un tableau sont
indexés à partir de 0, pas de 1.

43
00:02:13,182 --> 00:02:14,390
Et ce qui est vraiment important.

44
00:02:14,390 --> 00:02:18,530
Et en fait, voilà pourquoi nous, au CS 50,
et pourquoi les scientifiques informatiques fréquemment

45
00:02:18,530 --> 00:02:22,150
comptera de 0, est
en raison de la gamme de C

46
00:02:22,150 --> 00:02:24,660
indexation, qui commence toujours à 0.

47
00:02:24,660 --> 00:02:28,730
Donc, si un réseau est constitué de n éléments,
le premier élément de ce tableau

48
00:02:28,730 --> 00:02:32,960
est situé à l'index 0, et
le dernier élément de la matrice

49
00:02:32,960 --> 00:02:36,610
est situé à l'index n moins 1.

50
00:02:36,610 --> 00:02:43,160
Encore une fois, si il ya n éléments dans notre
tableau, le dernier indice est n moins 1.

51
00:02:43,160 --> 00:02:46,820
>> Donc, si notre réseau dispose de 50 éléments, les
premier élément se trouve à l'index 0,

52
00:02:46,820 --> 00:02:51,060
et le dernier élément
est situé à l'index 49.

53
00:02:51,060 --> 00:02:53,940
Malheureusement, ou heureusement,
en fonction de votre point de vue,

54
00:02:53,940 --> 00:02:56,170
C est très clémente ici.

55
00:02:56,170 --> 00:02:59,480
Il ne sera pas vous empêcher de
sortir des limites de votre tableau.

56
00:02:59,480 --> 00:03:03,080
Vous pouvez accéder au moins
3 élément de votre réseau

57
00:03:03,080 --> 00:03:07,400
ou l'élément 59e de votre tableau,
Si votre réseau ne dispose que de 50 éléments.

58
00:03:07,400 --> 00:03:11,060
Il ne sera pas arrêter votre programme à partir de
la compilation, mais au moment de l'exécution,

59
00:03:11,060 --> 00:03:14,350
vous pouvez rencontrer un
erreur de segmentation redouté

60
00:03:14,350 --> 00:03:17,460
si vous commencez à accéder à la mémoire
qui est en dehors des limites de ce que

61
00:03:17,460 --> 00:03:19,260
vous avez demandé votre programme pour vous donner.

62
00:03:19,260 --> 00:03:21,250
Donc, ne soyez prudent.

63
00:03:21,250 --> 00:03:23,120
>> Qu'est-ce que un tableau
déclaration ressembler?

64
00:03:23,120 --> 00:03:26,940
Comment le code-nous un tableau à l'existence
comme nous codons toute autre variable?

65
00:03:26,940 --> 00:03:31,250
Il ya trois parties à un tableau
declaration-- un type, un nom,

66
00:03:31,250 --> 00:03:31,880
et une taille.

67
00:03:31,880 --> 00:03:34,088
Ceci est très similaire à un
déclaration de variable, qui

68
00:03:34,088 --> 00:03:36,970
est juste un type et un nom,
l'élément de taille étant

69
00:03:36,970 --> 00:03:39,860
le cas spécial pour un tableau,
parce que nous obtenons un tas d'entre eux

70
00:03:39,860 --> 00:03:41,830
en même temps.

71
00:03:41,830 --> 00:03:45,560
>> Donc, le type est ce genre de variable que vous
voulons que chaque élément du tableau soit.

72
00:03:45,560 --> 00:03:47,150
Vous ne voulez à un tableau d'entiers?

73
00:03:47,150 --> 00:03:49,010
Ensuite, votre type de données doit être int.

74
00:03:49,010 --> 00:03:51,760
Voulez-vous que ce soit une
tableau de doubles ou de flotteurs?

75
00:03:51,760 --> 00:03:54,545
Type de données devrait être le double ou flotter.

76
00:03:54,545 --> 00:03:56,420
Le nom est ce que vous
vouloir appeler votre tableau.

77
00:03:56,420 --> 00:04:00,970
Que voulez-vous de nommer ce géant
banque de nombres entiers ou des flotteurs ou des caractères

78
00:04:00,970 --> 00:04:03,250
ou double, ou ce que vous avez?

79
00:04:03,250 --> 00:04:04,700
Que voulez-vous l'appeler?

80
00:04:04,700 --> 00:04:06,110
Assez explicite.

81
00:04:06,110 --> 00:04:08,610
>> Enfin, la taille, ce qui va
l'intérieur de crochets,

82
00:04:08,610 --> 00:04:12,180
est le nombre d'éléments que vous le feriez
comme votre tableau pour contenir.

83
00:04:12,180 --> 00:04:13,530
Combien d'entiers voulez-vous?

84
00:04:13,530 --> 00:04:15,570
Combien de flotteurs voulez-vous?

85
00:04:15,570 --> 00:04:19,070
>> Ainsi, par exemple, int notes des étudiants 40.

86
00:04:19,070 --> 00:04:26,020
Ceci déclare un tableau appelé Étudiant
les qualités, qui se compose de 40 nombres entiers.

87
00:04:26,020 --> 00:04:28,180
Assez explicite, je l'espère.

88
00:04:28,180 --> 00:04:29,330
Voici un autre exemple.

89
00:04:29,330 --> 00:04:31,560
Double prix du menu 8.

90
00:04:31,560 --> 00:04:34,610
Cela crée un tableau appelé
Les prix des menus, qui consiste

91
00:04:34,610 --> 00:04:38,300
de place en mémoire pour huit doubles.

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

93
00:04:42,000 --> 00:04:45,750
>> Si vous pensez que de chaque élément
d'un tableau de type de type de données,

94
00:04:45,750 --> 00:04:49,860
Ainsi, par exemple, un seul élément de
un tableau de type int, de la même manière que vous

95
00:04:49,860 --> 00:04:52,770
penserait de tout autre
variable de type int,

96
00:04:52,770 --> 00:04:56,440
toutes les opérations que l'on familiers
discuté précédemment dans les opérations

97
00:04:56,440 --> 00:04:58,270
vidéo prendra tout son sens.

98
00:04:58,270 --> 00:05:01,620
Donc, ici, nous pourrions déclarer un tableau
des booléens appelés Truthtable,

99
00:05:01,620 --> 00:05:05,590
qui se compose de la place pour 10 booléens.

100
00:05:05,590 --> 00:05:09,650
>> Et puis, comme tout nous pouvions assigner
une valeur à une autre variable de type

101
00:05:09,650 --> 00:05:13,470
Boolean, on pourrait dire quelque chose
comme Truthtable crochet

102
00:05:13,470 --> 00:05:18,040
2, qui est la façon dont nous indiquons,
lequel élément de la table de vérité?

103
00:05:18,040 --> 00:05:20,350
Le troisième élément de la
table de vérité, car rappelez-vous,

104
00:05:20,350 --> 00:05:21,800
nous comptons de 0.

105
00:05:21,800 --> 00:05:25,690
Voilà donc comment nous indiquons le
troisième élément de la table de vérité.

106
00:05:25,690 --> 00:05:28,680
Truthtable 2 est égale à faux,
tout comme nous pourrions declare--

107
00:05:28,680 --> 00:05:33,560
ou nous pourrions céder, plutôt, toute
Variable de type booléen est faux.

108
00:05:33,560 --> 00:05:35,050
>> Nous pouvons également l'utiliser dans des conditions.

109
00:05:35,050 --> 00:05:39,000
if (7 == truthtable
vrai), ce qui veut dire,

110
00:05:39,000 --> 00:05:42,370
si la huitième élément
de Truthtable est vrai,

111
00:05:42,370 --> 00:05:46,760
peut-être que nous voulons imprimer un message
pour l'utilisateur, printf ("TRUE! n") ;.

112
00:05:46,760 --> 00:05:50,290
Cela nous amène à dire Truthtable
10 équivaut vrai, non?

113
00:05:50,290 --> 00:05:53,590
Eh bien, je peux, mais il est assez
dangereux, rappelez-vous, parce que,

114
00:05:53,590 --> 00:05:56,260
nous avons un tableau de 10 booléens.

115
00:05:56,260 --> 00:06:02,340
Alors que l'indice le plus élevé le
compilateur nous a donné est 9.

116
00:06:02,340 --> 00:06:06,010
>> Ce programme va compiler, mais
si quelque chose dans la mémoire

117
00:06:06,010 --> 00:06:09,110
existe où nous
attendre Truthtable 10 pour aller,

118
00:06:09,110 --> 00:06:13,980
nous pourrions souffrir d'une erreur de segmentation. nous
pourrait sortir avec elle, mais en général,

119
00:06:13,980 --> 00:06:14,710
assez dangereux.

120
00:06:14,710 --> 00:06:19,759
Donc ce que je fais ici est C juridique,
mais pas nécessairement le meilleur coup.

121
00:06:19,759 --> 00:06:22,300
Maintenant, lorsque vous déclarez et
initialiser un tableau en même temps,

122
00:06:22,300 --> 00:06:23,960
il ya en fait une jolie
syntaxe spéciale que vous

123
00:06:23,960 --> 00:06:26,250
peut utiliser pour remplir le tableau
avec les valeurs de départ.

124
00:06:26,250 --> 00:06:30,130
Il peut devenir lourd à
déclarer un tableau de taille 100,

125
00:06:30,130 --> 00:06:33,430
et d'avoir à dire, l'élément 0
est égal à cette; élément 1 est égal à cette;

126
00:06:33,430 --> 00:06:34,850
élément 2 est égale à celle.

127
00:06:34,850 --> 00:06:36,370
Quel est le point, non?

128
00:06:36,370 --> 00:06:39,470
>> Si il est un petit tableau, vous
pourrait faire quelque chose comme ça.

129
00:06:39,470 --> 00:06:44,360
Bool truthtable 3 est égal ouverte
accolade puis virgule

130
00:06:44,360 --> 00:06:48,060
séparer la liste des éléments
que vous voulez mettre dans le tableau.

131
00:06:48,060 --> 00:06:50,520
Ensuite, fermez bouclés accolade virgule.

132
00:06:50,520 --> 00:06:53,910
Cela crée un tableau de
la taille de trois appelé Truthtable,

133
00:06:53,910 --> 00:06:56,090
avec des éléments faux, vrai, et le vrai.

134
00:06:56,090 --> 00:06:59,270
Et en fait, l'instanciation
Je dois syntaxe est ici

135
00:06:59,270 --> 00:07:03,350
exactement la même chose que faire la
élément individuel syntaxe ci-dessous.

136
00:07:03,350 --> 00:07:09,380
Ces deux façons de codage devraient
produire le même tableau exact.

137
00:07:09,380 --> 00:07:11,740
>> De même, nous pourrions parcourir
sur l'ensemble des éléments

138
00:07:11,740 --> 00:07:15,400
d'un tableau en utilisant une boucle qui, en
fait, est très fortement recommandé

139
00:07:15,400 --> 00:07:16,790
à domicile exercice.

140
00:07:16,790 --> 00:07:20,720
Comment créez-vous un tableau
de 100 nombres entiers, où

141
00:07:20,720 --> 00:07:23,477
chaque élément du tableau est son indice?

142
00:07:23,477 --> 00:07:26,560
Ainsi, par exemple, nous avons un réseau de 100
des nombres entiers, et dans le premier élément,

143
00:07:26,560 --> 00:07:27,790
nous voulons mettre 0.

144
00:07:27,790 --> 00:07:29,810
Dans le deuxième élément, nous voulons mettre 1.

145
00:07:29,810 --> 00:07:33,319
Dans le troisième élément, nous voulons
de mettre 2; Ainsi de suite.

146
00:07:33,319 --> 00:07:35,360
Voilà une très bonne
à domicile exercice à faire cela.

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

148
00:07:38,190 --> 00:07:40,220
>> Ici, il ne semble pas
comme on a trop changé.

149
00:07:40,220 --> 00:07:44,170
Mais noter que dans entre le
crochets, cette fois,

150
00:07:44,170 --> 00:07:45,830
Je l'ai effectivement omis le numéro.

151
00:07:45,830 --> 00:07:48,000
Si vous utilisez cette très
instanciation spéciale

152
00:07:48,000 --> 00:07:50,380
syntaxe pour créer une
tableau, vous faites réellement pas

153
00:07:50,380 --> 00:07:53,491
besoin pour indiquer la taille
de la matrice à l'avance.

154
00:07:53,491 --> 00:07:55,740
Le compilateur est assez intelligent
de savoir que vous avez réellement

155
00:07:55,740 --> 00:07:58,980
veulent un tableau de taille 3,
parce que vous mettez trois éléments

156
00:07:58,980 --> 00:08:00,640
à la droite du signe égal.

157
00:08:00,640 --> 00:08:04,140
Si vous aviez mis quatre, il aurait
vous donné une table de vérité de la taille de quatre;

158
00:08:04,140 --> 00:08:06,270
Ainsi de suite.

159
00:08:06,270 --> 00:08:09,380
>> Les tableaux ne sont pas limités à un seul
dimension, qui est plutôt cool.

160
00:08:09,380 --> 00:08:12,000
Vous pouvez effectivement avoir autant
prescripteurs secondaires que vous le souhaitez.

161
00:08:12,000 --> 00:08:16,470
Ainsi, par exemple, si vous voulez créer
un conseil pour le jeu Battleship, qui,

162
00:08:16,470 --> 00:08:20,910
si vous avez déjà joué, est un jeu qui est
joué avec des chevilles sur le 10 par 10 grille,

163
00:08:20,910 --> 00:08:22,450
vous pouvez créer un tableau comme celui-ci.

164
00:08:22,450 --> 00:08:26,030
Vous pourriez dire Bool
cuirassé support carré de 10

165
00:08:26,030 --> 00:08:29,590
carré fermé crochet
console 10 fermé crochet.

166
00:08:29,590 --> 00:08:32,710
>> Et puis, vous pouvez choisir de
interpréter cela dans votre esprit comme un 10

167
00:08:32,710 --> 00:08:35,576
par 10 les cellules de la grille.

168
00:08:35,576 --> 00:08:37,409
Maintenant, en fait, dans la mémoire,
il fait vraiment juste

169
00:08:37,409 --> 00:08:42,440
rester un élément 100,
dimensionnel unique.

170
00:08:42,440 --> 00:08:46,070
Et cela, en fait, va pour si vous
avoir trois dimensions ou quatre ou cinq.

171
00:08:46,070 --> 00:08:49,420
Il n'a vraiment pas simplement multiplier
la totalité de la indices--

172
00:08:49,420 --> 00:08:51,130
ou la totalité de la taille
specifiers-- ensemble,

173
00:08:51,130 --> 00:08:53,480
et vous obtenez juste une unidimensionnel
tableau de cette taille.

174
00:08:53,480 --> 00:08:57,090
>> Mais en termes d'organisation et de
visualisation et la perception humaine,

175
00:08:57,090 --> 00:08:59,240
il peut être beaucoup plus facile
de travailler avec une grille

176
00:08:59,240 --> 00:09:02,980
si vous travaillez sur un jeu
comme Tic-tac-toe ou Battleship,

177
00:09:02,980 --> 00:09:05,179
ou quelque chose comme ça.

178
00:09:05,179 --> 00:09:06,970
Il est une grande abstraction,
au lieu de devoir

179
00:09:06,970 --> 00:09:09,340
de penser à un tic-tac-toe
carte comme une ligne de neuf

180
00:09:09,340 --> 00:09:13,810
carrés ou un conseil Battleship
comme une ligne de 100 carrés.

181
00:09:13,810 --> 00:09:16,010
A 10 10 par une grille ou trois
par trois grille est probablement

182
00:09:16,010 --> 00:09:17,225
beaucoup plus facile à percevoir.

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

184
00:09:19,820 --> 00:09:22,280
>> Maintenant, quelque chose de vraiment
importante sur les tableaux.

185
00:09:22,280 --> 00:09:25,950
Nous pouvons traiter chaque personne
élément de la matrice en tant que variable.

186
00:09:25,950 --> 00:09:27,700
Nous avons vu que, plus tôt
quand nous étions assignons

187
00:09:27,700 --> 00:09:32,240
la vraie valeur de certaines booléens
ou les tester dans conditionnelles.

188
00:09:32,240 --> 00:09:35,960
Mais nous ne pouvons pas traiter l'ensemble de
eux-mêmes des tableaux comme variables.

189
00:09:35,960 --> 00:09:41,760
Nous ne pouvons pas, par exemple, affecter un tableau
à un autre tableau en utilisant l'affectation

190
00:09:41,760 --> 00:09:42,930
opérateur.

191
00:09:42,930 --> 00:09:44,640
Il est pas C. juridique

192
00:09:44,640 --> 00:09:47,920
>> Si nous voulons, par ce example--
nous ferions dans cet exemple

193
00:09:47,920 --> 00:09:50,200
serait de copier un tableau dans un autre.

194
00:09:50,200 --> 00:09:53,810
Si nous voulons le faire, nous avons fait
avoir besoin d'utiliser une boucle pour copier sur

195
00:09:53,810 --> 00:09:56,550
chaque élément individuel à la fois.

196
00:09:56,550 --> 00:09:58,700
Je sais qu'il est un peu de temps.

197
00:09:58,700 --> 00:10:04,022
>> Ainsi, par exemple, si nous avions ces quelques
de lignes de code, cela fonctionnerait?

198
00:10:04,022 --> 00:10:05,230
Eh bien, non, il ne serait pas, non?

199
00:10:05,230 --> 00:10:07,860
Parce que nous essayons
d'attribuer à la barre alimentaire.

200
00:10:07,860 --> 00:10:09,860
Cela ne va pas au travail,
car il est un tableau,

201
00:10:09,860 --> 00:10:13,130
et nous venons de décrire
que cela ne C. juridique

202
00:10:13,130 --> 00:10:15,580
>> Au lieu de cela, si nous voulons
copier le contenu de la nourriture

203
00:10:15,580 --> 00:10:18,070
dans la barre, ce qui est
nous essayons de faire ici,

204
00:10:18,070 --> 00:10:19,970
nous aurions besoin d'une syntaxe comme ça.

205
00:10:19,970 --> 00:10:24,170
Nous avons une boucle qui va
à partir de J est égal à 0 à 5,

206
00:10:24,170 --> 00:10:28,390
et on incrémente J à chaque itération de
la boucle et attribuer des éléments comme ça.

207
00:10:28,390 --> 00:10:33,360
Cela entraînerait également un bar
étant un, deux, trois, quatre, cinq,

208
00:10:33,360 --> 00:10:36,730
mais nous devons le faire de cette très
chemin élément par élément lente,

209
00:10:36,730 --> 00:10:40,009
au lieu de juste par
copier l'ensemble du réseau.

210
00:10:40,009 --> 00:10:42,050
Dans d'autres programmes
langues, plus modernes,

211
00:10:42,050 --> 00:10:45,610
vous pouvez, en fait, faire juste
aussi simple que cela équivaut à la syntaxe.

212
00:10:45,610 --> 00:10:49,620
Mais C, malheureusement, nous sommes
pas autorisés à le faire.

213
00:10:49,620 --> 00:10:52,026
>> Maintenant, il ya un autre
chose que je tiens à mentionner

214
00:10:52,026 --> 00:10:54,650
sur les tableaux qui peuvent être un peu
peu difficile la première fois que vous

215
00:10:54,650 --> 00:10:55,990
travailler avec eux.

216
00:10:55,990 --> 00:10:59,860
Nous avons discuté dans une vidéo
à propos de la portée des variables,

217
00:10:59,860 --> 00:11:04,940
que la plupart des variables dans C, lorsque vous appelez
les fonctions, sont passés par valeur.

218
00:11:04,940 --> 00:11:08,620
Vous rappelez-vous ce que cela signifie
passer quelque chose par sa valeur?

219
00:11:08,620 --> 00:11:12,570
Cela signifie que nous faisons une copie de la
la variable qui a été adoptée en.

220
00:11:12,570 --> 00:11:16,290
La fonction de l'appelé, la fonction
que cela recevoir la variable,

221
00:11:16,290 --> 00:11:17,730
ne prenez pas la variable elle-même.

222
00:11:17,730 --> 00:11:20,850
Il obtient sa propre locale
copie à travailler avec.

223
00:11:20,850 --> 00:11:24,070
>> Tableaux, bien sûr, ne
ne pas suivre cette règle.

224
00:11:24,070 --> 00:11:27,600
Plutôt, ce que nous appelons cette
est en passant par référence.

225
00:11:27,600 --> 00:11:31,360
L'appelé effectivement
ne recevoir le tableau.

226
00:11:31,360 --> 00:11:34,207
Il ne reçoit pas sa
propre copie locale de celui-ci.

227
00:11:34,207 --> 00:11:36,040
Et si vous pensez
il, cela fait sens.

228
00:11:36,040 --> 00:11:39,750
Si les tableaux sont très grandes, il
prend tellement de temps et d'efforts

229
00:11:39,750 --> 00:11:44,470
de faire une copie d'un tableau de
100 ou 1000 ou 10.000 éléments,

230
00:11:44,470 --> 00:11:48,290
qu'il vaut pas la peine pour une
fonctionner pour recevoir une copie de celui-ci,

231
00:11:48,290 --> 00:11:51,037
faire un travail avec elle, puis
juste être fait avec la copie;

232
00:11:51,037 --> 00:11:53,120
il n'a pas besoin d'avoir
il traîner plus.

233
00:11:53,120 --> 00:11:54,710
>> Car les tableaux sont quelques-uns
volumineux et encombrant,

234
00:11:54,710 --> 00:11:56,001
nous venons de passer entre eux par référence.

235
00:11:56,001 --> 00:12:01,210
Nous venons de confiance que la fonction
à ne pas casser quelque chose.

236
00:12:01,210 --> 00:12:03,010
Donc, il ne reçoit en fait le tableau.

237
00:12:03,010 --> 00:12:05,290
Il ne peut pas faire sa propre copie locale de celui-ci.

238
00:12:05,290 --> 00:12:07,170
>> Qu'est-ce que cela signifie,
puis, quand l'appelé

239
00:12:07,170 --> 00:12:08,970
manipule les éléments du tableau?

240
00:12:08,970 --> 00:12:10,780
Ce qui se produit?

241
00:12:10,780 --> 00:12:13,210
Pour l'instant, nous allons Gloss
plus exactement pourquoi ce

242
00:12:13,210 --> 00:12:15,320
qui se passe, pourquoi les tableaux
sont passés par référence

243
00:12:15,320 --> 00:12:17,810
et tout le reste est passé par valeur.

244
00:12:17,810 --> 00:12:20,470
Mais je vous promets, nous allons
revenir et de vous donner la réponse

245
00:12:20,470 --> 00:12:23,750
pour cela d'une vidéo plus tard.

246
00:12:23,750 --> 00:12:28,110
>> Voici encore un exercice pour vous
Avant de terminer les choses sur les tableaux.

247
00:12:28,110 --> 00:12:31,400
Le tas de code ici, qui est
pas particulièrement bon style,

248
00:12:31,400 --> 00:12:33,400
juste que je vais faire cette mise en garde.

249
00:12:33,400 --> 00:12:36,660
Il n'y a pas de commentaires ici,
ce qui est assez mauvaise forme.

250
00:12:36,660 --> 00:12:39,750
Mais il est seulement parce que je voulais être
capable de tenir tout sur l'écran.

251
00:12:39,750 --> 00:12:44,360
>> Au sommet, vous pouvez voir que je dois
deux déclarations de fonction pour ensemble gamme

252
00:12:44,360 --> 00:12:45,820
et mettre int.

253
00:12:45,820 --> 00:12:49,680
Set tableau prend apparemment un tableau
de quatre nombres entiers comme son entrée.

254
00:12:49,680 --> 00:12:52,767
Et ensemble int prend apparemment
un seul entier comme son entrée.

255
00:12:52,767 --> 00:12:54,350
Mais deux d'entre eux ne disposent pas d'une sortie.

256
00:12:54,350 --> 00:12:57,689
La sortie, le retour
taper, de chacun est nulle.

257
00:12:57,689 --> 00:12:59,480
En principal, nous avons une
quelques lignes de code.

258
00:12:59,480 --> 00:13:02,730
Nous déclarons une variable entière
appelé A et lui attribuer la valeur 10.

259
00:13:02,730 --> 00:13:07,080
Nous déclarons un tableau de quatre entiers
appelé B et affecter les éléments 0, 1,

260
00:13:07,080 --> 00:13:08,730
2 et 3, respectivement.

261
00:13:08,730 --> 00:13:12,190
Ensuite, nous avons un appel à mettre en
int et un appel pour régler tableau.

262
00:13:12,190 --> 00:13:15,910
Les définitions de jeu tableau et ensemble
int sont bas, au fond.

263
00:13:15,910 --> 00:13:17,640
>> Et donc, encore une fois, je vous pose la question.

264
00:13:17,640 --> 00:13:20,770
Ce qui est imprimé
ici à la fin du Main?

265
00:13:20,770 --> 00:13:23,020
Il ya un col d'impression. Je suis
imprimant deux entiers.

266
00:13:23,020 --> 00:13:28,010
Je imprimer le contenu de A et
le contenu du support carré B 0.

267
00:13:28,010 --> 00:13:29,880
Mettre en pause la vidéo ici et de prendre une minute.

268
00:13:29,880 --> 00:13:35,482
Pouvez-vous imaginer ce que cela
fonction permet d'imprimer à la fin?

269
00:13:35,482 --> 00:13:38,190
Espérons que, si vous vous souvenez du
distinction entre passant par valeur

270
00:13:38,190 --> 00:13:41,680
et passant par référence, ce
problème était pas trop difficile pour vous.

271
00:13:41,680 --> 00:13:44,130
Et la réponse vous le feriez
ai trouvé est présent.

272
00:13:44,130 --> 00:13:47,660
Si vous ne savez pas vraiment à
pourquoi cela est le cas, prendre une seconde,

273
00:13:47,660 --> 00:13:50,620
revenir en arrière, passer en revue ce que je étais juste
en discutant sur les tableaux passant

274
00:13:50,620 --> 00:13:53,450
par référence, par rapport passant
d'autres variables, en valeur,

275
00:13:53,450 --> 00:13:56,680
et espérons-le, ça va faire
un peu plus de sens.

276
00:13:56,680 --> 00:13:59,760
>> Je suis Doug Lloyd, et ceci est CS50.

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