1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] Vamos falar sobre matrizes.

2
00:00:09,360 --> 00:00:12,780
Então por que iríamos querer usar arrays?

3
00:00:12,780 --> 00:00:17,210
Bem, vamos dizer que você tem um programa que precisa para armazenar cinco identificações estudantis.

4
00:00:17,210 --> 00:00:21,270
Pode parecer razoável ter cinco variáveis ​​separadas.

5
00:00:21,270 --> 00:00:24,240
Por razões que veremos daqui a pouco, nós vamos começar a contar a partir de 0.

6
00:00:24,240 --> 00:00:30,700
As variáveis ​​que teremos será id0 int, int id1, e assim por diante.

7
00:00:30,700 --> 00:00:34,870
Qualquer lógica queremos executar em uma carteira de estudante deverá ser copiado e colado

8
00:00:34,870 --> 00:00:36,870
para cada um destes IDs do estudante.

9
00:00:36,870 --> 00:00:39,710
Se quiser verificar que os estudantes que ser em CS50,

10
00:00:39,710 --> 00:00:43,910
vamos primeiro precisa verificar se id0 representa o estudante no curso.

11
00:00:43,910 --> 00:00:48,070
Então, para fazer o mesmo para o aluno que vem, nós vamos precisar copiar e colar o código para id0

12
00:00:48,070 --> 00:00:54,430
e substituir todas as ocorrências com id0 id1 e assim por diante para id2, 3, e 4.

13
00:00:54,430 --> 00:00:57,560
>> Assim que você ouvir que é preciso copiar e colar,

14
00:00:57,560 --> 00:01:00,440
você deve começar a pensar que há uma solução melhor.

15
00:01:00,440 --> 00:01:05,360
Agora, o que se você percebe que não precisa de 5 identificações estudantis, mas sim 7?

16
00:01:05,360 --> 00:01:09,570
Você precisa voltar para o seu código fonte e adicionar em um ID5, um ID6,

17
00:01:09,570 --> 00:01:14,260
e copie e cole a lógica para verificar se as identificações pertencem à classe para estas duas novas identificações.

18
00:01:14,260 --> 00:01:19,600
Não há nada que ligue todas estas identificações juntos, e assim não há nenhuma maneira de pedir

19
00:01:19,600 --> 00:01:22,040
o programa para fazer isso para IDs de 0 a 6.

20
00:01:22,040 --> 00:01:26,120
Bem, agora você percebe que tem 100 identificações estudantis.

21
00:01:26,120 --> 00:01:30,770
Está começando a parecer menos do que o ideal a necessidade de declarar separadamente cada uma dessas identificações,

22
00:01:30,770 --> 00:01:33,760
e copiar e colar qualquer lógica para essas novas identificações.

23
00:01:33,760 --> 00:01:38,380
Mas talvez nós são determinados, e fazemos isso para todos os 100 alunos.

24
00:01:38,380 --> 00:01:42,240
Mas e se você não sabe quantos alunos realmente existem?

25
00:01:42,240 --> 00:01:47,320
Há apenas alguns alunos n e seu programa tem que perguntar ao usuário o que n é.

26
00:01:47,320 --> 00:01:50,250
Uh oh. Isso não vai funcionar muito bem.

27
00:01:50,250 --> 00:01:53,820
Seu programa só funciona para um número constante de alunos.

28
00:01:53,820 --> 00:01:57,520
>> Resolver todos esses problemas é a beleza de matrizes.

29
00:01:57,520 --> 00:01:59,930
Então, o que é uma matriz?

30
00:01:59,930 --> 00:02:04,480
Em algumas linguagens de programação um tipo de matriz pode ser capaz de fazer um pouco mais,

31
00:02:04,480 --> 00:02:09,960
mas aqui vamos nos concentrar no básico estrutura de dados matriz, assim como você vai ver que em C.

32
00:02:09,960 --> 00:02:14,030
Uma matriz é apenas um bloco grande de memória. É isso aí.

33
00:02:14,030 --> 00:02:17,770
Quando dizemos que temos uma matriz de 10 inteiros, isso só significa que temos algum bloco

34
00:02:17,770 --> 00:02:20,740
de memória que é grande o suficiente para armazenar 10 inteiros separados.

35
00:02:29,930 --> 00:02:33,410
Assumindo-se que um número inteiro de 4 bytes, o que significa que um array de 10 inteiros

36
00:02:33,410 --> 00:02:37,180
é um bloco contínuo de 40 bytes de memória.

37
00:02:42,660 --> 00:02:46,280
Mesmo quando você usa matrizes multidimensionais, que não vamos para aqui,

38
00:02:46,280 --> 00:02:49,200
ainda é apenas um bloco grande de memória.

39
00:02:49,200 --> 00:02:51,840
A notação multidimensional é apenas uma conveniência.

40
00:02:51,840 --> 00:02:55,640
Se você tem um 3 por 3 matriz multidimensional de inteiros,

41
00:02:55,640 --> 00:03:00,650
em seguida, o programa vai realmente apenas tratar isso como um grande bloco de 36 bytes.

42
00:03:00,650 --> 00:03:05,460
O número total de números inteiros é de 3 vezes 3, e cada número inteiro ocupa quatro bytes.

43
00:03:05,460 --> 00:03:07,750
>> Vamos dar uma olhada em um exemplo básico.

44
00:03:07,750 --> 00:03:10,660
Podemos ver aqui duas formas diferentes de matrizes declarando.

45
00:03:15,660 --> 00:03:18,580
Nós vamos ter que comentar um deles para fora para que o programa compilar

46
00:03:18,580 --> 00:03:20,900
uma vez que declara x duas vezes.

47
00:03:20,900 --> 00:03:25,140
Nós vamos dar uma olhada em algumas das diferenças entre estes dois tipos de declarações em um pouco.

48
00:03:25,140 --> 00:03:28,560
Ambas estas linhas de declarar uma matriz de tamanho N,

49
00:03:28,560 --> 00:03:30,740
onde temos # define N como 10.

50
00:03:30,740 --> 00:03:34,460
Poderíamos facilmente ter perguntado ao usuário um número inteiro positivo

51
00:03:34,460 --> 00:03:37,250
e usado esse inteiro como um número de elementos na nossa matriz.

52
00:03:37,250 --> 00:03:41,960
Como o nosso exemplo de estudante antes, este é o tipo de como declarar 10 completamente separado

53
00:03:41,960 --> 00:03:49,000
variáveis ​​imaginários; x0, x1, x2, e assim por diante até a xN-1.

54
00:03:57,270 --> 00:04:00,840
Ignorando as linhas onde nós declaramos a matriz, observe os colchetes intacta

55
00:04:00,840 --> 00:04:02,090
dentro do para loops.

56
00:04:02,090 --> 00:04:09,660
Quando escrevemos algo como x [3], que eu vou ler como suporte x 3,

57
00:04:09,660 --> 00:04:13,090
Você pode pensar nisso como pedir para o x3 imaginário.

58
00:04:13,090 --> 00:04:17,519
Notar que com uma matriz de tamanho N, isto significa que o número dentro dos suportes,

59
00:04:17,519 --> 00:04:22,630
que chamaremos o índice, pode ser qualquer coisa de 0 a N-1,

60
00:04:22,630 --> 00:04:25,660
que é um total de índices de N.

61
00:04:25,660 --> 00:04:28,260
>> Para pensar sobre como isso realmente funciona

62
00:04:28,260 --> 00:04:31,260
lembre-se que a matriz é um grande bloco de memória.

63
00:04:31,260 --> 00:04:37,460
Supondo-se que um número inteiro é de 4 bytes, o x matriz inteira é um bloco de 40 bytes de memória.

64
00:04:37,460 --> 00:04:41,360
Assim x0 refere-se aos primeiros 4 bytes do bloco.

65
00:04:45,810 --> 00:04:49,230
X [1] se refere às seguintes quatro bytes e assim por diante.

66
00:04:49,230 --> 00:04:53,760
Isto significa que o início de x é todo o programa sempre precisa acompanhar.

67
00:04:55,660 --> 00:04:59,840
Se você quiser usar x [400], em seguida, o programa sabe que isso é equivalente

68
00:04:59,840 --> 00:05:03,460
para apenas 1600 bytes após o início do x.

69
00:05:03,460 --> 00:05:08,780
Onde temos 1.600 bytes de? É apenas a 400 vezes 4 bytes por inteiro.

70
00:05:08,780 --> 00:05:13,170
>> Antes de prosseguir, é muito importante perceber que em C

71
00:05:13,170 --> 00:05:17,080
não há aplicação do índice que usamos na matriz.

72
00:05:17,080 --> 00:05:23,180
Nosso grande bloco é de apenas 10 inteiros longo, mas nada vai gritar com nós se escrever x [20]

73
00:05:23,180 --> 00:05:26,060
ou ainda x [-5].

74
00:05:26,060 --> 00:05:28,240
O índice não tem sequer a ser um número.

75
00:05:28,240 --> 00:05:30,630
Ele pode ser qualquer expressão arbitrária.

76
00:05:30,630 --> 00:05:34,800
No programa usamos a variável i do loop for para índice para a matriz.

77
00:05:34,800 --> 00:05:40,340
Trata-se de um padrão muito comum, looping de i = 0 para o comprimento da matriz,

78
00:05:40,340 --> 00:05:43,350
e, em seguida, utilizando i como o índice para a matriz.

79
00:05:43,350 --> 00:05:46,160
Desta forma, você circuito efetivamente todo o conjunto,,

80
00:05:46,160 --> 00:05:50,600
e você pode atribuir a cada ponto na matriz ou usá-lo por algum cálculo.

81
00:05:50,600 --> 00:05:53,920
>> No primeiro loop, i começa em 0,

82
00:05:53,920 --> 00:05:58,680
e por isso vai atribuir ao ponto 0 na matriz, o valor 0 vezes 2.

83
00:05:58,680 --> 00:06:04,370
Então eu incrementos, e atribuir o primeiro lugar na matriz o valor 1 vezes 2.

84
00:06:04,370 --> 00:06:10,170
Então eu incrementa novamente e assim por diante até que nós atribuímos para a posição N-1 na matriz

85
00:06:10,170 --> 00:06:13,370
o valor de N-1 vezes 2.

86
00:06:13,370 --> 00:06:17,810
Então, criamos uma matriz com os 10 primeiros números pares.

87
00:06:17,810 --> 00:06:21,970
Talvez nivela teria sido um pouco melhor nome para a variável de x,

88
00:06:21,970 --> 00:06:24,760
mas que teria dado coisas.

89
00:06:24,760 --> 00:06:30,210
O segundo loop então apenas imprime os valores que já foram armazenados dentro da matriz.

90
00:06:30,210 --> 00:06:33,600
>> Vamos tentar executar o programa com os dois tipos de declarações de matriz

91
00:06:33,600 --> 00:06:36,330
e dar uma olhada na saída do programa.

92
00:06:51,450 --> 00:06:57,020
Tanto quanto se pode ver, o programa se comporta da mesma forma para os dois tipos de declarações.

93
00:06:57,020 --> 00:07:02,230
Vamos também dar uma olhada no que acontece se mudarmos o primeiro ciclo de não parar em N

94
00:07:02,230 --> 00:07:05,040
mas dizer 10.000.

95
00:07:05,040 --> 00:07:07,430
Muito para além do fim da matriz.

96
00:07:14,700 --> 00:07:17,210
Oops. Talvez você tenha visto isso antes.

97
00:07:17,210 --> 00:07:20,440
Uma falha de segmentação significa que seu programa deixou de funcionar.

98
00:07:20,440 --> 00:07:24,430
Você começar a ver estes quando você tocar as áreas da memória que você não deve tocar.

99
00:07:24,430 --> 00:07:27,870
Aqui estamos tocando 10.000 lugares além do início de x,

100
00:07:27,870 --> 00:07:31,920
que, evidentemente, é um lugar de memória que não deve tocar.

101
00:07:31,920 --> 00:07:37,690
Assim, a maioria de nós provavelmente não teria acidentalmente colocar 10.000 em vez de N,

102
00:07:37,690 --> 00:07:42,930
mas o que se fazer algo mais sutil, como dizem gravação menor ou igual a N

103
00:07:42,930 --> 00:07:46,830
na condição de loop para em vez de menos de N.

104
00:07:46,830 --> 00:07:50,100
Lembre-se que uma matriz só tem índices de 0 a N-1,

105
00:07:50,100 --> 00:07:54,510
o que significa que o índice N é para além da extremidade da matriz.

106
00:07:54,510 --> 00:07:58,050
O programa não pode falhar neste caso, mas ainda assim é um erro.

107
00:07:58,050 --> 00:08:01,950
Na verdade, esse erro é tão comum que tem o seu próprio nome,

108
00:08:01,950 --> 00:08:03,970
um fora por um erro.

109
00:08:03,970 --> 00:08:05,970
>> Isso é tudo para o básico.

110
00:08:05,970 --> 00:08:09,960
Então, quais são as principais diferenças entre os dois tipos de declarações de matriz?

111
00:08:09,960 --> 00:08:13,960
Uma diferença é que o grande bloco de memória vai.

112
00:08:13,960 --> 00:08:17,660
Na primeira declaração, que eu vou chamar o tipo de suporte de matriz,

113
00:08:17,660 --> 00:08:20,300
embora isto seja de modo algum um nome convencional,

114
00:08:20,300 --> 00:08:22,480
ele vai para a pilha.

115
00:08:22,480 --> 00:08:27,450
Enquanto que no segundo, que eu vou chamar o tipo de ponteiro-array, ele vai na pilha.

116
00:08:27,450 --> 00:08:32,480
Isto significa que quando a função retorna, a matriz suporte será automaticamente desalocado,

117
00:08:32,480 --> 00:08:36,419
Considerando que, como você deve chamar Explicitamente livre na matriz de ponteiro

118
00:08:36,419 --> 00:08:38,010
ou então você tem um vazamento de memória.

119
00:08:38,010 --> 00:08:42,750
Além disso, a matriz de suporte não é, na verdade, uma variável.

120
00:08:42,750 --> 00:08:45,490
Isto é importante. É apenas um símbolo.

121
00:08:45,490 --> 00:08:49,160
Você pode pensar nisso como uma constante que o compilador escolhe para você.

122
00:08:49,160 --> 00:08:52,970
Isto significa que não podemos fazer algo como x + + com o tipo de suporte,

123
00:08:52,970 --> 00:08:56,240
que isto é perfeitamente válido com o tipo de ponteiro.

124
00:08:56,240 --> 00:08:58,270
>> O tipo de ponteiro é uma variável.

125
00:08:58,270 --> 00:09:01,510
Para o tipo de ponteiro, temos dois blocos separados de memória.

126
00:09:01,510 --> 00:09:06,060
A variável x em si é armazenado na pilha e está a apenas um único ponteiro,

127
00:09:06,060 --> 00:09:08,620
mas o grande bloco de memória é armazenada na pilha.

128
00:09:08,620 --> 00:09:11,010
A variável x na pilha apenas armazena o endereço

129
00:09:11,010 --> 00:09:14,010
do grande bloco de memória no heap.

130
00:09:14,010 --> 00:09:17,370
Uma implicação desta é com o tamanho do operador.

131
00:09:17,370 --> 00:09:22,480
Se você perguntar para o tamanho da matriz do suporte, que lhe dará o tamanho do grande bloco de memória,

132
00:09:22,480 --> 00:09:24,620
algo como 40 bytes,

133
00:09:24,620 --> 00:09:26,920
mas se você perguntar para o tamanho do tipo de ponteiro de matriz,

134
00:09:26,920 --> 00:09:32,740
ele vai te dar o tamanho da variável x em si, que o aparelho é provável apenas 4 bytes.

135
00:09:32,740 --> 00:09:36,530
Usando o tipo de ponteiro matriz, é impossível pedir diretamente para

136
00:09:36,530 --> 00:09:38,530
o tamanho do bloco de memória grande.

137
00:09:38,530 --> 00:09:42,530
Este não é geralmente muito mais de uma restrição, uma vez que muito raramente quer o tamanho

138
00:09:42,530 --> 00:09:46,980
do bloco do grande de memória, e nós geralmente pode calculá-lo se precisarmos.

139
00:09:46,980 --> 00:09:51,490
>> Finalmente, a matriz suporte acontece nos fornecer um atalho para inicializar uma matriz.

140
00:09:51,490 --> 00:09:56,130
Vamos ver como podemos escrever os 10 primeiros números inteiros até mesmo usando o initilization atalho.

141
00:10:11,220 --> 00:10:14,470
Com a matriz de ponteiro, não existe uma maneira de fazer um atalho como este.

142
00:10:14,470 --> 00:10:18,120
Esta é apenas uma introdução para o que você pode fazer com matrizes.

143
00:10:18,120 --> 00:10:20,990
Eles aparecem em quase todos os programas que você escreve.

144
00:10:20,990 --> 00:10:24,390
Espero que agora você pode ver a melhor maneira de fazer o aluno exemplo IDs

145
00:10:24,390 --> 00:10:26,710
a partir do início do vídeo.

146
00:10:26,710 --> 00:10:29,960
>> Meu nome é Rob Bowden, e este é o CS50.