1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [Seção 6] [Mais Confortável]

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
>> Nós podemos ir para nossa seção de perguntas.

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

6
00:00:17,000 --> 00:00:22,000
O início da seção das perguntas dizem-

7
00:00:22,000 --> 00:00:26,000
aparentemente, eu não sou inteiramente unsick é uma pergunta muito fácil

8
00:00:26,000 --> 00:00:28,000
de apenas o que é valgrind?

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

10
00:00:30,000 --> 00:00:34,000
Alguém quer dizer o que valgrind faz?

11
00:00:34,000 --> 00:00:36,000
[Estudante] Verifica a memória.

12
00:00:36,000 --> 00:00:41,000
Sim, valgrind é um verificador de memória geral.

13
00:00:41,000 --> 00:00:44,000
É, no final, diz que se você tiver quaisquer vazamentos de memória,

14
00:00:44,000 --> 00:00:49,000
que é principalmente o que estamos usando para isso, porque se você quiser

15
00:00:49,000 --> 00:00:54,000
fazer bem no conjunto de problemas ou se você quiser

16
00:00:54,000 --> 00:00:59,000
obter na placa grande, você precisa de ter nenhum vazamento de memória que seja,

17
00:00:59,000 --> 00:01:01,000
e no caso de você ter um vazamento de memória que você não pode encontrar,

18
00:01:01,000 --> 00:01:04,000
também ter em mente que sempre que você abre um arquivo

19
00:01:04,000 --> 00:01:07,000
e se você não fechá-lo, isso é um vazamento de memória.

20
00:01:07,000 --> 00:01:10,000
>> Um monte de pessoas estão à procura de algum nó que eles não estão liberando

21
00:01:10,000 --> 00:01:15,000
quando, na verdade, eles não fechar o dicionário no primeiro passo.

22
00:01:15,000 --> 00:01:19,000
Ele também diz que se você tiver qualquer inválido lê ou escreve,

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

24
00:01:22,000 --> 00:01:26,000
que está além do fim da pilha e que não aconteça a falha seg

25
00:01:26,000 --> 00:01:30,000
mas valgrind pega, como você não deve realmente ser escrito lá,

26
00:01:30,000 --> 00:01:33,000
e então você definitivamente não deve ter nenhuma dessas também.

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

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

29
00:01:42,000 --> 00:01:45,000
>> É uma questão geral de

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

31
00:01:49,000 --> 00:01:51,000
A saída é sobrecarregar um monte de vezes.

32
00:01:51,000 --> 00:01:54,000
Há também erros de diversão onde se você tem alguma coisa muito errada

33
00:01:54,000 --> 00:01:59,000
acontecendo em um loop, em seguida, ele acabará por dizer, "Caminho erros demais.

34
00:01:59,000 --> 00:02:03,000
Eu vou parar de contar agora. "

35
00:02:03,000 --> 00:02:08,000
É basicamente saída textual que você tem que analisar.

36
00:02:08,000 --> 00:02:13,000
No final, ele vai dizer qualquer vazamento de memória que você tem,

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

38
00:02:16,000 --> 00:02:20,000
se é um unfreed bloco, então é geralmente mais fácil de encontrar

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

40
00:02:23,000 --> 00:02:26,000
1.000 blocos unfreed provavelmente significa que você não está liberando

41
00:02:26,000 --> 00:02:30,000
suas listas ligadas de forma adequada ou algo assim.

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

43
00:02:32,000 --> 00:02:35,000
>> Agora temos nossa seção de perguntas,

44
00:02:35,000 --> 00:02:38,000
que você não precisa fazer o download.

45
00:02:38,000 --> 00:02:41,000
Você pode clicar no meu nome e puxe-los no espaço.

46
00:02:41,000 --> 00:02:44,000
Agora clique em mim.

47
00:02:44,000 --> 00:02:46,000
Revisão 1 será de pilha, que estamos a fazer em primeiro lugar.

48
00:02:46,000 --> 00:02:55,000
Revisão 2 será fila e Revisão 3 será a lista vinculada isoladamente.

49
00:02:55,000 --> 00:02:58,000
Começando com a nossa pilha.

50
00:02:58,000 --> 00:03:02,000
Como se diz aqui, uma pilha é uma das mais básicas,

51
00:03:02,000 --> 00:03:07,000
estruturas de dados fundamentais da ciência da computação.

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

53
00:03:11,000 --> 00:03:13,000
a pilha de bandejas no salão de jantar.

54
00:03:13,000 --> 00:03:16,000
É basicamente sempre que você está sendo apresentado a uma pilha,

55
00:03:16,000 --> 00:03:20,000
alguém vai dizer: "Oh, como uma pilha de bandejas."

56
00:03:20,000 --> 00:03:22,000
Você empilhar as bandejas para cima.

57
00:03:22,000 --> 00:03:24,000
Então quando você vai puxar uma bandeja,

58
00:03:24,000 --> 00:03:31,000
a primeira bandeja que está sendo puxado é a última que foi colocado na pilha.

59
00:03:31,000 --> 00:03:34,000
A pilha também, como se diz aqui-

60
00:03:34,000 --> 00:03:37,000
temos o segmento da memória denominada pilha.

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

62
00:03:40,000 --> 00:03:42,000
>> Porque, como uma estrutura de dados de pilha,

63
00:03:42,000 --> 00:03:46,000
ele empurra e aparece pilha de quadros na pilha,

64
00:03:46,000 --> 00:03:53,000
onde quadros de pilha são como uma chamada específica de uma função.

65
00:03:53,000 --> 00:03:57,000
E como uma pilha, você sempre tem que retornar

66
00:03:57,000 --> 00:04:03,000
a partir de uma chamada de função antes de descer em quadros menores pilha novamente.

67
00:04:03,000 --> 00:04:08,000
Você não pode ter principal chamada barra chamada foo e retorno barra diretamente principal.

68
00:04:08,000 --> 00:04:14,000
Ele sempre tem que seguir a pilha correta empurrando e popping.

69
00:04:14,000 --> 00:04:18,000
As duas operações, como eu disse, são push e pop.

70
00:04:18,000 --> 00:04:20,000
Esses são termos universais.

71
00:04:20,000 --> 00:04:26,000
Você deve saber push e pop, em termos de pilhas, não importa o quê.

72
00:04:26,000 --> 00:04:28,000
Vamos ver filas são um pouco diferente.

73
00:04:28,000 --> 00:04:32,000
Ele realmente não tem um termo universal, mas push e pop são universais para pilhas.

74
00:04:32,000 --> 00:04:34,000
Push é só colocar na pilha.

75
00:04:34,000 --> 00:04:37,000
Pop é tirar a pilha.

76
00:04:37,000 --> 00:04:43,000
E vemos aqui temos a nossa pilha typedef struct,

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

78
00:04:46,000 --> 00:04:51,000
Não fique com medo por qualquer **.

79
00:04:51,000 --> 00:04:54,000
Isso vai acabar sendo uma matriz de strings

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

81
00:04:58,000 --> 00:05:00,000
ponteiros para personagens tendem a ser cordas.

82
00:05:00,000 --> 00:05:05,000
Ele não tem que ser strings, mas aqui, eles vão ser strings.

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

84
00:05:08,000 --> 00:05:14,000
Temos um tamanho, o que representa quantos elementos estão na pilha,

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

86
00:05:19,000 --> 00:05:22,000
A capacidade deve começar como algo maior do que 1,

87
00:05:22,000 --> 00:05:27,000
mas o tamanho vai começar como 0.

88
00:05:27,000 --> 00:05:36,000
Agora, existem basicamente três maneiras diferentes que você pode pensar de uma pilha.

89
00:05:36,000 --> 00:05:39,000
Bem, há provavelmente mais, mas as duas principais formas são

90
00:05:39,000 --> 00:05:43,000
você pode implementá-lo usando uma matriz, ou você pode implementá-lo usando uma lista ligada.

91
00:05:43,000 --> 00:05:48,000
Listas ligadas são uma espécie de trivial para fazer pilhas de.

92
00:05:48,000 --> 00:05:51,000
É muito fácil fazer uma pilha usando listas ligadas,

93
00:05:51,000 --> 00:05:55,000
Então, aqui, nós vamos fazer uma pilha usando matrizes,

94
00:05:55,000 --> 00:05:59,000
e em seguida, usando matrizes, também há duas maneiras que você pode pensar sobre isso.

95
00:05:59,000 --> 00:06:01,000
Antes, quando eu disse que nós temos uma capacidade para a pilha,

96
00:06:01,000 --> 00:06:04,000
para que possa ajustar um elemento na pilha.

97
00:06:04,000 --> 00:06:09,000
>> A única maneira que poderia acontecer é assim que você acertar 10 elementos, então você está feito.

98
00:06:09,000 --> 00:06:13,000
Você pode saber que existe um limite superior de 10 coisas no mundo

99
00:06:13,000 --> 00:06:16,000
que você nunca vai ter mais do que 10 coisas em sua pilha,

100
00:06:16,000 --> 00:06:20,000
caso em que você pode ter um limite superior sobre o tamanho do seu stack.

101
00:06:20,000 --> 00:06:23,000
Ou você poderia ter sua pilha ser ilimitado,

102
00:06:23,000 --> 00:06:27,000
mas se você está fazendo uma matriz, o que significa que cada vez que você acertar 10 elementos,

103
00:06:27,000 --> 00:06:29,000
então você vai ter que crescer para 20 elementos, e quando você bate 20 elementos,

104
00:06:29,000 --> 00:06:33,000
você vai ter que crescer a sua matriz para 30 elementos ou 40 elementos.

105
00:06:33,000 --> 00:06:37,000
Você está indo a necessidade de aumentar a capacidade, que é o que nós vamos fazer aqui.

106
00:06:37,000 --> 00:06:40,000
Cada vez que atingir o tamanho máximo de nossa pilha,

107
00:06:40,000 --> 00:06:46,000
quando empurrar outra coisa, nós vamos precisar de aumentar a capacidade.

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

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

110
00:06:54,000 --> 00:06:58,000
bool e apenas diz se conseguimos ou não.

111
00:06:58,000 --> 00:07:00,000
>> Como não?

112
00:07:00,000 --> 00:07:04,000
Qual é a única circunstância que você pode pensar

113
00:07:04,000 --> 00:07:07,000
onde iríamos precisar retornar falso?

114
00:07:07,000 --> 00:07:09,000
Sim.

115
00:07:09,000 --> 00:07:12,000
[Estudante] Se ele está cheio e estamos usando uma implementação limitada.

116
00:07:12,000 --> 00:07:17,000
Sim, assim como nós definimos, ele respondeu

117
00:07:17,000 --> 00:07:23,000
se é total e estamos usando uma aplicação limitada.

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

119
00:07:26,000 --> 00:07:31,000
Assim que atingiu 10 coisas na matriz, não pode caber 11, assim voltamos falso.

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

121
00:07:32,000 --> 00:07:38,000
Se você não pode se expandir a matriz por algum motivo.

122
00:07:38,000 --> 00:07:43,000
Sim, então a memória é um recurso limitado,

123
00:07:43,000 --> 00:07:51,000
e, eventualmente, se manter as coisas empurrando para a pilha de uma e outra vez,

124
00:07:51,000 --> 00:07:54,000
vamos tentar alocar um maior matriz para caber

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

126
00:07:59,000 --> 00:08:02,000
Bem, malloc retornará nulo.

127
00:08:02,000 --> 00:08:05,000
>> Lembre-se, cada vez que você sempre chamar malloc, você deve verificar para ver se ele

128
00:08:05,000 --> 00:08:12,000
retorna nulo ou então que é uma dedução correção.

129
00:08:12,000 --> 00:08:17,000
Desde que nós queremos ter uma pilha ilimitada,

130
00:08:17,000 --> 00:08:21,000
o único caso que vamos estar retornando falso é se tentarmos

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ão pop não tem argumentos,

133
00:08:30,000 --> 00:08:37,000
e devolve a cadeia de caracteres que está no topo da pilha.

134
00:08:37,000 --> 00:08:41,000
Tudo o que foi mais recentemente colocado na pilha é o pop está voltando,

135
00:08:41,000 --> 00:08:44,000
e também remove da pilha.

136
00:08:44,000 --> 00:08:50,000
E notem que ele retorna nulo se não houver nada na pilha.

137
00:08:50,000 --> 00:08:53,000
É sempre possível que a pilha está vazia.

138
00:08:53,000 --> 00:08:55,000
Em Java, se você está acostumado a isso, ou outras línguas,

139
00:08:55,000 --> 00:09:01,000
tentando aparecer a partir de uma pilha vazia pode causar uma exceção ou algo assim.

140
00:09:01,000 --> 00:09:09,000
>> Mas em C, nulo é uma espécie de grande quantidade de casos como lidar com estes problemas.

141
00:09:09,000 --> 00:09:13,000
Voltando nulo é como nós vamos para significar que a pilha estava vazio.

142
00:09:13,000 --> 00:09:16,000
Nós fornecemos o código que irá testar a funcionalidade do seu stack,

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

144
00:09:19,000 --> 00:09:23,000
Isso não vai ser um monte de código.

145
00:09:23,000 --> 00:09:40,000
Eu vou, na verdade, antes de fazer isso, dica, sugestão-

146
00:09:40,000 --> 00:09:44,000
se você ainda não viu, malloc não é a única função

147
00:09:44,000 --> 00:09:47,000
que aloca memória na pilha para você.

148
00:09:47,000 --> 00:09:51,000
Há uma família de funções alloc.

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

150
00:09:53,000 --> 00:09:56,000
Então há calloc, que faz a mesma coisa que malloc,

151
00:09:56,000 --> 00:09:59,000
mas vai zerar tudo para você.

152
00:09:59,000 --> 00:10:04,000
Se você sempre quis para definir tudo para null após mallocing algo

153
00:10:04,000 --> 00:10:06,000
você deve ter usado apenas calloc, em primeiro lugar, em vez de escrever

154
00:10:06,000 --> 00:10:09,000
um loop for para zerar todo o bloco de memória.

155
00:10:09,000 --> 00:10:15,000
>> Realloc é como malloc e tem um monte de casos especiais,

156
00:10:15,000 --> 00:10:19,000
mas basicamente o que faz é realloc

157
00:10:19,000 --> 00:10:24,000
leva um ponteiro que já havia sido alocado.

158
00:10:24,000 --> 00:10:27,000
Realloc é a função que você deseja estar prestando atenção aqui.

159
00:10:27,000 --> 00:10:31,000
É preciso um ponteiro que já havia sido devolvido a partir de malloc.

160
00:10:31,000 --> 00:10:35,000
Vamos dizer que você solicitar malloc um ponteiro de 10 bytes.

161
00:10:35,000 --> 00:10:38,000
Então, mais tarde você percebe que você queria 20 bytes,

162
00:10:38,000 --> 00:10:42,000
Então você chama realloc em que o ponteiro com 20 bytes,

163
00:10:42,000 --> 00:10:47,000
realloc e automaticamente copiar tudo para você.

164
00:10:47,000 --> 00:10:51,000
Se você acabou de chamar malloc novamente, como eu tenho um bloco de 10 bytes.

165
00:10:51,000 --> 00:10:53,000
Agora eu preciso de um bloco de 20 bytes,

166
00:10:53,000 --> 00:10:58,000
então se eu malloc 20 bytes, então eu tenho que copiar manualmente ao longo dos 10 bytes de a primeira coisa

167
00:10:58,000 --> 00:11:01,000
na segunda coisa e então livre a primeira coisa.

168
00:11:01,000 --> 00:11:04,000
Realloc vai lidar com isso para você.

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

170
00:11:11,000 --> 00:11:15,000
que é apenas retornar um ponteiro para o bloco de memória,

171
00:11:15,000 --> 00:11:17,000
em seguida, void * ptr.

172
00:11:17,000 --> 00:11:22,000
Você pode pensar em void * como um ponteiro genérico.

173
00:11:22,000 --> 00:11:27,000
Geralmente, você nunca lidar com void *,

174
00:11:27,000 --> 00:11:30,000
malloc mas está retornando um void *, e então ele é apenas usado como

175
00:11:30,000 --> 00:11:34,000
isto é, na verdade, vai ser um char *.

176
00:11:34,000 --> 00:11:37,000
Void * anterior, que havia sido devolvido por malloc

177
00:11:37,000 --> 00:11:41,000
agora vai ser passado para realloc e tamanho

178
00:11:41,000 --> 00:11:49,000
é o novo número de bytes que você deseja alocar, para que a sua nova capacidade.

179
00:11:49,000 --> 00:11:57,000
Eu vou te dar um par de minutos, e fazê-lo em nosso espaço.

180
00:11:57,000 --> 00:12:02,000
Comece com Revisão 1.

181
00:12:16,000 --> 00:12:21,000
Eu vou parar depois espero que sobre tempo suficiente para implementar push,

182
00:12:21,000 --> 00:12:24,000
e então eu vou dar-lhe uma outra ruptura de fazer pop.

183
00:12:24,000 --> 00:12:27,000
Mas realmente não é que o código muito em tudo.

184
00:12:27,000 --> 00:12:35,000
A maior parte do código é provavelmente o material em expansão, a expansão da capacidade.

185
00:12:35,000 --> 00:12:39,000
Ok, nenhuma pressão para ser completamente feito,

186
00:12:39,000 --> 00:12:47,000
mas contanto que você sente que está no caminho certo, isso é bom.

187
00:12:47,000 --> 00:12:53,000
>> Alguém tem algum código que se sentir confortável comigo puxando para cima?

188
00:12:53,000 --> 00:12:59,000
Sim, eu vou, mas alguém tem algum código que pode puxar para cima?

189
00:12:59,000 --> 00:13:05,000
Ok, você pode começar, salvá-lo, seja o que for?

190
00:13:05,000 --> 00:13:09,000
Eu sempre esqueço que passo.

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

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

193
00:13:18,000 --> 00:13:24,000
[Estudante] Primeiro de tudo, eu aumentei o tamanho.

194
00:13:24,000 --> 00:13:28,000
Eu acho que talvez eu deveria ter que de qualquer maneira, eu aumentei o tamanho,

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

196
00:13:31,000 --> 00:13:36,000
E se é menos do que a capacidade, eu acrescentar à matriz que já temos.

197
00:13:36,000 --> 00:13:42,000
E se não for, eu multiplicar a capacidade por 2,

198
00:13:42,000 --> 00:13:50,000
e eu realocar a matriz cordas para algo com um tamanho maior capacidade agora.

199
00:13:50,000 --> 00:13:55,000
E depois, se falhar, eu digo o usuário e retornar falso,

200
00:13:55,000 --> 00:14:04,000
e se ele está bem, então eu coloquei a corda no novo local.

201
00:14:04,000 --> 00:14:07,000
>> [Rob B.] Note também que se a um operador bit a bit agradável aqui

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

203
00:14:09,000 --> 00:14:11,000
Lembre-se, desvio à esquerda é sempre vai ser multiplicada por 2.

204
00:14:11,000 --> 00:14:15,000
Deslocamento para a direita é dividido por dois, desde que você lembre-se que isso significa

205
00:14:15,000 --> 00:14:18,000
dividir por 2, como em um inteiro dividido por 2.

206
00:14:18,000 --> 00:14:20,000
Ele pode truncar a 1 aqui ou ali.

207
00:14:20,000 --> 00:14:26,000
Mas mudança deixada por um sempre vai ser multiplicado por 2,

208
00:14:26,000 --> 00:14:32,000
a menos que transbordam os limites do número inteiro, e então não vai ser.

209
00:14:32,000 --> 00:14:34,000
Um comentário lateral.

210
00:14:34,000 --> 00:14:39,000
Eu gosto de fazer-isso não vai mudar a codificação qualquer forma,

211
00:14:39,000 --> 00:14:48,000
mas eu gostaria de fazer algo assim.

212
00:14:48,000 --> 00:14:51,000
Ele realmente está indo para torná-lo um pouco mais.

213
00:15:04,000 --> 00:15:08,000
Talvez este não é o caso perfeito para mostrar isso,

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

215
00:15:14,000 --> 00:15:17,000
ok, se isso se acontecer, então eu vou fazer alguma coisa,

216
00:15:17,000 --> 00:15:19,000
e, em seguida, a função é feito.

217
00:15:19,000 --> 00:15:22,000
Eu não preciso de role meus olhos todo o caminho até a função

218
00:15:22,000 --> 00:15:25,000
para ver o que acontece após o outro.

219
00:15:25,000 --> 00:15:27,000
É, se isso se acontecer, então eu voltar.

220
00:15:27,000 --> 00:15:30,000
Ele também tem o benefício adicional de tudo agradável para além deste

221
00:15:30,000 --> 00:15:33,000
agora é deslocado para a esquerda uma vez.

222
00:15:33,000 --> 00:15:40,000
Eu já não precisa-se sempre perto ridiculamente longas filas,

223
00:15:40,000 --> 00:15:45,000
então esses 4 bytes pode ajudar, e também a algo mais à esquerda é,

224
00:15:45,000 --> 00:15:48,000
a menos sobrecarregado você se sentiria se gosta, tudo bem, eu tenho que lembrar

225
00:15:48,000 --> 00:15:53,000
Eu estou atualmente em um loop while dentro de um interior mais de um loop.

226
00:15:53,000 --> 00:15:58,000
Em qualquer lugar você pode fazer isso de retorno imediato, eu meio que gosto.

227
00:15:58,000 --> 00:16:05,000
É totalmente opcional e não é esperado de qualquer forma.

228
00:16:05,000 --> 00:16:12,000
>> [Estudante] Deve haver um tamanho - na condição de falha?

229
00:16:12,000 --> 00:16:19,000
A condição de falha aqui é que nós não realloc, então sim.

230
00:16:19,000 --> 00:16:22,000
Observe como na condição de falha, presumivelmente,

231
00:16:22,000 --> 00:16:26,000
a não ser que o material livre depois, estamos sempre vai falhar

232
00:16:26,000 --> 00:16:29,000
não importa quantas vezes nós tentar empurrar alguma coisa.

233
00:16:29,000 --> 00:16:32,000
Se continuarmos a empurrar, vamos manter o tamanho do incremento,

234
00:16:32,000 --> 00:16:36,000
mesmo que não estamos colocando nada na pilha.

235
00:16:36,000 --> 00:16:39,000
Normalmente nós não aumentar o tamanho até

236
00:16:39,000 --> 00:16:43,000
depois conseguimos colocá-lo na pilha.

237
00:16:43,000 --> 00:16:50,000
Podemos fazer, por exemplo, ou aqui e aqui.

238
00:16:50,000 --> 00:16:56,000
E então, em vez de dizer s.size capacidade ≤, é menos do que a capacidade,

239
00:16:56,000 --> 00:17:01,000
apenas porque nos mudamos onde estava tudo.

240
00:17:01,000 --> 00:17:07,000
>> E lembre-se, o único lugar que poderia retornar falso

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

242
00:17:14,000 --> 00:17:19,000
e se acontecer de você se lembrar de erro padrão,

243
00:17:19,000 --> 00:17:22,000
talvez você pode considerar este um caso em que você deseja imprimir um erro padrão,

244
00:17:22,000 --> 00:17:26,000
stderr para fprintf em vez de apenas imprimir diretamente para a saída padrão.

245
00:17:26,000 --> 00:17:31,000
Mais uma vez, isso não é uma expectativa, mas se é um erro,

246
00:17:31,000 --> 00:17:41,000
printf digitar, então você pode querer fazê-lo imprimir ao erro padrão em vez de saída padrão.

247
00:17:41,000 --> 00:17:44,000
>> Alguém tem mais alguma coisa a notar? Sim.

248
00:17:44,000 --> 00:17:47,000
[Estudante] Você pode ir até o [inaudível]?

249
00:17:47,000 --> 00:17:55,000
[Rob B.] Sim, o binariness real dele ou apenas o que é?

250
00:17:55,000 --> 00:17:57,000
[Estudante] Então você multiplicar isso por 2?

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

252
00:17:59,000 --> 00:18:11,000
Em terra binário, nós sempre temos o conjunto de dígitos.

253
00:18:11,000 --> 00:18:22,000
Mudando esta esquerda por uma basicamente insere-lo aqui no lado direito.

254
00:18:22,000 --> 00:18:25,000
Voltar para isso, basta lembrar que tudo em binário

255
00:18:25,000 --> 00:18:28,000
é uma potência de 2, pelo 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
Ao inserir um 0 para o lado direito agora, só mudar tudo de novo.

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

259
00:18:38,000 --> 00:18:41,000
O lado direito que nós inserimos

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

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

262
00:18:46,000 --> 00:18:49,000
Se você já se multiplicar um número por 2, isso não vai acabar estranho,

263
00:18:49,000 --> 00:18:54,000
de modo que o 2 para o local de 0 deve ser de 0,

264
00:18:54,000 --> 00:18:59,000
e é isso que eu meio que alertou sobre antes é se você fizer acontecer para mudar

265
00:18:59,000 --> 00:19:01,000
para além do número de bits de um número inteiro,

266
00:19:01,000 --> 00:19:04,000
então este é um vai acabar saindo.

267
00:19:04,000 --> 00:19:10,000
Essa é a única preocupação se acontecer de você estar lidando com capacidades muito grandes.

268
00:19:10,000 --> 00:19:15,000
Mas nesse ponto, então você está lidando com uma matriz de milhares de milhões de coisas,

269
00:19:15,000 --> 00:19:25,000
que pode não caber na memória de qualquer maneira.

270
00:19:25,000 --> 00:19:31,000
>> Agora podemos chegar ao pop, o que é ainda mais fácil.

271
00:19:31,000 --> 00:19:36,000
Você poderia fazer como se acontecer de você aparecer um monte,

272
00:19:36,000 --> 00:19:38,000
e agora você está na metade de sua capacidade novamente.

273
00:19:38,000 --> 00:19:42,000
Você poderia realloc para diminuir a quantidade de memória que você tem,

274
00:19:42,000 --> 00:19:47,000
mas você não tem que se preocupar com isso, então o caso realloc só vai ser

275
00:19:47,000 --> 00:19:50,000
crescente memória, nunca diminuir a memória,

276
00:19:50,000 --> 00:19:59,000
que vai fazer de super pop fácil.

277
00:19:59,000 --> 00:20:02,000
Agora filas, que vão ser como pilhas,

278
00:20:02,000 --> 00:20:06,000
mas a ordem que você tome as coisas é invertida.

279
00:20:06,000 --> 00:20:10,000
O exemplo prototípico de uma fila é uma linha,

280
00:20:10,000 --> 00:20:12,000
então eu acho que se você fosse Inglês, eu teria dito

281
00:20:12,000 --> 00:20:17,000
um exemplo prototípico de uma fila é uma fila.

282
00:20:17,000 --> 00:20:22,000
Assim como uma linha, se você é a primeira pessoa na linha,

283
00:20:22,000 --> 00:20:24,000
você espera ser a primeira pessoa fora da linha.

284
00:20:24,000 --> 00:20:31,000
Se você é a última pessoa na linha, você vai ser a última pessoa atendida.

285
00:20:31,000 --> 00:20:35,000
Nós chamamos esse padrão FIFO, enquanto pilha era padrão LIFO.

286
00:20:35,000 --> 00:20:40,000
Essas palavras são bastante universal.

287
00:20:40,000 --> 00:20:46,000
>> Como pilhas e diferentemente de matrizes, as filas normalmente não permitem o acesso a elementos no meio.

288
00:20:46,000 --> 00:20:50,000
Aqui, uma pilha, temos push e pop.

289
00:20:50,000 --> 00:20:54,000
Aqui, acontece que temos chamado enqueue e dequeue.

290
00:20:54,000 --> 00:20:58,000
Eu também ouvi-los chamado de turno e unshift.

291
00:20:58,000 --> 00:21:02,000
Eu ouvi pessoas dizerem push e pop para também aplicar a filas.

292
00:21:02,000 --> 00:21:05,000
Ouvi inserir, remover,

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

294
00:21:11,000 --> 00:21:16,000
Se você está falando sobre filas, você pode escolher as palavras que você deseja usar

295
00:21:16,000 --> 00:21:23,000
para inserção e remoção, e não há consenso sobre o que deve ser chamado.

296
00:21:23,000 --> 00:21:27,000
Mas aqui, temos enqueue e dequeue.

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

298
00:21:37,000 --> 00:21:40,000
Mas temos que manter o controle de cabeça.

299
00:21:40,000 --> 00:21:44,000
Eu acho que ele diz aqui, mas por que precisamos da cabeça?

300
00:21:53,000 --> 00:21:57,000
Os protótipos são praticamente idênticos ao push e pop.

301
00:21:57,000 --> 00:21:59,000
Você pode pensar nisso como push e pop.

302
00:21:59,000 --> 00:22:08,000
A única diferença é pop está voltando em vez da última, ele está retornando o primeiro.

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

304
00:22:12,000 --> 00:22:14,000
E aqui está o início.

305
00:22:14,000 --> 00:22:17,000
Nossa fila está completamente cheio, por isso há quatro elementos nele.

306
00:22:17,000 --> 00:22:21,000
O fim da nossa fila é atualmente de 2,

307
00:22:21,000 --> 00:22:24,000
e agora vamos para inserir algo mais.

308
00:22:24,000 --> 00:22:29,000
>> Quando queremos inserir esse algo mais, o que fizemos para a versão de pilha

309
00:22:29,000 --> 00:22:36,000
é que nós estendemos o nosso bloco de memória.

310
00:22:36,000 --> 00:22:40,000
Qual é o problema com isso?

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

312
00:22:45,000 --> 00:22:51,000
O que eu disse antes sobre o fim da fila,

313
00:22:51,000 --> 00:22:57,000
isso não faz sentido que começam em 1,

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

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

316
00:23:05,000 --> 00:23:08,000
Nós não podemos usar realloc agora,

317
00:23:08,000 --> 00:23:11,000
ou, no mínimo, você tem que usar realloc de uma maneira diferente.

318
00:23:11,000 --> 00:23:15,000
Mas provavelmente você não deve apenas usar realloc.

319
00:23:15,000 --> 00:23:18,000
Você vai ter que copiar manualmente sua memória.

320
00:23:18,000 --> 00:23:21,000
>> Existem duas funções para copiar a memória.

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

322
00:23:25,000 --> 00:23:29,000
Atualmente estou lendo as páginas do manual para ver qual deles você vai querer usar.

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

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

325
00:23:38,000 --> 00:23:41,000
onde você está copiando para uma região que acontece a sobrepor-se a região

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

327
00:23:46,000 --> 00:23:50,000
Memcopy não lidar com isso. Memmove faz.

328
00:23:50,000 --> 00:23:59,000
Você pode pensar no problema como-

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

330
00:24:09,000 --> 00:24:13,000
estes quatro para esse cara.

331
00:24:13,000 --> 00:24:16,000
No final, o que a matriz deve ser semelhante

332
00:24:16,000 --> 00:24:26,000
após a cópia é 2, 1, 2, 1, 3, 4, e, em seguida, algumas coisas no final.

333
00:24:26,000 --> 00:24:29,000
Mas esta é dependente da ordem em que, na verdade, copiar,

334
00:24:29,000 --> 00:24:32,000
pois, se não considerarmos o fato de que a região que está copiando em

335
00:24:32,000 --> 00:24:35,000
sobrepõe a que estamos copiando,

336
00:24:35,000 --> 00:24:46,000
então podemos fazer como começo aqui, copie a 2 para o lugar que quer ir,

337
00:24:46,000 --> 00:24:52,000
em seguida, passar nossos ponteiros para a frente.

338
00:24:52,000 --> 00:24:56,000
>> Agora nós vamos estar aqui e aqui, e agora queremos copiar

339
00:24:56,000 --> 00:25:04,000
esse cara esse cara e mover os nossos ponteiros para a frente.

340
00:25:04,000 --> 00:25:07,000
O que nós vamos acabar ficando é de 2, 1, 2, 1, 2, 1

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

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

343
00:25:15,000 --> 00:25:19,000
Memmove alças que corretamente.

344
00:25:19,000 --> 00:25:23,000
Neste caso, basicamente, apenas utilize sempre memmove

345
00:25:23,000 --> 00:25:26,000
porque ele lida corretamente.

346
00:25:26,000 --> 00:25:29,000
Geralmente não realizar qualquer pior.

347
00:25:29,000 --> 00:25:32,000
A idéia é, em vez de começar do início e cópia desta maneira

348
00:25:32,000 --> 00:25:35,000
como nós fizemos aqui, que começa a partir do final e copia em,

349
00:25:35,000 --> 00:25:38,000
e, nesse caso, você nunca pode ter um problema.

350
00:25:38,000 --> 00:25:40,000
Não há perda de performance.

351
00:25:40,000 --> 00:25:47,000
Sempre use memmove. Nunca se preocupe com memcopy.

352
00:25:47,000 --> 00:25:51,000
E é aí que você vai ter que separadamente memmove

353
00:25:51,000 --> 00:26:01,000
a porção envolta em torno de sua fila.

354
00:26:01,000 --> 00:26:04,000
Não se preocupe se não completamente feito.

355
00:26:04,000 --> 00:26:10,000
Isso é mais difícil do que pilha, pop push, e.

356
00:26:10,000 --> 00:26:15,000
>> Alguém tem algum código que poderia trabalhar?

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

358
00:26:21,000 --> 00:26:23,000
[Estudante] Sim, é completamente incompleta, no entanto.

359
00:26:23,000 --> 00:26:27,000
Completamente incompleta é bom, contanto que-você pode salvar a revisão?

360
00:26:27,000 --> 00:26:32,000
Eu esqueço que a cada momento.

361
00:26:32,000 --> 00:26:39,000
Ok, ignorando o que acontece quando precisamos redimensionar as coisas.

362
00:26:39,000 --> 00:26:42,000
Ignorar completamente redimensionamento.

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

364
00:26:49,000 --> 00:26:54,000
Estou verificando em primeiro lugar, se o tamanho é inferior a primeira cópia de todas

365
00:26:54,000 --> 00:27:01,000
e depois disso, eu insiro-me tomar a cabeça + tamanho,

366
00:27:01,000 --> 00:27:05,000
e eu ter certeza que envolve a capacidade da matriz,

367
00:27:05,000 --> 00:27:08,000
e eu inserir a nova cadeia nessa posição.

368
00:27:08,000 --> 00:27:12,000
Então eu aumentar o tamanho e retornar true.

369
00:27:12,000 --> 00:27:22,000
>> [Rob B.] Este é definitivamente um daqueles casos em que você vai querer estar usando mod.

370
00:27:22,000 --> 00:27:25,000
Qualquer tipo de caso onde você enrolar, se você acha que enrolar,

371
00:27:25,000 --> 00:27:29,000
o pensamento imediato deve ser mod.

372
00:27:29,000 --> 00:27:36,000
Como uma otimização rápido / fazer o seu código uma linha mais curta,

373
00:27:36,000 --> 00:27:42,000
você percebe que a linha imediatamente após este

374
00:27:42,000 --> 00:27:53,000
é apenas o tamanho + +, então você mesclar em que esta linha, tamanho + +.

375
00:27:53,000 --> 00:27:58,000
Agora aqui em baixo, temos o caso

376
00:27:58,000 --> 00:28:01,000
onde não tem memória suficiente,

377
00:28:01,000 --> 00:28:05,000
por isso estamos aumentando nossa capacidade por 2.

378
00:28:05,000 --> 00:28:09,000
Eu acho que você poderia ter o mesmo problema aqui, mas podemos ignorá-lo agora,

379
00:28:09,000 --> 00:28:13,000
onde se você não conseguiu aumentar a sua capacidade,

380
00:28:13,000 --> 00:28:18,000
então você vai querer diminuir a sua capacidade em 2 novamente.

381
00:28:18,000 --> 00:28:24,000
Outra nota curta é exatamente como você pode fazer + =,

382
00:28:24,000 --> 00:28:30,000
você também pode fazer << =.

383
00:28:30,000 --> 00:28:43,000
Quase tudo pode ir antes de igual para igual, + =, | =, & =, << =.

384
00:28:43,000 --> 00:28:52,000
Char * novo é o nosso novo bloco de memória.

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

386
00:28:55,000 --> 00:29:02,000
>> O que as pessoas pensam sobre o tipo do nosso novo bloco de memória?

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

388
00:29:06,000 --> 00:29:12,000
Pensando em nossa estrutura aqui em cima,

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 fazer um novo armazenamento dinâmico inteiro para os elementos na fila.

391
00:29:21,000 --> 00:29:25,000
O que nós vamos estar atribuindo a suas cordas é o que estamos mallocing agora,

392
00:29:25,000 --> 00:29:30,000
e tão nova, vai ser um char **.

393
00:29:30,000 --> 00:29:34,000
Vai ser uma matriz de strings.

394
00:29:34,000 --> 00:29:38,000
Então o que é o caso em que nós vamos retornar falso?

395
00:29:38,000 --> 00:29:41,000
[Estudante] Deveríamos estar fazendo o char *?

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

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

398
00:29:46,000 --> 00:29:49,000
[Rob B.] Nós queríamos fazer o tamanho de char *, porque não estamos mais-

399
00:29:49,000 --> 00:29:53,000
este seria realmente um problema muito grande, porque sizeof (char) seria 1.

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

401
00:29:55,000 --> 00:29:58,000
isso um monte de vezes, quando você está lidando com ints,

402
00:29:58,000 --> 00:30:01,000
você tende a fugir com ele porque o tamanho de int e tamanho de int *

403
00:30:01,000 --> 00:30:04,000
em um sistema de 32 bits vai ser a mesma coisa.

404
00:30:04,000 --> 00:30:09,000
Mas aqui, sizeof (char) e sizeof (char *) são agora vai ser a mesma coisa.

405
00:30:09,000 --> 00:30:15,000
>> O que é a circunstância em que retornar falso?

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

407
00:30:17,000 --> 00:30:23,000
Sim, se novo é nulo, nós retornar falso,

408
00:30:23,000 --> 00:30:34,000
e eu vou jogar aqui-

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

410
00:30:37,000 --> 00:30:39,000
[Rob B.] Sim, isso é ótimo.

411
00:30:39,000 --> 00:30:46,000
Você poderia fazer duas vezes a capacidade ou mudança de capacidade 1 e só então colocou-a aqui ou o que seja.

412
00:30:46,000 --> 00:30:52,000
Nós vamos fazer tudo o que se tinha.

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

414
00:30:56,000 --> 00:31:08,000
E você nunca vai ter que se preocupar em perder o seu lugar um

415
00:31:08,000 --> 00:31:12,000
porque você deixou desviado por um, de modo que o seu lugar um é necessariamente a 0,

416
00:31:12,000 --> 00:31:16,000
tão certo deslocamento por 1, você ainda vai estar bem.

417
00:31:16,000 --> 00:31:19,000
[Estudante] Você precisa fazer isso antes do retorno?

418
00:31:19,000 --> 00:31:29,000
[Rob B.] Sim, isso não faz nenhum sentido.

419
00:31:29,000 --> 00:31:36,000
>> Agora, vamos supor que vamos acabar voltando verdade até o fim.

420
00:31:36,000 --> 00:31:39,000
A maneira que nós vamos fazer essas memmoves,

421
00:31:39,000 --> 00:31:45,000
temos que ter cuidado com a forma como as fazemos.

422
00:31:45,000 --> 00:31:50,000
Alguém tem alguma sugestão de como as fazemos?

423
00:32:17,000 --> 00:32:21,000
Aqui está o nosso início.

424
00:32:21,000 --> 00:32:28,000
Inevitavelmente, queremos começar no início de novo

425
00:32:28,000 --> 00:32:35,000
e cópia em coisas de lá, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
Como você faz isso?

427
00:32:41,000 --> 00:32:52,000
Primeiro, eu tenho de olhar para a página do manual para memmove novamente.

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

429
00:32:57,000 --> 00:33:01,000
Queremos que o nosso primeiro destino, segundo fonte, a terceira dimensão.

430
00:33:01,000 --> 00:33:06,000
Há uma série de funções que invertem origem e destino.

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

432
00:33:17,000 --> 00:33:21,000
Movimento, o que é voltar?

433
00:33:21,000 --> 00:33:27,000
Ele retorna um ponteiro para o destino, por qualquer motivo, você pode querer isso.

434
00:33:27,000 --> 00:33:32,000
Eu posso imaginar lê-lo, mas queremos avançar para o nosso destino.

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

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

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

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

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

440
00:33:50,000 --> 00:33:55,000
O que é o endereço do 1?

441
00:33:55,000 --> 00:33:58,000
O que é o endereço do 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 endereço 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.] Sim, q.strings.

447
00:34:15,000 --> 00:34:20,000
Lembre-se, aqui, a nossa cabeça é 1.

448
00:34:20,000 --> 00:34:24,000
Droga. Eu só acho que é magicamente

449
00:34:24,000 --> 00:34:29,000
Aqui, nossa cabeça é 1. Eu vou mudar a minha cor também.

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

451
00:34:36,000 --> 00:34:41,000
Isso, nós pode escrever como fizemos aqui

452
00:34:41,000 --> 00:34:43,000
com cabeças + q.strings.

453
00:34:43,000 --> 00:34:51,000
Um monte de gente também escrevê-lo e q.strings [cabeça].

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

455
00:34:55,000 --> 00:34:58,000
Você pode pensar nisso como você está dereferencing-lo e em seguida, obter o endereço,

456
00:34:58,000 --> 00:35:04,000
mas o compilador vai traduzi-lo para o que tínhamos antes de qualquer forma, q.strings cabeça +.

457
00:35:04,000 --> 00:35:06,000
De qualquer maneira que você quer pensar nisso.

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

459
00:35:11,000 --> 00:35:15,000
[Estudante] Capacidade - cabeça.

460
00:35:15,000 --> 00:35:18,000
Capacidade - cabeça.

461
00:35:18,000 --> 00:35:21,000
E então você pode sempre escrever um exemplo

462
00:35:21,000 --> 00:35:23,000
para descobrir se isso é certo.

463
00:35:23,000 --> 00:35:26,000
[Estudante] Ela precisa ser dividido por dois, então.

464
00:35:26,000 --> 00:35:30,000
Sim, então eu acho que nós poderíamos usar tamanho.

465
00:35:30,000 --> 00:35:35,000
Nós ainda temos tamanho ser-

466
00:35:35,000 --> 00:35:39,000
usando tamanho, que tem tamanho igual a 4.

467
00:35:39,000 --> 00:35:42,000
Nosso tamanho é 4. Nossa cabeça é uma.

468
00:35:42,000 --> 00:35:46,000
Queremos copiar esses três elementos.

469
00:35:46,000 --> 00:35:54,000
Essa é a verificação de sanidade que tamanho - cabeça é corretamente 3.

470
00:35:54,000 --> 00:35:58,000
E voltar aqui, como dissemos antes,

471
00:35:58,000 --> 00:36:00,000
se usássemos capacidade, então teríamos que dividir por dois

472
00:36:00,000 --> 00:36:04,000
porque já crescido nossa capacidade, então em vez disso, vamos usar o tamanho.

473
00:36:11,000 --> 00:36:13,000
Que copia essa parte.

474
00:36:13,000 --> 00:36:18,000
Agora, precisamos copiar a outra parte, a parte que está à esquerda do início.

475
00:36:18,000 --> 00:36:28,000
>> Isso vai memmove em que posição?

476
00:36:28,000 --> 00:36:32,000
[Estudante] tamanho Plus - cabeça.

477
00:36:32,000 --> 00:36:38,000
Sim, por isso, já copiou em tamanho - bytes de cabeça,

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

479
00:36:43,000 --> 00:36:48,000
e tamanho de menos bem, o número de bytes que já copiado dentro

480
00:36:48,000 --> 00:36:52,000
E então 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.] Sim, q.strings.

483
00:36:56,000 --> 00:37:02,000
Podíamos fazer e q.strings [0].

484
00:37:02,000 --> 00:37:05,000
Isso é muito menos comum do que este.

485
00:37:05,000 --> 00:37:14,000
Se ele só vai ser 0, então você tende a ver q.strings.

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

487
00:37:16,000 --> 00:37:18,000
Quantos bytes que nos resta para copiar? >> [Estudante] 10.

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

489
00:37:20,000 --> 00:37:25,000
[Estudante] Nós temos que multiplicar 5-10 vezes o tamanho dos bytes ou algo assim?

490
00:37:25,000 --> 00:37:30,000
Sim, por isso este é o lugar onde, o que exatamente estamos copiando?

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

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

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

494
00:37:36,000 --> 00:37:41,000
Sim, então o char * s que estamos copiando, não sabemos onde aqueles são provenientes.

495
00:37:41,000 --> 00:37:47,000
Bem, onde eles estão apontando, como as cordas, acabamos empurrando-o para a fila

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

497
00:37:49,000 --> 00:37:51,000
Onde aqueles estão vindo, não temos idéia.

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

499
00:37:56,000 --> 00:38:00,000
Nós não queremos copiar tamanho - bytes de cabeça.

500
00:38:00,000 --> 00:38:03,000
Queremos copiar o tamanho - cabeça char * s,

501
00:38:03,000 --> 00:38:11,000
então vamos multiplicar isso por sizeof (char).

502
00:38:11,000 --> 00:38:17,000
Mesmo aqui em baixo, cabeça * 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
Isso aqui?

505
00:38:26,000 --> 00:38:28,000
[Estudante] Não, abaixo disso, o tamanho - cabeça.

506
00:38:28,000 --> 00:38:30,000
[Rob B.] Isso aqui?

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

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

509
00:38:35,000 --> 00:38:40,000
ele automaticamente multiplica pelo tamanho do tipo que estamos lidando.

510
00:38:40,000 --> 00:38:46,000
Assim como aqui, novo + (tamanho - cabeça)

511
00:38:46,000 --> 00:38:56,000
é exatamente equivalente a & [tamanho - cabeça] novo

512
00:38:56,000 --> 00:39:00,000
até que esperamos que funcione corretamente,

513
00:39:00,000 --> 00:39:04,000
pois, se estamos lidando com uma matriz int, então não fazer índice int-

514
00:39:04,000 --> 00:39:07,000
ou se é do tamanho de 5 e você deseja que o elemento 4, então 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
Você NÃO FAZEM [4] * O tamanho de 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ão, a sintaxe suporte

519
00:39:29,000 --> 00:39:34,000
é só ir para ser convertido para isso assim que você compilar.

520
00:39:34,000 --> 00:39:38,000
Isso é algo que você precisa ter cuidado com isso

521
00:39:38,000 --> 00:39:42,000
quando você está adicionando tamanho - cabeça

522
00:39:42,000 --> 00:39:45,000
você está adicionando não um byte.

523
00:39:45,000 --> 00:39:53,000
Você está adicionando um char *, que pode ser uma bytes ou o que seja.

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

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

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

527
00:40:11,000 --> 00:40:18,000
Ah, e eu acho que essa é a mesma situação 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
talvez nós queremos lidar com isso, talvez não.

530
00:40:24,000 --> 00:40:27,000
Nós não vamos fazer isso de novo aqui, mas mesmo que o nosso caso pilha.

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

532
00:40:34,000 --> 00:40:40,000
Alguém tem algum código que pode puxar para cima?

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

534
00:40:45,000 --> 00:40:56,000
A versão 2 é que, tudo bem.

535
00:40:56,000 --> 00:40:59,000
Você quer explicar?

536
00:40:59,000 --> 00:41:01,000
[Estudante] Primeiro, você se certificar de que há algo na fila

537
00:41:01,000 --> 00:41:07,000
e que o tamanho está indo para baixo em 1.

538
00:41:07,000 --> 00:41:11,000
Você precisa fazer isso, e depois voltar a cabeça

539
00:41:11,000 --> 00:41:13,000
e mova a cabeça 1.

540
00:41:13,000 --> 00:41:19,000
Ok, então não é um caso extremo, temos de considerar. Sim.

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

542
00:41:24,000 --> 00:41:26,000
então você não quiser cabeça para apontar fora da matriz.

543
00:41:26,000 --> 00:41:29,000
>> Sim, tão logo que cabeça bate o fim de nossa matriz,

544
00:41:29,000 --> 00:41:35,000
quando desenfileirar, nossa cabeça deve ser modded para 0.

545
00:41:35,000 --> 00:41:40,000
Infelizmente, não podemos fazer isso em uma única etapa.

546
00:41:40,000 --> 00:41:44,000
Eu acho que a maneira que eu provavelmente corrigi-lo é

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

548
00:41:52,000 --> 00:41:55,000
qualquer que seja o seu nome variável quer ser.

549
00:41:55,000 --> 00:42:02,000
Então nós queremos mod cabeça pela nossa capacidade

550
00:42:02,000 --> 00:42:10,000
e depois voltar ret.

551
00:42:10,000 --> 00:42:14,000
Um monte de gente aqui que poderiam fazer-

552
00:42:14,000 --> 00:42:19,000
este é o caso de ver as pessoas, pois você fazer se a cabeça

553
00:42:19,000 --> 00:42:29,000
é maior do que a capacidade, fazer a cabeça - capacidade.

554
00:42:29,000 --> 00:42:36,000
E isso é apenas a trabalhar em torno do que é mod.

555
00:42:36,000 --> 00:42:41,000
Chefe mod = capacidade é muito mais limpo

556
00:42:41,000 --> 00:42:51,000
de um invólucro em torno do que se a cabeça maior do que a cabeça de capacidade - a capacidade.

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

558
00:42:56,000 --> 00:43:02,000
Ok, a última coisa que nos resta é a nossa lista encadeada.

559
00:43:02,000 --> 00:43:07,000
Você pode ser usado para alguns dos comportamentos lista ligada se você fez

560
00:43:07,000 --> 00:43:11,000
listas ligadas em suas tabelas de hash, se você fez uma tabela hash.

561
00:43:11,000 --> 00:43:15,000
Eu recomendo fortemente a fazer uma tabela hash.

562
00:43:15,000 --> 00:43:17,000
Você já deve ter feito uma trie,

563
00:43:17,000 --> 00:43:23,000
mas tentativas são mais difíceis.

564
00:43:23,000 --> 00:43:27,000
Em teoria, eles são assintoticamente melhor.

565
00:43:27,000 --> 00:43:30,000
Mas basta olhar para a placa grande,

566
00:43:30,000 --> 00:43:35,000
e tenta não fazer melhor, e eles ocupam mais memória.

567
00:43:35,000 --> 00:43:43,000
Tudo sobre tenta acaba sendo pior para mais trabalho.

568
00:43:43,000 --> 00:43:49,000
É o que solução David Malan sempre é

569
00:43:49,000 --> 00:43:56,000
Ele é sempre mensagens Sua solução trie, e vamos ver onde ele é atualmente.

570
00:43:56,000 --> 00:44:00,000
O que ele estava sob, David J?

571
00:44:00,000 --> 00:44:06,000
Ele é n º 18, de modo que não é terrivelmente ruim,

572
00:44:06,000 --> 00:44:09,000
e que vai ser um dos melhores tentativas você pode pensar

573
00:44:09,000 --> 00:44:17,000
ou um dos melhores da procura de um trie.

574
00:44:17,000 --> 00:44:23,000
Não é mesmo a sua solução original?

575
00:44:23,000 --> 00:44:29,000
Eu me sinto como soluções trie tendem a ser mais nesta faixa de uso de RAM.

576
00:44:29,000 --> 00:44:33,000
>> Vá até o topo, e uso de RAM está na casa de um dígito.

577
00:44:33,000 --> 00:44:36,000
Desça para o fundo, e então você começa a ver tenta

578
00:44:36,000 --> 00:44:41,000
onde você começa o uso de RAM absolutamente enorme,

579
00:44:41,000 --> 00:44:45,000
e tentativas são mais difíceis.

580
00:44:45,000 --> 00:44:53,000
Não inteiramente pena, mas uma experiência educacional se você fez um.

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

582
00:44:56,000 --> 00:45:04,000
e essas três coisas, pilhas, filas e listas ligadas,

583
00:45:04,000 --> 00:45:09,000
qualquer coisa futura que você faz em ciência da computação

584
00:45:09,000 --> 00:45:12,000
supor que você tem familiaridade com essas coisas.

585
00:45:12,000 --> 00:45:19,000
Eles são tão fundamental para tudo.

586
00:45:19,000 --> 00:45:25,000
>> Listas ligadas, e aqui temos uma lista vinculada isoladamente vai ser nossa implementação.

587
00:45:25,000 --> 00:45:34,000
O que significa vinculada isoladamente ao contrário duplamente ligada? Sim.

588
00:45:34,000 --> 00:45:37,000
[Estudante] É apenas aponta para o ponteiro próximo e não para os ponteiros,

589
00:45:37,000 --> 00:45:39,000
como o que precede e aquele após ele.

590
00:45:39,000 --> 00:45:44,000
É, então, em formato de imagem, o que eu faço?

591
00:45:44,000 --> 00:45:48,000
Eu tenho duas coisas. Eu tenho imagem e imagem.

592
00:45:48,000 --> 00:45:51,000
Em formato de imagem, os nossos individualmente listas ligadas,

593
00:45:51,000 --> 00:45:57,000
inevitavelmente, nós temos algum tipo de ponteiro para a cabeça da nossa lista,

594
00:45:57,000 --> 00:46:02,000
e, em seguida, dentro de nossa lista, só temos ponteiros,

595
00:46:02,000 --> 00:46:05,000
e talvez isso aponta para nulo.

596
00:46:05,000 --> 00:46:08,000
Vai ser o seu desenho típico de uma lista vinculada isoladamente.

597
00:46:08,000 --> 00:46:14,000
Uma lista duplamente ligada, você pode ir para trás.

598
00:46:14,000 --> 00:46:19,000
Se eu lhe der qualquer nó na lista, então você pode necessariamente chegar a

599
00:46:19,000 --> 00:46:23,000
qualquer outro nó na lista se ele é uma lista duplamente ligada.

600
00:46:23,000 --> 00:46:27,000
Mas se eu te o terceiro nó na lista e é uma lista vinculada isoladamente,

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

602
00:46:30,000 --> 00:46:34,000
E há benefícios e malefícios, e um um óbvio

603
00:46:34,000 --> 00:46:42,000
é você pegar mais tamanho, e você tem que manter o controle de onde essas coisas estão apontando agora.

604
00:46:42,000 --> 00:46:49,000
Mas só se preocupam vinculada isoladamente.

605
00:46:49,000 --> 00:46:53,000
>> Algumas coisas que vamos ter que implementar.

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

607
00:47:00,000 --> 00:47:09,000
Typedef que devem ser queimados em suas mentes.

608
00:47:09,000 --> 00:47:14,000
Quiz 1 deve ser como dar um typedef de um nó de lista ligada,

609
00:47:14,000 --> 00:47:18,000
e você deve ser capaz de rabiscar imediatamente que para baixo

610
00:47:18,000 --> 00:47:22,000
sem sequer pensar sobre isso.

611
00:47:22,000 --> 00:47:27,000
Eu acho que algumas perguntas, por que precisamos de struct aqui?

612
00:47:27,000 --> 00:47:32,000
Por que não podemos dizer * nó?

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

614
00:47:35,000 --> 00:47:38,000
Sim.

615
00:47:38,000 --> 00:47:44,000
A única coisa que define um nó como uma coisa

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

617
00:47:47,000 --> 00:47:55,000
Mas a partir deste ponto, quando estamos tipo de análise por esta definição do nó de estrutura,

618
00:47:55,000 --> 00:48:01,000
nós não terminamos nosso typedef ainda, então desde o typedef não terminou,

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

620
00:48:05,000 --> 00:48:12,000
Mas struct nó faz, e esse nó aqui,

621
00:48:12,000 --> 00:48:14,000
isso também poderia ser chamado de qualquer outra coisa.

622
00:48:14,000 --> 00:48:16,000
Isto poderia ser chamado n.

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

624
00:48:19,000 --> 00:48:21,000
Poderia ser chamado de qualquer coisa.

625
00:48:21,000 --> 00:48:26,000
Mas esse nó estrutura precisa ser chamada a mesma coisa que este nó struct.

626
00:48:26,000 --> 00:48:29,000
O que você chama isso tem que ser também aqui,

627
00:48:29,000 --> 00:48:32,000
e para que também responde o segundo ponto da questão

628
00:48:32,000 --> 00:48:37,000
é por isso que, muitas vezes, quando você ver estruturas e typedefs de estruturas,

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

630
00:48:42,000 --> 00:48:47,000
implementação de dicionário estrutura, ou o que seja.

631
00:48:47,000 --> 00:48:51,000
>> Por que aqui não precisamos dizer nó?

632
00:48:51,000 --> 00:48:54,000
Por que não pode ser uma estrutura anônimo?

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

634
00:48:56,000 --> 00:48:58,000
[Estudante] Você precisa se referir a ele dentro da estrutura.

635
00:48:58,000 --> 00:49:04,000
Sim, dentro da estrutura, que você precisa para se referir à estrutura em si.

636
00:49:04,000 --> 00:49:10,000
Se você não dá a estrutura de um nome, se é uma estrutura anônimo, você não pode se referir a ele.

637
00:49:10,000 --> 00:49:17,000
E por último, mas, pelo menos, estes não devem ser todos um pouco simples,

638
00:49:17,000 --> 00:49:20,000
e eles devem ajudar você a perceber se você está escrevendo isso

639
00:49:20,000 --> 00:49:24,000
que você está fazendo algo errado, se este tipo de coisas não fazem sentido.

640
00:49:24,000 --> 00:49:28,000
Por último, mas não menos importante, por que isso tem que ser struct * nó?

641
00:49:28,000 --> 00:49:34,000
Por que não pode ser apenas struct próximo nó?

642
00:49:34,000 --> 00:49:37,000
[Estudante] Ponteiro para a estrutura que vem.

643
00:49:37,000 --> 00:49:39,000
Isso é inevitável o que queremos.

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

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

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

647
00:49:53,000 --> 00:49:55,000
Sim.

648
00:49:55,000 --> 00:49:57,000
[Estudante] Seria tudo em um.

649
00:49:57,000 --> 00:50:02,000
Sim, só de pensar como seria fazer o tamanho ou algo assim.

650
00:50:02,000 --> 00:50:08,000
Tamanho de uma estrutura é basicamente + ou - um padrão aqui ou ali.

651
00:50:08,000 --> 00:50:15,000
É basicamente vai ser a soma dos tamanhos das coisas na estrutura.

652
00:50:15,000 --> 00:50:18,000
Isso aqui, sem mudar nada, o tamanho vai ser fácil.

653
00:50:18,000 --> 00:50:24,000
Tamanho do nó struct vai ser tamanho de i + tamanho do próximo.

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

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

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

657
00:50:34,000 --> 00:50:37,000
em seguida, sizeof (i) vai ser 4.

658
00:50:37,000 --> 00:50:43,000
Tamanho do nó struct próximo vai ser o tamanho da i + tamanho do nó seguinte struct

659
00:50:43,000 --> 00:50:46,000
+ Tamanho da i + tamanho do nó struct seguinte.

660
00:50:46,000 --> 00:50:55,000
Seria uma recursividade infinita de nós.

661
00:50:55,000 --> 00:51:00,000
É por isso que esta é a forma como as coisas têm que ser.

662
00:51:00,000 --> 00:51:03,000
>> Mais uma vez, definitivamente memorizar que,

663
00:51:03,000 --> 00:51:06,000
ou pelo menos entendê-lo o suficiente para que você pode ser capaz de

664
00:51:06,000 --> 00:51:12,000
razão pela qual ele deve ser parecido.

665
00:51:12,000 --> 00:51:14,000
As coisas que vamos querer implementar.

666
00:51:14,000 --> 00:51:18,000
Se o comprimento da lista

667
00:51:18,000 --> 00:51:21,000
você pode enganar e manter em torno de um

668
00:51:21,000 --> 00:51:24,000
comprimento global ou algo assim, mas nós não vamos fazer isso.

669
00:51:24,000 --> 00:51:28,000
Nós vamos contar o tamanho da lista.

670
00:51:28,000 --> 00:51:34,000
Nós contém, de modo que é, basicamente, como uma pesquisa,

671
00:51:34,000 --> 00:51:41,000
por isso temos uma lista ligada de inteiros para ver se este inteiro está na lista ligada.

672
00:51:41,000 --> 00:51:44,000
Prepend vai inserir no início da lista.

673
00:51:44,000 --> 00:51:46,000
Anexar vai inserir no fim.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted vai inserir na posição classificada na lista.

675
00:51:53,000 --> 00:52:01,000
Tipo de Insert_sorted assume que você nunca usou preceder ou anexar em maus caminhos.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted quando você está implementando insert_sorted-

677
00:52:09,000 --> 00:52:13,000
vamos dizer que temos a nossa 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 inserir 3, por isso, enquanto a própria lista já está classificado,

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

681
00:52:27,000 --> 00:52:29,000
Eu começo no 2.

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

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

684
00:52:35,000 --> 00:52:39,000
e eu tenho que corrigir ponteiros e todas essas coisas.

685
00:52:39,000 --> 00:52:43,000
Mas se nós não estritamente usar insert_sorted,

686
00:52:43,000 --> 00:52:50,000
como vamos apenas dizer que eu preceder 6,

687
00:52:50,000 --> 00:52:55,000
então minha lista encadeada vai se tornar isso.

688
00:52:55,000 --> 00:53:01,000
Ele agora não faz sentido, portanto, para insert_sorted, você pode simplesmente assumir

689
00:53:01,000 --> 00:53:04,000
que a lista é ordenada, embora existam operações

690
00:53:04,000 --> 00:53:09,000
o que pode causar-lhe para não ser ordenado, e é isso.

691
00:53:09,000 --> 00:53:20,000
Encontre um útil de inserção, de modo essas são as principais coisas que você vai ter que implementar.

692
00:53:20,000 --> 00:53:24,000
>> Por agora, tomar um minuto para fazer comprimento e contém,

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

694
00:53:41,000 --> 00:53:48,000
Aproximando-se o tempo de fechamento, por isso ninguém tem nada para o comprimento ou contém?

695
00:53:48,000 --> 00:53:50,000
Eles vão ser quase idênticos.

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

697
00:53:57,000 --> 00:54:01,000
Vamos ver, de revisão.

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

699
00:54:12,000 --> 00:54:15,000
Você quer explicar?

700
00:54:15,000 --> 00:54:21,000
[Estudante] Eu só criar um nó ponteiro e inicializar a primeira, que é a nossa variável global,

701
00:54:21,000 --> 00:54:27,000
e então eu verificar para ver se é nulo, então eu não tiver uma falha de seg e retornar 0 se for o caso.

702
00:54:27,000 --> 00:54:34,000
Caso contrário, eu percorrer, mantendo o controle de dentro inteiro

703
00:54:34,000 --> 00:54:38,000
quantas vezes eu já acessou o elemento seguinte da lista

704
00:54:38,000 --> 00:54:43,000
e na operação mesmo incremento também acessar esse elemento real,

705
00:54:43,000 --> 00:54:47,000
e então eu continuamente fazer a verificação para ver se é nulo,

706
00:54:47,000 --> 00:54:56,000
e se é nulo, então ele aborta e só retorna o número de elementos que eu acessados.

707
00:54:56,000 --> 00:55:01,000
>> [Rob B.] Alguém tem algum comentário sobre qualquer coisa?

708
00:55:01,000 --> 00:55:06,000
Isso parece correto bem sábio.

709
00:55:06,000 --> 00:55:10,000
[Estudante] Eu não acho que você precisa do nó == null.

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

711
00:55:13,000 --> 00:55:18,000
Mas se nulo nó == então esta-oh, não é uma questão de correção.

712
00:55:18,000 --> 00:55:23,000
Era só você está retornando i, mas não é de âmbito agora.

713
00:55:23,000 --> 00:55:30,000
Você só precisa int i, para i = 0.

714
00:55:30,000 --> 00:55:34,000
Mas se o nó é nulo, então eu ainda vai ser 0,

715
00:55:34,000 --> 00:55:39,000
e nós estamos indo para retornar 0, portanto, neste caso, é idêntico.

716
00:55:39,000 --> 00:55:48,000
Outra coisa comum é a de manter a declaração

717
00:55:48,000 --> 00:55:51,000
de dentro do nó do laço for.

718
00:55:51,000 --> 00:55:54,000
Você poderia dizer-oh, não.

719
00:55:54,000 --> 00:55:56,000
Vamos mantê-lo como este.

720
00:55:56,000 --> 00:55:59,000
Eu, provavelmente, colocar int i = 0 aqui,

721
00:55:59,000 --> 00:56:05,000
então nó * nó = primeiro aqui.

722
00:56:05,000 --> 00:56:11,000
E este é, provavelmente, como-se livrar disso agora.

723
00:56:11,000 --> 00:56:14,000
Este é, provavelmente, como eu teria escrito.

724
00:56:14,000 --> 00:56:21,000
Você também pode olhar-lo assim.

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

726
00:56:25,000 --> 00:56:30,000
deve ser quase tão natural para você quanto para int i = 0

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

728
00:56:33,000 --> 00:56:38,000
Se é assim que você iterar sobre uma matriz, isto é como você iterar sobre uma lista ligada.

729
00:56:38,000 --> 00:56:45,000
>> Esta deve ser uma segunda natureza em algum ponto.

730
00:56:45,000 --> 00:56:50,000
Com isso em mente, este vai ser quase a mesma coisa.

731
00:56:50,000 --> 00:56:57,000
Você vai querer iterar sobre uma lista encadeada.

732
00:56:57,000 --> 00:57:02,000
Se o nó-Eu não tenho nenhuma idéia do que o valor é chamado.

733
00:57:02,000 --> 00:57:04,000
Nó i.

734
00:57:04,000 --> 00:57:15,000
Se o valor desse nó = i retornar verdadeiro, e é isso.

735
00:57:15,000 --> 00:57:18,000
Observe que a única maneira de sempre retornar false

736
00:57:18,000 --> 00:57:23,000
é se iterar sobre a lista inteira ligada e nunca mais voltar verdade,

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

738
00:57:29,000 --> 00:57:36,000
Como uma nota lateral, provavelmente não vai começar a acrescentar 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 você ver a palavra-chave estática, então vamos dizer contagem static int = 0,

741
00:57:52,000 --> 00:57:56,000
então o que fazemos contagem + +, você pode basicamente pensar nisso como uma variável global,

742
00:57:56,000 --> 00:58:00,000
mesmo que eu disse não é assim que nós vamos implementar comprimento.

743
00:58:00,000 --> 00:58:06,000
Eu estou fazendo isso aqui, e então contar + +.

744
00:58:06,000 --> 00:58:11,000
Qualquer forma, podemos introduzir um nó em nossa lista ligada estamos incrementando nossa contagem.

745
00:58:11,000 --> 00:58:15,000
O ponto é que a palavra-chave static significa.

746
00:58:15,000 --> 00:58:20,000
Se eu tivesse int count = 0 que seria uma variável antiga regulares global.

747
00:58:20,000 --> 00:58:25,000
O que significa contagem static int é que ela é uma variável global para este arquivo.

748
00:58:25,000 --> 00:58:28,000
É impossível para algum outro arquivo,

749
00:58:28,000 --> 00:58:34,000
gosto de pensar em pset 5, se você começou.

750
00:58:34,000 --> 00:58:39,000
Você tem tanto speller.c, e você tem dictionary.c,

751
00:58:39,000 --> 00:58:42,000
e se você simplesmente declarar uma coisa global, então qualquer coisa em speller.c

752
00:58:42,000 --> 00:58:45,000
pode ser acessado no dictionary.c e vice-versa.

753
00:58:45,000 --> 00:58:48,000
As variáveis ​​globais são acessíveis por qualquer arquivo c.,

754
00:58:48,000 --> 00:58:54,000
mas variáveis ​​estáticas só são acessíveis a partir de dentro do próprio arquivo,

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

756
00:59:01,000 --> 00:59:06,000
este é o tipo de como eu iria declarar minha variável para o tamanho da minha matriz

757
00:59:06,000 --> 00:59:10,000
ou o tamanho do meu número de palavras no dicionário.

758
00:59:10,000 --> 00:59:15,000
Desde que eu não quero declarar uma variável global que qualquer um tem acesso,

759
00:59:15,000 --> 00:59:18,000
Eu realmente só se preocupam com isso para meus próprios propósitos.

760
00:59:18,000 --> 00:59:21,000
>> A coisa boa sobre isso é também o material de colisão todo nome.

761
00:59:21,000 --> 00:59:27,000
Se algum outro arquivo tenta usar uma variável global chamada contagem, as coisas vão muito, muito errado,

762
00:59:27,000 --> 00:59:33,000
de modo que este mantém as coisas bem seguro, e só você pode acessá-lo,

763
00:59:33,000 --> 00:59:38,000
e ninguém mais pode, e se alguém declara uma variável global chamada contagem,

764
00:59:38,000 --> 00:59:43,000
então ele não irá interferir com a sua variável estática chamada contagem.

765
00:59:43,000 --> 00:59:47,000
Isso é o que é estática. É uma variável de arquivo global.

766
00:59:47,000 --> 00:59:52,000
>> Perguntas sobre alguma coisa?

767
00:59:52,000 --> 00:59:59,000
Tudo pronto. Tchau.

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