1
00:00:00,000 --> 00:00:03,388
>> [Música tocando]

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

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

4
00:00:06,020 --> 00:00:07,680
Trabalhando com único
variáveis ​​é muito divertido.

5
00:00:07,680 --> 00:00:09,500
Mas o que se quer trabalhar
com um grande número de variáveis,

6
00:00:09,500 --> 00:00:12,760
mas nós não queremos ter um monte de
nomes diferentes voando em torno de nosso código?

7
00:00:12,760 --> 00:00:15,980
Neste caso, são matrizes
vai ser realmente útil.

8
00:00:15,980 --> 00:00:19,510
Arrays são dados realmente fundamentais
estrutura para qualquer linguagem de programação

9
00:00:19,510 --> 00:00:20,260
que você vai usar.

10
00:00:20,260 --> 00:00:24,450
E eles são muito, muito útil,
particularmente, como veremos, no CS 50.

11
00:00:24,450 --> 00:00:27,870
>> Nós usamos matrizes para segurar
Os valores de dados do mesmo tipo

12
00:00:27,870 --> 00:00:29,830
em localizações contíguas de memória.

13
00:00:29,830 --> 00:00:32,430
Ou seja, é uma
forma que podemos agrupar

14
00:00:32,430 --> 00:00:35,430
um monte de números inteiros juntos em
memória ou um monte de personagens

15
00:00:35,430 --> 00:00:38,270
ou flutua na memória realmente
juntas e trabalho

16
00:00:38,270 --> 00:00:41,930
com eles sem ter que dar a cada
um seu próprio nome, o que pode

17
00:00:41,930 --> 00:00:44,500
obter complicado depois de um pouco de tempo.

18
00:00:44,500 --> 00:00:48,130
>> Agora, uma maneira de analogize matrizes
é pensar sobre o seu local post

19
00:00:48,130 --> 00:00:49,000
escritório por um segundo.

20
00:00:49,000 --> 00:00:51,820
Então, passo longe de programação
e basta fechar os olhos

21
00:00:51,820 --> 00:00:54,120
e visualize em sua mente
sua estação de correios local.

22
00:00:54,120 --> 00:00:57,160
Normalmente, na maioria pós
escritórios, há um grande banco

23
00:00:57,160 --> 00:01:00,490
as caixas de correios na parede.

24
00:01:00,490 --> 00:01:03,510
>> Uma matriz é um bloco gigante
de memória contíguo,

25
00:01:03,510 --> 00:01:06,120
da mesma maneira que um e-mail
banco em sua estação de correios

26
00:01:06,120 --> 00:01:11,230
é um grande espaço no
parede da estação de correios.

27
00:01:11,230 --> 00:01:15,750
Arrays foram divididos em pequenos,
identicamente blocos de tamanho de espaço,

28
00:01:15,750 --> 00:01:19,930
cada um dos quais é chamado um elemento, em
Da mesma forma que a parede do posto

29
00:01:19,930 --> 00:01:23,840
escritório foi dividida em pequeno,
identicamente blocos de tamanho de espaço,

30
00:01:23,840 --> 00:01:27,560
que chamamos de uma caixa postal.

31
00:01:27,560 --> 00:01:31,650
Cada elemento da matriz pode
armazenar uma certa quantidade de dados,

32
00:01:31,650 --> 00:01:37,540
assim como cada caixa postal é capaz
para manter uma certa quantidade de correio.

33
00:01:37,540 --> 00:01:41,540
>> O que pode ser armazenado em cada elemento de
a matriz é variáveis ​​do mesmo dados

34
00:01:41,540 --> 00:01:45,300
tipo, como int ou char, apenas
como em sua caixa postal,

35
00:01:45,300 --> 00:01:47,300
você só pode caber coisas
de um tipo semelhante,

36
00:01:47,300 --> 00:01:50,430
tais como cartas ou pacotes pequenos.

37
00:01:50,430 --> 00:01:55,050
Por último, podemos acessar cada elemento da
a matriz diretamente pelo número de índice,

38
00:01:55,050 --> 00:01:59,770
assim como podemos acessar nossa estação de correios
caixa por saber o seu número de caixa postal.

39
00:01:59,770 --> 00:02:02,750
Felizmente, essa analogia
ajuda a obter a sua cabeça

40
00:02:02,750 --> 00:02:05,540
em torno da idéia de matrizes por
analogizante para outra coisa

41
00:02:05,540 --> 00:02:08,400
que você provavelmente está
já está familiarizado.

42
00:02:08,400 --> 00:02:13,182
>> Em C, os elementos de uma matriz são
indexados a partir de 0, não a partir de 1.

43
00:02:13,182 --> 00:02:14,390
E isto é realmente importante.

44
00:02:14,390 --> 00:02:18,530
E, de fato, é por isso que, no CS 50,
e por que os cientistas computador com freqüência

45
00:02:18,530 --> 00:02:22,150
contará a partir de 0, é
por causa da variedade de C

46
00:02:22,150 --> 00:02:24,660
indexação, que sempre começa em 0.

47
00:02:24,660 --> 00:02:28,730
Portanto, se uma matriz consiste de n elementos,
o primeiro elemento dessa matriz

48
00:02:28,730 --> 00:02:32,960
situa-se no índice 0, e
o último elemento da matriz

49
00:02:32,960 --> 00:02:36,610
situa-se no índice n menos 1.

50
00:02:36,610 --> 00:02:43,160
Mais uma vez, se há elementos da nossa n
array, o último índice é n menos 1.

51
00:02:43,160 --> 00:02:46,820
>> Então, se a nossa matriz tem 50 elementos, os
primeiro elemento está localizado no índice 0,

52
00:02:46,820 --> 00:02:51,060
e o último elemento
situa-se no índice de 49.

53
00:02:51,060 --> 00:02:53,940
Infelizmente, ou felizmente,
dependendo da sua perspectiva,

54
00:02:53,940 --> 00:02:56,170
C é muito branda aqui.

55
00:02:56,170 --> 00:02:59,480
Ele não vai impedi-lo de
sair dos limites da sua matriz.

56
00:02:59,480 --> 00:03:03,080
Você pode acessar a menos
3 elemento de sua matriz

57
00:03:03,080 --> 00:03:07,400
ou o elemento 59 de sua matriz,
se a matriz tem apenas 50 elementos.

58
00:03:07,400 --> 00:03:11,060
Ela não vai parar seu programa de
compilando, mas em tempo de execução,

59
00:03:11,060 --> 00:03:14,350
você pode encontrar um
falha de segmentação temido

60
00:03:14,350 --> 00:03:17,460
se você começar a acessar a memória
que está fora dos limites do que

61
00:03:17,460 --> 00:03:19,260
você perguntou ao seu programa para dar-lhe.

62
00:03:19,260 --> 00:03:21,250
Portanto, tenha cuidado.

63
00:03:21,250 --> 00:03:23,120
>> O que faz um array
declaração parece?

64
00:03:23,120 --> 00:03:26,940
Como é que vamos codificar uma matriz à existência
como nós codificar qualquer outra variável?

65
00:03:26,940 --> 00:03:31,250
Há três partes para uma matriz
declaration-- um tipo, um nome,

66
00:03:31,250 --> 00:03:31,880
e um tamanho.

67
00:03:31,880 --> 00:03:34,088
Isto é muito semelhante a um
declaração de variável, que

68
00:03:34,088 --> 00:03:36,970
é apenas um tipo e um nome,
sendo o elemento de tamanho

69
00:03:36,970 --> 00:03:39,860
o caso especial de uma matriz,
porque estamos recebendo um monte deles

70
00:03:39,860 --> 00:03:41,830
ao mesmo tempo.

71
00:03:41,830 --> 00:03:45,560
>> Assim, o tipo é o tipo de variável que você
quero que cada elemento da matriz para ser.

72
00:03:45,560 --> 00:03:47,150
Não quero que um array de inteiros?

73
00:03:47,150 --> 00:03:49,010
Em seguida, o tipo de dados deve ser int.

74
00:03:49,010 --> 00:03:51,760
Você quer que ele seja um
matriz de duplas ou flutuadores?

75
00:03:51,760 --> 00:03:54,545
Tipo de dados deve ser o dobro ou flutuar.

76
00:03:54,545 --> 00:03:56,420
O nome é o que você
quero chamar a sua matriz.

77
00:03:56,420 --> 00:04:00,970
O que você quer para nomear este gigante
banco de inteiros ou flutuadores ou caracteres

78
00:04:00,970 --> 00:04:03,250
ou duplos, ou o que você tem?

79
00:04:03,250 --> 00:04:04,700
O que você quiser chamá-lo?

80
00:04:04,700 --> 00:04:06,110
Bastante auto-explicativo.

81
00:04:06,110 --> 00:04:08,610
>> Por último, o tamanho, o que vai
dentro de colchetes,

82
00:04:08,610 --> 00:04:12,180
é quantos elementos você faria
como a matriz para conter.

83
00:04:12,180 --> 00:04:13,530
Quantos inteiros que você quer?

84
00:04:13,530 --> 00:04:15,570
Quantos carros alegóricos que você quer?

85
00:04:15,570 --> 00:04:19,070
>> Assim, por exemplo, int notas dos alunos 40.

86
00:04:19,070 --> 00:04:26,020
Este declara um array chamado Student
graus, que consiste de 40 números inteiros.

87
00:04:26,020 --> 00:04:28,180
Bastante auto-explicativo, eu espero.

88
00:04:28,180 --> 00:04:29,330
Aqui está outro exemplo.

89
00:04:29,330 --> 00:04:31,560
Duplo preços de menu 8.

90
00:04:31,560 --> 00:04:34,610
Isso cria uma matriz chamada
Menu preços, que consiste

91
00:04:34,610 --> 00:04:38,300
de espaço na memória por oito duplas.

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

93
00:04:42,000 --> 00:04:45,750
>> Se você pensar em cada elemento
de uma matriz de tipo de dados tipo,

94
00:04:45,750 --> 00:04:49,860
Assim, por exemplo, um único elemento de
uma matriz do tipo int, da mesma forma que

95
00:04:49,860 --> 00:04:52,770
poderia pensar de qualquer outro
variável do tipo int,

96
00:04:52,770 --> 00:04:56,440
todas as operações que familiares
discutidos anteriormente nas Operações

97
00:04:56,440 --> 00:04:58,270
vídeo vai fazer sentido.

98
00:04:58,270 --> 00:05:01,620
Então, aqui, podemos declarar uma matriz
de Booleans chamados Truthtable,

99
00:05:01,620 --> 00:05:05,590
que consiste em sala para 10 Booleans.

100
00:05:05,590 --> 00:05:09,650
>> E então, assim como nós apenas poderia atribuir
um valor a qualquer outra variável do tipo

101
00:05:09,650 --> 00:05:13,470
Booleano, poderíamos dizer algo
como colchete Truthtable

102
00:05:13,470 --> 00:05:18,040
2, que é como nós indicamos,
qual elemento da tabela de verdade?

103
00:05:18,040 --> 00:05:20,350
O terceiro elemento do
tabela verdade, pois lembre-se,

104
00:05:20,350 --> 00:05:21,800
estamos contando a partir de 0.

105
00:05:21,800 --> 00:05:25,690
Então é assim que indicam a
terceiro elemento da tabela de verdade.

106
00:05:25,690 --> 00:05:28,680
Truthtable 2 é igual a false,
assim como nós poderia declare--

107
00:05:28,680 --> 00:05:33,560
ou poderíamos atribuir, em vez disso, qualquer
Variável do tipo booleano para ser falsa.

108
00:05:33,560 --> 00:05:35,050
>> Nós também podemos usá-lo em condições.

109
00:05:35,050 --> 00:05:39,000
if (7 == truthtable
verdadeiro), o que quer dizer,

110
00:05:39,000 --> 00:05:42,370
Se o oitavo elemento
de Truthtable é verdade,

111
00:05:42,370 --> 00:05:46,760
talvez nós queremos imprimir uma mensagem
para o utilizador, printf ("VERDADEIRO! N") ;.

112
00:05:46,760 --> 00:05:50,290
Isso nos leva a dizer Truthtable
10 é igual a verdade, certo?

113
00:05:50,290 --> 00:05:53,590
Bem, eu posso, mas é bastante
perigoso, pois lembre-se,

114
00:05:53,590 --> 00:05:56,260
temos um array de 10 Booleans.

115
00:05:56,260 --> 00:06:02,340
Assim, o índice mais elevado que o
compilador nos deu é 9.

116
00:06:02,340 --> 00:06:06,010
>> Este programa irá compilar, mas
se alguma outra coisa na memória

117
00:06:06,010 --> 00:06:09,110
existe onde iríamos
esperar Truthtable 10 para ir,

118
00:06:09,110 --> 00:06:13,980
nós poderia sofrer uma falha de segmentação. Nós
pode fugir com ele, mas, em geral,

119
00:06:13,980 --> 00:06:14,710
muito perigoso.

120
00:06:14,710 --> 00:06:19,759
Então, o que eu estou fazendo aqui é legal C,
mas não necessariamente a melhor jogada.

121
00:06:19,759 --> 00:06:22,300
Agora, quando você declarar e
inicializar uma matriz ao mesmo tempo,

122
00:06:22,300 --> 00:06:23,960
há realmente uma bonita
sintaxe especial que você

123
00:06:23,960 --> 00:06:26,250
pode usar para preencher a matriz
com os seus valores iniciais.

124
00:06:26,250 --> 00:06:30,130
Ele pode ficar pesado para
declarar uma matriz de tamanho 100,

125
00:06:30,130 --> 00:06:33,430
e, em seguida, tenho que dizer, o elemento 0
é igual a este; elemento 1 é igual a esta;

126
00:06:33,430 --> 00:06:34,850
elemento 2 é igual a isso.

127
00:06:34,850 --> 00:06:36,370
Qual é o ponto, certo?

128
00:06:36,370 --> 00:06:39,470
>> Se é uma pequena matriz,
poderia fazer algo parecido com isto.

129
00:06:39,470 --> 00:06:44,360
Bool truthtable 3 é igual aberta
chaveta e, em seguida vírgula

130
00:06:44,360 --> 00:06:48,060
separar a lista de elementos
que você quer colocar na matriz.

131
00:06:48,060 --> 00:06:50,520
Em seguida, feche encaracolado vírgula cinta.

132
00:06:50,520 --> 00:06:53,910
Isto cria uma matriz de
tamanho três chamado Truthtable,

133
00:06:53,910 --> 00:06:56,090
com elementos falso, verdadeiro, e verdadeiro.

134
00:06:56,090 --> 00:06:59,270
E, de fato, a instanciação
sintaxe que tenho aqui é

135
00:06:59,270 --> 00:07:03,350
exactamente o mesmo que o que faz
sintaxe elemento individual abaixo.

136
00:07:03,350 --> 00:07:09,380
Estas duas formas de codificação faria
produzir a mesma matriz exata.

137
00:07:09,380 --> 00:07:11,740
>> Da mesma forma, nós poderíamos fazer uma iteração
ao longo de todos os elementos

138
00:07:11,740 --> 00:07:15,400
de uma matriz usando um laço, o qual, em
verdade, é um muito fortemente recomendado

139
00:07:15,400 --> 00:07:16,790
at-home exercício.

140
00:07:16,790 --> 00:07:20,720
Como você criar uma matriz
100 de números inteiros, onde

141
00:07:20,720 --> 00:07:23,477
cada elemento da matriz é o seu índice?

142
00:07:23,477 --> 00:07:26,560
Assim, por exemplo, temos uma gama de 100
números inteiros, e no primeiro elemento,

143
00:07:26,560 --> 00:07:27,790
queremos colocar 0.

144
00:07:27,790 --> 00:07:29,810
No segundo elemento, queremos colocar um.

145
00:07:29,810 --> 00:07:33,319
No terceiro elemento, queremos
para colocar 2; e assim por diante e assim por diante.

146
00:07:33,319 --> 00:07:35,360
Isso é realmente um bom
at-home exercício para fazer isso.

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

148
00:07:38,190 --> 00:07:40,220
>> Aqui, ele não se parece
como muito mudou.

149
00:07:40,220 --> 00:07:44,170
Mas note que entre o
colchetes, desta vez,

150
00:07:44,170 --> 00:07:45,830
Eu realmente omitido o número.

151
00:07:45,830 --> 00:07:48,000
Se você estiver usando este muito
instanciação especial

152
00:07:48,000 --> 00:07:50,380
para criar uma sintaxe
array, você realmente não fazer

153
00:07:50,380 --> 00:07:53,491
necessidade de indicar o tamanho
da matriz de antemão.

154
00:07:53,491 --> 00:07:55,740
O compilador é inteligente o suficiente
saber que você, na verdade,

155
00:07:55,740 --> 00:07:58,980
quer uma matriz de tamanho 3,
porque você colocar três elementos

156
00:07:58,980 --> 00:08:00,640
à direita do sinal de igual.

157
00:08:00,640 --> 00:08:04,140
Se você tinha colocado quatro, teria
lhe dado uma tabela de verdade de tamanho quatro;

158
00:08:04,140 --> 00:08:06,270
e assim por diante e assim por diante.

159
00:08:06,270 --> 00:08:09,380
>> As matrizes não está limitado a uma única
dimensão, o que é muito legal.

160
00:08:09,380 --> 00:08:12,000
Você pode realmente ter tantos
especificadores colaterais como você deseja.

161
00:08:12,000 --> 00:08:16,470
Assim, por exemplo, se você quer criar
uma placa para o jogo Batalha Naval, que,

162
00:08:16,470 --> 00:08:20,910
se você já jogou, é um jogo que é
jogado com cavilhas na 10 por 10 grade,

163
00:08:20,910 --> 00:08:22,450
você pode criar uma matriz como este.

164
00:08:22,450 --> 00:08:26,030
Pode-se dizer Bool
colchete navio de guerra 10

165
00:08:26,030 --> 00:08:29,590
quadrado fechado colchete
suporte 10 fechou colchete.

166
00:08:29,590 --> 00:08:32,710
>> E então, você pode optar por
interpretar isso em sua mente como um 10

167
00:08:32,710 --> 00:08:35,576
por 10 grade de células.

168
00:08:35,576 --> 00:08:37,409
Agora, na verdade, na memória,
ele realmente faz apenas

169
00:08:37,409 --> 00:08:42,440
continuam a ser um elemento 100,
matriz dimensional única.

170
00:08:42,440 --> 00:08:46,070
E isso, na verdade, vale para se você
têm três dimensões ou quatro ou cinco.

171
00:08:46,070 --> 00:08:49,420
Realmente só se multiplica
todo o indices--

172
00:08:49,420 --> 00:08:51,130
ou a totalidade do tamanho
specifiers-- juntos,

173
00:08:51,130 --> 00:08:53,480
e você é só pegar um unidimensional
matriz desse tamanho.

174
00:08:53,480 --> 00:08:57,090
>> Mas em termos de organização e
visualização e percepção humana,

175
00:08:57,090 --> 00:08:59,240
ela pode ser muito mais fácil
a trabalhar com uma grade

176
00:08:59,240 --> 00:09:02,980
se você está trabalhando em um jogo
como Tic-tac-dedo do pé ou Battleship,

177
00:09:02,980 --> 00:09:05,179
ou algo assim.

178
00:09:05,179 --> 00:09:06,970
É uma grande abstração,
em vez de ter

179
00:09:06,970 --> 00:09:09,340
para pensar em um Tic-tac-dedo do pé
placa como uma linha de nove

180
00:09:09,340 --> 00:09:13,810
quadrados ou um tabuleiro de batalha
como uma linha de 100 praças.

181
00:09:13,810 --> 00:09:16,010
A 10 por 10 grade ou três
por três grade é provavelmente

182
00:09:16,010 --> 00:09:17,225
muito mais fácil de perceber.

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

184
00:09:19,820 --> 00:09:22,280
>> Agora, algo realmente
importante sobre matrizes.

185
00:09:22,280 --> 00:09:25,950
Nós podemos tratar cada indivíduo
elemento da matriz como uma variável.

186
00:09:25,950 --> 00:09:27,700
Vimos que mais cedo
quando estávamos atribuindo

187
00:09:27,700 --> 00:09:32,240
o valor True a certos Booleans
ou testando-os em condicionais.

188
00:09:32,240 --> 00:09:35,960
Mas não podemos tratar todo
si matrizes como variáveis.

189
00:09:35,960 --> 00:09:41,760
Não podemos, por exemplo, atribuir uma matriz
para outra matriz usando a atribuição

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

191
00:09:42,930 --> 00:09:44,640
Não é legal C.

192
00:09:44,640 --> 00:09:47,920
>> Se queremos, por que example--
nós estaríamos fazendo nesse exemplo

193
00:09:47,920 --> 00:09:50,200
seria copiar uma variedade para outra.

194
00:09:50,200 --> 00:09:53,810
Se nós queremos fazer isso, nós, na verdade,
precisa usar um loop para copiar

195
00:09:53,810 --> 00:09:56,550
cada elemento individual uma de cada vez.

196
00:09:56,550 --> 00:09:58,700
Eu sei que é um pouco demorado.

197
00:09:58,700 --> 00:10:04,022
>> Assim, por exemplo, se tivéssemos estes casal
de linhas de código, isso funcionaria?

198
00:10:04,022 --> 00:10:05,230
Bem, não, não, certo?

199
00:10:05,230 --> 00:10:07,860
Porque nós estamos tentando
para atribuir a comida bar.

200
00:10:07,860 --> 00:10:09,860
Isso não vai funcionar,
porque é uma matriz,

201
00:10:09,860 --> 00:10:13,130
e nós acabamos de descrever
que isso não é legal C.

202
00:10:13,130 --> 00:10:15,580
>> Em vez disso, se quisermos
copie o conteúdo da comida

203
00:10:15,580 --> 00:10:18,070
em bar, que é o que
nós estamos tentando fazer aqui,

204
00:10:18,070 --> 00:10:19,970
precisaríamos de uma sintaxe como esta.

205
00:10:19,970 --> 00:10:24,170
Temos um loop que vai
de J é igual a 0 até 5,

206
00:10:24,170 --> 00:10:28,390
e nós incrementar J em cada iteração
o loop e elementos atribuir assim.

207
00:10:28,390 --> 00:10:33,360
Isto iria resultar em barra também
sendo um, dois, três, quatro, cinco,

208
00:10:33,360 --> 00:10:36,730
mas temos de fazê-lo neste exato
forma lenta elemento por elemento,

209
00:10:36,730 --> 00:10:40,009
em vez de apenas
copiando a matriz inteira.

210
00:10:40,009 --> 00:10:42,050
Em outra programação
línguas, mais modernos,

211
00:10:42,050 --> 00:10:45,610
você pode, de fato, fazer exatamente
que é igual a sintaxe simples.

212
00:10:45,610 --> 00:10:49,620
Mas C, infelizmente, estamos
não tem permissão para fazer isso.

213
00:10:49,620 --> 00:10:52,026
>> Agora, há uma outra
coisa que eu quero mencionar

214
00:10:52,026 --> 00:10:54,650
sobre matrizes que podem ser um pouco
pouco complicado a primeira vez que você

215
00:10:54,650 --> 00:10:55,990
trabalhar com eles.

216
00:10:55,990 --> 00:10:59,860
Discutimos em um vídeo
sobre o escopo de variáveis,

217
00:10:59,860 --> 00:11:04,940
que a maioria das variáveis ​​em C, quando você chamar
-los em funções, são passados ​​por valor.

218
00:11:04,940 --> 00:11:08,620
Você se lembra o que significa
para passar por algo de valor?

219
00:11:08,620 --> 00:11:12,570
Isso significa que nós estamos fazendo uma cópia do
variável que está sendo passado.

220
00:11:12,570 --> 00:11:16,290
A função de receptor, a função
que está recebendo a variável,

221
00:11:16,290 --> 00:11:17,730
não recebe a própria variável.

222
00:11:17,730 --> 00:11:20,850
Ela recebe seu próprio local,
cópia do mesmo para trabalhar.

223
00:11:20,850 --> 00:11:24,070
>> Arrays, é claro, fazer
não seguir esta regra.

224
00:11:24,070 --> 00:11:27,600
Em vez disso, o que nós chamamos este
está passando por referência.

225
00:11:27,600 --> 00:11:31,360
O destinatário da chamada, na verdade,
não recebe a matriz.

226
00:11:31,360 --> 00:11:34,207
Ele não recebe seu
própria cópia local do mesmo.

227
00:11:34,207 --> 00:11:36,040
E se você pensar sobre
ele, isso faz sentido.

228
00:11:36,040 --> 00:11:39,750
Se matrizes são realmente grande,
leva muito tempo e esforço

229
00:11:39,750 --> 00:11:44,470
para fazer uma cópia de uma matriz de
100 ou 1.000 ou 10.000 elementos,

230
00:11:44,470 --> 00:11:48,290
que não vale a pena para um
funcionar para receber uma cópia do mesmo,

231
00:11:48,290 --> 00:11:51,037
fazer algum trabalho com ele, e, em seguida,
apenas ser feito com a cópia;

232
00:11:51,037 --> 00:11:53,120
que não precisa de ter
-lo pendurado em torno de mais.

233
00:11:53,120 --> 00:11:54,710
>> Como os arrays são alguns
volumosos e pesados,

234
00:11:54,710 --> 00:11:56,001
nós apenas passá-los por referência.

235
00:11:56,001 --> 00:12:01,210
Nós apenas confiar em que a função
para, não quebrar nada.

236
00:12:01,210 --> 00:12:03,010
Então, ele realmente obter a matriz.

237
00:12:03,010 --> 00:12:05,290
Ela não recebe sua própria cópia local do mesmo.

238
00:12:05,290 --> 00:12:07,170
>> Então o que isso quer dizer,
em seguida, quando o receptor

239
00:12:07,170 --> 00:12:08,970
manipula elementos do array?

240
00:12:08,970 --> 00:12:10,780
O que acontece?

241
00:12:10,780 --> 00:12:13,210
Por agora, vamos encobrir
sobre por que exatamente esta

242
00:12:13,210 --> 00:12:15,320
acontece, por que matrizes
são passados ​​por referência

243
00:12:15,320 --> 00:12:17,810
e tudo o resto é passado por valor.

244
00:12:17,810 --> 00:12:20,470
Mas eu prometo a você, nós iremos
voltar e dar-lhe a resposta

245
00:12:20,470 --> 00:12:23,750
para isso em um vídeo mais tarde.

246
00:12:23,750 --> 00:12:28,110
>> Aqui está mais um exercício para você
antes de finalizar as coisas em arrays.

247
00:12:28,110 --> 00:12:31,400
O monte de código aqui, isso é
não particularmente bom estilo,

248
00:12:31,400 --> 00:12:33,400
apenas vou fazer essa ressalva.

249
00:12:33,400 --> 00:12:36,660
Há comentários aqui,
o que é bastante má forma.

250
00:12:36,660 --> 00:12:39,750
Mas é só porque eu queria ser
capaz de caber tudo na tela.

251
00:12:39,750 --> 00:12:44,360
>> No topo, você pode ver que eu tenho
duas declarações de função para matriz set

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

253
00:12:45,820 --> 00:12:49,680
Set matriz aparentemente recebe um array
de quatro números inteiros como sua entrada.

254
00:12:49,680 --> 00:12:52,767
E conjunto int aparentemente leva
um único inteiro como sua entrada.

255
00:12:52,767 --> 00:12:54,350
Mas ambos não têm uma saída.

256
00:12:54,350 --> 00:12:57,689
A saída, o retorno
escreva, de cada um é nula.

257
00:12:57,689 --> 00:12:59,480
Na principal, temos uma
par de linhas de código.

258
00:12:59,480 --> 00:13:02,730
Nós declaramos uma variável inteira
A chamada e atribuir-lhe o valor 10.

259
00:13:02,730 --> 00:13:07,080
Nós declarar uma matriz de quatro números inteiros
chamado B e atribuir os elementos 0, 1,

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

261
00:13:08,730 --> 00:13:12,190
Então, temos uma chamada para definir
int e uma chamada para definir matriz.

262
00:13:12,190 --> 00:13:15,910
As definições de conjunto de matriz e conjunto
int estão lá em baixo, na parte inferior.

263
00:13:15,910 --> 00:13:17,640
>> E assim, mais uma vez, peço-lhe a pergunta.

264
00:13:17,640 --> 00:13:20,770
O que fica impresso
aqui no final principal?

265
00:13:20,770 --> 00:13:23,020
Há uma col impressão. Eu sou
imprimindo dois inteiros.

266
00:13:23,020 --> 00:13:28,010
Eu estou imprimindo o conteúdo de A e
o conteúdo de suporte B quadrado 0.

267
00:13:28,010 --> 00:13:29,880
Pausar o vídeo aqui e tomar um minuto.

268
00:13:29,880 --> 00:13:35,482
Você pode descobrir o que esta
função irá imprimir no final?

269
00:13:35,482 --> 00:13:38,190
Esperemos que, se você se lembra o
distinção entre passagem por valor

270
00:13:38,190 --> 00:13:41,680
e passagem por referência, este
problema não era muito complicado para você.

271
00:13:41,680 --> 00:13:44,130
E a resposta que você faria
encontrei é este.

272
00:13:44,130 --> 00:13:47,660
Se você não está realmente certo de como a
por que esse é o caso, tome um segundo,

273
00:13:47,660 --> 00:13:50,620
voltar, rever o que eu era apenas
discutir sobre a passagem de matrizes

274
00:13:50,620 --> 00:13:53,450
por referência, contra a passagem
outras variáveis ​​por valor,

275
00:13:53,450 --> 00:13:56,680
e esperançosamente, ele vai fazer
um pouco mais de sentido.

276
00:13:56,680 --> 00:13:59,760
>> Eu sou Doug Lloyd, e este é CS50.

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