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

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

3
00:00:12,780 --> 00:00:17,210
Ben, imos dicir que ten un programa que precisa para almacenar cinco identificacións estudantís.

4
00:00:17,210 --> 00:00:21,270
Pode parecer razoable ter cinco variables separadas.

5
00:00:21,270 --> 00:00:24,240
Por razóns que veremos de aquí a pouco, imos comezar a contar a partir de 0.

6
00:00:24,240 --> 00:00:30,700
As variables que teremos será id0 int, int id1, e así por diante.

7
00:00:30,700 --> 00:00:34,870
Calquera lóxica queremos facer nunha bolsa de estudante deberá ser copiado e pegado

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

9
00:00:36,870 --> 00:00:39,710
Se queres comprobar que os estudantes que ser en CS50,

10
00:00:39,710 --> 00:00:43,910
imos primeiro cómpre comprobar se id0 representa o estudante no curso.

11
00:00:43,910 --> 00:00:48,070
Entón, para facer o mesmo para o alumno que vén, nós imos ter copiar e pegar o código para id0

12
00:00:48,070 --> 00:00:54,430
e substituír todas as ocorrencias con id0 id1 e así por diante para id2, 3, e 4.

13
00:00:54,430 --> 00:00:57,560
>> Así que escoitar que hai que copiar e pegar,

14
00:00:57,560 --> 00:01:00,440
ten que comezar a pensar que hai unha solución mellor.

15
00:01:00,440 --> 00:01:05,360
Agora, o que se entende que non precisa de 5 identificacións estudantís, senón 7?

16
00:01:05,360 --> 00:01:09,570
Debe volver ao seu código fonte e engadir un ID5, un ID6,

17
00:01:09,570 --> 00:01:14,260
e copia e pega a lóxica para comprobar que as identificacións pertencen á clase para estas dúas novas identificacións.

18
00:01:14,260 --> 00:01:19,600
Non hai nada que chame todas estas identificacións xuntos, e así non hai ningunha forma de pedir

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

20
00:01:22,040 --> 00:01:26,120
Ben, agora entende que ten 100 identificacións estudantís.

21
00:01:26,120 --> 00:01:30,770
Está empezando a parecer menos que o ideal a necesidade de declarar por separado cada unha desas identificacións,

22
00:01:30,770 --> 00:01:33,760
e copiar e pegar calquera lóxica para esas novas identificacións.

23
00:01:33,760 --> 00:01:38,380
Pero quizais son determinados, e facemos isto para todos os 100 alumnos.

24
00:01:38,380 --> 00:01:42,240
Pero e se non sabe cantos alumnos realmente existen?

25
00:01:42,240 --> 00:01:47,320
Hai só uns alumnos ne seu programa ten que preguntar ao usuario o que n é.

26
00:01:47,320 --> 00:01:50,250
Uh oh. Iso non vai funcionar moi ben.

27
00:01:50,250 --> 00:01:53,820
O seu programa só funciona para un número constante de alumnos.

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

29
00:01:57,520 --> 00:01:59,930
Entón, o que é unha matriz?

30
00:01:59,930 --> 00:02:04,480
En moitas linguaxes de programación un tipo de matriz pode ser capaz de facer un pouco máis,

31
00:02:04,480 --> 00:02:09,960
pero aquí imos nos centrarse no básico estrutura de datos matriz, así como vai ver que en C.

32
00:02:09,960 --> 00:02:14,030
Unha matriz é só un bloque grande de memoria. É iso aí.

33
00:02:14,030 --> 00:02:17,770
Cando dicimos que temos unha matriz de 10 enteiros, iso só significa que temos algún bloque

34
00:02:17,770 --> 00:02:20,740
de memoria que é grande o suficiente para almacenar 10 enteiros separados.

35
00:02:29,930 --> 00:02:33,410
Asumindo que un número enteiro de 4 bytes, o que significa que un array de 10 enteiros

36
00:02:33,410 --> 00:02:37,180
é un bloque continuo de 40 bytes de memoria.

37
00:02:42,660 --> 00:02:46,280
Mesmo cando usa matrices multidimensionais que non imos para aquí,

38
00:02:46,280 --> 00:02:49,200
aínda é só un bloque grande de memoria.

39
00:02:49,200 --> 00:02:51,840
A notación multidimensional é só unha conveniencia.

40
00:02:51,840 --> 00:02:55,640
Se vostede ten un 3 por 3 matriz multidimensional de enteiros,

41
00:02:55,640 --> 00:03:00,650
a continuación, o programa vai realmente só tratar isto como un gran bloque de 36 bytes.

42
00:03:00,650 --> 00:03:05,460
O número total de números enteiros é de 3 veces 3, e cada número enteiro ocupa catro bytes.

43
00:03:05,460 --> 00:03:07,750
>> Imos dar un ollo a un exemplo básico.

44
00:03:07,750 --> 00:03:10,660
Podemos ver aquí dúas formas diferentes de matrices declarando.

45
00:03:15,660 --> 00:03:18,580
Nós imos ter que comentar un deles para fóra para que o programa compilar

46
00:03:18,580 --> 00:03:20,900
unha vez que declara x dúas veces.

47
00:03:20,900 --> 00:03:25,140
Nós imos dar un ollo a algunhas das diferenzas entre estes dous tipos de declaracións en un pouco.

48
00:03:25,140 --> 00:03:28,560
Ambas estas liñas de declarar unha matriz de tamaño 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
Poderiamos facilmente ter preguntado ao usuario un número enteiro positivo

51
00:03:34,460 --> 00:03:37,250
e usado ese enteiro como un número de elementos na nosa matriz.

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

53
00:03:41,960 --> 00:03:49,000
variables imaxinarios; x0, x1, x2, e así por diante ata o XN-1.

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

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

56
00:04:02,090 --> 00:04:09,660
Cando escribimos algo x [3], que eu vou ler como soporte x 3,

57
00:04:09,660 --> 00:04:13,090
Podes pensar niso como pedirlle a x3 imaxinario.

58
00:04:13,090 --> 00:04:17,519
Notar que unha matriz de tamaño N, isto significa que o número dentro dos soportes,

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

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

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

62
00:04:28,260 --> 00:04:31,260
Lembre que a matriz é un gran bloque de memoria.

63
00:04:31,260 --> 00:04:37,460
Supoñendo que se un número enteiro é de 4 bytes, o x matriz enteira é un bloque de 40 bytes de memoria.

64
00:04:37,460 --> 00:04:41,360
Así x0 refírese aos primeiros 4 bytes do bloque.

65
00:04:45,810 --> 00:04:49,230
X [1] refírese ás seguintes catro bytes e así por diante.

66
00:04:49,230 --> 00:04:53,760
Isto significa que o inicio x todo o programa sempre que seguir.

67
00:04:55,660 --> 00:04:59,840
Se quere usar x [400], a continuación, o programa sabe que iso é equivalente

68
00:04:59,840 --> 00:05:03,460
para só 1600 bytes tras o inicio do x.

69
00:05:03,460 --> 00:05:08,780
Onde temos 1.600 bytes? É só a 400 veces 4 bytes por enteiro.

70
00:05:08,780 --> 00:05:13,170
>> Antes de continuar, é moi importante entender que en C

71
00:05:13,170 --> 00:05:17,080
non hai aplicación do índice que utilizamos na matriz.

72
00:05:17,080 --> 00:05:23,180
O noso gran bloque é de só 10 enteiros longo, pero nada vai berrar con nós escribir x [20]

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

74
00:05:26,060 --> 00:05:28,240
O índice non ten sequera a ser un número.

75
00:05:28,240 --> 00:05:30,630
Pode ser calquera expresión arbitraria.

76
00:05:30,630 --> 00:05:34,800
No programa usan a variable i do loop for a índice para a matriz.

77
00:05:34,800 --> 00:05:40,340
Trátase de un patrón moi común, looping de i = 0 para a lonxitude da matriz,

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

79
00:05:43,350 --> 00:05:46,160
Deste xeito, circuíto efectivamente todo o conxunto,,

80
00:05:46,160 --> 00:05:50,600
e pode atribuír a cada punto na matriz ou usalo por algún cálculo.

81
00:05:50,600 --> 00:05:53,920
>> No primeiro bucle, i comeza en 0,

82
00:05:53,920 --> 00:05:58,680
e por iso vai asignar o punto 0 na matriz, o valor 0 veces 2.

83
00:05:58,680 --> 00:06:04,370
Entón eu incrementos, e asignar o primeiro lugar na matriz o valor 1 veces 2.

84
00:06:04,370 --> 00:06:10,170
Entón eu incrementa novo e así por diante ata que atribuímos á posición n-1 na matriz

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

86
00:06:13,370 --> 00:06:17,810
Entón, creamos unha matriz cos 10 primeiros números pares.

87
00:06:17,810 --> 00:06:21,970
Quizais gradúa sería un pouco mellor nome para a variable X,

88
00:06:21,970 --> 00:06:24,760
pero que daría cousas.

89
00:06:24,760 --> 00:06:30,210
O segundo bucle entón só imprime os valores que xa foron almacenados dentro da matriz.

90
00:06:30,210 --> 00:06:33,600
>> Imos tentar executar o programa cos dous tipos de declaracións de matriz

91
00:06:33,600 --> 00:06:36,330
e dar un ollo á saída do programa.

92
00:06:51,450 --> 00:06:57,020
Tanto como se pode ver, o programa compórtase do mesmo xeito para os dous tipos de declaracións.

93
00:06:57,020 --> 00:07:02,230
Imos tamén dar un ollo ao que acontece se mudarmos o primeiro ciclo de non parar en N

94
00:07:02,230 --> 00:07:05,040
pero dicir 10.000.

95
00:07:05,040 --> 00:07:07,430
Moito máis alá do fin da matriz.

96
00:07:14,700 --> 00:07:17,210
Oops. Poida que teña visto iso antes.

97
00:07:17,210 --> 00:07:20,440
Un fallo de segmento significa que o seu programa deixou de funcionar.

98
00:07:20,440 --> 00:07:24,430
Comezar a ver estes cando tocar as áreas da memoria que non debe tocar.

99
00:07:24,430 --> 00:07:27,870
Aquí estamos tocando 10.000 prazas ademais do inicio de x,

100
00:07:27,870 --> 00:07:31,920
que, evidentemente, é un lugar de memoria que non debe tocar.

101
00:07:31,920 --> 00:07:37,690
Así, a maioría de nós probablemente non tería accidentalmente poñer 10.000 en vez de N,

102
00:07:37,690 --> 00:07:42,930
pero o que facer algo máis sutil, como din gravación menor ou igual a N

103
00:07:42,930 --> 00:07:46,830
na súa condición de loop para en vez de menos de N.

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

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

106
00:07:54,510 --> 00:07:58,050
O programa non pode fallar neste caso, pero aínda así é un erro.

107
00:07:58,050 --> 00:08:01,950
En realidade, ese erro é tan común que ten o seu propio nome,

108
00:08:01,950 --> 00:08:03,970
un fóra por un erro.

109
00:08:03,970 --> 00:08:05,970
>> Isto é todo o básico.

110
00:08:05,970 --> 00:08:09,960
Entón, cales son as principais diferenzas entre os dous tipos de declaracións de matriz?

111
00:08:09,960 --> 00:08:13,960
Unha diferenza é que o gran bloque de memoria vai.

112
00:08:13,960 --> 00:08:17,660
Na primeira declaración, que eu vou chamar o tipo de admisión de matriz,

113
00:08:17,660 --> 00:08:20,300
aínda que isto sexa de xeito un nome convencional,

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

115
00:08:22,480 --> 00:08:27,450
Mentres que no segundo, que eu vou chamar o tipo de punteiro-array, que vai na pila.

116
00:08:27,450 --> 00:08:32,480
Isto significa que cando a función devolve a matriz soporte será automaticamente desalocado,

117
00:08:32,480 --> 00:08:36,419
Considerando que, como ten que chamar explicitamente libre na matriz de punteiro

118
00:08:36,419 --> 00:08:38,010
ou ben ten un baleirado de memoria.

119
00:08:38,010 --> 00:08:42,750
Ademais, a matriz de soporte non é, en realidade, unha variable.

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

121
00:08:45,490 --> 00:08:49,160
Podes pensar niso como unha constante que o compilador escolle para ti.

122
00:08:49,160 --> 00:08:52,970
Isto significa que non podemos facer algo como x + + co tipo de soporte,

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

124
00:08:56,240 --> 00:08:58,270
>> O tipo de punteiro é unha variable.

125
00:08:58,270 --> 00:09:01,510
Para o tipo de punteiro, temos dous bloques separados de memoria.

126
00:09:01,510 --> 00:09:06,060
A variable x en si é almacenado na pila e está a só un único punteiro,

127
00:09:06,060 --> 00:09:08,620
pero o gran bloque de memoria se garda na pila.

128
00:09:08,620 --> 00:09:11,010
A variable x na pila só almacena o enderezo

129
00:09:11,010 --> 00:09:14,010
do gran bloque de memoria no heap.

130
00:09:14,010 --> 00:09:17,370
Unha implicación desta é o tamaño do operador.

131
00:09:17,370 --> 00:09:22,480
Se preguntar para o tamaño da matriz do soporte, que lle dará o tamaño do gran bloque de memoria,

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

133
00:09:24,620 --> 00:09:26,920
pero se preguntar para o tamaño do tipo de punteiro de matriz,

134
00:09:26,920 --> 00:09:32,740
el vai che dar o tamaño da variable x en si, que o aparello é probable só 4 bytes.

135
00:09:32,740 --> 00:09:36,530
Usando o tipo de punteiro matriz, é imposible pedir directamente

136
00:09:36,530 --> 00:09:38,530
o tamaño do bloque de memoria grande.

137
00:09:38,530 --> 00:09:42,530
Este non é xeralmente moito máis dunha restrición, xa que moi raramente quere o tamaño

138
00:09:42,530 --> 00:09:46,980
do bloque do gran de memoria, e xeralmente pode calculalas lo se requirir.

139
00:09:46,980 --> 00:09:51,490
>> Finalmente, a matriz soporte acontece nos ofrecer un atallo para arrincar unha matriz.

140
00:09:51,490 --> 00:09:56,130
Imos ver como podemos escribir os 10 primeiros números enteiros ata usar o initilization ligazón.

141
00:10:11,220 --> 00:10:14,470
Coa matriz de punteiro, non existe unha forma de facer un atallo coma este.

142
00:10:14,470 --> 00:10:18,120
Esta é só unha introdución para o que podes facer con matrices.

143
00:10:18,120 --> 00:10:20,990
Aparecen en case todos os programas que escribe.

144
00:10:20,990 --> 00:10:24,390
Espero que agora podes ver a mellor forma de facer o alumno exemplo IDs

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

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