1
00:00:00,000 --> 00:00:02,760
[Powered by Google Translate] [SEMANA 5]

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

3
00:00:04,760 --> 00:00:11,990
[Esta é CS50.] [CS50.TV]

4
00:00:11,990 --> 00:00:17,780
[Mulher] Ele está mentindo, sobre o que, eu não sei.

5
00:00:17,780 --> 00:00:20,300
[Homem] Então, o que nós sabemos?

6
00:00:20,300 --> 00:00:24,120
[Mulher] Isso às 9:15, Ray Santoya estava no caixa eletrônico.

7
00:00:24,120 --> 00:00:27,420
[Homem] Então a questão é, o que ele estava fazendo em 9:16?

8
00:00:27,420 --> 00:00:29,980
[Mulher] Tiro a 9 mm em alguma coisa.

9
00:00:29,980 --> 00:00:31,900
Talvez ele viu o atirador.

10
00:00:31,900 --> 00:00:34,000
[Homem] Ou ele estava trabalhando com ele.

11
00:00:34,000 --> 00:00:36,330
[Mulher] Espere. Volte um.

12
00:00:36,330 --> 00:00:38,330
[Homem] O que você vê?

13
00:00:38,330 --> 00:00:44,520
[♫ ♫ música suspense]

14
00:00:44,520 --> 00:00:48,320
[Mulher] Traga o rosto. Tela cheia.

15
00:00:48,320 --> 00:00:51,230
[Homem] Seus óculos. >> Há uma reflexão.

16
00:00:51,230 --> 00:01:00,810
[♫ ♫ música suspense]

17
00:01:00,810 --> 00:01:03,580
[Homem] Essa é a equipe do Nuevita de beisebol. Essa é a sua logomarca.

18
00:01:03,580 --> 00:01:07,790
[Mulher] E ele está falando com quem está vestindo a jaqueta.

19
00:01:07,790 --> 00:01:13,730
>> [David Malan] Então, isso é CS50 semana 5, e hoje nós estragar um pouco de televisão e filme para você.

20
00:01:13,730 --> 00:01:16,170
Assim, sempre que você está assistindo a um show como este aqui,

21
00:01:16,170 --> 00:01:19,910
e os policiais dizem "Você pode limpar isso?" ou "Melhorar",

22
00:01:19,910 --> 00:01:21,900
não há nenhum realce no mundo real.

23
00:01:21,900 --> 00:01:25,220
Na verdade, o que realmente se é um pouco algo como isto.

24
00:01:25,220 --> 00:01:27,570
Eu já puxou uma das fotos da equipe a partir da página.

25
00:01:27,570 --> 00:01:30,980
Este é um programa chamado Photoshop. Esta é uma das duas Bowdens,

26
00:01:30,980 --> 00:01:36,300
1 de 3 Bowdens Na verdade, hoje, porque temos a Sra. Bowden aqui também, com Rob e Paulo.

27
00:01:36,300 --> 00:01:41,950
Mas aqui é Rob na tela, e se aumentar o zoom em um brilho que ele sempre teve em seu olho,

28
00:01:41,950 --> 00:01:47,600
o que você realmente vê é o que você vê é o que você recebe.

29
00:01:47,600 --> 00:01:51,690
Este é o "melhor", para "CSI" tem um pouco errado.

30
00:01:51,690 --> 00:01:55,190
Há um outro clipe, se é que podemos escolher em "CSI" apenas um pouco mais longo.

31
00:01:55,190 --> 00:01:58,500
Esta é uma frase legal para proferir doravante se você quiser

32
00:01:58,500 --> 00:02:10,280
parecer técnico com seus amigos quando, na verdade, você está dizendo absolutamente nada.

33
00:02:10,280 --> 00:02:12,970
>> [Homem] Durante semanas eu estive a investigar os assassinatos do assassino Cabby

34
00:02:12,970 --> 00:02:15,360
com uma certa fascinação mórbida.

35
00:02:15,360 --> 00:02:17,160
[Woman # 1] Esta é em tempo real.

36
00:02:17,160 --> 00:02:22,930
[Woman # 2] Eu vou criar uma interface gráfica usando o Visual Basic, ver se consigo controlar um endereço IP.

37
00:02:22,930 --> 00:02:29,570
>> [Malan] Então áudio fora de sincronia de lado, a criação de uma interface gráfica usando o Visual Basic

38
00:02:29,570 --> 00:02:31,820
para rastrear um endereço IP é um disparate completo.

39
00:02:31,820 --> 00:02:33,840
Estes dias você não usar o Visual Basic,

40
00:02:33,840 --> 00:02:38,920
não há necessidade de uma interface gráfica, eo endereço IP era um termo tecnicamente preciso.

41
00:02:38,920 --> 00:02:41,730
Portanto, manter um olho para fora para estes, e um dos meus favoritos:

42
00:02:41,730 --> 00:02:45,070
Este é um pouco mais misterioso, porque você precisa saber uma língua diferente.

43
00:02:45,070 --> 00:02:47,860
Há uma linguagem chamada Objective-C, que é um superconjunto de C.

44
00:02:47,860 --> 00:02:51,960
Que significa que é C mais alguns recursos adicionais, entre eles, programação orientada a objetos.

45
00:02:51,960 --> 00:02:55,070
E esta é a linguagem que a Apple popularizou para programação iOS.

46
00:02:55,070 --> 00:02:58,760
E aqui está um clipe de um show completamente diferente, de "Números",

47
00:02:58,760 --> 00:03:02,450
que, se você olhar de perto, na verdade, em seu TiVo e pausa no momento certo,

48
00:03:02,450 --> 00:03:07,700
você vai ver que o que eles estão olhando não é muito o que está sendo descrito.

49
00:03:07,700 --> 00:03:11,170
E deixe-me tentar um conector de áudio diferente aqui e ver se nós não podemos

50
00:03:11,170 --> 00:03:13,780
manter o áudio em sincronia este tempo.

51
00:03:13,780 --> 00:03:20,530
Eu dar-lhe "Números".

52
00:03:20,530 --> 00:03:23,240
>> [Man # 1] É um endereço de 32 bits do IPv4.

53
00:03:23,240 --> 00:03:38,930
[Man # 2] IP, que é a Internet. >> Rede privada. É rede privada de Anita.

54
00:03:38,930 --> 00:03:43,810
[Malan] Okay. Este é Objective-C, e é para o programa de um garoto de coloração,

55
00:03:43,810 --> 00:03:51,140
como você pode talvez inferir a partir do nome da variável de lá.

56
00:03:51,140 --> 00:03:54,410
Para que, então, era "Números". Então, hoje e esta semana vamos introduzir

57
00:03:54,410 --> 00:03:57,740
um pouco do mundo da ciência forense e do contexto dos problemas, portanto.

58
00:03:57,740 --> 00:04:00,590
Hoje será uma palestra abreviada porque há um evento especial aqui

59
00:04:00,590 --> 00:04:05,530
depois, por isso vamos dar uma olhada, e provocar os estudantes e pais de hoje

60
00:04:05,530 --> 00:04:07,420
com algumas das coisas que são no horizonte.

61
00:04:07,420 --> 00:04:12,240
Entre eles, a partir de segunda-feira, você terá um pouco mais colegas.

62
00:04:12,240 --> 00:04:16,050
EDX, Harvard e MITs nova iniciativa online para Open Courseware

63
00:04:16,050 --> 00:04:19,120
e mais, está lançando no campus de Harvard, na segunda-feira.

64
00:04:19,120 --> 00:04:21,490
O que significa que segunda-feira é que você terá - a partir de última contagem,

65
00:04:21,490 --> 00:04:26,210
86.000 colegas adicionais serão acompanhando com palestras do CS50

66
00:04:26,210 --> 00:04:29,170
e seções e orientações e conjuntos de problema.

67
00:04:29,170 --> 00:04:32,350
E, como parte disso, você vai se tornar membros da aula inaugural do

68
00:04:32,350 --> 00:04:35,090
CS50 e agora CS50x.

69
00:04:35,090 --> 00:04:39,310
>> Como parte deste, agora, perceber que haverá algumas upsides também.

70
00:04:39,310 --> 00:04:43,790
Para se preparar para isso, para o grande número de estudantes,

71
00:04:43,790 --> 00:04:47,180
basta dizer que, embora tenhamos 108 TFs e CAs,

72
00:04:47,180 --> 00:04:50,790
não é bem a melhor relação aluno / professor, uma vez que atingiu 80.000 outros estudantes.

73
00:04:50,790 --> 00:04:52,850
Portanto, não vai ser problema para muitos classificação define manualmente.

74
00:04:52,850 --> 00:04:55,920
Então, introduziu esta semana no conjunto de problemas será CS50 Check,

75
00:04:55,920 --> 00:04:58,450
que vai ser uma linha de comando no interior do aparelho

76
00:04:58,450 --> 00:05:01,200
que você vai ter uma vez que você atualizá-lo mais tarde neste fim de semana,

77
00:05:01,200 --> 00:05:03,200
e você vai ser capaz de executar um comando, verifique 50,

78
00:05:03,200 --> 00:05:06,500
em seu pset próprio, e você vai obter algum feedback para saber se o seu programa é

79
00:05:06,500 --> 00:05:11,160
correta ou incorreta de acordo com especificações de design diferentes que nós fornecemos.

80
00:05:11,160 --> 00:05:13,580
Então mais sobre isso ea especificação do conjunto de problemas e

81
00:05:13,580 --> 00:05:17,240
os colegas CS50x vai usar isso também.

82
00:05:17,240 --> 00:05:19,230
>> Então conjunto de problemas 4 é tudo sobre forense.

83
00:05:19,230 --> 00:05:21,940
E esta peça foi inspirada por algumas coisas da vida real,

84
00:05:21,940 --> 00:05:24,620
em que quando eu estava na faculdade, eu internados por um tempo com

85
00:05:24,620 --> 00:05:28,650
Escritório Distrital do Condado de Middlesex da Procuradoria está fazendo o trabalho forense

86
00:05:28,650 --> 00:05:31,650
com o seu principal investigador forense, eo que isso representou

87
00:05:31,650 --> 00:05:35,260
é, eu acho que eu mencionei passado algumas semanas, é a polícia do estado de Massa ou outros

88
00:05:35,260 --> 00:05:39,000
iria entrar, eles cairia coisas como discos rígidos, CDs e disquetes

89
00:05:39,000 --> 00:05:42,340
e similares, e, em seguida, o objectivo do escritório forense era determinar se

90
00:05:42,340 --> 00:05:44,600
lá era ou não evidência de algum tipo.

91
00:05:44,600 --> 00:05:48,010
Esta foi a Unidade de Investigações Especiais, por isso era crime de colarinho branco,

92
00:05:48,010 --> 00:05:52,350
ele era uma espécie mais preocupante de crimes,

93
00:05:52,350 --> 00:05:55,990
qualquer coisa que envolva algum tipo de mídia digital; Acontece que não que muitas pessoas

94
00:05:55,990 --> 00:05:59,370
escrever um e-mail dizendo "eu fiz isso."

95
00:05:59,370 --> 00:06:03,290
Então, muitas vezes essas pesquisas forenses não apareceu todos os frutos que muito,

96
00:06:03,290 --> 00:06:05,850
mas às vezes as pessoas escrevem e-mails desse tipo.

97
00:06:05,850 --> 00:06:08,490
Então, às vezes os esforços foram recompensados.

98
00:06:08,490 --> 00:06:14,420
>> Mas, para levar até este pset forense, estaremos introduzindo no pset 4 um pouco de gráficos.

99
00:06:14,420 --> 00:06:18,260
Portanto, você provavelmente levar estas coisas para concedido, JPEGs, GIFs e como nos dias de hoje,

100
00:06:18,260 --> 00:06:21,640
mas se você realmente pensa sobre isso, uma imagem, assim como o rosto de Rob,

101
00:06:21,640 --> 00:06:24,430
pode ser modelada como uma sequência de pontos, ou pixels.

102
00:06:24,430 --> 00:06:26,680
Agora, no caso de rosto de Rob, existem todos os tipos de cores,

103
00:06:26,680 --> 00:06:29,940
e começamos a ver os pontos individuais, otherwide conhecidos como pixels,

104
00:06:29,940 --> 00:06:31,610
uma vez que começou a fazer zoom in

105
00:06:31,610 --> 00:06:35,590
Mas se simplificar o mundo um pouco, e apenas dizer que isso aqui é Rob

106
00:06:35,590 --> 00:06:40,560
em preto e branco, bem, para representar o preto e branco podemos usar apenas binário.

107
00:06:40,560 --> 00:06:44,960
E se vamos usar binário, 1 ou 0, podemos expressar esta mesma imagem

108
00:06:44,960 --> 00:06:51,970
de rosto sorridente de Rob com esse padrão de bits: 11000011 representa

109
00:06:51,970 --> 00:06:55,160
branco, branco, preto, preto, preto, preto, branco branco.

110
00:06:55,160 --> 00:06:59,290
E por isso não é um grande salto, então, começar a falar sobre fotografias coloridas.

111
00:06:59,290 --> 00:07:01,920
Coisas que você veria no Facebook ou levar com uma câmera digital,

112
00:07:01,920 --> 00:07:04,730
mas, certamente, quando se trata de cores, você precisa mais bits.

113
00:07:04,730 --> 00:07:08,470
E bastante comum no mundo das fotografias é usar uma cor não-bit,

114
00:07:08,470 --> 00:07:12,730
como isso sugere, mas cor de 24 bits, onde você realmente obter milhões de cores.

115
00:07:12,730 --> 00:07:15,430
Assim como no caso quando o zoom no olho do Rob,

116
00:07:15,430 --> 00:07:19,270
que era um número qualquer de milhões de diferentes possibilidades coloridas.

117
00:07:19,270 --> 00:07:22,260
>> Então, nós vamos introduzir este problema em conjunto 4, bem como no passo a passo,

118
00:07:22,260 --> 00:07:27,050
que será hoje às 3:30 em vez de 2:30 o habitual por causa de palestra de sexta-feira aqui.

119
00:07:27,050 --> 00:07:29,930
Mas o vídeo vai estar on-line, como de costume, amanhã.

120
00:07:29,930 --> 00:07:31,880
Também vamos apresentá-lo para outro formato de arquivo.

121
00:07:31,880 --> 00:07:34,150
Portanto, este é deliberadamente quis olhar intimidador no início,

122
00:07:34,150 --> 00:07:38,980
mas isso é apenas uma documentação alguma para uma struct C.

123
00:07:38,980 --> 00:07:42,280
Acontece que a Microsoft, há anos, ajudou a popularizar este formato,

124
00:07:42,280 --> 00:07:46,630
chamado o formato de arquivo bitmap, BMP, e este foi um super-simples,

125
00:07:46,630 --> 00:07:50,390
formato de arquivo colorido gráfico que foi usado por algum tempo

126
00:07:50,390 --> 00:07:53,640
e às vezes ainda para papéis de parede em desktops.

127
00:07:53,640 --> 00:07:57,410
Se você acha que volta para o Windows XP e as colinas e céu azul,

128
00:07:57,410 --> 00:08:00,660
que era tipicamente um BMP ou imagem bitmap, e bitmaps

129
00:08:00,660 --> 00:08:03,340
são divertido para nós, porque eles têm um pouco mais de complexidade.

130
00:08:03,340 --> 00:08:05,640
Não é tão simples como esta grade de 0 e 1 de;

131
00:08:05,640 --> 00:08:10,680
em vez disso, você tem coisas como um cabeçalho no início de um arquivo.

132
00:08:10,680 --> 00:08:15,520
Portanto, em outras palavras, dentro de um arquivo bmp. É um monte de 0 e 1, o

133
00:08:15,520 --> 00:08:18,070
mas há algum adicional 0 e 1 em lá.

134
00:08:18,070 --> 00:08:21,450
E acontece que o que nós provavelmente já um dado adquirido há anos,

135
00:08:21,450 --> 00:08:27,040
formatos de arquivo como. doc ou. xls ou. mp3 ou. mp4,

136
00:08:27,040 --> 00:08:29,910
quaisquer que sejam os formatos de arquivo que você está familiarizado.

137
00:08:29,910 --> 00:08:31,900
Bem, o que ainda significa ser um formato de arquivo?

138
00:08:31,900 --> 00:08:35,740
Porque no fim do dia, todos estes ficheiros usamos têm apenas 0 e 1 do

139
00:08:35,740 --> 00:08:39,950
e talvez os 0 e 1 representam a, b, c, através ASCII ou similar,

140
00:08:39,950 --> 00:08:42,030
mas até o final do dia, é apenas de 0 e 1.

141
00:08:42,030 --> 00:08:45,300
>> Assim, os seres humanos apenas ocasionalmente decidem inventar um novo formato de arquivo

142
00:08:45,300 --> 00:08:49,420
onde padronizar o que padrões de bits vai realmente significar.

143
00:08:49,420 --> 00:08:52,790
E, neste caso aqui, o pessoal que projetou o formato de arquivo bitmap

144
00:08:52,790 --> 00:08:58,260
disse que no primeiro byte em um arquivo bitmap, como indicado por offset 0, ali,

145
00:08:58,260 --> 00:09:02,320
lá vai ser algum enigmaticamente chamado bfType variável chamada,

146
00:09:02,320 --> 00:09:06,510
que só fica para o tipo de arquivo de bitmap, que tipo de arquivo de bitmap que é isso.

147
00:09:06,510 --> 00:09:10,780
Você pode inferir, talvez, a partir de segunda linha que compensar 2, número de bytes 2,

148
00:09:10,780 --> 00:09:15,980
tem um padrão de 0 e 1, que representa o que?

149
00:09:15,980 --> 00:09:18,320
O tamanho de algo, e vai de lá.

150
00:09:18,320 --> 00:09:20,660
Assim, no conjunto de problemas 4, você vai ser orientado por algumas destas coisas.

151
00:09:20,660 --> 00:09:24,480
>> Nós não vai acabar se preocupar com todos eles, mas aviso que começa a ficar interessante

152
00:09:24,480 --> 00:09:30,780
em torno da linha ou byte 54, rgbtBlue, Verde e Vermelho.

153
00:09:30,780 --> 00:09:35,280
Se você já ouviu a sigla RGB, vermelho, verde azul, esta é uma referência a isso.

154
00:09:35,280 --> 00:09:37,840
Porque não é que você pode pintar todas as cores do arco-íris

155
00:09:37,840 --> 00:09:41,580
com uma combinação de vermelho e azul e verde.

156
00:09:41,580 --> 00:09:46,560
E, de fato, os pais no quarto pode recordar alguns dos primeiros projetores.

157
00:09:46,560 --> 00:09:49,360
Estes dias, você só vê uma luz brilhante que sai de uma lente.

158
00:09:49,360 --> 00:09:52,870
Mas de volta ao dia, você teve a lente vermelha, lente azul, ea lente verde

159
00:09:52,870 --> 00:09:56,620
e, juntos, visam a tela e formou uma imagem colorida.

160
00:09:56,620 --> 00:09:59,590
E muitas vezes escolas de ensino médio e escolas secundárias teria aquelas lentes

161
00:09:59,590 --> 00:10:02,680
tão-pouco torta, para que eram uma espécie de ver imagens duplas ou triplas,

162
00:10:02,680 --> 00:10:07,500
mas essa era a idéia. Você tinha luz vermelha, verde e azul pintar um quadro.

163
00:10:07,500 --> 00:10:09,570
E esse mesmo princípio é usado em computadores.

164
00:10:09,570 --> 00:10:12,000
>> Assim, entre os desafios, então, para você em conjunto de problemas 4

165
00:10:12,000 --> 00:10:16,080
vão ser algumas coisas: uma é para redimensionar uma imagem.

166
00:10:16,080 --> 00:10:18,050
Para tomar um padrão de 0 e 1, o

167
00:10:18,050 --> 00:10:22,840
descobrir qual pedaços de 0 e 1 representam o que de uma estrutura como esta,

168
00:10:22,840 --> 00:10:26,800
e então descobrir como replicar os pixels: os vermelhos, os azuis, os verdes

169
00:10:26,800 --> 00:10:32,460
dentro de modo que, quando uma imagem fica assim, inicialmente, pode ter este aspecto em vez depois disso.

170
00:10:32,460 --> 00:10:35,590
Entre outros desafios, também, vai ser que você vai ser entregue

171
00:10:35,590 --> 00:10:38,900
uma imagem forense de um arquivo real de uma câmera digital

172
00:10:38,900 --> 00:10:42,410
e em que a câmera, era uma vez, foram um monte de fotos.

173
00:10:42,410 --> 00:10:47,030
O problema é que nós acidentalmente apagados ou teve a imagem corrompida de algum modo.

174
00:10:47,030 --> 00:10:51,040
Coisas ruins acontecem com câmeras digitais, e portanto, rapidamente copiado todos os de 0 e 1 do

175
00:10:51,040 --> 00:10:55,410
fora desse cartão para você, salvou-los todos em um arquivo grande, e depois nós vamos entregá-los para você

176
00:10:55,410 --> 00:11:00,000
no conjunto de problemas 4, de modo que você pode escrever um programa em C com o qual se recuperar

177
00:11:00,000 --> 00:11:02,660
todas essas JPEGs, idealmente.

178
00:11:02,660 --> 00:11:06,280
E acontece que JPEGs, mesmo que sejam um pouco de um formato de arquivo complexo,

179
00:11:06,280 --> 00:11:09,580
eles são muito mais complexos do que este sorriso aqui.

180
00:11:09,580 --> 00:11:14,320
Acontece que cada JPEG começa com os mesmos padrões de 0 e 1 do.

181
00:11:14,320 --> 00:11:18,820
Então, usando um loop while ou um loop for ou similar,

182
00:11:18,820 --> 00:11:22,350
você pode iterar sobre todos os de 0 e 1 nesta imagem forense

183
00:11:22,350 --> 00:11:26,670
e cada vez que você ver o padrão especial que está definido na especificação do conjunto de problemas, a

184
00:11:26,670 --> 00:11:29,770
você pode supor, 'Oh, aqui é, com grande probabilidade,

185
00:11:29,770 --> 00:11:33,520
o início de um JPEG ', e assim que encontrar o mesmo padrão,

186
00:11:33,520 --> 00:11:36,050
um número de bytes ou kilobytes ou megabytes depois,

187
00:11:36,050 --> 00:11:40,550
você pode supor, "Ooh! Aqui é um JPEG segunda, a foto que eu tomei depois da primeira.

188
00:11:40,550 --> 00:11:44,720
Deixe-me parar de ler esse arquivo em primeiro lugar, começar a escrever este novo. "

189
00:11:44,720 --> 00:11:49,980
E a saída do seu programa para pset 4 vai ser cerca de 50 JPEGs.

190
00:11:49,980 --> 00:11:52,400
E se não é 50 JPEGs, você tem um pouco de um loop.

191
00:11:52,400 --> 00:11:55,580
Se você tem um número infinito de JPEGs, você tem um loop infinito.

192
00:11:55,580 --> 00:11:58,280
De modo que, também, vai ser muito caso comum.

193
00:11:58,280 --> 00:12:00,280
Isso é o que está no horizonte.

194
00:12:00,280 --> 00:12:03,740
>> Questionário 0, atrás de nós. Perceba, por meu e-mail, que, invariavelmente, há pessoas

195
00:12:03,740 --> 00:12:06,820
que são ambos tipo, feliz de neutro, e triste em torno de 0 Quiz tempo.

196
00:12:06,820 --> 00:12:10,160
E por favor, chegar a mim, os TFs cabeça, Zamyla, sua própria TF

197
00:12:10,160 --> 00:12:14,120
ou um dos CAs que você sabe, se você gostaria de discutir como as coisas correram.

198
00:12:14,120 --> 00:12:16,460
>> Então, para impressionar os pais aqui na sala,

199
00:12:16,460 --> 00:12:23,990
o que é a biblioteca CS50? Bom trabalho.

200
00:12:23,990 --> 00:12:32,280
O que é a biblioteca CS50? Sim? [Respostas dos alunos, ininteligível]

201
00:12:32,280 --> 00:12:35,730
>> Ok, bom. Portanto, é um conjunto de pré-escrita de código que nós, da equipe, escreveu:

202
00:12:35,730 --> 00:12:38,460
nós fornecemos para você, para fornecer algumas funcionalidades comuns.

203
00:12:38,460 --> 00:12:42,290
Coisas como me uma corda; me um int, todas as funções que estão listadas aqui.

204
00:12:42,290 --> 00:12:45,260
A partir de agora, começamos a realmente tomar essas rodinhas.

205
00:12:45,260 --> 00:12:48,230
Então, vamos começar a tirar uma "cadeia" de você,

206
00:12:48,230 --> 00:12:52,790
que, recall, era apenas um sinônimo para o tipo de dados real? char *.

207
00:12:52,790 --> 00:12:57,020
Então, para os pais, que foi provavelmente - que é bom, então char * nós vamos começar a ver

208
00:12:57,020 --> 00:13:00,810
na tela tudo o mais que nós removemos "cadeia" de nosso vocabulário,

209
00:13:00,810 --> 00:13:02,760
pelo menos quando se trata de realmente escrever código.

210
00:13:02,760 --> 00:13:06,240
Da mesma forma, nós vamos parar de usar algumas dessas funções tanto,

211
00:13:06,240 --> 00:13:08,390
porque os nossos programas estão indo para obter mais sofisticado

212
00:13:08,390 --> 00:13:11,370
em vez de apenas escrever programas que ficam lá com um piscar prompt,

213
00:13:11,370 --> 00:13:13,580
à espera de que o usuário digite algo dentro

214
00:13:13,580 --> 00:13:15,220
Você terá suas entradas a partir de outro lugar.

215
00:13:15,220 --> 00:13:18,720
Por exemplo, você vai levá-los a partir de uma série de bits no disco rígido local.

216
00:13:18,720 --> 00:13:23,340
Você vai em vez levá-los no futuro a partir de uma conexão de rede, algum site em algum lugar.

217
00:13:23,340 --> 00:13:27,460
Então, vamos descascar essa camada pela primeira vez, e puxar para cima o aparelho CS50

218
00:13:27,460 --> 00:13:32,300
e este arquivo chamado CS50.h, que você tenha sido acentuada incluindo por semanas.

219
00:13:32,300 --> 00:13:34,380
>> Mas vamos ver realmente o que está dentro do presente.

220
00:13:34,380 --> 00:13:38,250
Assim, o início do arquivo em azul é apenas um monte de comentários,

221
00:13:38,250 --> 00:13:41,340
informações sobre a garantia e licenciamento. Esta é uma espécie de paradigma comum

222
00:13:41,340 --> 00:13:44,600
em software, porque um monte de software nos dias de hoje é o que é chamado de "código aberto",

223
00:13:44,600 --> 00:13:46,940
o que significa que alguém tenha escrito o código

224
00:13:46,940 --> 00:13:50,060
e tornou disponível gratuitamente, e não apenas para correr e para usar,

225
00:13:50,060 --> 00:13:53,660
mas, na verdade, ler e alterar e integrar no seu próprio trabalho.

226
00:13:53,660 --> 00:13:55,790
Então é isso que você está usando, o software de código aberto,

227
00:13:55,790 --> 00:13:58,030
embora de uma forma muito pequena.

228
00:13:58,030 --> 00:14:01,860
Se eu rolar para baixo após os comentários, porém, vamos começar a ver algumas coisas mais familiares.

229
00:14:01,860 --> 00:14:08,090
Então, observe no topo aqui, que o arquivo CS50.h inclui um conjunto de arquivos de cabeçalho.

230
00:14:08,090 --> 00:14:11,160
Agora, a maioria destes não vimos antes, mas é um

231
00:14:11,160 --> 00:14:15,640
familiar; qual destes temos visto, ainda que brevemente, até agora?

232
00:14:15,640 --> 00:14:18,720
Sim, bibliotecas padrão. Stdlib.h tem malloc,

233
00:14:18,720 --> 00:14:21,590
Portanto, uma vez que começamos a falar sobre a alocação dinâmica de memória,

234
00:14:21,590 --> 00:14:24,960
que vamos voltar para a próxima semana, assim, começamos incluindo o arquivo.

235
00:14:24,960 --> 00:14:29,660
Acontece que bool e verdadeiro e falso na verdade, não existe em C, por si só,

236
00:14:29,660 --> 00:14:32,460
a menos que você inclua esse arquivo aqui.

237
00:14:32,460 --> 00:14:35,770
Portanto, temos, por semana, incluindo sido padrão bool.h

238
00:14:35,770 --> 00:14:39,020
de modo que você pode usar a noção de um. bool, verdadeiro ou falso

239
00:14:39,020 --> 00:14:41,830
Sem isso, você teria que classificar de fingir e usar um int

240
00:14:41,830 --> 00:14:45,920
e apenas arbitrariamente assumir que 0 é falso e 1 é verdadeira.

241
00:14:45,920 --> 00:14:49,980
>> Agora, se rolar mais, aqui é a nossa definição de uma cadeia.

242
00:14:49,980 --> 00:14:54,820
Acontece que, como já disse antes, que quando isso * é realmente não importa.

243
00:14:54,820 --> 00:14:56,750
Você pode até ter todo o espaço ao redor.

244
00:14:56,750 --> 00:15:01,550
Nós, neste semestre, têm vindo a promover-lo como esta para deixar claro que o * tem a ver com o tipo.

245
00:15:01,550 --> 00:15:05,370
Mas perceber, como comum, se não um pouco mais comum, é colocá-lo lá

246
00:15:05,370 --> 00:15:07,480
mas funcionalmente é a mesma coisa.

247
00:15:07,480 --> 00:15:11,070
Mas agora, se lermos mais para baixo, vamos dar uma olhada em, digamos, GetInt,

248
00:15:11,070 --> 00:15:15,350
porque usamos que, talvez, antes de mais nada neste semestre.

249
00:15:15,350 --> 00:15:19,620
E aqui está GetInt. Isto é o que?

250
00:15:19,620 --> 00:15:24,650
Este é o protótipo. Então, muitas vezes, temos que colocar protótipos no topo de nossa. Arquivos c,

251
00:15:24,650 --> 00:15:28,190
mas você também pode colocar protótipos em arquivos de cabeçalho, arquivos. h,

252
00:15:28,190 --> 00:15:32,110
como este aqui, de modo que quando você escreve algumas funções

253
00:15:32,110 --> 00:15:36,790
que você quer que outras pessoas para ser capaz de usar, que é exatamente o caso com a biblioteca CS50,

254
00:15:36,790 --> 00:15:40,900
você não só implementar suas funções em algo como CS50.c,

255
00:15:40,900 --> 00:15:46,720
você também colocar os protótipos não no topo do arquivo, mas no topo de um arquivo de cabeçalho,

256
00:15:46,720 --> 00:15:50,810
em seguida, o arquivo de cabeçalho é o que os amigos e colegas de incluir,

257
00:15:50,810 --> 00:15:52,800
com acentuada incluir no seu próprio código.

258
00:15:52,800 --> 00:15:55,440
Então, todo esse tempo que você tem, incluindo todos os protótipos

259
00:15:55,440 --> 00:15:59,870
efetivamente no topo do seu arquivo, mas por meio deste mecanismo incluem afiada

260
00:15:59,870 --> 00:16:03,320
que praticamente copia e cola este arquivo em seu próprio país.

261
00:16:03,320 --> 00:16:06,400
Agora, aqui está alguma documentação bastante detalhada.

262
00:16:06,400 --> 00:16:08,880
>> Nós praticamente um dado adquirido que GetInt recebe um int,

263
00:16:08,880 --> 00:16:10,740
mas acontece que há alguns casos de canto, certo?

264
00:16:10,740 --> 00:16:14,320
E se o usuário digita um número que é muito grande?

265
00:16:14,320 --> 00:16:17,350
A quintilhões, que simplesmente não pode caber dentro de um int?

266
00:16:17,350 --> 00:16:21,180
Qual é o comportamento esperado? Bem, idealmente, é previsível.

267
00:16:21,180 --> 00:16:23,460
Portanto, neste caso, se você realmente ler a cópia fina,

268
00:16:23,460 --> 00:16:27,850
você vai ver que, se a linha não pode ser lido, INT_MAX este retorno.

269
00:16:27,850 --> 00:16:30,800
Nós nunca conversamos sobre isso, mas com base na sua capitalização,

270
00:16:30,800 --> 00:16:33,030
o que é, provavelmente?

271
00:16:33,030 --> 00:16:36,610
É uma constante, por isso é uma constante especial que é, provavelmente, declarou

272
00:16:36,610 --> 00:16:39,460
em um desses arquivos de cabeçalho que é até maior no arquivo,

273
00:16:39,460 --> 00:16:43,400
e INT_MAX é provavelmente algo como, aproximadamente, 2 bilhões.

274
00:16:43,400 --> 00:16:48,160
A idéia é que, porque precisamos de alguma forma, significa que algo saiu errado,

275
00:16:48,160 --> 00:16:51,090
temos, sim, tem 4 bilhões de números à nossa disposição,

276
00:16:51,090 --> 00:16:53,980
negativa 2 bilhões em até 2 bilhões, mais ou menos.

277
00:16:53,980 --> 00:16:58,030
Bem, o que é comum em programação é você roubar apenas um desses números.

278
00:16:58,030 --> 00:17:02,250
Talvez 0, talvez 2 bilhões, talvez negativo 2 bilhões.

279
00:17:02,250 --> 00:17:06,720
Então você gasta um de seus valores possíveis de modo que você pode cometer ao mundo

280
00:17:06,720 --> 00:17:10,089
que, se algo der errado, eu vou retornar esse valor super-grande.

281
00:17:10,089 --> 00:17:13,329
Mas você não quer que o usuário digitar algo enigmático como "2, 3, 4 ..."

282
00:17:13,329 --> 00:17:17,079
de número realmente grande, onde você generalizar vez como uma constante.

283
00:17:17,079 --> 00:17:19,380
Então, realmente, se você estava sendo anal nas últimas semanas,

284
00:17:19,380 --> 00:17:23,800
quando você chamar GetInt, você deveria ter vindo a verificar com uma condição se.

285
00:17:23,800 --> 00:17:27,109
Será que o usuário digite INT_MAX, ou mais especificamente,

286
00:17:27,109 --> 00:17:29,900
fez GetInt INT_MAX retorno? Porque, se o fez,

287
00:17:29,900 --> 00:17:35,140
que realmente significa que eles não digitá-lo, algo deu errado neste caso.

288
00:17:35,140 --> 00:17:38,970
Portanto, este é o que é geralmente conhecido como "sentinela" valor, o que significa apenas especial.

289
00:17:38,970 --> 00:17:41,020
>> Bem, vamos agora para os arquivos. C.

290
00:17:41,020 --> 00:17:44,500
O arquivo C existiu no aparelho por algum tempo,

291
00:17:44,500 --> 00:17:47,540
e, de fato, o aparelho tem pré-compilado para você

292
00:17:47,540 --> 00:17:49,720
nessa coisa que chamamos de "código objeto",

293
00:17:49,720 --> 00:17:52,940
mas ele simplesmente não importa para onde está porque o sistema sabe,

294
00:17:52,940 --> 00:17:54,780
neste caso, em que é, o aparelho.

295
00:17:54,780 --> 00:18:00,620
Mas vamos rolar agora para getInt, e ver como GetInt vem trabalhando todo esse tempo.

296
00:18:00,620 --> 00:18:02,380
Portanto, temos aqui comentários similares de antes.

297
00:18:02,380 --> 00:18:04,930
Deixe-me zoom em apenas parte do código,

298
00:18:04,930 --> 00:18:07,410
eo que temos para GetInt é o seguinte.

299
00:18:07,410 --> 00:18:12,770
Não é preciso de entrada e retorna um int, enquanto (verdadeiro), por isso temos um loop infinito deliberada

300
00:18:12,770 --> 00:18:16,560
mas, provavelmente, vamos romper com isso de alguma forma, ou retornar a partir desta.

301
00:18:16,560 --> 00:18:19,890
Então vamos ver como isso funciona. Bem, parece que estamos usando GetString

302
00:18:19,890 --> 00:18:22,550
nesta primeira linha dentro do loop, 166.

303
00:18:22,550 --> 00:18:25,320
Isto agora é uma boa prática, porque em que circunstâncias

304
00:18:25,320 --> 00:18:30,820
GetString poderia retornar este especial palavra-chave NULL,?

305
00:18:30,820 --> 00:18:38,460
Se algo der errado. O que poderia dar errado quando você chamar algo como GetString?

306
00:18:38,460 --> 00:18:42,550
Sim? [Responder Estudante, ininteligível] >> Yeah. Então talvez malloc falhar.

307
00:18:42,550 --> 00:18:45,310
Em algum lugar debaixo do capô GetString está chamando malloc,

308
00:18:45,310 --> 00:18:48,210
que aloca memória, que permite que a loja de informática

309
00:18:48,210 --> 00:18:50,950
todos os caracteres que o usuário digita no teclado.

310
00:18:50,950 --> 00:18:53,270
E suponha que o usuário tinha um monte de tempo livre

311
00:18:53,270 --> 00:18:56,470
e digitado mais, por exemplo, de 2 biliões de caracteres.

312
00:18:56,470 --> 00:18:59,600
Mais caracteres que o computador ainda tem RAM.

313
00:18:59,600 --> 00:19:02,350
Bem, GetString tem de ser capaz de significar que a você,

314
00:19:02,350 --> 00:19:05,650
mesmo que este é um super, super-canto caso incomum.

315
00:19:05,650 --> 00:19:08,490
Ela tem, de alguma forma ser capaz de lidar com isto, e de modo GetString,

316
00:19:08,490 --> 00:19:11,850
se voltar e ler sua documentação, se, de fato, retornar NULL.

317
00:19:11,850 --> 00:19:16,150
Agora, se GetString falhar, retornando NULL, GetInt vai falhar

318
00:19:16,150 --> 00:19:19,370
retornando INT_MAX, como uma sentinela.

319
00:19:19,370 --> 00:19:22,650
Estes são apenas convenções humanas. A única maneira que você sabe que este é o caso

320
00:19:22,650 --> 00:19:24,840
é lendo a documentação.

321
00:19:24,840 --> 00:19:28,200
Então, vamos rolar para onde o int é realmente GotInt.

322
00:19:28,200 --> 00:19:34,220
>> Então, se eu rolar um pouco mais, na linha 170, temos um comentário acima destas linhas.

323
00:19:34,220 --> 00:19:38,470
Assim, declaramos, em 172, um n int e um char c, e então esta nova função

324
00:19:38,470 --> 00:19:41,870
que alguns de vocês ter tropeçado antes, mas sscanf.

325
00:19:41,870 --> 00:19:44,190
Isso significa string f digitalização.

326
00:19:44,190 --> 00:19:48,580
Em outras palavras, dá-me uma corda e eu irá procurar por peças de informação de interesse.

327
00:19:48,580 --> 00:19:53,820
Então, o que isso significa? Bem, suponha que eu digitar, literalmente, 1 2 3 no teclado,

328
00:19:53,820 --> 00:19:59,730
e tecle enter. Qual é o tipo de dados de 1 2 3 quando retornou por GetString?

329
00:19:59,730 --> 00:20:05,010
É óbvio que é uma string, certo? Eu tenho uma string, assim 1 2 3 é realmente "1 2 3"

330
00:20:05,010 --> 00:20:07,260
com o 0 \ no final da mesma. Isso não é um int.

331
00:20:07,260 --> 00:20:10,420
Isso não é um número. Parece um número, mas isso não é verdade.

332
00:20:10,420 --> 00:20:14,680
Então, o que GetInt tenho que fazer? Tem que analisar essa seqüência esquerda para a direita,

333
00:20:14,680 --> 00:20:19,010
1 2 3 \ 0, e de alguma forma, convertê-lo em um inteiro real.

334
00:20:19,010 --> 00:20:21,010
Agora, você pode descobrir como fazer isso.

335
00:20:21,010 --> 00:20:24,240
Se você acha que volta para pset 2, você provavelmente tem um pouco confortável

336
00:20:24,240 --> 00:20:26,810
com César ou vigenere assim você pode iterar sobre uma corda,

337
00:20:26,810 --> 00:20:29,800
você pode converter caracteres para ints com picareta. Isso é um monte de trabalho.

338
00:20:29,800 --> 00:20:32,800
Por que não chamar uma função como sscanf que faz isso para você?

339
00:20:32,800 --> 00:20:37,520
Então sscanf espera um argumento, neste caso chamado de linha, que é uma cadeia.

340
00:20:37,520 --> 00:20:41,310
Você, então, especificar, entre aspas, muito semelhante ao printf,

341
00:20:41,310 --> 00:20:44,960
o que você espera para ver nesta corda?

342
00:20:44,960 --> 00:20:52,980
O que eu estou dizendo aqui é que, eu espero ver um número decimal e talvez um personagem.

343
00:20:52,980 --> 00:20:54,990
E vamos ver por que este é o caso em apenas um momento.

344
00:20:54,990 --> 00:20:58,440
Acontece que esta notação é agora lembra de coisas

345
00:20:58,440 --> 00:21:00,840
começamos a falar sobre pouco mais de uma semana atrás.

346
00:21:00,840 --> 00:21:05,430
>> O que é & n & c e fazendo por nós aqui? [Respostas dos alunos, ininteligível]

347
00:21:05,430 --> 00:21:07,610
Sim >>. Está me dando o endereço de n e endereço do c.

348
00:21:07,610 --> 00:21:10,440
Agora, por que isso é importante? Bem, você sabe que com funções em C

349
00:21:10,440 --> 00:21:13,440
você sempre pode retornar um valor ou nenhum valor.

350
00:21:13,440 --> 00:21:16,630
Você pode retornar um int, uma corda, uma bóia, um char, o que for.

351
00:21:16,630 --> 00:21:21,150
Ou você pode retornar vazio, mas você só pode retornar 1 coisa ao máximo.

352
00:21:21,150 --> 00:21:26,100
Mas, aqui queremos sscanf para voltar me talvez um int, um número decimal,

353
00:21:26,100 --> 00:21:29,240
e também um. char, e eu vou explicar por que o char em um momento

354
00:21:29,240 --> 00:21:34,250
Então você efetivamente quer f para retornar 2 coisas, que não é apenas possível em C.

355
00:21:34,250 --> 00:21:38,460
Então você pode resolver isso passando em dois endereços,

356
00:21:38,460 --> 00:21:43,710
porque assim que você entrega uma função de dois endereços, o que essa função faz com eles?

357
00:21:43,710 --> 00:21:49,880
Ele pode escrever para esses endereços. Você pode usar a operação * e "ir lá" para cada um desses endereços.

358
00:21:49,880 --> 00:21:54,320
É uma espécie de este mecanismo backdoor, mas muito comum para alterar os valores das variáveis

359
00:21:54,320 --> 00:21:58,020
em mais do que apenas um lugar, neste caso 2.

360
00:21:58,020 --> 00:22:04,590
Agora, repare que eu estou verificando para == to1, e depois retornando n se isso, de fato, avaliar a verdade.

361
00:22:04,590 --> 00:22:09,340
Então, o que está acontecendo? Bem, tecnicamente, tudo o que realmente quer que aconteça em GetInt é esta.

362
00:22:09,340 --> 00:22:12,340
Queremos analisar, por assim dizer, queremos ler a seqüência

363
00:22:12,340 --> 00:22:16,210
"1 2 3" e se parece que há um número lá,

364
00:22:16,210 --> 00:22:21,360
o que estamos dizendo sscanf a fazer é colocar esse número, 1 2 3, nesta variável n para mim.

365
00:22:21,360 --> 00:22:26,060
Por que, então, eu tinha isso também?

366
00:22:26,060 --> 00:22:33,750
Qual é o papel de também dizer, sscanf, você também pode obter um personagem aqui.

367
00:22:33,750 --> 00:22:36,890
[Falando Estudante, ininteligível] >> Não - um ponto decimal podia trabalhar.

368
00:22:36,890 --> 00:22:40,650
Vamos sustentar que pensou por um momento. O que mais?

369
00:22:40,650 --> 00:22:42,570
[Estudante, ininteligível] >> Então, o pensamento bom, poderia ser o caractere nulo.

370
00:22:42,570 --> 00:22:44,970
Na verdade não é, neste caso. Sim? [Estudante, ininteligível]

371
00:22:44,970 --> 00:22:47,100
>> >> ASCII. Ou, deixe-me generalizar ainda mais.

372
00:22:47,100 --> 00:22:49,670
O c% não é apenas para verificação de erros.

373
00:22:49,670 --> 00:22:52,510
Nós não queremos que haja caráter após o número,

374
00:22:52,510 --> 00:22:54,980
mas o que isso me permite fazer é o seguinte:

375
00:22:54,980 --> 00:23:01,270
Acontece que sscanf, além de armazenar valores de n e c, neste exemplo aqui,

376
00:23:01,270 --> 00:23:08,170
o que também não é ele retorna o número de variáveis ​​que colocar valores dentro

377
00:23:08,170 --> 00:23:13,330
Então, se você digitar apenas na 1 2 3, somente o% d vai coincidir com

378
00:23:13,330 --> 00:23:18,830
e só n fica armazenado com um valor como 1 2 3 e nada é colocado em c;

379
00:23:18,830 --> 00:23:20,870
c continua a ser um valor de lixo, por assim dizer.

380
00:23:20,870 --> 00:23:23,550
Lixo, porque isso nunca foi inicializado como algum valor.

381
00:23:23,550 --> 00:23:29,390
Assim, neste caso, sscanf retornará 1, porque I preenchida uma destas indicações,

382
00:23:29,390 --> 00:23:33,650
caso em que, ótimo. Eu tenho um int, então eu liberar a linha para liberar a memória

383
00:23:33,650 --> 00:23:37,150
GetString que efectivamente atribuído, e então eu voltar n.

384
00:23:37,150 --> 00:23:42,210
Outra coisa, se você já se perguntou onde que repetir declaração vem, vem aqui.

385
00:23:42,210 --> 00:23:45,770
Se, pelo contrário, eu digitar 1 2 3 foo,

386
00:23:45,770 --> 00:23:48,640
apenas uma seqüência aleatória de algum texto, sscanf vai ver,

387
00:23:48,640 --> 00:23:51,500
ooh, número, ooh, número, ooh, número, ooh - f.

388
00:23:51,500 --> 00:23:54,190
E vai colocar o 1 2 3 no n.

389
00:23:54,190 --> 00:23:59,970
Vai colocar o f em c, e depois voltar 2.

390
00:23:59,970 --> 00:24:02,980
Então nós temos, apenas usando a definição básica de comportamento do scanf,

391
00:24:02,980 --> 00:24:06,170
uma maneira muito simples - bem, complexo, à primeira vista, mas no final do dia,

392
00:24:06,170 --> 00:24:11,460
mecanismo bastante simples de dizer, há um int, e se assim for, é que a única coisa que eu encontrei?

393
00:24:11,460 --> 00:24:14,950
E o espaço em branco aqui é deliberada. Se você ler a documentação para sscanf,

394
00:24:14,950 --> 00:24:18,690
ele diz-lhe que, se você incluir um pedaço de espaço em branco no início ou no final,

395
00:24:18,690 --> 00:24:24,990
sscanf também vai permitir que o usuário, por qualquer motivo, a barra de espaço para bater 1 2 3, e que será legítimo.

396
00:24:24,990 --> 00:24:28,310
Ele não vai gritar com o usuário só porque bateu a barra de espaço no início ou no final,

397
00:24:28,310 --> 00:24:32,160
que é apenas um pouco mais user-friendly.

398
00:24:32,160 --> 00:24:34,160
>> Qualquer dúvida, então, sobre GetInts? Sim?

399
00:24:34,160 --> 00:24:36,820
[Pergunta do estudante, ininteligível]

400
00:24:36,820 --> 00:24:40,740
>> Boa pergunta. E se você acabou de digitar em um char, como hit f, e digite

401
00:24:40,740 --> 00:24:47,830
sem nunca digitando 1 2 3, o que você acha que o comportamento desta linha de código seria então?

402
00:24:47,830 --> 00:24:50,500
Assim sscanf pode cobrir isso também, porque, nesse caso,

403
00:24:50,500 --> 00:24:56,280
não vai encher n ou c, que vai, em vez retornar 0.

404
00:24:56,280 --> 00:25:01,540
Nesse caso, eu também estou pegando esse cenário, porque o valor esperado que eu quero é 1.

405
00:25:01,540 --> 00:25:07,310
Eu só quero uma, e apenas uma coisa a ser preenchido. Boa pergunta. Outros?

406
00:25:07,310 --> 00:25:09,610
>> Tudo bem, então não vamos passar por todas as funções aqui,

407
00:25:09,610 --> 00:25:11,820
mas o que parece ser, talvez, da participação remanescente

408
00:25:11,820 --> 00:25:14,530
é GetString pois verifica-se que GetFloat, GetInt,

409
00:25:14,530 --> 00:25:19,490
GetDouble, GetLongLong todos punt muito de sua funcionalidade para GetString.

410
00:25:19,490 --> 00:25:22,860
Então, vamos dar uma olhada em como ele é implementado aqui.

411
00:25:22,860 --> 00:25:27,040
Este parece um pouco complexo, mas ele usa os mesmos fundamentos

412
00:25:27,040 --> 00:25:29,680
que começamos a falar sobre a semana passada. Assim, em GetString,

413
00:25:29,680 --> 00:25:32,670
que leva nenhum argumento conforme o vazio até aqui,

414
00:25:32,670 --> 00:25:37,110
e retorna uma string, por isso eu estou declarando uma string chamada buffer.

415
00:25:37,110 --> 00:25:39,670
Eu realmente não sei o que vai ser usado para ainda, mas vamos ver.

416
00:25:39,670 --> 00:25:42,950
Parece que a capacidade é, por padrão, 0; não tem certeza de onde isso vai dar.

417
00:25:42,950 --> 00:25:44,920
Não sei o que n vai ser usado para ainda.

418
00:25:44,920 --> 00:25:47,860
Mas agora está ficando um pouco mais interessante, assim, em linha 243,

419
00:25:47,860 --> 00:25:51,760
declaramos um int c, isto é uma espécie de um detalhe estúpido.

420
00:25:51,760 --> 00:25:58,080
Um char é de 8 bits, e 8 bits pode armazenar quantos valores diferentes?

421
00:25:58,080 --> 00:26:03,310
256. O problema é que, se você quer ter 256 diferentes caracteres ASCII,

422
00:26:03,310 --> 00:26:06,210
que há, se você olhar para trás, e isso não é algo para memorizar.

423
00:26:06,210 --> 00:26:09,100
Mas se você acha que volta para esse gráfico grande ASCII tivemos semanas atrás,

424
00:26:09,100 --> 00:26:13,780
foram, neste caso, de 128 ou 256 caracteres ASCII.

425
00:26:13,780 --> 00:26:16,220
Nós usamos todos os padrões de 0 e 1 para cima.

426
00:26:16,220 --> 00:26:19,410
Isso é um problema se você quiser ser capaz de detectar um erro.

427
00:26:19,410 --> 00:26:23,290
Porque se você já está usando 256 valores para seus personagens,

428
00:26:23,290 --> 00:26:26,390
você realmente não planejar com antecedência, porque agora você não tem nenhuma maneira de dizer,

429
00:26:26,390 --> 00:26:29,750
"Este não é um personagem legal, o que é uma mensagem errada".

430
00:26:29,750 --> 00:26:32,430
Então, o que o mundo faz é, eles usam o valor maior seguinte,

431
00:26:32,430 --> 00:26:35,790
algo como um int para que você tenha um número louco de bits,

432
00:26:35,790 --> 00:26:39,610
32 para 4 mil milhões de valores possíveis, de modo que você pode simplesmente acabar usando,

433
00:26:39,610 --> 00:26:44,800
essencialmente, 257 deles, um dos quais tem algum significado especial como um erro.

434
00:26:44,800 --> 00:26:49,190
>> Então vamos ver como isso funciona. Na linha 246, eu tenho essa grande loop while

435
00:26:49,190 --> 00:26:54,530
que está chamando fgetc; f arquivo significado, getc, e depois stdin.

436
00:26:54,530 --> 00:26:59,030
Acontece que esta é apenas a maneira mais precisa de dizer "ler a entrada do teclado."

437
00:26:59,030 --> 00:27:02,730
Teclado meio padrão de entrada, saída padrão significa tela,

438
00:27:02,730 --> 00:27:06,920
e erro padrão, o que veremos na pset 4, significa que o ecrã,

439
00:27:06,920 --> 00:27:09,670
mas uma parte especial da tela de modo que não é confundida

440
00:27:09,670 --> 00:27:13,760
com a saída real que você pretende imprimir, mas mais sobre isso no futuro.

441
00:27:13,760 --> 00:27:19,430
Então fgetc significa apenas ler um caracter do teclado, e armazená-lo onde?

442
00:27:19,430 --> 00:27:24,000
Guarde-o em c, e depois verificar, então eu estou usando apenas algumas conjunções booleanos aqui,

443
00:27:24,000 --> 00:27:28,430
verificar que não é igual a \ n, de modo que o usuário tenha aperte enter.

444
00:27:28,430 --> 00:27:31,510
Queremos parar nesse ponto, final do ciclo, e também queremos verificar

445
00:27:31,510 --> 00:27:36,170
para a constante especial, EOF, que se você saber ou adivinhar - o que é que significa?

446
00:27:36,170 --> 00:27:39,860
Fim do arquivo. Portanto, este é o tipo de absurdo, porque se eu estou digitando no teclado,

447
00:27:39,860 --> 00:27:41,900
não há realmente nenhum arquivo envolvido nisso,

448
00:27:41,900 --> 00:27:44,330
mas isso é apenas uma espécie de o termo genérico utilizado para significar

449
00:27:44,330 --> 00:27:50,320
que nada mais é que vem dedos dos humanos. EOF. Fim do arquivo.

450
00:27:50,320 --> 00:27:52,600
Como um aparte, se você já atingiu o controle d em seu teclado,

451
00:27:52,600 --> 00:27:54,680
não que você teria ainda, você bateu controle c.

452
00:27:54,680 --> 00:27:57,920
Mas o controle d envia esta constante EOF especial chamado.

453
00:27:57,920 --> 00:28:03,100
>> Portanto, agora só temos alguns alocação dinâmica de memória.

454
00:28:03,100 --> 00:28:06,460
Então, se n + 1> capacidade, agora eu vou explicar n.

455
00:28:06,460 --> 00:28:09,380
n é apenas quantos bytes estão atualmente no buffer,

456
00:28:09,380 --> 00:28:11,970
a seqüência que você está actualmente a construir-se a partir do usuário.

457
00:28:11,970 --> 00:28:16,240
Se você tem mais caracteres em seu buffer do que você tem capacidade de buffer,

458
00:28:16,240 --> 00:28:20,760
intuitivamente, o que precisamos fazer, então, é alocar mais capacidade.

459
00:28:20,760 --> 00:28:24,490
Eu estou indo para pular um pouco da aritmética aqui

460
00:28:24,490 --> 00:28:26,900
e focar apenas esta função aqui.

461
00:28:26,900 --> 00:28:29,170
Sabe o que malloc é, ou pelo menos geralmente familiar.

462
00:28:29,170 --> 00:28:32,380
Adivinha o que realloc faz. [Responder Estudante, ininteligível]

463
00:28:32,380 --> 00:28:35,690
Sim >>. E não é muito a adição de memória, que realoca memória da seguinte maneira:

464
00:28:35,690 --> 00:28:40,530
Se ainda há espaço no final da cadeia para dar-lhe mais do que a memória

465
00:28:40,530 --> 00:28:43,370
do que originalmente lhe dá, então você vai ter que memória adicional.

466
00:28:43,370 --> 00:28:46,640
Então você pode apenas colocar os personagens cordas de costas para trás, para trás.

467
00:28:46,640 --> 00:28:49,290
Mas se esse não é o caso, porque você esperou muito tempo

468
00:28:49,290 --> 00:28:51,700
e algo aleatório tem se estatelou na memória lá, mas não é extra

469
00:28:51,700 --> 00:28:56,480
memória aqui, tudo bem. Realloc vai fazer todo o trabalho pesado para você,

470
00:28:56,480 --> 00:28:58,810
mover a seqüência que você já leu em assim muito longe daqui,

471
00:28:58,810 --> 00:29:02,550
colocá-lo lá em baixo, e depois dar-lhe um pouco mais de pista naquele ponto.

472
00:29:02,550 --> 00:29:05,610
Assim, com um aceno de mão, deixe-me dizer que o que está fazendo GetString

473
00:29:05,610 --> 00:29:09,540
é que está começando com um buffer pequeno, talvez um caráter único,

474
00:29:09,540 --> 00:29:12,300
e se o usuário digita em dois personagens, GetString acaba

475
00:29:12,300 --> 00:29:15,210
chamando realloc e diz, 'Oh, um personagem não foi suficiente.

476
00:29:15,210 --> 00:29:18,480
Dá-me duas personagens. " Então, se você ler a lógica do circuito,

477
00:29:18,480 --> 00:29:21,070
ele vai dizer: 'Oh, o usuário digitou 3 caracteres.

478
00:29:21,070 --> 00:29:25,690
Dê-me agora não dois, mas quatro personagens, então me dar oito, então me dê 16 e 32. "

479
00:29:25,690 --> 00:29:28,180
O fato de que eu estou dobrando a capacidade de cada vez

480
00:29:28,180 --> 00:29:30,320
significa que o buffer não vai crescer lentamente.

481
00:29:30,320 --> 00:29:35,870
Vai crescer super rápido, eo que poderia ser a vantagem disso?

482
00:29:35,870 --> 00:29:38,540
Por que eu estou dobrando o tamanho do buffer, mesmo que o usuário

483
00:29:38,540 --> 00:29:41,450
só precisa um personagem extra a partir do teclado?

484
00:29:41,450 --> 00:29:44,830
[Responder Estudante, ininteligível]. >> O que é isso?

485
00:29:44,830 --> 00:29:46,750
Exatamente. Você não tem que crescer sempre.

486
00:29:46,750 --> 00:29:48,870
E esta é apenas uma espécie de - você cobertura suas apostas aqui.

487
00:29:48,870 --> 00:29:54,150
A idéia é que você não quer chamar realloc muito, porque ele tende a ser lenta.

488
00:29:54,150 --> 00:29:56,840
Toda vez que você perguntar o sistema operacional para a memória, como você verá em breve

489
00:29:56,840 --> 00:30:00,620
em um conjunto de problema futuro, tende a levar algum tempo.

490
00:30:00,620 --> 00:30:04,980
Assim, minimizando a quantidade de tempo, mesmo se você está perdendo um pouco de espaço, tende a ser uma coisa boa.

491
00:30:04,980 --> 00:30:07,250
>> Mas se lermos a parte final da GetString aqui,

492
00:30:07,250 --> 00:30:10,880
e, novamente, a compreensão de cada linha, aqui, não é tão importante hoje.

493
00:30:10,880 --> 00:30:14,830
Mas note que, eventualmente, chama malloc novamente, e ele aloca

494
00:30:14,830 --> 00:30:16,980
exatamente como muitos bytes que ele precisa para a cadeia

495
00:30:16,980 --> 00:30:21,620
e depois joga fora chamando livre, o buffer excessivamente grande,

496
00:30:21,620 --> 00:30:23,510
se realmente foi dobrado muitas vezes.

497
00:30:23,510 --> 00:30:25,970
Em suma, é assim que GetString vem trabalhando todo esse tempo.

498
00:30:25,970 --> 00:30:30,100
Tudo que faz é ler um personagem em um momento novo e de novo e de novo

499
00:30:30,100 --> 00:30:37,930
e cada vez que precisa de um pouco de memória adicional, pede ao sistema operacional para ele chamando realloc.

500
00:30:37,930 --> 00:30:41,660
Alguma pergunta? Tudo bem.

501
00:30:41,660 --> 00:30:45,220
>> Um ataque. Agora que entendemos ponteiros, ou pelo menos

502
00:30:45,220 --> 00:30:47,560
estão cada vez mais familiarizados com ponteiros,

503
00:30:47,560 --> 00:30:50,020
vamos considerar como o mundo inteiro começa a entrar em colapso

504
00:30:50,020 --> 00:30:53,160
se você não consegue se defender contra os usuários contraditório,

505
00:30:53,160 --> 00:30:55,180
pessoas que estão tentando invadir seu sistema.

506
00:30:55,180 --> 00:31:00,260
As pessoas que estão tentando roubar o seu software, contornando alguns código de registro

507
00:31:00,260 --> 00:31:02,150
que eles poderiam ter que digitar dentro

508
00:31:02,150 --> 00:31:04,860
Dê uma olhada neste exemplo aqui, que é apenas o código C

509
00:31:04,860 --> 00:31:07,920
que tem uma função principal na parte inferior, que chama uma função foo,

510
00:31:07,920 --> 00:31:12,100
e para que é que passa a foo? [Estudante] Um único argumento.

511
00:31:12,100 --> 00:31:15,660
>> Único argumento. Então, argv [1], o que significa que a primeira palavra que o usuário digitou

512
00:31:15,660 --> 00:31:19,150
na linha de comando depois de a.out ou qualquer que seja o programa é chamado.

513
00:31:19,150 --> 00:31:24,920
Então foo, na parte superior, leva em um char *, char *, mas é exatamente o que?

514
00:31:24,920 --> 00:31:28,860
String. Não há nada de novo aqui, e essa seqüência é arbitrariamente sendo chamado de bar.

515
00:31:28,860 --> 00:31:36,090
Nesta linha aqui, char c [12], em uma espécie de semi-técnico Inglês, o que é essa linha está fazendo?

516
00:31:36,090 --> 00:31:40,640
Matriz de -? Caracteres. Dê-me um conjunto de 12 caracteres.

517
00:31:40,640 --> 00:31:44,970
Assim, poderíamos chamar isso de um buffer. É tecnicamente chamado de c, mas um tampão na programação

518
00:31:44,970 --> 00:31:47,890
significa apenas um monte de espaço que você pode colocar algumas coisas dentro

519
00:31:47,890 --> 00:31:49,940
>> Então, por fim, memcpy, não usei antes.

520
00:31:49,940 --> 00:31:52,380
Mas você pode adivinhar o que ele faz. Ele copia memória.

521
00:31:52,380 --> 00:31:58,790
O que ele faz? Bem, aparentemente copia bar, sua entrada, em c,

522
00:31:58,790 --> 00:32:03,420
mas apenas até o comprimento da barra.

523
00:32:03,420 --> 00:32:07,440
Mas há um bug aqui.

524
00:32:07,440 --> 00:32:14,500
Ok, então, tecnicamente, deve realmente fazer strlen (bar) x sizeof (char), isso é correto.

525
00:32:14,500 --> 00:32:17,920
Mas, no pior caso aqui, vamos supor que isso é - assim, tudo bem.

526
00:32:17,920 --> 00:32:23,760
Então há dois bugs. Então, sizeof (char), tudo bem, vamos fazer isso um pouco mais.

527
00:32:23,760 --> 00:32:28,860
Então, agora ainda há um bug, que é o que?

528
00:32:28,860 --> 00:32:31,630
[Responder Estudante, ininteligível] Verificação >> para quê? Ok, então nós deve verificar

529
00:32:31,630 --> 00:32:35,010
para NULL, porque as coisas ruins acontecem quando o ponteiro é NULL,

530
00:32:35,010 --> 00:32:38,490
Porque você pode acabar indo lá, e você não deve nunca estar indo para NULL

531
00:32:38,490 --> 00:32:40,890
por desreferência-lo com o operador *.

532
00:32:40,890 --> 00:32:45,250
Então, isso é bom, eo que mais estamos fazendo? Logicamente há uma falha aqui também.

533
00:32:45,250 --> 00:32:47,650
[Responder Estudante, ininteligível]

534
00:32:47,650 --> 00:32:51,340
Portanto, verifique se >> argc ≥ 2?

535
00:32:51,340 --> 00:32:54,130
Ok, então há três bugs neste programa.

536
00:32:54,130 --> 00:33:00,080
Nós não estamos verificando se o usuário realmente digitou alguma coisa em argv [1], bom.

537
00:33:00,080 --> 00:33:02,240
Então, qual é o bug terceiro? Sim?

538
00:33:02,240 --> 00:33:04,420
[Responder Estudante, ininteligível] >> Boa.

539
00:33:04,420 --> 00:33:09,590
Então, vamos checar um cenário. Nós implicitamente verificado não copie mais memória

540
00:33:09,590 --> 00:33:12,800
que excede o comprimento da barra.

541
00:33:12,800 --> 00:33:15,720
Então, se a string que o usuário digitou é de 10 caracteres,

542
00:33:15,720 --> 00:33:18,260
isto está dizendo: "Só copiar 10 caracteres.

543
00:33:18,260 --> 00:33:21,140
E está tudo bem, mas e se o usuário digitou uma palavra no prompt

544
00:33:21,140 --> 00:33:29,360
como uma palavra de 20 caracteres, isto é, dizendo cópia 20 caracteres de bar em que?

545
00:33:29,360 --> 00:33:32,840
c, também conhecido como o nosso buffer, o que significa que você acabou de escrever dados

546
00:33:32,840 --> 00:33:35,950
a 8 locais de bytes que você não possui,

547
00:33:35,950 --> 00:33:38,320
e você não possuí-los no sentido de que você nunca alocados eles.

548
00:33:38,320 --> 00:33:41,190
Portanto, este é o que é geralmente conhecido como o ataque de estouro de buffer,

549
00:33:41,190 --> 00:33:46,650
ou tampão ataque superação, e é ataque no sentido de que se o usuário

550
00:33:46,650 --> 00:33:50,650
ou o programa que está chamando a sua função é fazer isso de forma maliciosa,

551
00:33:50,650 --> 00:33:53,780
o que realmente acontece próximo pode ser muito ruim.

552
00:33:53,780 --> 00:33:55,690
>> Vamos dar uma olhada nesta foto aqui.

553
00:33:55,690 --> 00:33:59,070
Esta imagem representa sua pilha de memória.

554
00:33:59,070 --> 00:34:01,050
E lembrar que cada vez que você chamar uma função,

555
00:34:01,050 --> 00:34:04,520
você tem esse quadro pouco na pilha e depois outro e depois outro e depois outro.

556
00:34:04,520 --> 00:34:07,250
E, até agora, temos apenas um tipo de abstraídas estas longe como retângulos

557
00:34:07,250 --> 00:34:09,380
ou há no conselho ou na tela aqui.

558
00:34:09,380 --> 00:34:12,219
Mas, se aproximar de um desses rectângulos,

559
00:34:12,219 --> 00:34:16,460
quando você chamar uma função foo, verifica-se que há mais na pilha

560
00:34:16,460 --> 00:34:18,739
dentro desse quadro e que retângulo

561
00:34:18,739 --> 00:34:23,370
que apenas x e y e a e b, como fizemos falando sobre swap.

562
00:34:23,370 --> 00:34:25,949
Acontece que há alguns detalhes de nível inferior,

563
00:34:25,949 --> 00:34:27,780
entre eles retornam endereço.

564
00:34:27,780 --> 00:34:33,020
Assim, verifica-se quando principal chama foo, principal tem de informar foo

565
00:34:33,020 --> 00:34:36,760
o endereço principal está na memória do computador.

566
00:34:36,760 --> 00:34:40,659
Porque, caso contrário, logo que foo é feito de execução, tal como neste caso aqui,

567
00:34:40,659 --> 00:34:43,790
uma vez que você chegar a esta estreita cinta encaracolado no final de foo,

568
00:34:43,790 --> 00:34:48,860
como o diabo não foo sabe onde o controle do programa deve ir?

569
00:34:48,860 --> 00:34:52,460
Acontece que a resposta a essa pergunta é em que retângulo vermelho aqui.

570
00:34:52,460 --> 00:34:56,130
Isso representa um ponteiro, e cabe ao computador para armazenar, temporariamente,

571
00:34:56,130 --> 00:35:00,250
sobre a pilha de chamada o endereço da página, de modo que, logo que é feito foo execução,

572
00:35:00,250 --> 00:35:04,110
o computador sabe onde e qual linha principal para voltar.

573
00:35:04,110 --> 00:35:06,900
Ponteiro do quadro salvo se relaciona de forma semelhante a esta.

574
00:35:06,900 --> 00:35:09,620
Char bar * aqui representa o que?

575
00:35:09,620 --> 00:35:14,740
Bem, agora este segmento azul aqui é frame foo, o que é bar?

576
00:35:14,740 --> 00:35:18,300
Ok, então barra é apenas o argumento para a função foo.

577
00:35:18,300 --> 00:35:20,720
>> Portanto, agora estamos de volta para o quadro familiar.

578
00:35:20,720 --> 00:35:22,960
Há mais coisas e mais distrações na tela

579
00:35:22,960 --> 00:35:27,490
mas esse segmento de luz azul é o que estamos desenhando no quadro-negro para algo como swap.

580
00:35:27,490 --> 00:35:31,890
Esse é o quadro para foo ea única coisa em que agora é bar,

581
00:35:31,890 --> 00:35:34,630
que é este parâmetro.

582
00:35:34,630 --> 00:35:39,840
Mas o que mais deve estar na pilha, de acordo com este código aqui?

583
00:35:39,840 --> 00:35:44,280
Char c [12]. Assim, devemos também ver 12 quadrados de memória,

584
00:35:44,280 --> 00:35:46,260
atribuída a uma variável chamada c.

585
00:35:46,260 --> 00:35:48,340
E de fato temos que na tela.

586
00:35:48,340 --> 00:35:51,650
O topo há c [0], e em seguida o autor deste diagrama

587
00:35:51,650 --> 00:35:55,130
não se incomodou desenhar todas as praças, mas há de fato há 12

588
00:35:55,130 --> 00:36:00,120
porque se você olhar no canto inferior direito, c [11], se você contar de 0, é o 12 bytes tais.

589
00:36:00,120 --> 00:36:06,190
Mas aqui está o problema: Em que direção está crescendo c?

590
00:36:06,190 --> 00:36:10,390
Tipo de cima para baixo, certo? Se ele começa na parte superior e aumenta para o fundo,

591
00:36:10,390 --> 00:36:13,480
não se parece com nós mesmos deixamos pista muito aqui.

592
00:36:13,480 --> 00:36:15,320
Nós tipo de pintado nos em um canto,

593
00:36:15,320 --> 00:36:20,210
e que c [11] é até contra bar, que fica à direita contra o ponteiro quadro de pilha,

594
00:36:20,210 --> 00:36:23,800
que é até contra o endereço de retorno, não há mais espaço.

595
00:36:23,800 --> 00:36:26,100
Então, qual é a implicação, então, se você estragar,

596
00:36:26,100 --> 00:36:30,460
e você tenta ler 20 bytes em um buffer de 12 bytes?

597
00:36:30,460 --> 00:36:33,460
Onde estão os 8 bytes adicionais indo?

598
00:36:33,460 --> 00:36:36,370
Dentro de tudo o resto, alguns dos quais é super importante.

599
00:36:36,370 --> 00:36:40,480
E a coisa mais importante, potencialmente, é a caixa vermelha lá, endereço de retorno.

600
00:36:40,480 --> 00:36:44,720
Porque acho que você é acidentalmente ou adversarially

601
00:36:44,720 --> 00:36:48,040
substituir esses 4 bytes, que endereço do ponteiro,

602
00:36:48,040 --> 00:36:53,190
não apenas com o lixo, mas com um número que acontece para representar um endereço real na memória?

603
00:36:53,190 --> 00:36:55,930
Qual é a implicaiton, logicamente?

604
00:36:55,930 --> 00:36:59,080
[Respostas dos alunos, ininteligível] >> Exatamente. Quando retorna foo

605
00:36:59,080 --> 00:37:03,560
e hits que chaveta, o programa vai continuar não voltar ao principal,

606
00:37:03,560 --> 00:37:08,320
ele vai voltar a qualquer endereço em que é caixa vermelha.

607
00:37:08,320 --> 00:37:11,560
>> Agora, no caso do registo do software contornar,

608
00:37:11,560 --> 00:37:14,400
qual é o endereço que está sendo retornado para a função é

609
00:37:14,400 --> 00:37:18,820
que normalmente é chamado depois que você paga pelo software e inserido o seu código de registro?

610
00:37:18,820 --> 00:37:23,160
Você poderia classificar de enganar o computador em não ir aqui, mas em vez disso, vai-se aqui.

611
00:37:23,160 --> 00:37:27,950
Ou, se você é realmente inteligente, um adversário pode realmente digitar no teclado,

612
00:37:27,950 --> 00:37:32,500
por exemplo, não uma palavra real, e não de 20 personagens, mas suponho que ele ou ela

613
00:37:32,500 --> 00:37:36,200
em alguns tipos de caracteres que representam o código?

614
00:37:36,200 --> 00:37:38,860
E não vai ser de código C, que vai ser os personagens

615
00:37:38,860 --> 00:37:42,920
que representam códigos binários de máquinas, 0 e 1 a.

616
00:37:42,920 --> 00:37:46,740
Mas suponha que eles são espertos o suficiente para fazer isso, de alguma forma, colar no prompt GetString

617
00:37:46,740 --> 00:37:49,460
algo que é, essencialmente, o código compilado,

618
00:37:49,460 --> 00:37:56,900
e os últimos 4 bytes substituir esse endereço de retorno, e que endereço se que a entrada de fazer?

619
00:37:56,900 --> 00:38:01,860
Ele armazena neste retângulo vermelho o endereço do primeiro byte do buffer.

620
00:38:01,860 --> 00:38:04,270
Então você tem que ser realmente inteligente, e isso é um monte de tentativa e erro

621
00:38:04,270 --> 00:38:08,500
para pessoas ruins lá fora, mas se você pode descobrir o quão grande é este tampão,

622
00:38:08,500 --> 00:38:12,170
de tal forma que os bytes últimos na entrada que você fornecer para o programa

623
00:38:12,170 --> 00:38:15,970
Acontece que equivale ao endereço de início do seu tampão,

624
00:38:15,970 --> 00:38:22,270
você pode fazer isso. Se dizemos, normalmente, Olá, e \ 0, que é o que acaba no buffer.

625
00:38:22,270 --> 00:38:27,860
Mas se nós somos mais inteligentes, e preenchemos o buffer com o que vamos chamar genericamente código de ataque,

626
00:38:27,860 --> 00:38:31,920
A, A, A, A: Ataque, ataque, ataque, ataque, onde este é apenas algo que faz algo ruim.

627
00:38:31,920 --> 00:38:35,190
Bem, o que acontece se você é realmente inteligente, você pode fazer isso:

628
00:38:35,190 --> 00:38:41,740
Na caixa vermelha aqui é uma seqüência de números: 80, CO, 35, 08.

629
00:38:41,740 --> 00:38:44,890
Note que que coincide com o número que está aqui em cima.

630
00:38:44,890 --> 00:38:47,280
É na ordem inversa, mas mais sobre isso em outro momento.

631
00:38:47,280 --> 00:38:51,430
Note que este endereço de retorno foi deliberadamente alterado

632
00:38:51,430 --> 00:38:54,970
para igualar o endereço aqui, não o endereço do principal.

633
00:38:54,970 --> 00:39:00,170
Então, se o cara mau é super inteligente, ele ou ela vai incluir nesse código de ataque

634
00:39:00,170 --> 00:39:02,890
algo como, 'Apagar todos os arquivos do usuário. "

635
00:39:02,890 --> 00:39:06,320
Ou "copiar as senhas", ou "Criar uma conta de usuário que eu possa entrar em '.

636
00:39:06,320 --> 00:39:10,130
Qualquer coisa, e isso é tanto perigo quanto o poder de C.

637
00:39:10,130 --> 00:39:12,900
Porque você tem acesso a memória através de ponteiros

638
00:39:12,900 --> 00:39:15,950
e, portanto, você pode escrever o que quiser na memória de um computador.

639
00:39:15,950 --> 00:39:19,290
Você pode fazer um computador fazer o que quiser, simplesmente

640
00:39:19,290 --> 00:39:22,780
tendo que pular dentro do seu próprio espaço de memória.

641
00:39:22,780 --> 00:39:27,230
E assim, até hoje, tantos programas e sites de tantos que estão comprometidas

642
00:39:27,230 --> 00:39:29,730
resumem-se a pessoas que tomam vantagem disso.

643
00:39:29,730 --> 00:39:32,510
E isso pode parecer um ataque super-sofisticado,

644
00:39:32,510 --> 00:39:34,220
mas nem sempre é iniciado assim.

645
00:39:34,220 --> 00:39:36,770
>> A realidade é que o que as pessoas ruins normalmente fazer é,

646
00:39:36,770 --> 00:39:41,470
se é um programa em uma linha de comando ou um programa gráfico ou um site,

647
00:39:41,470 --> 00:39:43,290
é que você acabou de começar a fornecer um absurdo.

648
00:39:43,290 --> 00:39:46,940
Você digita uma palavra muito grande no campo de pesquisa e tecle enter,

649
00:39:46,940 --> 00:39:49,030
e esperar para ver se as falhas do site.

650
00:39:49,030 --> 00:39:53,270
Ou você esperar para ver se o programa se manifesta alguma mensagem de erro.

651
00:39:53,270 --> 00:39:55,480
Porque, se você tiver sorte, como o cara mau,

652
00:39:55,480 --> 00:39:59,610
e você fornecer algumas informações louco que trava o programa,

653
00:39:59,610 --> 00:40:02,280
isso significa que o programador não antecipou o seu mau comportamento

654
00:40:02,280 --> 00:40:05,420
o que significa que você pode provavelmente, com bastante esforço,

655
00:40:05,420 --> 00:40:09,870
julgamento suficiente e erro, descobrir como travar um ataque mais preciso.

656
00:40:09,870 --> 00:40:15,900
Assim como uma grande parte de segurança não é apenas evitar estes ataques completamente, mas detectá-los

657
00:40:15,900 --> 00:40:20,250
e realmente olhar para os logs e ver o que as pessoas loucas entradas digitadas em seu site.

658
00:40:20,250 --> 00:40:26,040
Que termos de pesquisa digitados pessoas em seu site, na esperança de transbordar alguns buffer?

659
00:40:26,040 --> 00:40:28,900
E isso tudo se resume a os princípios simples do que é uma matriz,

660
00:40:28,900 --> 00:40:32,510
eo que isso significa para alocar e usar a memória?

661
00:40:32,510 --> 00:40:34,920
E, com relação a isso, também, é isso.

662
00:40:34,920 --> 00:40:37,520
>> Então vamos apenas olhar para dentro de um disco rígido novamente.

663
00:40:37,520 --> 00:40:40,190
Então, você se lembra de uma ou duas semanas atrás que quando você arrastar os arquivos

664
00:40:40,190 --> 00:40:45,470
a sua lixeira ou lata de lixo, o que acontece?

665
00:40:45,470 --> 00:40:47,850
[Estudante] Nada. >> Sim, absolutamente nada. Eventualmente, se você executar baixa

666
00:40:47,850 --> 00:40:51,370
espaço em disco, Windows ou Mac OS vai começar a apagar arquivos para você.

667
00:40:51,370 --> 00:40:53,670
Mas se você arrastar alguma coisa lá dentro, então não é de todo segura.

668
00:40:53,670 --> 00:40:56,550
Todo o seu membro do amigo companheiro de quarto, ou a família tem que fazer é clicar duas vezes, e pronto.

669
00:40:56,550 --> 00:40:59,720
Há todos os arquivos esboçado que você tentou excluir.

670
00:40:59,720 --> 00:41:02,840
Assim, a maioria de nós, pelo menos, saber que você tem com o botão direito ou clique

671
00:41:02,840 --> 00:41:05,320
e lixo o vazio, ou algo assim.

672
00:41:05,320 --> 00:41:07,900
Mas, mesmo assim, que não chega a fazer o truque.

673
00:41:07,900 --> 00:41:11,340
Porque o que acontece quando você tem um arquivo em seu disco rígido

674
00:41:11,340 --> 00:41:14,590
que representa algum documento ou alguma palavra JPEG?

675
00:41:14,590 --> 00:41:18,820
E isso representa o seu disco rígido, e vamos dizer que esta faixa aqui representa o arquivo,

676
00:41:18,820 --> 00:41:21,640
e é composto de um monte de 0 e 1 do.

677
00:41:21,640 --> 00:41:25,470
O que acontece quando você não só arrastar o arquivo para a lixeira ou lixeira,

678
00:41:25,470 --> 00:41:30,390
mas também esvaziá-la?

679
00:41:30,390 --> 00:41:32,820
Espécie de nada. Não há absolutamente nada agora.

680
00:41:32,820 --> 00:41:37,630
Agora é só nada, porque alguma coisa acontece na forma de tabela.

681
00:41:37,630 --> 00:41:41,170
Portanto, há uma espécie de banco de dados ou tabela dentro da memória de um computador

682
00:41:41,170 --> 00:41:44,470
que, essencialmente, tem uma coluna de nomes de arquivos,

683
00:41:44,470 --> 00:41:50,550
e uma coluna para o local do arquivo, onde este pode ser local 123, apenas um número aleatório.

684
00:41:50,550 --> 00:41:58,270
Assim, poderíamos ter algo como x.jpg e localização 123.

685
00:41:58,270 --> 00:42:02,870
E o que acontece, então, quando você esvaziar o seu lixo?

686
00:42:02,870 --> 00:42:06,720
Que vai embora. Mas o que não vai embora é o de 0 e 1.

687
00:42:06,720 --> 00:42:09,690
>> Então, o que, então, a conexão com PSet 4?

688
00:42:09,690 --> 00:42:13,460
Bem, com pset 4, só porque temos acidentalmente apagados

689
00:42:13,460 --> 00:42:15,890
o cartão de memória flash compacto que tinha todas essas fotos,

690
00:42:15,890 --> 00:42:18,710
ou apenas porque pela má sorte tornou-se corrompido,

691
00:42:18,710 --> 00:42:21,170
não significa que a 0 e 1 não ainda estão lá.

692
00:42:21,170 --> 00:42:23,920
Talvez alguns deles são perdidos porque algo foi corrompido

693
00:42:23,920 --> 00:42:26,530
no sentido de que alguns de 0 tornou-se 1 e tornou-se um 0.

694
00:42:26,530 --> 00:42:30,460
Coisas ruins podem acontecer por causa do software de buggy ou hardware defeituoso.

695
00:42:30,460 --> 00:42:33,510
Mas muitos desses bits, talvez até 100% deles ainda estão lá,

696
00:42:33,510 --> 00:42:38,330
é só que o computador ou a câmera não sabe onde JPEG 1 começou

697
00:42:38,330 --> 00:42:41,660
e onde JPEG 2 começou, mas se você, programador,

698
00:42:41,660 --> 00:42:45,800
sabe, com um pouco de habilidade, onde os JPEGs são ou o que eles se parecem,

699
00:42:45,800 --> 00:42:49,570
você pode analisar o de 0 e 1, e dizer, 'Ooh. JPEG. Ooh, JPEG.

700
00:42:49,570 --> 00:42:52,830
Você pode escrever um programa com essencialmente apenas um for ou while

701
00:42:52,830 --> 00:42:56,100
que recupera todos e cada um desses arquivos.

702
00:42:56,100 --> 00:42:59,360
Assim, a lição, então, é começar a "segurança" de apagar seus arquivos

703
00:42:59,360 --> 00:43:01,720
se você gostaria de evitar este completamente. Sim?

704
00:43:01,720 --> 00:43:06,940
[Pergunta do estudante, ininteligível]

705
00:43:06,940 --> 00:43:11,150
>> Tenha mais memória do que você fez antes -

706
00:43:11,150 --> 00:43:14,790
Oh! Boa pergunta. Então, por que, então, depois de esvaziar a lixeira,

707
00:43:14,790 --> 00:43:18,300
se o seu computador te dizer que você tem mais espaço livre do que você fez antes?

708
00:43:18,300 --> 00:43:22,450
Em poucas palavras, porque ele está mentindo. Mais tecnicamente, você tem mais espaço.

709
00:43:22,450 --> 00:43:26,720
Porque agora você disse, você pode colocar outras coisas em que o arquivo era uma vez,

710
00:43:26,720 --> 00:43:28,930
mas isso não significa que os bits estão indo embora,

711
00:43:28,930 --> 00:43:33,070
e isso não significa que os bits estão sendo alterados todos os 0, por exemplo, para sua proteção.

712
00:43:33,070 --> 00:43:37,520
Por outro lado, se você "seguramente" apagar arquivos ou destruir fisicamente o dispositivo,

713
00:43:37,520 --> 00:43:40,810
que realmente é o único caminho, às vezes, em torno disso.

714
00:43:40,810 --> 00:43:45,300
Então, por que não deixamos em que a nota semi-assustador, e vamos vê-lo na segunda-feira.

715
00:43:45,300 --> 00:43:52,810
CS50.TV