1
00:00:00,000 --> 00:00:02,860
[Powered by Google Translate] [Semana 5]

2
00:00:02,860 --> 00:00:04,860
[David J. Malan - Harvard University]

3
00:00:04,860 --> 00:00:07,260
[Esta é CS50. - CS50.TV]

4
00:00:07,260 --> 00:00:09,740
>> Este é CS50 Semana, 5.

5
00:00:09,740 --> 00:00:12,900
Hoje e esta semana, apresentamos um pouco do mundo da ciência forense

6
00:00:12,900 --> 00:00:14,850
no contexto do Conjunto de Problemas 4.

7
00:00:14,850 --> 00:00:18,480
Hoje será uma palestra abreviada porque há um evento especial aqui depois.

8
00:00:18,480 --> 00:00:21,940
Então, vamos dar uma olhada e provocar estudantes e pais de hoje

9
00:00:21,940 --> 00:00:24,600
com algumas das coisas que são no horizonte.

10
00:00:24,600 --> 00:00:29,050
>> Entre eles, a partir de segunda-feira, você terá um pouco mais colegas.

11
00:00:29,050 --> 00:00:32,980
EDX, Harvard e MIT nova iniciativa online para OpenCourseWare e mais,

12
00:00:32,980 --> 00:00:36,730
está lançando no campus de Harvard, na segunda-feira, o que significa que na segunda-feira

13
00:00:36,730 --> 00:00:40,930
você terá, a partir de última contagem, 86 mil colegas adicionais

14
00:00:40,930 --> 00:00:43,680
que vai seguir juntamente com palestras CS50 e seções

15
00:00:43,680 --> 00:00:45,890
e orientações e conjuntos de problema.

16
00:00:45,890 --> 00:00:51,870
E, como parte disso, você vai se tornar membros da aula inaugural do CS50 e agora CS50x.

17
00:00:51,870 --> 00:00:56,150
Como parte deste momento, perceber que haverá algumas upsides também.

18
00:00:56,150 --> 00:01:00,620
Para se preparar para isso, para o grande número de estudantes,

19
00:01:00,620 --> 00:01:03,820
basta dizer que, embora tenhamos 108 TFs e CAs,

20
00:01:03,820 --> 00:01:07,560
não é bem a melhor relação professor-aluno, uma vez que atingiu 80.000 dos alunos.

21
00:01:07,560 --> 00:01:09,830
Nós não vamos ser problema para muitos classificação define manualmente,

22
00:01:09,830 --> 00:01:13,050
assim introduzido esta semana no conjunto de problemas será CS50 Check,

23
00:01:13,050 --> 00:01:15,410
que vai ser um utilitário de linha de comando dentro do aparelho

24
00:01:15,410 --> 00:01:17,880
que você vai ter uma vez que você atualizá-lo mais tarde neste fim de semana.

25
00:01:17,880 --> 00:01:21,030
Você vai ser capaz de executar um comando, check50, em seu próprio pset,

26
00:01:21,030 --> 00:01:24,770
e você vai ter um feedback instantâneo para saber se o seu programa é correta ou incorreta

27
00:01:24,770 --> 00:01:27,980
acordo com as especificações de design diferentes que nós fornecemos.

28
00:01:27,980 --> 00:01:30,310
Mais sobre isso na especificação do conjunto de problemas.

29
00:01:30,310 --> 00:01:34,220
Os colegas CS50x vai usar isso também.

30
00:01:34,220 --> 00:01:36,170
>> Set problema 4 é tudo sobre a ciência forense,

31
00:01:36,170 --> 00:01:38,630
e este pset estava realmente inspirado por algumas coisas na vida real

32
00:01:38,630 --> 00:01:41,210
pelo que, quando eu estava na faculdade eu internados por um tempo

33
00:01:41,210 --> 00:01:45,270
na Procuradoria do Condado de Middlesex District está fazendo o trabalho forense

34
00:01:45,270 --> 00:01:47,660
com o seu principal investigador forense.

35
00:01:47,660 --> 00:01:50,280
O que isso representou, como eu acho que eu mencionei algumas semanas passado,

36
00:01:50,280 --> 00:01:52,720
é a polícia do Estado de massa ou outros entrava,

37
00:01:52,720 --> 00:01:56,150
eles iriam deixar as coisas como discos rígidos, CDs e disquetes e similares,

38
00:01:56,150 --> 00:01:58,770
e, em seguida, o objetivo do escritório forense foi verificar

39
00:01:58,770 --> 00:02:01,470
se houve ou não era evidência de algum tipo.

40
00:02:01,470 --> 00:02:04,730
Esta foi a Unidade de Investigações Especiais, por isso era crime de colarinho branco.

41
00:02:04,730 --> 00:02:10,949
Era uma espécie mais preocupante de crimes, qualquer coisa que envolva algum tipo de mídia digital.

42
00:02:10,949 --> 00:02:16,450
Acontece que não que muitas pessoas escrevem um e-mail dizendo: "Eu fiz isso."

43
00:02:16,450 --> 00:02:20,490
Então, muitas vezes, essas pesquisas forenses não apareceu todos os frutos que muito,

44
00:02:20,490 --> 00:02:22,820
mas às vezes as pessoas escrevem e-mails desse tipo.

45
00:02:22,820 --> 00:02:25,240
Então, às vezes, os esforços foram recompensados.

46
00:02:25,240 --> 00:02:31,210
>> Mas, para levar até este pset forense, estaremos introduzindo no pset4 um pouco de gráficos.

47
00:02:31,210 --> 00:02:35,410
Você provavelmente levar estas coisas para concedido - JPEGs, GIFs e outros - estes dias.

48
00:02:35,410 --> 00:02:38,320
Mas se você realmente pensa sobre isso, uma imagem, assim como o rosto de Rob,

49
00:02:38,320 --> 00:02:41,270
pode ser modelada como uma sequência de pontos ou pixels.

50
00:02:41,270 --> 00:02:43,380
No caso da cara de Rob, existem todos os tipos de cores,

51
00:02:43,380 --> 00:02:46,760
e começamos a ver os pontos individuais, também conhecidos como pixels,

52
00:02:46,760 --> 00:02:48,610
uma vez que começou a fazer zoom in

53
00:02:48,610 --> 00:02:54,660
Mas se simplificar o mundo um pouco e dizer que isso aqui é Rob em preto e branco,

54
00:02:54,660 --> 00:02:57,490
para representar o preto e branco, podemos usar apenas binário.

55
00:02:57,490 --> 00:03:01,660
E se vamos usar binário, 1 ou 0, podemos expressar esta mesma imagem

56
00:03:01,660 --> 00:03:06,140
de rosto sorridente de Rob com esse padrão de bits.

57
00:03:06,140 --> 00:03:12,100
11000011 representa o branco, branco, preto, preto, preto, preto, branco, branco.

58
00:03:12,100 --> 00:03:16,150
E por isso não é um grande salto em seguida, começar a falar sobre fotografias coloridas,

59
00:03:16,150 --> 00:03:18,600
coisas que você veria no Facebook ou levar com uma câmera digital.

60
00:03:18,600 --> 00:03:21,410
Mas, certamente, quando se trata de cores, você precisa mais bits.

61
00:03:21,410 --> 00:03:25,690
E bastante comum no mundo das fotografias é usar uma cor não-bit,

62
00:03:25,690 --> 00:03:29,560
como isso sugere, mas cor de 24 bits, onde você realmente obter milhões de cores.

63
00:03:29,560 --> 00:03:32,250
Assim como no caso quando o zoom no olho do Rob,

64
00:03:32,250 --> 00:03:36,370
que era um número qualquer de milhões de diferentes possibilidades coloridas.

65
00:03:36,370 --> 00:03:39,040
Então, nós vamos introduzir esta no Conjunto Problema 4, bem como no passo a passo,

66
00:03:39,040 --> 00:03:43,370
que será hoje às 3:30 em vez de 2:30 o habitual por causa de palestra de sexta-feira aqui.

67
00:03:43,370 --> 00:03:46,620
Mas o vídeo estará online amanhã como de costume.

68
00:03:46,620 --> 00:03:48,820
>> Também vamos apresentá-lo para outro formato de arquivo.

69
00:03:48,820 --> 00:03:51,270
Este é deliberadamente quis olhar intimidador no início,

70
00:03:51,270 --> 00:03:55,670
mas isso é apenas uma documentação alguma para uma struct C.

71
00:03:55,670 --> 00:03:58,940
Acontece que há anos a Microsoft ajudou a popularizar este formato

72
00:03:58,940 --> 00:04:05,150
chamado o formato de arquivo bitmap, bmp, e este foi um super simples, formato de arquivo gráfico colorido

73
00:04:05,150 --> 00:04:10,150
que foi usado por algum tempo e, por vezes ainda para papéis de parede em desktops.

74
00:04:10,150 --> 00:04:14,760
Se você acha que volta para o Windows XP e as colinas eo céu azul,

75
00:04:14,760 --> 00:04:17,170
que era tipicamente uma imagem BMP ou bitmap.

76
00:04:17,170 --> 00:04:19,959
Bitmaps são divertido para nós, porque eles têm um pouco mais de complexidade.

77
00:04:19,959 --> 00:04:22,610
Não é tão simples como esta grade de 0s e 1s.

78
00:04:22,610 --> 00:04:27,510
Em vez disso, você tem coisas como um cabeçalho no início de um arquivo.

79
00:04:27,510 --> 00:04:31,990
Portanto, em outras palavras, dentro de um arquivo bmp. É um monte de 0s e 1s,

80
00:04:31,990 --> 00:04:34,910
mas há algum adicional 0s e 1s lá.

81
00:04:34,910 --> 00:04:38,220
E acontece que o que nós provavelmente já um dado adquirido há anos -

82
00:04:38,220 --> 00:04:45,170
formatos de arquivo como. doc ou. xls ou. mp3, mp4., independentemente dos formatos de arquivo

83
00:04:45,170 --> 00:04:48,480
que você está familiarizado com - o que isso significa mesmo ser um formato de arquivo,

84
00:04:48,480 --> 00:04:52,480
porque no fim do dia, todos estes ficheiros usamos têm apenas 0 e 1.

85
00:04:52,480 --> 00:04:56,810
E talvez os 0s e 1s representam ABC através ASCII ou similar,

86
00:04:56,810 --> 00:04:58,820
mas no final do dia, ainda é apenas 0s e 1s.

87
00:04:58,820 --> 00:05:02,100
Assim, os seres humanos apenas ocasionalmente decidem inventar um novo formato de arquivo

88
00:05:02,100 --> 00:05:06,420
onde padronizar o que padrões de bits vai realmente significar.

89
00:05:06,420 --> 00:05:09,220
E, neste caso aqui, o pessoal que projetou o formato de arquivo bitmap

90
00:05:09,220 --> 00:05:15,620
disse que no primeiro byte em um arquivo bitmap, como denotado por 0 compensados ​​lá,

91
00:05:15,620 --> 00:05:18,940
lá vai ser algum enigmaticamente chamado bfType variável chamada,

92
00:05:18,940 --> 00:05:23,080
que só fica para o tipo de arquivo de bitmap, que tipo de arquivo bitmap é esta.

93
00:05:23,080 --> 00:05:27,700
Você pode inferir talvez da segunda linha que compensar 2, número de bytes 2,

94
00:05:27,700 --> 00:05:33,740
tem um padrão de 0s e 1s que representa o que? O tamanho de algo.

95
00:05:33,740 --> 00:05:35,310
E vai de lá.

96
00:05:35,310 --> 00:05:37,410
Então, no Conjunto Problema 4, você vai ser orientado por algumas destas coisas.

97
00:05:37,410 --> 00:05:39,520
Nós não vai acabar se preocupar com todos eles.

98
00:05:39,520 --> 00:05:47,510
Mas note que começa a ficar interessante em torno de byte 54: rgbtBlue, Verde e Vermelho.

99
00:05:47,510 --> 00:05:52,110
Se você já ouviu a sigla RGB - vermelho, verde, azul - esta é uma referência a esse

100
00:05:52,110 --> 00:05:54,610
pois verifica-se que você pode pintar todas as cores do arco-íris

101
00:05:54,610 --> 00:05:58,180
com uma combinação de vermelho e azul e verde.

102
00:05:58,180 --> 00:06:03,320
E, de fato, os pais no quarto pode recordar alguns dos primeiros projetores.

103
00:06:03,320 --> 00:06:05,890
Estes dias, você só vê uma luz brilhante que sai de uma lente,

104
00:06:05,890 --> 00:06:09,800
mas volta no dia em que teve a lente vermelha, lente azul, ea lente verde,

105
00:06:09,800 --> 00:06:13,380
e, juntos, destinado a uma tela e formou uma imagem colorida.

106
00:06:13,380 --> 00:06:16,270
E, muitas vezes, escolas de ensino médio e escolas secundárias teria aquelas lentes

107
00:06:16,270 --> 00:06:19,720
levemente torto, para que eram uma espécie de ver imagens duplas ou triplas.

108
00:06:19,720 --> 00:06:24,100
Mas essa era a idéia. Você tinha luz vermelha, verde e azul pintar um quadro.

109
00:06:24,100 --> 00:06:26,590
E esse mesmo princípio é usado em computadores.

110
00:06:26,590 --> 00:06:30,230
>> Assim, entre os desafios, em seguida, para você em Problema Set 4 vão ser algumas coisas.

111
00:06:30,230 --> 00:06:34,800
Um deles é para redimensionar uma imagem, para tomar um padrão de 0s e 1s,

112
00:06:34,800 --> 00:06:40,200
descobrir qual pedaços de 0s e 1s representam o que em uma estrutura como esta,

113
00:06:40,200 --> 00:06:43,630
e então descobrir como replicar os pixels - os vermelhos, os azuis, os verdes -

114
00:06:43,630 --> 00:06:46,660
dentro de modo que, quando uma imagem fica assim, inicialmente,

115
00:06:46,660 --> 00:06:49,210
pode parecer que esta vez depois disso.

116
00:06:49,210 --> 00:06:53,640
Entre os outros desafios que também vai ser que você vai ser entregue uma imagem forense

117
00:06:53,640 --> 00:06:56,030
de um arquivo real de uma câmera digital.

118
00:06:56,030 --> 00:06:58,960
E nessa câmera, era uma vez, foram um monte de fotos.

119
00:06:58,960 --> 00:07:03,760
O problema é que acidentalmente apagados ou teve a imagem corrompida de algum modo.

120
00:07:03,760 --> 00:07:05,750
Coisas ruins acontecem com câmeras digitais.

121
00:07:05,750 --> 00:07:09,150
E, assim, rapidamente copiado todo o off 0s e 1s de que o cartão para você,

122
00:07:09,150 --> 00:07:13,610
salva-los todos em um arquivo grande, e depois nós vamos entregá-los a você no Conjunto de Problemas 4

123
00:07:13,610 --> 00:07:19,320
de modo que você pode escrever um programa em C com o qual se recuperar todas essas JPEGs, idealmente.

124
00:07:19,320 --> 00:07:23,330
E acontece que JPEGs, mesmo que sejam um pouco de um formato de arquivo complexo -

125
00:07:23,330 --> 00:07:26,360
eles são muito mais complexos do que este sorriso aqui -

126
00:07:26,360 --> 00:07:31,160
verifica-se que todos os JPEG inicia-se com os mesmos padrões de 0s e 1s.

127
00:07:31,160 --> 00:07:35,630
Então, usando, em última análise, um loop while ou um loop for ou similar,

128
00:07:35,630 --> 00:07:38,880
você pode iterar sobre todos os 0s e 1s nesta imagem forense,

129
00:07:38,880 --> 00:07:43,150
e cada vez que você ver o padrão especial que está definido na especificação conjunto de problemas,

130
00:07:43,150 --> 00:07:47,880
você pode assumir aqui é, com grande probabilidade, o início de um JPEG.

131
00:07:47,880 --> 00:07:51,230
E assim que você encontrar o mesmo padrão algum número de bytes

132
00:07:51,230 --> 00:07:55,430
ou kilobytes ou megabytes mais tarde, você pode assumir aqui é um JPEG segundo,

133
00:07:55,430 --> 00:07:57,380
a foto que eu tomei depois da primeira.

134
00:07:57,380 --> 00:08:01,370
Deixe-me parar de ler esse arquivo em primeiro lugar, começar a escrever este novo,

135
00:08:01,370 --> 00:08:06,310
ea saída do seu programa para pset4 vai ser cerca de 50 JPEGs.

136
00:08:06,310 --> 00:08:09,270
E se não é 50 JPEGs, você tem um pouco de um loop.

137
00:08:09,270 --> 00:08:12,490
Se você tem um número infinito de JPEGs, você tem um loop infinito.

138
00:08:12,490 --> 00:08:14,910
De modo que também será bastante caso comum.

139
00:08:14,910 --> 00:08:16,600
Então, isso é o que está no horizonte.

140
00:08:16,600 --> 00:08:21,310
>> 0 Quiz atrás de nós, perceber por meu e-mail que, invariavelmente, há pessoas que são ambos felizes,

141
00:08:21,310 --> 00:08:23,640
espécie de neutro, e triste ao redor questionário tempo 0.

142
00:08:23,640 --> 00:08:26,800
E por favor, chegar a mim, a cabeça TF Zamyla, sua própria TF,

143
00:08:26,800 --> 00:08:31,180
ou um dos CAs que você sabe, se você gostaria de discutir como as coisas correram.

144
00:08:31,180 --> 00:08:35,539
>> Então, para impressionar os pais aqui na sala, o que é a biblioteca CS50?

145
00:08:36,429 --> 00:08:40,390
[Risos] Bom trabalho.

146
00:08:40,390 --> 00:08:48,340
O que é a biblioteca CS50? Sim. >> [Aluno] É um conjunto pré-escrita de código [inaudível]

147
00:08:48,340 --> 00:08:49,750
Ok, bom.

148
00:08:49,750 --> 00:08:53,240
É um conjunto de pré-escrita de código que o pessoal escreveu, oferecemos a você,

149
00:08:53,240 --> 00:08:55,030
que oferece algumas funcionalidades comuns,

150
00:08:55,030 --> 00:08:59,020
coisas como me uma corda, me um int - todas as funções que estão listadas aqui.

151
00:08:59,020 --> 00:09:02,260
>> A partir de agora, começamos a realmente tomar essas rodinhas.

152
00:09:02,260 --> 00:09:05,050
Nós vamos começar a tirar uma série de você,

153
00:09:05,050 --> 00:09:08,870
que recordação era apenas um sinônimo para o tipo de dados real? >> [Vários alunos] Char *.

154
00:09:08,870 --> 00:09:12,730
* Char. Para os pais, que foi, provavelmente, [som faz whooshing]. Isso é bom.

155
00:09:12,730 --> 00:09:17,550
* Char vamos começar a ver na tela tudo o mais que podemos remover seqüência de nosso vocabulário,

156
00:09:17,550 --> 00:09:19,730
pelo menos quando se trata de realmente escrever código.

157
00:09:19,730 --> 00:09:22,840
Da mesma forma, nós vamos parar de usar algumas dessas funções tanto

158
00:09:22,840 --> 00:09:25,280
porque os nossos programas estão indo para obter mais sofisticado.

159
00:09:25,280 --> 00:09:28,480
Em vez de apenas escrever programas que ficam lá com um piscar prompt,

160
00:09:28,480 --> 00:09:31,870
à espera de que o usuário digite algo, você terá suas entradas a partir de outro lugar.

161
00:09:31,870 --> 00:09:35,490
Por exemplo, você vai levá-los a partir de uma série de bits no disco rígido local.

162
00:09:35,490 --> 00:09:38,580
Você vai em vez levá-los no futuro a partir de uma conexão de rede,

163
00:09:38,580 --> 00:09:40,230
algum site em algum lugar.

164
00:09:40,230 --> 00:09:44,110
>> Então, vamos descascar essa camada pela primeira vez e puxar para cima o Appliance CS50

165
00:09:44,110 --> 00:09:49,010
e este arquivo chamado cs50.h, o que você tem # incluindo por semanas,

166
00:09:49,010 --> 00:09:51,140
mas vamos ver realmente o que está dentro do presente.

167
00:09:51,140 --> 00:09:54,430
O início do arquivo em azul é apenas um monte de comentários:

168
00:09:54,430 --> 00:09:57,050
informações sobre a garantia e licenciamento.

169
00:09:57,050 --> 00:09:59,050
Esta é uma espécie de paradigma comum em software

170
00:09:59,050 --> 00:10:01,580
porque um monte de software nos dias de hoje é o que é chamado de código aberto,

171
00:10:01,580 --> 00:10:05,220
o que significa que alguém tenha escrito o código e tornou disponível gratuitamente

172
00:10:05,220 --> 00:10:10,470
não apenas para correr e para usar, mas para realmente ler e alterar e integrar no seu próprio trabalho.

173
00:10:10,470 --> 00:10:14,660
Então é isso que você está usando, o software de fonte aberta, embora de uma forma muito pequena.

174
00:10:14,660 --> 00:10:18,560
Se eu rolar para baixo após os comentários, porém, vamos começar a ver algumas coisas mais familiares.

175
00:10:18,560 --> 00:10:25,010
Aviso no topo aqui que o arquivo cs50.h inclui um conjunto de arquivos de cabeçalho.

176
00:10:25,010 --> 00:10:28,560
A maioria destes, não vimos antes, mas um é familiar.

177
00:10:28,560 --> 00:10:32,270
Qual destes temos visto, ainda que brevemente, até agora? >> [Aluno] biblioteca padrão.

178
00:10:32,270 --> 00:10:35,810
Sim, biblioteca padrão. stdlib.h tem malloc.

179
00:10:35,810 --> 00:10:38,320
Uma vez que começamos a falar sobre alocação dinâmica de memória,

180
00:10:38,320 --> 00:10:41,650
que vamos voltar para a próxima semana, assim, começamos incluindo o arquivo.

181
00:10:41,650 --> 00:10:46,640
Acontece que bool e verdadeiro e falso na verdade, não existe em C, por si só

182
00:10:46,640 --> 00:10:49,440
a menos que você inclua esse arquivo aqui.

183
00:10:49,440 --> 00:10:52,710
Temos de semana foi incluindo stdbool.h

184
00:10:52,710 --> 00:10:55,620
de modo que você pode usar a noção de um. bool, verdadeiro ou falso

185
00:10:55,620 --> 00:10:58,620
Sem isso, você teria que classificar de fingir e usar um int

186
00:10:58,620 --> 00:11:02,610
e apenas arbitrariamente assumir que 0 é falso e 1 é verdadeira.

187
00:11:02,610 --> 00:11:07,150
Se rolar mais, aqui é a nossa definição de uma cadeia.

188
00:11:07,150 --> 00:11:11,390
Acontece que, como já disse antes, que esta estrela é onde realmente não importa.

189
00:11:11,390 --> 00:11:13,720
Você pode até ter todo o espaço ao redor.

190
00:11:13,720 --> 00:11:16,740
Nós neste semestre foram promovendo-o como esta para deixar claro

191
00:11:16,740 --> 00:11:18,620
que a estrela tem a ver com o tipo,

192
00:11:18,620 --> 00:11:21,700
mas percebe tão comum, se não um pouco mais comum,

193
00:11:21,700 --> 00:11:24,430
é colocá-lo lá, mas funcionalmente é a mesma coisa.

194
00:11:24,430 --> 00:11:27,720
Mas agora, se lermos mais para baixo, vamos dar uma olhada em GetInt

195
00:11:27,720 --> 00:11:32,190
porque usamos que, talvez, antes de mais nada neste semestre.

196
00:11:32,190 --> 00:11:37,440
Aqui está GetInt. Isto é o que? >> [Aluno] Um protótipo. >> Este é apenas um protótipo.

197
00:11:37,440 --> 00:11:41,410
Muitas vezes, temos que colocar protótipos no topo de nossa. Arquivos c,

198
00:11:41,410 --> 00:11:46,690
mas você também pode colocar protótipos em arquivos de cabeçalho, arquivos. h, como esta aqui

199
00:11:46,690 --> 00:11:50,840
de modo que quando você escreve algumas funções que você quer que outras pessoas para ser capaz de usar,

200
00:11:50,840 --> 00:11:53,550
que é exatamente o caso da biblioteca CS50,

201
00:11:53,550 --> 00:11:57,040
você não só implementar suas funções em algo como cs50.c,

202
00:11:57,040 --> 00:12:02,790
você também colocar os protótipos não no topo do arquivo, mas no topo de um arquivo de cabeçalho.

203
00:12:02,790 --> 00:12:07,170
Em seguida, o arquivo de cabeçalho é o que os amigos e colegas de incluir

204
00:12:07,170 --> 00:12:09,760
com # incluir no seu próprio código.

205
00:12:09,760 --> 00:12:12,210
Então todo esse tempo, você está incluindo todos os protótipos,

206
00:12:12,210 --> 00:12:16,580
efetivamente no topo do seu arquivo, mas por meio deste mecanismo # include,

207
00:12:16,580 --> 00:12:20,070
que essencialmente copia e cola este arquivo em seu próprio.

208
00:12:20,070 --> 00:12:23,070
Aqui está alguma documentação bastante detalhada.

209
00:12:23,070 --> 00:12:25,640
Nós praticamente um dado adquirido que GetInt recebe um int,

210
00:12:25,640 --> 00:12:27,640
mas acontece que há alguns casos de canto.

211
00:12:27,640 --> 00:12:31,810
E se o usuário digita um número que é muito grande, um quintilhões,

212
00:12:31,810 --> 00:12:35,490
que simplesmente não pode caber dentro de um int? Qual é o comportamento esperado?

213
00:12:35,490 --> 00:12:38,020
Idealmente, é previsível.

214
00:12:38,020 --> 00:12:40,280
Portanto, neste caso, se você realmente ler a cópia fina,

215
00:12:40,280 --> 00:12:44,500
você realmente verá que, se a linha não pode ser lido, INT_MAX este retorno.

216
00:12:44,500 --> 00:12:48,320
Nós nunca conversamos sobre isso, mas com base na sua capitalização, o que é provavelmente?

217
00:12:48,320 --> 00:12:50,640
[Aluno] A constante. >> É uma constante.

218
00:12:50,640 --> 00:12:54,770
É uma constante especial que é, provavelmente, declarou em um desses arquivos de cabeçalho

219
00:12:54,770 --> 00:13:00,090
que é até maior no arquivo, e INT_MAX é provavelmente algo como cerca de 2 bilhões,

220
00:13:00,090 --> 00:13:04,990
A idéia é que, porque precisamos de alguma forma significar que algo deu errado,

221
00:13:04,990 --> 00:13:10,700
temos, sim, tem 4 bilhões de números à nossa disposição: -2000000000 em até 2 bilhões, mais ou menos.

222
00:13:10,700 --> 00:13:14,710
Bem, o que é comum em programação é você roubar apenas um desses números,

223
00:13:14,710 --> 00:13:18,920
talvez 0, talvez 2 bilhões, talvez -2000000000,

224
00:13:18,920 --> 00:13:23,280
assim você gasta um de seus valores possíveis de modo que você pode cometer ao mundo

225
00:13:23,280 --> 00:13:26,820
que, se algo der errado, eu vou retornar esse valor super grande.

226
00:13:26,820 --> 00:13:31,030
Mas você não quer que o usuário digitar algo enigmático como 234 ..., um número muito grande.

227
00:13:31,030 --> 00:13:34,060
Você generalizá-lo em vez como uma constante.

228
00:13:34,060 --> 00:13:38,060
Então, realmente, se você estava sendo anal nas últimas semanas, a qualquer hora que você ligou GetInt,

229
00:13:38,060 --> 00:13:42,900
você deveria ter vindo a verificar com uma condição, se fez o tipo de usuário em INT_MAX,

230
00:13:42,900 --> 00:13:46,590
ou, mais especificamente, fez GetInt INT_MAX retorno, porque se o fizesse,

231
00:13:46,590 --> 00:13:51,830
que realmente significa que eles não digitá-lo. Algo deu errado neste caso.

232
00:13:51,830 --> 00:13:56,080
Portanto, este é o que é geralmente conhecido como um valor de sentinela, o que significa apenas especial.

233
00:13:56,080 --> 00:13:58,120
>> Vamos agora voltar para o arquivo c..

234
00:13:58,120 --> 00:14:01,340
O arquivo C existiu no aparelho por algum tempo.

235
00:14:01,340 --> 00:14:06,840
E, de fato, o aparelho tem pré-compilados para você nessa coisa que chamamos de código objeto,

236
00:14:06,840 --> 00:14:09,540
mas ele simplesmente não importa para onde está porque o sistema sabe

237
00:14:09,540 --> 00:14:11,730
neste caso em que é: aparelho.

238
00:14:11,730 --> 00:14:17,400
Vamos rolar agora para getInt e ver como GetInt vem trabalhando todo esse tempo.

239
00:14:17,400 --> 00:14:19,460
Aqui temos comentários similares de antes.

240
00:14:19,460 --> 00:14:21,660
Deixe-me ampliar apenas o código porção.

241
00:14:21,660 --> 00:14:23,900
E o que temos para GetInt é o seguinte.

242
00:14:23,900 --> 00:14:25,700
Não é preciso de entrada.

243
00:14:25,700 --> 00:14:29,510
Ele retorna um int, enquanto (verdadeiro), por isso temos um loop infinito deliberada,

244
00:14:29,510 --> 00:14:33,180
mas provavelmente vamos sair dessa forma ou de voltar a partir desta.

245
00:14:33,180 --> 00:14:34,870
>> Vamos ver como isso funciona.

246
00:14:34,870 --> 00:14:39,240
Parece que estamos usando GetString nesta primeira linha dentro do loop, 166.

247
00:14:39,240 --> 00:14:43,780
Isto agora é uma boa prática, porque em que circunstâncias poderia voltar GetString

248
00:14:43,780 --> 00:14:47,660
a palavra-chave NULL especial? >> [Aluno] Se algo der errado.

249
00:14:47,660 --> 00:14:51,630
Se algo der errado. E o que poderia dar errado quando você chamar algo como GetString?

250
00:14:54,960 --> 00:14:57,640
Sim. >> [Aluno] Malloc falha em dar-lhe os ints.

251
00:14:57,640 --> 00:14:59,150
Sim. Talvez malloc falhar.

252
00:14:59,150 --> 00:15:03,190
Em algum lugar debaixo do capô, GetString está chamando malloc, que aloca memória,

253
00:15:03,190 --> 00:15:06,020
que permite que a loja de informática de todos os personagens

254
00:15:06,020 --> 00:15:07,750
que o utilizador escreve no teclado.

255
00:15:07,750 --> 00:15:11,590
E suponha que o usuário tinha um monte de tempo livre e mais digitado, por exemplo,

256
00:15:11,590 --> 00:15:16,160
de 2 bilhões de caracteres, mais personagens do que o computador ainda tem RAM.

257
00:15:16,160 --> 00:15:19,250
GetString tem de ser capaz de significar que para você.

258
00:15:19,250 --> 00:15:22,560
Mesmo que este é um super, super-canto caso incomum,

259
00:15:22,560 --> 00:15:24,340
ele tem de algum modo ser capaz de lidar com isto,

260
00:15:24,340 --> 00:15:28,750
e assim GetString, se voltou e ler sua documentação, faz em NULL retorno fato.

261
00:15:28,750 --> 00:15:34,460
Portanto, agora se GetString falhar, retornando NULL, GetInt vai falhar, retornando INT_MAX

262
00:15:34,460 --> 00:15:37,690
apenas como uma sentinela. Estes são apenas convenções humanas.

263
00:15:37,690 --> 00:15:41,450
A única maneira que você sabe que este é o caso é através da leitura da documentação.

264
00:15:41,450 --> 00:15:45,040
>> Vamos deslocar até onde o int é realmente chegado.

265
00:15:45,040 --> 00:15:51,160
Se eu rolar um pouco mais, na linha 170, temos um comentário acima destas linhas.

266
00:15:51,160 --> 00:15:55,100
Declaramos em 172 um int, n, e um char, c, e, em seguida, esta nova função,

267
00:15:55,100 --> 00:15:58,930
que alguns de vocês ter tropeçado antes, sscanf.

268
00:15:58,930 --> 00:16:00,870
Isso significa scanf string.

269
00:16:00,870 --> 00:16:05,700
Em outras palavras, dá-me uma corda e eu irá procurar por peças de informação de interesse.

270
00:16:05,700 --> 00:16:07,360
O que significa isso?

271
00:16:07,360 --> 00:16:11,800
Suponha que eu digitar, literalmente, 123 no teclado e pressione a tecla Enter.

272
00:16:11,800 --> 00:16:16,470
Qual é o tipo de dados de 123 quando retornou por GetString? >> [Aluno] String.

273
00:16:16,470 --> 00:16:18,380
É óbvio que é uma string, certo? Eu tenho um string.

274
00:16:18,380 --> 00:16:23,220
Então, é realmente 123, aspas fecha aspas, 123 com o 0 \ no final do mesmo.

275
00:16:23,220 --> 00:16:27,110
Isso não é um int. Isso não é um número. Parece um número, mas isso não é verdade.

276
00:16:27,110 --> 00:16:29,080
Então, o que GetInt tenho que fazer?

277
00:16:29,080 --> 00:16:35,750
Tem que analisar essa seqüência esquerda para a direita - 123 \ 0 - e de alguma forma converter para um inteiro real.

278
00:16:35,750 --> 00:16:37,850
Você poderia descobrir como fazer isso.

279
00:16:37,850 --> 00:16:41,450
Se você acha que volta para pset2, você provavelmente tem um pouco confortável com César

280
00:16:41,450 --> 00:16:44,820
ou Vigenère, assim você pode iterar sobre uma corda, você pode converter caracteres para ints.

281
00:16:44,820 --> 00:16:46,710
Mas que diabo, é um monte de trabalho.

282
00:16:46,710 --> 00:16:49,860
Por que não chamar uma função como sscanf que faz isso para você?

283
00:16:49,860 --> 00:16:54,230
Então sscanf espera um argumento - neste caso chamado de linha, que é uma cadeia.

284
00:16:54,230 --> 00:17:01,840
Você, então, especificar entre aspas, muito semelhante ao printf, o que você espera para ver nesta seqüência.

285
00:17:01,840 --> 00:17:09,000
E o que eu estou dizendo aqui é que eu espero ver um número decimal e talvez um personagem.

286
00:17:09,000 --> 00:17:12,000
E vamos ver por que este é o caso em apenas um momento.

287
00:17:12,000 --> 00:17:15,869
E acontece que esta notação é agora lembra de coisas que começaram a falar sobre

288
00:17:15,869 --> 00:17:17,619
pouco mais de uma semana atrás.

289
00:17:17,619 --> 00:17:21,740
O que é & n & c e fazendo por nós aqui? >> [Aluno] Endereço de n e endereço do c.

290
00:17:21,740 --> 00:17:25,400
Sim. Está me dando o endereço de n e endereço do c. Por que isso é importante?

291
00:17:25,400 --> 00:17:30,220
Você sabe que com funções em C, você sempre pode retornar um valor ou nenhum valor.

292
00:17:30,220 --> 00:17:34,530
Você pode retornar um int, uma corda, uma bóia, um char, qualquer que seja, ou você pode retornar vazio,

293
00:17:34,530 --> 00:17:38,030
mas você só pode retornar uma coisa ao máximo.

294
00:17:38,030 --> 00:17:42,760
Mas, aqui queremos sscanf para voltar me talvez um int, um número decimal,

295
00:17:42,760 --> 00:17:46,220
e também um. char, e eu vou explicar por que o char em um momento

296
00:17:46,220 --> 00:17:51,460
Você efetivamente quer sscanf para retornar duas coisas, mas isso não é possível em C.

297
00:17:51,460 --> 00:17:55,200
Você pode resolver isso passando em dois endereços

298
00:17:55,200 --> 00:17:57,370
porque assim que você entrega uma função de dois endereços,

299
00:17:57,370 --> 00:18:00,470
o que pode essa função fazer com eles? >> [Aluno] Escreva para esses endereços.

300
00:18:00,470 --> 00:18:02,010
Ele pode escrever para esses endereços.

301
00:18:02,010 --> 00:18:05,770
Você pode usar a operação de estrela e ir para lá, para cada um desses endereços.

302
00:18:05,770 --> 00:18:11,260
É uma espécie de este mecanismo de back-door, mas muito comum para alterar os valores das variáveis

303
00:18:11,260 --> 00:18:14,870
mais do que apenas um único local - neste caso, dois.

304
00:18:14,870 --> 00:18:21,340
Agora repare que eu estou verificando == 1 e depois retornando n se isso, de fato, avaliar a verdade.

305
00:18:21,340 --> 00:18:26,170
Então, o que está acontecendo? Tecnicamente, tudo o que realmente quer que aconteça em GetInt é esta.

306
00:18:26,170 --> 00:18:30,740
Queremos analisar, por assim dizer, queremos ler a seqüência - entre aspas-123 -

307
00:18:30,740 --> 00:18:34,560
e se parece que há um número lá, o que estamos dizendo sscanf fazer

308
00:18:34,560 --> 00:18:38,190
é colocar esse número - 123 - nesta variável n para mim.

309
00:18:38,190 --> 00:18:42,090
Então, por que então eu realmente tenho isso também?

310
00:18:42,090 --> 00:18:48,220
Qual é o papel de sscanf dizendo que você também pode obter um personagem aqui?

311
00:18:48,220 --> 00:18:53,470
[Resposta do aluno inaudível] >> Um ponto decimal realmente poderia funcionar.

312
00:18:53,470 --> 00:18:56,330
Vamos sustentar que pensou por um momento. O que mais?

313
00:18:56,330 --> 00:18:59,270
[Aluno] Poderia ser NULL. >> Bom pensamento. Poderia ser o caractere nulo.

314
00:18:59,270 --> 00:19:01,660
Não é verdade neste caso. Sim. >> [Aluno] ASCII.

315
00:19:01,660 --> 00:19:04,340
ASCII. Ou deixe-me generalizar ainda mais.

316
00:19:04,340 --> 00:19:06,640
O c% não é apenas para verificação de erro.

317
00:19:06,640 --> 00:19:09,300
Nós não queremos que haja um personagem após o número,

318
00:19:09,300 --> 00:19:11,870
mas o que isso me permite fazer é o seguinte.

319
00:19:11,870 --> 00:19:18,210
Acontece que sscanf, além de armazenar valores de n e c neste exemplo aqui,

320
00:19:18,210 --> 00:19:24,890
o que também não é ele retorna o número de variáveis ​​que colocar valores dentro

321
00:19:24,890 --> 00:19:30,260
Então, se você digitar apenas em 123, então apenas o% d vai corresponder,

322
00:19:30,260 --> 00:19:33,880
e só n fica armazenado com um valor como 123,

323
00:19:33,880 --> 00:19:35,640
e nada é colocado em c.

324
00:19:35,640 --> 00:19:37,620
C continua a ser um valor de lixo, por assim dizer -

325
00:19:37,620 --> 00:19:40,730
lixo, porque isso nunca foi inicializada com algum valor.

326
00:19:40,730 --> 00:19:45,520
Então, nesse caso, sscanf retorna 1 porque eu preenchido um dos ponteiros,

327
00:19:45,520 --> 00:19:50,190
caso em que grande, eu tenho um int para que eu liberar a linha para liberar a memória

328
00:19:50,190 --> 00:19:54,000
GetString que efectivamente atribuído, e então eu voltar n,

329
00:19:54,000 --> 00:19:58,500
mais se você já se perguntou onde que Repetir declaração vem, ele vem aqui.

330
00:19:58,500 --> 00:20:04,390
Assim, se, pelo contrário, eu digitar 123foo - apenas uma seqüência aleatória de algum texto -

331
00:20:04,390 --> 00:20:08,490
sscanf vai ver número, número, número, f,

332
00:20:08,490 --> 00:20:16,410
e vai colocar o 123 em n; vai colocar o f em c e depois voltar 2.

333
00:20:16,410 --> 00:20:20,640
Então nós temos, apenas usando a definição básica de comportamento sscanf, uma maneira muito simples -

334
00:20:20,640 --> 00:20:23,900
assim, complexo, à primeira vista, mas no final do dia mecanismo relativamente simples -

335
00:20:23,900 --> 00:20:28,320
de dizer que há um int e se assim for, é que a única coisa que eu encontrei?

336
00:20:28,320 --> 00:20:29,860
E o espaço em branco aqui é deliberada.

337
00:20:29,860 --> 00:20:34,000
Se você ler a documentação para sscanf, diz-lhe que, se você incluir um pedaço de espaço em branco

338
00:20:34,000 --> 00:20:38,810
, no início ou no final, sscanf também irá permitir que o utilizador, por qualquer razão,

339
00:20:38,810 --> 00:20:41,860
para bater 123 barra de espaço e que será legítimo.

340
00:20:41,860 --> 00:20:44,150
Você não vai gritar com o usuário só porque bateu a barra de espaço

341
00:20:44,150 --> 00:20:48,640
no início ou no final, que é apenas um pouco mais user-friendly.

342
00:20:48,640 --> 00:20:52,300
>> Quaisquer perguntas, então no GetInt? Sim. >> [Aluno] E se você só colocar em um char?

343
00:20:52,300 --> 00:20:54,030
Boa pergunta.

344
00:20:54,030 --> 00:20:59,890
E se você acabou de digitar em um char como f e pressione Enter sem nunca digitando 123?

345
00:20:59,890 --> 00:21:02,420
O que você acha que o comportamento desta linha de código seria então?

346
00:21:02,420 --> 00:21:04,730
[Resposta do aluno inaudível]

347
00:21:04,730 --> 00:21:08,790
Sim, então sscanf pode cobrir isso também porque, nesse caso, não vai encher n ou c.

348
00:21:08,790 --> 00:21:15,310
Vai em vez retornar 0, caso em que eu também estou pegando esse cenário

349
00:21:15,310 --> 00:21:18,750
porque o valor esperado que eu quero é 1.

350
00:21:18,750 --> 00:21:22,000
Eu só quero uma e apenas uma coisa a ser preenchido. Boa pergunta.

351
00:21:22,000 --> 00:21:24,290
>> Outros? Tudo bem.

352
00:21:24,290 --> 00:21:26,250
>> Não vamos passar por todas as funções aqui,

353
00:21:26,250 --> 00:21:29,500
mas o que parece ser, talvez, de participação remanescente é GetString

354
00:21:29,500 --> 00:21:32,790
pois verifica-se que GetFloat, GetInt, GetDouble, GetLongLong

355
00:21:32,790 --> 00:21:36,260
todos punt muito de sua funcionalidade para GetString.

356
00:21:36,260 --> 00:21:39,750
Então, vamos dar uma olhada em como ele é implementado aqui.

357
00:21:39,750 --> 00:21:43,630
Este parece um pouco complexo, mas usa os mesmos fundamentos

358
00:21:43,630 --> 00:21:45,670
que começamos a falar sobre a semana passada.

359
00:21:45,670 --> 00:21:49,490
Em GetString, que leva nenhum argumento conforme o vazio aqui

360
00:21:49,490 --> 00:21:53,730
e ele retorna um string, eu aparentemente estou declarando uma string chamada buffer.

361
00:21:53,730 --> 00:21:56,270
Eu realmente não sei o que vai ser usado para ainda, mas vamos ver.

362
00:21:56,270 --> 00:21:58,390
Parece que a capacidade é, por padrão 0.

363
00:21:58,390 --> 00:22:01,350
Não é bem certo onde isso vai dar, não sei o que n vai ser utilizado para, no entanto,

364
00:22:01,350 --> 00:22:03,590
mas agora está ficando um pouco mais interessante.

365
00:22:03,590 --> 00:22:06,520
Na linha 243, declaramos um int, c.

366
00:22:06,520 --> 00:22:08,800
Esta é uma espécie de um detalhe estúpido.

367
00:22:08,800 --> 00:22:15,820
Um char é de 8 bits, e 8 bits pode armazenar quantos valores diferentes? >> [Aluno] 256. >> 256.

368
00:22:15,820 --> 00:22:20,730
O problema é se você quer ter 256 diferentes caracteres ASCII, que há

369
00:22:20,730 --> 00:22:23,340
se você acha que volta - e isso não é algo para memorizar.

370
00:22:23,340 --> 00:22:25,710
Mas se você acha que volta para esse gráfico grande ASCII tivemos semanas atrás,

371
00:22:25,710 --> 00:22:30,600
foram, neste caso 128 ou 256 caracteres ASCII.

372
00:22:30,600 --> 00:22:32,940
Nós usamos todos os padrões de até 0s e 1s.

373
00:22:32,940 --> 00:22:36,210
Isso é um problema se você quiser ser capaz de detectar um erro

374
00:22:36,210 --> 00:22:40,190
porque se você já está usando 256 valores para seus personagens,

375
00:22:40,190 --> 00:22:43,050
você realmente não planejar com antecedência, porque agora você não tem nenhuma maneira de dizer,

376
00:22:43,050 --> 00:22:46,270
este não é um personagem legal, isto é alguma mensagem errada.

377
00:22:46,270 --> 00:22:50,270
Então, o que o mundo faz é que eles usam o maior valor próximo, algo como um int,

378
00:22:50,270 --> 00:22:54,720
para que você tenha um número louco de bits, 32, para 4 mil milhões de valores possíveis

379
00:22:54,720 --> 00:22:58,860
de modo que você pode simplesmente acabar usando, essencialmente, 257 deles,

380
00:22:58,860 --> 00:23:01,720
Um dos quais tem algum significado especial como um erro.

381
00:23:01,720 --> 00:23:03,120
>> Então vamos ver como isso funciona.

382
00:23:03,120 --> 00:23:07,760
Na linha 246, eu tenho essa grande loop while que está chamando fgetc,

383
00:23:07,760 --> 00:23:11,090
f arquivo significado, de modo getc, e depois stdin.

384
00:23:11,090 --> 00:23:15,520
Acontece que esta é apenas a maneira mais precisa de dizer ler a entrada do teclado.

385
00:23:15,520 --> 00:23:19,300
Teclado meio padrão de entrada, saída padrão significa tela,

386
00:23:19,300 --> 00:23:23,310
e erro padrão, o que veremos na pset4, significa que o ecrã

387
00:23:23,310 --> 00:23:27,490
mas uma parte especial da tela de modo que não é confundida com saída real

388
00:23:27,490 --> 00:23:30,750
que você pretende imprimir. Mas mais sobre isso no futuro.

389
00:23:30,750 --> 00:23:34,440
Então fgetc significa apenas ler um caracter do teclado e armazená-lo onde?

390
00:23:34,440 --> 00:23:37,350
Guarde-o em c.

391
00:23:37,350 --> 00:23:41,360
E em seguida, verificar - por isso estou usando apenas algumas conjunções booleanos aqui -

392
00:23:41,360 --> 00:23:46,000
verifique se não é igual - \ n, de modo que o usuário aperte Enter, nós queremos parar nesse ponto,

393
00:23:46,000 --> 00:23:49,850
fim do ciclo - e nós também queremos verificar a EOF constante especial,

394
00:23:49,850 --> 00:23:53,610
que se você saber ou adivinhar, o que isso significa? >> [Aluno] Fim do arquivo. Fim >> de arquivo.

395
00:23:53,610 --> 00:23:56,560
Este é o tipo de absurdo, porque se eu estou digitando no teclado,

396
00:23:56,560 --> 00:23:58,870
não há realmente nenhum arquivo envolvido nisso,

397
00:23:58,870 --> 00:24:01,150
mas isso é apenas uma espécie de o termo genérico utilizado para significar

398
00:24:01,150 --> 00:24:04,220
que nada mais é que vem dedos dos humanos.

399
00:24:04,220 --> 00:24:06,460
EOF - final do arquivo.

400
00:24:06,460 --> 00:24:09,920
Como um aparte, se você já atingiu Control D em seu teclado não, que você teria ainda -

401
00:24:09,920 --> 00:24:15,230
você bateu Controle C - Control D envia esta constante especial chamado EOF.

402
00:24:15,230 --> 00:24:19,850
Portanto, agora só temos alguns alocação dinâmica de memória.

403
00:24:19,850 --> 00:24:23,440
>> Assim, se (n + 1 Capacidade>). Agora eu vou explicar n.

404
00:24:23,440 --> 00:24:26,100
N é apenas quantos bytes estão atualmente no buffer,

405
00:24:26,100 --> 00:24:28,620
a seqüência que você está actualmente a construir-se a partir do usuário.

406
00:24:28,620 --> 00:24:33,450
Se você tem mais caracteres em seu buffer do que você tem capacidade de buffer,

407
00:24:33,450 --> 00:24:37,410
intuitivamente o que temos de fazer, então, é alocar mais capacidade.

408
00:24:37,410 --> 00:24:43,330
Então eu vou para pular um pouco da aritmética aqui e focar apenas esta função aqui.

409
00:24:43,330 --> 00:24:46,070
Sabe o que malloc é ou são, pelo menos geralmente familiar.

410
00:24:46,070 --> 00:24:48,970
Adivinha o que realloc faz. >> [Aluno] Adiciona memória.

411
00:24:48,970 --> 00:24:52,920
Não é bem a adição de memória. É realoca memória como segue.

412
00:24:52,920 --> 00:24:57,220
Se ainda há espaço no final da cadeia para dar-lhe mais do que a memória

413
00:24:57,220 --> 00:25:00,000
do que originalmente lhe dá, então você vai ter que memória adicional.

414
00:25:00,000 --> 00:25:03,460
Então você pode apenas continuar colocando personagens da corda de costas para trás, para trás.

415
00:25:03,460 --> 00:25:05,830
Mas se esse não é o caso, porque você esperou muito tempo

416
00:25:05,830 --> 00:25:07,940
e foi algo aleatório jogou na memória não

417
00:25:07,940 --> 00:25:10,290
mas não há memória extra aqui, tudo bem.

418
00:25:10,290 --> 00:25:13,100
Realloc vai fazer todo o trabalho pesado para você,

419
00:25:13,100 --> 00:25:16,750
mover a seqüência que você já leu em assim muito longe daqui, colocá-lo lá em baixo,

420
00:25:16,750 --> 00:25:19,460
e depois dar-lhe um pouco mais de pista naquele ponto.

421
00:25:19,460 --> 00:25:22,550
>> Assim, com um aceno de mão, deixe-me dizer que o que está fazendo GetString

422
00:25:22,550 --> 00:25:26,330
é que está começando com um buffer pequeno, talvez um caráter único,

423
00:25:26,330 --> 00:25:30,820
e se o usuário digita em dois personagens, GetString acaba chamando realloc e diz

424
00:25:30,820 --> 00:25:33,150
um personagem não foi o suficiente, dá-me dois personagens.

425
00:25:33,150 --> 00:25:35,950
Então, se você ler a lógica do circuito, que vai dizer

426
00:25:35,950 --> 00:25:39,600
o usuário digitou 3 caracteres, dá-me agora não dois, mas quatro personagens,

427
00:25:39,600 --> 00:25:42,320
então me dê 8, em seguida, dar-me 16 e 32.

428
00:25:42,320 --> 00:25:45,000
O fato de que eu estou dobrando a capacidade de cada vez

429
00:25:45,000 --> 00:25:48,570
significa que o buffer não vai crescer lentamente, ele vai crescer super rápido.

430
00:25:48,570 --> 00:25:51,380
E o que poderia ser a vantagem disso?

431
00:25:51,380 --> 00:25:54,600
Por que eu estou dobrando o tamanho do buffer

432
00:25:54,600 --> 00:25:58,020
mesmo que o usuário só precisa um personagem extra a partir do teclado?

433
00:25:58,020 --> 00:26:01,750
[Resposta do aluno inaudível] >> O que é isso? >> [Aluno] Você não tem que crescer sempre.

434
00:26:01,750 --> 00:26:03,300
Exatamente. Você não tem que crescer sempre.

435
00:26:03,300 --> 00:26:05,510
E este é apenas um tipo de cobertura você está aqui as suas apostas,

436
00:26:05,510 --> 00:26:10,850
A idéia é que você não quer chamar realloc muito, porque ele tende a ser lenta.

437
00:26:10,850 --> 00:26:12,910
Toda vez que você perguntar o sistema operacional para a memória,

438
00:26:12,910 --> 00:26:16,990
como você vai ver em breve em um conjunto de problema futuro, tende a levar algum tempo.

439
00:26:16,990 --> 00:26:20,010
Assim, minimizando a quantidade de tempo, mesmo se você está perdendo um pouco de espaço,

440
00:26:20,010 --> 00:26:21,900
tende a ser uma coisa boa.

441
00:26:21,900 --> 00:26:24,060
>> Mas se lermos a parte final da GetString aqui -

442
00:26:24,060 --> 00:26:27,950
e, novamente, a compreensão cada linha, aqui, não é tão importante hoje -

443
00:26:27,950 --> 00:26:30,530
notar que, eventualmente, chama malloc novamente

444
00:26:30,530 --> 00:26:33,880
e aloca exatamente como muitos bytes como ele precisa para a cadeia

445
00:26:33,880 --> 00:26:38,060
e depois joga fora chamando o tampão livre excessivamente grande

446
00:26:38,060 --> 00:26:40,080
se realmente foi dobrado muitas vezes.

447
00:26:40,080 --> 00:26:42,730
Então, em suma, é assim que GetString vem trabalhando todo esse tempo.

448
00:26:42,730 --> 00:26:47,060
Tudo que faz é ler um personagem em um momento novo e de novo e de novo,

449
00:26:47,060 --> 00:26:50,750
e cada vez que precisa de um pouco de memória adicional, ele pede ao sistema operacional para ele

450
00:26:50,750 --> 00:26:53,670
chamando realloc.

451
00:26:53,670 --> 00:26:57,890
>> Alguma pergunta? Tudo bem.

452
00:26:57,890 --> 00:26:59,270
>> Um ataque.

453
00:26:59,270 --> 00:27:04,060
Agora que entendemos ponteiros ou pelo menos estão cada vez mais familiarizados com ponteiros,

454
00:27:04,060 --> 00:27:06,700
vamos considerar como o mundo inteiro começa a entrar em colapso

455
00:27:06,700 --> 00:27:10,030
se você não consegue se defender contra os usuários contraditório,

456
00:27:10,030 --> 00:27:11,850
pessoas que estão tentando invadir seu sistema,

457
00:27:11,850 --> 00:27:16,890
pessoas que estão tentando roubar o seu software, contornando alguns código de registro

458
00:27:16,890 --> 00:27:19,090
que eles poderiam ter que digitar dentro

459
00:27:19,090 --> 00:27:22,990
>> Dê uma olhada neste exemplo aqui, que é apenas o código C, que tem uma função principal na parte inferior

460
00:27:22,990 --> 00:27:26,380
que chama uma função foo. E o que é passar para foo?

461
00:27:26,380 --> 00:27:29,680
[Aluno] um único argumento. >> [Malan] Um argumento único.

462
00:27:29,680 --> 00:27:33,450
Então, argv [1], o que significa que a primeira palavra que o usuário digitou na linha de comando

463
00:27:33,450 --> 00:27:36,360
após a.out ou o que quer que o programa é chamado.

464
00:27:36,360 --> 00:27:41,680
Então foo no topo leva em um char *. Mas char * é exatamente o que? >> [Aluno] Uma seqüência.

465
00:27:41,680 --> 00:27:43,350
[Malan] Um fio, então não há nada de novo aqui.

466
00:27:43,350 --> 00:27:45,420
Essa seqüência é arbitrariamente sendo chamado de bar.

467
00:27:45,420 --> 00:27:51,430
Nesta linha aqui, char c [12], em uma espécie de semi-técnico Inglês, o que é essa linha está fazendo?

468
00:27:51,430 --> 00:27:55,220
[Estudante] Uma matriz de - Array >> de? >> [Aluno] Personagens. Personagens. >>

469
00:27:55,220 --> 00:27:58,870
Dê-me um conjunto de 12 caracteres. Assim, poderíamos chamar isso de um buffer.

470
00:27:58,870 --> 00:28:02,920
É tecnicamente chamado de c, mas um tampão na programação significa apenas um monte de espaço

471
00:28:02,920 --> 00:28:04,800
que você pode colocar algumas coisas dentro

472
00:28:04,800 --> 00:28:07,940
Então, por fim, memcpy que não usei antes, mas você provavelmente pode adivinhar o que ele faz.

473
00:28:07,940 --> 00:28:10,480
Ele copia memória. O que ele faz?

474
00:28:10,480 --> 00:28:19,270
Aparentemente, copia bar, a sua entrada, em c, mas apenas até o comprimento da barra.

475
00:28:19,270 --> 00:28:24,930
Mas há um bug aqui. >> [Aluno] Você precisa do caráter sizeof. Ok >>.

476
00:28:24,930 --> 00:28:30,860
Tecnicamente, devemos realmente fazer strlen (bar) * sizeof (char)). Isso é correto.

477
00:28:30,860 --> 00:28:33,930
Mas, no pior caso aqui, vamos supor que isso é -

478
00:28:33,930 --> 00:28:35,950
Okay. Depois, há dois erros.

479
00:28:35,950 --> 00:28:39,160
Então, sizeof (char));

480
00:28:39,160 --> 00:28:41,290
Vamos fazer isso um pouco mais.

481
00:28:41,290 --> 00:28:44,910
Então, agora ainda há um bug, que é o que? >> [Resposta do aluno inaudível]

482
00:28:44,910 --> 00:28:46,990
Verifique se o quê? >> [Aluno] Verificar NULL.

483
00:28:46,990 --> 00:28:50,270
Nós geralmente deve ser a verificação de NULL porque as coisas ruins acontecem

484
00:28:50,270 --> 00:28:53,200
quando o ponteiro é NULL porque você pode acabar indo lá,

485
00:28:53,200 --> 00:28:57,630
e você não deve nunca estar indo para NULL por dereferencing com o operador estrela.

486
00:28:57,630 --> 00:29:01,050
Então, isso é bom. E o que mais estamos fazendo? Logicamente, há uma falha aqui também.

487
00:29:01,050 --> 00:29:04,450
[Aluno] Verifique se argc é> = a 2.

488
00:29:04,450 --> 00:29:10,550
Portanto, verifique se argc é> = 2. Ok, então há três bugs neste programa.

489
00:29:10,550 --> 00:29:16,630
Estamos verificando se o usuário realmente digitou alguma coisa em argv [1]. Bom.

490
00:29:16,630 --> 00:29:20,950
Então, qual é o bug terceiro? Sim. >> [Aluno] C pode não ser grande o suficiente.

491
00:29:20,950 --> 00:29:23,320
Bom. Nós verificado um cenário.

492
00:29:23,320 --> 00:29:29,520
Nós implicitamente verificado não copiar mais memória do que exceder o comprimento da barra.

493
00:29:29,520 --> 00:29:32,510
Então, se a string que o usuário digitou é de 10 caracteres,

494
00:29:32,510 --> 00:29:36,020
isto está dizendo apenas copiar 10 caracteres. E está tudo bem.

495
00:29:36,020 --> 00:29:39,940
Mas e se o usuário digitou uma palavra no prompt como uma palavra de 20 caracteres?

496
00:29:39,940 --> 00:29:44,900
Isto está dizendo cópia 20 caracteres de bar em que?

497
00:29:44,900 --> 00:29:49,750
C, também conhecida como o nosso buffer, o que significa que você acabou de escrever dados

498
00:29:49,750 --> 00:29:52,540
a 8 locais de bytes que você não possui,

499
00:29:52,540 --> 00:29:54,870
e você não possuí-los no sentido de que você nunca alocados eles.

500
00:29:54,870 --> 00:30:00,370
Portanto, este é o que é geralmente conhecido como o ataque de buffer overflow ou ataque estouro de buffer.

501
00:30:00,370 --> 00:30:05,580
E é um ataque no sentido de que se o usuário ou o programa que está chamando a sua função

502
00:30:05,580 --> 00:30:10,490
está fazendo isso de forma maliciosa, o que realmente acontece próximo pode ser realmente muito ruim.

503
00:30:10,490 --> 00:30:12,450
>> Então, vamos dar uma olhada nesta foto aqui.

504
00:30:12,450 --> 00:30:16,060
Esta imagem representa sua pilha de memória.

505
00:30:16,060 --> 00:30:19,580
Lembre-se que cada vez que você chamar uma função que você começa este quadro pouco sobre a pilha

506
00:30:19,580 --> 00:30:21,520
e depois outro e depois outro e outro.

507
00:30:21,520 --> 00:30:24,300
E, até agora, temos apenas um tipo de abstraídas estes como retângulos

508
00:30:24,300 --> 00:30:26,290
ou no conselho ou na tela aqui.

509
00:30:26,290 --> 00:30:30,580
Mas, se aumentar o zoom em um desses retângulos, quando você chamar uma função foo,

510
00:30:30,580 --> 00:30:35,880
verifica-se que há mais no interior da pilha de que o quadro em que retângulo

511
00:30:35,880 --> 00:30:40,060
que apenas x e y e a e b, como fizemos falando sobre swap.

512
00:30:40,060 --> 00:30:44,410
Acontece que há alguns detalhes de nível inferior, entre eles, endereço de retorno.

513
00:30:44,410 --> 00:30:49,550
Assim, verifica-se quando principal chama foo, principal tem de informar foo

514
00:30:49,550 --> 00:30:53,520
o endereço principal está na memória do computador

515
00:30:53,520 --> 00:30:57,770
porque de outro modo, assim que foo é feito de execução, tal como neste caso aqui,

516
00:30:57,770 --> 00:31:00,830
uma vez que você chegar a esta cinta fechado encaracolado no final de foo,

517
00:31:00,830 --> 00:31:05,310
como o diabo não foo sabe onde o controle do programa deve ir?

518
00:31:05,310 --> 00:31:08,970
Acontece que a resposta a essa pergunta é neste retângulo vermelho aqui.

519
00:31:08,970 --> 00:31:12,670
Isso representa um ponteiro, e cabe ao computador para armazenar temporariamente

520
00:31:12,670 --> 00:31:17,030
sobre a pilha de chamada o endereço da página, de modo que, logo que é feito foo execução,

521
00:31:17,030 --> 00:31:21,120
o computador sabe onde e qual linha principal para voltar.

522
00:31:21,120 --> 00:31:23,940
Quadro ponteiro salvo se relaciona de forma semelhante a esta.

523
00:31:23,940 --> 00:31:26,310
Char bar * aqui representa o que?

524
00:31:26,310 --> 00:31:31,350
Agora este segmento azul aqui é frame foo. O que é o bar?

525
00:31:31,570 --> 00:31:35,010
Bar é apenas o argumento para a função foo.

526
00:31:35,010 --> 00:31:37,500
Portanto, agora estamos de volta ao tipo de quadro familiar.

527
00:31:37,500 --> 00:31:39,850
Há mais coisas e mais distrações na tela,

528
00:31:39,850 --> 00:31:43,380
mas esse segmento de luz azul é apenas o que estamos desenhando no quadro-negro

529
00:31:43,380 --> 00:31:45,790
para algo como swap. Esse é o quadro para foo.

530
00:31:45,790 --> 00:31:51,490
E a única coisa em que agora é o bar, que é este parâmetro.

531
00:31:51,490 --> 00:31:55,220
Mas o que mais deve estar na pilha de acordo com este código aqui?

532
00:31:55,220 --> 00:31:57,760
[Aluno] char c [12]. >> [Malan] char c [12].

533
00:31:57,760 --> 00:32:02,810
Nós também deve ver 12 quadrados de memória alocada para uma variável chamada c,

534
00:32:02,810 --> 00:32:04,970
e de fato temos que na tela.

535
00:32:04,970 --> 00:32:08,480
O topo há c [0], e em seguida o autor deste diagrama

536
00:32:08,480 --> 00:32:11,850
não se incomodou desenhando todas as praças, mas há de fato há 12

537
00:32:11,850 --> 00:32:16,590
porque se você olhar no canto inferior direito, c [11], se você contar de 0 é o byte 12 tal.

538
00:32:16,590 --> 00:32:18,400
Mas aqui está o problema.

539
00:32:18,400 --> 00:32:22,390
Em que direção está crescendo c?

540
00:32:22,390 --> 00:32:27,080
Tipo de cima para baixo se ele começa no topo e cresce para baixo.

541
00:32:27,080 --> 00:32:30,110
Ele não se parece com nós mesmos deixamos pista muito aqui.

542
00:32:30,110 --> 00:32:32,090
Nós tipo de pintado nos em um canto,

543
00:32:32,090 --> 00:32:36,940
e que c [11] é até contra bar, que fica à direita contra o ponteiro de Moldura Salvo,

544
00:32:36,940 --> 00:32:39,960
que é até contra endereço de retorno. Não há mais espaço.

545
00:32:39,960 --> 00:32:42,810
Então, qual é a implicação então se você estragar

546
00:32:42,810 --> 00:32:46,500
e você tenta ler 20 bytes em um buffer de 12 bytes?

547
00:32:46,500 --> 00:32:50,060
Onde estão os 8 bytes adicionais indo? >> [Aluno] Inside -

548
00:32:50,060 --> 00:32:53,200
Dentro de tudo o resto, alguns dos quais é super importante.

549
00:32:53,200 --> 00:32:57,260
E a coisa mais importante, potencialmente, é a caixa vermelha lá, endereço de retorno,

550
00:32:57,260 --> 00:33:03,560
porque suponha que você acidentalmente ou adversarially substituir esses 4 bytes,

551
00:33:03,560 --> 00:33:07,260
que endereço de ponteiro, não apenas com o lixo, mas com um número

552
00:33:07,260 --> 00:33:09,810
que acontece para representar um endereço real na memória.

553
00:33:09,810 --> 00:33:13,880
Qual é a implicação, logicamente? >> [Aluno] Função vai voltar para um lugar diferente.

554
00:33:13,880 --> 00:33:15,250
Exatamente.

555
00:33:15,250 --> 00:33:19,170
Quando retorna foo e hits que chaveta, o programa vai continuar

556
00:33:19,170 --> 00:33:25,060
não voltar para a principal, que vai voltar a qualquer endereço em que é caixa vermelha.

557
00:33:25,060 --> 00:33:28,600
>> No caso de registro de software contornar,

558
00:33:28,600 --> 00:33:32,260
e se o endereço que está sendo devolvido a é a função que normalmente é chamado

559
00:33:32,260 --> 00:33:35,690
depois que você pagou para o software e inserido o seu código de registro?

560
00:33:35,690 --> 00:33:39,870
Você pode classificar de enganar o computador em não ir aqui, mas em vez de ir até aqui.

561
00:33:39,870 --> 00:33:45,100
Ou se você é realmente inteligente, um adversário pode realmente digitar no teclado, por exemplo,

562
00:33:45,100 --> 00:33:50,690
não uma palavra real, não 20 personagens, mas suponho que ele ou ela realmente tipos em

563
00:33:50,690 --> 00:33:52,770
alguns personagens que representam o código.

564
00:33:52,770 --> 00:33:55,320
E não vai ser de código C, que vai de fato ser os personagens

565
00:33:55,320 --> 00:33:59,290
que representam o código de máquina binária, 0s e 1s.

566
00:33:59,290 --> 00:34:01,290
Mas suponha que eles são espertos o suficiente para fazer isso,

567
00:34:01,290 --> 00:34:06,500
de alguma forma, colar no prompt de GetString algo que é essencialmente código compilado,

568
00:34:06,500 --> 00:34:09,980
e os últimos 4 bytes substituir esse endereço de retorno.

569
00:34:09,980 --> 00:34:13,360
E o endereço é que a entrada de fazer?

570
00:34:13,360 --> 00:34:18,630
É realmente armazena neste retângulo vermelho o endereço do primeiro byte do buffer.

571
00:34:18,630 --> 00:34:23,070
Então você tem que ser realmente inteligente, e isso é um monte de tentativa e erro para pessoas ruins lá fora,

572
00:34:23,070 --> 00:34:25,639
mas se você pode descobrir o quão grande é este buffer

573
00:34:25,639 --> 00:34:28,820
de tal forma que os bytes últimos na entrada que você fornecer para o programa

574
00:34:28,820 --> 00:34:33,540
acontecer de ser equivalente ao endereço do início de sua reserva, você pode fazer isso.

575
00:34:33,540 --> 00:34:39,320
Se dizemos normalmente Olá e \ 0, que é o que acaba no buffer.

576
00:34:39,320 --> 00:34:44,420
Mas se nós somos mais espertos e preenchemos o buffer com o que vamos chamar genericamente código de ataque -

577
00:34:44,420 --> 00:34:48,860
AAA, ataque, ataque, ataque - onde isso é apenas algo que faz algo ruim,

578
00:34:48,860 --> 00:34:51,820
o que acontece se você é realmente inteligente, você pode fazer isso.

579
00:34:51,820 --> 00:34:58,610
Na caixa vermelha aqui é uma seqüência de números - 80, C0, 35, 08.

580
00:34:58,610 --> 00:35:01,610
Note que que coincide com o número que está aqui em cima.

581
00:35:01,610 --> 00:35:04,430
É na ordem inversa, mas mais sobre isso em outro momento.

582
00:35:04,430 --> 00:35:08,140
Note que este endereço de retorno foi deliberadamente alterado

583
00:35:08,140 --> 00:35:12,020
para igualar o endereço aqui, não o endereço do principal.

584
00:35:12,020 --> 00:35:17,500
Então, se o cara mau é super inteligente, ele ou ela vai incluir nesse código de ataque

585
00:35:17,500 --> 00:35:20,930
algo como apagar todos os arquivos do usuário ou copiar as senhas

586
00:35:20,930 --> 00:35:24,680
ou criar uma conta de usuário que eu possa então fazer login para - nada.

587
00:35:24,680 --> 00:35:26,950
>> E isso é tanto o perigo e o poder de C.

588
00:35:26,950 --> 00:35:29,840
Porque você tem acesso a memória através de ponteiros

589
00:35:29,840 --> 00:35:32,520
e, portanto, você pode escrever o que quiser na memória de um computador,

590
00:35:32,520 --> 00:35:35,080
você pode fazer um computador fazer o que quiser

591
00:35:35,080 --> 00:35:39,550
simplesmente por ter que pular dentro do seu próprio espaço de memória.

592
00:35:39,550 --> 00:35:44,650
E assim até hoje tantos programas e tantos sites que estão comprometidas

593
00:35:44,650 --> 00:35:46,200
resumem-se a pessoas que tomam vantagem disso.

594
00:35:46,200 --> 00:35:50,760
E isso pode parecer um super ataque sofisticado, mas nem sempre é iniciado assim.

595
00:35:50,760 --> 00:35:53,560
A realidade é que o que as pessoas ruins normalmente fazer é,

596
00:35:53,560 --> 00:35:58,200
se é um programa em uma linha de comando ou um programa gráfico ou um site,

597
00:35:58,200 --> 00:35:59,940
você acabou de começar a fornecer um absurdo.

598
00:35:59,940 --> 00:36:03,980
Você digita uma palavra muito grande no campo de pesquisa e tecle Enter

599
00:36:03,980 --> 00:36:05,780
e esperar para ver se o site trava

600
00:36:05,780 --> 00:36:09,990
ou você esperar para ver se o programa se manifesta alguma mensagem de erro

601
00:36:09,990 --> 00:36:14,330
porque se você tiver sorte como o cara mau e você fornecer algumas informações louco

602
00:36:14,330 --> 00:36:18,980
que trava o programa, isso significa que o programador não antecipou seu mau comportamento,

603
00:36:18,980 --> 00:36:23,630
o que significa que você pode provavelmente com bastante esforço, estudo bastante e erro,

604
00:36:23,630 --> 00:36:26,650
descobrir como travar um ataque mais preciso.

605
00:36:26,650 --> 00:36:31,410
Assim como uma grande parte de segurança não é apenas evitar estes ataques completamente

606
00:36:31,410 --> 00:36:34,100
mas detectá-los e realmente olhar para os logs

607
00:36:34,100 --> 00:36:36,780
e ver o que as pessoas loucas entradas digitadas em seu site,

608
00:36:36,780 --> 00:36:38,960
o que termos de pesquisa digitados pessoas em seu site

609
00:36:38,960 --> 00:36:42,870
na esperança de transbordar alguns buffer.

610
00:36:42,870 --> 00:36:45,500
E isso tudo se resume a os princípios simples do que é uma matriz

611
00:36:45,500 --> 00:36:49,080
eo que isso significa para alocar e usar a memória.

612
00:36:49,080 --> 00:36:51,710
>> Relacionado com isso, então também é este.

613
00:36:51,710 --> 00:36:54,280
Vamos apenas olhar para dentro de um disco rígido novamente.

614
00:36:54,280 --> 00:36:58,440
Você se lembra de uma ou duas semanas atrás que quando você arrastar os arquivos para a lixeira ou lata de lixo,

615
00:36:58,440 --> 00:37:03,710
o que acontece? >> [Aluno] Nada. >> Absolutamente nada, certo?

616
00:37:03,710 --> 00:37:05,740
Eventualmente, se você executar pouco espaço em disco,

617
00:37:05,740 --> 00:37:08,190
Windows ou Mac OS vai começar a apagar arquivos para você.

618
00:37:08,190 --> 00:37:10,390
Mas se você arrastar alguma coisa lá dentro, que não é de todo segura.

619
00:37:10,390 --> 00:37:13,800
Todo o seu companheiro de quarto ou amigo ou membro da família tem a fazer é clicar duas vezes e, voilà,

620
00:37:13,800 --> 00:37:16,310
há todos os arquivos esboçado que você tentou excluir.

621
00:37:16,310 --> 00:37:19,590
A maioria de nós, pelo menos, saber que você tem com o botão direito ou clique

622
00:37:19,590 --> 00:37:22,310
e lixo o vazio ou algo assim.

623
00:37:22,310 --> 00:37:25,000
Mas, mesmo assim, que não chega a fazer o truque

624
00:37:25,000 --> 00:37:28,010
porque o que acontece quando você tem um arquivo em seu disco rígido

625
00:37:28,010 --> 00:37:32,770
que representa algum documento do Word ou algum JPEG, e isso representa o seu disco rígido,

626
00:37:32,770 --> 00:37:35,350
e digamos que esta faixa aqui representa o arquivo,

627
00:37:35,350 --> 00:37:38,390
e é composto de um monte de 0s e 1s.

628
00:37:38,390 --> 00:37:42,470
O que acontece quando você não só arrastar o arquivo para a lixeira ou lixeira

629
00:37:42,470 --> 00:37:48,020
mas também esvaziá-la? Espécie de nada.

630
00:37:48,020 --> 00:37:49,640
Não há absolutamente nada agora.

631
00:37:49,640 --> 00:37:54,290
Agora é só nada porque alguma coisa acontece na forma de tabela.

632
00:37:54,290 --> 00:37:58,370
Portanto, há uma espécie de banco de dados ou tabela dentro da memória de um computador

633
00:37:58,370 --> 00:38:03,850
que, essencialmente, tem uma coluna para arquivos dos nomes e uma coluna para arquivos 'localização,

634
00:38:03,850 --> 00:38:07,720
onde isso pode ser local de 123, apenas um número aleatório.

635
00:38:07,720 --> 00:38:14,560
Assim, poderíamos ter algo como x.jpeg e localização 123.

636
00:38:14,560 --> 00:38:18,800
O que acontece então quando você realmente esvaziar seu lixo?

637
00:38:18,800 --> 00:38:20,330
Que vai embora.

638
00:38:20,330 --> 00:38:23,610
Mas o que não vai embora é a 0s e 1s.

639
00:38:23,610 --> 00:38:26,270
>> Então, qual é então a conexão com pset4?

640
00:38:26,270 --> 00:38:31,240
Bem, com pset4, só porque temos acidentalmente apagados do cartão de memória flash compacto

641
00:38:31,240 --> 00:38:35,750
que tinha todas essas fotos ou apenas porque pela má sorte se corrompeu

642
00:38:35,750 --> 00:38:38,000
não significa que os 0s e 1s não ainda estão lá.

643
00:38:38,000 --> 00:38:40,410
Talvez alguns deles são perdidos porque algo foi corrompido

644
00:38:40,410 --> 00:38:43,320
no sentido de que alguns tornaram-se 0s e 1s 1s tornou 0s.

645
00:38:43,320 --> 00:38:47,240
Coisas ruins podem acontecer por causa do software de buggy ou hardware defeituoso.

646
00:38:47,240 --> 00:38:50,370
Mas muitos desses bits, talvez até 100% deles, ainda estão lá.

647
00:38:50,370 --> 00:38:55,050
É que o computador ou a câmera não sabe onde começou JPEG1

648
00:38:55,050 --> 00:38:56,910
e onde JPEG2 iniciado.

649
00:38:56,910 --> 00:39:01,070
Mas se você, programador, sabe, com um pouco de habilidade onde os JPEGs são

650
00:39:01,070 --> 00:39:06,010
ou o que parece que você possa analisar o JPEG 0s e 1s e dizer, JPEG,

651
00:39:06,010 --> 00:39:09,440
você pode escrever um programa com essencialmente apenas um for ou while

652
00:39:09,440 --> 00:39:12,820
que recupera cada um desses arquivos.

653
00:39:12,820 --> 00:39:16,030
Assim, a lição, então, é para começar a forma segura de apagar seus arquivos

654
00:39:16,030 --> 00:39:18,340
se você gostaria de evitar este completamente. Sim.

655
00:39:18,340 --> 00:39:21,010
>> [Aluno] Como é que ele diz em seu computador

656
00:39:21,010 --> 00:39:23,550
que você tem mais memória do que você fez antes?

657
00:39:23,550 --> 00:39:27,820
Ter mais memória do que você fez antes - >> [aluno] Mais memória disponível.

658
00:39:27,820 --> 00:39:29,630
Oh. Boa pergunta.

659
00:39:29,630 --> 00:39:32,360
Então, por que depois de esvaziar a lixeira do seu computador não dizer

660
00:39:32,360 --> 00:39:34,910
que você tenha mais espaço livre do que você fez antes?

661
00:39:34,910 --> 00:39:36,770
Em poucas palavras, porque ele está mentindo.

662
00:39:36,770 --> 00:39:40,740
Mais tecnicamente, você tem mais espaço, porque agora você disse

663
00:39:40,740 --> 00:39:43,680
você pode colocar outras coisas em que o arquivo já foi.

664
00:39:43,680 --> 00:39:45,450
Mas isso não significa que os bits estão indo embora,

665
00:39:45,450 --> 00:39:48,590
e isso não significa que os bits estão a ser alteradas para todos 0s, por exemplo,

666
00:39:48,590 --> 00:39:50,150
para sua proteção.

667
00:39:50,150 --> 00:39:54,640
Então, por outro lado, se você seguramente apagar arquivos ou destruir fisicamente o dispositivo,

668
00:39:54,640 --> 00:39:57,300
que realmente é a única forma, por vezes, em torno disso.

669
00:39:57,300 --> 00:40:02,020
>> Então, por que não deixamos em que a nota semi-assustador, e vamos vê-lo na segunda-feira.

670
00:40:02,020 --> 00:40:07,000
[Aplausos]

671
00:40:07,780 --> 00:40:10,000
>> [CS50.TV]