1
00:00:00,000 --> 00:00:02,860
[Powered by Google Translate] [Vecka 5]

2
00:00:02,860 --> 00:00:04,860
[David J. Malan - Harvard University]

3
00:00:04,860 --> 00:00:07,260
[Detta är CS50. - CS50.TV]

4
00:00:07,260 --> 00:00:09,740
>> Detta är CS50, vecka 5.

5
00:00:09,740 --> 00:00:12,900
Idag och denna vecka presenterar vi en liten bit av världen av kriminalteknik

6
00:00:12,900 --> 00:00:14,850
inom ramen av problemet Set 4.

7
00:00:14,850 --> 00:00:18,480
Idag blir en förkortad föreläsning eftersom det finns en särskild händelse här efteråt.

8
00:00:18,480 --> 00:00:21,940
Så vi tar en titt och retas både elever och föräldrar i dag

9
00:00:21,940 --> 00:00:24,600
med några av de saker som är på horisonten.

10
00:00:24,600 --> 00:00:29,050
>> Bland dem, som i måndag, kommer du att ha några fler klasskamrater.

11
00:00:29,050 --> 00:00:32,980
EDX, Harvard och MIT: s nya online-initiativ för OpenCourseWare och mer,

12
00:00:32,980 --> 00:00:36,730
lanserar på Harvards campus på måndag, vilket innebär kommit måndag

13
00:00:36,730 --> 00:00:40,930
du kommer att ha, från och med senaste räkningen, 86.000 nya klasskamrater

14
00:00:40,930 --> 00:00:43,680
som kommer att följa tillsammans med CS50 föreläsningar och sektioner

15
00:00:43,680 --> 00:00:45,890
och genomgångar och sätter problem.

16
00:00:45,890 --> 00:00:51,870
Och som en del av detta kommer du att bli medlemmar i det inledande klass CS50 och nu CS50x.

17
00:00:51,870 --> 00:00:56,150
Som en del av detta nu, inser att det kommer att finnas några upsides också.

18
00:00:56,150 --> 00:01:00,620
Att göra sig redo för det här, för det massiva antalet studenter,

19
00:01:00,620 --> 00:01:03,820
det räcker med att säga att även om vi har 108 TFS och CAS,

20
00:01:03,820 --> 00:01:07,560
det är inte riktigt den bästa elev-lärare förhållandet när vi slog 80.000 av eleverna.

21
00:01:07,560 --> 00:01:09,830
Vi kommer inte att klassificera så många problem sätter manuellt,

22
00:01:09,830 --> 00:01:13,050
så introducerade denna vecka i problemet som kommer att vara CS50 Check,

23
00:01:13,050 --> 00:01:15,410
som kommer att bli en kommandoradsverktyg i apparaten

24
00:01:15,410 --> 00:01:17,880
att du får när du uppdaterar det senare i helgen.

25
00:01:17,880 --> 00:01:21,030
Du kommer att kunna köra ett kommando, check50, på din egen pset,

26
00:01:21,030 --> 00:01:24,770
och du får omedelbar feedback om huruvida programmet är rätt eller fel

27
00:01:24,770 --> 00:01:27,980
enligt olika design specifikationer som vi tillhandahåller.

28
00:01:27,980 --> 00:01:30,310
Mer om detta i problemet inställda specifikationen.

29
00:01:30,310 --> 00:01:34,220
De CS50x klasskamrater kommer att använda detta.

30
00:01:34,220 --> 00:01:36,170
>> Problem Set 4 handlar om kriminalteknik,

31
00:01:36,170 --> 00:01:38,630
och denna pset var verkligen inspirerad av några verkliga saker

32
00:01:38,630 --> 00:01:41,210
varigenom när jag var i forskarskolan jag internerades ett tag

33
00:01:41,210 --> 00:01:45,270
med Middlesex län åklagare kontor gör kriminaltekniska arbetet

34
00:01:45,270 --> 00:01:47,660
med deras bly kriminaltekniska utredare.

35
00:01:47,660 --> 00:01:50,280
Vad detta innebar, eftersom jag tror att jag nämnde ett par veckor tidigare,

36
00:01:50,280 --> 00:01:52,720
är massan statspolisen eller andra skulle komma in,

37
00:01:52,720 --> 00:01:56,150
de skulle släppa av saker som hårddiskar och CD-skivor och disketter och liknande,

38
00:01:56,150 --> 00:01:58,770
och därefter mål kriminalteknik kontoret var att fastställa

39
00:01:58,770 --> 00:02:01,470
om det fanns eller inte var bevis av något slag.

40
00:02:01,470 --> 00:02:04,730
Detta var den särskilda utredningar enhet, så det var ekonomisk brottslighet.

41
00:02:04,730 --> 00:02:10,949
Det var mer oroande slags brott, något som innebär någon form av digitala medier.

42
00:02:10,949 --> 00:02:16,450
Det visar sig att inte så många människor skriver ett e-postmeddelande att säga "jag gjorde det."

43
00:02:16,450 --> 00:02:20,490
Så ofta, har dessa kriminaltekniska sökningar Höj inte så mycket frukt,

44
00:02:20,490 --> 00:02:22,820
men ibland folk skulle skriva sådana meddelanden.

45
00:02:22,820 --> 00:02:25,240
Så ibland var de ansträngningar belönas.

46
00:02:25,240 --> 00:02:31,210
>> Men att leda fram till detta kriminaltekniska pset kommer vi att introducera i pset4 lite grafik.

47
00:02:31,210 --> 00:02:35,410
Du tar förmodligen dessa saker för givet - JPEG, GIF och liknande - i dessa dagar.

48
00:02:35,410 --> 00:02:38,320
Men om du verkligen tänker på det, en bild, ungefär som Rob ansikte,

49
00:02:38,320 --> 00:02:41,270
skulle kunna utformas som en sekvens av punkter eller pixlar.

50
00:02:41,270 --> 00:02:43,380
I fallet av Rob ansikte, det finns alla möjliga färger,

51
00:02:43,380 --> 00:02:46,760
och vi började se de enskilda punkter, annars känd som pixlar,

52
00:02:46,760 --> 00:02:48,610
när vi började att zooma in

53
00:02:48,610 --> 00:02:54,660
Men om vi förenklar världen lite och bara säga att detta här är Rob i svart och vitt,

54
00:02:54,660 --> 00:02:57,490
att representera svart och vitt, kan vi använda bara binärt.

55
00:02:57,490 --> 00:03:01,660
Och om vi ska använda binära, 1 eller 0, kan vi uttrycka samma bild

56
00:03:01,660 --> 00:03:06,140
av Rob leende ansikte med detta mönster av bitar.

57
00:03:06,140 --> 00:03:12,100
11000011 representerar vitt, vitt, svart, svart, svart, svart, vit, vit.

58
00:03:12,100 --> 00:03:16,150
Och så är det inte ett stort steg att sedan börja tala om färgglada fotografier,

59
00:03:16,150 --> 00:03:18,600
saker som du skulle se på Facebook eller ta med en digitalkamera.

60
00:03:18,600 --> 00:03:21,410
Men säkert när det kommer till färger, behöver du fler bitar.

61
00:03:21,410 --> 00:03:25,690
Och ganska vanligt i världen av fotografier är att inte använda 1-bitars färg,

62
00:03:25,690 --> 00:03:29,560
eftersom detta antyder, men 24-bitars färg, där du faktiskt få miljontals färger.

63
00:03:29,560 --> 00:03:32,250
Så som i fallet när vi zoomat in på Rob öga,

64
00:03:32,250 --> 00:03:36,370
Det var ett antal miljoner olika färgglada möjligheter.

65
00:03:36,370 --> 00:03:39,040
Så vi ska införa detta i problembild 4 samt i genomgången,

66
00:03:39,040 --> 00:03:43,370
som kommer att vara idag på 3:30 istället för den vanliga 2:30 på grund av fredagens föreläsning här.

67
00:03:43,370 --> 00:03:46,620
Men video kommer att vara online som vanligt imorgon.

68
00:03:46,620 --> 00:03:48,820
>> Vi kommer också att introducera dig till ett annat filformat.

69
00:03:48,820 --> 00:03:51,270
Detta är avsiktligt tänkt att se hotfull först,

70
00:03:51,270 --> 00:03:55,670
men detta är bara några underlag för en C struct.

71
00:03:55,670 --> 00:03:58,940
Det visar sig att Microsoft år sedan hjälpte popularisera detta format

72
00:03:58,940 --> 00:04:05,150
kallas bitmapp filformat, bmp, och detta var en super enkel, färgglad grafisk filformat

73
00:04:05,150 --> 00:04:10,150
som användes under ganska lång tid och ibland fortfarande för tapeter på stationära datorer.

74
00:04:10,150 --> 00:04:14,760
Om du tänker tillbaka på Windows XP och de rullande kullarna och den blå himlen,

75
00:04:14,760 --> 00:04:17,170
Det var oftast en bmp eller bitmappsbild.

76
00:04:17,170 --> 00:04:19,959
Bitmappar är roligt för oss eftersom de har lite mer komplexitet.

77
00:04:19,959 --> 00:04:22,610
Det är inte riktigt så enkelt som detta nät av 0 och 1.

78
00:04:22,610 --> 00:04:27,510
Istället har du saker som en rubrik i början av en fil.

79
00:04:27,510 --> 00:04:31,990
Så med andra ord, inne i en. Bmp-fil är en hel massa av 0 och 1,

80
00:04:31,990 --> 00:04:34,910
men det finns några ytterligare 0 och 1 där.

81
00:04:34,910 --> 00:04:38,220
Och det visar sig att det vi förmodligen har tagit för givet år -

82
00:04:38,220 --> 00:04:45,170
filformat som. doc eller. xls eller. mp3,. mp4 oavsett filformat

83
00:04:45,170 --> 00:04:48,480
att du är bekant med - vad innebär det även att vara ett filformat,

84
00:04:48,480 --> 00:04:52,480
eftersom i slutet av dagen alla dessa filer använder vi bara har 0 och 1.

85
00:04:52,480 --> 00:04:56,810
Och kanske de 0 och 1 representerar ABC genom ASCII eller liknande,

86
00:04:56,810 --> 00:04:58,820
men i slutet av dagen, det är fortfarande bara 0 och 1.

87
00:04:58,820 --> 00:05:02,100
Så människor bara ibland väljer att uppfinna ett nytt filformat

88
00:05:02,100 --> 00:05:06,420
där de standardisera vilka mönster av bitar i praktiken kommer att innebära.

89
00:05:06,420 --> 00:05:09,220
Och i detta fall här, folk som ritade bitmap-format

90
00:05:09,220 --> 00:05:15,620
sade att den allra första byten i en bitmappsfil som betecknas med offset 0 där,

91
00:05:15,620 --> 00:05:18,940
det kommer att vara några kryptiskt namn variabel kallad bfType,

92
00:05:18,940 --> 00:05:23,080
som bara står för bitmap filtyp, vilken typ av bitmap-fil är det.

93
00:05:23,080 --> 00:05:27,700
Du kan sluta kanske från den andra raden som offset 2, byte nummer 2,

94
00:05:27,700 --> 00:05:33,740
har ett mönster av 0 och 1 som representerar vad? Storleken på något.

95
00:05:33,740 --> 00:05:35,310
Och det fortsätter därifrån.

96
00:05:35,310 --> 00:05:37,410
Så i problembild 4, kommer du att gått igenom några av dessa saker.

97
00:05:37,410 --> 00:05:39,520
Vi kommer inte att sluta bry sig om dem alla.

98
00:05:39,520 --> 00:05:47,510
Men märker det börjar bli intressant runt byte 54: rgbtBlue, Grön och Röd.

99
00:05:47,510 --> 00:05:52,110
Om du någonsin hört förkortningen RGB - röd, grön, blå - detta är en referens till den

100
00:05:52,110 --> 00:05:54,610
eftersom det visar sig att du kan måla alla regnbågens färger

101
00:05:54,610 --> 00:05:58,180
med en kombination av rött och blått och grönt.

102
00:05:58,180 --> 00:06:03,320
Och i själva verket kan föräldrarna i rummet erinra om några av de tidigaste projektorer.

103
00:06:03,320 --> 00:06:05,890
Dessa dagar, ser du bara en ljus som kommer ut ur en lins,

104
00:06:05,890 --> 00:06:09,800
men tillbaka i dag du hade röd lins, blå lins, och den gröna linsen,

105
00:06:09,800 --> 00:06:13,380
och tillsammans syftar till en skärm och bildade en färgstark bild.

106
00:06:13,380 --> 00:06:16,270
Och ganska ofta skulle mellersta skolor och gymnasier har dessa linser

107
00:06:16,270 --> 00:06:19,720
någonsin så lite snett, så du var typ att se dubbla eller tredubbla bilder.

108
00:06:19,720 --> 00:06:24,100
Men det var tanken. Du hade rött och grönt och blått ljus måla en bild.

109
00:06:24,100 --> 00:06:26,590
Och att samma princip används i datorer.

110
00:06:26,590 --> 00:06:30,230
>> Så bland de utmaningar då för dig i problembild 4 kommer att vara ett par saker.

111
00:06:30,230 --> 00:06:34,800
En är att faktiskt ändra storlek på en bild, för att ta i ett mönster av 0 och 1,

112
00:06:34,800 --> 00:06:40,200
reda på vilka bitar av 0 och 1 representerar vad i en struktur som denna,

113
00:06:40,200 --> 00:06:43,630
och sedan räkna ut hur att replikera pixlar - de röda, de blå, de gröna -

114
00:06:43,630 --> 00:06:46,660
inne så att när en bild ser ut så här från början,

115
00:06:46,660 --> 00:06:49,210
kan det se ut så här i stället efter det.

116
00:06:49,210 --> 00:06:53,640
Bland andra utmaningar också kommer att vara att du kommer att överlämnas en rättsmedicinsk bild

117
00:06:53,640 --> 00:06:56,030
av en verklig fil från en digitalkamera.

118
00:06:56,030 --> 00:06:58,960
Och på den kameran, en gång i tiden var en massa bilder.

119
00:06:58,960 --> 00:07:03,760
Problemet är att vi raderas av misstag eller hade bilden skadad på något sätt.

120
00:07:03,760 --> 00:07:05,750
Dåliga saker händer med digitalkameror.

121
00:07:05,750 --> 00:07:09,150
Och så vi kopierade snabbt alla 0 och 1 bort av det kortet för dig,

122
00:07:09,150 --> 00:07:13,610
räddade dem alla i en stor fil, och sedan kommer vi lämna dem till dig i problembild 4

123
00:07:13,610 --> 00:07:19,320
så att du kan skriva ett program i C som man kan återvinna alla dessa JPEG, helst.

124
00:07:19,320 --> 00:07:23,330
Och det visar sig att JPEG, även om de är något av en komplex filformat -

125
00:07:23,330 --> 00:07:26,360
de är mycket mer komplex än så leende ansikte här -

126
00:07:26,360 --> 00:07:31,160
det visar sig att alla JPEG börjar med samma mönster av 0 och 1.

127
00:07:31,160 --> 00:07:35,630
Så använder i slutändan en while-slinga eller en for-slinga eller liknande,

128
00:07:35,630 --> 00:07:38,880
Du kan iterera över alla 0 och 1 i detta kriminaltekniska bild,

129
00:07:38,880 --> 00:07:43,150
och varje gång du ser den speciella mönster som är definierat i problemet inställda specifikation,

130
00:07:43,150 --> 00:07:47,880
Du kan anta här är, med mycket hög sannolikhet, början på en JPEG.

131
00:07:47,880 --> 00:07:51,230
Och så fort du hittar samma mönster visst antal byte

132
00:07:51,230 --> 00:07:55,430
eller kilobyte eller megabyte senare kan du anta här är en andra JPEG,

133
00:07:55,430 --> 00:07:57,380
bilden jag tog efter den första.

134
00:07:57,380 --> 00:08:01,370
Låt mig sluta läsa den första filen, börja skriva den nya en,

135
00:08:01,370 --> 00:08:06,310
och utgången av ditt program för pset4 kommer att bli så många som 50 JPEG-bilder.

136
00:08:06,310 --> 00:08:09,270
Och om det inte är 50 JPEG-bilder, du har en bit av en slinga.

137
00:08:09,270 --> 00:08:12,490
Om du har ett oändligt antal JPEG, har du en oändlig loop.

138
00:08:12,490 --> 00:08:14,910
Så att även kommer att vara ganska vanligt fall.

139
00:08:14,910 --> 00:08:16,600
Så det är vad som finns på horisonten.

140
00:08:16,600 --> 00:08:21,310
>> Quiz 0 bakom oss, inser per min e-post som alltid finns folk som är både glad,

141
00:08:21,310 --> 00:08:23,640
slags neutral och ledsen runt frågesport 0 tid.

142
00:08:23,640 --> 00:08:26,800
Och ska du nå ut till mig, huvudet TF Zamyla, din egen TF,

143
00:08:26,800 --> 00:08:31,180
eller en av de certifikatutfärdare som du vet om du vill diskutera hur det gick.

144
00:08:31,180 --> 00:08:35,539
>> Så för att imponera på föräldrarna här i rummet, vad är det CS50 biblioteket?

145
00:08:36,429 --> 00:08:40,390
[Skratt] Bra jobbat.

146
00:08:40,390 --> 00:08:48,340
Vad är det CS50 biblioteket? Ja. >> [Elev] Det är en redan skrivna uppsättning kod [ohörbart]

147
00:08:48,340 --> 00:08:49,750
Okej, bra.

148
00:08:49,750 --> 00:08:53,240
Det är en redan skrivna uppsättning kod som vi personalen skrev ger vi dig,

149
00:08:53,240 --> 00:08:55,030
som ger vissa gemensamma funktioner,

150
00:08:55,030 --> 00:08:59,020
sånt får mig en sträng, ge mig en int - alla de funktioner som är listade här.

151
00:08:59,020 --> 00:09:02,260
>> Från och med nu börjar vi verkligen ta dessa stödhjul av.

152
00:09:02,260 --> 00:09:05,050
Vi kommer att börja ta bort en sträng från dig,

153
00:09:05,050 --> 00:09:08,870
vilket minns var bara en synonym för vad den faktiska datatypen? >> [Flera studenter] Char *.

154
00:09:08,870 --> 00:09:12,730
Char *. För föräldrar, det var förmodligen [gör whooshing ljud]. Det är bra.

155
00:09:12,730 --> 00:09:17,550
Char * vi börja se på skärmen desto mer när vi tar bort sträng från vårt ordförråd,

156
00:09:17,550 --> 00:09:19,730
åtminstone när det gäller att faktiskt skriva kod.

157
00:09:19,730 --> 00:09:22,840
Likaså kommer vi sluta använda en del av dessa funktioner så mycket

158
00:09:22,840 --> 00:09:25,280
eftersom våra program kommer att få mer sofistikerade.

159
00:09:25,280 --> 00:09:28,480
Snarare än att bara skriva program som sitter där med en snabb blinkande,

160
00:09:28,480 --> 00:09:31,870
väntar på användaren att skriva något i, får du dina insatser från andra håll.

161
00:09:31,870 --> 00:09:35,490
Till exempel får du dem från en rad bitar på den lokala hårddisken.

162
00:09:35,490 --> 00:09:38,580
Du kommer istället få dem i framtiden från en nätverksanslutning,

163
00:09:38,580 --> 00:09:40,230
någon hemsida någonstans.

164
00:09:40,230 --> 00:09:44,110
>> Så låt oss dra tillbaka detta lager för första gången och dra upp CS50 Appliance

165
00:09:44,110 --> 00:09:49,010
och denna fil som heter cs50.h, som du har varit # även för veckor,

166
00:09:49,010 --> 00:09:51,140
men låt oss faktiskt se vad som finns inuti denna.

167
00:09:51,140 --> 00:09:54,430
Den övre delen av filen i blått är bara en massa kommentarer:

168
00:09:54,430 --> 00:09:57,050
garantiinformation och licensiering.

169
00:09:57,050 --> 00:09:59,050
Detta är en slags gemensam paradigm i programvara

170
00:09:59,050 --> 00:10:01,580
eftersom en massa program dessa dagar är vad som kallas öppen källkod,

171
00:10:01,580 --> 00:10:05,220
vilket innebär att någon har skrivit koden och gjort den fritt tillgänglig

172
00:10:05,220 --> 00:10:10,470
inte bara att köra och att använda men att faktiskt läsa och ändra och integrera i ditt eget arbete.

173
00:10:10,470 --> 00:10:14,660
Så det är vad du har använt, öppen källkod, om än i en mycket liten form.

174
00:10:14,660 --> 00:10:18,560
Om jag bläddra ner förbi kommentarer, men vi börjar se lite mer bekanta saker.

175
00:10:18,560 --> 00:10:25,010
Meddelande upptill här att cs50.h filen innehåller en hel del header-filer.

176
00:10:25,010 --> 00:10:28,560
De flesta av dessa, har vi inte sett förut, men en är bekant.

177
00:10:28,560 --> 00:10:32,270
Vilka av dessa har vi sett, om än kortfattat, hittills? >> [Elev] Standard bibliotek.

178
00:10:32,270 --> 00:10:35,810
Ja, standard bibliotek. stdlib.h har malloc.

179
00:10:35,810 --> 00:10:38,320
När vi började prata om dynamisk minnesallokering,

180
00:10:38,320 --> 00:10:41,650
som vi ska återkomma till nästa vecka också, började vi även den filen.

181
00:10:41,650 --> 00:10:46,640
Det visar sig att bool och sant och falskt egentligen inte existerar i C i sig

182
00:10:46,640 --> 00:10:49,440
om du inte inkludera denna fil här.

183
00:10:49,440 --> 00:10:52,710
Vi har i flera veckor varit bland stdbool.h

184
00:10:52,710 --> 00:10:55,620
så att du kan använda begreppet bool, sant eller falskt.

185
00:10:55,620 --> 00:10:58,620
Utan detta, skulle du behöva sortera av falska den och använda en int

186
00:10:58,620 --> 00:11:02,610
och bara godtyckligt anta att 0 är falsk och 1 är sant.

187
00:11:02,610 --> 00:11:07,150
Om vi ​​rulla ner ytterligare, här är vår definition av en sträng.

188
00:11:07,150 --> 00:11:11,390
Det visar sig, som vi har sagt tidigare, att där denna stjärna är egentligen inte spelar någon roll.

189
00:11:11,390 --> 00:11:13,720
Du kan även få utrymme runt.

190
00:11:13,720 --> 00:11:16,740
Vi här terminen har varit att främja det som detta för att göra klart

191
00:11:16,740 --> 00:11:18,620
att stjärnan har att göra med den typ

192
00:11:18,620 --> 00:11:21,700
men inser lika vanligt, om inte lite vanligare,

193
00:11:21,700 --> 00:11:24,430
är att lägga den där, men funktionellt är det samma sak.

194
00:11:24,430 --> 00:11:27,720
Men nu när vi läser ned ytterligare, låt oss ta en titt på getInt

195
00:11:27,720 --> 00:11:32,190
eftersom vi använde det kanske först före allt annat här terminen.

196
00:11:32,190 --> 00:11:37,440
Här är getInt. Detta är vad? >> [Elev] En prototyp. >> Det här är bara en prototyp.

197
00:11:37,440 --> 00:11:41,410
Ofta har vi lagt prototyper på toppen av vår. C-filer,

198
00:11:41,410 --> 00:11:46,690
men du kan också lägga prototyper i header-filer,. h-filer, som den här här

199
00:11:46,690 --> 00:11:50,840
så att när du skriver vissa funktioner som du vill att andra ska kunna använda,

200
00:11:50,840 --> 00:11:53,550
vilket är precis fallet med CS50 biblioteket,

201
00:11:53,550 --> 00:11:57,040
du inte bara genomföra dina uppgifter i något liknande cs50.c,

202
00:11:57,040 --> 00:12:02,790
du sätter också prototyperna inte på toppen av den filen, men på toppen av en huvudfil.

203
00:12:02,790 --> 00:12:07,170
Då header-fil är det som vänner och kollegor har

204
00:12:07,170 --> 00:12:09,760
med # include i sin egen kod.

205
00:12:09,760 --> 00:12:12,210
Så hela den här tiden, du har även alla dessa prototyper,

206
00:12:12,210 --> 00:12:16,580
effektivt på toppen av din fil men genom detta är # mekanism,

207
00:12:16,580 --> 00:12:20,070
som i huvudsak kopior och pastor filen till din egen.

208
00:12:20,070 --> 00:12:23,070
Här är några ganska detaljerad dokumentation.

209
00:12:23,070 --> 00:12:25,640
Vi har ganska mycket tas för givet att getInt får en int,

210
00:12:25,640 --> 00:12:27,640
men det visar sig att det finns vissa hörn fall.

211
00:12:27,640 --> 00:12:31,810
Vad händer om användaren skriver in ett nummer som är alldeles för stor, en kvintiljon,

212
00:12:31,810 --> 00:12:35,490
som bara inte får plats inuti en int? Vad är det förväntade beteendet?

213
00:12:35,490 --> 00:12:38,020
Helst är det förutsägbart.

214
00:12:38,020 --> 00:12:40,280
Så i det här fallet, om du läser faktiskt det finstilta,

215
00:12:40,280 --> 00:12:44,500
du faktiskt se att om linjen inte kan läsas, detta returer INT_MAX.

216
00:12:44,500 --> 00:12:48,320
Vi har aldrig pratat om det här, men baserat på dess kapitalisering, vad är det förmodligen?

217
00:12:48,320 --> 00:12:50,640
[Elev] En konstant. >> Det är en konstant.

218
00:12:50,640 --> 00:12:54,770
Det är några speciella konstant som troligen uttalade i en av dessa header-filer

219
00:12:54,770 --> 00:13:00,090
Det är upp högre i filen och INT_MAX är förmodligen något i stil med cirka 2 miljarder kronor,

220
00:13:00,090 --> 00:13:04,990
Tanken är att eftersom vi måste på något sätt betyda att något gick fel,

221
00:13:04,990 --> 00:13:10,700
Vi, ja, har 4 miljarder siffror till vårt förfogande: -2 miljarder upp till 2 miljarder, ge eller ta.

222
00:13:10,700 --> 00:13:14,710
Nå, vad är vanligt i programmering är du stjäla bara en av dessa siffror,

223
00:13:14,710 --> 00:13:18,920
kanske 0, kanske 2 miljarder, kanske -2.000 miljoner,

224
00:13:18,920 --> 00:13:23,280
så du spenderar en av dina möjliga värden så att du kan engagera sig i världen

225
00:13:23,280 --> 00:13:26,820
att om något går fel, jag återkommer denna super stort värde.

226
00:13:26,820 --> 00:13:31,030
Men du vill inte att användaren skriver något kryptiskt som 234 ..., en riktigt stor siffra.

227
00:13:31,030 --> 00:13:34,060
Man generalisera det istället som en konstant.

228
00:13:34,060 --> 00:13:38,060
Så egentligen, om du är analsex de senaste veckorna, när som helst du ringde getInt,

229
00:13:38,060 --> 00:13:42,900
du borde ha kontroll med om villkor gjorde användartyp i INT_MAX,

230
00:13:42,900 --> 00:13:46,590
eller, mer specifikt, gjorde getInt retur INT_MAX, för om den gjorde det,

231
00:13:46,590 --> 00:13:51,830
det betyder egentligen de inte skriva in det. Något gick fel i det här fallet.

232
00:13:51,830 --> 00:13:56,080
Så detta är vad som allmänt är känt som en vaktpost värde, vilket betyder bara speciell.

233
00:13:56,080 --> 00:13:58,120
>> Låt oss nu övergå till den. C. filen.

234
00:13:58,120 --> 00:14:01,340
C-filen har funnits i apparaten under en längre tid.

235
00:14:01,340 --> 00:14:06,840
Och i själva verket har apparaten den förkompilerade för dig in i det som vi kallade objektkod,

236
00:14:06,840 --> 00:14:09,540
men det bara inte roll för dig om det är på grund av att systemet vet

237
00:14:09,540 --> 00:14:11,730
i detta fall där det är: apparaten.

238
00:14:11,730 --> 00:14:17,400
Låt oss rulla ner nu getInt och se hur getInt har arbetat hela tiden.

239
00:14:17,400 --> 00:14:19,460
Här har vi har liknande kommentarer från tidigare.

240
00:14:19,460 --> 00:14:21,660
Låt mig zooma in på bara koden delen.

241
00:14:21,660 --> 00:14:23,900
Och vad vi har för getInt är följande.

242
00:14:23,900 --> 00:14:25,700
Det tar ingen ingång.

243
00:14:25,700 --> 00:14:29,510
Den returnerar en int, medan (sant), så vi har en medveten oändlig slinga,

244
00:14:29,510 --> 00:14:33,180
men förmodligen kommer vi bryta detta på något sätt eller returnera inifrån detta.

245
00:14:33,180 --> 00:14:34,870
>> Låt oss se hur det fungerar.

246
00:14:34,870 --> 00:14:39,240
Vi verkar använda GetString i denna första raden innanför slingan, 166.

247
00:14:39,240 --> 00:14:43,780
Detta är nu god praxis för under vilka omständigheter skulle GetString tillbaka

248
00:14:43,780 --> 00:14:47,660
den speciella sökord NULL? >> [Elev] Om något går fel.

249
00:14:47,660 --> 00:14:51,630
Om något går fel. Och vad kan gå fel när du ringer något liknande GetString?

250
00:14:54,960 --> 00:14:57,640
Ja. >> [Elev] malloc inte ge den Ints.

251
00:14:57,640 --> 00:14:59,150
Ja. Kanske malloc misslyckas.

252
00:14:59,150 --> 00:15:03,190
Någonstans under huven, är GetString ringer malloc, som fördelar minne,

253
00:15:03,190 --> 00:15:06,020
som låter datorbutik alla tecken

254
00:15:06,020 --> 00:15:07,750
att användare skriver i tangentbordet.

255
00:15:07,750 --> 00:15:11,590
Och antar att användaren hade en hel del ledig tid och skrev mer, till exempel,

256
00:15:11,590 --> 00:15:16,160
än 2 miljarder tecken i, fler tecken än datorn har även RAM.

257
00:15:16,160 --> 00:15:19,250
GetString måste kunna beteckna det till dig.

258
00:15:19,250 --> 00:15:22,560
Även om detta är en super, super ovanligt hörn fall,

259
00:15:22,560 --> 00:15:24,340
det måste på något sätt kunna hantera detta,

260
00:15:24,340 --> 00:15:28,750
och så getString, om vi gick tillbaka och läsa dess dokumentation, faktiskt tillbaka NULL.

261
00:15:28,750 --> 00:15:34,460
Så nu om GetString misslyckas genom att returnera NULL är getInt kommer att misslyckas genom att returnera INT_MAX

262
00:15:34,460 --> 00:15:37,690
precis som en vaktpost. Dessa är bara mänskliga konventioner.

263
00:15:37,690 --> 00:15:41,450
Det enda sättet du skulle veta detta är fallet är att läsa dokumentationen.

264
00:15:41,450 --> 00:15:45,040
>> Låt oss bläddra ner till där int faktiskt fått.

265
00:15:45,040 --> 00:15:51,160
Om jag scrolla ner en bit i linje 170, har vi en kommentar ovanför dessa rader.

266
00:15:51,160 --> 00:15:55,100
Vi förklarar i 172 en int, n, och en röding, c och sedan denna nya funktion,

267
00:15:55,100 --> 00:15:58,930
som vissa av er har snubblat över tidigare, sscanf.

268
00:15:58,930 --> 00:16:00,870
Detta står för sträng scanf.

269
00:16:00,870 --> 00:16:05,700
Med andra ord, ge mig en sträng och jag kommer att söka det för bitar av information av intresse.

270
00:16:05,700 --> 00:16:07,360
Vad betyder det?

271
00:16:07,360 --> 00:16:11,800
Antag att jag skriver i, bokstavligen, 123 på tangentbordet och sedan trycka Enter.

272
00:16:11,800 --> 00:16:16,470
Vad är datatypen för 123 när returneras av GetString? >> [Elev] Sträng.

273
00:16:16,470 --> 00:16:18,380
Det är naturligtvis en sträng, eller hur? Jag fick en sträng.

274
00:16:18,380 --> 00:16:23,220
Så 123 är egentligen citat-unquote, 123 med \ 0 i slutet av den.

275
00:16:23,220 --> 00:16:27,110
Det är inte en int. Det är inte ett nummer. Det ser ut som ett nummer men det är faktiskt inte.

276
00:16:27,110 --> 00:16:29,080
Så vad har getInt att göra?

277
00:16:29,080 --> 00:16:35,750
Den måste avsöka strängen vänster till höger - 123 \ 0 - och på något sätt omvandlas till en faktisk heltal.

278
00:16:35,750 --> 00:16:37,850
Du kan räkna ut hur man gör detta.

279
00:16:37,850 --> 00:16:41,450
Om du tänker tillbaka på pset2, du förmodligen lite bekväm med Caesar

280
00:16:41,450 --> 00:16:44,820
eller Vigenère, så att du kan iterera över en sträng kan du konvertera tecken vare sin.

281
00:16:44,820 --> 00:16:46,710
Men heck, det är en hel del arbete.

282
00:16:46,710 --> 00:16:49,860
Varför inte kalla en funktion som sscanf som gör det åt dig?

283
00:16:49,860 --> 00:16:54,230
Så sscanf förväntar ett argument - i detta fall kallas linje, vilket är en sträng.

284
00:16:54,230 --> 00:17:01,840
Du anger sedan i citat, mycket likt printf, vad du förväntar dig att se i denna sträng.

285
00:17:01,840 --> 00:17:09,000
Och vad jag säger här är jag förväntar mig att se ett decimaltal och kanske ett tecken.

286
00:17:09,000 --> 00:17:12,000
Och vi kommer att se varför detta är fallet på bara ett ögonblick.

287
00:17:12,000 --> 00:17:15,869
Och det visar sig att denna notation nu påminner om saker vi började prata om

288
00:17:15,869 --> 00:17:17,619
drygt en vecka sedan.

289
00:17:17,619 --> 00:17:21,740
Vad är & n och & c gör för oss här? >> [Elev] adress n och adress c..

290
00:17:21,740 --> 00:17:25,400
Ja. Det ger mig adressen till n och adress c.. Varför är det viktigt?

291
00:17:25,400 --> 00:17:30,220
Du vet att med funktioner i C, kan du alltid returnera ett värde eller inget värde alls.

292
00:17:30,220 --> 00:17:34,530
Du kan returnera en int, en sträng, en flottör, en röding, oavsett, eller så kan du gå tillbaka ogiltig,

293
00:17:34,530 --> 00:17:38,030
men du kan bara returnera en sak maximalt.

294
00:17:38,030 --> 00:17:42,760
Men här vill vi sscanf tillbaka mig kanske en int, ett decimaltal,

295
00:17:42,760 --> 00:17:46,220
och även en röding, och jag ska förklara varför röding i ett ögonblick.

296
00:17:46,220 --> 00:17:51,460
Du vill effektivt sscanf tillbaka två saker, men det är bara inte möjligt i C.

297
00:17:51,460 --> 00:17:55,200
Du kan lösa det genom att i två adresser

298
00:17:55,200 --> 00:17:57,370
eftersom så snart du lämnar en funktion två adresser,

299
00:17:57,370 --> 00:18:00,470
vad kan denna funktion göra med dem? >> [Elev] Skriv till dessa adresser.

300
00:18:00,470 --> 00:18:02,010
Den kan skriva till dessa adresser.

301
00:18:02,010 --> 00:18:05,770
Du kan använda stjärnan drift och dit, till var och en av dessa adresser.

302
00:18:05,770 --> 00:18:11,260
Det är typ av denna bakdörren mekanism men mycket vanligt att ändra värdena på variabler

303
00:18:11,260 --> 00:18:14,870
mer än bara en plats - i det här fallet, två.

304
00:18:14,870 --> 00:18:21,340
Nu märker jag söker efter == 1 och sedan återvänder n om det betyder i själva verket utvärderas till sant.

305
00:18:21,340 --> 00:18:26,170
Så vad händer om? Tekniskt sett är allt vi verkligen vill ska hända i getInt detta.

306
00:18:26,170 --> 00:18:30,740
Vi vill tolka, så att säga, vi vill läsa strängen - citat-unquote 123 -

307
00:18:30,740 --> 00:18:34,560
och om det ser ut som det finns ett antal där, vad vi säger sscanf att göra

308
00:18:34,560 --> 00:18:38,190
läggs det numret - 123 - i denna variabel n för mig.

309
00:18:38,190 --> 00:18:42,090
Så varför då hade jag faktiskt detta också?

310
00:18:42,090 --> 00:18:48,220
Vilken roll sscanf säger du också kan få en karaktär här?

311
00:18:48,220 --> 00:18:53,470
[Ohörbart elev svar] >> En decimalpunkt faktiskt skulle kunna fungera.

312
00:18:53,470 --> 00:18:56,330
Låt oss hålla det trodde för ett ögonblick. Vad mer?

313
00:18:56,330 --> 00:18:59,270
[Elev] Det kan vara NULL. >> Bra tanke. Det kan vara noll karaktär.

314
00:18:59,270 --> 00:19:01,660
Det är faktiskt inte i detta fall. Ja. >> [Elev] ASCII.

315
00:19:01,660 --> 00:19:04,340
ASCII. Eller låt mig generalisera ytterligare.

316
00:19:04,340 --> 00:19:06,640
Den% c finns bara för felkontroll.

317
00:19:06,640 --> 00:19:09,300
Vi vill inte att det skall finnas ett tecken efter numret,

318
00:19:09,300 --> 00:19:11,870
men vad detta tillåter mig att göra är följande.

319
00:19:11,870 --> 00:19:18,210
Det visar sig att sscanf, förutom att lagra värden i N och C i detta exempel här,

320
00:19:18,210 --> 00:19:24,890
vad det också gör det returnerar antalet variabler det sätta värden i.

321
00:19:24,890 --> 00:19:30,260
Så om du bara skriva in 123, då endast% d går att matcha,

322
00:19:30,260 --> 00:19:33,880
och endast n får lagras med ett värde som 123,

323
00:19:33,880 --> 00:19:35,640
och ingenting får placeras i C.

324
00:19:35,640 --> 00:19:37,620
C är ett skräp värde, så att säga -

325
00:19:37,620 --> 00:19:40,730
sopor eftersom det aldrig har varit initieras till något värde.

326
00:19:40,730 --> 00:19:45,520
Så i detta fall återvänder sscanf 1 eftersom jag befolkade 1 av dessa pekare,

327
00:19:45,520 --> 00:19:50,190
i vilket fall bra, jag har en int så jag frigöra linjen för att frigöra minne

328
00:19:50,190 --> 00:19:54,000
att GetString tilldelade faktiskt, och sedan jag återvänder n,

329
00:19:54,000 --> 00:19:58,500
annars om du någonsin undrat var som Retry uttalande kommer från, det kommer från höger här.

330
00:19:58,500 --> 00:20:04,390
Så om däremot skriver jag 123foo - bara några slumpmässig sekvens av text -

331
00:20:04,390 --> 00:20:08,490
sscanf kommer att se, antal, nummer, f,

332
00:20:08,490 --> 00:20:16,410
och det kommer att sätta 123 i N, det kommer att sätta fi c och sedan återvända 2.

333
00:20:16,410 --> 00:20:20,640
Så vi har bara använda den grundläggande definitionen av sscanf beteende, ett mycket enkelt sätt -

334
00:20:20,640 --> 00:20:23,900
bra, komplex vid första anblicken, men i slutet av dagen ganska enkel mekanism -

335
00:20:23,900 --> 00:20:28,320
att säga finns det en int och i så fall är att det enda som jag hittade?

336
00:20:28,320 --> 00:20:29,860
Och blanksteg här är avsiktligt.

337
00:20:29,860 --> 00:20:34,000
Om du läser dokumentationen för sscanf, säger det dig att om du inkluderar en bit av blanktecken

338
00:20:34,000 --> 00:20:38,810
vid början eller slutet, sscanf också kan användaren, av någon anledning,

339
00:20:38,810 --> 00:20:41,860
att slå 123 mellanslagstangenten och som kommer att vara legitim.

340
00:20:41,860 --> 00:20:44,150
Du kommer inte skrika på användaren bara för att de drabbade mellanslag

341
00:20:44,150 --> 00:20:48,640
vid början eller slutet, vilket är lite mer användarvänligt.

342
00:20:48,640 --> 00:20:52,300
>> Eventuella frågor sedan på getInt? Ja. >> [Elev] Vad händer om du bara sätta i en röding?

343
00:20:52,300 --> 00:20:54,030
Bra fråga.

344
00:20:54,030 --> 00:20:59,890
Vad händer om du bara skrivit in en röding som f och tryck på Enter utan att någonsin skriva 123?

345
00:20:59,890 --> 00:21:02,420
Vad tror du beteendet hos denna kodrad då vara?

346
00:21:02,420 --> 00:21:04,730
[Ohörbart elev svar]

347
00:21:04,730 --> 00:21:08,790
Ja, så sscanf kan täcka det också eftersom i det fallet, det kommer inte att fylla N-eller C.

348
00:21:08,790 --> 00:21:15,310
Det kommer att i stället återvända 0, i vilket fall jag också fånga det scenariot

349
00:21:15,310 --> 00:21:18,750
eftersom det förväntade värdet jag vill ha är 1.

350
00:21:18,750 --> 00:21:22,000
Jag vill bara en och endast en sak som skall fyllas. Bra fråga.

351
00:21:22,000 --> 00:21:24,290
>> Andra? Okej.

352
00:21:24,290 --> 00:21:26,250
>> Låt oss inte gå igenom alla funktioner i här,

353
00:21:26,250 --> 00:21:29,500
men en som verkar vara kanske av kvarvarande intresse GetString

354
00:21:29,500 --> 00:21:32,790
eftersom det visar sig att getFloat, getInt, GetDouble, GetLongLong

355
00:21:32,790 --> 00:21:36,260
alla punt mycket av sin funktionalitet till GetString.

356
00:21:36,260 --> 00:21:39,750
Så låt oss ta en titt på hur han implementeras här.

357
00:21:39,750 --> 00:21:43,630
Den här ser lite komplicerat, men det använder samma grundläggande

358
00:21:43,630 --> 00:21:45,670
att vi började prata om förra veckan.

359
00:21:45,670 --> 00:21:49,490
I GetString tar som inget argument enligt tomrummet här uppe

360
00:21:49,490 --> 00:21:53,730
och den returnerar en sträng, jag tydligen är att förklara en sträng som heter buffert.

361
00:21:53,730 --> 00:21:56,270
Jag vet inte riktigt vad det kommer att användas för än, men vi får se.

362
00:21:56,270 --> 00:21:58,390
Det ser ut som kapaciteten är som standard 0.

363
00:21:58,390 --> 00:22:01,350
Inte helt säker på var detta kommer, inte säker på vad n ska användas för ännu,

364
00:22:01,350 --> 00:22:03,590
men nu det blir lite mer intressant.

365
00:22:03,590 --> 00:22:06,520
I linje 243, deklarerar vi en int, c.

366
00:22:06,520 --> 00:22:08,800
Detta är en slags dum detalj.

367
00:22:08,800 --> 00:22:15,820
En röding är 8 bitar och 8 bitar kan lagra hur många olika värden? >> [Elev] 256. >> 256.

368
00:22:15,820 --> 00:22:20,730
Problemet är om du vill ha 256 olika ASCII-tecken, där det finns

369
00:22:20,730 --> 00:22:23,340
Om du tänker tillbaka - och detta är inte något att memorera.

370
00:22:23,340 --> 00:22:25,710
Men om du tänker tillbaka på den stora ASCII diagram vi hade veckor sedan,

371
00:22:25,710 --> 00:22:30,600
fanns i så fall 128 eller 256 ASCII-tecken.

372
00:22:30,600 --> 00:22:32,940
Vi använde alla mönster 0 och 1 upp.

373
00:22:32,940 --> 00:22:36,210
Det är ett problem om du vill kunna upptäcka ett fel

374
00:22:36,210 --> 00:22:40,190
för om du redan använder 256 värden för dina karaktärer,

375
00:22:40,190 --> 00:22:43,050
du inte riktigt planera i förväg eftersom du nu har ingen möjlighet att säga,

376
00:22:43,050 --> 00:22:46,270
Detta är inte en äkta karaktär, är detta något felaktigt meddelande.

377
00:22:46,270 --> 00:22:50,270
Så vad världen gör är att de använder den näst största värdet, något som en int,

378
00:22:50,270 --> 00:22:54,720
så att du har en galen antal bitar, 32, för 4 miljarder möjliga värden

379
00:22:54,720 --> 00:22:58,860
så att du enkelt kan sluta med i huvudsak 257 av dem,

380
00:22:58,860 --> 00:23:01,720
1 av som har några speciella betydelse som ett fel.

381
00:23:01,720 --> 00:23:03,120
>> Så låt oss se hur det fungerar.

382
00:23:03,120 --> 00:23:07,760
I linje 246, har jag denna stora while-slinga som ringer fgetc,

383
00:23:07,760 --> 00:23:11,090
F Betydelse filen, så getc och sedan stdin.

384
00:23:11,090 --> 00:23:15,520
Det visar sig detta är bara mer exakt sätt att säga läsa indata från tangentbordet.

385
00:23:15,520 --> 00:23:19,300
Standard input betyder tangentbord, betyder standard ut skärmen,

386
00:23:19,300 --> 00:23:23,310
och standardfelet, som vi ser i pset4 innebär skärmen

387
00:23:23,310 --> 00:23:27,490
men en särskild del av skärmen så att den inte är sammanbinds med den faktiska produktionen

388
00:23:27,490 --> 00:23:30,750
att du ville skriva ut. Men mer om det i framtiden.

389
00:23:30,750 --> 00:23:34,440
Så fgetc betyder bara läsa ett tecken från tangentbordet och förvaras där?

390
00:23:34,440 --> 00:23:37,350
Förvara den i c.

391
00:23:37,350 --> 00:23:41,360
Och sedan kontrollera - så jag bara med några booleska konjunktioner här -

392
00:23:41,360 --> 00:23:46,000
kontrollera att det inte är lika - \ n, så att användaren har drabbat Enter vill vi stanna vid denna punkt,

393
00:23:46,000 --> 00:23:49,850
slutet av slingan - och vi vill också se till det särskilda konstant EOF,

394
00:23:49,850 --> 00:23:53,610
som om du vet eller gissa, vad står på? >> [Elev] Slut på fil. >> Slutet av filen.

395
00:23:53,610 --> 00:23:56,560
Detta är typ av nonsens, för om jag skriver på tangentbordet,

396
00:23:56,560 --> 00:23:58,870
det finns egentligen ingen fil inblandade i detta,

397
00:23:58,870 --> 00:24:01,150
men detta är sortera bara av den generiska termen för att beteckna

398
00:24:01,150 --> 00:24:04,220
att inget annat kommer från mänskliga fingrar.

399
00:24:04,220 --> 00:24:06,460
EOF - slutet av filen.

400
00:24:06,460 --> 00:24:09,920
Som en sidoreplik, om du någonsin drabbats Kontroll D i tangentbordet, inte att du skulle ha ännu -

401
00:24:09,920 --> 00:24:15,230
du nått Kontroll C - Kontroll D sänder denna speciella konstant kallas EOF.

402
00:24:15,230 --> 00:24:19,850
Så nu har vi bara några dynamisk minnesallokering.

403
00:24:19,850 --> 00:24:23,440
>> Så om (n + 1> kapacitet). Nu ska jag förklara n.

404
00:24:23,440 --> 00:24:26,100
N är bara hur många byte är för närvarande i bufferten,

405
00:24:26,100 --> 00:24:28,620
den sträng som du för närvarande bygger upp från användaren.

406
00:24:28,620 --> 00:24:33,450
Om du har fler tecken i din buffert än du har kapacitet i bufferten,

407
00:24:33,450 --> 00:24:37,410
intuitivt vad vi behöver göra då är fördela mer kapacitet.

408
00:24:37,410 --> 00:24:43,330
Så jag kommer att skumma över en del av den aritmetiska här och bara fokusera på denna funktion här.

409
00:24:43,330 --> 00:24:46,070
Du vet vad malloc är eller åtminstone generellt bekant.

410
00:24:46,070 --> 00:24:48,970
Ta en gissning vad realloc gör. >> [Elev] Lägger minne.

411
00:24:48,970 --> 00:24:52,920
Det är inte riktigt lägga till minne. Det omfördelar minne enligt följande.

412
00:24:52,920 --> 00:24:57,220
Om det fortfarande finns rum i slutet av strängen för att ge dig mer av det minne

413
00:24:57,220 --> 00:25:00,000
än det ursprungligen ger dig, så kommer du få det extra minnet.

414
00:25:00,000 --> 00:25:03,460
Så du kan bara hålla sätta strängen karaktärer rygg mot rygg mot rygg mot rygg.

415
00:25:03,460 --> 00:25:05,830
Men om det inte är fallet eftersom du väntat för länge

416
00:25:05,830 --> 00:25:07,940
och något slumpmässigt fick plopped i minnet där

417
00:25:07,940 --> 00:25:10,290
men det finns extra minne här nere, det är okej.

418
00:25:10,290 --> 00:25:13,100
Realloc kommer att göra alla tunga lyft för dig,

419
00:25:13,100 --> 00:25:16,750
flytta strängen du har läst i så långt härifrån, lägg ner där,

420
00:25:16,750 --> 00:25:19,460
och sedan ge dig lite mer landningsbana på den punkten.

421
00:25:19,460 --> 00:25:22,550
>> Så med en handrörelse, låt mig säga att det GetString gör

422
00:25:22,550 --> 00:25:26,330
är det börjar med en liten buffert, kanske en enstaka tecken,

423
00:25:26,330 --> 00:25:30,820
och om användaren skriver in två tecken, slutar GetString upp ringa realloc och säger

424
00:25:30,820 --> 00:25:33,150
ett tecken räckte inte, ge mig två tecken.

425
00:25:33,150 --> 00:25:35,950
Sen om du läser igenom logiken i slingan, det kommer att säga

426
00:25:35,950 --> 00:25:39,600
användaren har skrivit in 3 tecken, ge mig nu inte 2, men 4 tecken,

427
00:25:39,600 --> 00:25:42,320
sedan ge mig 8, så ge mig 16 och 32.

428
00:25:42,320 --> 00:25:45,000
Det faktum att jag fördubbling av kapaciteten varje gång

429
00:25:45,000 --> 00:25:48,570
innebär att bufferten inte kommer att växa långsamt, det kommer att växa supersnabb.

430
00:25:48,570 --> 00:25:51,380
Och vad kan vara fördelen med det?

431
00:25:51,380 --> 00:25:54,600
Varför jag fördubbla storleken på bufferten

432
00:25:54,600 --> 00:25:58,020
även om användaren kanske bara behöver en extra karaktär från tangentbordet?

433
00:25:58,020 --> 00:26:01,750
[Ohörbart elev svar] >> Vad är det? >> [Elev] Du behöver inte odla den så ofta.

434
00:26:01,750 --> 00:26:03,300
Exakt. Du behöver inte att odla den så ofta.

435
00:26:03,300 --> 00:26:05,510
Och detta är bara typ av du säkra dina insatser här,

436
00:26:05,510 --> 00:26:10,850
Tanken är att du inte vill ringa realloc mycket eftersom det tenderar att vara långsam.

437
00:26:10,850 --> 00:26:12,910
Varje gång du frågar operativsystemet för minne,

438
00:26:12,910 --> 00:26:16,990
som ni kommer snart att se i en framtida problembild, tenderar det att ta lite tid.

439
00:26:16,990 --> 00:26:20,010
Så minimera denna tid, även om du slösar bort en del utrymme,

440
00:26:20,010 --> 00:26:21,900
tenderar att vara en bra sak.

441
00:26:21,900 --> 00:26:24,060
>> Men om vi läser igenom den sista delen av getString här -

442
00:26:24,060 --> 00:26:27,950
och återigen förstå varenda rad här är inte så viktigt i dag -

443
00:26:27,950 --> 00:26:30,530
märker att det till slut ringer malloc igen

444
00:26:30,530 --> 00:26:33,880
och det fördelar precis som många byte som den behöver för strängen

445
00:26:33,880 --> 00:26:38,060
och sedan kastar bort genom att ringa gratis till alltför stor buffert

446
00:26:38,060 --> 00:26:40,080
om det verkligen blev dubbelt så många gånger.

447
00:26:40,080 --> 00:26:42,730
Så kort sagt, det är hur GetString har arbetat hela tiden.

448
00:26:42,730 --> 00:26:47,060
Allt det gör är läser ett tecken i tiden igen och igen och igen,

449
00:26:47,060 --> 00:26:50,750
och varje gång den behöver lite extra minne, frågar den operativsystemet för det

450
00:26:50,750 --> 00:26:53,670
genom att ringa realloc.

451
00:26:53,670 --> 00:26:57,890
>> Några frågor? Okej.

452
00:26:57,890 --> 00:26:59,270
>> En attack.

453
00:26:59,270 --> 00:27:04,060
Nu när vi förstår pekare eller åtminstone blir alltmer förtrogna med pekare,

454
00:27:04,060 --> 00:27:06,700
låt oss överväga hur hela världen börjar kollapsa

455
00:27:06,700 --> 00:27:10,030
om du inte riktigt försvara sig mot kontradiktoriska användare,

456
00:27:10,030 --> 00:27:11,850
människor som försöker hacka sig in i systemet,

457
00:27:11,850 --> 00:27:16,890
människor som försöker stjäla din programvara genom att kringgå vissa registreringskod

458
00:27:16,890 --> 00:27:19,090
att de annars måste skriva i.

459
00:27:19,090 --> 00:27:22,990
>> Ta en titt på detta exempel här, vilket är just C-kod som har en funktion huvud i botten

460
00:27:22,990 --> 00:27:26,380
som anropar en funktion foo. Och vad är det som går till foo?

461
00:27:26,380 --> 00:27:29,680
[Eleven] En enda argument. >> [Malan] En enda argument.

462
00:27:29,680 --> 00:27:33,450
Så argv [1], vilket innebär det första ordet som användaren skrivit på kommandoraden

463
00:27:33,450 --> 00:27:36,360
efter a.out eller vad programmet heter.

464
00:27:36,360 --> 00:27:41,680
Så foo överst tar in en char *. Men char * är precis vad? >> [Elev] En sträng.

465
00:27:41,680 --> 00:27:43,350
[Malan] En sträng, så det finns inget nytt här.

466
00:27:43,350 --> 00:27:45,420
Denna sträng är godtyckligt kallas bar.

467
00:27:45,420 --> 00:27:51,430
I denna linje här, röding C [12], i form av semi-teknisk engelska, vad denna linje gör?

468
00:27:51,430 --> 00:27:55,220
[Elev] En array med - >> Array av? >> [Elev] Tecken. >> Tecken.

469
00:27:55,220 --> 00:27:58,870
Ge mig en rad 12 tecken. Så vi kan kalla detta en buffert.

470
00:27:58,870 --> 00:28:02,920
Det tekniskt kallas C, men en buffert i programmering betyder bara en massa utrymme

471
00:28:02,920 --> 00:28:04,800
att du kan lägga några saker i.

472
00:28:04,800 --> 00:28:07,940
Sedan slutligen, memcpy vi inte har använt förut, men du kan nog gissa vad den gör.

473
00:28:07,940 --> 00:28:10,480
Den kopierar minne. Vad gör det?

474
00:28:10,480 --> 00:28:19,270
Den kopierar tydligen bar, dess ingång, till C men endast upp till längden på baren.

475
00:28:19,270 --> 00:28:24,930
Men det finns en bugg här. >> [Eleven] Du behöver sizeof karaktär. >> Okej.

476
00:28:24,930 --> 00:28:30,860
Tekniskt sett ska vi verkligen strlen (bar) * sizeof (char)). Det är korrekt.

477
00:28:30,860 --> 00:28:33,930
Men i värsta fall här, låt oss anta att that -

478
00:28:33,930 --> 00:28:35,950
Okej. Sedan finns två buggar.

479
00:28:35,950 --> 00:28:39,160
Så sizeof (char));

480
00:28:39,160 --> 00:28:41,290
Låt oss göra detta till en lite bredare.

481
00:28:41,290 --> 00:28:44,910
Så nu finns det fortfarande en bugg, vilket är vad? >> [Ohörbart elev svar]

482
00:28:44,910 --> 00:28:46,990
Kontrollera om vad? >> [Elev] Kontrollera NULL.

483
00:28:46,990 --> 00:28:50,270
Vi bör i allmänhet kontroll av NULL eftersom dåliga saker hända

484
00:28:50,270 --> 00:28:53,200
när pekaren är NULL eftersom du kan hamna kommer det,

485
00:28:53,200 --> 00:28:57,630
och du bör inte någonsin kommer att NULL genom dereferencing den med stjärnan operatören.

486
00:28:57,630 --> 00:29:01,050
Så det är bra. Och vad gör vi? Logiskt sett finns det en brist här.

487
00:29:01,050 --> 00:29:04,450
[Elev] Kontrollera om argc är> = till 2.

488
00:29:04,450 --> 00:29:10,550
Så kolla om argc är> = 2. Okej, så det finns tre buggar i programmet här.

489
00:29:10,550 --> 00:29:16,630
Vi bevakar nu kontrollera om användaren faktiskt skrivit i något i argv [1]. Bra.

490
00:29:16,630 --> 00:29:20,950
Så vad är den tredje bugg? Ja. >> [Elev] C kanske inte tillräckligt stor.

491
00:29:20,950 --> 00:29:23,320
Bra. Vi kollade en scenario.

492
00:29:23,320 --> 00:29:29,520
Vi kollade implicit inte kopierar mer minne än vad som skulle överskrida längden på baren.

493
00:29:29,520 --> 00:29:32,510
Så om strängen användaren skrivit in är 10 tecken långt,

494
00:29:32,510 --> 00:29:36,020
Detta säger bara kopiera 10 tecken. Och det är okej.

495
00:29:36,020 --> 00:29:39,940
Men vad händer om användaren skrivit in ett ord vid prompten som en 20-tecken ord?

496
00:29:39,940 --> 00:29:44,900
Detta säger exemplar 20 tecken från bar till vad?

497
00:29:44,900 --> 00:29:49,750
C, annars känd som vår buffert, vilket innebär att du bara skrev uppgifter

498
00:29:49,750 --> 00:29:52,540
till 8 byte platser som du inte äger,

499
00:29:52,540 --> 00:29:54,870
och du inte äger dem i den meningen att du aldrig tilldelats dem.

500
00:29:54,870 --> 00:30:00,370
Så detta är vad som allmänt är känt som buffertspill attack eller buffertöverskridning attack.

501
00:30:00,370 --> 00:30:05,580
Och det är en attack i den meningen att om användaren eller programmet som ringer din funktion

502
00:30:05,580 --> 00:30:10,490
gör detta uppsåtligt, vad som egentligen händer nästa kan faktiskt vara ganska dålig.

503
00:30:10,490 --> 00:30:12,450
>> Så låt oss ta en titt på den här bilden här.

504
00:30:12,450 --> 00:30:16,060
Denna bild representerar din stack minne.

505
00:30:16,060 --> 00:30:19,580
Minns att varje gång du ringer en funktion får du denna lilla ram på stacken

506
00:30:19,580 --> 00:30:21,520
och sedan en annan och sedan en annan och en annan.

507
00:30:21,520 --> 00:30:24,300
Och hittills vi har bara typ av abstraherade dessa som rektanglar

508
00:30:24,300 --> 00:30:26,290
antingen på kortet eller på skärmen här.

509
00:30:26,290 --> 00:30:30,580
Men om vi zooma in på en av dessa rektanglar, när du ringer en funktion foo,

510
00:30:30,580 --> 00:30:35,880
det visar sig att det finns mer på stacken insidan av denna ram i den rektangel

511
00:30:35,880 --> 00:30:40,060
än x och y och a och b, som vi gjorde tala om swap.

512
00:30:40,060 --> 00:30:44,410
Det visar sig att det finns en del på lägre nivå detaljer, bland dem returadress.

513
00:30:44,410 --> 00:30:49,550
Så det visar sig när huvud samtal foo, har stora informera foo

514
00:30:49,550 --> 00:30:53,520
vad främsta adress är i datorns minne

515
00:30:53,520 --> 00:30:57,770
annars är så fort foo gjort exekvera, som i detta fall här,

516
00:30:57,770 --> 00:31:00,830
när du har nått denna slutna klammerparentes i slutet av foo,

517
00:31:00,830 --> 00:31:05,310
Hur i helsike vet foo där kontroll av programmet är tänkt att gå?

518
00:31:05,310 --> 00:31:08,970
Det visar sig att svaret på den frågan är i detta röd rektangel här.

519
00:31:08,970 --> 00:31:12,670
Detta motsvarar en pekare, och det är upp till datorn för att lagra temporärt

520
00:31:12,670 --> 00:31:17,030
den så kallade stacken adressen till huvud så att så fort foo görs köra,

521
00:31:17,030 --> 00:31:21,120
datorn vet var och vad linje i huvud att gå tillbaka till.

522
00:31:21,120 --> 00:31:23,940
Sparade rampekaren avser liknande till detta.

523
00:31:23,940 --> 00:31:26,310
Char * bar här representerar vad?

524
00:31:26,310 --> 00:31:31,350
Nu blå segment är här foo s ram. Vad är bar?

525
00:31:31,570 --> 00:31:35,010
Bar är bara argumentet till foo-funktionen.

526
00:31:35,010 --> 00:31:37,500
Så nu är vi tillbaka på typ av det välbekanta bilden.

527
00:31:37,500 --> 00:31:39,850
Det finns mer saker och fler distraktioner på skärmen,

528
00:31:39,850 --> 00:31:43,380
men denna ljusblå segment är precis vad vi har att rita på tavlan

529
00:31:43,380 --> 00:31:45,790
för något som swap. Det är ramen för foo.

530
00:31:45,790 --> 00:31:51,490
Och det enda i det just nu är bar, som är den här parametern.

531
00:31:51,490 --> 00:31:55,220
Men vad ska vara i stapeln enligt denna kod här?

532
00:31:55,220 --> 00:31:57,760
[Eleven] röding C [12]. >> [Malan] röding C [12].

533
00:31:57,760 --> 00:32:02,810
Vi bör också se 12 rutor minne som tilldelats en variabel som heter C,

534
00:32:02,810 --> 00:32:04,970
och faktiskt vi har det på skärmen.

535
00:32:04,970 --> 00:32:08,480
Högst upp finns c [0] och författare till detta diagram

536
00:32:08,480 --> 00:32:11,850
brydde sig inte dra alla rutorna, men det finns faktiskt 12 finns

537
00:32:11,850 --> 00:32:16,590
för om man tittar på det nedre högra, C [11] om man räknar från 0 är den 12: e sådan byte.

538
00:32:16,590 --> 00:32:18,400
Men här är problemet.

539
00:32:18,400 --> 00:32:22,390
I vilken riktning c växer?

540
00:32:22,390 --> 00:32:27,080
Sortera på uppifrån och ner om det börjar i toppen och växer till botten.

541
00:32:27,080 --> 00:32:30,110
Det ser inte ut som vi lämnade oss mycket banan här alls.

542
00:32:30,110 --> 00:32:32,090
Vi har typ av målat in oss i ett hörn,

543
00:32:32,090 --> 00:32:36,940
och att c [11] är rätt upp mot bar, som är rätt upp mot Sparad Ram pekare,

544
00:32:36,940 --> 00:32:39,960
vilket är rätt upp mot returadress. Det finns ingen mer plats.

545
00:32:39,960 --> 00:32:42,810
Så vad är innebörden så om du skruvar upp

546
00:32:42,810 --> 00:32:46,500
och du försöker läsa 20 byte i en 12-byte buffert?

547
00:32:46,500 --> 00:32:50,060
Vart är de 8 extra byte kommer att gå? >> [Elev] Inside -

548
00:32:50,060 --> 00:32:53,200
Inuti allt annat, är några av dessa super viktigt.

549
00:32:53,200 --> 00:32:57,260
Och det viktigaste, eventuellt är den röda rutan där returadress,

550
00:32:57,260 --> 00:33:03,560
eftersom antar att du antingen av misstag eller adversarially skriva dessa 4 byte,

551
00:33:03,560 --> 00:33:07,260
att pekaren adress, inte bara med skräp, men med ett antal

552
00:33:07,260 --> 00:33:09,810
det händer att representera en verklig adress i minnet.

553
00:33:09,810 --> 00:33:13,880
Vad är innebörden, logiskt? >> [Eleven] Funktion kommer att återgå till en annan plats.

554
00:33:13,880 --> 00:33:15,250
Exakt.

555
00:33:15,250 --> 00:33:19,170
När foo avkastning och träffar som klammerparentes är programmet kommer att fortsätta

556
00:33:19,170 --> 00:33:25,060
inte återvända till huvud, det kommer att återvända till vad adress är i det röda rutan.

557
00:33:25,060 --> 00:33:28,600
>> I fallet kringgå programvara registrering,

558
00:33:28,600 --> 00:33:32,260
vad händer om den adress som är återförs till är den funktion som normalt anropas

559
00:33:32,260 --> 00:33:35,690
efter att du har betalat för programvaran och matas din registreringskod?

560
00:33:35,690 --> 00:33:39,870
Du kan sortera om lura datorn till inte kommer hit utan att gå upp här.

561
00:33:39,870 --> 00:33:45,100
Eller om du är riktigt smart kan en motståndare skriva faktiskt på tangentbordet, till exempel,

562
00:33:45,100 --> 00:33:50,690
inte en verklig ord, inte 20 tecken, men antar han eller hon faktiskt typer i

563
00:33:50,690 --> 00:33:52,770
vissa tecken som representerar kod.

564
00:33:52,770 --> 00:33:55,320
Och det kommer inte att bli C-kod, det kommer faktiskt bli tecknen

565
00:33:55,320 --> 00:33:59,290
som representerar binära maskinkod, 0 och 1.

566
00:33:59,290 --> 00:34:01,290
Men antar att de är smarta nog att göra det,

567
00:34:01,290 --> 00:34:06,500
att på något sätt klistra in den GetString snabb något som är i huvudsak kompilerad kod,

568
00:34:06,500 --> 00:34:09,980
och de sista 4 byte skriva att returadress.

569
00:34:09,980 --> 00:34:13,360
Och vad adress betyder det ingång gör?

570
00:34:13,360 --> 00:34:18,630
Den lagrar faktiskt i denna röd rektangel adressen för den första byten i bufferten.

571
00:34:18,630 --> 00:34:23,070
Så du måste vara riktigt smart, och detta är en hel del trial and error för dåliga människor där ute,

572
00:34:23,070 --> 00:34:25,639
men om du kan lista ut hur stor denna buffert är

573
00:34:25,639 --> 00:34:28,820
så att de sista byte i ingången du ger till programmet

574
00:34:28,820 --> 00:34:33,540
råkar motsvara adressen början av din buffert, kan du göra det här.

575
00:34:33,540 --> 00:34:39,320
Om vi ​​säger normalt hej och \ 0, det är vad hamnar i bufferten.

576
00:34:39,320 --> 00:34:44,420
Men om vi är mer smart och vi fyller denna buffert med vad vi ska generiskt kallar attackkod -

577
00:34:44,420 --> 00:34:48,860
AAA, attack, attack, attack - om det är bara något som gör något dåligt,

578
00:34:48,860 --> 00:34:51,820
vad händer om du är riktigt smart, kan du göra det här.

579
00:34:51,820 --> 00:34:58,610
I den röda rutan här är en sekvens av siffror - 80, C0, 35, 08.

580
00:34:58,610 --> 00:35:01,610
Observera att som matchar numret som är här uppe.

581
00:35:01,610 --> 00:35:04,430
Det är i omvänd ordning, men mer om det en annan gång.

582
00:35:04,430 --> 00:35:08,140
Observera att detta returadress medvetet har ändrats

583
00:35:08,140 --> 00:35:12,020
till lika adressen här uppe, inte adressen till huvud.

584
00:35:12,020 --> 00:35:17,500
Så om den onde är super smart, han eller hon kommer att ingå i den attacken kod

585
00:35:17,500 --> 00:35:20,930
något som tar bort alla användarens filer eller kopiera lösenorden

586
00:35:20,930 --> 00:35:24,680
eller skapa ett användarkonto som jag sedan kan logga in på - något alls.

587
00:35:24,680 --> 00:35:26,950
>> Och detta är både faran och kraften i C.

588
00:35:26,950 --> 00:35:29,840
Eftersom du har tillgång till minnet via pekare

589
00:35:29,840 --> 00:35:32,520
och du kan därför skriva vad du vill i en dators minne,

590
00:35:32,520 --> 00:35:35,080
kan du göra en dator göra vad du vill

591
00:35:35,080 --> 00:35:39,550
helt enkelt genom att ha den hoppar runt i sitt eget minne.

592
00:35:39,550 --> 00:35:44,650
Och så i dag så många program och så många webbplatser som äventyras

593
00:35:44,650 --> 00:35:46,200
koka ner till människor som tar nytta av detta.

594
00:35:46,200 --> 00:35:50,760
Och detta kan tyckas vara en super sofistikerad attack, men det är inte alltid startar på det sättet.

595
00:35:50,760 --> 00:35:53,560
Verkligheten är att det dåliga människor vanligen gör är,

596
00:35:53,560 --> 00:35:58,200
oavsett om det är ett program på en kommandorad eller ett grafiskt program eller en hemsida,

597
00:35:58,200 --> 00:35:59,940
du börjar bara erbjuda nonsens.

598
00:35:59,940 --> 00:36:03,980
Du skriver i en riktigt stor ord i sökfältet och tryck Enter,

599
00:36:03,980 --> 00:36:05,780
och du vänta och se om webbplatsen kraschar

600
00:36:05,780 --> 00:36:09,990
eller om du vänta och se om programmet visar något felmeddelande

601
00:36:09,990 --> 00:36:14,330
för om du har tur som den onde och du ge några galna ingång

602
00:36:14,330 --> 00:36:18,980
som kraschar programmet, som innebär att programmeraren inte förutse dina dåliga beteende,

603
00:36:18,980 --> 00:36:23,630
vilket innebär att du kan förmodligen tillräckligt med ansträngning, tillräckligt försök och misstag,

604
00:36:23,630 --> 00:36:26,650
räkna ut hur att föra en mer exakt attack.

605
00:36:26,650 --> 00:36:31,410
Så lika mycket en del av säkerheten är inte bara undvika dessa attacker helt

606
00:36:31,410 --> 00:36:34,100
men upptäcka dem och faktiskt titta på loggar

607
00:36:34,100 --> 00:36:36,780
och se vad galna ingångar har människor skrivit i din hemsida,

608
00:36:36,780 --> 00:36:38,960
vilka ord har människor skrivit på din hemsida

609
00:36:38,960 --> 00:36:42,870
i hopp om att överfyllda lite buffert.

610
00:36:42,870 --> 00:36:45,500
Och allt detta handlar om att de enkla grunderna i vad en matris

611
00:36:45,500 --> 00:36:49,080
och vad innebär det att fördela och använda minnet.

612
00:36:49,080 --> 00:36:51,710
>> Relaterat till detta då också är det.

613
00:36:51,710 --> 00:36:54,280
Låt oss bara blick inuti en hårddisk ännu en gång.

614
00:36:54,280 --> 00:36:58,440
Du minns från en vecka eller två sedan att när man drar filer till din papperskorgen eller papperskorgen,

615
00:36:58,440 --> 00:37:03,710
vad händer? >> [Elev] Inget. >> Absolut ingenting, eller hur?

616
00:37:03,710 --> 00:37:05,740
Så småningom om du kör låg på diskutrymme,

617
00:37:05,740 --> 00:37:08,190
Windows eller Mac OS kommer att börja ta bort filer för dig.

618
00:37:08,190 --> 00:37:10,390
Men om du drar något där, det är inte alls säkert.

619
00:37:10,390 --> 00:37:13,800
Alla dina rumskompis eller vän eller familjemedlem har att göra är att dubbelklicka och voila,

620
00:37:13,800 --> 00:37:16,310
Det finns alla de skissartade filer som du försökte ta bort.

621
00:37:16,310 --> 00:37:19,590
De flesta av oss åtminstone veta att du måste högerklicka eller kontrollera klicka

622
00:37:19,590 --> 00:37:22,310
och töm papperskorgen eller något liknande.

623
00:37:22,310 --> 00:37:25,000
Men även då det inte gör riktigt susen

624
00:37:25,000 --> 00:37:28,010
eftersom vad som händer när du har en fil på din hårddisk

625
00:37:28,010 --> 00:37:32,770
som står för cirka Word-dokument eller något JPEG och detta representerar din hårddisk,

626
00:37:32,770 --> 00:37:35,350
och låt oss säga detta flisa här representerar filen,

627
00:37:35,350 --> 00:37:38,390
och det består av en hel massa av 0 och 1.

628
00:37:38,390 --> 00:37:42,470
Vad händer när du inte bara dra filen till papperskorgen kan eller papperskorgen

629
00:37:42,470 --> 00:37:48,020
men också tömma den? Sortera ingenting.

630
00:37:48,020 --> 00:37:49,640
Det är inte absolut ingenting nu.

631
00:37:49,640 --> 00:37:54,290
Nu är det bara ingenting eftersom en liten sak som händer i form av den här tabellen.

632
00:37:54,290 --> 00:37:58,370
Så det finns någon form av databas eller tabell inuti en dators minne

633
00:37:58,370 --> 00:38:03,850
som har i huvudsak en kolumn för filer namn och en kolumn för filer "läge,

634
00:38:03,850 --> 00:38:07,720
där detta kan vara platsen 123, bara ett slumptal.

635
00:38:07,720 --> 00:38:14,560
Så vi kanske har något som x.jpeg och plats 123.

636
00:38:14,560 --> 00:38:18,800
Vad händer då när du faktiskt tömma papperskorgen?

637
00:38:18,800 --> 00:38:20,330
Det går undan.

638
00:38:20,330 --> 00:38:23,610
Men vad inte går bort är det 0 och 1.

639
00:38:23,610 --> 00:38:26,270
>> Så vad är då anslutningen till pset4?

640
00:38:26,270 --> 00:38:31,240
Tja, med pset4, bara för att vi har oavsiktligt raderas compact flash-kortet

641
00:38:31,240 --> 00:38:35,750
som hade alla dessa bilder eller bara för att det genom otur blev skadad

642
00:38:35,750 --> 00:38:38,000
betyder inte att den 0 och 1 är inte kvar.

643
00:38:38,000 --> 00:38:40,410
Kanske några av dem går förlorade eftersom något blev skadad

644
00:38:40,410 --> 00:38:43,320
i den meningen att vissa 0s blev 1s och 1s blev 0s.

645
00:38:43,320 --> 00:38:47,240
Dåliga saker kan hända på grund av buggiga program eller defekt hårdvara.

646
00:38:47,240 --> 00:38:50,370
Men många av dessa bitar, kanske 100% av dem, finns fortfarande kvar.

647
00:38:50,370 --> 00:38:55,050
Det är bara att datorn eller kameran inte vet var JPEG1 startade

648
00:38:55,050 --> 00:38:56,910
och där JPEG2 startade.

649
00:38:56,910 --> 00:39:01,070
Men om du, programmeraren, vet med lite vett om dessa JPEG-bilder är

650
00:39:01,070 --> 00:39:06,010
eller hur de ser ut så att du kan analysera 0 och 1 och säga JPEG, JPEG,

651
00:39:06,010 --> 00:39:09,440
Du kan skriva ett program med i huvudsak bara en för eller while-slinga

652
00:39:09,440 --> 00:39:12,820
som återvinner var och en av dessa filer.

653
00:39:12,820 --> 00:39:16,030
Så lektionen är då att börja säkert radera dina filer

654
00:39:16,030 --> 00:39:18,340
Om du vill undvika detta helt och hållet. Ja.

655
00:39:18,340 --> 00:39:21,010
>> [Elev] Hur kommer det står på din dator

656
00:39:21,010 --> 00:39:23,550
att du har mer minne än du gjorde innan?

657
00:39:23,550 --> 00:39:27,820
Har mer minne än vad du gjorde innan - >> [elev] Mer tillgängligt minne.

658
00:39:27,820 --> 00:39:29,630
Åh. Bra fråga.

659
00:39:29,630 --> 00:39:32,360
Så varför då efter tömning av papperskorgen berättar din dator du

660
00:39:32,360 --> 00:39:34,910
att du har mer ledigt utrymme än du gjorde innan?

661
00:39:34,910 --> 00:39:36,770
I ett nötskal, eftersom det ljuger.

662
00:39:36,770 --> 00:39:40,740
Mer tekniskt, har du mer utrymme eftersom du nu har sagt

663
00:39:40,740 --> 00:39:43,680
kan du lägga andra saker där den filen en gång var.

664
00:39:43,680 --> 00:39:45,450
Men det betyder inte att bitarna går bort,

665
00:39:45,450 --> 00:39:48,590
och det betyder inte att de bitarna ändras till enbart 0, till exempel,

666
00:39:48,590 --> 00:39:50,150
för att skydda dig.

667
00:39:50,150 --> 00:39:54,640
Så däremot om du säkert radera filer eller fysiskt förstöra enheten,

668
00:39:54,640 --> 00:39:57,300
det är egentligen det enda sättet ibland runt det.

669
00:39:57,300 --> 00:40:02,020
>> Så varför inte vi lämnar på den semi-skrämmande anmärkning, och vi kommer att se dig på måndag.

670
00:40:02,020 --> 00:40:07,000
[Applåder]

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