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
Но вы знаете, это уже и есть
файл функция ввода / вывода, что собирается

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, 0xff, 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
Никто иной, как этих двух комбинаций
из четырех байт.

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
И мы идем оттуда, а затем один раз
один 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
И вот мы видим, что у нас есть название,
массив символов, который будет хранить

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
>> Теперь одна важная вещь, следует отметить,
что если вы используете другой файл ввода / вывода

112
00:06:36,310 --> 00:06:43,860
функции, как fgetc, это будет также возвращать
сколько элементов он успешно читал.

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 возвращает 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