1
00:00:00,000 --> 00:00:02,860
[Powered by Google Translate] [Седмица 5]

2
00:00:02,860 --> 00:00:04,860
[Дейвид Дж. Малан - Харвардския университет

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 000 допълнителни съученици

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 и CAS,

20
00:01:03,820 --> 00:01:07,560
това не е точно най-доброто съотношение ученик-учител, след като удари 80 000 от учениците.

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
>> Проблем Комплект 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
с офис Middlesex County окръжен прокурор прави съдебномедицинска работа

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
те ще паднат неща, като твърди дискове и CD-та и дискети и други подобни,

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
която ще бъде днес в 03:30 вместо обичайната 02: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
Bitmaps са забавни за нас, защото те имат малко по-голяма сложност.

77
00:04:19,959 --> 00:04:22,610
Това не е толкова просто, колкото тази мрежа на 0s и 1s.

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

79
00:04:27,510 --> 00:04:31,990
Така че, с други думи, в рамките на файла BMP цял куп 0s и 1s,

80
00:04:31,990 --> 00:04:34,910
но има някои допълнителни 0s и 1s там.

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
защото в края на деня всички тези файлове ние използваме само 0s и 1s.

85
00:04:52,480 --> 00:04:56,810
И може би тези 0s и 1s представляват ABC чрез ASCII или нещо подобно,

86
00:04:56,810 --> 00:04:58,820
но в края на деня, това е все още само 0s и 1s.

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
има модел на 0s и 1s, която представлява какво? Размерът на нещо.

95
00:05:33,740 --> 00:05:35,310
И не е от там.

96
00:05:35,310 --> 00:05:37,410
Така че в Проблем Комплект 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
Единият е да преоразмерите изображение, за да се вземе в модел на 0s и 1s,

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

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
И така, ние бързо се копират на 0s и 1s изключване на тази карта за вас

122
00:07:09,150 --> 00:07:13,610
спаси всички тях в един голям файл, а след това ще ги предам да ви Проблем Сет 4

123
00:07:13,610 --> 00:07:19,320
така че можете да напишете програма на С, с които да възстанови всички тези 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 започва с едни и същи модели на 0s и 1s.

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

128
00:07:35,630 --> 00:07:38,880
можете да превъртате над цялата 0s и 1s в този съдебен изображение,

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
подобни неща ме низ, дай ми едно цяло число - всички функции, които са изброени тук.

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
Чар *. За родителите, които е вероятно [прави се движи шумно звук]. Това е добре.

155
00:09:12,730 --> 00:09:17,550
Чар * ние ще започнете да виждате на екрана още по-премахнем низ от нашия речник,

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 техника

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
Оказва се, че булев и истина и лъжа всъщност не съществува в 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
Без това, вие ще трябва да сортирате съсипват и използване на вътр

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

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 получава вътр,

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
, които просто не могат да се поберат в рамките на едно цяло число? Какво е очакваното поведение?

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
Тя връща Int, докато (вярно), така че ние имаме умишлено безкраен цикъл,

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
Да. >> Студент изчистване не успее да го даде на цели числа.

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
>> Да превъртете надолу до мястото, където вътр всъщност е намерила.

265
00:15:45,040 --> 00:15:51,160
Ако превъртете надолу малко по-нататък, в съответствие 170, имаме коментар над тези редове.

266
00:15:51,160 --> 00:15:55,100
Ние заявяваме, 172 INT, N, и Чар, C, и след това тази нова функция,

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
Това не е вътр. Това не е номер. Тя изглежда като брой, но това не е реално.

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
След това се посочва в кавички, много подобен на ФОРМАТ, какво очаквате да видите в този низ.

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 и в прави за нас тук? >> [Ученик] Адрес на N и адрес на в.

290
00:17:21,740 --> 00:17:25,400
Да. Това ми дава адреса на N и адрес на в. Защо това е важно?

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 може да ме върне INT, десетично число,

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 и след това се връщат N, ако това се, в действителност, оценка да е истина.

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 - в тази променлива N за мен.

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
% В там е само за проверка за грешки.

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, освен съхраняване на стойности в N и в този пример тук,

320
00:19:18,210 --> 00:19:24,890
какво се е връща броя на променливите стойности инча

321
00:19:24,890 --> 00:19:30,260
Така че, ако имате само да въведете 123, то само% г ще да съвпадат,

322
00:19:30,260 --> 00:19:33,880
и само се записва N със стойност, като 123,

323
00:19:33,880 --> 00:19:35,640
и нищо не се получава в

324
00:19:35,640 --> 00:19:37,620
C остава боклук стойност, така да се каже -

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

326
00:19:40,730 --> 00:19:45,520
Така че в този случай, sscanf връща 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 ще види номер, номер, номера, е,

332
00:20:08,490 --> 00:20:16,410
и тя ще постави 123 в N, тя ще постави е в в и след това се върнете 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
Какво ще стане, ако просто написали в знак като е и натиснете Въведете без изобщо да пишете 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 може да покрие, че твърде, защото в този случай не става да запълни N или в.

348
00:21:08,790 --> 00:21:15,310
Това е вместо това ще върне 0, в който случай аз да се включат този сценарий

349
00:21:15,310 --> 00:21:18,750
, тъй като очакваната стойност, което искам, е едно.

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
Не е съвсем сигурен, когато това се случва, без да знае какво н ще се използва за още,

364
00:22:01,350 --> 00:22:03,590
но сега е малко по-интересна.

365
00:22:03,590 --> 00:22:06,520
В съответствие 243, ние заявяваме, ПНА, в.

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
Ние използвахме всички модели на 0s и 1s до.

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
Така че това, което светът е, че те използва следващото най-голямата стойност, нещо като едно цяло число,

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
Един от които има някакво специално значение като грешка.

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
е смисъла файл, така че getc, и след това стандартния вход.

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
проверете дали не е равно - \ N, така че потребителят е хит Въведете, ние искаме да спре в този момент,

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
Като настрана, ако сте някога хит Control D на клавиатурата не, че ще има още -

401
00:24:09,920 --> 00:24:15,230
вие сте удари Control C - Control D изпраща тази специална постоянна нарича EOF.

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

403
00:24:19,850 --> 00:24:23,440
>> Така че, ако (N + 1> капацитет). Сега ще обясня N.

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
Презаделяне ще направи всичко най-тежката работа за вас,

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 знака, дай ми сега не две, а четири символа,

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
[Ученик] масив - >> Array? >> [Ученик] знака. >> Други.

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
Тогава накрая, memcpy ние не сме използвали преди, но вероятно можете да се досетите, това, което го прави.

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 (Чар)). Това е правилно.

477
00:28:30,860 --> 00:28:33,930
Но в най-лошия случай, нека да приемем, че това е -

478
00:28:33,930 --> 00:28:35,950
Добре. След това има две грешки.

479
00:28:35,950 --> 00:28:39,160
Така че sizeof (Чар));

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
и не трябва никога да се случва да NULL го dereferencing със звездата оператор.

486
00:28:57,630 --> 00:29:01,050
Така че е добре. И какво правим? Логично е, че тук има един недостатък.

487
00:29:01,050 --> 00:29:04,450
[Ученик] Проверете дали argc> = 2.

488
00:29:04,450 --> 00:29:10,550
Така че проверете дали argc> = 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, основно трябва да информира 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
след като достигне тази затворена фигурна скоба в края на Foo

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
Запазени Frame показалеца се отнася по подобен начин за това.

523
00:31:23,940 --> 00:31:26,310
Чар * бар тук какво представлява?

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] е точно срещу бар, който е точно срещу Запазени Frame показалеца,

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 допълнителни байта да отидете? >> [Ученик] Inside -

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
, които представляват двоичен машинен код, 0s и 1s.

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
дали това е програма на командния ред или GUI програма или уеб сайт,

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
, която представлява някои Word документ или някои JPEG, и това представлява вашия твърд диск,

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

627
00:37:35,350 --> 00:37:38,390
и е съставен от цял ​​куп 0s и 1s.

628
00:37:38,390 --> 00:37:42,470
Какво се случва, когато не трябва само да плъзнете този файл в кошчето или кошчето

629
00:37:42,470 --> 00:37:48,020
но също така празна? Sort от нищо.

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
Но това, което не си отиде, е 0s и 1s.

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
не означава, че 0s и 1s не са все още там.

643
00:38:38,000 --> 00:38:40,410
Може би някои от тях са изгубени, защото нещо има повреден

644
00:38:40,410 --> 00:38:43,320
в смисъл, че някои 0s стана 1s и 1s стана 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
или как изглеждат, така че да може да се анализира 0s и 1s и да кажа, 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]