1
00:00:00,000 --> 00:00:09,780
>> [Música tocando]

2
00:00:09,780 --> 00:00:11,150
>> ZAMYLA CHAN: Vamos enfrentar recuperar.

3
00:00:11,150 --> 00:00:14,030
Recuperar é provavelmente o meu favorito PSET,
e, principalmente, porque eu acho que é

4
00:00:14,030 --> 00:00:15,650
muito, muito legal.

5
00:00:15,650 --> 00:00:19,040
Basicamente, você está dado uma memória
arquivo de cartão em que

6
00:00:19,040 --> 00:00:20,900
fotos foram excluídos.

7
00:00:20,900 --> 00:00:23,650
Mas o que você vai
fazer é recuperá-los todos.

8
00:00:23,650 --> 00:00:24,250
>> OK.

9
00:00:24,250 --> 00:00:28,230
Então, é realmente excitante, mas talvez um
pouco intimidante, porque você é

10
00:00:28,230 --> 00:00:32,430
dado um arquivo e C vazio
você tem que preenchê-lo dentro

11
00:00:32,430 --> 00:00:36,250
OK, então vamos quebrar esse
em partes gerenciáveis.

12
00:00:36,250 --> 00:00:38,160
Você vai querer abrir o
de arquivos do cartão de memória.

13
00:00:38,160 --> 00:00:39,900
Isso parece bastante simples.

14
00:00:39,900 --> 00:00:43,030
Em seguida, localize o início
de uma imagem JPG.

15
00:00:43,030 --> 00:00:46,740
Todos os arquivos deste memória
cartão vão ser JPGs.

16
00:00:46,740 --> 00:00:50,840
Então, quando você encontrar o início,
você vai abrir uma nova JPG, que

17
00:00:50,840 --> 00:00:57,610
é, tipo, criar um JPG, e escrever 512
byte de cada vez até que um novo JPG é

18
00:00:57,610 --> 00:01:02,930
encontrado, e terminando o programa, uma vez que
você detectar o fim do arquivo.

19
00:01:02,930 --> 00:01:06,400
>> Então primeiros passos primeira é abrir
o arquivo de cartão de memória.

20
00:01:06,400 --> 00:01:09,850
Mas você já sabe disso, e não há
um arquivo de função I / O que vai

21
00:01:09,850 --> 00:01:12,030
ser muito útil.

22
00:01:12,030 --> 00:01:12,820
OK.

23
00:01:12,820 --> 00:01:14,760
Então, quais são JPGs?

24
00:01:14,760 --> 00:01:16,330
Porque precisamos começo.

25
00:01:16,330 --> 00:01:21,310
Bem, JPGs, assim como mapas de bits,
são apenas seqüências de bytes.

26
00:01:21,310 --> 00:01:30,660
Felizmente, cada JPG começa com um
0xff, 0xd8, 0xff, 0xE0, uma seqüência

27
00:01:30,660 --> 00:01:33,610
de bytes, ou outro
seqüência de bytes.

28
00:01:33,610 --> 00:01:37,250
>> Então esses quatro bytes indicam
o início de um JPG.

29
00:01:37,250 --> 00:01:40,780
Nada mais do que essas duas combinações
de quatro bytes.

30
00:01:40,780 --> 00:01:44,840
E felizmente para nós, outro fato que
pode aproveitar é que cada

31
00:01:44,840 --> 00:01:48,550
JPG é armazenado lado-a-lado
no cartão de memória.

32
00:01:48,550 --> 00:01:52,210
Eu representada a estrutura de um
cartão de memória esquematicamente nesta

33
00:01:52,210 --> 00:01:53,310
deslizar aqui.

34
00:01:53,310 --> 00:01:59,270
Aqui, cada praça, cada retângulo,
representa 512 bytes, e começa

35
00:01:59,270 --> 00:02:01,750
com um cinza em que nós não
realmente tem um JPG.

36
00:02:01,750 --> 00:02:05,700
>> Mas, então, finalmente, acertar
um bloco com uma estrela.

37
00:02:05,700 --> 00:02:10,940
Isso significa que os primeiros quatro bytes fora
dos 512 é um daqueles dois

38
00:02:10,940 --> 00:02:13,230
iniciar seqüências de um JPG.

39
00:02:13,230 --> 00:02:17,340
E vamos a partir daí, em seguida, uma vez
um JPG termina, o próximo começa.

40
00:02:17,340 --> 00:02:20,990
Não precisa nem mais
espaço cinza no meio.

41
00:02:20,990 --> 00:02:25,550
>> Mas como é que vamos realmente ler isto, e
ler os 512 bytes, para que possamos fazer

42
00:02:25,550 --> 00:02:27,500
a comparação do primeiro lugar?

43
00:02:27,500 --> 00:02:33,470
Bem, vamos voltar para fread, que
leva na estrutura que conterá

44
00:02:33,470 --> 00:02:34,470
os bytes que você está lendo.

45
00:02:34,470 --> 00:02:36,570
Então você está indo para colocar
aqueles em que -

46
00:02:36,570 --> 00:02:42,192
o tamanho, o número e, em seguida inpointer
que você está lendo a partir.

47
00:02:42,192 --> 00:02:49,900
Agora, queremos ler 512 de cada vez, e
queremos armazenar isso em um buffer,

48
00:02:49,900 --> 00:02:50,700
Vou chamá-lo.

49
00:02:50,700 --> 00:02:54,100
>> Basicamente, nós estamos indo para segurar
para essas 512 bytes e fazer

50
00:02:54,100 --> 00:02:55,500
coisas com ele, certo?

51
00:02:55,500 --> 00:02:58,260
Ou nós vamos comparar a primeira
quatro bytes, ou nós vamos

52
00:02:58,260 --> 00:02:59,830
ler-lo, OK?

53
00:02:59,830 --> 00:03:05,050
Então o ponteiro de dados será então
servir como seu buffer, ea

54
00:03:05,050 --> 00:03:07,745
inpointer, bem, isso só vai
para ser o seu cartão de memória.

55
00:03:07,745 --> 00:03:09,500
>> De volta ao nosso esquema de cartão de memória.

56
00:03:09,500 --> 00:03:14,690
Vamos ler 512 bytes de cada vez,
armazenando cada bloco de 512 bytes

57
00:03:14,690 --> 00:03:19,190
em um buffer, agarrando-se aqueles
tampão, essas 512 bytes, até que saibamos

58
00:03:19,190 --> 00:03:22,000
exatamente o que fazer deles.

59
00:03:22,000 --> 00:03:25,960
Assim, o começo não é nada, então
vamos ler o buffer, compará-lo, e

60
00:03:25,960 --> 00:03:28,160
nós não precisamos fazer nada com ele.

61
00:03:28,160 --> 00:03:32,030
E então, finalmente acertar uma estrela
bloquear, o que significa que nós temos

62
00:03:32,030 --> 00:03:33,630
encontramos nosso primeiro JPG.

63
00:03:33,630 --> 00:03:36,560
Então, o buffer agora detêm
bytes do que JPG.

64
00:03:36,560 --> 00:03:40,220
>> A próxima vez que 512 bytes, porque eles são
não um bloco de estrela, são também

65
00:03:40,220 --> 00:03:41,740
parte desse JPG.

66
00:03:41,740 --> 00:03:47,630
E JPGs são contínuas a partir daí
em diante, até chegarmos a próxima JPG.

67
00:03:47,630 --> 00:03:51,880
E então o buffer então segura
512 bytes para que JPG e

68
00:03:51,880 --> 00:03:53,580
assim por diante, e assim por diante.

69
00:03:53,580 --> 00:03:54,250
OK.

70
00:03:54,250 --> 00:03:58,980
>> Então, quando você acertar o primeiro estrelado
bloco, a primeira JPG, como você

71
00:03:58,980 --> 00:04:01,910
na verdade, bem, abri-lo?

72
00:04:01,910 --> 00:04:04,990
Vamos fazer um novo JPG.

73
00:04:04,990 --> 00:04:08,846
Os nomes de arquivos para um JPG vão
ter o formato, o número, o número,

74
00:04:08,846 --> 00:04:13,830
number.jpg, na medida em que está nomeado em
a ordem na qual eles se encontram,

75
00:04:13,830 --> 00:04:14,780
começando em 0.

76
00:04:14,780 --> 00:04:19,890
>> Assim, o primeiro JPG que você
encontrar será 000.jpg.

77
00:04:19,890 --> 00:04:26,560
Então, provavelmente uma boa idéia para manter um registo
de quantas JPGs que você encontrou até agora.

78
00:04:26,560 --> 00:04:27,610
Então esse é o nome do arquivo.

79
00:04:27,610 --> 00:04:29,660
Mas como você realmente fazer isso?

80
00:04:29,660 --> 00:04:34,310
Bem, nós estamos indo para usar um
função chamada sprintf.

81
00:04:34,310 --> 00:04:38,260
Um pouco semelhante ao printf, onde
você pode usar espaços reservados para cordas,

82
00:04:38,260 --> 00:04:42,420
só que neste caso, sprintf imprimirá
o arquivo para fora no atual

83
00:04:42,420 --> 00:04:45,550
diretório, não no terminal.

84
00:04:45,550 --> 00:04:46,120
>> OK.

85
00:04:46,120 --> 00:04:49,950
Então, vamos ver que temos o título,
uma matriz de char que irá armazenar o

86
00:04:49,950 --> 00:04:55,120
cadeia resultante, e passamos no
título da seqüência real com uma

87
00:04:55,120 --> 00:04:58,720
espaço reservado, assim como nós
aprendi a fazer com printf.

88
00:04:58,720 --> 00:05:05,530
Mas esse código que eu tenho aqui
dará 2.jpg, não 002.jpg.

89
00:05:05,530 --> 00:05:09,920
Então, eu vou deixar você para descobrir como
modificar o espaço reservado para fazer a

90
00:05:09,920 --> 00:05:11,920
nome correto.

91
00:05:11,920 --> 00:05:12,610
>> OK.

92
00:05:12,610 --> 00:05:17,390
Então, uma vez que você sprintf'd então você pode
abrir esse arquivo, porque existe em

93
00:05:17,390 --> 00:05:22,690
seu diretório, com fopen, usando o
título e qualquer que seja o modo que você quer

94
00:05:22,690 --> 00:05:25,140
para abrir esse arquivo dentro

95
00:05:25,140 --> 00:05:30,260
Portanto, agora que abrimos um novo arquivo JPG,
agora podemos escrever 512 bytes em um

96
00:05:30,260 --> 00:05:33,320
tempo, até que um novo JPG é encontrado.

97
00:05:33,320 --> 00:05:36,640
Então, vamos ter um outro olhar
na sintaxe de fwrite.

98
00:05:36,640 --> 00:05:40,060
>> Eu sei que eu estou mostrando este slide um
muito, mas eu só quero ter certeza de que

99
00:05:40,060 --> 00:05:43,530
Vocês não ficar muito confuso, porque
Eu sei que é muito fácil de

100
00:05:43,530 --> 00:05:47,000
misturar-se a primeira e a última
argumento, em particular.

101
00:05:47,000 --> 00:05:54,390
Mas lembre-se que você está escrevendo a partir de
seu buffer nas imagens de arquivo para fora.

102
00:05:54,390 --> 00:05:59,250
>> Agora que você sabe como a gravação de 512
bytes em seu arquivo JPG que você tem

103
00:05:59,250 --> 00:06:03,230
criado, bem, nós queremos parar com isso
processo uma vez que tenhamos chegado ao fim da

104
00:06:03,230 --> 00:06:06,720
a placa, porque não haverá
mais imagens para ser encontrado.

105
00:06:06,720 --> 00:06:10,760
Então vamos voltar para fread
mais uma vez, eu prometo.

106
00:06:10,760 --> 00:06:15,600
fread retorna quantos itens de tamanho,
tamanho, estavam prontos em sucesso.

107
00:06:15,600 --> 00:06:19,440
O ideal é que isso vai ser o que
você passar por número, certo?

108
00:06:19,440 --> 00:06:24,140
Porque você está tentando ler o número
de elementos de tamanho, o tamanho.

109
00:06:24,140 --> 00:06:29,380
Mas se fread não é capaz de ler que
número de elementos, então ele vai voltar

110
00:06:29,380 --> 00:06:32,530
qualquer número que lido com sucesso.

111
00:06:32,530 --> 00:06:36,310
>> Agora, uma coisa importante a salientar é
que se você usar outro arquivo I / O

112
00:06:36,310 --> 00:06:43,860
função como fgetc, ele também vai voltar
quantos itens ele ler com sucesso.

113
00:06:43,860 --> 00:06:48,000
O que é útil sobre esta função é
que se você utilizar as funções dentro de uma

114
00:06:48,000 --> 00:06:53,190
condição, ele vai executar-se enquanto
determinar essa condição, o que é

115
00:06:53,190 --> 00:06:54,340
realmente muito útil.

116
00:06:54,340 --> 00:07:00,440
Então se você tem esta condição, digamos,
se tampão fread, CÃO sizeof, 2,

117
00:07:00,440 --> 00:07:04,870
ponteiro, é igual é igual a 1, isto
significa que eu gostaria de ler

118
00:07:04,870 --> 00:07:06,540
2 cães no momento.

119
00:07:06,540 --> 00:07:13,490
Mas se fread retorna uma vez de duas como
esperado, o que significa que existem dois

120
00:07:13,490 --> 00:07:16,480
cães deixados no meu arquivo, mas sim 1.

121
00:07:16,480 --> 00:07:22,450
Mas se ele retorna 2, então eu ainda tenho
esses dois cães dentro do meu tampão.

122
00:07:22,450 --> 00:07:26,280
>> Portanto, agora que lhe dá uma sensação de como
verificar o fim do arquivo, mas

123
00:07:26,280 --> 00:07:28,940
vamos passar por agora a lógica.

124
00:07:28,940 --> 00:07:32,460
Como é que vamos realmente remendar tudo
esses elementos juntos?

125
00:07:32,460 --> 00:07:36,880
Uma vez que nós batemos o nosso primeiro JPG, desde
sabemos que JPGs são armazenados

126
00:07:36,880 --> 00:07:40,910
contígua, estaremos escrevendo até
chegamos ao final do arquivo do cartão.

127
00:07:40,910 --> 00:07:43,950
Mas não quero escrever
nada até então.

128
00:07:43,950 --> 00:07:48,710
Então, é importante, não só que estamos no
o início de um novo JPG, mas se

129
00:07:48,710 --> 00:07:50,655
já encontramos um JPG ou não.

130
00:07:50,655 --> 00:07:55,390
>> Se É o início de uma nova JPG, nós vamos
quer fechar nossa atual arquivo JPG se

131
00:07:55,390 --> 00:07:59,110
temos um aberto e aberto
um novo para escrever em.

132
00:07:59,110 --> 00:08:03,340
Se não é o início do novo JPG,
porém, vamos manter o mesmo arquivo JPG

133
00:08:03,340 --> 00:08:05,910
abrir e escrever para isso.

134
00:08:05,910 --> 00:08:10,100
Vamos escrever a nossa reserva para qualquer
Arquivo JPG temos aberto, desde que

135
00:08:10,100 --> 00:08:12,120
temos uma aberta, é claro.

136
00:08:12,120 --> 00:08:16,190
Se nós não encontramos nosso primeiro JPG
ainda, não escreva nada.

137
00:08:16,190 --> 00:08:20,290
E este processo continua até que você
atingir o fim do ficheiro do cartão.

138
00:08:20,290 --> 00:08:23,410
>> E, finalmente, você vai querer fazer
Certifique-se de que você fclose qualquer

139
00:08:23,410 --> 00:08:25,800
arquivos que você fopened.

140
00:08:25,800 --> 00:08:28,360
Uma vez que você está confortável com o
conceitos, dê uma olhada em algumas

141
00:08:28,360 --> 00:08:30,840
pseudocódigo, que eu incluí aqui.

142
00:08:30,840 --> 00:08:34,830
Primeiro, você deseja abrir o arquivo de cartão,
e em seguida, repita o processo a seguir

143
00:08:34,830 --> 00:08:37,144
até que você tenha atingido o
extremidade do cartão.

144
00:08:37,144 --> 00:08:40,880
Você quer ler 512 bytes
em um tampão.

145
00:08:40,880 --> 00:08:43,934
Usando esse buffer, você vai querer verificar
se você está no início de um

146
00:08:43,934 --> 00:08:45,300
novo JPG ou não.

147
00:08:45,300 --> 00:08:48,400
E a resposta para essa pergunta vai
afetar o seu gerenciamento de arquivos -

148
00:08:48,400 --> 00:08:51,940
quais arquivos você aberto, o que
aqueles que você fechar.

149
00:08:51,940 --> 00:08:55,220
>> Em seguida, você já encontrou um JPG?

150
00:08:55,220 --> 00:08:57,740
Como você tem sido manter
o controle de que?

151
00:08:57,740 --> 00:09:01,735
Então, dependendo do que, você quer
escrever para o JPG atual que

152
00:09:01,735 --> 00:09:07,090
ter aberto, ou não escrevê-lo em tudo,
porque você ainda não encontrou um JPG ainda.

153
00:09:07,090 --> 00:09:10,870
Finalmente, uma vez que você chegou ao fim da
o arquivo, você vai querer fechar qualquer

154
00:09:10,870 --> 00:09:12,590
remanescente arquivos que você tenha aberto.

155
00:09:12,590 --> 00:09:14,590
Queremos ser arrumado aqui.

156
00:09:14,590 --> 00:09:18,790
>> E com isso, você já recuperou todos
os arquivos ausentes de que a memória

157
00:09:18,790 --> 00:09:21,620
cartão, o que é um feito incrível.

158
00:09:21,620 --> 00:09:23,430
Então, palmadinhas nas costas.

159
00:09:23,430 --> 00:09:27,560
Mas, há mais um elemento para
o PSET, que é a competição.

160
00:09:27,560 --> 00:09:30,920
Você verá que todas as imagens
que você tenha recuperado são realmente

161
00:09:30,920 --> 00:09:32,820
fotos de funcionários do CS50.

162
00:09:32,820 --> 00:09:38,500
Então, se você está no campus ou em algum lugar
próximo, então você pode tirar fotos com

163
00:09:38,500 --> 00:09:42,600
o pessoal, ea seção que tem o
a maioria das fotos com os membros da equipe

164
00:09:42,600 --> 00:09:46,940
a partir de seus arquivos recuperados serão
receber um prêmio incrível.

165
00:09:46,940 --> 00:09:50,650
Com isso, depois que você terminou
o PSET recuperar.

166
00:09:50,650 --> 00:09:53,600
Meu nome é Zamyla, e este é CS50.

167
00:09:53,600 --> 00:10:01,835