1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [Sección 6] [máis cómodo]

2
00:00:01,000 --> 00:00:04,000
[Rob Bowden] [Harvard University]

3
00:00:04,000 --> 00:00:09,000
[Esta é CS50.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> Podemos ir para a nosa sección de preguntas.

5
00:00:11,000 --> 00:00:17,000
Eu mandei a URL para o espazo antes.

6
00:00:17,000 --> 00:00:22,000
O inicio da sección de preguntas din-

7
00:00:22,000 --> 00:00:26,000
Ao parecer, eu non son enteiramente unsick é unha pregunta moi fácil

8
00:00:26,000 --> 00:00:28,000
só o que é valgrind?

9
00:00:28,000 --> 00:00:30,000
O que valgrind facer?

10
00:00:30,000 --> 00:00:34,000
Alguén quere dicir que valgrind fai?

11
00:00:34,000 --> 00:00:36,000
[Estudante] verifica a memoria.

12
00:00:36,000 --> 00:00:41,000
Si, valgrind é un verificador de memoria xeral.

13
00:00:41,000 --> 00:00:44,000
É, ao final, di que se tes algunha derrames de memoria,

14
00:00:44,000 --> 00:00:49,000
que é principalmente o que estamos usando para iso, porque se quere

15
00:00:49,000 --> 00:00:54,000
facer ben no conxunto de problemas ou se quere

16
00:00:54,000 --> 00:00:59,000
obter na tarxeta grande, ten que ter ningún escape de memoria que sexa,

17
00:00:59,000 --> 00:01:01,000
e no caso de que vostede un baleirado de memoria que non pode atopar,

18
00:01:01,000 --> 00:01:04,000
tamén ter presente que cando se abre un ficheiro

19
00:01:04,000 --> 00:01:07,000
e se non pecha-lo, iso é un baleirado de memoria.

20
00:01:07,000 --> 00:01:10,000
>> Unha morea de persoas están á procura de algún no que eles non están liberando

21
00:01:10,000 --> 00:01:15,000
cando, en realidade, non pechar o dicionario no primeiro paso.

22
00:01:15,000 --> 00:01:19,000
Tamén di que se ten calquera válido le ou escribe,

23
00:01:19,000 --> 00:01:22,000
o que significa que se tentar definir un valor

24
00:01:22,000 --> 00:01:26,000
que está alén do fin da pila e que non aconteza o fallo seg

25
00:01:26,000 --> 00:01:30,000
pero valgrind pega, como non debe realmente ser escrito alí,

26
00:01:30,000 --> 00:01:33,000
e entón vostede definitivamente non debe ter ningunha desas tamén.

27
00:01:33,000 --> 00:01:38,000
Como vostede usa Valgrind?

28
00:01:38,000 --> 00:01:42,000
Como vostede usa Valgrind?

29
00:01:42,000 --> 00:01:45,000
>> É unha cuestión xeral de

30
00:01:45,000 --> 00:01:49,000
tipo de executa-lo e ollar para a saída.

31
00:01:49,000 --> 00:01:51,000
A saída é sobrecargar unha morea de veces.

32
00:01:51,000 --> 00:01:54,000
Hai tamén erros de diversión onde se ten algo moi mal

33
00:01:54,000 --> 00:01:59,000
suceder en un loop, a continuación, el acabará por dicir, "Camiño erros de máis.

34
00:01:59,000 --> 00:02:03,000
Vou deixar de contar agora. "

35
00:02:03,000 --> 00:02:08,000
É basicamente saída textual que ten que analizar.

36
00:02:08,000 --> 00:02:13,000
Ao final, el vai dicir calquera escape de memoria que ten,

37
00:02:13,000 --> 00:02:16,000
cantos bloques, o que pode ser útil, pois

38
00:02:16,000 --> 00:02:20,000
se é un unfreed bloque, entón é xeralmente máis fácil de atopar

39
00:02:20,000 --> 00:02:23,000
de 1.000 bloques unfreed.

40
00:02:23,000 --> 00:02:26,000
1.000 bloques unfreed probablemente significa que non está liberando

41
00:02:26,000 --> 00:02:30,000
súas listas ligadas de forma adecuada ou algo así.

42
00:02:30,000 --> 00:02:32,000
Isto valgrind.

43
00:02:32,000 --> 00:02:35,000
>> Agora temos a nosa sección de preguntas,

44
00:02:35,000 --> 00:02:38,000
que non precisa facer a descarga.

45
00:02:38,000 --> 00:02:41,000
Podes premer no meu nome e tire-los no espazo.

46
00:02:41,000 --> 00:02:44,000
Agora prema en min.

47
00:02:44,000 --> 00:02:46,000
Revisión 1 será de pila, que estamos a facer en primeiro lugar.

48
00:02:46,000 --> 00:02:55,000
Revisión 2 será cola e Revisión 3 será a lista vinculada illadamente.

49
00:02:55,000 --> 00:02:58,000
Comezando coa nosa pila.

50
00:02:58,000 --> 00:03:02,000
Como se di aquí, unha pila é unha das máis básicas,

51
00:03:02,000 --> 00:03:07,000
estruturas de datos fundamentais da ciencia da computación.

52
00:03:07,000 --> 00:03:11,000
O exemplo prototípico é moi

53
00:03:11,000 --> 00:03:13,000
a pila de bandexas no salón de cea.

54
00:03:13,000 --> 00:03:16,000
É basicamente sempre que está a ser presentado a unha pila,

55
00:03:16,000 --> 00:03:20,000
alguén vai dicir: "Oh, como unha pila de bandexas."

56
00:03:20,000 --> 00:03:22,000
Vostede empilhar as bandexas para arriba.

57
00:03:22,000 --> 00:03:24,000
Entón cando vai tirar unha bandexa,

58
00:03:24,000 --> 00:03:31,000
a primeira bandexa que está a ser levado é a última que foi colocado na pila.

59
00:03:31,000 --> 00:03:34,000
A pila tamén, como se di aquí-

60
00:03:34,000 --> 00:03:37,000
temos o segmento de memoria denominada pila.

61
00:03:37,000 --> 00:03:40,000
E por que é chamado de pila?

62
00:03:40,000 --> 00:03:42,000
>> Porque, como unha estrutura de datos de pila,

63
00:03:42,000 --> 00:03:46,000
el empurra e aparece pila de cadros na pila,

64
00:03:46,000 --> 00:03:53,000
onde cadros de pila son como unha chamada específica dunha función.

65
00:03:53,000 --> 00:03:57,000
E como unha pila, sempre ten que voltar

66
00:03:57,000 --> 00:04:03,000
a partir dunha chamada de función antes de descender en cadros menores pila de novo.

67
00:04:03,000 --> 00:04:08,000
Non podes ter principal chamada barra chamada foo e retorno barra directamente principal.

68
00:04:08,000 --> 00:04:14,000
El sempre ten que seguir a pila correcta empurrando e popping.

69
00:04:14,000 --> 00:04:18,000
As dúas operacións, como eu dixen, son push e pop.

70
00:04:18,000 --> 00:04:20,000
Estes son termos universais.

71
00:04:20,000 --> 00:04:26,000
Debes saber push e pop en termos de pilas, non importa o que.

72
00:04:26,000 --> 00:04:28,000
Imos ver colas son un pouco diferente.

73
00:04:28,000 --> 00:04:32,000
El realmente non ten un termo universal, pero push e pop son universais para pilas.

74
00:04:32,000 --> 00:04:34,000
Push é só poñer na pila.

75
00:04:34,000 --> 00:04:37,000
Pop é sacar a pila.

76
00:04:37,000 --> 00:04:43,000
E vemos aquí temos a nosa pila typedef struct,

77
00:04:43,000 --> 00:04:46,000
por iso temos cordas char **.

78
00:04:46,000 --> 00:04:51,000
Non sexa con medo por calquera **.

79
00:04:51,000 --> 00:04:54,000
Isto vai acabar sendo unha matriz de cadeas

80
00:04:54,000 --> 00:04:58,000
ou unha matriz de punteiros para caracteres, onde

81
00:04:58,000 --> 00:05:00,000
punteiros para personaxes tenden a ser cordas.

82
00:05:00,000 --> 00:05:05,000
Non ten que ser cadeas, pero aquí, eles van ser strings.

83
00:05:05,000 --> 00:05:08,000
>> Nós temos unha matriz de cadeas.

84
00:05:08,000 --> 00:05:14,000
Temos un tamaño, o que representa cantos elementos están na pila,

85
00:05:14,000 --> 00:05:19,000
e despois temos a capacidade, que é o número de elementos pode ser na pila.

86
00:05:19,000 --> 00:05:22,000
A capacidade que comezar como algo maior que 1,

87
00:05:22,000 --> 00:05:27,000
pero o tamaño vai comezar como 0.

88
00:05:27,000 --> 00:05:36,000
Agora, hai basicamente tres xeitos diferentes que pode pensar dunha pila.

89
00:05:36,000 --> 00:05:39,000
Así, hai probablemente máis, pero as dúas principais formas son

90
00:05:39,000 --> 00:05:43,000
pode implementar lo usando unha matriz, ou pode implementar lo usando unha lista ligada.

91
00:05:43,000 --> 00:05:48,000
Listas ligadas son unha especie de trivial para facer pilas de.

92
00:05:48,000 --> 00:05:51,000
É moi fácil facer unha pila empregando listas ligadas,

93
00:05:51,000 --> 00:05:55,000
Entón, aquí, imos facer unha pila empregando matrices,

94
00:05:55,000 --> 00:05:59,000
e en seguida, usando matrices, tamén hai dúas formas que pode pensar sobre iso.

95
00:05:59,000 --> 00:06:01,000
Antes, cando dixo que temos unha capacidade para a pila,

96
00:06:01,000 --> 00:06:04,000
para que poida axustar un elemento na pila.

97
00:06:04,000 --> 00:06:09,000
>> O único xeito que podería acontecer é así que acertar 10 elementos, entón está feito.

98
00:06:09,000 --> 00:06:13,000
Podes saber que existe un límite superior de 10 cousas no mundo

99
00:06:13,000 --> 00:06:16,000
que nunca vai ter máis que 10 cousas na súa pila,

100
00:06:16,000 --> 00:06:20,000
caso en que pode ter un límite superior do tamaño do seu stack.

101
00:06:20,000 --> 00:06:23,000
Ou podería ter a súa pila ser ilimitado,

102
00:06:23,000 --> 00:06:27,000
pero se está facendo unha matriz, o que significa que cada vez que acertar 10 elementos,

103
00:06:27,000 --> 00:06:29,000
entón vai ter que medrar para 20 elementos, e cando bate 20 elementos,

104
00:06:29,000 --> 00:06:33,000
vai ter que medrar a súa matriz de 30 elementos ou 40 elementos.

105
00:06:33,000 --> 00:06:37,000
Está indo a necesidade de aumentar a capacidade, que é o que imos facer aquí.

106
00:06:37,000 --> 00:06:40,000
Cada vez que alcanzar o tamaño máximo da nosa pila,

107
00:06:40,000 --> 00:06:46,000
cando empurrar outra cousa, nós imos ter que aumentar a capacidade.

108
00:06:46,000 --> 00:06:50,000
Aquí, nós impulso declarado como impulso bool (char * str).

109
00:06:50,000 --> 00:06:54,000
* Str Char é a cadea que estamos empurrando para a pila,

110
00:06:54,000 --> 00:06:58,000
bool e só se se conseguimos ou non.

111
00:06:58,000 --> 00:07:00,000
>> Como non?

112
00:07:00,000 --> 00:07:04,000
Cal é a única circunstancia que pode pensar

113
00:07:04,000 --> 00:07:07,000
onde iriamos ter voltar falso?

114
00:07:07,000 --> 00:07:09,000
Si

115
00:07:09,000 --> 00:07:12,000
[Estudante] Se está cheo e estamos a usar unha implementación limitada.

116
00:07:12,000 --> 00:07:17,000
Si, así como nós definimos, el respondeu

117
00:07:17,000 --> 00:07:23,000
se é total e estamos a usar unha aplicación limitada.

118
00:07:23,000 --> 00:07:26,000
Entón, nós definitivamente return false.

119
00:07:26,000 --> 00:07:31,000
Así que alcanzou 10 cousas na matriz, non pode caber 11, así volvemos falso.

120
00:07:31,000 --> 00:07:32,000
E se é ilimitado? Si

121
00:07:32,000 --> 00:07:38,000
Se non pode ampliar a matriz por algún motivo.

122
00:07:38,000 --> 00:07:43,000
Si, entón a memoria é un recurso limitado,

123
00:07:43,000 --> 00:07:51,000
e, finalmente, manter as cousas empurrando para a pila de unha e outra vez,

124
00:07:51,000 --> 00:07:54,000
imos tentar reservar un maior matriz para caber

125
00:07:54,000 --> 00:07:59,000
maior capacidade, malloc e ou o que estamos usando vai voltar falso.

126
00:07:59,000 --> 00:08:02,000
Ben, malloc volverá nulo.

127
00:08:02,000 --> 00:08:05,000
>> Teña en conta que, cada vez que sempre chamar malloc, ten que comprobar a ver se

128
00:08:05,000 --> 00:08:12,000
retorna nulo ou ben que é unha dedución corrección.

129
00:08:12,000 --> 00:08:17,000
Dende que nós queremos ter unha pila ilimitada,

130
00:08:17,000 --> 00:08:21,000
o único caso que imos estar retornando teito é se intentemos

131
00:08:21,000 --> 00:08:26,000
aumentar a capacidade e malloc ou o que retorna falso.

132
00:08:26,000 --> 00:08:30,000
Entón pop non ten argumentos,

133
00:08:30,000 --> 00:08:37,000
e devolve a cadea de caracteres que está na parte superior da pila.

134
00:08:37,000 --> 00:08:41,000
Todo o que foi máis recentemente colocado na pila é o pop volve,

135
00:08:41,000 --> 00:08:44,000
e tamén elimina da pila.

136
00:08:44,000 --> 00:08:50,000
E noten que retorna nulo se non hai nada na pila.

137
00:08:50,000 --> 00:08:53,000
É sempre posible que a pila está baleira.

138
00:08:53,000 --> 00:08:55,000
En Java, se está acostumado a iso, ou outras linguas,

139
00:08:55,000 --> 00:09:01,000
intentando aparecer a partir dunha pila baleira pode causar unha excepción ou algo así.

140
00:09:01,000 --> 00:09:09,000
>> Pero en C, nulo é unha especie de gran cantidade de casos como tratar con estes problemas.

141
00:09:09,000 --> 00:09:13,000
Voltar nulo é como nós imos para significar que a pila estaba baleiro.

142
00:09:13,000 --> 00:09:16,000
Nós fornecen o código que ha probar a funcionalidade do seu stack,

143
00:09:16,000 --> 00:09:19,000
aplicar push e pop.

144
00:09:19,000 --> 00:09:23,000
Iso non vai ser unha morea de código.

145
00:09:23,000 --> 00:09:40,000
Vou, en realidade, antes de facelo, Consello, suxestión-

146
00:09:40,000 --> 00:09:44,000
Se aínda non viu, malloc non é a única función

147
00:09:44,000 --> 00:09:47,000
que aloca memoria na pila para ti.

148
00:09:47,000 --> 00:09:51,000
Hai unha familia de funcións alloc.

149
00:09:51,000 --> 00:09:53,000
O primeiro é malloc, que está acostumado.

150
00:09:53,000 --> 00:09:56,000
Entón hai calloc, que fai a mesma cousa que malloc,

151
00:09:56,000 --> 00:09:59,000
pero vai zerar todo para ti.

152
00:09:59,000 --> 00:10:04,000
Se vostede sempre quixo para definir todo para null despois mallocing algo

153
00:10:04,000 --> 00:10:06,000
ten que ter usado só calloc, en primeiro lugar, en vez de escribir

154
00:10:06,000 --> 00:10:09,000
un loop for a zerar todo o bloque de memoria.

155
00:10:09,000 --> 00:10:15,000
>> Realloc é como malloc e ten unha morea de casos especiais,

156
00:10:15,000 --> 00:10:19,000
pero basicamente o que fai é realloc

157
00:10:19,000 --> 00:10:24,000
leva un punteiro que xa fora asignado.

158
00:10:24,000 --> 00:10:27,000
Realloc é a función que quere estar prestando atención aquí.

159
00:10:27,000 --> 00:10:31,000
É preciso un punteiro que xa fora devolto a partir de malloc.

160
00:10:31,000 --> 00:10:35,000
Imos dicir que solicitar malloc un punteiro de 10 bytes.

161
00:10:35,000 --> 00:10:38,000
Entón, máis tarde entender que quería 20 bytes,

162
00:10:38,000 --> 00:10:42,000
Entón chama realloc en que o punteiro con 20 bytes,

163
00:10:42,000 --> 00:10:47,000
realloc e automaticamente copiar todo para ti.

164
00:10:47,000 --> 00:10:51,000
Se acaba de chamar malloc novo, como eu teño un bloque de 10 bytes.

165
00:10:51,000 --> 00:10:53,000
Agora eu teño un bloque de 20 bytes,

166
00:10:53,000 --> 00:10:58,000
entón eu malloc 20 bytes, entón eu teño que copiar manualmente ao longo dos 10 bytes de o primeiro

167
00:10:58,000 --> 00:11:01,000
na segunda cousa e entón libre o primeiro.

168
00:11:01,000 --> 00:11:04,000
Realloc vai tratar con isto para ti.

169
00:11:04,000 --> 00:11:11,000
>> Observe a sinatura vai ser void *,

170
00:11:11,000 --> 00:11:15,000
que é só devolver un punteiro para o bloque de memoria,

171
00:11:15,000 --> 00:11:17,000
a continuación, void * PTR.

172
00:11:17,000 --> 00:11:22,000
Podes pensar en void * como un punteiro xenérico.

173
00:11:22,000 --> 00:11:27,000
Xeralmente, nunca xestione void *,

174
00:11:27,000 --> 00:11:30,000
malloc pero está retornando un void *, e entón é só usar como

175
00:11:30,000 --> 00:11:34,000
é dicir, en realidade, vai ser un char *.

176
00:11:34,000 --> 00:11:37,000
Void * anterior, que fora devolto por malloc

177
00:11:37,000 --> 00:11:41,000
agora vai ser pasado para realloc e tamaño

178
00:11:41,000 --> 00:11:49,000
é o novo número de bytes que quere reservar para que a súa nova capacidade.

179
00:11:49,000 --> 00:11:57,000
Eu vou te dar un par de minutos, e facelo no noso espazo.

180
00:11:57,000 --> 00:12:02,000
Comece Revisión 1.

181
00:12:16,000 --> 00:12:21,000
Vou deixar despois espero que sobre tempo suficiente para aplicar push,

182
00:12:21,000 --> 00:12:24,000
e entón eu vou dar-lle outra rotura de facer pop.

183
00:12:24,000 --> 00:12:27,000
Pero realmente non é que o código moito en todo.

184
00:12:27,000 --> 00:12:35,000
A maior parte do código é probablemente o material en expansión, a expansión da capacidade.

185
00:12:35,000 --> 00:12:39,000
Ok, non hai presión para ser completamente feito,

186
00:12:39,000 --> 00:12:47,000
pero sempre que sente que está no camiño certo, iso é bo.

187
00:12:47,000 --> 00:12:53,000
>> Alguén ten algún código que sentirse cómodo comigo tirando para arriba?

188
00:12:53,000 --> 00:12:59,000
Si, eu vou, pero alguén ten algún código que podes tirar cara arriba?

189
00:12:59,000 --> 00:13:05,000
Ok, pode comezar, garda-lo, sexa o que sexa?

190
00:13:05,000 --> 00:13:09,000
Eu sempre esquezo que paso.

191
00:13:09,000 --> 00:13:15,000
Ok, ollando para push,

192
00:13:15,000 --> 00:13:18,000
quere explicar o seu código?

193
00:13:18,000 --> 00:13:24,000
[Estudante] Primeiro de todo, eu aumentei o tamaño.

194
00:13:24,000 --> 00:13:28,000
Eu creo que talvez debería ter que de calquera xeito, eu aumentei o tamaño,

195
00:13:28,000 --> 00:13:31,000
e eu ver se é menos que a capacidade.

196
00:13:31,000 --> 00:13:36,000
E se é menos que a capacidade, eu engadir á matriz que xa temos.

197
00:13:36,000 --> 00:13:42,000
E se non é, eu multiplicar a capacidade por 2,

198
00:13:42,000 --> 00:13:50,000
e eu realocar a matriz cordas para algo cun tamaño maior capacidade agora.

199
00:13:50,000 --> 00:13:55,000
E despois, se falla, eu digo o usuario e voltar falso,

200
00:13:55,000 --> 00:14:04,000
e se está ben, entón eu coloque a corda no novo local.

201
00:14:04,000 --> 00:14:07,000
>> [Rob B.] Nótese tamén que a un operador bit a bit agradable aquí

202
00:14:07,000 --> 00:14:09,000
a multiplicar por 2.

203
00:14:09,000 --> 00:14:11,000
Lembre, desvío á esquerda é sempre vai ser multiplicada por 2.

204
00:14:11,000 --> 00:14:15,000
Desprazamento cara á dereita está dividido por dous, sempre que lembre que isto significa

205
00:14:15,000 --> 00:14:18,000
dividir por 2, como en un enteiro dividido por 2.

206
00:14:18,000 --> 00:14:20,000
Pode truncar a 1 aquí ou alí.

207
00:14:20,000 --> 00:14:26,000
Pero cambio deixada por un sempre vai ser multiplicado por 2,

208
00:14:26,000 --> 00:14:32,000
a menos que desbordan os límites do número enteiro, e entón non vai ser.

209
00:14:32,000 --> 00:14:34,000
Un comentario lateral.

210
00:14:34,000 --> 00:14:39,000
Eu gusto de facer iso non vai cambiar a codificación calquera caso,

211
00:14:39,000 --> 00:14:48,000
pero me gustaría facer algo así.

212
00:14:48,000 --> 00:14:51,000
El realmente está indo a facelo un pouco máis.

213
00:15:04,000 --> 00:15:08,000
Quizais este non é o caso perfecto para amosar que,

214
00:15:08,000 --> 00:15:14,000
pero eu gosto de segmento que nestes bloques de-

215
00:15:14,000 --> 00:15:17,000
ok, se iso acontecer, entón eu vou facer algo,

216
00:15:17,000 --> 00:15:19,000
e, a continuación, a función está feito.

217
00:15:19,000 --> 00:15:22,000
Eu non teño de role meus ollos todo o camiño ata a función

218
00:15:22,000 --> 00:15:25,000
para ver o que pasa despois do outro.

219
00:15:25,000 --> 00:15:27,000
E, se iso acontecer, entón eu volver.

220
00:15:27,000 --> 00:15:30,000
Tamén ten o beneficio adicional de todo agradable para alén deste

221
00:15:30,000 --> 00:15:33,000
agora é desprazado cara á esquerda unha vez.

222
00:15:33,000 --> 00:15:40,000
Eu xa non precisa que sempre preto ridiculamente longas colas,

223
00:15:40,000 --> 00:15:45,000
entón eses 4 bytes pode axudar, e tamén a algo máis á esquerda é,

224
00:15:45,000 --> 00:15:48,000
a menos resaltado se sentiría se lle gusta, todo ben, eu teño que lembrar

225
00:15:48,000 --> 00:15:53,000
Eu estou actualmente en un loop while dentro dun interior máis de un loop.

226
00:15:53,000 --> 00:15:58,000
En calquera lugar pode facelo de retorno inmediato, eu medio que me gusta.

227
00:15:58,000 --> 00:16:05,000
É totalmente opcional e non se espera de calquera forma.

228
00:16:05,000 --> 00:16:12,000
>> [Estudante] Debe haber un tamaño - na condición de fallo?

229
00:16:12,000 --> 00:16:19,000
A condición de fallo aquí é que nós non realloc, entón si.

230
00:16:19,000 --> 00:16:22,000
Observe como na súa condición de fallo, presuntamente,

231
00:16:22,000 --> 00:16:26,000
a non ser que o material libre despois, estamos sempre vai fallar

232
00:16:26,000 --> 00:16:29,000
non importa cantas veces nós tentar empurrar algo.

233
00:16:29,000 --> 00:16:32,000
Se seguimos a empuxar, imos manter o tamaño do incremento,

234
00:16:32,000 --> 00:16:36,000
aínda que non estamos poñendo todo na pila.

235
00:16:36,000 --> 00:16:39,000
Normalmente non aumentar o tamaño ata

236
00:16:39,000 --> 00:16:43,000
despois logramos poñelas na pila.

237
00:16:43,000 --> 00:16:50,000
Podemos facer, por exemplo, ou aquí e aquí.

238
00:16:50,000 --> 00:16:56,000
E entón, en vez de dicir s.size capacidade ≤, é menos que a capacidade,

239
00:16:56,000 --> 00:17:01,000
só porque nos cambiamos onde estaba todo.

240
00:17:01,000 --> 00:17:07,000
>> E lembre, o único lugar que podería voltar falso

241
00:17:07,000 --> 00:17:14,000
é aquí onde realloc retornou nulo,

242
00:17:14,000 --> 00:17:19,000
e se ocorrer de se lembrar de erro estándar,

243
00:17:19,000 --> 00:17:22,000
quizais pode considerar este un caso en que quere imprimir un erro estándar,

244
00:17:22,000 --> 00:17:26,000
stderr para fprintf en vez de só imprimir directamente á saída estándar.

245
00:17:26,000 --> 00:17:31,000
Unha vez máis, iso non é unha expectativa, pero é un erro,

246
00:17:31,000 --> 00:17:41,000
printf escribir, entón podes querer facelo imprimir ao erro estándar en vez de saída estándar.

247
00:17:41,000 --> 00:17:44,000
>> Alguén ten algunha outra cousa a notar? Si

248
00:17:44,000 --> 00:17:47,000
[Estudante] Pode ir ata o [inaudível]?

249
00:17:47,000 --> 00:17:55,000
[Rob B.] Si, o binariness real del ou só o que é?

250
00:17:55,000 --> 00:17:57,000
[Estudante] Entón multiplicar isto por 2?

251
00:17:57,000 --> 00:17:59,000
[Rob B.] Si, basicamente.

252
00:17:59,000 --> 00:18:11,000
En terra binario, sempre temos o conxunto de díxitos.

253
00:18:11,000 --> 00:18:22,000
Cambiando esta esquerda por unha basicamente inserir-lo aquí no lado dereito.

254
00:18:22,000 --> 00:18:25,000
Voltar iso, basta lembrar que todo en binario

255
00:18:25,000 --> 00:18:28,000
é unha potencia de 2, polo que esta representa 2 a 0,

256
00:18:28,000 --> 00:18:30,000
este 2 a 1, 2 para a esta 2.

257
00:18:30,000 --> 00:18:33,000
Para inserir un 0 para o lado dereito agora, só cambiar todo de novo.

258
00:18:33,000 --> 00:18:38,000
O que adoitaba ser de 2 a 0 é agora 2 a 1, 2 e é o 2.

259
00:18:38,000 --> 00:18:41,000
O lado dereito que inserimos

260
00:18:41,000 --> 00:18:44,000
é necesariamente vai ser 0,

261
00:18:44,000 --> 00:18:46,000
o que ten sentido.

262
00:18:46,000 --> 00:18:49,000
Se xa se multiplicar un número por 2, iso non vai acabar estraño,

263
00:18:49,000 --> 00:18:54,000
de xeito que o 2 ata o lugar de 0 debe ser de 0,

264
00:18:54,000 --> 00:18:59,000
e é iso que eu medio que alertou sobre antes e se fai pasar para cambiar

265
00:18:59,000 --> 00:19:01,000
ademais do número de bits de un número enteiro,

266
00:19:01,000 --> 00:19:04,000
entón este é un vai acabar saíndo.

267
00:19:04,000 --> 00:19:10,000
Esa é a única preocupación se ocorrer de estar lidando con capacidades moi grandes.

268
00:19:10,000 --> 00:19:15,000
Pero nese punto, entón está lidando con unha matriz de miles de millóns de cousas,

269
00:19:15,000 --> 00:19:25,000
que pode non caber na memoria de calquera maneira.

270
00:19:25,000 --> 00:19:31,000
>> Agora podemos chegar ao pop, o que é aínda máis fácil.

271
00:19:31,000 --> 00:19:36,000
Vostede podería facer como se ocorrer de aparecer unha morea,

272
00:19:36,000 --> 00:19:38,000
e agora está na metade da súa capacidade novo.

273
00:19:38,000 --> 00:19:42,000
Vostede podería realloc para diminuír a cantidade de memoria que ten,

274
00:19:42,000 --> 00:19:47,000
pero non ten que se preocupar con iso, entón o caso realloc só vai ser

275
00:19:47,000 --> 00:19:50,000
crecente memoria, nunca baixar a memoria,

276
00:19:50,000 --> 00:19:59,000
que vai facer de super pop sinxelo.

277
00:19:59,000 --> 00:20:02,000
Agora filas, que van ser como pilas,

278
00:20:02,000 --> 00:20:06,000
pero a orde que Tomé as cousas é invertida.

279
00:20:06,000 --> 00:20:10,000
O exemplo prototípico dunha fila é unha liña,

280
00:20:10,000 --> 00:20:12,000
entón eu creo que se fose inglés, eu diría

281
00:20:12,000 --> 00:20:17,000
un exemplo prototípico dunha fila é unha fila.

282
00:20:17,000 --> 00:20:22,000
Así como unha liña, se é a primeira persoa en liña,

283
00:20:22,000 --> 00:20:24,000
espera ser a primeira persoa fóra da liña.

284
00:20:24,000 --> 00:20:31,000
Se vostede é a última persoa na liña, vai ser a última persoa atendida.

285
00:20:31,000 --> 00:20:35,000
Chamamos ese estándar FIFO, mentres pila era patrón LIFO.

286
00:20:35,000 --> 00:20:40,000
Estas palabras son moi universal.

287
00:20:40,000 --> 00:20:46,000
>> Como pilas e diferenza de matrices, as colas normalmente non permiten o acceso a elementos no medio.

288
00:20:46,000 --> 00:20:50,000
Aquí, unha pila, temos push e pop.

289
00:20:50,000 --> 00:20:54,000
Aquí, pasa que temos chamado enqueue e dequeue.

290
00:20:54,000 --> 00:20:58,000
Eu tamén oín-los chamado de quenda e unshift.

291
00:20:58,000 --> 00:21:02,000
Eu oín persoas diciren push e pop para tamén aplicar a filas.

292
00:21:02,000 --> 00:21:05,000
Oín inserir, eliminar,

293
00:21:05,000 --> 00:21:11,000
para push e pop, se está falando de pilas, está empurrando e popping.

294
00:21:11,000 --> 00:21:16,000
Se está falando sobre filas, pode escoller as palabras que desexa utilizar

295
00:21:16,000 --> 00:21:23,000
para a inserción e eliminación, e non hai consenso sobre o que debe ser chamado.

296
00:21:23,000 --> 00:21:27,000
Pero aquí temos enqueue e dequeue.

297
00:21:27,000 --> 00:21:37,000
Agora, a estrutura é case idéntico ao da estrutura de pila.

298
00:21:37,000 --> 00:21:40,000
Pero temos que manter o control de cabeza.

299
00:21:40,000 --> 00:21:44,000
Coido que di aquí, pero por que necesitamos da cabeza?

300
00:21:53,000 --> 00:21:57,000
Os prototipos son practicamente idénticos ao push e pop.

301
00:21:57,000 --> 00:21:59,000
Podes pensar niso como push e pop.

302
00:21:59,000 --> 00:22:08,000
A única diferenza é pop volve en vez da última, está retornando o primeiro.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, ou algo así.

304
00:22:12,000 --> 00:22:14,000
E aquí está o principio.

305
00:22:14,000 --> 00:22:17,000
A nosa cola está completamente cheo, por iso hai catro elementos nel.

306
00:22:17,000 --> 00:22:21,000
O fin da nosa fila é actualmente de 2,

307
00:22:21,000 --> 00:22:24,000
e agora imos para introducir algo máis.

308
00:22:24,000 --> 00:22:29,000
>> Cando queremos introducir ese algo máis, o que fixemos para a versión de pila

309
00:22:29,000 --> 00:22:36,000
é que estenden o noso bloque de memoria.

310
00:22:36,000 --> 00:22:40,000
Cal é o problema con iso?

311
00:22:40,000 --> 00:22:45,000
[Estudante] move o 2.

312
00:22:45,000 --> 00:22:51,000
O que eu dixen antes sobre o fin da cola,

313
00:22:51,000 --> 00:22:57,000
iso non ten sentido que comezan o 1,

314
00:22:57,000 --> 00:23:01,000
entón queremos dequeue 1, entón dequeue 3, entón dequeue 4,

315
00:23:01,000 --> 00:23:05,000
entón dequeue 2, entón desenfileirar este.

316
00:23:05,000 --> 00:23:08,000
Non podemos usar realloc agora,

317
00:23:08,000 --> 00:23:11,000
ou, como mínimo, ten que usar realloc dun xeito diferente.

318
00:23:11,000 --> 00:23:15,000
Pero probablemente non debe só usar realloc.

319
00:23:15,000 --> 00:23:18,000
Vai ter que copiar manualmente súa memoria.

320
00:23:18,000 --> 00:23:21,000
>> Existen dúas funcións de copiar a memoria.

321
00:23:21,000 --> 00:23:25,000
Hai memcopy e memmove.

322
00:23:25,000 --> 00:23:29,000
Actualmente estou lendo as páxinas do manual para ver cal deles vai querer empregar.

323
00:23:29,000 --> 00:23:35,000
Ok, memcopy, a diferenza é

324
00:23:35,000 --> 00:23:38,000
que memcopy e memmove, un trata do caso correctamente

325
00:23:38,000 --> 00:23:41,000
onde está copiando a unha rexión que pasa a sobrepasar-se a rexión

326
00:23:41,000 --> 00:23:46,000
está copiando.

327
00:23:46,000 --> 00:23:50,000
Memcopy non tratar con isto. Memmove fai.

328
00:23:50,000 --> 00:23:59,000
Podes pensar no problema como-

329
00:23:59,000 --> 00:24:09,000
digamos que quero copiar este cara,

330
00:24:09,000 --> 00:24:13,000
estes catro para este cara.

331
00:24:13,000 --> 00:24:16,000
Ao final, o que a matriz debe ser semellante

332
00:24:16,000 --> 00:24:26,000
tras a copia é 2, 1, 2, 1, 3, 4, e, a continuación, algunhas cousas ao final.

333
00:24:26,000 --> 00:24:29,000
Pero esta é dependente da orde en que, en realidade, copiar,

334
00:24:29,000 --> 00:24:32,000
pois, se non considerarmos o feito de que a rexión que está copiando en

335
00:24:32,000 --> 00:24:35,000
igual que estamos copiando,

336
00:24:35,000 --> 00:24:46,000
entón podemos facer como comezo aquí, por favor copie o 2 ao lugar que quere ir,

337
00:24:46,000 --> 00:24:52,000
a continuación, pasar os nosos punteiros para adiante.

338
00:24:52,000 --> 00:24:56,000
>> Agora imos estar aquí e aquí, e agora queremos copiar

339
00:24:56,000 --> 00:25:04,000
este cara esa cara e mover os nosos punteiros para adiante.

340
00:25:04,000 --> 00:25:07,000
O que imos acabar quedando é de 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
en vez do 2 apropiado, 1, 2, 1, 3, 4, porque

342
00:25:10,000 --> 00:25:15,000
2, 1 superou o orixinal 3, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove tirantes que correctamente.

344
00:25:19,000 --> 00:25:23,000
Neste caso, basicamente, só Utilice sempre memmove

345
00:25:23,000 --> 00:25:26,000
porque trata correctamente.

346
00:25:26,000 --> 00:25:29,000
Xeralmente non realizar calquera peor.

347
00:25:29,000 --> 00:25:32,000
A idea é, en vez de comezar de inicio e copia deste xeito

348
00:25:32,000 --> 00:25:35,000
como fixemos aquí, que comeza a partir do final e copia,

349
00:25:35,000 --> 00:25:38,000
e, nese caso, vostede non pode ter un problema.

350
00:25:38,000 --> 00:25:40,000
Non hai perda de rendemento.

351
00:25:40,000 --> 00:25:47,000
Sempre use memmove. Nunca te preocupes memcopy.

352
00:25:47,000 --> 00:25:51,000
E é aí onde vai ter que por separado memmove

353
00:25:51,000 --> 00:26:01,000
a porción envolta en torno a súa cola.

354
00:26:01,000 --> 00:26:04,000
Non te preocupes se non completamente feito.

355
00:26:04,000 --> 00:26:10,000
Isto é máis difícil do que pila, pop push, e.

356
00:26:10,000 --> 00:26:15,000
>> Alguén ten algún código que podería traballar?

357
00:26:15,000 --> 00:26:21,000
Mesmo completamente incompleto?

358
00:26:21,000 --> 00:26:23,000
[Estudante] Si, é completamente incompleta, con todo.

359
00:26:23,000 --> 00:26:27,000
Completamente incompleta é bo, sempre que-pode gardar a revisión?

360
00:26:27,000 --> 00:26:32,000
Eu esquezo que en cada momento.

361
00:26:32,000 --> 00:26:39,000
Ok, ignorando o que ocorre cando necesitamos cambiar o tamaño as cousas.

362
00:26:39,000 --> 00:26:42,000
Ignorar por completo Adaptación.

363
00:26:42,000 --> 00:26:49,000
Explicar este código.

364
00:26:49,000 --> 00:26:54,000
Estou comprobando en primeiro lugar, o tamaño é inferior a primeira copia de todas

365
00:26:54,000 --> 00:27:01,000
e despois diso, eu insiro me tomar a cabeza + tamaño,

366
00:27:01,000 --> 00:27:05,000
e eu que seguro que implica a capacidade da matriz,

367
00:27:05,000 --> 00:27:08,000
e eu introducir a nova cadea nesa posición.

368
00:27:08,000 --> 00:27:12,000
Entón eu aumentar o tamaño e voltar true.

369
00:27:12,000 --> 00:27:22,000
>> [Rob B.] Este é sempre un dos casos en que vai querer estar usando mod.

370
00:27:22,000 --> 00:27:25,000
Calquera tipo de caso onde enrolar, se pensas que enrolar,

371
00:27:25,000 --> 00:27:29,000
o pensamento inmediato debe ser mod.

372
00:27:29,000 --> 00:27:36,000
Como unha optimización rápido / facer o seu código dunha liña máis curta,

373
00:27:36,000 --> 00:27:42,000
entender que a liña inmediatamente logo deste

374
00:27:42,000 --> 00:27:53,000
é só o tamaño + +, entón mesturar en que esta liña, tamaño + +.

375
00:27:53,000 --> 00:27:58,000
Agora aquí abaixo, temos o caso

376
00:27:58,000 --> 00:28:01,000
onde non ten memoria suficiente,

377
00:28:01,000 --> 00:28:05,000
por iso estamos aumentando a nosa capacidade por 2.

378
00:28:05,000 --> 00:28:09,000
Eu creo que podería ter o mesmo problema aquí, pero podemos ignore-lo agora

379
00:28:09,000 --> 00:28:13,000
onde se non conseguiu aumentar a súa capacidade,

380
00:28:13,000 --> 00:28:18,000
entón vai querer diminuír a súa capacidade en 2 de novo.

381
00:28:18,000 --> 00:28:24,000
Outra nota curta é exactamente como pode facer + =,

382
00:28:24,000 --> 00:28:30,000
Tamén pode facer << =.

383
00:28:30,000 --> 00:28:43,000
Case todo pode ir antes de igual a igual, + =, | =, & =, << =.

384
00:28:43,000 --> 00:28:52,000
Char * novo é o noso novo bloque de memoria.

385
00:28:52,000 --> 00:28:55,000
Oh, aquí.

386
00:28:55,000 --> 00:29:02,000
>> O que a xente pensa sobre o tipo do noso novo bloque de memoria?

387
00:29:02,000 --> 00:29:06,000
[Estudante] Debe ser char **.

388
00:29:06,000 --> 00:29:12,000
Pensando na nosa estrutura aquí enriba,

389
00:29:12,000 --> 00:29:14,000
cordas é o que estamos realocando.

390
00:29:14,000 --> 00:29:21,000
Estamos a facer un novo almacenamento dinámico enteiro para os elementos na cola.

391
00:29:21,000 --> 00:29:25,000
O que nós imos estar atribuíndo ás súas cordas é o que estamos mallocing agora,

392
00:29:25,000 --> 00:29:30,000
e tan nova, vai ser un char **.

393
00:29:30,000 --> 00:29:34,000
Vai ser unha matriz de cadeas.

394
00:29:34,000 --> 00:29:38,000
Entón o que é o caso en que imos regresar falso?

395
00:29:38,000 --> 00:29:41,000
[Estudante] Deberiamos estar facendo o char *?

396
00:29:41,000 --> 00:29:44,000
[Rob B.] Si, boa chamada.

397
00:29:44,000 --> 00:29:46,000
[Estudante] O que foi iso?

398
00:29:46,000 --> 00:29:49,000
[Rob B.] Nós queriamos facer o tamaño char *, porque non estamos máis-

399
00:29:49,000 --> 00:29:53,000
este sería realmente un problema moi grande, porque sizeof (char) sería 1.

400
00:29:53,000 --> 00:29:55,000
Sizeof char * vai ser 4,

401
00:29:55,000 --> 00:29:58,000
iso unha morea de veces, cando está lidando con ints,

402
00:29:58,000 --> 00:30:01,000
tende a fuxir con el porque o tamaño de int e tamaño de int *

403
00:30:01,000 --> 00:30:04,000
nun sistema de 32 bits vai ser a mesma cousa.

404
00:30:04,000 --> 00:30:09,000
Pero aquí, sizeof (char) e sizeof (char *) son agora vai ser a mesma cousa.

405
00:30:09,000 --> 00:30:15,000
>> ¿Que é a circunstancia en que volva falso?

406
00:30:15,000 --> 00:30:17,000
[Estudante] Nova é nulo.

407
00:30:17,000 --> 00:30:23,000
Si, si é novo é nulo, nós voltar falso,

408
00:30:23,000 --> 00:30:34,000
e eu vou xogar aquí-

409
00:30:34,000 --> 00:30:37,000
[Estudante] [inaudível]

410
00:30:37,000 --> 00:30:39,000
[Rob B.] Si, iso é óptimo.

411
00:30:39,000 --> 00:30:46,000
Vostede podería facer dúas veces a capacidade ou cambio de capacidade 1 e só entón colocouse a aquí ou o que sexa.

412
00:30:46,000 --> 00:30:52,000
Nós imos facer todo o que se tiña.

413
00:30:52,000 --> 00:30:56,000
Capacidade >> = 1.

414
00:30:56,000 --> 00:31:08,000
E nunca vai ter que se preocupar en perder o seu lugar un

415
00:31:08,000 --> 00:31:12,000
porque deixou desviado por un, de xeito que o seu sitio un é necesariamente a 0,

416
00:31:12,000 --> 00:31:16,000
tan certo desprazamento por 1, aínda vai estar ben.

417
00:31:16,000 --> 00:31:19,000
[Estudante] Debe facelo antes do retorno?

418
00:31:19,000 --> 00:31:29,000
[Rob B.] Si, iso non fai ningún sentido.

419
00:31:29,000 --> 00:31:36,000
>> Agora, imos supor que imos acabar volvendo verdade ata o final.

420
00:31:36,000 --> 00:31:39,000
A maneira que nós imos facer estas memmoves,

421
00:31:39,000 --> 00:31:45,000
temos que ter coidado coa forma como as facemos.

422
00:31:45,000 --> 00:31:50,000
Alguén ten algunha suxestión de como as facemos?

423
00:32:17,000 --> 00:32:21,000
Aquí está o noso principio.

424
00:32:21,000 --> 00:32:28,000
Inevitablemente, queremos comezar a principios de novo

425
00:32:28,000 --> 00:32:35,000
e copia en cousas de alí, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
Como fai iso?

427
00:32:41,000 --> 00:32:52,000
En primeiro lugar, eu teño de ollar para a páxina do manual para memmove novo.

428
00:32:52,000 --> 00:32:57,000
Memmove, a orde de argumentos é sempre importante.

429
00:32:57,000 --> 00:33:01,000
Queremos que o noso primeiro destino, segundo fonte, a terceira dimensión.

430
00:33:01,000 --> 00:33:06,000
Hai unha serie de funcións que inverten orixe e destino.

431
00:33:06,000 --> 00:33:11,000
Orixe, destino, tende a ser un pouco consistente.

432
00:33:17,000 --> 00:33:21,000
Movemento, que é volver?

433
00:33:21,000 --> 00:33:27,000
El retorna un punteiro para o destino, por calquera motivo, pode querer iso.

434
00:33:27,000 --> 00:33:32,000
Podo imaxinar lelo, pero queremos avanzar cara ao noso destino.

435
00:33:32,000 --> 00:33:35,000
>> O que é o noso destino será?

436
00:33:35,000 --> 00:33:37,000
[Estudante] Novo.

437
00:33:37,000 --> 00:33:39,000
[Rob B.] Si, e onde estamos copiando?

438
00:33:39,000 --> 00:33:43,000
A primeira cousa que estamos copiando é este 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
Cal é esta-1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
Que é o enderezo do 1?

441
00:33:55,000 --> 00:33:58,000
Que é o enderezo que 1?

442
00:33:58,000 --> 00:34:01,000
[Estudante] [inaudível]

443
00:34:01,000 --> 00:34:03,000
[Rob B.] Head + o enderezo do primeiro elemento.

444
00:34:03,000 --> 00:34:05,000
Como podemos obter o primeiro elemento na matriz?

445
00:34:05,000 --> 00:34:10,000
[Estudante] Fila.

446
00:34:10,000 --> 00:34:15,000
[Rob B.] Si, q.strings.

447
00:34:15,000 --> 00:34:20,000
Teña en conta que, aquí, a nosa cabeza é 1.

448
00:34:20,000 --> 00:34:24,000
Drogas. Eu só creo que é Magic

449
00:34:24,000 --> 00:34:29,000
Aquí, a nosa cabeza é 1. Eu vou cambiar a miña cor tamén.

450
00:34:29,000 --> 00:34:36,000
E aquí está cordas.

451
00:34:36,000 --> 00:34:41,000
Tanto, nós pode escribir como fixemos aquí

452
00:34:41,000 --> 00:34:43,000
con cabezas + q.strings.

453
00:34:43,000 --> 00:34:51,000
Unha morea de xente tamén escribilo lo e q.strings [cabeza].

454
00:34:51,000 --> 00:34:55,000
Isto non é realmente menos eficiente.

455
00:34:55,000 --> 00:34:58,000
Podes pensar niso como está dereferencing-lo e, a continuación, obter o enderezo,

456
00:34:58,000 --> 00:35:04,000
pero o compilador vai traducir-lo para o que tiñamos antes de calquera forma, q.strings cabeza +.

457
00:35:04,000 --> 00:35:06,000
De calquera maneira que quere pensar niso.

458
00:35:06,000 --> 00:35:11,000
>> E cantos bytes que queremos copiar?

459
00:35:11,000 --> 00:35:15,000
[Estudante] Capacidade - cabeza.

460
00:35:15,000 --> 00:35:18,000
Capacidade - cabeza.

461
00:35:18,000 --> 00:35:21,000
E entón podes sempre escribir un exemplo

462
00:35:21,000 --> 00:35:23,000
para descubrir se isto é certo.

463
00:35:23,000 --> 00:35:26,000
[Estudante] Ela precisa ser dividido por dous, entón.

464
00:35:26,000 --> 00:35:30,000
Si, entón eu creo que nós poderíamos usar tamaño.

465
00:35:30,000 --> 00:35:35,000
Aínda temos tamaño ser-

466
00:35:35,000 --> 00:35:39,000
usando tamaño, que ten tamaño igual a 4.

467
00:35:39,000 --> 00:35:42,000
O noso tamaño e 4. A nosa cabeza é unha.

468
00:35:42,000 --> 00:35:46,000
Queremos copiar estes tres elementos.

469
00:35:46,000 --> 00:35:54,000
Esa é a comprobación de sanidade que tamaño - cabeza é correctamente 3.

470
00:35:54,000 --> 00:35:58,000
E volver aquí, como dixemos antes,

471
00:35:58,000 --> 00:36:00,000
se usássemos capacidade, entón teriamos que dividir por dous

472
00:36:00,000 --> 00:36:04,000
porque xa creceu a nosa capacidade, entón en vez diso, imos usar o tamaño.

473
00:36:11,000 --> 00:36:13,000
Que copiar esa parte.

474
00:36:13,000 --> 00:36:18,000
Agora, necesitamos copiar a outra parte, a parte que está á esquerda do inicio.

475
00:36:18,000 --> 00:36:28,000
>> Isto vai memmove en que posición?

476
00:36:28,000 --> 00:36:32,000
[Estudante] tamaño Plus - cabeza.

477
00:36:32,000 --> 00:36:38,000
Si, por iso, xa copiou en tamaño - bytes de cabeza,

478
00:36:38,000 --> 00:36:43,000
e así por onde queremos copiar os bytes restantes é novo

479
00:36:43,000 --> 00:36:48,000
e tamaño de menos ben, o número de bytes que xa copiado dentro

480
00:36:48,000 --> 00:36:52,000
E entón onde estamos copiando?

481
00:36:52,000 --> 00:36:54,000
[Estudante] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[Rob B.] Si, q.strings.

483
00:36:56,000 --> 00:37:02,000
Podiamos facer e q.strings [0].

484
00:37:02,000 --> 00:37:05,000
Isto é moito menos común do que este.

485
00:37:05,000 --> 00:37:14,000
Se só vai ser 0, entón tenden a ver q.strings.

486
00:37:14,000 --> 00:37:16,000
É aí onde estamos copiando.

487
00:37:16,000 --> 00:37:18,000
Cantos máis que nos queda para copiar? >> [Estudante] 10.

488
00:37:18,000 --> 00:37:20,000
Dereito.

489
00:37:20,000 --> 00:37:25,000
[Estudante] Temos que multiplicar 5-10 veces o tamaño dos bytes ou algo así?

490
00:37:25,000 --> 00:37:30,000
Si, por iso este é o lugar onde, o que exactamente estamos copiando?

491
00:37:30,000 --> 00:37:32,000
[Estudante] [inaudível]

492
00:37:32,000 --> 00:37:34,000
Cal é o tipo de cousas que estamos copiando?

493
00:37:34,000 --> 00:37:36,000
[Estudante] [inaudível]

494
00:37:36,000 --> 00:37:41,000
Si, entón o char * s que estamos copiando, non sabemos onde os proveñen.

495
00:37:41,000 --> 00:37:47,000
Ben, onde están apuntando, como as cordas, acabamos empurrando-o para a fila

496
00:37:47,000 --> 00:37:49,000
ou enqueuing para a cola.

497
00:37:49,000 --> 00:37:51,000
Onde os están vindo, non temos idea.

498
00:37:51,000 --> 00:37:56,000
Nós só necesitamos manter o control do char * s si.

499
00:37:56,000 --> 00:38:00,000
Nós non queremos copiar tamaño - bytes de cabeza.

500
00:38:00,000 --> 00:38:03,000
Queremos copiar o tamaño - cabeza char * s,

501
00:38:03,000 --> 00:38:11,000
entón imos multiplicar isto por sizeof (char).

502
00:38:11,000 --> 00:38:17,000
Mesmo aquí abaixo, cabeza * sizeof (char *).

503
00:38:17,000 --> 00:38:24,000
>> [Estudante] E sobre [inaudível]?

504
00:38:24,000 --> 00:38:26,000
Iso aquí?

505
00:38:26,000 --> 00:38:28,000
[Estudante] Non, a continuación diso, o tamaño - cabeza.

506
00:38:28,000 --> 00:38:30,000
[Rob B.] Iso aquí?

507
00:38:30,000 --> 00:38:32,000
Aritmética de punteiro.

508
00:38:32,000 --> 00:38:35,000
Como a aritmética de punteiro está indo para o traballo é

509
00:38:35,000 --> 00:38:40,000
el automaticamente multiplica polo tamaño do tipo que estamos lidando.

510
00:38:40,000 --> 00:38:46,000
Así como aquí, novo + (tamaño - cabeza)

511
00:38:46,000 --> 00:38:56,000
é exactamente equivalente a & [tamaño - cabeza] Novo

512
00:38:56,000 --> 00:39:00,000
ata que esperamos que funcione correctamente,

513
00:39:00,000 --> 00:39:04,000
pois, se estamos lidando con unha matriz int, non facer índice int-

514
00:39:04,000 --> 00:39:07,000
ou se é do tamaño de 5 e quere que o elemento 4, entón o índice que no

515
00:39:07,000 --> 00:39:10,000
int array [4].

516
00:39:10,000 --> 00:39:14,000
Vostede non fan [4] * O tamaño int.

517
00:39:14,000 --> 00:39:21,000
Que manipula-lo automaticamente, e neste caso

518
00:39:21,000 --> 00:39:29,000
é literalmente equivalente, entón, a sintaxe soporte

519
00:39:29,000 --> 00:39:34,000
é só ir a ser convertido para iso así que compilar.

520
00:39:34,000 --> 00:39:38,000
Iso é algo que cómpre ter coidado con iso

521
00:39:38,000 --> 00:39:42,000
cando está engadindo tamaño - cabeza

522
00:39:42,000 --> 00:39:45,000
está engadindo non un byte.

523
00:39:45,000 --> 00:39:53,000
Vostede está engadindo un char *, que pode ser unha máis ou o que sexa.

524
00:39:53,000 --> 00:39:56,000
>> Outras preguntas?

525
00:39:56,000 --> 00:40:04,000
Ok, dequeue vai ser máis fácil.

526
00:40:04,000 --> 00:40:11,000
Eu vou te dar un minuto de aplicar.

527
00:40:11,000 --> 00:40:18,000
Ah, e eu creo que esa é a mesma situación onde

528
00:40:18,000 --> 00:40:21,000
que o caso enqueue, se estamos enqueuing nulo,

529
00:40:21,000 --> 00:40:24,000
quizais queremos tratar con isto, quizais non.

530
00:40:24,000 --> 00:40:27,000
Non imos facelo de novo aquí, pero aínda que o noso caso pila.

531
00:40:27,000 --> 00:40:34,000
Se enfileirar nulo, que pode querer ignore-lo.

532
00:40:34,000 --> 00:40:40,000
Alguén ten algún código que podes tirar cara arriba?

533
00:40:40,000 --> 00:40:45,000
[Estudante] eu só teño dequeue.

534
00:40:45,000 --> 00:40:56,000
A versión 2 é que, todo ben.

535
00:40:56,000 --> 00:40:59,000
Quere explicar?

536
00:40:59,000 --> 00:41:01,000
[Estudante] Primeiro, asegurarse de que hai algo na cola

537
00:41:01,000 --> 00:41:07,000
e que o tamaño está indo para abaixo en 1.

538
00:41:07,000 --> 00:41:11,000
Cómpre facer iso, e despois volver a cabeza

539
00:41:11,000 --> 00:41:13,000
e mover a cabeza 1.

540
00:41:13,000 --> 00:41:19,000
Ok, entón non é un caso extremo, temos que considerar. Si

541
00:41:19,000 --> 00:41:24,000
[Estudante] Se a súa cabeza está no último elemento,

542
00:41:24,000 --> 00:41:26,000
entón non quere cabeza para apuntar fóra da matriz.

543
00:41:26,000 --> 00:41:29,000
>> Si, tan pronto como sexa cabeza bate o fin da nosa matriz,

544
00:41:29,000 --> 00:41:35,000
cando desenfileirar, a nosa cabeza debe ser modded a 0.

545
00:41:35,000 --> 00:41:40,000
Desafortunadamente, non podemos facelo nunha única etapa.

546
00:41:40,000 --> 00:41:44,000
Eu creo que a forma que eu probablemente resolve-lo é

547
00:41:44,000 --> 00:41:52,000
este vai ser un char *, o que estamos volvendo,

548
00:41:52,000 --> 00:41:55,000
calquera que sexa o seu nome variable quere ser.

549
00:41:55,000 --> 00:42:02,000
Entón queremos mod cabeza pola nosa capacidade

550
00:42:02,000 --> 00:42:10,000
e despois volver Ret.

551
00:42:10,000 --> 00:42:14,000
Unha morea de xente aquí que poderían facerse

552
00:42:14,000 --> 00:42:19,000
Este é o caso de ver a xente, porque facer a cabeza

553
00:42:19,000 --> 00:42:29,000
é maior que a capacidade, facer a cabeza - capacidade.

554
00:42:29,000 --> 00:42:36,000
E iso é só a traballar en torno ao que é mod.

555
00:42:36,000 --> 00:42:41,000
Xefe mod = capacidade é moito máis limpo

556
00:42:41,000 --> 00:42:51,000
dun invólucro en torno ao que se a cabeza maior que a cabeza de capacidade - A capacidade.

557
00:42:51,000 --> 00:42:56,000
>> Preguntas?

558
00:42:56,000 --> 00:43:02,000
Ok, a última cousa que nos queda é a nosa lista encadeada.

559
00:43:02,000 --> 00:43:07,000
Pode ser usado para algúns dos comportamentos lista ligada se fixo

560
00:43:07,000 --> 00:43:11,000
listas ligadas nas súas táboas de hash, se fixo unha táboa hash.

561
00:43:11,000 --> 00:43:15,000
Eu recomendo encarecidamente que facer unha táboa hash.

562
00:43:15,000 --> 00:43:17,000
Xa debería ter feito unha trie,

563
00:43:17,000 --> 00:43:23,000
pero intentos son máis difíciles.

564
00:43:23,000 --> 00:43:27,000
En teoría, son assintoticamente mellor.

565
00:43:27,000 --> 00:43:30,000
Pero basta ollar para a tarxeta grande,

566
00:43:30,000 --> 00:43:35,000
e intenta non facer mellor, e eles ocupan máis memoria.

567
00:43:35,000 --> 00:43:43,000
Todo sobre intenta acaba sendo peor para máis traballo.

568
00:43:43,000 --> 00:43:49,000
É o que solución David Malan sempre é

569
00:43:49,000 --> 00:43:56,000
El sempre mensaxes Súa solución trie, e imos ver onde está actualmente.

570
00:43:56,000 --> 00:44:00,000
O que estaba baixo, David J?

571
00:44:00,000 --> 00:44:06,000
El é n º 18, de xeito que non é terriblemente malo,

572
00:44:06,000 --> 00:44:09,000
e que vai ser un dos mellores intentos pode pensar

573
00:44:09,000 --> 00:44:17,000
ou un dos mellores da procura dun trie.

574
00:44:17,000 --> 00:44:23,000
Non é mesmo a súa solución orixinal?

575
00:44:23,000 --> 00:44:29,000
Eu me sinto como solucións trie tenden a ser máis nesta franxa de uso de memoria RAM.

576
00:44:29,000 --> 00:44:33,000
>> Desprácese ata o cumio, e uso de RAM está na casa de un díxito.

577
00:44:33,000 --> 00:44:36,000
Desc para o fondo, e entón comeza a ver intenta

578
00:44:36,000 --> 00:44:41,000
onde comeza o uso de RAM absolutamente enorme,

579
00:44:41,000 --> 00:44:45,000
e intentos son máis difíciles.

580
00:44:45,000 --> 00:44:53,000
Non enteiramente pena, pero unha experiencia educativa se fixo un.

581
00:44:53,000 --> 00:44:56,000
A última cousa é a nosa lista ligada,

582
00:44:56,000 --> 00:45:04,000
e esas tres cousas, pilas, colas e listas ligadas,

583
00:45:04,000 --> 00:45:09,000
calquera cousa futura que fai en ciencia da computación

584
00:45:09,000 --> 00:45:12,000
supoñer que ten familiaridade con estas cousas.

585
00:45:12,000 --> 00:45:19,000
Son tan fundamental para todo.

586
00:45:19,000 --> 00:45:25,000
>> Listas ligadas, e aquí temos unha lista vinculada illadamente vai ser a nosa implantación.

587
00:45:25,000 --> 00:45:34,000
O que significa vinculada illadamente ao contrario dobremente ligada? Si

588
00:45:34,000 --> 00:45:37,000
[Estudante] É só apunta para o punteiro próximo e non para os punteiros,

589
00:45:37,000 --> 00:45:39,000
como o que precede e aquel tras el.

590
00:45:39,000 --> 00:45:44,000
É, entón, en formato de imaxe, o que fago?

591
00:45:44,000 --> 00:45:48,000
Eu teño dúas cousas. Eu teño imaxe e imaxe.

592
00:45:48,000 --> 00:45:51,000
En formato de imaxe, os nosos individualmente listas ligadas,

593
00:45:51,000 --> 00:45:57,000
inevitablemente, temos algún tipo de punteiro para a cabeza da lista,

594
00:45:57,000 --> 00:46:02,000
e, a continuación, dentro da nosa lista, só temos punteiros,

595
00:46:02,000 --> 00:46:05,000
e quizais iso apunta a nulo.

596
00:46:05,000 --> 00:46:08,000
Vai ser o seu deseño típico dunha lista vinculada illadamente.

597
00:46:08,000 --> 00:46:14,000
Unha lista dobremente ligada, pode ir cara atrás.

598
00:46:14,000 --> 00:46:19,000
Se eu lle der calquera nodo na lista, entón podes necesariamente chegar a

599
00:46:19,000 --> 00:46:23,000
calquera outro no da lista se é unha lista dobremente ligada.

600
00:46:23,000 --> 00:46:27,000
Pero se eu te o terceiro nó na lista e é unha lista vinculada illadamente,

601
00:46:27,000 --> 00:46:30,000
ningunha maneira que está indo cada vez para chegar a nós de primeiro e segundo.

602
00:46:30,000 --> 00:46:34,000
E hai beneficios e malefícios, e un un evidente

603
00:46:34,000 --> 00:46:42,000
é incorporarse máis tamaño, e ten que manter o control de onde esas cousas están apuntando agora.

604
00:46:42,000 --> 00:46:49,000
Pero só se preocupan vinculada illadamente.

605
00:46:49,000 --> 00:46:53,000
>> Algunhas cousas que imos ter que aplicar.

606
00:46:53,000 --> 00:47:00,000
O seu nó typedef struct, int i: struct node * seguinte; nodo.

607
00:47:00,000 --> 00:47:09,000
Typedef que deben ser queimados nas súas mentes.

608
00:47:09,000 --> 00:47:14,000
Quiz 1 debe ser como dar un typedef dun nodo de lista ligada,

609
00:47:14,000 --> 00:47:18,000
e ten que ser capaz de rabiscar inmediatamente que abaixo

610
00:47:18,000 --> 00:47:22,000
sen sequera pensar sobre iso.

611
00:47:22,000 --> 00:47:27,000
Eu creo que algunhas preguntas, por que necesitamos struct aquí?

612
00:47:27,000 --> 00:47:32,000
Por que non podemos dicir * no?

613
00:47:32,000 --> 00:47:35,000
[Estudante] [inaudível]

614
00:47:35,000 --> 00:47:38,000
Si

615
00:47:38,000 --> 00:47:44,000
O único que define un nodo como unha cousa

616
00:47:44,000 --> 00:47:47,000
é o typedef si.

617
00:47:47,000 --> 00:47:55,000
Pero a partir deste punto, cando estamos tipo de análise por esta definición do nodo de estrutura,

618
00:47:55,000 --> 00:48:01,000
non terminais noso typedef aínda, entón desde o typedef non rematou,

619
00:48:01,000 --> 00:48:05,000
nó non existe.

620
00:48:05,000 --> 00:48:12,000
Pero struct nodo fai, e ese nó aquí,

621
00:48:12,000 --> 00:48:14,000
iso tamén podería ser chamado de calquera outra cousa.

622
00:48:14,000 --> 00:48:16,000
Isto podería ser chamado n.

623
00:48:16,000 --> 00:48:19,000
Podería ser chamado de nó de lista encadeada.

624
00:48:19,000 --> 00:48:21,000
Podería ser chamado de calquera cousa.

625
00:48:21,000 --> 00:48:26,000
Pero ese nó estrutura debe ser chamada o mesmo que este nodo struct.

626
00:48:26,000 --> 00:48:29,000
O que chama iso ten que ser tamén aquí,

627
00:48:29,000 --> 00:48:32,000
e para que tamén responde o segundo punto da cuestión

628
00:48:32,000 --> 00:48:37,000
É por iso que, moitas veces, cando ves estruturas e typedefs de estruturas,

629
00:48:37,000 --> 00:48:42,000
vai ver estruturas anónimos onde só vai ver typedef struct,

630
00:48:42,000 --> 00:48:47,000
implementación de dicionario estrutura, ou o que sexa.

631
00:48:47,000 --> 00:48:51,000
>> Por que aquí non necesitamos dicir no?

632
00:48:51,000 --> 00:48:54,000
Por que non pode ser unha estrutura anónimo?

633
00:48:54,000 --> 00:48:56,000
É case a mesma resposta.

634
00:48:56,000 --> 00:48:58,000
[Estudante] Debe referirse a el dentro da estrutura.

635
00:48:58,000 --> 00:49:04,000
Si, dentro da estructura, que precisa para referirse á estrutura en si.

636
00:49:04,000 --> 00:49:10,000
Se non dá a estrutura dun nome, se é unha estrutura anónimo, non pode se referir a el.

637
00:49:10,000 --> 00:49:17,000
E por último, pero, polo menos, estes non deben ser todos un pouco simple,

638
00:49:17,000 --> 00:49:20,000
e eles deben axudar a entender se está escribindo isto

639
00:49:20,000 --> 00:49:24,000
que está facendo algo mal, se este tipo de cousas non teñen sentido.

640
00:49:24,000 --> 00:49:28,000
Por último, pero non menos importante, por que iso ten que ser struct * no?

641
00:49:28,000 --> 00:49:34,000
Por que non pode ser só struct próximo no?

642
00:49:34,000 --> 00:49:37,000
[Estudante] Punteiro para a estrutura que vén.

643
00:49:37,000 --> 00:49:39,000
Iso é inevitable que queremos.

644
00:49:39,000 --> 00:49:42,000
Por que nunca ser no struct próximo?

645
00:49:42,000 --> 00:49:50,000
Por que ten que ser struct node * próximo? Si

646
00:49:50,000 --> 00:49:53,000
[Estudante] É como un loop infinito.

647
00:49:53,000 --> 00:49:55,000
Si

648
00:49:55,000 --> 00:49:57,000
[Estudante] Sería todo nun.

649
00:49:57,000 --> 00:50:02,000
Si, só de pensar como sería facer o tamaño ou algo así.

650
00:50:02,000 --> 00:50:08,000
Tamaño dunha estrutura é basicamente + ou - un estándar aquí ou alí.

651
00:50:08,000 --> 00:50:15,000
É basicamente vai ser a suma dos tamaños das cousas na estrutura.

652
00:50:15,000 --> 00:50:18,000
Iso aquí, sen cambiar nada, o tamaño vai ser doado.

653
00:50:18,000 --> 00:50:24,000
Tamaño do nó struct será tamaño de I + tamaño do próximo.

654
00:50:24,000 --> 00:50:27,000
Tamaño da i vai ser 4. Tamaño da próxima vai ser 4.

655
00:50:27,000 --> 00:50:30,000
Tamaño do nó struct vai ser 8.

656
00:50:30,000 --> 00:50:34,000
Se non temos o *, pensando sizeof,

657
00:50:34,000 --> 00:50:37,000
a continuación, sizeof (i) será 4.

658
00:50:37,000 --> 00:50:43,000
Tamaño do nó struct próximo vai ser o tamaño da I + tamaño do nó seguinte struct

659
00:50:43,000 --> 00:50:46,000
+ Tamaño da I + tamaño do nó struct seguinte.

660
00:50:46,000 --> 00:50:55,000
Sería unha recursividade infinita de nós.

661
00:50:55,000 --> 00:51:00,000
É por iso que esta é a forma como as cousas teñen que ser.

662
00:51:00,000 --> 00:51:03,000
>> Unha vez máis, en definitiva Recordar que,

663
00:51:03,000 --> 00:51:06,000
ou polo menos entendelo lo o suficiente para que pode ser capaz de

664
00:51:06,000 --> 00:51:12,000
razón pola cal debe ser parecido.

665
00:51:12,000 --> 00:51:14,000
As cousas que imos querer implantar.

666
00:51:14,000 --> 00:51:18,000
Se a lonxitude da lista

667
00:51:18,000 --> 00:51:21,000
pode enganar e manter en torno a un

668
00:51:21,000 --> 00:51:24,000
lonxitude global ou algo así, pero nós non imos facelo.

669
00:51:24,000 --> 00:51:28,000
Nós imos contar o tamaño da lista.

670
00:51:28,000 --> 00:51:34,000
Nós contén, de xeito que é, basicamente, como unha busca,

671
00:51:34,000 --> 00:51:41,000
por iso temos unha lista ligada de enteiros para ver este enteiro está na lista ligada.

672
00:51:41,000 --> 00:51:44,000
Prepend vai introducir no inicio da lista.

673
00:51:44,000 --> 00:51:46,000
Anexar vai introducir no fin.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted vai inserir na posición clasificada na lista.

675
00:51:53,000 --> 00:52:01,000
Tipo de Insert_sorted asume que nunca usou preceder ou achegar en malos camiños.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted cando está aplicando insert_sorted-

677
00:52:09,000 --> 00:52:13,000
imos dicir que temos a nosa lista ligada.

678
00:52:13,000 --> 00:52:18,000
Isto é o que parece actualmente, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
Quero introducir 3, polo que, mentres a propia lista xa está clasificado,

680
00:52:24,000 --> 00:52:27,000
é fácil atopar onde 3 pertence.

681
00:52:27,000 --> 00:52:29,000
Eu comezo o 2.

682
00:52:29,000 --> 00:52:32,000
Ok, 3 é maior que 2, entón eu quero continuar.

683
00:52:32,000 --> 00:52:35,000
Oh, 4 é moi grande, entón eu sei 3 está a ir entre 2 e 4,

684
00:52:35,000 --> 00:52:39,000
e eu teño que corrixir punteiros e todas esas cousas.

685
00:52:39,000 --> 00:52:43,000
Pero se nós non estrictamente usar insert_sorted,

686
00:52:43,000 --> 00:52:50,000
como imos só dicir que eu preceder 6,

687
00:52:50,000 --> 00:52:55,000
entón miña lista encadeada vai facer iso.

688
00:52:55,000 --> 00:53:01,000
El agora non ten sentido, polo tanto, para insert_sorted, pode simplemente asumir

689
00:53:01,000 --> 00:53:04,000
que a lista é ordenada, aínda que existan operacións

690
00:53:04,000 --> 00:53:09,000
o que pode causar-lle para non ser ordenado, e é iso.

691
00:53:09,000 --> 00:53:20,000
Atopar un útil de inserción, de xeito estas son as principais cousas que vai ter que aplicar.

692
00:53:20,000 --> 00:53:24,000
>> Por agora, tomar un minuto para facer lonxitude e contén,

693
00:53:24,000 --> 00:53:30,000
e os que deben ser relativamente rápida.

694
00:53:41,000 --> 00:53:48,000
Achegando-se o tempo de peche, polo que ninguén ten nada para a lonxitude ou contén?

695
00:53:48,000 --> 00:53:50,000
Eles van ser case idénticos.

696
00:53:50,000 --> 00:53:57,000
[Estudante] lonxitude.

697
00:53:57,000 --> 00:54:01,000
Imos ver, de revisión.

698
00:54:01,000 --> 00:54:04,000
Okay.

699
00:54:12,000 --> 00:54:15,000
Quere explicar?

700
00:54:15,000 --> 00:54:21,000
[Estudante] Eu só crear un nó punteiro e arrincar a primeira, que é a nosa variable global,

701
00:54:21,000 --> 00:54:27,000
e entón eu comprobar a ver se é nulo, entón eu non ten un fallo de seg e voltar 0 se é o caso.

702
00:54:27,000 --> 00:54:34,000
Se non, eu percorrer, mantendo o control de dentro enteiro

703
00:54:34,000 --> 00:54:38,000
cantas veces eu xa identificado elemento seguinte da lista

704
00:54:38,000 --> 00:54:43,000
e na operación mesmo incremento tamén acceder a este elemento real,

705
00:54:43,000 --> 00:54:47,000
e entón eu continuamente facer a comprobación para ver se é nulo,

706
00:54:47,000 --> 00:54:56,000
e é nulo, entón aborta e só devolve o número de elementos que acceder.

707
00:54:56,000 --> 00:55:01,000
>> [Rob B.] Alguén ten algún comentario sobre calquera cousa?

708
00:55:01,000 --> 00:55:06,000
Isto parece correcto ben sabio.

709
00:55:06,000 --> 00:55:10,000
[Estudante] Eu non creo que precisa do nó == null.

710
00:55:10,000 --> 00:55:13,000
É, entón, se o nó == 0 retorno nulo.

711
00:55:13,000 --> 00:55:18,000
Pero se nulo nó == entón esta-oh, non é unha cuestión de corrección.

712
00:55:18,000 --> 00:55:23,000
Era só está retornando i, pero non é de ámbito agora.

713
00:55:23,000 --> 00:55:30,000
Só ten int i, para i = 0.

714
00:55:30,000 --> 00:55:34,000
Pero se o nodo é nulo, entón eu aínda vai ser 0,

715
00:55:34,000 --> 00:55:39,000
e nós estamos indo para voltar 0, polo tanto, neste caso, é o mesmo.

716
00:55:39,000 --> 00:55:48,000
Outra cousa común é a de manter a declaración

717
00:55:48,000 --> 00:55:51,000
dentro do nó do lazo é.

718
00:55:51,000 --> 00:55:54,000
Vostede podería dicir-oh, non.

719
00:55:54,000 --> 00:55:56,000
Imos mantelo coma este.

720
00:55:56,000 --> 00:55:59,000
Eu, probablemente, poñer int i = 0 aquí,

721
00:55:59,000 --> 00:56:05,000
entón no * nodo = primeiro aquí.

722
00:56:05,000 --> 00:56:11,000
E este é, probablemente, como se librar diso agora.

723
00:56:11,000 --> 00:56:14,000
Este é, probablemente, como eu tería escrito.

724
00:56:14,000 --> 00:56:21,000
Tamén pode ollar-lo así.

725
00:56:21,000 --> 00:56:25,000
Esta estrutura de loop para aquí

726
00:56:25,000 --> 00:56:30,000
debe ser case tan natural para ti como para int i = 0

727
00:56:30,000 --> 00:56:33,000
i é inferior á lonxitude da matriz i + +.

728
00:56:33,000 --> 00:56:38,000
Se é así que iterar sobre unha matriz, isto é como iterar sobre unha lista ligada.

729
00:56:38,000 --> 00:56:45,000
>> Esta debe ser unha segunda natureza nalgún punto.

730
00:56:45,000 --> 00:56:50,000
Con isto en mente, este vai ser case o mesmo.

731
00:56:50,000 --> 00:56:57,000
Vai querer iterar sobre unha lista encadeada.

732
00:56:57,000 --> 00:57:02,000
O No-Eu non teño ningunha idea do que o valor é chamado.

733
00:57:02,000 --> 00:57:04,000
No I.

734
00:57:04,000 --> 00:57:15,000
Se o valor dese nó = i volver certo, e é iso.

735
00:57:15,000 --> 00:57:18,000
Teña en conta que a única forma de sempre volver false

736
00:57:18,000 --> 00:57:23,000
é se iterar sobre a lista enteira conexionada e nunca máis volver verdade,

737
00:57:23,000 --> 00:57:29,000
de xeito que é o que este fai.

738
00:57:29,000 --> 00:57:36,000
Como unha nota lateral, probablemente non vai comezar a engadir ou preceder.

739
00:57:36,000 --> 00:57:39,000
>> Última nota rápida.

740
00:57:39,000 --> 00:57:52,000
Se ves a palabra chave estática, entón imos dicir contador Static int = 0,

741
00:57:52,000 --> 00:57:56,000
entón o que facemos reconto + +, pode basicamente pensar niso como unha variable global,

742
00:57:56,000 --> 00:58:00,000
aínda que eu dixen non é así que nós imos implementar lonxitude.

743
00:58:00,000 --> 00:58:06,000
Eu estou facendo iso aquí, e entón contar + +.

744
00:58:06,000 --> 00:58:11,000
Calquera forma, podemos introducir un nó na nosa lista ligada estamos incrementando a nosa conta.

745
00:58:11,000 --> 00:58:15,000
O punto é que a palabra clave Static significa.

746
00:58:15,000 --> 00:58:20,000
Se eu tivese int count = 0 que sería unha variable antiga regulares global.

747
00:58:20,000 --> 00:58:25,000
O que significa conta Static int é que é unha variable global para este ficheiro.

748
00:58:25,000 --> 00:58:28,000
É imposible para un ficheiro,

749
00:58:28,000 --> 00:58:34,000
gusto de pensar en pset 5, se comezou.

750
00:58:34,000 --> 00:58:39,000
Ten tanto speller.c, e ten dictionary.c,

751
00:58:39,000 --> 00:58:42,000
e simplemente declarar unha cousa global, entón calquera cousa en speller.c

752
00:58:42,000 --> 00:58:45,000
se pode acceder no dictionary.c e viceversa.

753
00:58:45,000 --> 00:58:48,000
As variables globais son accesibles por calquera arquivo c.,

754
00:58:48,000 --> 00:58:54,000
pero variables estáticas só son accesibles desde dentro do propio arquivo,

755
00:58:54,000 --> 00:59:01,000
dentro de corrector ortográfico ou dentro dictionary.c,

756
00:59:01,000 --> 00:59:06,000
este é o tipo de como eu ía declarar miña variable para o tamaño da miña matriz

757
00:59:06,000 --> 00:59:10,000
ou o tamaño do meu número de palabras no dicionario.

758
00:59:10,000 --> 00:59:15,000
Dende que eu non quero declarar unha variable global que calquera ten acceso,

759
00:59:15,000 --> 00:59:18,000
Realmente só se preocupan con iso para os meus propios fins.

760
00:59:18,000 --> 00:59:21,000
>> A cousa boa sobre iso é tamén o material de colisión todo nome.

761
00:59:21,000 --> 00:59:27,000
Se algún ficheiro intenta usar unha variable global chamada conta, as cousas van moi, moi mal,

762
00:59:27,000 --> 00:59:33,000
de xeito que este mantén as cousas ben seguro, e só pode acceder a ela,

763
00:59:33,000 --> 00:59:38,000
e ninguén máis pode, e se alguén declara unha variable global chamada conta,

764
00:59:38,000 --> 00:59:43,000
el non ha interferir coa súa variable estática chamada conta.

765
00:59:43,000 --> 00:59:47,000
Isto é o que é estática. É unha variable de arquivo global.

766
00:59:47,000 --> 00:59:52,000
>> Preguntas sobre algo?

767
00:59:52,000 --> 00:59:59,000
Todo preparado. Tchau.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]