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
Hoxe e esta semana, presentamos un pouco do mundo da ciencia forense

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

7
00:00:14,850 --> 00:00:18,480
Hoxe será unha charla abreviada porque hai un evento especial aquí despois.

8
00:00:18,480 --> 00:00:21,940
Entón, imos dar un ollo e provocar estudantes e pais de hoxe

9
00:00:21,940 --> 00:00:24,600
con algunhas das cousas que son no horizonte.

10
00:00:24,600 --> 00:00:29,050
>> Entre eles, a partir do luns, terá un pouco máis compañeiros.

11
00:00:29,050 --> 00:00:32,980
EDX, Harvard e MIT nova iniciativa en liña para OpenCourseWare e máis,

12
00:00:32,980 --> 00:00:36,730
está lanzando no campus de Harvard, o luns, o que significa que o luns

13
00:00:36,730 --> 00:00:40,930
terá, a partir de última conta, 86 mil compañeiros adicional

14
00:00:40,930 --> 00:00:43,680
que vai seguir xunto con conferencias CS50 e seccións

15
00:00:43,680 --> 00:00:45,890
e orientacións e conxuntos de problemas.

16
00:00:45,890 --> 00:00:51,870
E, como parte diso, vai converterse membros da clase inaugural do CS50 e agora CS50x.

17
00:00:51,870 --> 00:00:56,150
Como parte deste momento, entender que haberá algunhas upsides tamén.

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

19
00:01:00,620 --> 00:01:03,820
basta dicir que, aínda que teñamos 108 TFS e CAS,

20
00:01:03,820 --> 00:01:07,560
non é así a mellor relación profesor-alumno, unha vez que alcanzou 80.000 dos alumnos.

21
00:01:07,560 --> 00:01:09,830
Non imos ser problema para moitos clasificación define manualmente

22
00:01:09,830 --> 00:01:13,050
así introducido esta semana no conxunto de problemas será CS50 Check,

23
00:01:13,050 --> 00:01:15,410
que vai ser unha utilidade de liña de comandos dentro do aparello

24
00:01:15,410 --> 00:01:17,880
que vai ter unha vez que actualiza-lo máis tarde este fin de semana.

25
00:01:17,880 --> 00:01:21,030
Vai ser capaz de executar un comando, check50, no seu propio pset,

26
00:01:21,030 --> 00:01:24,770
e vai ter un feedback instantáneo para saber se o seu programa é correcta ou incorrecta

27
00:01:24,770 --> 00:01:27,980
acordo coas especificacións de deseño diferentes que nós fornecen.

28
00:01:27,980 --> 00:01:30,310
Máis sobre iso na especificación do conxunto de problemas.

29
00:01:30,310 --> 00:01:34,220
Os compañeiros CS50x vai usar isto tamén.

30
00:01:34,220 --> 00:01:36,170
>> Set problema 4 é todo sobre a ciencia forense,

31
00:01:36,170 --> 00:01:38,630
e este pset estaba realmente inspirado por algunhas cousas na vida real

32
00:01:38,630 --> 00:01:41,210
polo que, cando estaba na facultade eu internados por un tempo

33
00:01:41,210 --> 00:01:45,270
na Fiscalía do Condado de Middlesex District está facendo o traballo forense

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

35
00:01:47,660 --> 00:01:50,280
O que isto representa, como eu creo que eu mencionen algunhas semanas pasado,

36
00:01:50,280 --> 00:01:52,720
é a policía do Estado de masa ou outros entraba,

37
00:01:52,720 --> 00:01:56,150
eles ían deixar as cousas como discos duros, CDs e disquetes e similares,

38
00:01:56,150 --> 00:01:58,770
e, a continuación, o obxectivo da oficina forense foi comprobar

39
00:01:58,770 --> 00:02:01,470
se houbo ou non era evidencia de calquera tipo.

40
00:02:01,470 --> 00:02:04,730
Esta foi a Unidade de Investigacións Especiais, por iso era delito de colo branco.

41
00:02:04,730 --> 00:02:10,949
Era unha especie máis preocupante de crimes, calquera cousa que involucre algún tipo de comunicación dixital.

42
00:02:10,949 --> 00:02:16,450
Acontece que non que moitas persoas escriben un e-mail dicindo: "Eu fixen iso."

43
00:02:16,450 --> 00:02:20,490
Entón, moitas veces, estas investigacións forenses non apareceu todos os froitos que moito,

44
00:02:20,490 --> 00:02:22,820
pero ás veces as persoas escriben correo-e dese tipo.

45
00:02:22,820 --> 00:02:25,240
Entón, ás veces, os esforzos foron recompensados.

46
00:02:25,240 --> 00:02:31,210
>> Pero, para levar ata este pset forense, estaremos introducindo no pset4 un pouco de gráficos.

47
00:02:31,210 --> 00:02:35,410
Probablemente levar estas cousas para concedida - JPEGs, GIFs e outros - estes días.

48
00:02:35,410 --> 00:02:38,320
Pero se realmente pensa sobre iso, unha imaxe, así como o rostro de Rob,

49
00:02:38,320 --> 00:02:41,270
pode ser modelada como unha secuencia de puntos ou píxeles.

50
00:02:41,270 --> 00:02:43,380
No caso da cara de Rob, hai todo tipo de cores,

51
00:02:43,380 --> 00:02:46,760
e comezamos a ver os puntos individuais, tamén coñecidos como píxeles,

52
00:02:46,760 --> 00:02:48,610
unha vez que comezou a facer zoom in

53
00:02:48,610 --> 00:02:54,660
Pero simplificar o mundo un pouco e dicir que iso aquí é Rob en branco e negro,

54
00:02:54,660 --> 00:02:57,490
para representar o branco e negro, podemos usar só binario.

55
00:02:57,490 --> 00:03:01,660
E se imos usar binario, 1 ou 0, podemos expresar esta mesma imaxe

56
00:03:01,660 --> 00:03:06,140
de rostro sorrinte de Rob con ese patrón de bits.

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

58
00:03:12,100 --> 00:03:16,150
E por iso non é un gran salto a continuación, comezar a falar fotografías de cores,

59
00:03:16,150 --> 00:03:18,600
cousas que vería no Facebook ou levar unha cámara dixital.

60
00:03:18,600 --> 00:03:21,410
Pero, certamente, cando se trata de cores, ten que máis bits.

61
00:03:21,410 --> 00:03:25,690
É bastante común no mundo das fotografías é usar unha cor non-bit,

62
00:03:25,690 --> 00:03:29,560
como iso suxire, pero cor de 24 bits, onde realmente obter millóns de cores.

63
00:03:29,560 --> 00:03:32,250
Así como no caso cando o zoom no ollo do Rob,

64
00:03:32,250 --> 00:03:36,370
que era un número calquera de millóns de distintas posibilidades de cores.

65
00:03:36,370 --> 00:03:39,040
Entón, nós imos introducir esta no Conxunto Problema 4, así como no paso a paso,

66
00:03:39,040 --> 00:03:43,370
que será hoxe ás 3:30 en vez de 2:30 habitual por mor da charla do venres aquí.

67
00:03:43,370 --> 00:03:46,620
Pero o vídeo estará en liña mañá como de costume.

68
00:03:46,620 --> 00:03:48,820
>> Tamén imos presenta-lo a outro formato de arquivo.

69
00:03:48,820 --> 00:03:51,270
Este é deliberadamente quería ollar intimidador en principio,

70
00:03:51,270 --> 00:03:55,670
pero iso é só unha documentación algunha para unha struct C.

71
00:03:55,670 --> 00:03:58,940
Acontece que hai anos a Microsoft axudou a popularizar este formato

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

73
00:04:05,150 --> 00:04:10,150
que foi usado por algún tempo e, ás veces aínda para fondos de pantalla en escritorios.

74
00:04:10,150 --> 00:04:14,760
Se pensas que volta para o Windows XP e os outeiros eo ceo azul,

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

76
00:04:17,170 --> 00:04:19,959
Bitmaps son divertido para nós, porque eles teñen un pouco máis de complexidade.

77
00:04:19,959 --> 00:04:22,610
Non é tan sinxelo coma esta reixa de 0s e 1s.

78
00:04:22,610 --> 00:04:27,510
En vez diso, ten cousas como unha cabeceira no inicio dun arquivo.

79
00:04:27,510 --> 00:04:31,990
Polo tanto, noutras palabras, dentro dun arquivo bmp. É un monte de 0s e 1s,

80
00:04:31,990 --> 00:04:34,910
pero hai algún adicional 0s e 1s alí.

81
00:04:34,910 --> 00:04:38,220
E resulta que o que probablemente xa un dato adquirido hai anos -

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

83
00:04:45,170 --> 00:04:48,480
que está familiarizado con - o que iso significa mesmo ser un formato de arquivo,

84
00:04:48,480 --> 00:04:52,480
porque ao final do día, todos estes ficheiros usan teñen só 0 e 1.

85
00:04:52,480 --> 00:04:56,810
E quizais os 0s e 1s representan ABC través ASCII ou similar,

86
00:04:56,810 --> 00:04:58,820
pero ao final do día, aínda é só 0s e 1s.

87
00:04:58,820 --> 00:05:02,100
Así, os seres humanos só ocasionalmente deciden inventar un novo formato de arquivo

88
00:05:02,100 --> 00:05:06,420
onde padronizar o que patróns de bits vai realmente significar.

89
00:05:06,420 --> 00:05:09,220
E, neste caso aquí, o persoal que proxectou o formato de arquivo bitmap

90
00:05:09,220 --> 00:05:15,620
dixo que o primeiro byte nun arquivo bitmap, como denotado por 0 compensado alí,

91
00:05:15,620 --> 00:05:18,940
alí vai ser un enigmaticamente chamado bfType variable chamada,

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

93
00:05:23,080 --> 00:05:27,700
Pode deducir quizais da segunda liña que compensar 2, número de bytes 2,

94
00:05:27,700 --> 00:05:33,740
ten un nivel de 0s e 1s que representa o que? O tamaño de algo.

95
00:05:33,740 --> 00:05:35,310
E vai de alí.

96
00:05:35,310 --> 00:05:37,410
Entón, o Conxunto Problema 4, vai ser orientado por algunhas destas cousas.

97
00:05:37,410 --> 00:05:39,520
Non vai acabar se preocupar con todos eles.

98
00:05:39,520 --> 00:05:47,510
Pero teña en conta que comeza a estar interesante en torno a byte 54: rgbtBlue, verde e vermello.

99
00:05:47,510 --> 00:05:52,110
Se vostede xa escoitou a sigla RGB - vermello, verde, azul - esta é unha referencia a ese

100
00:05:52,110 --> 00:05:54,610
pois verifícase que pode pintar todas as cores do arco da vella

101
00:05:54,610 --> 00:05:58,180
cunha combinación de vermello e azul e verde.

102
00:05:58,180 --> 00:06:03,320
E, de feito, os pais no cuarto pode recordar algúns dos primeiros proxectores.

103
00:06:03,320 --> 00:06:05,890
Estes días, só ve unha luz brillante que sae dunha lente,

104
00:06:05,890 --> 00:06:09,800
pero volta o día en que tivo a lente vermella, lento azul, ea lente verde,

105
00:06:09,800 --> 00:06:13,380
e, xuntos, destinado a unha pantalla e formou unha imaxe en cor.

106
00:06:13,380 --> 00:06:16,270
E, moitas veces, escolas de ensino medio e escolas secundarias tería aquelas lentes

107
00:06:16,270 --> 00:06:19,720
levemente torto, para que eran unha especie de ver imaxes dobres ou triplas.

108
00:06:19,720 --> 00:06:24,100
Pero esa era a idea. Tiña luz vermella, verde e azul pintar un cadro.

109
00:06:24,100 --> 00:06:26,590
E ese mesmo principio é usado en computadoras.

110
00:06:26,590 --> 00:06:30,230
>> Así, entre os retos, a continuación, para que en Problema Set 4 van ser algunhas cousas.

111
00:06:30,230 --> 00:06:34,800
Un deles é para redimensionar unha imaxe, para tomar un patrón de 0s e 1s,

112
00:06:34,800 --> 00:06:40,200
descubrir cal anacos de 0s e 1s representan o que unha estrutura como esta,

113
00:06:40,200 --> 00:06:43,630
e entón descubrir como replicar os píxeles - os vermellos, os azuis, os verdes -

114
00:06:43,630 --> 00:06:46,660
dentro de xeito que, cando unha imaxe queda así, inicialmente,

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

116
00:06:49,210 --> 00:06:53,640
Entre os outros desafíos que tamén vai ser que vai ser entregado unha imaxe forense

117
00:06:53,640 --> 00:06:56,030
dun arquivo real dunha cámara dixital.

118
00:06:56,030 --> 00:06:58,960
E nesa cámara, era unha vez, foron unha morea de fotos.

119
00:06:58,960 --> 00:07:03,760
O problema é que accidentalmente borrados ou tivo a imaxe corrupta dalgún modo.

120
00:07:03,760 --> 00:07:05,750
Cousas malas suceden con cámaras dixitais.

121
00:07:05,750 --> 00:07:09,150
E, así, axiña copiado todo o off 0s e 1s que a tarxeta para ti,

122
00:07:09,150 --> 00:07:13,610
garda-los todos nun arquivo grande, e despois imos entrega-los a vostede no conxunto de problemas 4

123
00:07:13,610 --> 00:07:19,320
de xeito que podes escribir un programa en C co cal se recuperar todas esas JPEGs, idealmente.

124
00:07:19,320 --> 00:07:23,330
E ocorre que JPEGs, aínda que sexan un pouco de un formato de ficheiro complexo -

125
00:07:23,330 --> 00:07:26,360
son moito máis complexos do que este sorriso aquí -

126
00:07:26,360 --> 00:07:31,160
verifícase que todos os JPEG iníciase cos mesmos estándares de 0s e 1s.

127
00:07:31,160 --> 00:07:35,630
Entón, usando, en última análise, un loop while ou un loop for ou similar,

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

129
00:07:38,880 --> 00:07:43,150
e cada vez que ver o patrón especial que está definido na especificación conxunto de problemas,

130
00:07:43,150 --> 00:07:47,880
pode asumir aquí é, con gran probabilidade, o inicio dun JPEG.

131
00:07:47,880 --> 00:07:51,230
E así que atopar o mesmo patrón algún número de bytes

132
00:07:51,230 --> 00:07:55,430
ou kilobytes ou megabytes máis tarde, pode asumir aquí é un JPEG segundo,

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

134
00:07:57,380 --> 00:08:01,370
Deixe-me deixar de ler este ficheiro en primeiro lugar, comezar a escribir este novo,

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

136
00:08:06,310 --> 00:08:09,270
E se non é 50 JPEGs, ten un pouco de un loop.

137
00:08:09,270 --> 00:08:12,490
Se vostede ten un número infinito de JPEGs, ten un loop infinito.

138
00:08:12,490 --> 00:08:14,910
De xeito que tamén será moi caso común.

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

140
00:08:16,600 --> 00:08:21,310
>> 0 Quiz detrás de nós, entender por meu correo-e que, invariablemente, hai persoas que son ambos felices,

141
00:08:21,310 --> 00:08:23,640
especie de neutro, e triste ao redor cuestionario tempo 0.

142
00:08:23,640 --> 00:08:26,800
E por favor, chegar a min, a cabeza TF Zamyla, a súa propia TF,

143
00:08:26,800 --> 00:08:31,180
ou un dos CAs que vostede sabe, se desexa discutir como as cousas correron.

144
00:08:31,180 --> 00:08:35,539
>> Entón, para impresionar os pais aquí na sala, o que é a biblioteca CS50?

145
00:08:36,429 --> 00:08:40,390
[Risas] Bo traballo.

146
00:08:40,390 --> 00:08:48,340
¿Que é a biblioteca CS50? Si >> [Alumno] É un conxunto pre-escritura de código [inaudível]

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

148
00:08:49,750 --> 00:08:53,240
É un conxunto de pre-escritura de código que o persoal escribiu, ofrecemos a vostede,

149
00:08:53,240 --> 00:08:55,030
que ofrece algunhas funcións comúns,

150
00:08:55,030 --> 00:08:59,020
cousas como me unha corda, me un int - todas as funcións que están listados aquí.

151
00:08:59,020 --> 00:09:02,260
>> A partir de agora, comezamos a realmente tomar esas Rodas pequenas.

152
00:09:02,260 --> 00:09:05,050
Nós imos comezar a tomar unha serie de ti,

153
00:09:05,050 --> 00:09:08,870
que recordo era só un sinónimo para o tipo de datos real? >> [Varios alumnos] char *.

154
00:09:08,870 --> 00:09:12,730
* Char. Para os pais, que foi, probablemente, [son fai whooshing]. Isto é bo.

155
00:09:12,730 --> 00:09:17,550
* Char imos comezar a ver na pantalla todo o máis que podemos eliminar secuencia do noso vocabulario,

156
00:09:17,550 --> 00:09:19,730
polo menos cando se trata de que realmente escribir código.

157
00:09:19,730 --> 00:09:22,840
Do mesmo xeito, nós imos deixar de usar algunhas desas funcións tanto

158
00:09:22,840 --> 00:09:25,280
porque os nosos programas están indo para obter máis sofisticado.

159
00:09:25,280 --> 00:09:28,480
En vez de só escribir programas que están alí cun chiscar ventá,

160
00:09:28,480 --> 00:09:31,870
á espera de que o usuario escriba algo, terá entrada dende outro sitio.

161
00:09:31,870 --> 00:09:35,490
Por exemplo, vai leva-los a partir dunha serie de bits no disco duro local.

162
00:09:35,490 --> 00:09:38,580
Vai en vez leva-los no futuro a partir dunha conexión de rede,

163
00:09:38,580 --> 00:09:40,230
algún sitio en algún lugar.

164
00:09:40,230 --> 00:09:44,110
>> Entón, imos pelar esa capa por primeira vez e tirar para arriba o Appliance CS50

165
00:09:44,110 --> 00:09:49,010
e este ficheiro chamado cs50.h, o que ten # incluíndo por semanas,

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

167
00:09:51,140 --> 00:09:54,430
O inicio do ficheiro en azul é só unha morea de comentarios:

168
00:09:54,430 --> 00:09:57,050
información sobre a garantía e licenzas.

169
00:09:57,050 --> 00:09:59,050
Esta é unha especie de paradigma común en software

170
00:09:59,050 --> 00:10:01,580
porque unha morea de software nos días de hoxe é o que se chama de código aberto,

171
00:10:01,580 --> 00:10:05,220
o que significa que alguén teña escrito o código e tornouse dispoñible gratuitamente

172
00:10:05,220 --> 00:10:10,470
non só para executar e para usar, pero para realmente ler e modificar e integrar no seu propio traballo.

173
00:10:10,470 --> 00:10:14,660
Entón é iso que está a usar, o software de código aberto, aínda que dunha forma moi pequena.

174
00:10:14,660 --> 00:10:18,560
Se rolar para abaixo tras os comentarios, pero imos comezar a ver algunhas cousas máis familiares.

175
00:10:18,560 --> 00:10:25,010
Aviso arriba aquí que o arquivo cs50.h inclúe un conxunto de ficheiros de cabeceira.

176
00:10:25,010 --> 00:10:28,560
A maioría destes, non vimos antes, pero un é familiar.

177
00:10:28,560 --> 00:10:32,270
Cal destes vimos, aínda que brevemente, ata agora? >> [Alumno] biblioteca estándar.

178
00:10:32,270 --> 00:10:35,810
Si, biblioteca estándar. stdlib.h ten malloc.

179
00:10:35,810 --> 00:10:38,320
Unha vez que comezamos a falar sobre distribución dinámica de memoria,

180
00:10:38,320 --> 00:10:41,650
que imos volver para a próxima semana, así, comezamos incluíndo o arquivo.

181
00:10:41,650 --> 00:10:46,640
Acontece que bool e certo e falso en realidade, non existe en C, por si só

182
00:10:46,640 --> 00:10:49,440
a menos que inclúa este ficheiro aquí.

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

184
00:10:52,710 --> 00:10:55,620
de modo que pode empregar a noción de un. bool, verdadeiro ou falso

185
00:10:55,620 --> 00:10:58,620
Sen iso, tería que clasificar de finxir e utilizar un int

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

187
00:11:02,610 --> 00:11:07,150
Se rolar máis, aquí é a nosa definición dunha cadea.

188
00:11:07,150 --> 00:11:11,390
Acontece que, como xa dixen antes, que esta estrela é onde realmente non importa.

189
00:11:11,390 --> 00:11:13,720
Pode até ter todo o espazo ao redor.

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

191
00:11:16,740 --> 00:11:18,620
que a estrela ten que ver co tipo,

192
00:11:18,620 --> 00:11:21,700
pero enténdese tan común, se non un pouco máis común,

193
00:11:21,700 --> 00:11:24,430
é poñer-lo alí, pero funcionalmente é a mesma cousa.

194
00:11:24,430 --> 00:11:27,720
Pero agora, se lermos máis abaixo, imos dar un ollo a GetInt

195
00:11:27,720 --> 00:11:32,190
porque usamos que, se cadra, antes de máis nada neste semestre.

196
00:11:32,190 --> 00:11:37,440
Aquí está GetInt. Isto é o que? >> [Alumno] Un prototipo. >> Este é só un prototipo.

197
00:11:37,440 --> 00:11:41,410
Moitas veces, hai que poñer prototipos arriba da nosa. Arquivos c,

198
00:11:41,410 --> 00:11:46,690
pero tamén pode poñer prototipos en arquivos de cabeceira, arquivos. h, como esta aquí

199
00:11:46,690 --> 00:11:50,840
de xeito que cando escribe algunhas funcións que quere que outras persoas para ser capaz de utilizar,

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

201
00:11:53,550 --> 00:11:57,040
non só aplicar as súas funcións en algo así como cs50.c,

202
00:11:57,040 --> 00:12:02,790
tamén poñer os prototipos non na parte superior do ficheiro, pero na parte superior de un arquivo de cabeceira.

203
00:12:02,790 --> 00:12:07,170
A continuación, o ficheiro de cabeceira é o que os amigos e compañeiros de incluír

204
00:12:07,170 --> 00:12:09,760
con # incluír no seu propio código.

205
00:12:09,760 --> 00:12:12,210
Entón todo este tempo, está incluíndo todos os prototipos,

206
00:12:12,210 --> 00:12:16,580
efectivamente no cume do seu arquivo, pero por medio deste mecanismo # include,

207
00:12:16,580 --> 00:12:20,070
que esencialmente copia e pega este ficheiro no seu propio país.

208
00:12:20,070 --> 00:12:23,070
Aquí está algunha documentación bastante detallada.

209
00:12:23,070 --> 00:12:25,640
Nós practicamente un dato adquirido que GetInt recibe un int,

210
00:12:25,640 --> 00:12:27,640
pero acontece que hai algúns casos de canto.

211
00:12:27,640 --> 00:12:31,810
E se o usuario escribe un número que é moi grande, un quintilhões,

212
00:12:31,810 --> 00:12:35,490
que simplemente non pode caber dentro dun int? Cal é o comportamento esperado?

213
00:12:35,490 --> 00:12:38,020
Ideal, é previsible.

214
00:12:38,020 --> 00:12:40,280
Polo tanto, neste caso, se realmente ler a copia fina,

215
00:12:40,280 --> 00:12:44,500
realmente ver que, se a liña non se pode ler, INT_MAX este retorno.

216
00:12:44,500 --> 00:12:48,320
Nós nunca falamos sobre iso, pero con base na súa capitalización, o que pode ser?

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

218
00:12:50,640 --> 00:12:54,770
É unha constante especial que é, probablemente, declarou un deses ficheiros de cabeceira

219
00:12:54,770 --> 00:13:00,090
que é ata maior no arquivo, e INT_MAX é probablemente algo como preto de 2 millóns,

220
00:13:00,090 --> 00:13:04,990
A idea é que, porque necesitamos de algunha maneira significar que algo deu mal,

221
00:13:04,990 --> 00:13:10,700
Temos, si, ten 4 millóns de números á nosa disposición: -2000000000 en ata 2 millóns, máis ou menos.

222
00:13:10,700 --> 00:13:14,710
Ben, o que é común en programación é vostede roubar só un deses números,

223
00:13:14,710 --> 00:13:18,920
quizais 0, quizais 2 millóns, quizais -2000000000,

224
00:13:18,920 --> 00:13:23,280
así gasta un dos seus valores posíbeis de xeito que pode cometer ao mundo

225
00:13:23,280 --> 00:13:26,820
que, se algo sae mal, eu vou volver ese valor super grande.

226
00:13:26,820 --> 00:13:31,030
Pero non quere que o usuario escriba algo enigmático como 234 ..., un número moi grande.

227
00:13:31,030 --> 00:13:34,060
Vostede xeneraliza-lo en vez como unha constante.

228
00:13:34,060 --> 00:13:38,060
Entón, realmente, se estaba sendo anal nas últimas semanas, a calquera hora que chamou GetInt,

229
00:13:38,060 --> 00:13:42,900
debería ter benvida a comprobar unha condición, se fixo o tipo de usuario INT_MAX,

230
00:13:42,900 --> 00:13:46,590
ou, máis especificamente, fixo GetInt INT_MAX retorno, porque se o fixese,

231
00:13:46,590 --> 00:13:51,830
que realmente significa que non escriba-lo. Algo deu mal neste caso.

232
00:13:51,830 --> 00:13:56,080
Polo tanto, este é o que é xeralmente coñecido como un valor de sentinela, o que significa só especial.

233
00:13:56,080 --> 00:13:58,120
>> Imos agora volver ao arquivo c ..

234
00:13:58,120 --> 00:14:01,340
O ficheiro C existiu no aparello por algún tempo.

235
00:14:01,340 --> 00:14:06,840
E, de feito, o aparello ten precompilados para ti nesa cousa que chamamos de código obxecto,

236
00:14:06,840 --> 00:14:09,540
pero simplemente non importa a onde está porque o sistema sabe

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

238
00:14:11,730 --> 00:14:17,400
Imos rolar agora getInt e ver como GetInt vén traballando todo este tempo.

239
00:14:17,400 --> 00:14:19,460
Aquí temos comentarios similares antes.

240
00:14:19,460 --> 00:14:21,660
Deixe-me ampliar só o código porción.

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
Non é preciso de entrada.

243
00:14:25,700 --> 00:14:29,510
El retorna un int, mentres (certo), por iso temos un loop infinito deliberada,

244
00:14:29,510 --> 00:14:33,180
pero probablemente imos saír desa forma ou volver a partir desta.

245
00:14:33,180 --> 00:14:34,870
>> Imos ver como funciona isto.

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

247
00:14:39,240 --> 00:14:43,780
Isto agora é unha boa práctica, porque en que circunstancias podería volver GetString

248
00:14:43,780 --> 00:14:47,660
a palabra chave NULL especial? >> [Alumno] Se algo sae mal.

249
00:14:47,660 --> 00:14:51,630
Se algo sae mal. E o que podería dar mal cando chamar algo así como GetString?

250
00:14:54,960 --> 00:14:57,640
Si >> [Alumno] Malloc falla en darlle os ints.

251
00:14:57,640 --> 00:14:59,150
Si Quizais malloc falla.

252
00:14:59,150 --> 00:15:03,190
En algún lugar debaixo do capó, GetString está chamando malloc, que aloca memoria,

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

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

255
00:15:07,750 --> 00:15:11,590
E supoña que o usuario tiña unha morea de tempo libre e ingresaran, por exemplo,

256
00:15:11,590 --> 00:15:16,160
de 2 millóns de carácteres, máis personaxes que o ordenador aínda ten RAM.

257
00:15:16,160 --> 00:15:19,250
GetString ten que ser capaz de significar que para ti.

258
00:15:19,250 --> 00:15:22,560
Aínda que este é un super, super-canto se inusual,

259
00:15:22,560 --> 00:15:24,340
ten dalgún modo ser capaz de tratar con isto,

260
00:15:24,340 --> 00:15:28,750
e así GetString, volveuse e ler a súa documentación, fai NULL retorno feito.

261
00:15:28,750 --> 00:15:34,460
Polo tanto, agora GetString falla, retornando NULL, GetInt vai fallar, retornando INT_MAX

262
00:15:34,460 --> 00:15:37,690
só como unha sentinela. Estes son só convencións humanas.

263
00:15:37,690 --> 00:15:41,450
O único xeito que sabe que este é o caso a través da lectura da documentación.

264
00:15:41,450 --> 00:15:45,040
>> Imos cambiar ata onde o int é realmente chegou.

265
00:15:45,040 --> 00:15:51,160
Se rolar un pouco máis, na liña 170, temos un comentario enriba destas liñas.

266
00:15:51,160 --> 00:15:55,100
Declaramos en 172 un int, n, e un char, c, e, a continuación, esta nova función,

267
00:15:55,100 --> 00:15:58,930
que algúns de vostedes que tropeçado antes, sscanf.

268
00:15:58,930 --> 00:16:00,870
Isto significa scanf cadea.

269
00:16:00,870 --> 00:16:05,700
Noutras palabras, dáme unha corda e eu debería buscar pezas de información de interese.

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

271
00:16:07,360 --> 00:16:11,800
Supoña que eu escribir, literalmente, 123 no teclado e prema a tecla Intro.

272
00:16:11,800 --> 00:16:16,470
Cal é o tipo de datos de 123 cando retornou por GetString? >> [Alumno] Cadea.

273
00:16:16,470 --> 00:16:18,380
É evidente que é unha cadea, non? Eu teño un string.

274
00:16:18,380 --> 00:16:23,220
Entón, é realmente 123, comiñas pecha comiñas, 123 co 0 \ ao final do mesmo.

275
00:16:23,220 --> 00:16:27,110
Isto non é un int. Isto non é un número. Parece un número, pero iso non é verdade.

276
00:16:27,110 --> 00:16:29,080
Entón, o que GetInt teño que facer?

277
00:16:29,080 --> 00:16:35,750
Ten que analizar esa secuencia esquerda a dereita - 123 \ 0 - e dalgunha forma converter a un enteiro real.

278
00:16:35,750 --> 00:16:37,850
Vostede podería descubrir como facelo.

279
00:16:37,850 --> 00:16:41,450
Se pensas que volta para pset2, probablemente ten un pouco cómodo con César

280
00:16:41,450 --> 00:16:44,820
ou Vigenère, así pode iterar sobre unha corda, pode converterse caracteres para ints.

281
00:16:44,820 --> 00:16:46,710
Pero que demo, é un monte de traballo.

282
00:16:46,710 --> 00:16:49,860
Por que non chamar a unha función como sscanf que fai isto para vostede?

283
00:16:49,860 --> 00:16:54,230
Entón sscanf espera un argumento - neste caso chamado de liña, que é unha cadea.

284
00:16:54,230 --> 00:17:01,840
Vostede, entón, indicar entre comiñas, moi semellante ao printf, o que espera a ver nesta secuencia.

285
00:17:01,840 --> 00:17:09,000
E o que eu estou dicindo aquí é que eu espero ver un número decimal e quizais un personaxe.

286
00:17:09,000 --> 00:17:12,000
E imos ver por que este é o caso en só un momento.

287
00:17:12,000 --> 00:17:15,869
E ocorre que esta notación é agora lembra de cousas que comezaron a falar sobre

288
00:17:15,869 --> 00:17:17,619
pouco máis dunha semana.

289
00:17:17,619 --> 00:17:21,740
¿Que é & n & C e facendo por nós aquí? >> [Alumno] Enderezo n e enderezo do c.

290
00:17:21,740 --> 00:17:25,400
Si Está me dando o enderezo de n e enderezo do c. Por que iso é importante?

291
00:17:25,400 --> 00:17:30,220
Vostede sabe que con funcións en C, sempre pode voltar un valor ou ningún valor.

292
00:17:30,220 --> 00:17:34,530
Podes devolver un int, unha corda, unha boia, un char, calquera que sexa, ou pode voltar baleiro

293
00:17:34,530 --> 00:17:38,030
pero só se pode retornar unha cousa ao máximo.

294
00:17:38,030 --> 00:17:42,760
Pero aquí queremos sscanf para volver me quizais un int, un número decimal,

295
00:17:42,760 --> 00:17:46,220
e tamén un. char, e eu vou explicar por que o char nun momento

296
00:17:46,220 --> 00:17:51,460
Vostede efectivamente quere sscanf para voltar dúas cousas, pero iso non é posible en C.

297
00:17:51,460 --> 00:17:55,200
Pode resolver iso pasando en dous enderezos

298
00:17:55,200 --> 00:17:57,370
porque así que entrega unha función de dous enderezos,

299
00:17:57,370 --> 00:18:00,470
o que pode facer esa función con eles? >> [Alumno] Escriba para estes enderezos.

300
00:18:00,470 --> 00:18:02,010
Pode escribir para eses enderezos.

301
00:18:02,010 --> 00:18:05,770
Podes utilizar a operación de estrela e ir para alí, para cada un destes enderezos.

302
00:18:05,770 --> 00:18:11,260
É unha especie de este mecanismo de back-door, pero moi común para cambiar os valores das variables

303
00:18:11,260 --> 00:18:14,870
máis que un único local - neste caso, dous.

304
00:18:14,870 --> 00:18:21,340
Agora repare que eu estou comprobando == 1 e despois retornando n se isto, de feito, avaliar a realidade.

305
00:18:21,340 --> 00:18:26,170
Entón, o que está a suceder? Tecnicamente, todo o que realmente quere que aconteza en GetInt é esta.

306
00:18:26,170 --> 00:18:30,740
Queremos analizar, por así dicir, queremos ler a secuencia - entre comiñas-123 -

307
00:18:30,740 --> 00:18:34,560
e parece que hai un número alí, o que estamos dicindo sscanf facer

308
00:18:34,560 --> 00:18:38,190
é poñer ese número - 123 - Esta variable n para min.

309
00:18:38,190 --> 00:18:42,090
Entón, por que entón eu realmente teño iso tamén?

310
00:18:42,090 --> 00:18:48,220
Cal é o papel de sscanf dicindo que tamén se pode obter un personaxe aquí?

311
00:18:48,220 --> 00:18:53,470
[Resposta do alumno inaudível] >> Un punto decimal realmente podería funcionar.

312
00:18:53,470 --> 00:18:56,330
Imos soster que penso por un momento. O que máis?

313
00:18:56,330 --> 00:18:59,270
[Alumno] Podería ser NULL. >> Bo pensamento. Podería ser o carácter nulo.

314
00:18:59,270 --> 00:19:01,660
Non é certo neste caso. Si >> [Alumno] ASCII.

315
00:19:01,660 --> 00:19:04,340
ASCII. Ou deixe-me xeneralizar aínda máis.

316
00:19:04,340 --> 00:19:06,640
O c% non é só para comprobación de erros.

317
00:19:06,640 --> 00:19:09,300
Nós non queremos que haxa un personaxe despois do número,

318
00:19:09,300 --> 00:19:11,870
pero o que iso me permite facer é o seguinte.

319
00:19:11,870 --> 00:19:18,210
Acontece que sscanf, ademais de almacenar valores de n e c neste exemplo aquí,

320
00:19:18,210 --> 00:19:24,890
o que tampouco é el retorna o número de variables que poñer valores dentro

321
00:19:24,890 --> 00:19:30,260
Entón, se escribir só en 123, entón só o% d vai corresponder,

322
00:19:30,260 --> 00:19:33,880
e só n queda almacenado cun valor como 123,

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

324
00:19:35,640 --> 00:19:37,620
C segue a ser un valor de lixo, por así dicir -

325
00:19:37,620 --> 00:19:40,730
lixo, porque iso nunca foi inicializada con algún valor.

326
00:19:40,730 --> 00:19:45,520
Entón, nese caso, sscanf retorna 1 porque eu cuberto un dos punteiros,

327
00:19:45,520 --> 00:19:50,190
caso en que gran, eu teño un int para que eu liberar a liña para liberar a memoria

328
00:19:50,190 --> 00:19:54,000
GetString que efectivamente asignado, e entón eu volver n,

329
00:19:54,000 --> 00:19:58,500
máis se xa se preguntas onde que repetir declaración vén, vén aquí.

330
00:19:58,500 --> 00:20:04,390
Así, se, pola contra, eu escriba 123foo - só unha secuencia aleatoria de calquera 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 poñer o 123 en n; vai poñer o f en C e despois volver 2.

333
00:20:16,410 --> 00:20:20,640
Entón temos, só usando a definición básica de comportamento sscanf, dun xeito moi simple -

334
00:20:20,640 --> 00:20:23,900
así, complexo, a primeira vista, pero ao final do día mecanismo relativamente simple -

335
00:20:23,900 --> 00:20:28,320
de dicir que hai un int e se é así, é que a única cousa que eu atope?

336
00:20:28,320 --> 00:20:29,860
E o espazo en branco aquí é deliberada.

337
00:20:29,860 --> 00:20:34,000
Se ler a documentación para sscanf, dille que, se incluír unha peza de espazo en branco

338
00:20:34,000 --> 00:20:38,810
, No inicio ou no final, sscanf tamén ha permitir que o usuario, por calquera razón,

339
00:20:38,810 --> 00:20:41,860
a bater 123 barra de espazo e que será lexítimo.

340
00:20:41,860 --> 00:20:44,150
Non vai berrar co usuario só porque bateu a barra de espazo

341
00:20:44,150 --> 00:20:48,640
no inicio ou no final, que é só un pouco máis user-friendly.

342
00:20:48,640 --> 00:20:52,300
>> Algunha preguntas, entón no GetInt? Si >> [Alumno] E se só poñer un char?

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

344
00:20:54,030 --> 00:20:59,890
E se acaba de escribir un char como f e prema Intro sen nunca escribindo 123?

345
00:20:59,890 --> 00:21:02,420
¿Que pensas que o comportamento desta liña de código sería entón?

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

347
00:21:04,730 --> 00:21:08,790
Si, entón sscanf pode cubrir iso tamén porque, nese caso, non vai encher n ou c.

348
00:21:08,790 --> 00:21:15,310
Vai en vez volver 0, caso en que eu tamén estou pegando este escenario

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

350
00:21:18,750 --> 00:21:22,000
Eu só quero unha e só unha cousa a ser cuberto. Boa pregunta.

351
00:21:22,000 --> 00:21:24,290
>> Outros? Todo ben.

352
00:21:24,290 --> 00:21:26,250
>> Non imos pasar por todas as funcións aquí,

353
00:21:26,250 --> 00:21:29,500
pero o que parece ser, quizais, de participación remanescente é GetString

354
00:21:29,500 --> 00:21:32,790
pois verifícase que GetFloat, GetInt, GetDouble, GetLongLong

355
00:21:32,790 --> 00:21:36,260
todos punto moito de súa funcionalidade para GetString.

356
00:21:36,260 --> 00:21:39,750
Entón, imos dar un ollo a como é aplicado aquí.

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

358
00:21:43,630 --> 00:21:45,670
que comezamos a falar sobre a semana pasada.

359
00:21:45,670 --> 00:21:49,490
En GetString, que leva ningún argumento segundo o baleiro aquí

360
00:21:49,490 --> 00:21:53,730
e retorna un string, eu parecer estou declarando unha cadea chamada buffer.

361
00:21:53,730 --> 00:21:56,270
Eu realmente non sei o que vai ser usado para aínda, pero imos ver.

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

363
00:21:58,390 --> 00:22:01,350
Non é ben certo onde iso vai dar, non sei o que n vai ser usado para, con todo,

364
00:22:01,350 --> 00:22:03,590
pero agora está quedando un pouco máis interesante.

365
00:22:03,590 --> 00:22:06,520
Na liña 243, declaramos un int, c.

366
00:22:06,520 --> 00:22:08,800
Esta é unha especie de un detalle estúpido.

367
00:22:08,800 --> 00:22:15,820
Un char é de 8 bits, e 8 bits pode almacenar cantos valores diferentes? >> [Alumno] 256. >> 256.

368
00:22:15,820 --> 00:22:20,730
O problema é se quere ter 256 diferentes carácteres ASCII, que hai

369
00:22:20,730 --> 00:22:23,340
se pensas que volta - e iso non é algo para memorizar.

370
00:22:23,340 --> 00:22:25,710
Pero se pensas que volta a ese gráfico gran ASCII tivemos semanas,

371
00:22:25,710 --> 00:22:30,600
foron, neste caso 128 ou 256 carácteres ASCII.

372
00:22:30,600 --> 00:22:32,940
Usamos os patróns de ata 0s e 1s.

373
00:22:32,940 --> 00:22:36,210
Isto é un problema se quere ser capaz de detectar un erro

374
00:22:36,210 --> 00:22:40,190
porque se xa está a usar 256 valores para os seus personaxes,

375
00:22:40,190 --> 00:22:43,050
realmente non planificar con antelación, porque agora non ten ningunha forma de dicir,

376
00:22:43,050 --> 00:22:46,270
este non é un personaxe legal, é dicir algunha mensaxe incorrecta.

377
00:22:46,270 --> 00:22:50,270
Entón, o que o mundo ten que usan o maior valor próximo, algo así como un int,

378
00:22:50,270 --> 00:22:54,720
para que teña un número tolo de bits, 32, para 4 mil millóns de valores posíbeis

379
00:22:54,720 --> 00:22:58,860
de xeito que pode simplemente acabar empregando, esencialmente, 257 deles,

380
00:22:58,860 --> 00:23:01,720
Un dos cales ten algún significado especial como un erro.

381
00:23:01,720 --> 00:23:03,120
>> Entón imos ver como funciona isto.

382
00:23:03,120 --> 00:23:07,760
Na liña 246, eu teño esa gran loop while que está chamando fgetc,

383
00:23:07,760 --> 00:23:11,090
f ficheiro significado, de xeito getc, e despois stdin.

384
00:23:11,090 --> 00:23:15,520
Acontece que esta é só a forma máis precisa de dicir ler a entrada do teclado.

385
00:23:15,520 --> 00:23:19,300
Teclado medio estándar de entrada, saída estándar significa pantalla,

386
00:23:19,300 --> 00:23:23,310
e erro estándar, o que veremos na pset4, significa que a pantalla

387
00:23:23,310 --> 00:23:27,490
pero unha parte especial da pantalla de xeito que non é confundida con saída real

388
00:23:27,490 --> 00:23:30,750
que desexa imprimir. Pero máis sobre iso no futuro.

389
00:23:30,750 --> 00:23:34,440
Entón fgetc significa só ler un caracter do teclado e almacena-lo onde?

390
00:23:34,440 --> 00:23:37,350
Garda o en c.

391
00:23:37,350 --> 00:23:41,360
E a continuación, comprobar - por iso estou usando só algunhas conxuncións booleanos aquí -

392
00:23:41,360 --> 00:23:46,000
asegúrese de que non é igual - \ n, de xeito que o usuario prema Intro, queremos deixar nese punto,

393
00:23:46,000 --> 00:23:49,850
fin do ciclo - e nós tamén queremos comprobar a EOF constante especial,

394
00:23:49,850 --> 00:23:53,610
que se indica ou adiviñar, o que significa isto? >> [Alumno] Fin do arquivo. Fin >> de arquivo.

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

396
00:23:56,560 --> 00:23:58,870
non hai realmente ningún arquivo implicado niso,

397
00:23:58,870 --> 00:24:01,150
pero iso é só unha especie de termo xenérico usado para significar

398
00:24:01,150 --> 00:24:04,220
que nada máis é que vén 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 un aparte, se xa alcanzou Control D no seu teclado non, que tería aínda -

401
00:24:09,920 --> 00:24:15,230
bateu Control C - Control D envía esta constante especial chamado EOF.

402
00:24:15,230 --> 00:24:19,850
Polo tanto, agora só temos algúns asignación dinámica de memoria.

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

404
00:24:23,440 --> 00:24:26,100
N é só cantos bytes están actualmente no búfer,

405
00:24:26,100 --> 00:24:28,620
a secuencia que está a construírse a partir do usuario.

406
00:24:28,620 --> 00:24:33,450
Se ten máis caracteres no seu buffer que ten capacidade de buffer,

407
00:24:33,450 --> 00:24:37,410
intuitivamente o que temos que facer, entón, é reservar máis capacidade.

408
00:24:37,410 --> 00:24:43,330
Entón eu vou para saltar un pouco da aritmética aquí e centrar só esta función aquí.

409
00:24:43,330 --> 00:24:46,070
Sabe o que malloc é ou son, polo menos xeralmente familiar.

410
00:24:46,070 --> 00:24:48,970
Adiviña o que realloc fai. >> [Alumno] Engade memoria.

411
00:24:48,970 --> 00:24:52,920
Non é así a adición de memoria. É realoca memoria como segue.

412
00:24:52,920 --> 00:24:57,220
Se aínda hai espazo no final da cadea para darlle máis que a memoria

413
00:24:57,220 --> 00:25:00,000
do que orixinalmente lle dá, entón vai ter que memoria adicional.

414
00:25:00,000 --> 00:25:03,460
Entón podes só seguir poñendo personaxes da corda de costas cara atrás, cara atrás.

415
00:25:03,460 --> 00:25:05,830
Pero se ese non é o caso, porque esperou moito tempo

416
00:25:05,830 --> 00:25:07,940
e foi algo aleatorio xogou na memoria non

417
00:25:07,940 --> 00:25:10,290
pero non hai memoria extra aquí, todo ben.

418
00:25:10,290 --> 00:25:13,100
Realloc vai facer todo o traballo pesado para ti,

419
00:25:13,100 --> 00:25:16,750
mover a secuencia que xa leu en así moi lonxe de aquí, colocar-lo alí en baixo,

420
00:25:16,750 --> 00:25:19,460
e despois darlle un pouco máis de pista naquel momento.

421
00:25:19,460 --> 00:25:22,550
>> Así, cun aceno de man, deixe-me dicir que o que está facendo GetString

422
00:25:22,550 --> 00:25:26,330
é que está comezando con un buffer pequeno, quizais un carácter único,

423
00:25:26,330 --> 00:25:30,820
e se o usuario escribe en dous personaxes, GetString acaba chamando realloc e di

424
00:25:30,820 --> 00:25:33,150
un personaxe non foi o suficiente, dáme dous personaxes.

425
00:25:33,150 --> 00:25:35,950
Entón, se ler a lóxica do circuíto, que vai dicir

426
00:25:35,950 --> 00:25:39,600
o usuario introduciu 3 caracteres dáme agora non dous, senón catro personaxes,

427
00:25:39,600 --> 00:25:42,320
entón me dea 8, a continuación, dar-me 16 e 32.

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

429
00:25:45,000 --> 00:25:48,570
significa que o buffer non vai crecer lentamente, vai medrar super rápido.

430
00:25:48,570 --> 00:25:51,380
E o que podería ser a vantaxe disto?

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

432
00:25:54,600 --> 00:25:58,020
aínda que o usuario só precisa dun personaxe extra a partir do teclado?

433
00:25:58,020 --> 00:26:01,750
[Resposta do alumno inaudível] >> ¿Que é iso? >> [Alumno] Non ten que crecer sempre.

434
00:26:01,750 --> 00:26:03,300
Exactamente. Non ten que crecer sempre.

435
00:26:03,300 --> 00:26:05,510
E este é só un tipo de cobertura está aquí as súas apostas,

436
00:26:05,510 --> 00:26:10,850
A idea é que non quere chamar realloc moito, porque tende a ser lenta.

437
00:26:10,850 --> 00:26:12,910
Cada vez que preguntar o sistema operativo para a memoria,

438
00:26:12,910 --> 00:26:16,990
como podes ver en breve nun conxunto de problemas futuro, tende a levar moito tempo.

439
00:26:16,990 --> 00:26:20,010
Así, minimizando a cantidade de tempo, mesmo se está perdendo un pouco de espazo,

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

441
00:26:21,900 --> 00:26:24,060
>> Pero se lermos a parte final da GetString aquí -

442
00:26:24,060 --> 00:26:27,950
e, de novo, a comprensión cada liña, aquí, non é tan importante hoxe -

443
00:26:27,950 --> 00:26:30,530
notar que, finalmente, chama malloc novo

444
00:26:30,530 --> 00:26:33,880
e aloca exactamente como moitos máis coma el necesita para a cadea

445
00:26:33,880 --> 00:26:38,060
e despois xoga fóra chamando o tapón libre excesivamente grande

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

447
00:26:40,080 --> 00:26:42,730
Entón, en suma, é así que GetString vén traballando todo este tempo.

448
00:26:42,730 --> 00:26:47,060
Todo o que fai é ler un personaxe nun momento novo e de novo e de novo,

449
00:26:47,060 --> 00:26:50,750
e cada vez que precisa un pouco de memoria adicional, el pide ao sistema operativo para el

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

451
00:26:53,670 --> 00:26:57,890
>> Algunha pregunta? Todo ben.

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

453
00:26:59,270 --> 00:27:04,060
Agora que entendemos punteiros ou polo menos están cada vez máis familiarizado con punteiros,

454
00:27:04,060 --> 00:27:06,700
imos considerar como o mundo enteiro comeza a entrar en colapso

455
00:27:06,700 --> 00:27:10,030
Se vostede non pode defenderse contra os usuarios contraditorio,

456
00:27:10,030 --> 00:27:11,850
persoas que están tentando invadir o seu sistema,

457
00:27:11,850 --> 00:27:16,890
persoas que están tentando roubar o seu software, contornando algúns código de rexistro

458
00:27:16,890 --> 00:27:19,090
que eles poderían ter que escribir dentro

459
00:27:19,090 --> 00:27:22,990
>> Bótalle un ollo neste exemplo aquí, que é só o código C, que ten unha función principal na parte inferior

460
00:27:22,990 --> 00:27:26,380
que chama unha función foo. E o que é pasar foo?

461
00:27:26,380 --> 00:27:29,680
[Alumno] un único argumento. >> [Malan] Un argumento único.

462
00:27:29,680 --> 00:27:33,450
Entón, argv [1], o que significa que a primeira palabra que o usuario introduciu na liña de comandos

463
00:27:33,450 --> 00:27:36,360
logo a.out ou o que quere que o programa é chamado.

464
00:27:36,360 --> 00:27:41,680
Entón foo arriba leva un char *. Pero char * é o que? >> [Alumno] Unha secuencia.

465
00:27:41,680 --> 00:27:43,350
[Malan] Un fío, entón non hai nada novo aquí.

466
00:27:43,350 --> 00:27:45,420
Esta secuencia é arbitrariamente sendo chamado de bar.

467
00:27:45,420 --> 00:27:51,430
Nesta liña aquí, char c [12], nunha especie de semi-técnico inglés, o que é esa liña está facendo?

468
00:27:51,430 --> 00:27:55,220
[Estudante] Unha matriz de - Array >> de? >> [Alumno] personaxes. Personaxes. >>

469
00:27:55,220 --> 00:27:58,870
Déame un conxunto de 12 caracteres. Así, poderiamos chamar iso de un buffer.

470
00:27:58,870 --> 00:28:02,920
É tecnicamente chamado c, pero un tapón na programación significa só unha morea de espazo

471
00:28:02,920 --> 00:28:04,800
que pode poñer algunhas cousas dentro

472
00:28:04,800 --> 00:28:07,940
Entón, por fin, memcpy que non usei antes, pero probablemente pode adiviñar o que fai.

473
00:28:07,940 --> 00:28:10,480
El copia memoria. O que fai?

474
00:28:10,480 --> 00:28:19,270
Ao parecer, copia bar, a súa entrada en C, pero só ata a lonxitude da barra.

475
00:28:19,270 --> 00:28:24,930
Pero hai un erro aquí. >> [Alumno] Debe do carácter sizeof. Ok >>.

476
00:28:24,930 --> 00:28:30,860
Tecnicamente, debemos realmente facer strlen (bar) * sizeof (char)). Isto é correcto.

477
00:28:30,860 --> 00:28:33,930
Pero, no peor caso aquí, imos supor que isto é -

478
00:28:33,930 --> 00:28:35,950
Okay. Despois, hai dous erros.

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

480
00:28:39,160 --> 00:28:41,290
Imos facelo un pouco máis.

481
00:28:41,290 --> 00:28:44,910
Entón, agora aínda hai un erro, que é o que? >> [Resposta do alumno inaudível]

482
00:28:44,910 --> 00:28:46,990
Asegúrese de que o que? >> [Alumno] Comprobarase NULL.

483
00:28:46,990 --> 00:28:50,270
Nós xeralmente debe ser a verificación de NULL porque as cousas malas suceden

484
00:28:50,270 --> 00:28:53,200
cando o punteiro está NULL porque pode acabar indo alí,

485
00:28:53,200 --> 00:28:57,630
e non debe nunca estar indo NULL por dereferencing co operador estrela.

486
00:28:57,630 --> 00:29:01,050
Entón, iso é bo. E o que máis estamos facendo? Loxicamente, hai unha falla aquí tamén.

487
00:29:01,050 --> 00:29:04,450
[Alumno] Asegúrese de que argc é> = 2.

488
00:29:04,450 --> 00:29:10,550
Polo tanto, comproba que argc é> = 2. Ok, entón hai tres erros neste programa.

489
00:29:10,550 --> 00:29:16,630
Estamos comprobando se o usuario realmente escribiu algo en argv [1]. Bo

490
00:29:16,630 --> 00:29:20,950
Entón, cal é o erro terceiro? Si >> [Alumno] C pode non ser grande abondo.

491
00:29:20,950 --> 00:29:23,320
Bo Nós verificar un escenario.

492
00:29:23,320 --> 00:29:29,520
Nós implicitamente comprobado non copiar máis memoria do que superar a lonxitude da barra.

493
00:29:29,520 --> 00:29:32,510
Entón, se a cadea que o usuario introduciu é de 10 carácteres,

494
00:29:32,510 --> 00:29:36,020
Isto está dicindo só copiar 10 caracteres. E está todo ben.

495
00:29:36,020 --> 00:29:39,940
Pero e se o usuario introduciu unha palabra no poder como unha palabra de 20 caracteres?

496
00:29:39,940 --> 00:29:44,900
Isto está dicindo copia 20 caracteres de bar en que?

497
00:29:44,900 --> 00:29:49,750
C, tamén coñecida como o noso buffer, o que significa que vostede acaba de escribir datos

498
00:29:49,750 --> 00:29:52,540
a 8 lugares de bytes que non ten,

499
00:29:52,540 --> 00:29:54,870
e non ten-los no sentido de que nunca alocados eles.

500
00:29:54,870 --> 00:30:00,370
Polo tanto, este é o que é xeralmente coñecido como o ataque de buffer overflow ou ataque estourido de buffer.

501
00:30:00,370 --> 00:30:05,580
E é un ataque no sentido de que o usuario ou o programa que está chamando a súa función

502
00:30:05,580 --> 00:30:10,490
está facendo iso de forma maliciosa, o que realmente acontece próximo pode ser realmente moi malo.

503
00:30:10,490 --> 00:30:12,450
>> Entón, imos dar un ollo nesta foto aquí.

504
00:30:12,450 --> 00:30:16,060
Esta imaxe representa a súa pila de memoria.

505
00:30:16,060 --> 00:30:19,580
Lembre que cada vez que chamar a unha función que comeza este cadro pouco sobre a pila

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

507
00:30:21,520 --> 00:30:24,300
E, ata agora, temos só un tipo de abstraídas estes como rectángulos

508
00:30:24,300 --> 00:30:26,290
ou no consello ou na pantalla aquí.

509
00:30:26,290 --> 00:30:30,580
Pero, se aumentar o zoom nun deses rectángulos, cando chamar unha función foo,

510
00:30:30,580 --> 00:30:35,880
verifícase que hai máis no interior da pila de que o cadro en que rectángulo

511
00:30:35,880 --> 00:30:40,060
que só X e Y e a e b, como fixemos fala de intercambio.

512
00:30:40,060 --> 00:30:44,410
Acontece que hai algúns detalles de nivel inferior, entre eles, o enderezo de retorno.

513
00:30:44,410 --> 00:30:49,550
Así, verifícase cando principal chámase foo, principal saber foo

514
00:30:49,550 --> 00:30:53,520
o enderezo principal na memoria do ordenador

515
00:30:53,520 --> 00:30:57,770
porque doutro xeito, así que foo está feito de execución, como neste caso aquí,

516
00:30:57,770 --> 00:31:00,830
unha vez que chegar a esta cinta pechado rizado a finais de foo,

517
00:31:00,830 --> 00:31:05,310
como o diaño non foo sabe onde o control do programa que ir?

518
00:31:05,310 --> 00:31:08,970
Acontece que a resposta a esta pregunta é neste rectángulo vermello aquí.

519
00:31:08,970 --> 00:31:12,670
Isto representa un punteiro, e cabe ao ordenador para almacenar temporalmente

520
00:31:12,670 --> 00:31:17,030
sobre a pila de chamada o enderezo da páxina, de xeito que, unha vez que está feito foo execución,

521
00:31:17,030 --> 00:31:21,120
o ordenador sabe onde e cal liña principal para volver.

522
00:31:21,120 --> 00:31:23,940
Cadro punteiro agás se relaciona de forma semellante a esta.

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

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

525
00:31:31,570 --> 00:31:35,010
Bar é só o argumento para a función foo.

526
00:31:35,010 --> 00:31:37,500
Polo tanto, agora estamos de volta ao tipo de cadro familiar.

527
00:31:37,500 --> 00:31:39,850
Hai máis cousas e máis distraccións na pantalla,

528
00:31:39,850 --> 00:31:43,380
pero ese segmento de luz azul é só o que estamos deseñando no cadro-negro

529
00:31:43,380 --> 00:31:45,790
para algo así como intercambio. Ese é o marco para foo.

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

531
00:31:51,490 --> 00:31:55,220
Pero o que máis debería estar na pila de acordo con este código aquí?

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

533
00:31:57,760 --> 00:32:02,810
Tamén debe ver 12 cadrados de memoria alocada para unha variable chamada c,

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

535
00:32:04,970 --> 00:32:08,480
O principio hai c [0], e logo o autor deste diagrama

536
00:32:08,480 --> 00:32:11,850
non se incomodou deseñando as prazas, pero hai de feito hai 12

537
00:32:11,850 --> 00:32:16,590
porque se ollar no ángulo inferior dereito, c [11], se contar de 0 é o byte 12 tal.

538
00:32:16,590 --> 00:32:18,400
Pero aquí está o problema.

539
00:32:18,400 --> 00:32:22,390
En que dirección está crecendo c?

540
00:32:22,390 --> 00:32:27,080
Tipo de arriba abaixo se comeza no principio e crece cara a abaixo.

541
00:32:27,080 --> 00:32:30,110
Non se parece con nós mesmos deixamos pista moi aquí.

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

543
00:32:32,090 --> 00:32:36,940
e que c [11] é ata contra bar, que está á dereita contra o punteiro de Marco Salvo,

544
00:32:36,940 --> 00:32:39,960
que é ata contra enderezo de retorno. Non hai máis espazo.

545
00:32:39,960 --> 00:32:42,810
Entón, cal é a implicación entón se romper

546
00:32:42,810 --> 00:32:46,500
e intenta ler 20 bytes nun buffer de 12 bytes?

547
00:32:46,500 --> 00:32:50,060
Onde están os 8 bytes máis indo? >> [Alumno] Inside -

548
00:32:50,060 --> 00:32:53,200
Dentro de todo o resto, algúns dos cales é super importante.

549
00:32:53,200 --> 00:32:57,260
E a cousa máis importante, potencialmente, é a caixa vermella alí, enderezo de retorno,

550
00:32:57,260 --> 00:33:03,560
porque supoña que accidentalmente ou adversarially substituír estes 4 bytes,

551
00:33:03,560 --> 00:33:07,260
que o enderezo de punteiro, non só co lixo, pero cun número

552
00:33:07,260 --> 00:33:09,810
que pasa a representar un enderezo real na memoria.

553
00:33:09,810 --> 00:33:13,880
Cal é a implicación, loxicamente? >> [Alumno] Función vai voltar a un lugar diferente.

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

555
00:33:15,250 --> 00:33:19,170
Cando retorna foo e hits que chaveta, o programa seguirá

556
00:33:19,170 --> 00:33:25,060
non volver para a principal, que vai volver a calquera enderezo en que é caixa vermella.

557
00:33:25,060 --> 00:33:28,600
>> No caso de rexistro de software evitar,

558
00:33:28,600 --> 00:33:32,260
e se o enderezo que está a ser devolto a é a función que normalmente se chama

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

560
00:33:35,690 --> 00:33:39,870
Pode clasificar de enganar o ordenador en non ir aquí, pero en vez de ir ata aquí.

561
00:33:39,870 --> 00:33:45,100
Ou se é realmente intelixente, un rival realmente pode escribir no teclado, por exemplo,

562
00:33:45,100 --> 00:33:50,690
non unha palabra real, non 20 personaxes, pero supoño que el ou ela realmente tipos en

563
00:33:50,690 --> 00:33:52,770
algúns personaxes que representan o código.

564
00:33:52,770 --> 00:33:55,320
E non vai ser de código C, que vai de feito ser os personaxes

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

566
00:33:59,290 --> 00:34:01,290
Pero supoña que son espertos o suficiente para facelo,

567
00:34:01,290 --> 00:34:06,500
dalgunha forma, pegar no ventá de GetString algo que é esencialmente código compilado,

568
00:34:06,500 --> 00:34:09,980
e os últimos 4 bytes substituír este enderezo de retorno.

569
00:34:09,980 --> 00:34:13,360
E o enderezo é que a entrada de facer?

570
00:34:13,360 --> 00:34:18,630
É realmente almacena neste rectángulo vermello a dirección do primeiro byte do buffer.

571
00:34:18,630 --> 00:34:23,070
Entón ten que ser realmente intelixente, e iso é unha chea de intento e erro para persoas malas aí fóra,

572
00:34:23,070 --> 00:34:25,639
pero se pode descubrir 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 fornecer para o programa

574
00:34:28,820 --> 00:34:33,540
ocorrer de ser equivalente ao enderezo do inicio da súa reserva, pode facelo.

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

576
00:34:39,320 --> 00:34:44,420
Pero se somos máis espertos e preenchemos o buffer co que imos chamar xenericamente código de ataque -

577
00:34:44,420 --> 00:34:48,860
AAA, ataque, ataque, ataque - onde iso é só algo que fai algo malo,

578
00:34:48,860 --> 00:34:51,820
Qué acontece se vostede é realmente intelixente, pode facelo.

579
00:34:51,820 --> 00:34:58,610
Na caixa vermella aquí é unha secuencia de números - 80, C0, 35, 08.

580
00:34:58,610 --> 00:35:01,610
Teña en conta que que coincide co número que está aquí enriba.

581
00:35:01,610 --> 00:35:04,430
É na orde inversa, pero máis sobre iso noutro momento.

582
00:35:04,430 --> 00:35:08,140
Teña en conta que este enderezo de retorno foi deliberadamente modificado

583
00:35:08,140 --> 00:35:12,020
para igualar o enderezo aquí, non o enderezo do principal.

584
00:35:12,020 --> 00:35:17,500
Entón, se o cara mal é super intelixente, el ou ela vai incluír nese código de ataque

585
00:35:17,500 --> 00:35:20,930
algo así como eliminar todos os ficheiros do usuario ou copiar as claves

586
00:35:20,930 --> 00:35:24,680
ou crear unha conta de usuario que eu poida entón facer login para - nada.

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

588
00:35:26,950 --> 00:35:29,840
Porque ten acceso a memoria a través de punteiros

589
00:35:29,840 --> 00:35:32,520
e, polo tanto, pode escribir o que queira na memoria dun ordenador,

590
00:35:32,520 --> 00:35:35,080
pode facer un ordenador facer o que quere

591
00:35:35,080 --> 00:35:39,550
simplemente por ter que saltar dentro do seu propio espazo de memoria.

592
00:35:39,550 --> 00:35:44,650
E así ata hoxe tantos programas e tantos sitios que están comprometidas

593
00:35:44,650 --> 00:35:46,200
resumen-se a persoas que toman vantaxe diso.

594
00:35:46,200 --> 00:35:50,760
E iso pode parecer un super ataque sofisticado, pero non sempre é iniciado así.

595
00:35:50,760 --> 00:35:53,560
A realidade é que o que a xente malas normalmente facer é,

596
00:35:53,560 --> 00:35:58,200
se é un programa en liña de comandos ou un programa gráfico ou un sitio web,

597
00:35:58,200 --> 00:35:59,940
acaba de comezar a ofrecer un absurdo.

598
00:35:59,940 --> 00:36:03,980
Escribe unha palabra moi grande no campo de investigación e escriba Intro

599
00:36:03,980 --> 00:36:05,780
e esperar a ver se o sitio traba

600
00:36:05,780 --> 00:36:09,990
ou esperar a ver se o programa se manifesta algunha mensaxe de erro

601
00:36:09,990 --> 00:36:14,330
porque se ten sorte como o cara mal e proporcionar unha información tolo

602
00:36:14,330 --> 00:36:18,980
que traba o programa, isto significa que o programador non anticipou o seu mal comportamento,

603
00:36:18,980 --> 00:36:23,630
o que significa que pode ser con bastante esforzo, estudo bastante e erro,

604
00:36:23,630 --> 00:36:26,650
descubrir como frear un ataque máis preciso.

605
00:36:26,650 --> 00:36:31,410
Así como unha gran parte de seguridade non é só evitar estes ataques completamente

606
00:36:31,410 --> 00:36:34,100
pero detecta-los e realmente ollar os rexistros

607
00:36:34,100 --> 00:36:36,780
e ver o que as persoas tolas entradas escritas na súa páxina web,

608
00:36:36,780 --> 00:36:38,960
o que termos de busca tecleados persoas na súa páxina web

609
00:36:38,960 --> 00:36:42,870
na esperanza de rebosar algúns buffer.

610
00:36:42,870 --> 00:36:45,500
E iso todo se reduce a principios simple do que é unha matriz

611
00:36:45,500 --> 00:36:49,080
eo que iso supón para reservar e utilizar a memoria.

612
00:36:49,080 --> 00:36:51,710
>> Relacionado con iso, entón tamén é este.

613
00:36:51,710 --> 00:36:54,280
Nós só ollar para dentro dun disco duro novo.

614
00:36:54,280 --> 00:36:58,440
Vostede recorda de unha ou dúas semanas que cando arrastrar os ficheiros ao lixo ou lata de lixo,

615
00:36:58,440 --> 00:37:03,710
o que pasa? >> [Alumno] Nada. >> Absolutamente nada, non?

616
00:37:03,710 --> 00:37:05,740
Eventualmente, se executar pouco espazo en disco,

617
00:37:05,740 --> 00:37:08,190
Windows ou Mac OS vai comezar a borrar arquivos para ti.

618
00:37:08,190 --> 00:37:10,390
Pero se arrastrar algo alí dentro, que non é de todo segura.

619
00:37:10,390 --> 00:37:13,800
Todo o seu compañeiro de cuarto ou amigo ou membro da familia ten que facer é premer dúas veces e, listo,

620
00:37:13,800 --> 00:37:16,310
hai todos os ficheiros multimedia que intentou eliminar.

621
00:37:16,310 --> 00:37:19,590
A maioría de nós, polo menos, saber que ten co botón dereito ou prema

622
00:37:19,590 --> 00:37:22,310
e lixo o baleiro ou algo así.

623
00:37:22,310 --> 00:37:25,000
Pero, aínda así, que non chega a facer o truco

624
00:37:25,000 --> 00:37:28,010
porque o que ocorre cando ten un arquivo no seu disco duro

625
00:37:28,010 --> 00:37:32,770
que representa un documento de Word ou algún JPEG, e iso representa o seu disco duro,

626
00:37:32,770 --> 00:37:35,350
e digamos que esta franxa aquí representa o ficheiro,

627
00:37:35,350 --> 00:37:38,390
e está composto de unha morea de 0s e 1s.

628
00:37:38,390 --> 00:37:42,470
O que acontece cando non só arrastrar o ficheiro ao lixo ou lixo

629
00:37:42,470 --> 00:37:48,020
pero tamén baleiralo-la? Especie de nada.

630
00:37:48,020 --> 00:37:49,640
Non hai absolutamente nada agora.

631
00:37:49,640 --> 00:37:54,290
Agora é só nada porque algo ocorre en forma de táboa.

632
00:37:54,290 --> 00:37:58,370
Polo tanto, hai unha especie de base de datos ou táboa dentro da memoria dun ordenador

633
00:37:58,370 --> 00:38:03,850
que, esencialmente, ten unha columna para arquivos dos nomes e unha columna para arquivos 'localización,

634
00:38:03,850 --> 00:38:07,720
onde isto pode ser lugar de 123, só un número aleatorio.

635
00:38:07,720 --> 00:38:14,560
Así, poderiamos ter algo x.jpeg e localización 123.

636
00:38:14,560 --> 00:38:18,800
O que acontece entón cando realmente baleirar o seu lixo?

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

638
00:38:20,330 --> 00:38:23,610
Pero o que non vai é a 0s e 1s.

639
00:38:23,610 --> 00:38:26,270
>> Entón, cal é entón a conexión pset4?

640
00:38:26,270 --> 00:38:31,240
Ben, con pset4, só porque temos accidentalmente borrados da tarxeta de memoria flash compacto

641
00:38:31,240 --> 00:38:35,750
que todas estas fotos ou só porque pola mala sorte se corrompeu

642
00:38:35,750 --> 00:38:38,000
non significa que os 0s e 1s non aínda están alí.

643
00:38:38,000 --> 00:38:40,410
Quizais algúns deles son perdidos porque algo foi corrompido

644
00:38:40,410 --> 00:38:43,320
no sentido de que algúns convertéronse en 0s e 1s 1s fixo 0s.

645
00:38:43,320 --> 00:38:47,240
Cousas malas poden ocorrer por mor do software de buggy ou hardware defectuosa.

646
00:38:47,240 --> 00:38:50,370
Pero moitos deses bits, quizais ata o 100% deles, aínda están alí.

647
00:38:50,370 --> 00:38:55,050
É que o ordenador ou a cámara non sabe onde comezou JPEG1

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

649
00:38:56,910 --> 00:39:01,070
Pero se, programador, sabe, con un pouco de habilidade onde os JPEGs son

650
00:39:01,070 --> 00:39:06,010
ou o que parece que poida analizar o JPEG 0s e 1s e dicir, JPEG,

651
00:39:06,010 --> 00:39:09,440
podes escribir un programa con esencialmente só un é ou while

652
00:39:09,440 --> 00:39:12,820
que recupera cada un destes ficheiros.

653
00:39:12,820 --> 00:39:16,030
Así, a lección, entón, é para comezar a xeito seguro de borrar os seus arquivos

654
00:39:16,030 --> 00:39:18,340
Se desexa evitar este completamente. Si

655
00:39:18,340 --> 00:39:21,010
>> [Alumno] Como é que di no seu computador

656
00:39:21,010 --> 00:39:23,550
que ten máis memoria do que fixo antes?

657
00:39:23,550 --> 00:39:27,820
Ter máis memoria do que fixo antes - >> [alumno] Máis memoria dispoñible.

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

659
00:39:29,630 --> 00:39:32,360
Entón, por que despois de baleirar o lixo do seu ordenador non dicir

660
00:39:32,360 --> 00:39:34,910
que teña máis espazo libre do que fixo antes?

661
00:39:34,910 --> 00:39:36,770
En poucas palabras, porque está mentindo.

662
00:39:36,770 --> 00:39:40,740
Máis tecnicamente, ten máis espazo, porque agora lle dixo

663
00:39:40,740 --> 00:39:43,680
pode pór outras cousas en que o ficheiro xa foi.

664
00:39:43,680 --> 00:39:45,450
Pero iso non significa que os bits están indo aínda que,

665
00:39:45,450 --> 00:39:48,590
e iso non significa que os bits están sendo substituidas para todos 0s, por exemplo,

666
00:39:48,590 --> 00:39:50,150
para a súa protección.

667
00:39:50,150 --> 00:39:54,640
Entón, por outra banda, se seguramente borrar arquivos ou destruír fisicamente o dispositivo,

668
00:39:54,640 --> 00:39:57,300
que realmente é a única forma, por veces, en torno a iso.

669
00:39:57,300 --> 00:40:02,020
>> Entón, por que non deixamos que a nota semi-asustado, e imos velo o luns.

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

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