1
00:00:00,000 --> 00:00:02,860
[Powered by Google Translate] [Неделя 5]

2
00:00:02,860 --> 00:00:04,860
[David J. Малан - Гарвардский университет]

3
00:00:04,860 --> 00:00:07,260
[Это CS50. - CS50.TV]

4
00:00:07,260 --> 00:00:09,740
>> Это CS50, 5-я неделя.

5
00:00:09,740 --> 00:00:12,900
Сегодня и на этой неделе, мы вводим немного мире судебно-медицинской экспертизы

6
00:00:12,900 --> 00:00:14,850
в контексте поставленной задачи 4.

7
00:00:14,850 --> 00:00:18,480
Сегодня будет сокращенно лекцию, потому что есть специальное мероприятие здесь впоследствии.

8
00:00:18,480 --> 00:00:21,940
Поэтому мы заглянуть и дразнить как студентов, так и их родителей сегодня

9
00:00:21,940 --> 00:00:24,600
с некоторыми из вещей, которые на горизонте.

10
00:00:24,600 --> 00:00:29,050
>> Среди них, как в понедельник, у вас будет еще несколько одноклассников.

11
00:00:29,050 --> 00:00:32,980
EDX, Гарвард и новые онлайн инициативе MIT для OpenCourseWare и больше,

12
00:00:32,980 --> 00:00:36,730
запускает на кампусе Гарвардского университета в понедельник, что означает пришел понедельник

13
00:00:36,730 --> 00:00:40,930
Вы будете иметь, по состоянию последним подсчетам, 86 тысяч дополнительных одноклассников

14
00:00:40,930 --> 00:00:43,680
кто будет следующим наряду с лекциями CS50 и секции

15
00:00:43,680 --> 00:00:45,890
и пошаговые руководства и проблема множеств.

16
00:00:45,890 --> 00:00:51,870
И как часть этого, вы станете членами первого класса CS50 и теперь CS50x.

17
00:00:51,870 --> 00:00:56,150
В рамках этого сейчас, понимаю, что там будут какие-то положительные моменты, а также.

18
00:00:56,150 --> 00:01:00,620
Чтобы подготовиться к этому, для огромного количества студентов,

19
00:01:00,620 --> 00:01:03,820
Достаточно сказать, что, хотя у нас есть 108 TFs и сертификации,

20
00:01:03,820 --> 00:01:07,560
это не совсем лучший ученик-учитель соотношении один раз мы попали 80000 студентов.

21
00:01:07,560 --> 00:01:09,830
Мы не собираемся быть сортировка столько проблема устанавливается вручную,

22
00:01:09,830 --> 00:01:13,050
так представила на этой неделе в задаче набор будет CS50 проверки,

23
00:01:13,050 --> 00:01:15,410
который будет утилиту командной строки внутри прибора

24
00:01:15,410 --> 00:01:17,880
что вы получите, как только вы обновите его в конце этой недели.

25
00:01:17,880 --> 00:01:21,030
Вы будете иметь возможность запускать команды, check50, на свой собственный PSET,

26
00:01:21,030 --> 00:01:24,770
и вы получите мгновенную обратную связь относительно того, ваша программа является правильной или неправильной

27
00:01:24,770 --> 00:01:27,980
в соответствии с различными спецификациями дизайна, которые мы предоставляем.

28
00:01:27,980 --> 00:01:30,310
Подробнее об этом в описании множества проблем.

29
00:01:30,310 --> 00:01:34,220
CS50x одноклассники будут использовать его.

30
00:01:34,220 --> 00:01:36,170
>> Проблема Set 4 это все о судебной экспертизы,

31
00:01:36,170 --> 00:01:38,630
и это PSET был действительно вдохновлен некоторые реальные вещи

32
00:01:38,630 --> 00:01:41,210
которому, когда я был в аспирантуре я интернированы на время

33
00:01:41,210 --> 00:01:45,270
с офисом окружного прокурора округа Миддлсекс дела идут судебно-медицинской экспертизы

34
00:01:45,270 --> 00:01:47,660
с их ведущим судебным следователем.

35
00:01:47,660 --> 00:01:50,280
Что это означало, как я думаю, я уже несколько недель прошлом,

36
00:01:50,280 --> 00:01:52,720
масса Государственной полиции или других войдет,

37
00:01:52,720 --> 00:01:56,150
они уходят такие вещи, как жесткие диски и компакт-диски и дискеты и т.п.,

38
00:01:56,150 --> 00:01:58,770
и тогда цель офис экспертизы было выяснить

39
00:01:58,770 --> 00:02:01,470
было ли или не было доказательств какой-то.

40
00:02:01,470 --> 00:02:04,730
Это был Специальная следственная группа, так что белых воротничков преступления.

41
00:02:04,730 --> 00:02:10,949
Это было более тревожным рода преступлениях, ничего участием некоторых видов цифровых носителей.

42
00:02:10,949 --> 00:02:16,450
Оказывается, что не так много людей пишут письмо сказав: "Я сделал это".

43
00:02:16,450 --> 00:02:20,490
Так довольно часто, эти судебные поиски не оказаться все, что много фруктов,

44
00:02:20,490 --> 00:02:22,820
но иногда люди будут писать такие письма.

45
00:02:22,820 --> 00:02:25,240
Так что иногда, усилия были вознаграждены.

46
00:02:25,240 --> 00:02:31,210
>> Но доводить до этого судебно PSET, мы будем представлять в pset4 немного графики.

47
00:02:31,210 --> 00:02:35,410
Вы, наверное, взять эти вещи само собой разумеющееся - JPEG, GIF, и тому подобное - в эти дни.

48
00:02:35,410 --> 00:02:38,320
Но если вы действительно думаете об этом, изображение, так же, как лицо Роба,

49
00:02:38,320 --> 00:02:41,270
могут быть смоделированы в виде последовательности точек или пикселей.

50
00:02:41,270 --> 00:02:43,380
В случае лице Роба, есть все виды цветов,

51
00:02:43,380 --> 00:02:46,760
и мы начали видеть отдельные точки, иначе известный как пикселов,

52
00:02:46,760 --> 00:02:48,610
как только мы начали, чтобы увеличить масштаб

53
00:02:48,610 --> 00:02:54,660
Но если мы упростим мире немного, и просто сказать, что это здесь Роб в черно-белом,

54
00:02:54,660 --> 00:02:57,490
представлять черное и белое, мы можем просто использовать бинарный.

55
00:02:57,490 --> 00:03:01,660
И если мы собираемся использовать двоичный, 1 или 0, мы можем выразить это же изображение

56
00:03:01,660 --> 00:03:06,140
улыбающееся лицо Роба с этой картины бит.

57
00:03:06,140 --> 00:03:12,100
11000011 представляет белый, белый, черный, черный, черный, черный, белый, белый.

58
00:03:12,100 --> 00:03:16,150
И это не огромный скачок потом начинают говорить о красочных фотографий,

59
00:03:16,150 --> 00:03:18,600
вещи, которые вы видите на Facebook или взять с собой цифровую камеру.

60
00:03:18,600 --> 00:03:21,410
Но, конечно, когда дело доходит до цветов, вам нужно больше битов.

61
00:03:21,410 --> 00:03:25,690
И весьма распространены в мире фотографии является использование не является 1-битный цвет,

62
00:03:25,690 --> 00:03:29,560
так как это предполагает, но 24-битный цвет, где вы фактически получаете миллионы цветов.

63
00:03:29,560 --> 00:03:32,250
Так как в случае, когда мы увеличено на глаза Роба,

64
00:03:32,250 --> 00:03:36,370
, что было любое количество миллионы различных красочных возможностей.

65
00:03:36,370 --> 00:03:39,040
Таким образом, мы введем это в проблеме Set 4, а также в руководстве

66
00:03:39,040 --> 00:03:43,370
который будет сегодня в 3:30 вместо обычного 2:30, потому что лекции пятницу здесь.

67
00:03:43,370 --> 00:03:46,620
Но видео будет в режиме онлайн, как обычно, завтра.

68
00:03:46,620 --> 00:03:48,820
>> Мы также познакомим вас с другой формат файла.

69
00:03:48,820 --> 00:03:51,270
Это заведомо должна выглядеть пугающим на первый,

70
00:03:51,270 --> 00:03:55,670
Но это только некоторые документы для структуры C.

71
00:03:55,670 --> 00:03:58,940
Оказывается, Microsoft лет назад помог популяризировать этот формат

72
00:03:58,940 --> 00:04:05,150
называется растровый формат, BMP, и это было супер простой, красочный графический формат файла

73
00:04:05,150 --> 00:04:10,150
, которая была использована в течение достаточно долгого времени, а иногда еще для обоев на рабочих столах.

74
00:04:10,150 --> 00:04:14,760
Если вы думаете, вернуться к Windows XP и холмов и голубого неба,

75
00:04:14,760 --> 00:04:17,170
, что было типично BMP или растровые изображения.

76
00:04:17,170 --> 00:04:19,959
Растровыми изображениями являются забавой для нас, потому что у них есть немного больше сложности.

77
00:04:19,959 --> 00:04:22,610
Это не так просто, как это сетка из 0 и 1.

78
00:04:22,610 --> 00:04:27,510
Вместо этого, у Вас есть такие вещи, как заголовок в начале файла.

79
00:04:27,510 --> 00:04:31,990
Итак, другими словами, внутри. Файлов BMP представляет собой целый букет из 0 и 1,

80
00:04:31,990 --> 00:04:34,910
но есть некоторые дополнительные 0 и 1 в там.

81
00:04:34,910 --> 00:04:38,220
И получается, что то, что мы, вероятно, само собой разумеющимся в течение многих лет -

82
00:04:38,220 --> 00:04:45,170
форматы файлов, как. документ или. или XLS. mp3,. mp4, независимо от форматов файлов

83
00:04:45,170 --> 00:04:48,480
что вы знакомы с - что это вообще значит быть формат файла,

84
00:04:48,480 --> 00:04:52,480
потому что в конце концов все эти файлы, которые мы используем, имеют только 0 и 1.

85
00:04:52,480 --> 00:04:56,810
А может быть, эти 0 и 1 представляют ABC через ASCII и т.п.,

86
00:04:56,810 --> 00:04:58,820
но, в конце концов, это еще только 0 и 1.

87
00:04:58,820 --> 00:05:02,100
Таким образом, люди просто иногда решили изобрести новый формат файлов

88
00:05:02,100 --> 00:05:06,420
где они стандартизации, какие модели бит будет на самом деле имею в виду.

89
00:05:06,420 --> 00:05:09,220
И в этом случае здесь, люди, которые разработаны растровый формат

90
00:05:09,220 --> 00:05:15,620
Говорят, что в самый первый байт в растровый файл, как обозначать смещение 0 там,

91
00:05:15,620 --> 00:05:18,940
там будет несколько загадочно именем переменной bfType,

92
00:05:18,940 --> 00:05:23,080
который просто стоит для растрового типа файла, тип файла растрового изображения заключается в следующем.

93
00:05:23,080 --> 00:05:27,700
Можно сделать вывод, возможно, со второго ряда, что смещение 2, байт номер 2,

94
00:05:27,700 --> 00:05:33,740
имеет рисунок из 0 и 1, которая представляет что? Размер что-то.

95
00:05:33,740 --> 00:05:35,310
И это идет оттуда.

96
00:05:35,310 --> 00:05:37,410
Таким образом, в проблеме Set 4, вы будете прошел через некоторые из этих вещей.

97
00:05:37,410 --> 00:05:39,520
Мы не будем в конечном итоге забота о всех из них.

98
00:05:39,520 --> 00:05:47,510
Но заметьте, это начинает становиться интересным вокруг байт 54: rgbtBlue, зеленый и красный.

99
00:05:47,510 --> 00:05:52,110
Если вы когда-нибудь слышали сокращение RGB - красный, зеленый, синий - это ссылка на этот

100
00:05:52,110 --> 00:05:54,610
потому что оказывается, можно рисовать все цвета радуги

101
00:05:54,610 --> 00:05:58,180
с некоторой комбинацией красного и синего и зеленого.

102
00:05:58,180 --> 00:06:03,320
И в самом деле, родители в зале могли бы вспомнить некоторые из самых ранних проекторов.

103
00:06:03,320 --> 00:06:05,890
В эти дни, вы видите только один яркий свет, исходящий из объектива,

104
00:06:05,890 --> 00:06:09,800
Но вернемся в день, у вас красные линзы, голубые линзы и зеленые линзы,

105
00:06:09,800 --> 00:06:13,380
и вместе они направлены на экране и сформировал красочную картину.

106
00:06:13,380 --> 00:06:16,270
И довольно часто, средней школы и вузы будут иметь те линзы

107
00:06:16,270 --> 00:06:19,720
чуть-чуть криво, так что вы были своего рода видим двойные или тройные изображений.

108
00:06:19,720 --> 00:06:24,100
Но это была идея. Вы были красный и зеленый и синий свет нарисовать картину.

109
00:06:24,100 --> 00:06:26,590
И тот же самый принцип используется в компьютерах.

110
00:06:26,590 --> 00:06:30,230
>> Таким образом, среди проблем, то для Вас в проблеме Set 4 собираемся быть несколько вещей.

111
00:06:30,230 --> 00:06:34,800
Одним из них является на самом деле изменить размер изображения, чтобы взять в картину 0 и 1,

112
00:06:34,800 --> 00:06:40,200
выяснить, какие куски 0 и 1 представляют то, что в структуре, как это,

113
00:06:40,200 --> 00:06:43,630
, а затем выяснить, как повторить пикселей - красного, блюз, зелень -

114
00:06:43,630 --> 00:06:46,660
внутри так, что, когда картина выглядит так изначально,

115
00:06:46,660 --> 00:06:49,210
это может выглядеть так, а не после этого.

116
00:06:49,210 --> 00:06:53,640
Среди других проблем тоже будет, что вы будете переданы судебно изображение

117
00:06:53,640 --> 00:06:56,030
фактического файл с цифровой камеры.

118
00:06:56,030 --> 00:06:58,960
И на этой камере, когда-то, было целая куча фотографий.

119
00:06:58,960 --> 00:07:03,760
Задача мы случайно стерты или был образ поврежден каким-то образом.

120
00:07:03,760 --> 00:07:05,750
Плохие вещи случаются с цифровых камер.

121
00:07:05,750 --> 00:07:09,150
И поэтому мы быстро скопировать все 0 и 1 с этой картой для вас,

122
00:07:09,150 --> 00:07:13,610
сохранить их все в один большой файл, а затем мы будем передавать их вам в проблеме Set 4

123
00:07:13,610 --> 00:07:19,320
так что вы можете написать программу на C, с которым, чтобы восстановить все из тех, JPEG, идеально.

124
00:07:19,320 --> 00:07:23,330
И оказывается, что JPEG, даже если они чем-то сложный формат файла -

125
00:07:23,330 --> 00:07:26,360
они гораздо более сложной, чем это улыбающееся лицо здесь -

126
00:07:26,360 --> 00:07:31,160
Оказывается, что каждый JPEG начинается с тех же моделей из 0 и 1.

127
00:07:31,160 --> 00:07:35,630
Таким образом, используя, в конечном счете, в то время как цикл или цикл или аналогичный,

128
00:07:35,630 --> 00:07:38,880
Вы можете перебрать все 0 и 1 в этой судебной изображения,

129
00:07:38,880 --> 00:07:43,150
и каждый раз, когда вы видите специальный шаблон, который определен в спецификации поставленной задачи,

130
00:07:43,150 --> 00:07:47,880
Вы можете предположить, вот, с очень высокой вероятностью, начала JPEG.

131
00:07:47,880 --> 00:07:51,230
И как только вы найдете по той же схеме некоторое количество байт

132
00:07:51,230 --> 00:07:55,430
или килобайтах или мегабайтах позже, можно предположить, вот второй JPEG,

133
00:07:55,430 --> 00:07:57,380
фото я взял после того, как первый.

134
00:07:57,380 --> 00:08:01,370
Позвольте мне остановиться читал, что первый файл, начать писать эту новую,

135
00:08:01,370 --> 00:08:06,310
и выход из вашей программы для pset4 будет целых 50 JPEG.

136
00:08:06,310 --> 00:08:09,270
А если это не 50 JPEG, у вас есть немного цикла.

137
00:08:09,270 --> 00:08:12,490
Если у вас есть бесконечное количество JPEG, у вас есть бесконечный цикл.

138
00:08:12,490 --> 00:08:14,910
Так что тоже будет довольно распространенный случай.

139
00:08:14,910 --> 00:08:16,600
Так вот что на горизонте.

140
00:08:16,600 --> 00:08:21,310
>> Викторина 0 за нами, понимают, на мою электронную почту, которая неизменно есть люди, которые оба счастливы,

141
00:08:21,310 --> 00:08:23,640
рода нейтральная, и грустно вокруг викторина 0 раз.

142
00:08:23,640 --> 00:08:26,800
И, пожалуйста, дотянуться до меня, голова TF Zamyla, ваши собственные TF,

143
00:08:26,800 --> 00:08:31,180
или одного из центров сертификации, которые вы знаете, если вы хотели бы обсудить, как все прошло.

144
00:08:31,180 --> 00:08:35,539
>> Таким образом, чтобы произвести впечатление на родителей здесь, в комнате, что CS50 библиотеку?

145
00:08:36,429 --> 00:08:40,390
[Смеется] Хорошая работа.

146
00:08:40,390 --> 00:08:48,340
Что CS50 библиотеку? Да. >> [Студент] Это предварительного письменного набора кода [неразборчиво]

147
00:08:48,340 --> 00:08:49,750
Ладно, хорошо.

148
00:08:49,750 --> 00:08:53,240
Это предварительного письменного набора кода, который мы написали сотрудников, мы предоставляем вам,

149
00:08:53,240 --> 00:08:55,030
, что дает некоторые общие функциональные возможности,

150
00:08:55,030 --> 00:08:59,020
такие вещи, как мне получить строку, поймите меня INT - все функции, перечисленные здесь.

151
00:08:59,020 --> 00:09:02,260
>> Начиная с этого момента, мы начинаем по-настоящему взять эти учебные колеса прочь.

152
00:09:02,260 --> 00:09:05,050
Мы собираемся начать, чтобы забрать строку из вас,

153
00:09:05,050 --> 00:09:08,870
Напомним который был всего лишь синоним, что фактический тип данных? >> [Несколько студентов] Char *.

154
00:09:08,870 --> 00:09:12,730
Char *. Для родителей, которые, вероятно, [делает свистящий звук]. Это хорошо.

155
00:09:12,730 --> 00:09:17,550
Char *, мы начнем видеть на экране все больше, как мы удалить строку из нашего лексикона,

156
00:09:17,550 --> 00:09:19,730
по крайней мере когда дело доходит до фактического написания кода.

157
00:09:19,730 --> 00:09:22,840
Кроме того, мы будем отказаться от использования некоторых из этих функций, как много

158
00:09:22,840 --> 00:09:25,280
потому что наши программы собираются получить более изощренными.

159
00:09:25,280 --> 00:09:28,480
Вместо того, чтобы писать программы, которые сидят там с запросом мигать,

160
00:09:28,480 --> 00:09:31,870
ожидания для пользователя, чтобы напечатать что-нибудь, вы будете получать ваши материалы из других источников.

161
00:09:31,870 --> 00:09:35,490
Например, Вы будете получать их из последовательности битов на локальном жестком диске.

162
00:09:35,490 --> 00:09:38,580
Вы, а не получать их в будущем от сети,

163
00:09:38,580 --> 00:09:40,230
некоторые веб-сайт где-то.

164
00:09:40,230 --> 00:09:44,110
>> Так что давайте отогните этот слой в первый раз и потяните вверх CS50 Appliance

165
00:09:44,110 --> 00:09:49,010
и этот файл называется cs50.h, что вы были # включая недель,

166
00:09:49,010 --> 00:09:51,140
Но давайте реально увидеть, что находится внутри этого.

167
00:09:51,140 --> 00:09:54,430
В верхней части файла в синем это просто целая куча комментариев:

168
00:09:54,430 --> 00:09:57,050
Информация лицензирования и гарантии.

169
00:09:57,050 --> 00:09:59,050
Это своего рода общую парадигму в программное обеспечение

170
00:09:59,050 --> 00:10:01,580
потому что много программного обеспечения в эти дни, что называется открытым исходным кодом,

171
00:10:01,580 --> 00:10:05,220
Это означает, что кто-то написал код, и сделал это в свободном доступе

172
00:10:05,220 --> 00:10:10,470
Не просто запустить и использовать, но на самом деле читать и изменять и интегрировать в свою работу.

173
00:10:10,470 --> 00:10:14,660
Так вот что вы используете программное обеспечение с открытым источником, хотя и в очень малой формы.

174
00:10:14,660 --> 00:10:18,560
Если я прокрутите вниз мимо комментариев, хотя, мы начинаем видеть некоторые более знакомые вещи.

175
00:10:18,560 --> 00:10:25,010
Обратите внимание на верхнюю здесь, что файл cs50.h включает в себя целую кучу файлов заголовков.

176
00:10:25,010 --> 00:10:28,560
Большинство из них, мы еще не видели, но один знакомый.

177
00:10:28,560 --> 00:10:32,270
Какие из них мы не видели, хотя и ненадолго, до сих пор? >> [Студент] Стандартная библиотека.

178
00:10:32,270 --> 00:10:35,810
Да, стандартные библиотеки. stdlib.h имеет таНос.

179
00:10:35,810 --> 00:10:38,320
Как только мы начали говорить о динамическом распределении памяти,

180
00:10:38,320 --> 00:10:41,650
которые мы вернемся на следующей неделе, а мы начали в том числе и файлов.

181
00:10:41,650 --> 00:10:46,640
Оказывается, BOOL и истинным и ложным на самом деле не существует в C таковой

182
00:10:46,640 --> 00:10:49,440
если вы включаете этот файл здесь.

183
00:10:49,440 --> 00:10:52,710
Мы недель были в том числе stdbool.h

184
00:10:52,710 --> 00:10:55,620
так что вы можете использовать понятие логическое, истинной или ложной.

185
00:10:55,620 --> 00:10:58,620
Без этого, вам придется разобраться поддельных и использовать Int

186
00:10:58,620 --> 00:11:02,610
и просто произвольно считать, что 0 является ложным и 1 верна.

187
00:11:02,610 --> 00:11:07,150
Если мы прокрутить вниз дальше, вот наше определение строки.

188
00:11:07,150 --> 00:11:11,390
Оказывается, как мы уже говорили ранее, что там, где эта звезда действительно не имеет значения.

189
00:11:11,390 --> 00:11:13,720
Вы даже можете иметь пространство вокруг.

190
00:11:13,720 --> 00:11:16,740
Мы в этом семестре было содействие, так как это ясно дать понять,

191
00:11:16,740 --> 00:11:18,620
, что звезда имеет дело с типом,

192
00:11:18,620 --> 00:11:21,700
но понимаю, как общего, если не немного больше общего,

193
00:11:21,700 --> 00:11:24,430
, чтобы положить его туда, но функционально это то же самое.

194
00:11:24,430 --> 00:11:27,720
Но теперь, если мы читаем дальше вниз, давайте взглянем на GetInt

195
00:11:27,720 --> 00:11:32,190
потому что мы использовали, что, возможно, прежде чем что-нибудь еще в этом семестре.

196
00:11:32,190 --> 00:11:37,440
Вот GetInt. Это что? >> [Студент] прототип. >> Это всего лишь прототип.

197
00:11:37,440 --> 00:11:41,410
Часто мы поставили прототипы на вершинах наших. С файлами,

198
00:11:41,410 --> 00:11:46,690
но вы также можете поместить прототипы в файлы заголовков,. ч файлы, как это здесь

199
00:11:46,690 --> 00:11:50,840
так что когда вы написать несколько функций, которые вы хотите, чтобы другие люди могли использовать,

200
00:11:50,840 --> 00:11:53,550
который как раз тот случай с библиотекой CS50,

201
00:11:53,550 --> 00:11:57,040
Вы не только реализовать свои функции в что-то вроде cs50.c,

202
00:11:57,040 --> 00:12:02,790
Вы также поместить прототипы не в верхней части этого файла, но в верхней части заголовка файла.

203
00:12:02,790 --> 00:12:07,170
Тогда этот заголовок файла является то, что друзья и коллеги включают

204
00:12:07,170 --> 00:12:09,760
с № включать в свой собственный код.

205
00:12:09,760 --> 00:12:12,210
Так что все это время вы были в том числе все эти прототипы,

206
00:12:12,210 --> 00:12:16,580
эффективно в верхней части вашего файла, но по пути этого # включать механизм,

207
00:12:16,580 --> 00:12:20,070
которые по существу копирует и вставляет этот файл в свой собственный.

208
00:12:20,070 --> 00:12:23,070
Вот некоторые довольно подробную документацию.

209
00:12:23,070 --> 00:12:25,640
Мы в значительной степени само собой разумеющимся, что GetInt получает INT,

210
00:12:25,640 --> 00:12:27,640
но, оказывается, есть некоторые частные случаи.

211
00:12:27,640 --> 00:12:31,810
Что делать, если пользователь вводит число, которое слишком большой, квинтиллиона,

212
00:12:31,810 --> 00:12:35,490
что просто не может поместиться внутри Int? Каково ожидаемое поведение?

213
00:12:35,490 --> 00:12:38,020
В идеале, это предсказуемо.

214
00:12:38,020 --> 00:12:40,280
Таким образом, в этом случае, если вы на самом деле читать мелкий шрифт,

215
00:12:40,280 --> 00:12:44,500
Вы действительно будете видеть, что если строка не может быть прочитан, это возвращает INT_MAX.

216
00:12:44,500 --> 00:12:48,320
Мы никогда не говорили об этом, но, основываясь на его капитализацию, что это возможно?

217
00:12:48,320 --> 00:12:50,640
[Студент] постоянно. >> Это постоянная.

218
00:12:50,640 --> 00:12:54,770
Это какая-то специальная константа, которая, вероятно, заявил в одном из этих файлов заголовков

219
00:12:54,770 --> 00:13:00,090
вот подняться выше в файле, и INT_MAX, вероятно, что-то вроде примерно 2 миллиарда,

220
00:13:00,090 --> 00:13:04,990
Идея в том, что, поскольку мы должны каким-то образом означает, что что-то пошло не так,

221
00:13:04,990 --> 00:13:10,700
Мы, да, есть 4 миллиарда номера в нашем распоряжении: -2 млрд. до 2 млрд., плюс-минус.

222
00:13:10,700 --> 00:13:14,710
Ну, то, что является общим в программировании ты украл лишь один из этих номеров,

223
00:13:14,710 --> 00:13:18,920
может быть 0, может быть, 2 млрд, может быть, -2 млрд,

224
00:13:18,920 --> 00:13:23,280
так что вы тратите одну из ваших возможных значений, так что вы можете совершить в мире

225
00:13:23,280 --> 00:13:26,820
что если что-то пойдет не так, я верну это супер большое значение.

226
00:13:26,820 --> 00:13:31,030
Но вы не хотите, чтобы пользователь печатает что-то загадочное, типа 234 ..., действительно большие числа.

227
00:13:31,030 --> 00:13:34,060
Вы обобщить его, а не как константу.

228
00:13:34,060 --> 00:13:38,060
Так на самом деле, если вы были анального последние несколько недель, в любое время вы называли GetInt,

229
00:13:38,060 --> 00:13:42,900
Вы должны были проверить с условием, если пользователь сделал типа в INT_MAX,

230
00:13:42,900 --> 00:13:46,590
или, более конкретно, сделали GetInt возвращения INT_MAX, потому что если это так,

231
00:13:46,590 --> 00:13:51,830
что на самом деле означает, что они не вводите его. Что-то пошло не так в этом случае.

232
00:13:51,830 --> 00:13:56,080
Итак, это то, что обычно называют дозорных значение, которое просто означает, особенный.

233
00:13:56,080 --> 00:13:58,120
>> Давайте теперь обратимся в. Файл с.

234
00:13:58,120 --> 00:14:01,340
Файл C существовала в прибор на некоторое время.

235
00:14:01,340 --> 00:14:06,840
И в самом деле, прибор имеет это предварительно скомпилированные для вас в это вещь, которую мы называли объектный код,

236
00:14:06,840 --> 00:14:09,540
но это просто не имеет значения для вас, где это потому, что система знает,

237
00:14:09,540 --> 00:14:11,730
В этом случае, если он: прибор.

238
00:14:11,730 --> 00:14:17,400
Давайте теперь прокрутите вниз, чтобы GetInt и посмотреть, как GetInt работал все это время.

239
00:14:17,400 --> 00:14:19,460
Здесь у нас есть подобные комментарии, чем прежде.

240
00:14:19,460 --> 00:14:21,660
Позвольте мне увеличить только на часть кода.

241
00:14:21,660 --> 00:14:23,900
А что мы имеем на GetInt заключается в следующем.

242
00:14:23,900 --> 00:14:25,700
Он не принимает никаких входных данных.

243
00:14:25,700 --> 00:14:29,510
Она возвращает целое, в то время (правда), так что у нас есть преднамеренное бесконечный цикл,

244
00:14:29,510 --> 00:14:33,180
но по-видимому, мы вырваться из этого так или вернуть из в этом.

245
00:14:33,180 --> 00:14:34,870
>> Давайте посмотрим, как это работает.

246
00:14:34,870 --> 00:14:39,240
Мы, похоже, используют GetString в этой первой линией внутри цикла, 166.

247
00:14:39,240 --> 00:14:43,780
Теперь это хорошая практика, потому что, при каких обстоятельствах может вернуться GetString

248
00:14:43,780 --> 00:14:47,660
специальное ключевое слово NULL? >> [Студент] Если что-то пойдет не так.

249
00:14:47,660 --> 00:14:51,630
Если что-то пойдет не так. И то, что может пойти не так, когда вы звоните что-то вроде GetString?

250
00:14:54,960 --> 00:14:57,640
Да. >> [Студент] Malloc не дает ей целыми.

251
00:14:57,640 --> 00:14:59,150
Да. Может быть, таНос не удается.

252
00:14:59,150 --> 00:15:03,190
Где-то под капотом, GetString зовет таНос, которая выделяет память,

253
00:15:03,190 --> 00:15:06,020
который позволяет компьютерном магазине все символы

254
00:15:06,020 --> 00:15:07,750
о том, что пользователь набирает на клавиатуре.

255
00:15:07,750 --> 00:15:11,590
И предположим, что пользователь имел много свободного времени и набрали больше, например,

256
00:15:11,590 --> 00:15:16,160
чем 2 млрд. символов, больше символов, чем компьютер, даже имеет RAM.

257
00:15:16,160 --> 00:15:19,250
GetString должен быть в состоянии означает, что к вам.

258
00:15:19,250 --> 00:15:22,560
Даже если это супер, супер редкий случай углу,

259
00:15:22,560 --> 00:15:24,340
она должна каким-то образом быть в состоянии справиться с этим,

260
00:15:24,340 --> 00:15:28,750
и так GetString, если бы мы пошли назад и прочитайте документацию, в действительности NULL возвращение.

261
00:15:28,750 --> 00:15:34,460
Так что теперь, если GetString не удается, возвращая NULL, GetInt собирается потерпеть неудачу, возвращая INT_MAX

262
00:15:34,460 --> 00:15:37,690
так же, как дозорный. Это всего лишь человеческие конвенции.

263
00:15:37,690 --> 00:15:41,450
Только так вы бы знали, что это дело, читая документацию.

264
00:15:41,450 --> 00:15:45,040
>> Давайте прокрутите вниз, туда, где Int фактически получили.

265
00:15:45,040 --> 00:15:51,160
Если я прокрутите вниз немного дальше, в линии 170, у нас есть комментарий выше этих линий.

266
00:15:51,160 --> 00:15:55,100
Мы заявляем, в 172 Int, п, и символ, с, а затем эта новая функция,

267
00:15:55,100 --> 00:15:58,930
который некоторые из вас наткнулся раньше, Sscanf.

268
00:15:58,930 --> 00:16:00,870
Это означает строка SCANF.

269
00:16:00,870 --> 00:16:05,700
Иными словами, дать мне строки, и я буду проверить его на куски информации, представляющей интерес.

270
00:16:05,700 --> 00:16:07,360
Что это значит?

271
00:16:07,360 --> 00:16:11,800
Предположим, что я печатаю, буквально, 123 на клавиатуре, а затем нажмите Enter.

272
00:16:11,800 --> 00:16:16,470
Что такое тип данных из 123, когда возвращаются GetString? >> [Студент] String.

273
00:16:16,470 --> 00:16:18,380
Очевидно, что это строка, не так ли? Я получил строку.

274
00:16:18,380 --> 00:16:23,220
Таким 123 является на самом деле, цитата, конец цитаты, 123 с \ 0 в конце его.

275
00:16:23,220 --> 00:16:27,110
Это не Int. Это не число. Это выглядит как число, но это не на самом деле.

276
00:16:27,110 --> 00:16:29,080
Итак, что же GetInt делать?

277
00:16:29,080 --> 00:16:35,750
Это имеет для сканирования этой строки слева направо - 123 \ 0 - и каким-то образом преобразовать в фактических целое.

278
00:16:35,750 --> 00:16:37,850
Вы могли понять, как это сделать.

279
00:16:37,850 --> 00:16:41,450
Если вы вспомните pset2, Вы, вероятно, получил немного знакомы с Цезарем

280
00:16:41,450 --> 00:16:44,820
или Vigenere, так что вы можете перемещаться по строке, вы можете конвертировать символов для целых чисел.

281
00:16:44,820 --> 00:16:46,710
Но черт возьми, это целая большая работа.

282
00:16:46,710 --> 00:16:49,860
Почему бы не назвать функцию, как Sscanf, что делает это для вас?

283
00:16:49,860 --> 00:16:54,230
Так Sscanf ожидает аргумент - в этом случае называется линия, которая является строкой.

284
00:16:54,230 --> 00:17:01,840
Затем указываются в кавычках, очень похожий на Printf, что вы ожидаете увидеть в этой строке.

285
00:17:01,840 --> 00:17:09,000
И то, что я говорю здесь, я ожидаю увидеть десятичное число и, возможно, характер.

286
00:17:09,000 --> 00:17:12,000
И мы увидим, почему это так, в один момент.

287
00:17:12,000 --> 00:17:15,869
И оказывается, что это обозначение сейчас напоминает материал, который мы начали говорить о

288
00:17:15,869 --> 00:17:17,619
чуть более недели назад.

289
00:17:17,619 --> 00:17:21,740
Что такое & N и & C делает для нас здесь? >> [Студент] Адрес п и адрес с.

290
00:17:21,740 --> 00:17:25,400
Да. Он дал мне адрес и адрес п с. Почему это так важно?

291
00:17:25,400 --> 00:17:30,220
Вы знаете, что с функциями в C, вы всегда можете вернуть значение не имеет никакого значения вообще.

292
00:17:30,220 --> 00:17:34,530
Вы можете вернуть целое число, строка, число с плавающей точкой, символ, независимо, или вы можете вернуться недействительными,

293
00:17:34,530 --> 00:17:38,030
но вы можете вернуть только одно максимально.

294
00:17:38,030 --> 00:17:42,760
Но здесь мы хотим Sscanf вернуть меня, может быть, целое число, десятичное число,

295
00:17:42,760 --> 00:17:46,220
а также символ, и я объясню, почему символов в минуту.

296
00:17:46,220 --> 00:17:51,460
Вы хотите эффективно Sscanf вернуть две вещи, но это просто не возможно в C.

297
00:17:51,460 --> 00:17:55,200
Вы можете обойти, что, переходя в два адреса

298
00:17:55,200 --> 00:17:57,370
потому что как только вы передать функцию двум адресам,

299
00:17:57,370 --> 00:18:00,470
что можно, что функция с ними делать? >> [Студент] Напишите на эти адреса.

300
00:18:00,470 --> 00:18:02,010
Он может писать на эти адреса.

301
00:18:02,010 --> 00:18:05,770
Вы можете использовать звезду операцию и поехать туда, к каждому из этих адресов.

302
00:18:05,770 --> 00:18:11,260
Это своего рода этом заднюю дверь механизм, но очень часто меняются значения переменных

303
00:18:11,260 --> 00:18:14,870
больше, чем просто одно место - в данном случае, два.

304
00:18:14,870 --> 00:18:21,340
Теперь я замечаю проверки == 1, а затем возвращаются п если это, на самом деле, оценить к истине.

305
00:18:21,340 --> 00:18:26,170
Так что же происходит? Технически, все мы действительно хотим, произойдет в GetInt это.

306
00:18:26,170 --> 00:18:30,740
Мы хотим, чтобы разобрать, так сказать, мы хотим, чтобы прочитать строку - конец цитаты цитаты-123 -

307
00:18:30,740 --> 00:18:34,560
и если она выглядит как есть ряд там, что мы говорим Sscanf делать

308
00:18:34,560 --> 00:18:38,190
помещают это число - 123 - в этой переменной п для меня.

309
00:18:38,190 --> 00:18:42,090
Так почему же тогда я на самом деле это так?

310
00:18:42,090 --> 00:18:48,220
Какова роль Sscanf говорят, что вы можете также получить символ здесь?

311
00:18:48,220 --> 00:18:53,470
[Неразборчиво ответ студента] >> десятичная точка на самом деле могли бы работать.

312
00:18:53,470 --> 00:18:56,330
Давайте считать, что на мгновение задумался. Что еще?

313
00:18:56,330 --> 00:18:59,270
[Студент] Это может быть NULL. >> Хорошая мысль. Это может быть нулевой символ.

314
00:18:59,270 --> 00:19:01,660
Это на самом деле не в этом случае. Да. >> [Студент] ASCII.

315
00:19:01,660 --> 00:19:04,340
ASCII. Или позвольте мне обобщать еще дальше.

316
00:19:04,340 --> 00:19:06,640
% C существует только для проверки ошибок.

317
00:19:06,640 --> 00:19:09,300
Мы не хотим там быть символ после номера,

318
00:19:09,300 --> 00:19:11,870
но то, что это позволяет мне сделать следующее.

319
00:19:11,870 --> 00:19:18,210
Оказывается, что Sscanf, помимо хранения значений в п и с в этом примере,

320
00:19:18,210 --> 00:19:24,890
что он также делает это возвращает количество переменных положить значения дюйма

321
00:19:24,890 --> 00:19:30,260
Так что если вы только вводите 123, то только% D будет совпадать,

322
00:19:30,260 --> 00:19:33,880
и только п получает хранится на сумму, как 123,

323
00:19:33,880 --> 00:19:35,640
и ничего не получает положить в с.

324
00:19:35,640 --> 00:19:37,620
С остается мусор значение, так сказать -

325
00:19:37,620 --> 00:19:40,730
мусор, потому что он никогда не был инициализирован до некоторого значения.

326
00:19:40,730 --> 00:19:45,520
Так что в этом случае, Sscanf возвращает 1, потому что я населенный 1 из этих указателей,

327
00:19:45,520 --> 00:19:50,190
В этом случае большая, у меня есть целое число, поэтому я освободит линию, чтобы освободить память

328
00:19:50,190 --> 00:19:54,000
GetString, что на самом деле выделяется, а затем я вернусь п,

329
00:19:54,000 --> 00:19:58,500
еще, если вы никогда не задумывались, где это Повторить заявление приходит, она приходит прямо отсюда.

330
00:19:58,500 --> 00:20:04,390
Таким образом, если, напротив, я набираю в 123foo - лишь некоторые случайные последовательности текста -

331
00:20:04,390 --> 00:20:08,490
Sscanf будет видеть номер, номер, номер, F,

332
00:20:08,490 --> 00:20:16,410
и он собирается поставить 123 в п; он собирается поставить е в С, а затем вернуть 2.

333
00:20:16,410 --> 00:20:20,640
Итак, мы имеем, только с помощью основного определения поведения Sscanf, в очень простой способ -

334
00:20:20,640 --> 00:20:23,900
Ну, сложные, на первый взгляд, но в конце дня довольно простой механизм -

335
00:20:23,900 --> 00:20:28,320
сказать есть целое число, и если да, то, что единственное, что я нашел?

336
00:20:28,320 --> 00:20:29,860
И пробелы здесь не случайно.

337
00:20:29,860 --> 00:20:34,000
Если вы прочитали документацию по Sscanf, он говорит вам, что если вы включаете часть пробелов

338
00:20:34,000 --> 00:20:38,810
в начале или в конце концов, Sscanf слишком позволит пользователю, по какой причине,

339
00:20:38,810 --> 00:20:41,860
, достиг 123 пробел, и это будет законно.

340
00:20:41,860 --> 00:20:44,150
Вы не будете кричать на пользователей только потому, что они попали в пробела

341
00:20:44,150 --> 00:20:48,640
в начале или в конце, который является немного более удобным для пользователей.

342
00:20:48,640 --> 00:20:52,300
>> Любые вопросы, то на GetInt? Да. >> [Студент] Что делать, если вы просто положить в символ?

343
00:20:52,300 --> 00:20:54,030
Хороший вопрос.

344
00:20:54,030 --> 00:20:59,890
Что делать, если вы только что ввели в символ, как F и нажмите Enter, никогда не набрав 123?

345
00:20:59,890 --> 00:21:02,420
Что вы думаете поведение этой строки кода бы тогда?

346
00:21:02,420 --> 00:21:04,730
[Неразборчиво ответ студента]

347
00:21:04,730 --> 00:21:08,790
Да, так Sscanf может покрыть, что тоже, потому что в таком случае, он не собирается заполнить п или с.

348
00:21:08,790 --> 00:21:15,310
Это будет вместо возврата 0, в этом случае я также ловить, что сценарий

349
00:21:15,310 --> 00:21:18,750
потому что ожидаемое значение я хочу 1.

350
00:21:18,750 --> 00:21:22,000
Я хочу только одну и только одну вещь, чтобы быть заполнены. Хороший вопрос.

351
00:21:22,000 --> 00:21:24,290
>> Другие? Хорошо.

352
00:21:24,290 --> 00:21:26,250
>> Давайте не будем пройти через все функции здесь,

353
00:21:26,250 --> 00:21:29,500
но тот, который, кажется, может быть, из оставшихся интерес GetString

354
00:21:29,500 --> 00:21:32,790
потому что оказывается, что GetFloat, GetInt, GetDouble, GetLongLong

355
00:21:32,790 --> 00:21:36,260
Все плоскодонки много их функциональность GetString.

356
00:21:36,260 --> 00:21:39,750
Итак, давайте взглянем на то, как он реализуется здесь.

357
00:21:39,750 --> 00:21:43,630
Это выглядит немного сложным, но он использует те же основы

358
00:21:43,630 --> 00:21:45,670
что мы начали говорить о прошлой недели.

359
00:21:45,670 --> 00:21:49,490
В GetString, который не принимает аргументов, как в пустоту здесь

360
00:21:49,490 --> 00:21:53,730
и возвращает строку, я, кажется, я объявлении строки называется буфером.

361
00:21:53,730 --> 00:21:56,270
Я действительно не знаю, что это собирается быть использован для еще нет, но мы будем видеть.

362
00:21:56,270 --> 00:21:58,390
Похоже, мощностью по умолчанию 0.

363
00:21:58,390 --> 00:22:01,350
Не совсем уверен, где это происходит, не уверены, что N будет использоваться для клиентов,

364
00:22:01,350 --> 00:22:03,590
но теперь это становится немного более интересной.

365
00:22:03,590 --> 00:22:06,520
В соответствии 243, мы заявляем, INT, с.

366
00:22:06,520 --> 00:22:08,800
Это своего рода глупые подробно.

367
00:22:08,800 --> 00:22:15,820
Символ это 8 бит и 8 бит может хранить сколько различных значений? >> [Студент] 256. >> 256.

368
00:22:15,820 --> 00:22:20,730
Проблема в том, если вы хотите иметь 256 различных символов ASCII, которые существуют

369
00:22:20,730 --> 00:22:23,340
Если вы вспомните - и это не то, чтобы запомнить.

370
00:22:23,340 --> 00:22:25,710
Но если вы вспомните, что большая ASCII графике мы были неделю назад,

371
00:22:25,710 --> 00:22:30,600
было в этом случае 128 или 256 ASCII символов.

372
00:22:30,600 --> 00:22:32,940
Мы использовали все модели 0 и 1 вверх.

373
00:22:32,940 --> 00:22:36,210
Это проблема, если вы хотите быть в состоянии обнаружить ошибку

374
00:22:36,210 --> 00:22:40,190
потому что, если вы уже используете 256 значений для ваших персонажей,

375
00:22:40,190 --> 00:22:43,050
Вы действительно не планировать заранее, потому что теперь у вас нет возможности сказать,

376
00:22:43,050 --> 00:22:46,270
это не законный характер, это какое-то ошибочное сообщение.

377
00:22:46,270 --> 00:22:50,270
Так что мир делает это они используют следующий самая большая ценность, что-то вроде INT,

378
00:22:50,270 --> 00:22:54,720
так что у вас сумасшедшим количеством битов, 32, 4 млрд. возможных значений

379
00:22:54,720 --> 00:22:58,860
так что вы можете просто конечном итоге, используя по существу 257 из них,

380
00:22:58,860 --> 00:23:01,720
1 из которых имеет некоторое особое значение как ошибку.

381
00:23:01,720 --> 00:23:03,120
>> Итак, давайте посмотрим, как это работает.

382
00:23:03,120 --> 00:23:07,760
В соответствии 246, у меня есть этот большой цикл, пока что вызывает fgetc,

383
00:23:07,760 --> 00:23:11,090
F Значение файла, так ЕОКП, а затем стандартного ввода.

384
00:23:11,090 --> 00:23:15,520
Оказывается, это всего лишь более точным способом сказать, читать ввод с клавиатуры.

385
00:23:15,520 --> 00:23:19,300
Стандартная клавиатура средств ввод, стандартный вывод означает, экран,

386
00:23:19,300 --> 00:23:23,310
и стандартные ошибки, которые мы увидим в pset4, означает, что экран

387
00:23:23,310 --> 00:23:27,490
но особая часть экрана, так что она не смешивается с фактическим выходом

388
00:23:27,490 --> 00:23:30,750
что вы предназначены для печати. Но об этом в будущем.

389
00:23:30,750 --> 00:23:34,440
Так fgetc просто означает, что читать один символ с клавиатуры и хранить его где?

390
00:23:34,440 --> 00:23:37,350
Храните его в с.

391
00:23:37,350 --> 00:23:41,360
А потом проверить - так что я просто используя некоторые булевы союзов здесь -

392
00:23:41,360 --> 00:23:46,000
убедитесь, что она не равна - \ п, так что пользователь нажал Enter, мы хотим, чтобы остановить в тот момент,

393
00:23:46,000 --> 00:23:49,850
конец цикла - и мы также хотим, чтобы проверить на специальном постоянном EOF,

394
00:23:49,850 --> 00:23:53,610
, который, если вы знаете или догадываетесь, что это означает? >> [Студент] конец файла. >> Конец файла.

395
00:23:53,610 --> 00:23:56,560
Это своего рода бессмысленно, потому что если я печатаю на клавиатуре,

396
00:23:56,560 --> 00:23:58,870
там действительно нет файла, участвующие в этом,

397
00:23:58,870 --> 00:24:01,150
Но это всего лишь своего рода общий термин, используемый для обозначения

398
00:24:01,150 --> 00:24:04,220
что ничего не приходит из пальца человека.

399
00:24:04,220 --> 00:24:06,460
EOF - конец файла.

400
00:24:06,460 --> 00:24:09,920
Как в стороне, если вы когда-либо ударил управления D на вашей клавиатуре, не то, что вам придется еще -

401
00:24:09,920 --> 00:24:15,230
Вы попали управления C - D управления посылает это специальная константа называется EOF.

402
00:24:15,230 --> 00:24:19,850
Итак, теперь мы просто есть некоторые динамического распределения памяти.

403
00:24:19,850 --> 00:24:23,440
>> Так что, если (п + 1> мощностей). Сейчас я объясню, с.

404
00:24:23,440 --> 00:24:26,100
N только, сколько байт в настоящее время в буфере,

405
00:24:26,100 --> 00:24:28,620
Строка, вы в настоящее время наращивания от пользователя.

406
00:24:28,620 --> 00:24:33,450
Если у вас есть несколько символов в буфере, чем у вас есть потенциал в буфер,

407
00:24:33,450 --> 00:24:37,410
Интуитивно, что нам нужно сделать, это выделить больше мощности.

408
00:24:37,410 --> 00:24:43,330
Так что я буду скользить над некоторыми арифметической здесь и сосредоточены только на этой функции здесь.

409
00:24:43,330 --> 00:24:46,070
Вы знаете, что таНос является или, по крайней мере в целом знакомы.

410
00:24:46,070 --> 00:24:48,970
Возьмите предположение, что перераспределить делает. >> [Студент] Добавляет памяти.

411
00:24:48,970 --> 00:24:52,920
Это не совсем добавление памяти. Она перераспределяет память следующим образом.

412
00:24:52,920 --> 00:24:57,220
Если есть еще место в конце строки, чтобы дать вам больше, что память

413
00:24:57,220 --> 00:25:00,000
чем это изначально дает вам, то вы получите, что дополнительная память.

414
00:25:00,000 --> 00:25:03,460
Таким образом, вы можете просто держать положить символов струны спиной к спине, чтобы спина к спине.

415
00:25:03,460 --> 00:25:05,830
Но если это не так, потому что вы слишком долго ждали

416
00:25:05,830 --> 00:25:07,940
и что-то случайное получил шлепнулся в памяти есть

417
00:25:07,940 --> 00:25:10,290
но есть дополнительная память здесь, внизу, это нормально.

418
00:25:10,290 --> 00:25:13,100
Realloc будет делать всю тяжелую работу за вас,

419
00:25:13,100 --> 00:25:16,750
переместить строку, которую вы читали в так далеко отсюда, положите его туда,

420
00:25:16,750 --> 00:25:19,460
, а затем дать вам еще несколько взлетно-посадочная полоса в этой точке.

421
00:25:19,460 --> 00:25:22,550
>> Так что с волной стороны, позвольте мне сказать, что то, что делает GetString

422
00:25:22,550 --> 00:25:26,330
оно начинает с небольшой буфер, может быть, одного характера,

423
00:25:26,330 --> 00:25:30,820
и если пользователь вводит в два символа, GetString заканчивается вызовом перераспределить и говорит:

424
00:25:30,820 --> 00:25:33,150
один символ не хватало, дай мне два символа.

425
00:25:33,150 --> 00:25:35,950
Тогда, если вы прочитали логике цикла, она скажет

426
00:25:35,950 --> 00:25:39,600
пользователь вводит в 3 символа, дай мне теперь не 2, а 4-х символов,

427
00:25:39,600 --> 00:25:42,320
Затем дайте мне 8, то дайте мне 16 и 32.

428
00:25:42,320 --> 00:25:45,000
Тот факт, что я удвоение мощности каждый раз

429
00:25:45,000 --> 00:25:48,570
означает, что буфер не будет расти медленно, он будет расти очень быстро.

430
00:25:48,570 --> 00:25:51,380
А что может быть преимуществом, что?

431
00:25:51,380 --> 00:25:54,600
Почему я удвоение размера буфера

432
00:25:54,600 --> 00:25:58,020
хотя пользователь может просто нужно один дополнительный символ с клавиатуры?

433
00:25:58,020 --> 00:26:01,750
[Неразборчиво ответ студента] >> Что это такое? >> [Студент] Вы не должны расти так часто.

434
00:26:01,750 --> 00:26:03,300
Именно так. Вы не должны расти так часто.

435
00:26:03,300 --> 00:26:05,510
И это только отчасти вы хеджирования ставки здесь,

436
00:26:05,510 --> 00:26:10,850
Идея в том, что вы не хотите позвонить перераспределить много, потому что он имеет тенденцию быть медленным.

437
00:26:10,850 --> 00:26:12,910
Каждый раз, когда вы спросите операционной системы для памяти,

438
00:26:12,910 --> 00:26:16,990
как вы скоро увидите, в будущем поставленной задачи, он стремится занять некоторое время.

439
00:26:16,990 --> 00:26:20,010
Таким образом, минимизация, что количество времени, даже если вы тратите некоторое пространство,

440
00:26:20,010 --> 00:26:21,900
как правило, хорошо.

441
00:26:21,900 --> 00:26:24,060
>> Но если мы прочитали финальную часть GetString здесь -

442
00:26:24,060 --> 00:26:27,950
и снова понимании каждая строка здесь не так важна сегодня -

443
00:26:27,950 --> 00:26:30,530
заметить, что в конечном счете вызывает таНос раз

444
00:26:30,530 --> 00:26:33,880
и он выделяет именно столько байт, сколько ему нужно для строки

445
00:26:33,880 --> 00:26:38,060
, а затем выбрасывает по телефону бесплатно чрезмерно большие буфера

446
00:26:38,060 --> 00:26:40,080
если он действительно получил удвоил слишком много раз.

447
00:26:40,080 --> 00:26:42,730
Короче говоря, вот как GetString работал все это время.

448
00:26:42,730 --> 00:26:47,060
Все это делает чтение одного символа в то время, снова и снова, и снова,

449
00:26:47,060 --> 00:26:50,750
и каждый раз, когда она нуждается в некоторой дополнительной памяти, она спрашивает операционной системы для ее

450
00:26:50,750 --> 00:26:53,670
по телефону перераспределить.

451
00:26:53,670 --> 00:26:57,890
>> Есть вопросы? Хорошо.

452
00:26:57,890 --> 00:26:59,270
>> Атаке.

453
00:26:59,270 --> 00:27:04,060
Теперь, когда мы понимаем, указатели или по крайней мере все более знакомым с указателями,

454
00:27:04,060 --> 00:27:06,700
давайте рассмотрим, как весь мир начинает разваливаться

455
00:27:06,700 --> 00:27:10,030
если вы не совсем защитить от состязательного пользователей,

456
00:27:10,030 --> 00:27:11,850
люди, которые пытаются взломать вашу систему,

457
00:27:11,850 --> 00:27:16,890
люди, которые пытаются украсть ваши программы в обход некоторых регистрационный код

458
00:27:16,890 --> 00:27:19,090
что они могли бы в противном случае придется вводить дюйма

459
00:27:19,090 --> 00:27:22,990
>> Взгляните на этот пример здесь, который находится всего в C код, который имеет функцию основного внизу

460
00:27:22,990 --> 00:27:26,380
, которая вызывает функцию Foo. И то, что он переход к Foo?

461
00:27:26,380 --> 00:27:29,680
[Студент] один аргумент. >> [Малан] один аргумент.

462
00:27:29,680 --> 00:27:33,450
Так ARGV [1], что означает, что первое слово, которое пользователь вводит в командной строке

463
00:27:33,450 --> 00:27:36,360
После a.out или любой другой программы, называется.

464
00:27:36,360 --> 00:27:41,680
Так Foo в верхней берет в символ *. Но символ * только что? >> [Студент] строку.

465
00:27:41,680 --> 00:27:43,350
[Малан] строки, так что ничего нового.

466
00:27:43,350 --> 00:27:45,420
Эта строка условно называться баром.

467
00:27:45,420 --> 00:27:51,430
В этой линии здесь, символ с [12], в роде полу-технического английского языка, то, что эта линия делает?

468
00:27:51,430 --> 00:27:55,220
[Студент] Массив - >> Массив? >> [Студент] персонажи. >> Персонажи.

469
00:27:55,220 --> 00:27:58,870
Дайте мне массив из 12 символов. Таким образом, мы могли бы назвать это буфер.

470
00:27:58,870 --> 00:28:02,920
Это технически называется C, а буфер в программировании просто означает, куча пространства

471
00:28:02,920 --> 00:28:04,800
что вы можете поместить некоторые вещи дюйма

472
00:28:04,800 --> 00:28:07,940
Тогда, наконец, тетсру мы не использовали раньше, но вы можете догадаться, что он делает.

473
00:28:07,940 --> 00:28:10,480
Он копирует памяти. Что он делает?

474
00:28:10,480 --> 00:28:19,270
Это очевидно копирует бар, на входе, в с, но только до длины бар.

475
00:28:19,270 --> 00:28:24,930
Но есть ошибка здесь. >> [Студент] Вы должны SizeOf характер. >> Хорошо.

476
00:28:24,930 --> 00:28:30,860
Технически, мы должны действительно сделать StrLen (бар) * SizeOf (Char)). Это правильно.

477
00:28:30,860 --> 00:28:33,930
Но в худшем случае здесь, давайте предположим, что that's -

478
00:28:33,930 --> 00:28:35,950
Хорошо. Тогда есть две ошибки.

479
00:28:35,950 --> 00:28:39,160
Таким образом, SizeOf (Char));

480
00:28:39,160 --> 00:28:41,290
Давайте сделаем это немного шире.

481
00:28:41,290 --> 00:28:44,910
Так что теперь есть еще ошибка, что есть что? >> [Неразборчиво ответ студента]

482
00:28:44,910 --> 00:28:46,990
Проверьте, что ли? >> [Студент] Проверка на NULL.

483
00:28:46,990 --> 00:28:50,270
Мы должны, как правило проверки на NULL потому, что плохие вещи случаются

484
00:28:50,270 --> 00:28:53,200
когда ваш указатель NULL, потому что вы могли бы в конечном итоге происходит там,

485
00:28:53,200 --> 00:28:57,630
и вы никогда не должны идти в пустое разыменования его со звездой оператора.

486
00:28:57,630 --> 00:29:01,050
Так что это хорошо. А что еще мы делаем? Логично, что есть недостаток здесь.

487
00:29:01,050 --> 00:29:04,450
[Студент] Проверьте, если агдс является> = 2.

488
00:29:04,450 --> 00:29:10,550
Таким образом, проверьте агдс является> = 2. Итак, есть три ошибки в этой программе.

489
00:29:10,550 --> 00:29:16,630
Мы следим проверки, если пользователь на самом деле набрали ни в чем в ARGV [1]. Хорошо.

490
00:29:16,630 --> 00:29:20,950
Так что третья ошибка? Да. >> [Студент] C не может быть достаточно большой.

491
00:29:20,950 --> 00:29:23,320
Хорошо. Мы проверили один сценарий.

492
00:29:23,320 --> 00:29:29,520
Мы неявно проверить, не копируйте больше памяти, чем будет превышать длину бара.

493
00:29:29,520 --> 00:29:32,510
Таким образом, если строка пользователь вводит в состоит из 10 символов,

494
00:29:32,510 --> 00:29:36,020
это говорит копировать только 10 символов. И это нормально.

495
00:29:36,020 --> 00:29:39,940
Но что, если пользователь вводит в слово в строке, как 20-значное слово?

496
00:29:39,940 --> 00:29:44,900
Это говорит копии 20 символов из бара во что?

497
00:29:44,900 --> 00:29:49,750
C, иначе известный как наш буфер, который означает, что вы только что написали данные

498
00:29:49,750 --> 00:29:52,540
до 8 байт мест, которые вам не принадлежат,

499
00:29:52,540 --> 00:29:54,870
и вы не владеете им в том смысле, что вы никогда не выделяла их.

500
00:29:54,870 --> 00:30:00,370
Итак, это то, что обычно известно как атака переполнения буфера или атаки с переполнением буфера.

501
00:30:00,370 --> 00:30:05,580
И это нападение в том смысле, что если пользователь или программа, которая звонит ваша функция

502
00:30:05,580 --> 00:30:10,490
делает это злонамеренно, что на самом деле происходит следующее самом деле может быть очень плохо.

503
00:30:10,490 --> 00:30:12,450
>> Итак, давайте взглянем на эту картину здесь.

504
00:30:12,450 --> 00:30:16,060
Эта картина представляет свой стек памяти.

505
00:30:16,060 --> 00:30:19,580
Напомним, что каждый раз, когда вы вызываете функцию вы получите эту маленькую кадра в стеке

506
00:30:19,580 --> 00:30:21,520
а потом еще и потом еще и еще.

507
00:30:21,520 --> 00:30:24,300
И до сих пор, мы только вид этих отведенной в виде прямоугольников

508
00:30:24,300 --> 00:30:26,290
либо на доске или на экране здесь.

509
00:30:26,290 --> 00:30:30,580
Но если увеличить на один из этих прямоугольников, при вызове функции Foo,

510
00:30:30,580 --> 00:30:35,880
Оказывается, что есть больше в стек внутри этого фрейма в этом прямоугольнике

511
00:30:35,880 --> 00:30:40,060
чем просто х и у, а и Ь, как мы сделали говорим о своп.

512
00:30:40,060 --> 00:30:44,410
Оказывается, что есть некоторые низкоуровневые детали, среди них обратный адрес.

513
00:30:44,410 --> 00:30:49,550
Вот и получается, когда основные называет Фу, основная должен сообщить Foo

514
00:30:49,550 --> 00:30:53,520
какой адрес основного находится в оперативной памяти компьютера

515
00:30:53,520 --> 00:30:57,770
потому что иначе, как только Foo делается выполнение, как в данном случае здесь,

516
00:30:57,770 --> 00:31:00,830
как только вы достигнете этого замкнутого фигурной скобкой в ​​конце Фу,

517
00:31:00,830 --> 00:31:05,310
как, черт возьми никак Foo знает, где контроль программа должна пойти?

518
00:31:05,310 --> 00:31:08,970
Оказывается, что ответ на этот вопрос в этом красном прямоугольнике здесь.

519
00:31:08,970 --> 00:31:12,670
Это представляет собой указатель, и это до компьютера для хранения временно

520
00:31:12,670 --> 00:31:17,030
на так называемом стеке адрес основного, так что, как только Foo делается выполнение,

521
00:31:17,030 --> 00:31:21,120
Компьютер знает, где и какие линии в основном, чтобы вернуться в.

522
00:31:21,120 --> 00:31:23,940
Сохранено указатель кадра относится так же к этому.

523
00:31:23,940 --> 00:31:26,310
Char * бар здесь представляет то, что?

524
00:31:26,310 --> 00:31:31,350
Сейчас этот сегмент синего вот кадр Foo автора. Что такое бар?

525
00:31:31,570 --> 00:31:35,010
Бар является лишь аргументом функции Foo.

526
00:31:35,010 --> 00:31:37,500
Так что теперь мы вернулись на вид знакомая картина.

527
00:31:37,500 --> 00:31:39,850
Там больше вещей и больше отвлекаться на экране,

528
00:31:39,850 --> 00:31:43,380
но это голубой сегмент только то, что мы уже опираясь на доске

529
00:31:43,380 --> 00:31:45,790
что-то вроде подкачки. Это рамка для Foo.

530
00:31:45,790 --> 00:31:51,490
И единственное, что в ней сейчас находится бар, который является этим параметром.

531
00:31:51,490 --> 00:31:55,220
Но что еще должно быть в стеке соответствии с настоящим Кодексом здесь?

532
00:31:55,220 --> 00:31:57,760
[Студент] символ с [12]. >> [Малан] символ с [12].

533
00:31:57,760 --> 00:32:02,810
Мы должны также видеть 12 квадратов памяти, выделенной для переменной с,

534
00:32:02,810 --> 00:32:04,970
да и у нас есть, что на экране.

535
00:32:04,970 --> 00:32:08,480
В самом верху есть с [0], а затем автор этой схеме

536
00:32:08,480 --> 00:32:11,850
не беспокоить рисования все квадраты, но на самом деле есть 12 имеется

537
00:32:11,850 --> 00:32:16,590
потому что если вы посмотрите на нижнюю правую, с [11], если считать от 0 занимает 12-е такие байт.

538
00:32:16,590 --> 00:32:18,400
Но вот в чем проблема.

539
00:32:18,400 --> 00:32:22,390
В каком направлении с растущей?

540
00:32:22,390 --> 00:32:27,080
Вид сверху вниз, если она начинается в верхней и растет на дно.

541
00:32:27,080 --> 00:32:30,110
Это не похоже мы оставили себе много взлетно-посадочной полосы здесь вообще.

542
00:32:30,110 --> 00:32:32,090
Мы видов окрашены себя в угол,

543
00:32:32,090 --> 00:32:36,940
и что с [11] вплотную баре, который находится прямо против Сохранено указатель кадра,

544
00:32:36,940 --> 00:32:39,960
который находится прямо против обратного адреса. Там нет больше места.

545
00:32:39,960 --> 00:32:42,810
Так что же подразумевается то, если вы испортить

546
00:32:42,810 --> 00:32:46,500
а вы попробуйте прочитать 20 байт в 12-байт буфера?

547
00:32:46,500 --> 00:32:50,060
Где эти 8 дополнительных байтов идти? >> [Студент] Внутри -

548
00:32:50,060 --> 00:32:53,200
Внутри все остальное, некоторые из которых это супер важно.

549
00:32:53,200 --> 00:32:57,260
И самое главное, возможно, является красная коробка там, обратный адрес,

550
00:32:57,260 --> 00:33:03,560
потому предположим, что вы случайно или adversarially переписать эти 4 байта,

551
00:33:03,560 --> 00:33:07,260
что указатель адреса, а не только с мусором, но с рядом

552
00:33:07,260 --> 00:33:09,810
что происходит представляют фактический адрес в памяти.

553
00:33:09,810 --> 00:33:13,880
Что косвенно, логически? >> [Студент] Функция собирается вернуться в другое место.

554
00:33:13,880 --> 00:33:15,250
Именно так.

555
00:33:15,250 --> 00:33:19,170
Когда Foo возвращается и хиты, которые фигурной скобкой, программа будет продолжаться

556
00:33:19,170 --> 00:33:25,060
Не для возврата в главное, он собирается вернуться в любой адрес в том, что красные коробки.

557
00:33:25,060 --> 00:33:28,600
>> В случае обхода регистрации программного обеспечения,

558
00:33:28,600 --> 00:33:32,260
Что делать, если адрес который возвращается в это функция, которая обычно вызывается

559
00:33:32,260 --> 00:33:35,690
после того как вы заплатили за программное обеспечение и вводится регистрационный код?

560
00:33:35,690 --> 00:33:39,870
Вы можете сортировать трюк компьютер в не собираемся здесь, но вместо этого собираются здесь.

561
00:33:39,870 --> 00:33:45,100
Или, если вы действительно умный, противник действительно может ввести с клавиатуры, например,

562
00:33:45,100 --> 00:33:50,690
Не фактического слово, не более 20 символов, но предполагаю, что он или она на самом деле типов

563
00:33:50,690 --> 00:33:52,770
некоторые символы, которые представляют собой код.

564
00:33:52,770 --> 00:33:55,320
И это не будет C код, он на самом деле будет символы

565
00:33:55,320 --> 00:33:59,290
, которые представляют собой двоичный код машины, 0 и 1.

566
00:33:59,290 --> 00:34:01,290
Но предположим, что они достаточно умны, чтобы сделать это,

567
00:34:01,290 --> 00:34:06,500
как-то вставить в строку GetString то, что, по существу скомпилированный код,

568
00:34:06,500 --> 00:34:09,980
и последние 4 байта перезаписи, что обратный адрес.

569
00:34:09,980 --> 00:34:13,360
И то, что адрес не что входной делать?

570
00:34:13,360 --> 00:34:18,630
Это на самом деле хранит в этом красном прямоугольнике адрес первого байта буфера.

571
00:34:18,630 --> 00:34:23,070
Таким образом, вы должны быть очень умным, и это много проб и ошибок для плохих людей там,

572
00:34:23,070 --> 00:34:25,639
Но если вы можете выяснить, насколько большой этот буфер

573
00:34:25,639 --> 00:34:28,820
такие, что за последние несколько байт во входном вы предоставляете программе

574
00:34:28,820 --> 00:34:33,540
оказаться эквивалентной адрес начала вашего буфера, вы можете сделать это.

575
00:34:33,540 --> 00:34:39,320
Если мы говорим, обычно привет и \ 0, это то, что попадает в буфер.

576
00:34:39,320 --> 00:34:44,420
Но если мы умнее и мы заполняем этот буфер с тем, что мы называем общим вредоносный код -

577
00:34:44,420 --> 00:34:48,860
AAA, атака, атака, атака - там, где это только то, что делает что-то плохое,

578
00:34:48,860 --> 00:34:51,820
Что произойдет, если вы действительно умны, вы можете это сделать.

579
00:34:51,820 --> 00:34:58,610
В красной коробке здесь последовательность чисел - 80, C0, 35, 08.

580
00:34:58,610 --> 00:35:01,610
Обратите внимание, что совпадает с числом это здесь.

581
00:35:01,610 --> 00:35:04,430
Это в обратном порядке, но об этом как-нибудь в другой раз.

582
00:35:04,430 --> 00:35:08,140
Обратите внимание, что этот обратный адрес был намеренно изменен

583
00:35:08,140 --> 00:35:12,020
равным адресу здесь, а не адрес основного.

584
00:35:12,020 --> 00:35:17,500
Таким образом, если плохой парень супер умный, он или она собирается включить в этот вредоносный код

585
00:35:17,500 --> 00:35:20,930
что-то вроде удалить все файлы пользователя или копировать пароли

586
00:35:20,930 --> 00:35:24,680
или создать учетную запись пользователя, что я могу войти в систему - вообще ничего.

587
00:35:24,680 --> 00:35:26,950
>> И это как опасность и силу C.

588
00:35:26,950 --> 00:35:29,840
Потому что у вас есть доступ к памяти через указатели

589
00:35:29,840 --> 00:35:32,520
и поэтому вы можете написать все, что угодно в память компьютера,

590
00:35:32,520 --> 00:35:35,080
Вы можете сделать компьютер делать все, что угодно

591
00:35:35,080 --> 00:35:39,550
просто то, что прыгать в своем собственном пространстве памяти.

592
00:35:39,550 --> 00:35:44,650
И так по сей день так много программ и так много сайтов, которые оказываются под угрозой

593
00:35:44,650 --> 00:35:46,200
сводятся к людям воспользоваться этим.

594
00:35:46,200 --> 00:35:50,760
И это может показаться супер сложные атаки, но это не всегда начинаются именно так.

595
00:35:50,760 --> 00:35:53,560
Реальность такова, что то, что плохие люди, как правило, сделать это,

596
00:35:53,560 --> 00:35:58,200
будь то программы в командную строку или графический интерфейс программы или веб-сайт,

597
00:35:58,200 --> 00:35:59,940
Вы просто начать предоставление ерунда.

598
00:35:59,940 --> 00:36:03,980
Вы вводите в действительно большом слово в поле поиска и нажмите Enter,

599
00:36:03,980 --> 00:36:05,780
и вы ждать, чтобы увидеть, если сайт падает

600
00:36:05,780 --> 00:36:09,990
или вы ждать, чтобы увидеть, если программа обнаруживает некоторые сообщения об ошибке

601
00:36:09,990 --> 00:36:14,330
потому что, если вам повезет, как плохой парень, и вы предоставить некоторые сумасшедшие вход

602
00:36:14,330 --> 00:36:18,980
, что сбой программы, это означает, что программист не ожидает вашего плохого поведения,

603
00:36:18,980 --> 00:36:23,630
которая означает, что вы, вероятно, может с достаточно усилий, достаточно проб и ошибок,

604
00:36:23,630 --> 00:36:26,650
выяснить, как вести более точную атаку.

605
00:36:26,650 --> 00:36:31,410
Итак, как же неотъемлемой частью безопасности не только избежать этих атак совсем

606
00:36:31,410 --> 00:36:34,100
но обнаружение их и на самом деле, глядя на журналы

607
00:36:34,100 --> 00:36:36,780
и видя, что сумасшедший входов есть люди, введенные в свой сайт,

608
00:36:36,780 --> 00:36:38,960
какие поисковые термины люди набрали на свой сайт

609
00:36:38,960 --> 00:36:42,870
в надежде переполнены некоторые буфера.

610
00:36:42,870 --> 00:36:45,500
И все это сводится к простым основам того, что массив

611
00:36:45,500 --> 00:36:49,080
и что это значит для выделения и использования памяти.

612
00:36:49,080 --> 00:36:51,710
>> , Относящиеся к, что тогда тоже этого.

613
00:36:51,710 --> 00:36:54,280
Давайте просто заглянуть внутрь жесткого диска еще раз.

614
00:36:54,280 --> 00:36:58,440
Вы помните, с неделю или две назад, что при перетаскивании файлов в корзины или корзины,

615
00:36:58,440 --> 00:37:03,710
что происходит? >> [Студент] Ничего. >> Абсолютно ничего, верно?

616
00:37:03,710 --> 00:37:05,740
В конце концов, если вы запустите нехватке места на диске,

617
00:37:05,740 --> 00:37:08,190
ОС Windows или Mac OS начнется удаление файлов для вас.

618
00:37:08,190 --> 00:37:10,390
Но если вы перетащите что-то там, что вовсе не безопасно.

619
00:37:10,390 --> 00:37:13,800
Все ваш сосед или друг или член семьи должен сделать, дважды щелкните и, вуаля,

620
00:37:13,800 --> 00:37:16,310
там все отрывочные файлы, которые вы пытались удалить.

621
00:37:16,310 --> 00:37:19,590
Большинство из нас, по крайней мере, знаю, что вы должны правой кнопкой мыши или управления нажмите

622
00:37:19,590 --> 00:37:22,310
и пустой мусор или что-то вроде этого.

623
00:37:22,310 --> 00:37:25,000
Но даже то, что не совсем сделать трюк

624
00:37:25,000 --> 00:37:28,010
потому что то, что происходит, когда у вас есть файл на жестком диске

625
00:37:28,010 --> 00:37:32,770
, который представляет некоторый документ или несколько JPEG, и это является жесткий диск,

626
00:37:32,770 --> 00:37:35,350
и скажем, это ленты здесь представляет этот файл,

627
00:37:35,350 --> 00:37:38,390
и он состоит из целую кучу 0 и 1.

628
00:37:38,390 --> 00:37:42,470
Что происходит, когда вы не только перетащить файл в мусорное ведро или корзины

629
00:37:42,470 --> 00:37:48,020
но и очистить его? Вроде ничего.

630
00:37:48,020 --> 00:37:49,640
Это не абсолютно ничего не сейчас.

631
00:37:49,640 --> 00:37:54,290
Теперь это просто ничто, потому что кое-что происходит в форме этой таблице.

632
00:37:54,290 --> 00:37:58,370
Таким образом, есть своего рода базу данных или таблицу в памяти компьютера

633
00:37:58,370 --> 00:38:03,850
, что существенно имеет один столбец для файлов, имена и один столбец для файлов место,

634
00:38:03,850 --> 00:38:07,720
где это может быть расположение 123, просто случайное число.

635
00:38:07,720 --> 00:38:14,560
Таким образом, мы могли бы иметь что-то вроде x.jpeg и расположение 123.

636
00:38:14,560 --> 00:38:18,800
Что происходит потом, когда вы действительно опустошить ваш мусор?

637
00:38:18,800 --> 00:38:20,330
Это уходит.

638
00:38:20,330 --> 00:38:23,610
Но то, что не исчезает, это 0 и 1.

639
00:38:23,610 --> 00:38:26,270
>> Так в чем же тогда подключение к pset4?

640
00:38:26,270 --> 00:38:31,240
Ну, с pset4, просто потому, что мы случайно стерты компактные флэш-карты

641
00:38:31,240 --> 00:38:35,750
, что было все эти фотографии или просто потому, что его неудача была повреждена

642
00:38:35,750 --> 00:38:38,000
не означает, что 0 и 1, не все еще там.

643
00:38:38,000 --> 00:38:40,410
Может быть, некоторые из них потеряли, потому что что-то испортился

644
00:38:40,410 --> 00:38:43,320
В том смысле, что некоторые 0s стали 1 и 1с стала 0s.

645
00:38:43,320 --> 00:38:47,240
Плохие вещи могут произойти из-за ошибки в программном обеспечении или неисправность оборудования.

646
00:38:47,240 --> 00:38:50,370
Но многие из тех битов, может быть, даже 100% из них, все еще там.

647
00:38:50,370 --> 00:38:55,050
Это просто, что компьютер или камеру не знает, где JPEG1 начала

648
00:38:55,050 --> 00:38:56,910
и где JPEG2 началось.

649
00:38:56,910 --> 00:39:01,070
Но если вы программист, знаю, с немного здравого смысла, где эти изображения в формате JPEG являются

650
00:39:01,070 --> 00:39:06,010
или то, что они выглядят так что вы можете анализировать 0 и 1 и говорить JPEG, JPEG,

651
00:39:06,010 --> 00:39:09,440
Вы можете написать программу, с основном только для или во время цикла

652
00:39:09,440 --> 00:39:12,820
, которая восстанавливает каждый из этих файлов.

653
00:39:12,820 --> 00:39:16,030
Так что урок является то, чтобы начать безопасного удаления файлов

654
00:39:16,030 --> 00:39:18,340
если вы хотите, чтобы избежать этого вообще. Да.

655
00:39:18,340 --> 00:39:21,010
>> [Студент] Почему он говорит на вашем компьютере

656
00:39:21,010 --> 00:39:23,550
что у вас больше памяти, чем вы делали раньше?

657
00:39:23,550 --> 00:39:27,820
Иметь больше памяти, чем вы делали раньше - >> [студент] Подробнее доступной памяти.

658
00:39:27,820 --> 00:39:29,630
Ох. Хороший вопрос.

659
00:39:29,630 --> 00:39:32,360
Так почему же тогда после опорожнения мусор ваш компьютер вам сказать

660
00:39:32,360 --> 00:39:34,910
что у вас больше свободного пространства, чем вы делали раньше?

661
00:39:34,910 --> 00:39:36,770
В двух словах, потому что он лжет.

662
00:39:36,770 --> 00:39:40,740
Более технически, у вас есть больше пространства, потому что теперь вы сказали,

663
00:39:40,740 --> 00:39:43,680
Вы можете поместить другие вещи, где этот файл был раньше.

664
00:39:43,680 --> 00:39:45,450
Но это не означает, что бит уходит,

665
00:39:45,450 --> 00:39:48,590
и это не значит, биты меняются для всех 0s, например,

666
00:39:48,590 --> 00:39:50,150
для вашей защиты.

667
00:39:50,150 --> 00:39:54,640
Таким образом, в отличие от, если вы надежно стирать файлы или физически уничтожить устройство,

668
00:39:54,640 --> 00:39:57,300
, который действительно является единственным способом иногда вокруг этого.

669
00:39:57,300 --> 00:40:02,020
>> Так почему бы нам не оставить на этом полу-страшно записку, и мы будем видеть Вас в понедельник.

670
00:40:02,020 --> 00:40:07,000
[Аплодисменты]

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