1
00:00:00,000 --> 00:00:09,780
>> [音乐播放]

2
00:00:09,780 --> 00:00:11,150
>> ZAMYLA陈：让我们来解决恢复。

3
00:00:11,150 --> 00:00:14,030
恢复大概是我最喜欢的PSET，
，主要是因为我认为这是

4
00:00:14,030 --> 00:00:15,650
真的，真的很酷。

5
00:00:15,650 --> 00:00:19,040
基本上，你给出一个记忆
卡文件中，

6
00:00:19,040 --> 00:00:20,900
图像已被删除。

7
00:00:20,900 --> 00:00:23,650
但是，你要什么
做的是恢复他们所有。

8
00:00:23,650 --> 00:00:24,250
>> 确定。

9
00:00:24,250 --> 00:00:28,230
所以这是非常激动人心的，但也许一
有点吓人，因为你

10
00:00:28,230 --> 00:00:32,430
给定一个空的C文件和
你必须填写。

11
00:00:32,430 --> 00:00:36,250
好了，让我们打破这种
成可管理的部分。

12
00:00:36,250 --> 00:00:38,160
你要打开
内存卡文件。

13
00:00:38,160 --> 00:00:39,900
这似乎很简单。

14
00:00:39,900 --> 00:00:43,030
然后，找到开始
的JPG图片。

15
00:00:43,030 --> 00:00:46,740
所有在此内存中的文件
卡都将是JPG格式。

16
00:00:46,740 --> 00:00:50,840
然后，一旦你发现之初，
你要打开一个新的JPG，那

17
00:00:50,840 --> 00:00:57,610
是一样，创建一个JPG文件，并写512
在同一时间，直到一个新的JPG是字节

18
00:00:57,610 --> 00:01:02,930
发现，并结束该程序，一旦
你侦测文件的末尾。

19
00:01:02,930 --> 00:01:06,400
>> 所以，第一步首先是要打开
存储卡的文件。

20
00:01:06,400 --> 00:01:09,850
但你知道这已经，而且也
文件I / O功能，那将

21
00:01:09,850 --> 00:01:12,030
证明是非常有用的。

22
00:01:12,030 --> 00:01:12,820
确定。

23
00:01:12,820 --> 00:01:14,760
那么什么是JPG格式？

24
00:01:14,760 --> 00:01:16,330
因为我们需要开始的时候。

25
00:01:16,330 --> 00:01:21,310
好吧，JPG格式，就像位图，
是字节的只是序列。

26
00:01:21,310 --> 00:01:30,660
幸运的是，每一个JPG文件开始与任何
为0xff，为0xD8，255，0XE0，一个序列

27
00:01:30,660 --> 00:01:33,610
的字节，或另一
字节序列。

28
00:01:33,610 --> 00:01:37,250
>> 因此，这四个字节表示
一个JPG文件的开始。

29
00:01:37,250 --> 00:01:40,780
没有比这两个组合其他
的4个字节。

30
00:01:40,780 --> 00:01:44,840
而幸运的是，另一个事实是，我们
可以利用的就是每一个

31
00:01:44,840 --> 00:01:48,550
JPG存储并排侧
在存储卡。

32
00:01:48,550 --> 00:01:52,210
我所代表的结构
示意图在此存储卡

33
00:01:52,210 --> 00:01:53,310
滑动在这里。

34
00:01:53,310 --> 00:01:59,270
在这里，每一个广场，每一个矩形，
代表512个字节，并开始

35
00:01:59,270 --> 00:02:01,750
在一个灰色的，我们不
真的有一个JPG文件。

36
00:02:01,750 --> 00:02:05,700
>> 但后来，我们终于打
有星号的块。

37
00:02:05,700 --> 00:02:10,940
这意味着，前四个字节出
那些512是指两个中的一个

38
00:02:10,940 --> 00:02:13,230
开始的JPG序列。

39
00:02:13,230 --> 00:02:17,340
我们从那里，然后一旦
1 JPG结束，下一个开始。

40
00:02:17,340 --> 00:02:20,990
我们永远不要有任何更多
灰色空间在两者之间。

41
00:02:20,990 --> 00:02:25,550
>> 但是，我们到底怎么读这一点，
读取512字节，这样我们可以使

42
00:02:25,550 --> 00:02:27,500
比较的第一个地方？

43
00:02:27,500 --> 00:02:33,470
好吧，让我们回到FREAD，这
在需要将包含结构

44
00:02:33,470 --> 00:02:34,470
您正在阅读的字节数。

45
00:02:34,470 --> 00:02:36,570
所以，你要放
那些在那里 - 

46
00:02:36,570 --> 00:02:42,192
的大小，数量，然后inpointer
您正在阅读的。

47
00:02:42,192 --> 00:02:49,900
现在，我们要读512的时间，并
我们要存储这个缓冲区中，

48
00:02:49,900 --> 00:02:50,700
我要调用它。

49
00:02:50,700 --> 00:02:54,100
>> 基本上，我们打算举行
那些上512字节和做

50
00:02:54,100 --> 00:02:55,500
事情有了它，对不对？

51
00:02:55,500 --> 00:02:58,260
我们不是要比较的第一个
四个字节，或者我们要

52
00:02:58,260 --> 00:02:59,830
读它，好不好？

53
00:02:59,830 --> 00:03:05,050
那么接下来的数据指针，然后将
作为您的缓冲区，

54
00:03:05,050 --> 00:03:07,745
inpointer，嗯，这只是要
是你的内存卡。

55
00:03:07,745 --> 00:03:09,500
>> 回到我们的记忆卡原理图。

56
00:03:09,500 --> 00:03:14,690
我们要读512字节的时间，
存储每512字节块

57
00:03:14,690 --> 00:03:19,190
到缓冲区中，抓着那些
缓冲，这些512字节，直到我们知道

58
00:03:19,190 --> 00:03:22,000
到底该怎么做他们。

59
00:03:22,000 --> 00:03:25,960
所以一开始没有什么，所以
我们将读取缓冲区，比较它，

60
00:03:25,960 --> 00:03:28,160
我们将不再需要用它做任何事情。

61
00:03:28,160 --> 00:03:32,030
然后，我们终于打了一个星
封锁，这意味着我们已经

62
00:03:32,030 --> 00:03:33,630
发现我们的第一个JPG文件。

63
00:03:33,630 --> 00:03:36,560
因此，缓冲区现在持有
从JPG字节。

64
00:03:36,560 --> 00:03:40,220
>> 下一次512个字节，因为他们
不是明星的块，也

65
00:03:40,220 --> 00:03:41,740
该JPG的一部分。

66
00:03:41,740 --> 00:03:47,630
和JPG格式是从那里连续
在，直到我们打了下一个JPG文件。

67
00:03:47,630 --> 00:03:51,880
然后在缓冲区，然后保存
512字节为JPG和

68
00:03:51,880 --> 00:03:53,580
等等，等等。

69
00:03:53,580 --> 00:03:54,250
确定。

70
00:03:54,250 --> 00:03:58,980
>> 所以，一旦你打的第一个星号的
块，第一个JPG文件，你怎么

71
00:03:58,980 --> 00:04:01,910
其实，好了，打开它？

72
00:04:01,910 --> 00:04:04,990
让我们做一个新的JPG。

73
00:04:04,990 --> 00:04:08,846
文件名的JPG格式要
在该格式中，数，数字，

74
00:04:08,846 --> 00:04:13,830
number.jpg，因为他们在一个名为
它们被发现的顺序，

75
00:04:13,830 --> 00:04:14,780
从0开始。

76
00:04:14,780 --> 00:04:19,890
>> 所以第一个JPG文件，你
发现将被000.jpg。

77
00:04:19,890 --> 00:04:26,560
所以，可能是一个好主意来跟踪
你有多少JPG格式迄今为止发现。

78
00:04:26,560 --> 00:04:27,610
所以这是文件名。

79
00:04:27,610 --> 00:04:29,660
但是你怎么居然作出这样的？

80
00:04:29,660 --> 00:04:34,310
好了，我们要使用一个
函数调用sprintf的。

81
00:04:34,310 --> 00:04:38,260
类似于printf的一点点，在那里
您可以使用占位符的字符串，

82
00:04:38,260 --> 00:04:42,420
除了在这种情况下，sprintf的将打印
出该文件到当前

83
00:04:42,420 --> 00:04:45,550
目录，而不是到终端。

84
00:04:45,550 --> 00:04:46,120
>> 确定。

85
00:04:46,120 --> 00:04:49,950
所以在这里我们可以看到，我们有标题，
一个char数组将存储

86
00:04:49,950 --> 00:04:55,120
结果字符串，并且我们通过在
与实际字符串的标题

87
00:04:55,120 --> 00:04:58,720
占位符，就像我们已经
学会做的printf。

88
00:04:58,720 --> 00:05:05,530
但是这个代码，我这里
会给2.JPG，不002.JPG。

89
00:05:05,530 --> 00:05:09,920
所以我会离开你找出如何
修改中的占位符以使

90
00:05:09,920 --> 00:05:11,920
正确的名称。

91
00:05:11,920 --> 00:05:12,610
>> 确定。

92
00:05:12,610 --> 00:05:17,390
所以，一旦你sprintf'd那么你就可以
打开该文件，因为它存在于

93
00:05:17,390 --> 00:05:22,690
您的目录，用fopen，使用
标题，然后你想要的任何方式

94
00:05:22,690 --> 00:05:25,140
英寸打开该文件

95
00:05:25,140 --> 00:05:30,260
所以，现在，我们已经打开了一个新的JPG文件，
现在我们可以在写512个字节

96
00:05:30,260 --> 00:05:33,320
时间，直到新的JPG被发现。

97
00:05:33,320 --> 00:05:36,640
因此，让我们再看一下
在fwrite的语法。

98
00:05:36,640 --> 00:05:40,060
>> 我知道，我展示这张幻灯片一
很多，但我只是想确保

99
00:05:40,060 --> 00:05:43,530
你们不要太糊涂了，因为
我知道这是很容易

100
00:05:43,530 --> 00:05:47,000
混淆的第一个和最后一个
的说法，尤其如此。

101
00:05:47,000 --> 00:05:54,390
但要记住，你是从写
您的缓冲区到了文件中的图像。

102
00:05:54,390 --> 00:05:59,250
>> 现在你知道怎么写512
字节到，你已经你的JPG文件

103
00:05:59,250 --> 00:06:03,230
创建好了，我们要停止
过程中，一旦我们已经达到的结束

104
00:06:03,230 --> 00:06:06,720
我们的卡，因为不会有
任何更多的图像被发现。

105
00:06:06,720 --> 00:06:10,760
因此，让我们回去的fread
再一次，我保证。

106
00:06:10,760 --> 00:06:15,600
用fread返回的大小多少个项目，
大小，准备成功。

107
00:06:15,600 --> 00:06:19,440
理想情况下，这将是任何
您传递的数量，对不对？

108
00:06:19,440 --> 00:06:24,140
因为你试图读取数
的大小，尺寸元素。

109
00:06:24,140 --> 00:06:29,380
但如果用fread不能够读取该
元素的个数，那么它将返回

110
00:06:29,380 --> 00:06:32,530
不管它多少成功读取。

111
00:06:32,530 --> 00:06:36,310
>> 现在，需要注意的一件重要的事情是
如果您使用其他文件I / O

112
00:06:36,310 --> 00:06:43,860
象龟etc功能，它也将返回
有多少项目是成功读取。

113
00:06:43,860 --> 00:06:48,000
什么是关于这个功能是非常有用
如果你使用的内部功能

114
00:06:48,000 --> 00:06:53,190
情况下，它会执行本身，而
判定条件，这是

115
00:06:53,190 --> 00:06:54,340
只是真的很有用。

116
00:06:54,340 --> 00:07:00,440
所以，如果你有这样的情况，比方说，
如果用fread缓冲区的sizeof狗，2，

117
00:07:00,440 --> 00:07:04,870
指针，等于等于1，即
也就是说，我想读

118
00:07:04,870 --> 00:07:06,540
2狗的时候。

119
00:07:06,540 --> 00:07:13,490
但如果用fread返回，而不是2 1作为
预期，这意味着有2

120
00:07:13,490 --> 00:07:16,480
留在我的文件中的狗，而是1。

121
00:07:16,480 --> 00:07:22,450
但是，如果返回2，那么我仍然有
那些狗2我的缓冲区内。

122
00:07:22,450 --> 00:07:26,280
>> 所以，现在给你如何感
检查该文件的结束，但

123
00:07:26,280 --> 00:07:28,940
让我们通过现在的逻辑。

124
00:07:28,940 --> 00:07:32,460
我们到底怎么拼凑所有
这些元素结合在一起？

125
00:07:32,460 --> 00:07:36,880
一旦我们达到我们的第一个JPG文件，因为
我们知道，JPG格式存储

126
00:07:36,880 --> 00:07:40,910
连续，我们会写，直到
我们到达卡片文件的末尾。

127
00:07:40,910 --> 00:07:43,950
但我们不想写
什么再说吧。

128
00:07:43,950 --> 00:07:48,710
所以它很重要，不仅是我们在
新的JPG开始，但无论

129
00:07:48,710 --> 00:07:50,655
我们已经找到了一个JPG或者没有。

130
00:07:50,655 --> 00:07:55,390
>> 如果它是一个新的JPG的开始，我们将
要关闭我们目前的JPG文件，如果

131
00:07:55,390 --> 00:07:59,110
我们有一个开放的，开放的
一个新的写进去。

132
00:07:59,110 --> 00:08:03,340
如果不是新的JPG的开始，
不过，我们将保持相同的JPG文件

133
00:08:03,340 --> 00:08:05,910
打开和写入到这一点。

134
00:08:05,910 --> 00:08:10,100
我们会写我们的缓冲区中取
我们有开放的JPG文件，但前提是

135
00:08:10,100 --> 00:08:12,120
我们有一个开放的，当然。

136
00:08:12,120 --> 00:08:16,190
如果我们还没有发现我们的第一个JPG
然而，我们不写任何东西。

137
00:08:16,190 --> 00:08:20,290
而这个过程一直持续到你
到达卡片文件的末尾。

138
00:08:20,290 --> 00:08:23,410
>> 最后，你会希望
确保您FCLOSE任何

139
00:08:23,410 --> 00:08:25,800
你已经fopened文件。

140
00:08:25,800 --> 00:08:28,360
一旦你熟悉了
概念，来看看一些

141
00:08:28,360 --> 00:08:30,840
伪代码，我已经包括在这里。

142
00:08:30,840 --> 00:08:34,830
首先，你要打开的卡文件，
然后重复以下过程

143
00:08:34,830 --> 00:08:37,144
直到你已经达到了
该卡的结束。

144
00:08:37,144 --> 00:08:40,880
你想读的512个字节
入缓冲区。

145
00:08:40,880 --> 00:08:43,934
使用该缓冲区，你要检查
无论你是在一个开始

146
00:08:43,934 --> 00:08:45,300
新的JPG或没有。

147
00:08:45,300 --> 00:08:48,400
而这个问题的答案会
影响你的文件管理 - 

148
00:08:48,400 --> 00:08:51,940
你打开文件，
那些你关闭。

149
00:08:51,940 --> 00:08:55,220
>> 那么，你已经找到了一个JPG文件？

150
00:08:55,220 --> 00:08:57,740
你是如何一直保持
轨迹是什么？

151
00:08:57,740 --> 00:09:01,735
然后，根据这一点，你会要么
写入到当前的JPG，你

152
00:09:01,735 --> 00:09:07,090
有开放的，或者不写它在所有，
因为你还没有找到一个JPG文件呢。

153
00:09:07,090 --> 00:09:10,870
最后，一​​旦你已经达到年底
该文件，你要关闭任何

154
00:09:10,870 --> 00:09:12,590
其余的已打开的文件。

155
00:09:12,590 --> 00:09:14,590
我们希望在这里整齐。

156
00:09:14,590 --> 00:09:18,790
>> 有了这样的，你已经恢复了所有的
从内存中丢失的文件

157
00:09:18,790 --> 00:09:21,620
卡，这是一个相当惊人的壮举。

158
00:09:21,620 --> 00:09:23,430
于是拍拍自己的背。

159
00:09:23,430 --> 00:09:27,560
但是，还有一元素
在PSET，这是比赛。

160
00:09:27,560 --> 00:09:30,920
你会发现，所有的图片
你已经恢复实际上是

161
00:09:30,920 --> 00:09:32,820
CS50的工作人员的照片。

162
00:09:32,820 --> 00:09:38,500
所以，如果你在校园里或其他地方
近了，那么你可以拍摄

163
00:09:38,500 --> 00:09:42,600
工作人员，并具有节
最留念的工作人员

164
00:09:42,600 --> 00:09:46,940
从他们恢复的文件将
得到一个真棒奖品。

165
00:09:46,940 --> 00:09:50,650
有了这一点，那么你已经完成
在恢复PSET。

166
00:09:50,650 --> 00:09:53,600
我的名字是Zamyla，这是CS50。

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