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

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

3
00:00:04,860 --> 00:00:07,260
[Dette er CS50. - CS50.TV]

4
00:00:07,260 --> 00:00:09,740
>> Det er CS50, Uge 5.

5
00:00:09,740 --> 00:00:12,900
I dag og i denne uge introducerer vi en lille smule af verden retsvidenskab

6
00:00:12,900 --> 00:00:14,850
i forbindelse med Problem Set 4.

7
00:00:14,850 --> 00:00:18,480
I dag vil være en forkortet foredrag, fordi der er en særlig begivenhed i her bagefter.

8
00:00:18,480 --> 00:00:21,940
Så vil vi tage et kig og drille både elever og forældre i dag

9
00:00:21,940 --> 00:00:24,600
med nogle af de ting, der er i horisonten.

10
00:00:24,600 --> 00:00:29,050
>> Blandt dem, som mandag vil du have nogle flere klassekammerater.

11
00:00:29,050 --> 00:00:32,980
EDX, Harvard og MIT nye online initiativ for OpenCourseWare og mere,

12
00:00:32,980 --> 00:00:36,730
lancerer på Harvards campus på mandag, hvilket betyder kommet mandag

13
00:00:36,730 --> 00:00:40,930
vil du have, som fra sidste optælling, 86.000 ekstra klassekammerater

14
00:00:40,930 --> 00:00:43,680
der vil følge sammen med CS50 forelæsninger og sektioner

15
00:00:43,680 --> 00:00:45,890
og walkthroughs og problemstillinger sæt.

16
00:00:45,890 --> 00:00:51,870
Og som en del af dette, vil du blive medlemmer af det konstituerende klasse af CS50 og nu CS50x.

17
00:00:51,870 --> 00:00:56,150
Som en del af dette nu, indse, at der vil være nogle upsides så godt.

18
00:00:56,150 --> 00:01:00,620
For at blive klar til dette, for det massive antal af studerende,

19
00:01:00,620 --> 00:01:03,820
er det tilstrækkeligt at sige, at selvom vi har 108 TF'er og CA,

20
00:01:03,820 --> 00:01:07,560
det er ikke helt den bedste elev-lærer ratio, når vi rammer 80.000 af de studerende.

21
00:01:07,560 --> 00:01:09,830
Vi vil ikke være sortering så mange problem sætter manuelt,

22
00:01:09,830 --> 00:01:13,050
så introduceret i denne uge i det problem sæt vil være CS50 Check,

23
00:01:13,050 --> 00:01:15,410
der vil være en kommando-linje værktøj i apparatet

24
00:01:15,410 --> 00:01:17,880
at du får, når du opdatere det senere i denne weekend.

25
00:01:17,880 --> 00:01:21,030
Du vil være i stand til at køre en kommando, check50, på din egen Pset,

26
00:01:21,030 --> 00:01:24,770
og du får øjeblikkelig feedback om, hvorvidt dit program er rigtig eller forkert

27
00:01:24,770 --> 00:01:27,980
ifølge forskellige design specifikationer, som vi har leveret.

28
00:01:27,980 --> 00:01:30,310
Mere om det i det problem indstillede specifikation.

29
00:01:30,310 --> 00:01:34,220
De CS50x klassekammerater vil bruge det så godt.

30
00:01:34,220 --> 00:01:36,170
>> Problem sæt 4 handler om retsvidenskab,

31
00:01:36,170 --> 00:01:38,630
og denne Pset var virkelig inspireret af nogle virkelige liv stuff

32
00:01:38,630 --> 00:01:41,210
hvorved da jeg var i forskerskolen jeg interneret i et stykke tid

33
00:01:41,210 --> 00:01:45,270
med Middlesex Amts District Attorney kontor laver retsmedicinsk arbejde

34
00:01:45,270 --> 00:01:47,660
med deres bly retsmedicinske efterforsker.

35
00:01:47,660 --> 00:01:50,280
Hvad dette beløb sig til, da jeg tror, ​​jeg nævnte et par uger tidligere,

36
00:01:50,280 --> 00:01:52,720
er massen State Police eller andre ville komme i,

37
00:01:52,720 --> 00:01:56,150
de ville slippe væk fra ting som harddiske og cd'er og disketter og lignende,

38
00:01:56,150 --> 00:01:58,770
og derefter målet for retsvidenskab kontor var at fastslå

39
00:01:58,770 --> 00:02:01,470
om der var eller ikke var tegn på en slags.

40
00:02:01,470 --> 00:02:04,730
Det var den særlige Undersøgelser Unit, så det var white collar kriminalitet.

41
00:02:04,730 --> 00:02:10,949
Det var mere bekymrende slags kriminalitet, noget der involverer en form for digitale medier.

42
00:02:10,949 --> 00:02:16,450
Det viser sig, at ikke så mange mennesker skriver en e-mail at sige, "jeg gjorde det."

43
00:02:16,450 --> 00:02:20,490
Så ofte har disse retsmedicinske søgninger ikke slå op så meget frugt,

44
00:02:20,490 --> 00:02:22,820
men nogle gange folk ville skrive sådanne e-mails.

45
00:02:22,820 --> 00:02:25,240
Så nogle gange, blev indsatsen belønnet.

46
00:02:25,240 --> 00:02:31,210
>> Men at lede op til dette retsmedicinsk Pset, vil vi introducere i pset4 en smule af grafik.

47
00:02:31,210 --> 00:02:35,410
Du har sandsynligvis tage disse ting for givet - JPEG, GIF og lignende - i disse dage.

48
00:02:35,410 --> 00:02:38,320
Men hvis du virkelig tænker over det, et billede, ligesom Rob ansigt,

49
00:02:38,320 --> 00:02:41,270
kunne modelleres som en sekvens af punkter eller pixels.

50
00:02:41,270 --> 00:02:43,380
I tilfælde af Rob ansigt, er der alle mulige farver,

51
00:02:43,380 --> 00:02:46,760
og vi begyndte at se de enkelte prikker, ellers kendt som pixels,

52
00:02:46,760 --> 00:02:48,610
når vi begyndte at zoome ind

53
00:02:48,610 --> 00:02:54,660
Men hvis vi forenkler verden lidt og bare sige, at dette her er Rob i sort og hvid,

54
00:02:54,660 --> 00:02:57,490
at repræsentere sort og hvid, kan vi bare bruge binær.

55
00:02:57,490 --> 00:03:01,660
Og hvis vi kommer til at bruge binær, 1 eller 0, kan vi udtrykke dette samme billede

56
00:03:01,660 --> 00:03:06,140
af Robs smilende ansigt med dette mønster af bits.

57
00:03:06,140 --> 00:03:12,100
11000011 repræsenterer hvid, hvid, sort, sort, sort, sort, hvid, hvid.

58
00:03:12,100 --> 00:03:16,150
Og så det er ikke et stort spring derefter at begynde at tale om farverige fotografier,

59
00:03:16,150 --> 00:03:18,600
ting, som du ville se på Facebook eller tage med et digitalt kamera.

60
00:03:18,600 --> 00:03:21,410
Men netop når det kommer til farver, du har brug for flere bits.

61
00:03:21,410 --> 00:03:25,690
Og ganske almindeligt i verden af ​​billeder er at bruge ikke 1-bit farver,

62
00:03:25,690 --> 00:03:29,560
som dette antyder, men 24-bit farver, hvor du faktisk få millioner af farver.

63
00:03:29,560 --> 00:03:32,250
Således som det er tilfældet, når vi zoomet ind på Rob øje,

64
00:03:32,250 --> 00:03:36,370
det var helst antal millioner af forskellige farverige muligheder.

65
00:03:36,370 --> 00:03:39,040
Så vi vil indføre dette i Problem sæt 4 samt i walkthrough,

66
00:03:39,040 --> 00:03:43,370
som vil være i dag kl 3:30 i stedet for de sædvanlige 2:30 på grund af fredagens foredrag her.

67
00:03:43,370 --> 00:03:46,620
Men video vil være online som sædvanlig i morgen.

68
00:03:46,620 --> 00:03:48,820
>> Vi vil også introducere dig til et andet filformat.

69
00:03:48,820 --> 00:03:51,270
Dette er bevidst ment til at se skræmmende i starten,

70
00:03:51,270 --> 00:03:55,670
men dette er blot nogle dokumentation for en C struct.

71
00:03:55,670 --> 00:03:58,940
Det viser sig, at Microsoft år siden hjalp popularisere dette format

72
00:03:58,940 --> 00:04:05,150
kaldet bitmap filformat, bmp, og dette var en super enkel, farverig grafisk filformat

73
00:04:05,150 --> 00:04:10,150
der blev brugt i temmelig lang tid og til tider stadig for wallpapers på desktops.

74
00:04:10,150 --> 00:04:14,760
Hvis du tænker tilbage til Windows XP og de bølgende bakker og den blå himmel,

75
00:04:14,760 --> 00:04:17,170
det var typisk et BMP eller bitmapbillede.

76
00:04:17,170 --> 00:04:19,959
Bitmaps er sjovt for os, fordi de har en smule mere kompliceret.

77
00:04:19,959 --> 00:04:22,610
Det er ikke helt så simpelt som dette net af 0'er og 1'ere.

78
00:04:22,610 --> 00:04:27,510
I stedet har du ting som en header i starten af ​​en fil.

79
00:04:27,510 --> 00:04:31,990
Så med andre ord, inde i en. Bmp fil er en hel bunke af 0'er og 1-taller,

80
00:04:31,990 --> 00:04:34,910
men der er nogle ekstra 0'er og 1'ere derinde.

81
00:04:34,910 --> 00:04:38,220
Og det viser sig, at det vi har nok taget for givet i årevis -

82
00:04:38,220 --> 00:04:45,170
filformater som. doc eller. xls eller. mp3,. mp4, uanset hvilke filformater

83
00:04:45,170 --> 00:04:48,480
at du er fortrolig med - hvad betyder det overhovedet sige at være et filformat,

84
00:04:48,480 --> 00:04:52,480
fordi det i sidste ende alle disse filer bruger vi har bare 0'er og 1'ere.

85
00:04:52,480 --> 00:04:56,810
Og måske de 0'er og 1-taller repræsenterer ABC gennem ASCII eller lignende,

86
00:04:56,810 --> 00:04:58,820
men i slutningen af ​​dagen, er det stadig bare 0'er og 1'ere.

87
00:04:58,820 --> 00:05:02,100
Så mennesker bare lejlighedsvis beslutte at opfinde et nyt filformat

88
00:05:02,100 --> 00:05:06,420
hvor de standardisere hvilke mønstre af bits rent faktisk vil betyde.

89
00:05:06,420 --> 00:05:09,220
Og i dette tilfælde her, de folk, der har designet bitmap filformat

90
00:05:09,220 --> 00:05:15,620
sagde, at i det første byte i en bitmap-fil, som angivet ved offset 0 dér,

91
00:05:15,620 --> 00:05:18,940
Der vil være nogle kryptisk navngivne variabel kaldet bfType,

92
00:05:18,940 --> 00:05:23,080
der bare står for bitmap filtype, hvilken type bitmapfil er dette.

93
00:05:23,080 --> 00:05:27,700
Du kan udlede måske fra den anden række, at offset 2, byte nummer 2,

94
00:05:27,700 --> 00:05:33,740
har et mønster af 0'er og 1-taller, der repræsenterer hvad? Størrelsen af ​​noget.

95
00:05:33,740 --> 00:05:35,310
Og det går videre derfra.

96
00:05:35,310 --> 00:05:37,410
Så i Problem sæt 4, vil du blive ført gennem nogle af disse ting.

97
00:05:37,410 --> 00:05:39,520
Vi vil ikke ende op bekymre sig om dem alle.

98
00:05:39,520 --> 00:05:47,510
Men bemærk det begynder at blive interessant omkring byte 54: rgbtBlue, grøn og rød.

99
00:05:47,510 --> 00:05:52,110
Hvis du nogensinde har hørt akronymet RGB - rød, grøn, blå - det er en henvisning til, at

100
00:05:52,110 --> 00:05:54,610
fordi det viser sig, du kan male alle regnbuens farver

101
00:05:54,610 --> 00:05:58,180
med en kombination af rød og blå og grøn.

102
00:05:58,180 --> 00:06:03,320
Og i virkeligheden, kan forældre i værelset minde om nogle af de tidligste projektorer.

103
00:06:03,320 --> 00:06:05,890
Disse dage, du bare se en lys der kommer ud af en linse,

104
00:06:05,890 --> 00:06:09,800
men tilbage i dag du havde den røde linse, den blå linse, og den grønne linse,

105
00:06:09,800 --> 00:06:13,380
og sammen med henblik på en skærm og dannede et farverigt billede.

106
00:06:13,380 --> 00:06:16,270
Og ganske ofte, vil mellemledere skoler og gymnasier har disse linser

107
00:06:16,270 --> 00:06:19,720
nogensinde så lidt skævt, så du var slags at se dobbelt eller tredobbelt billeder.

108
00:06:19,720 --> 00:06:24,100
Men det var idéen. Du havde rødt og grønt og blåt lys maler et billede.

109
00:06:24,100 --> 00:06:26,590
Og det samme princip bruges i computere.

110
00:06:26,590 --> 00:06:30,230
>> Så blandt de udfordringer derefter for dig i Problem sæt 4 kommer til at være et par ting.

111
00:06:30,230 --> 00:06:34,800
Den ene er rent faktisk at ændre størrelsen på et billede, for at tage i et mønster af 0'er og 1-taller,

112
00:06:34,800 --> 00:06:40,200
finde ud af hvilken bidder af 0'er og 1-taller repræsenterer hvad i en struktur som denne,

113
00:06:40,200 --> 00:06:43,630
og derefter finde ud af at kopiere de pixels - de røde, blues, De Grønne -

114
00:06:43,630 --> 00:06:46,660
inde, så at når et billede ser sådan ud i første omgang,

115
00:06:46,660 --> 00:06:49,210
det kunne se sådan ud i stedet efter det.

116
00:06:49,210 --> 00:06:53,640
Blandt de andre udfordringer også vil være at du vil blive udleveret en retsmedicinsk billede

117
00:06:53,640 --> 00:06:56,030
en aktuel fil fra et digitalt kamera.

118
00:06:56,030 --> 00:06:58,960
Og på det kamera, engang var en hel bunke af fotos.

119
00:06:58,960 --> 00:07:03,760
Problemet er, at vi ved et uheld slettet eller havde det billede ødelagt eller anden måde.

120
00:07:03,760 --> 00:07:05,750
Dårlige ting sker med digitale kameraer.

121
00:07:05,750 --> 00:07:09,150
Og så vi hurtigt kopieret alle de 0'er og 1-taller ud af kortet for dig,

122
00:07:09,150 --> 00:07:13,610
reddede dem alle i én stor fil, og så vil vi udlevere dem til dig i Problem Set 4

123
00:07:13,610 --> 00:07:19,320
så du kan skrive et program i C med til at inddrive alle disse JPEG, ideelt.

124
00:07:19,320 --> 00:07:23,330
Og det viser sig, at JPEG, selvom de er lidt af en kompleks filformat -

125
00:07:23,330 --> 00:07:26,360
de er meget mere kompleks end denne smilende ansigt her -

126
00:07:26,360 --> 00:07:31,160
Det viser sig, at hver JPEG starter med det samme mønstre af 0'er og 1'ere.

127
00:07:31,160 --> 00:07:35,630
Så bruger i sidste ende en while-løkke eller en for-løkke eller lignende,

128
00:07:35,630 --> 00:07:38,880
du kan gentage over alle de 0'er og 1-taller i denne retsmedicinsk billede,

129
00:07:38,880 --> 00:07:43,150
og hver gang du ser det specielle mønster, der er defineret i det problem indstillede specifikation,

130
00:07:43,150 --> 00:07:47,880
du kan påtage her er, med meget stor sandsynlighed, starten på en JPEG.

131
00:07:47,880 --> 00:07:51,230
Og så snart du finder det samme mønster nogle antallet af bytes

132
00:07:51,230 --> 00:07:55,430
eller kilobyte eller megabyte senere, kan du antage her er en anden JPEG,

133
00:07:55,430 --> 00:07:57,380
fotoet jeg tog efter det første.

134
00:07:57,380 --> 00:08:01,370
Lad mig stoppe læse, at første fil, begynder at skrive denne nye,

135
00:08:01,370 --> 00:08:06,310
og outputtet af dit program for pset4 vil være så mange som 50 JPEG.

136
00:08:06,310 --> 00:08:09,270
Og hvis det ikke er 50 JPEG-billeder, du har lidt af en løkke.

137
00:08:09,270 --> 00:08:12,490
Hvis du har et uendeligt antal JPEG, har du en uendelig løkke.

138
00:08:12,490 --> 00:08:14,910
Så det vil også være en ganske almindelig sag.

139
00:08:14,910 --> 00:08:16,600
Så det er hvad der er i horisonten.

140
00:08:16,600 --> 00:08:21,310
>> Quiz 0 bag os, indser per min e-mail, der uvægerligt er der folk, der er både glade,

141
00:08:21,310 --> 00:08:23,640
slags neutral, og trist omkring quiz 0 tid.

142
00:08:23,640 --> 00:08:26,800
Og er du nå ud til mig, hovedet TF Zamyla, din egen TF,

143
00:08:26,800 --> 00:08:31,180
eller et af de nøglecentre, som du ved, hvis du gerne vil diskutere, hvordan det gik.

144
00:08:31,180 --> 00:08:35,539
>> Så for at imponere forældrene her i rummet, hvad er det CS50 biblioteket?

145
00:08:36,429 --> 00:08:40,390
[Latter] Godt arbejde.

146
00:08:40,390 --> 00:08:48,340
Hvad er det CS50 biblioteket? Yeah. >> [Studerende] Det er en præ-skrevet sæt kode [uhørlig]

147
00:08:48,340 --> 00:08:49,750
Okay, godt.

148
00:08:49,750 --> 00:08:53,240
Det er en præ-skrevet sæt kode, som vi personalet skrev, vi leverer til dig,

149
00:08:53,240 --> 00:08:55,030
der giver nogle fælles funktionalitet,

150
00:08:55,030 --> 00:08:59,020
Ting som får mig en streng, få mig en int - alle de funktioner, der er angivet her.

151
00:08:59,020 --> 00:09:02,260
>> Start nu, begynder vi virkelig at tage disse støttehjul off.

152
00:09:02,260 --> 00:09:05,050
Vi vil begynde at tage væk en streng fra dig,

153
00:09:05,050 --> 00:09:08,870
som tilbagekaldelse var blot et synonym for, hvad egentlige datatype? >> [Flere studerende] Char *.

154
00:09:08,870 --> 00:09:12,730
Char *. For forældre, var der formentlig [gør susen lyd]. Det er godt.

155
00:09:12,730 --> 00:09:17,550
Char * vi vil begynde at se på skærmen, desto mere som vi fjerner strengen fra vores ordforråd,

156
00:09:17,550 --> 00:09:19,730
i hvert fald når det kommer til faktisk at skrive kode.

157
00:09:19,730 --> 00:09:22,840
Ligeledes vil vi stoppe med at bruge nogle af disse funktioner så meget

158
00:09:22,840 --> 00:09:25,280
fordi vores programmer kommer til at blive mere sofistikerede.

159
00:09:25,280 --> 00:09:28,480
Snarere end blot at skrive programmer, der sidder der med en prompt blinker,

160
00:09:28,480 --> 00:09:31,870
venter for brugeren at skrive noget ind, vil du få dine input fra andre steder.

161
00:09:31,870 --> 00:09:35,490
For eksempel, vil du få dem fra en række af bits på den lokale harddisk.

162
00:09:35,490 --> 00:09:38,580
Du vil i stedet få dem i fremtiden fra en netværksforbindelse,

163
00:09:38,580 --> 00:09:40,230
nogle hjemmeside eller andet sted.

164
00:09:40,230 --> 00:09:44,110
>> Så lad os skrælle dette lag for første gang og trække op CS50 Appliance

165
00:09:44,110 --> 00:09:49,010
og denne fil kaldet cs50.h, som du har været # herunder for uger,

166
00:09:49,010 --> 00:09:51,140
men lad os nu se, hvad der er inde i dette.

167
00:09:51,140 --> 00:09:54,430
Den øverste del af filen i blå er bare en hel masse kommentarer:

168
00:09:54,430 --> 00:09:57,050
oplysninger om garanti og licensering.

169
00:09:57,050 --> 00:09:59,050
Det er en slags fælles paradigme i software

170
00:09:59,050 --> 00:10:01,580
fordi en masse software i disse dage er, hvad der kaldes open source,

171
00:10:01,580 --> 00:10:05,220
hvilket betyder, at nogen har skrevet koden og gjorde det frit tilgængelige

172
00:10:05,220 --> 00:10:10,470
ikke bare at køre og at bruge, men rent faktisk at læse og ændre og integrere i dit eget arbejde.

173
00:10:10,470 --> 00:10:14,660
Så det er, hvad du har brugt, open source software, omend i en meget lille form.

174
00:10:14,660 --> 00:10:18,560
Hvis jeg rulle ned forbi de bemærkninger, dog vil vi begynde at se nogle mere velkendte ting.

175
00:10:18,560 --> 00:10:25,010
Meddelelse øverst her, at cs50.h-fil indeholder en hel masse header-filer.

176
00:10:25,010 --> 00:10:28,560
De fleste af disse har vi ikke set før, men man kender.

177
00:10:28,560 --> 00:10:32,270
Hvilke af disse har vi set, om end kortvarigt, indtil videre? >> [Studerende] 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 begyndte at tale om dynamisk allokering af hukommelse,

180
00:10:38,320 --> 00:10:41,650
som vi vil komme tilbage til i næste uge så godt, vi begyndte herunder at fil.

181
00:10:41,650 --> 00:10:46,640
Det viser sig, at bool og sandt og falsk faktisk ikke findes i C per se

182
00:10:46,640 --> 00:10:49,440
medmindre du medtage denne fil her.

183
00:10:49,440 --> 00:10:52,710
Vi har for uger blevet inklusive stdbool.h

184
00:10:52,710 --> 00:10:55,620
så du kan bruge begrebet en bool, sand eller falsk.

185
00:10:55,620 --> 00:10:58,620
Uden dette, ville du nødt til at sortere i fake det og bruge en int

186
00:10:58,620 --> 00:11:02,610
og bare vilkårligt antage, at 0 er falsk og 1 er sandt.

187
00:11:02,610 --> 00:11:07,150
Hvis vi rulle ned yderligere, her er vores definition af en streng.

188
00:11:07,150 --> 00:11:11,390
Det viser sig, som vi har sagt før, at når denne stjerne er ikke rigtig noget.

189
00:11:11,390 --> 00:11:13,720
Du kan endda have plads hele vejen rundt.

190
00:11:13,720 --> 00:11:16,740
Vi dette semester har været fremme det som dette at gøre det klart,

191
00:11:16,740 --> 00:11:18,620
at stjernen har at gøre med den type,

192
00:11:18,620 --> 00:11:21,700
men indse lige så almindeligt, hvis ikke lidt mere almindeligt,

193
00:11:21,700 --> 00:11:24,430
er at sætte det der, men funktionelt er det samme.

194
00:11:24,430 --> 00:11:27,720
Men nu, hvis vi læser yderligere ned, lad os tage et kig på GetInt

195
00:11:27,720 --> 00:11:32,190
fordi vi brugte den måske først, før noget andet i dette semester.

196
00:11:32,190 --> 00:11:37,440
Her er GetInt. Dette er, hvad? >> [Studerende] En prototype. >> Dette er blot en prototype.

197
00:11:37,440 --> 00:11:41,410
Ofte har vi lagt prototyper på toppen af ​​vores. C-filer,

198
00:11:41,410 --> 00:11:46,690
men du kan også sætte prototyper i header-filer,. H filer, som denne her

199
00:11:46,690 --> 00:11:50,840
så når du skriver nogle funktioner, som du ønsker andre mennesker til at kunne bruge,

200
00:11:50,840 --> 00:11:53,550
hvilket netop er tilfældet med CS50 bibliotek,

201
00:11:53,550 --> 00:11:57,040
du ikke kun implementere dine funktioner i noget lignende cs50.c,

202
00:11:57,040 --> 00:12:02,790
man også sætte prototyperne ikke øverst i denne fil, men øverst på en header-fil.

203
00:12:02,790 --> 00:12:07,170
Så at header filen er hvad venner og kolleger omfatter

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

205
00:12:09,760 --> 00:12:12,210
Så al den tid, du har, herunder alle disse prototyper,

206
00:12:12,210 --> 00:12:16,580
effektivt på toppen af ​​din fil, men ved hjælp af denne # include mekanisme,

207
00:12:16,580 --> 00:12:20,070
som i det væsentlige kopier og pastaer denne fil ind i din egen.

208
00:12:20,070 --> 00:12:23,070
Her er nogle temmelig detaljeret dokumentation.

209
00:12:23,070 --> 00:12:25,640
Vi har stort set taget for givet, at GetInt får en int,

210
00:12:25,640 --> 00:12:27,640
men det viser sig der er nogle hjørne tilfælde.

211
00:12:27,640 --> 00:12:31,810
Hvad hvis brugeren skriver i et nummer, der er alt for stor, en quintillion,

212
00:12:31,810 --> 00:12:35,490
der bare ikke kan passe inde i en int? Hvad er den forventede adfærd?

213
00:12:35,490 --> 00:12:38,020
Ideelt set er det forudsigeligt.

214
00:12:38,020 --> 00:12:40,280
Så i dette tilfælde, hvis du rent faktisk læser det med småt,

215
00:12:40,280 --> 00:12:44,500
du faktisk se, at hvis den linje ikke kan læses, dette afkast INT_MAX.

216
00:12:44,500 --> 00:12:48,320
Vi har aldrig talt om dette, men baseret på dens kapitalisering, hvad er det sandsynligvis?

217
00:12:48,320 --> 00:12:50,640
[Studerende] En konstant. >> Det er en konstant.

218
00:12:50,640 --> 00:12:54,770
Det er nogle særlige konstant det er nok erklæret i en af ​​disse header-filer

219
00:12:54,770 --> 00:13:00,090
der er højere op i filen, og INT_MAX er nok noget i retning af 2 milliarder groft,

220
00:13:00,090 --> 00:13:04,990
Ideen er, at fordi vi er nødt til en eller anden måde betyde, at noget gik galt,

221
00:13:04,990 --> 00:13:10,700
vi, ja, have 4 milliarder numre til vores rådighed: -2 mia op til 2 mia give eller tage.

222
00:13:10,700 --> 00:13:14,710
Nå, hvad er almindelig i programmering er du stjæler bare en af ​​disse tal,

223
00:13:14,710 --> 00:13:18,920
måske 0, måske 2 mia måske -2.000 millioner,

224
00:13:18,920 --> 00:13:23,280
så du bruger en af ​​dine mulige værdier, så du kan forpligte sig til verden

225
00:13:23,280 --> 00:13:26,820
at hvis noget går galt, vil jeg vende tilbage denne super store værdi.

226
00:13:26,820 --> 00:13:31,030
Men du ikke ønsker, at brugeren skrive noget kryptisk ligesom 234 ..., en virkelig store tal.

227
00:13:31,030 --> 00:13:34,060
Du generalisere det i stedet som en konstant.

228
00:13:34,060 --> 00:13:38,060
Så virkelig, hvis du var anal de sidste par uger, hver gang du kaldte GetInt,

229
00:13:38,060 --> 00:13:42,900
du skulle have været til kontrol med en hvis betingelse gjorde brugeren type i INT_MAX,

230
00:13:42,900 --> 00:13:46,590
eller mere specifikt, gjorde GetInt tilbage INT_MAX, for hvis det gjorde,

231
00:13:46,590 --> 00:13:51,830
der rent faktisk betyder, at de ikke skrive det. Noget gik galt i denne sag.

232
00:13:51,830 --> 00:13:56,080
Så dette er hvad der normalt betegnes som en sentinel værdi, hvilket betyder bare speciel.

233
00:13:56,080 --> 00:13:58,120
>> Lad os nu vende ind. C. filen.

234
00:13:58,120 --> 00:14:01,340
Den C-fil har eksisteret i apparatet i nogen tid.

235
00:14:01,340 --> 00:14:06,840
Og i virkeligheden har apparatet det pre-kompileret for dig ind i den ting vi kaldte objekt kode,

236
00:14:06,840 --> 00:14:09,540
men det bare ikke noget for dig, hvor det er fordi systemet kender

237
00:14:09,540 --> 00:14:11,730
i dette tilfælde, hvor det er: apparatet.

238
00:14:11,730 --> 00:14:17,400
Lad os rulle ned nu for at GetInt og se, hvordan GetInt har arbejdet hele tiden.

239
00:14:17,400 --> 00:14:19,460
Her har vi lignende kommentarer fra før.

240
00:14:19,460 --> 00:14:21,660
Lad mig zoome ind på bare koden portion.

241
00:14:21,660 --> 00:14:23,900
Og hvad vi har for GetInt er følgende.

242
00:14:23,900 --> 00:14:25,700
Det tager ingen input.

243
00:14:25,700 --> 00:14:29,510
Den returnerer en int, mens (sand), så vi har en bevidst uendelig løkke,

244
00:14:29,510 --> 00:14:33,180
men formentlig vil vi bryde ud af dette på en eller vende tilbage fra inden for dette.

245
00:14:33,180 --> 00:14:34,870
>> Lad os se hvordan det virker.

246
00:14:34,870 --> 00:14:39,240
Vi synes at benytte GetString i denne første linje inde i løkken, 166.

247
00:14:39,240 --> 00:14:43,780
Dette er nu god praksis, fordi under hvilke omstændigheder kunne GetString returnere

248
00:14:43,780 --> 00:14:47,660
den særlige søgeord NULL? >> [Studerende] Hvis noget går galt.

249
00:14:47,660 --> 00:14:51,630
Hvis noget går galt. Og hvad der kunne gå galt, når du kalder noget GetString?

250
00:14:54,960 --> 00:14:57,640
Yeah. >> [Studerende] malloc undlader at give den de int'er.

251
00:14:57,640 --> 00:14:59,150
Yeah. Måske malloc mislykkes.

252
00:14:59,150 --> 00:15:03,190
Et eller andet sted under hætten, er GetString kalder malloc, der allokerer hukommelse,

253
00:15:03,190 --> 00:15:06,020
hvilket lader computeren butikken alle de tegn

254
00:15:06,020 --> 00:15:07,750
at brugeren skriver ind i tastaturet.

255
00:15:07,750 --> 00:15:11,590
Og formoder, at brugeren havde en hel masse fritid og skrevet mere, for eksempel,

256
00:15:11,590 --> 00:15:16,160
end 2 milliarder tegn i, flere tegn end computeren har endda RAM.

257
00:15:16,160 --> 00:15:19,250
GetString skal være i stand til at betyde, at for dig.

258
00:15:19,250 --> 00:15:22,560
Selv om dette er en super, super ualmindeligt hjørne sag,

259
00:15:22,560 --> 00:15:24,340
Det skal en eller anden måde kunne håndtere dette,

260
00:15:24,340 --> 00:15:28,750
og så GetString, hvis vi gik tilbage og læse den tilhørende dokumentation, faktisk tilbage NULL.

261
00:15:28,750 --> 00:15:34,460
Så nu hvis GetString fejler ved at returnere NULL er GetInt kommer til at mislykkes ved at returnere INT_MAX

262
00:15:34,460 --> 00:15:37,690
ligesom en skildvagt. Disse er blot menneskelige konventioner.

263
00:15:37,690 --> 00:15:41,450
Den eneste måde du ville vide dette er tilfældet, er ved at læse dokumentationen.

264
00:15:41,450 --> 00:15:45,040
>> Lad os rulle ned til, hvor int faktisk fået.

265
00:15:45,040 --> 00:15:51,160
Hvis jeg rulle ned lidt længere, på linje 170, har vi en kommentar over disse linjer.

266
00:15:51,160 --> 00:15:55,100
Vi erklærer i 172 en int, n, og en char, c, og så er denne nye funktion,

267
00:15:55,100 --> 00:15:58,930
som nogle af jer har snublet over før, sscanf.

268
00:15:58,930 --> 00:16:00,870
Det står for streng scanf.

269
00:16:00,870 --> 00:16:05,700
Med andre ord, giv mig en streng, og jeg vil scanne det for stykker af information af interesse.

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

271
00:16:07,360 --> 00:16:11,800
Antag at jeg skriver i, bogstaveligt talt, 123 på tastaturet og derefter trykke Enter.

272
00:16:11,800 --> 00:16:16,470
Hvad er datatypen på 123, når de returneres ved GetString? >> [Studerende] String.

273
00:16:16,470 --> 00:16:18,380
Det er naturligvis en streng, ikke? Jeg fik en streng.

274
00:16:18,380 --> 00:16:23,220
Så 123 er virkelig, citat-citat slut, 123 med \ 0 ved udgangen af ​​det.

275
00:16:23,220 --> 00:16:27,110
Det er ikke en int. Det er ikke et tal. Det ligner et nummer, men det er faktisk ikke.

276
00:16:27,110 --> 00:16:29,080
Så hvad gør GetInt nødt til at gøre?

277
00:16:29,080 --> 00:16:35,750
Det har at scanne denne streng venstre til højre - 123 \ 0 - og på en måde konvertere til en egentlig heltal.

278
00:16:35,750 --> 00:16:37,850
Du kan finde ud af at gøre dette.

279
00:16:37,850 --> 00:16:41,450
Hvis du tænker tilbage til pset2, du formentlig fik en lille komfortable med Cæsar

280
00:16:41,450 --> 00:16:44,820
eller Vigenere, så du kan gentage over en streng, kan du konvertere tegn til int'er.

281
00:16:44,820 --> 00:16:46,710
Men heck, det er en hel masse arbejde.

282
00:16:46,710 --> 00:16:49,860
Hvorfor ikke kalde en funktion som sscanf der gør det for dig?

283
00:16:49,860 --> 00:16:54,230
Så sscanf forventer et argument - i dette tilfælde kaldet linje, der er en streng.

284
00:16:54,230 --> 00:17:01,840
Du derefter angive citater, meget lig printf, hvad du forventer at se i denne streng.

285
00:17:01,840 --> 00:17:09,000
Og hvad jeg siger her er jeg forventer at se et decimaltal og måske et tegn.

286
00:17:09,000 --> 00:17:12,000
Og vi vil se, hvorfor dette er tilfældet i bare et øjeblik.

287
00:17:12,000 --> 00:17:15,869
Og det viser sig, at denne notation er nu minder om ting, vi begyndte at snakke om

288
00:17:15,869 --> 00:17:17,619
lidt over en uge siden.

289
00:17:17,619 --> 00:17:21,740
Hvad er & n og & c gør for os her? >> [Elev] Adresse på n og adresse på ca.

290
00:17:21,740 --> 00:17:25,400
Yeah. Det giver mig adressen på n og adresse på ca. Hvorfor er det vigtigt?

291
00:17:25,400 --> 00:17:30,220
Du ved, at med funktioner i C, kan du altid returnere en værdi eller ingen værdi overhovedet.

292
00:17:30,220 --> 00:17:34,530
Du kan returnere en int, en streng, en float, en char, uanset hvad, eller du kan returnere ugyldige,

293
00:17:34,530 --> 00:17:38,030
men du kan kun returnere én ting maksimalt.

294
00:17:38,030 --> 00:17:42,760
Men her ønsker vi sscanf at returnere mig måske en int, et decimaltal,

295
00:17:42,760 --> 00:17:46,220
og også en char, og jeg vil forklare hvorfor den char i et øjeblik.

296
00:17:46,220 --> 00:17:51,460
Du faktisk ønsker sscanf at returnere to ting, men det er bare ikke muligt i C.

297
00:17:51,460 --> 00:17:55,200
Du kan omgå det ved at passere i to adresser

298
00:17:55,200 --> 00:17:57,370
fordi så snart du afleverer en funktion to adresser,

299
00:17:57,370 --> 00:18:00,470
hvad kan denne funktion gøre med dem? >> [Studerende] Skriv til disse adresser.

300
00:18:00,470 --> 00:18:02,010
Det kan skrive til disse adresser.

301
00:18:02,010 --> 00:18:05,770
Du kan bruge stjerne operation og gå der, til hver af disse adresser.

302
00:18:05,770 --> 00:18:11,260
Det er en slags denne bagdøren mekanisme, men meget almindeligt for at ændre værdierne af variabler

303
00:18:11,260 --> 00:18:14,870
mere end blot ét sted - i dette tilfælde to.

304
00:18:14,870 --> 00:18:21,340
Bemærk nu Jeg tjekker for == 1 og derefter returnere n hvis det betyder i virkeligheden evaluere til true.

305
00:18:21,340 --> 00:18:26,170
Så hvad sker der? Teknisk set alt, hvad vi virkelig ønsker at ske i GetInt er dette.

306
00:18:26,170 --> 00:18:30,740
Vi ønsker at parse, så at sige, vi ønsker at læse strengen - quote-citat slut 123 -

307
00:18:30,740 --> 00:18:34,560
og hvis det ser ud som om der er et tal der, hvad vi fortæller sscanf at gøre

308
00:18:34,560 --> 00:18:38,190
sættes, at antallet - 123 - i denne variabel n for mig.

309
00:18:38,190 --> 00:18:42,090
Så hvorfor så havde jeg faktisk har det så godt?

310
00:18:42,090 --> 00:18:48,220
Hvilken rolle sscanf siger du måske også få et tegn her?

311
00:18:48,220 --> 00:18:53,470
[Uhørlig student svar] >> et komma faktisk kunne arbejde.

312
00:18:53,470 --> 00:18:56,330
Lad os holde det tænkte sig om et øjeblik. Hvad ellers?

313
00:18:56,330 --> 00:18:59,270
[Studerende] Det kunne være NULL. >> God tanke. Det kunne være den null-tegn.

314
00:18:59,270 --> 00:19:01,660
Det er faktisk ikke i dette tilfælde. Yeah. >> [Studerende] ASCII.

315
00:19:01,660 --> 00:19:04,340
ASCII. Eller lad mig generalisere yderligere.

316
00:19:04,340 --> 00:19:06,640
Den% c der er bare for fejlkontrol.

317
00:19:06,640 --> 00:19:09,300
Vi ønsker ikke, at der er et tegn efter tallet,

318
00:19:09,300 --> 00:19:11,870
men hvad dette giver mig mulighed for at gøre, er følgende.

319
00:19:11,870 --> 00:19:18,210
Det viser sig, at sscanf foruden lagring af værdier i n og c i dette eksempel her,

320
00:19:18,210 --> 00:19:24,890
hvad den også gør, er det returnerer antallet af variabler det sætte værdier i.

321
00:19:24,890 --> 00:19:30,260
Så hvis du kun skrive i 123, er det kun% d kommer til at matche,

322
00:19:30,260 --> 00:19:33,880
og kun n bliver gemt med en værdi som 123,

323
00:19:33,880 --> 00:19:35,640
og intet bliver sat i ca.

324
00:19:35,640 --> 00:19:37,620
C er stadig en garbage værdi, så at sige -

325
00:19:37,620 --> 00:19:40,730
skrald fordi det er aldrig blevet initialiseret til en vis værdi.

326
00:19:40,730 --> 00:19:45,520
Så i dette tilfælde returnerer sscanf 1, fordi jeg befolkede 1 i disse pejlemærker,

327
00:19:45,520 --> 00:19:50,190
i hvilket tilfælde store, har jeg en int, så jeg frigøre den linje for at frigøre hukommelse

328
00:19:50,190 --> 00:19:54,000
at GetString faktisk allokeret, og så vender jeg tilbage n,

329
00:19:54,000 --> 00:19:58,500
ellers hvis du nogensinde spekuleret over, hvor der Retry erklæring kommer fra, det kommer fra lige her.

330
00:19:58,500 --> 00:20:04,390
Så hvis derimod skriver jeg i 123foo - bare nogle tilfældige sekvens af tekst -

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

332
00:20:08,490 --> 00:20:16,410
og det kommer til at sætte 123 i n; det kommer til at sætte f i c og derefter vende tilbage 2.

333
00:20:16,410 --> 00:20:20,640
Så vi har, bare ved hjælp af grundlæggende definition af sscanf adfærd, en meget enkel måde -

334
00:20:20,640 --> 00:20:23,900
godt, kompleks ved første øjekast, men ved slutningen af ​​dagen forholdsvis enkel mekanisme -

335
00:20:23,900 --> 00:20:28,320
at sige er der en int og hvis ja, er at det eneste, jeg fandt?

336
00:20:28,320 --> 00:20:29,860
Og mellemrum her er bevidst.

337
00:20:29,860 --> 00:20:34,000
Hvis du læser dokumentationen til sscanf, det fortæller dig, at hvis du inkluderer et stykke af blanke tegn

338
00:20:34,000 --> 00:20:38,810
ved begyndelsen eller slutningen også sscanf kan brugeren, uanset årsagen,

339
00:20:38,810 --> 00:20:41,860
at ramme space bar 123, og det vil være legitimt.

340
00:20:41,860 --> 00:20:44,150
Du vil ikke råbe på brugeren, bare fordi de ramte mellemrumstasten

341
00:20:44,150 --> 00:20:48,640
i starten eller slutningen, er der bare lidt mere brugervenlig.

342
00:20:48,640 --> 00:20:52,300
>> Eventuelle spørgsmål derefter på GetInt? Yeah. >> [Studerende] Hvad hvis du bare sætte i en char?

343
00:20:52,300 --> 00:20:54,030
Godt spørgsmål.

344
00:20:54,030 --> 00:20:59,890
Hvad hvis du lige har skrevet i en char som f og tryk på Enter uden nogensinde at skrive 123?

345
00:20:59,890 --> 00:21:02,420
Hvad tror du opførslen af ​​denne linje kode vil så være?

346
00:21:02,420 --> 00:21:04,730
[Uhørlig student svar]

347
00:21:04,730 --> 00:21:08,790
Ja, så sscanf kan dække det også fordi der i så fald er det ikke kommer til at fylde N eller C.

348
00:21:08,790 --> 00:21:15,310
Det kommer til stedet returnere 0, i hvilket tilfælde jeg også at fange dette scenario

349
00:21:15,310 --> 00:21:18,750
fordi den forventede værdi jeg ønsker, er 1.

350
00:21:18,750 --> 00:21:22,000
Jeg ønsker kun én og kun én ting, der skal besættes. Godt spørgsmål.

351
00:21:22,000 --> 00:21:24,290
>> Andre? Ok.

352
00:21:24,290 --> 00:21:26,250
>> Lad os ikke gå igennem alle de funktioner i her,

353
00:21:26,250 --> 00:21:29,500
men den ene, der synes at være måske af resterende renter er GetString

354
00:21:29,500 --> 00:21:32,790
fordi det viser sig, at GetFloat, GetInt, GetDouble, GetLongLong

355
00:21:32,790 --> 00:21:36,260
alle punt en masse af deres funktionalitet til GetString.

356
00:21:36,260 --> 00:21:39,750
Så lad os tage et kig på, hvordan han er implementeret her.

357
00:21:39,750 --> 00:21:43,630
Denne ene ser lidt kompliceret, men det bruger de samme fundamentale

358
00:21:43,630 --> 00:21:45,670
at vi begyndte at tale om i sidste uge.

359
00:21:45,670 --> 00:21:49,490
I GetString tager som noget argument som pr tomrum op her

360
00:21:49,490 --> 00:21:53,730
og det returnerer en streng, jeg åbenbart er om en streng kaldet buffer.

361
00:21:53,730 --> 00:21:56,270
Jeg ved ikke rigtig, hvad der kommer til at blive brugt til endnu, men vi vil se.

362
00:21:56,270 --> 00:21:58,390
Det ligner kapacitet er som standard 0.

363
00:21:58,390 --> 00:22:01,350
Ikke helt sikker på hvor dette foregår, ikke sikker på hvad n vil blive brugt til endnu,

364
00:22:01,350 --> 00:22:03,590
men nu er det at blive lidt mere interessant.

365
00:22:03,590 --> 00:22:06,520
I tråd 243, erklære vi en int, ca.

366
00:22:06,520 --> 00:22:08,800
Det er en slags dum detalje.

367
00:22:08,800 --> 00:22:15,820
En char er 8 bit, og 8 bit kan gemme hvor mange forskellige værdier? >> [Studerende] 256. >> 256.

368
00:22:15,820 --> 00:22:20,730
Problemet er, hvis du ønsker at have 256 forskellige ASCII-tegn, som der er

369
00:22:20,730 --> 00:22:23,340
hvis du tænker tilbage - og det er ikke noget at huske.

370
00:22:23,340 --> 00:22:25,710
Men hvis du tænker tilbage på den store ASCII diagram havde vi uger siden,

371
00:22:25,710 --> 00:22:30,600
Der var i dette tilfælde 128 eller 256 ASCII-tegn.

372
00:22:30,600 --> 00:22:32,940
Vi brugte alle de mønstre af 0'er og 1'ere op.

373
00:22:32,940 --> 00:22:36,210
Det er et problem, hvis du ønsker at være i stand til at opdage en fejl

374
00:22:36,210 --> 00:22:40,190
fordi hvis du allerede bruger 256 værdier for dine karakterer,

375
00:22:40,190 --> 00:22:43,050
du ikke rigtig planlægge fordi nu har du ingen måde at sige,

376
00:22:43,050 --> 00:22:46,270
dette er ikke en legit karakter, er dette en fejlagtig meddelelse.

377
00:22:46,270 --> 00:22:50,270
Så hvad verden gør, er de bruger den næststørste værdi, noget i retning af en int,

378
00:22:50,270 --> 00:22:54,720
så du har et vanvittigt antal bit, 32, for 4 milliarder mulige værdier

379
00:22:54,720 --> 00:22:58,860
så du bare kan ende med at bruge det væsentlige 257 af dem,

380
00:22:58,860 --> 00:23:01,720
1, som har en særlig betydning som en fejl.

381
00:23:01,720 --> 00:23:03,120
>> Så lad os se hvordan det virker.

382
00:23:03,120 --> 00:23:07,760
I tråd 246, har jeg denne store while-løkke, der ringer fgetc,

383
00:23:07,760 --> 00:23:11,090
f mening fil, så getc, og derefter stdin.

384
00:23:11,090 --> 00:23:15,520
Det viser sig, det er bare den mere præcis måde at sige læse input fra tastaturet.

385
00:23:15,520 --> 00:23:19,300
Standard input betyder tastatur, standard output betyder skærm,

386
00:23:19,300 --> 00:23:23,310
og standardfejlen, som vi vil se i pset4 betyder skærmen

387
00:23:23,310 --> 00:23:27,490
men en særlig del af skærmen, så det er ikke smelter sammen med den faktiske produktion

388
00:23:27,490 --> 00:23:30,750
at du ville udskrive. Men mere om det i fremtiden.

389
00:23:30,750 --> 00:23:34,440
Så fgetc betyder blot læse et tegn fra tastaturet og gemme det, hvor?

390
00:23:34,440 --> 00:23:37,350
Opbevar det i ca.

391
00:23:37,350 --> 00:23:41,360
Og så tjek - så jeg bare bruge nogle Boolean konjunktioner her -

392
00:23:41,360 --> 00:23:46,000
kontrollere, at det ikke lige - \ n, så brugeren har ramt Enter, vi ønsker at stoppe på det tidspunkt,

393
00:23:46,000 --> 00:23:49,850
slutningen af ​​løkken - og vi ønsker også at kontrollere for den særlige konstant EOF,

394
00:23:49,850 --> 00:23:53,610
som hvis du kender eller gætte, hvad det står for? >> [Elev] Slut på fil. >> End of file.

395
00:23:53,610 --> 00:23:56,560
Det er lidt meningsløst, fordi hvis jeg skriver på tastaturet,

396
00:23:56,560 --> 00:23:58,870
der er virkelig ingen fil involveret i dette,

397
00:23:58,870 --> 00:24:01,150
men dette er blot sortere af artsbetegnelsen bruges til at betyde

398
00:24:01,150 --> 00:24:04,220
at intet andet kommer fra de menneskelige fingre.

399
00:24:04,220 --> 00:24:06,460
EOF - slutningen af ​​filen.

400
00:24:06,460 --> 00:24:09,920
Som en sidebemærkning, hvis du nogensinde har ramt Kontrol D på dit tastatur, ikke at du ville have endnu -

401
00:24:09,920 --> 00:24:15,230
du har ramt Kontrol C - Control D sender denne særlige konstant kaldet EOF.

402
00:24:15,230 --> 00:24:19,850
Så nu har vi bare have nogle dynamisk allokering af hukommelse.

403
00:24:19,850 --> 00:24:23,440
>> Så hvis (n + 1> kapacitet). Nu vil jeg forklare n.

404
00:24:23,440 --> 00:24:26,100
N er bare hvor mange bytes er i øjeblikket i bufferen,

405
00:24:26,100 --> 00:24:28,620
den streng, du i øjeblikket er ved at bygge op fra brugeren.

406
00:24:28,620 --> 00:24:33,450
Hvis du har flere karakterer i din buffer, end du har kapacitet i bufferen,

407
00:24:33,450 --> 00:24:37,410
intuitivt, hvad vi skal gøre derefter allokere mere kapacitet.

408
00:24:37,410 --> 00:24:43,330
Så jeg har tænkt mig at skimme over nogle af de aritmetiske her og kun fokusere på denne funktion her.

409
00:24:43,330 --> 00:24:46,070
Du ved, hvad malloc er eller i det mindste generelt velkendt.

410
00:24:46,070 --> 00:24:48,970
Tag et gæt hvad realloc gør. >> [Studerende] Tilføjer hukommelse.

411
00:24:48,970 --> 00:24:52,920
Det er ikke helt tilføjelse af hukommelse. Det omfordeler hukommelse som følger.

412
00:24:52,920 --> 00:24:57,220
Hvis der stadig er plads i slutningen af ​​strengen for at give dig mere af denne hukommelse

413
00:24:57,220 --> 00:25:00,000
end det oprindeligt giver dig, så vil du få det ekstra hukommelse.

414
00:25:00,000 --> 00:25:03,460
Så du kan bare holde lægge strengens tegn tilbage til back to back to back.

415
00:25:03,460 --> 00:25:05,830
Men hvis det ikke er tilfældet, fordi du ventede for længe

416
00:25:05,830 --> 00:25:07,940
og noget tilfældigt fik plopped i hukommelsen der

417
00:25:07,940 --> 00:25:10,290
men der er ekstra hukommelse hernede, det er okay.

418
00:25:10,290 --> 00:25:13,100
Realloc vil gøre alt det tunge arbejde for dig,

419
00:25:13,100 --> 00:25:16,750
flytte den streng, du har læst i hidtil herfra, sætte den ned der,

420
00:25:16,750 --> 00:25:19,460
og derefter give dig nogle flere landingsbane på dette punkt.

421
00:25:19,460 --> 00:25:22,550
>> Så med en bølge af hånden, lad mig sige, hvad GetString gør

422
00:25:22,550 --> 00:25:26,330
Det er begyndt med en lille puffer, måske en enkelt karakter,

423
00:25:26,330 --> 00:25:30,820
og hvis brugeren skriver i to tegn, ender GetString op at ringe realloc og siger

424
00:25:30,820 --> 00:25:33,150
et tegn var ikke nok, giv mig to tegn.

425
00:25:33,150 --> 00:25:35,950
Så hvis du læser gennem logikken i løkken, det vil sige

426
00:25:35,950 --> 00:25:39,600
brugeren har indtastet i 3 tegn, giv mig nu ikke 2, men 4 tegn,

427
00:25:39,600 --> 00:25:42,320
derefter give mig 8, så giv mig 16 og 32.

428
00:25:42,320 --> 00:25:45,000
Det faktum, at jeg fordobler kapaciteten hver gang

429
00:25:45,000 --> 00:25:48,570
betyder, at bufferen ikke kommer til at vokse langsomt, går det at vokse super hurtigt.

430
00:25:48,570 --> 00:25:51,380
Og hvad kunne være den fordel det?

431
00:25:51,380 --> 00:25:54,600
Hvorfor er jeg en fordobling af størrelsen af ​​bufferen

432
00:25:54,600 --> 00:25:58,020
selvom brugeren måske bare brug for en ekstra tegn fra tastaturet?

433
00:25:58,020 --> 00:26:01,750
[Uhørlig student svar] >> Hvad er det? >> [Studerende] Du behøver ikke at dyrke det så ofte.

434
00:26:01,750 --> 00:26:03,300
Præcis. Du behøver ikke at dyrke det så ofte.

435
00:26:03,300 --> 00:26:05,510
Og det er lige slags du afdækning dine indsatser her,

436
00:26:05,510 --> 00:26:10,850
Ideen er, at du ikke ønsker at kalde realloc et parti, fordi det har en tendens til at være langsom.

437
00:26:10,850 --> 00:26:12,910
Hver gang du beder operativsystemet for hukommelse,

438
00:26:12,910 --> 00:26:16,990
som du snart vil se i et fremtidigt problem sæt, det har en tendens til at tage lidt tid.

439
00:26:16,990 --> 00:26:20,010
Så minimere den mængde af tid, selvom du spilder noget plads,

440
00:26:20,010 --> 00:26:21,900
tendens til at være en god ting.

441
00:26:21,900 --> 00:26:24,060
>> Men hvis vi læser igennem den sidste del af GetString her -

442
00:26:24,060 --> 00:26:27,950
og igen forstå hver enkelt linie her er ikke så vigtigt i dag -

443
00:26:27,950 --> 00:26:30,530
bemærke, at det i sidste ende kalder malloc igen

444
00:26:30,530 --> 00:26:33,880
og det afsætter lige så mange bytes som den har brug for streng

445
00:26:33,880 --> 00:26:38,060
og derefter smider ved at ringe gratis til alt for store buffer

446
00:26:38,060 --> 00:26:40,080
hvis det virkelig blev fordoblet for mange gange.

447
00:26:40,080 --> 00:26:42,730
Så kort sagt, er, at hvordan GetString har arbejdet hele tiden.

448
00:26:42,730 --> 00:26:47,060
Alt det gør læses ét tegn ad gangen igen og igen og igen,

449
00:26:47,060 --> 00:26:50,750
og hver gang den har brug for nogle ekstra hukommelse, spørger operativsystemet for det

450
00:26:50,750 --> 00:26:53,670
ved at kalde realloc.

451
00:26:53,670 --> 00:26:57,890
>> Eventuelle spørgsmål? Ok.

452
00:26:57,890 --> 00:26:59,270
>> Et angreb.

453
00:26:59,270 --> 00:27:04,060
Nu, hvor vi forstår pegepinde eller i det mindste bliver stadig mere fortrolige med pegepinde,

454
00:27:04,060 --> 00:27:06,700
lad os overveje, hvordan hele verden begynder at kollapse

455
00:27:06,700 --> 00:27:10,030
hvis du ikke helt forsvare sig mod kontradiktorisk brugere,

456
00:27:10,030 --> 00:27:11,850
mennesker, der forsøger at hacke ind i dit system,

457
00:27:11,850 --> 00:27:16,890
mennesker, der forsøger at stjæle din software ved at omgå nogle registreringskode

458
00:27:16,890 --> 00:27:19,090
som de ellers måtte have til at skrive i.

459
00:27:19,090 --> 00:27:22,990
>> Tag et kig på dette eksempel her, som er lige C-kode, der har en funktion main nederst

460
00:27:22,990 --> 00:27:26,380
der kalder en funktion foo. Og hvad er det passerer til Foo?

461
00:27:26,380 --> 00:27:29,680
[Studerende] Et enkelt argument. >> [Malan] Et enkelt argument.

462
00:27:29,680 --> 00:27:33,450
Så argv [1], hvilket betyder, det første ord, brugeren har indtastet på kommandolinjen

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

464
00:27:36,360 --> 00:27:41,680
Så Foo øverst tager i en char *. Men char * er bare hvad? >> [Studerende] En streng.

465
00:27:41,680 --> 00:27:43,350
[Malan] En streng, så der er intet nyt her.

466
00:27:43,350 --> 00:27:45,420
Denne streng vilkårligt blive kaldt bar.

467
00:27:45,420 --> 00:27:51,430
I denne linje her, c char [12] i en slags semi-teknisk engelsk, er hvad denne linie gør?

468
00:27:51,430 --> 00:27:55,220
[Studerende] En række af - >> Array af? >> [Studerende] Tegn. >> Tegn.

469
00:27:55,220 --> 00:27:58,870
Giv mig en vifte af 12 tegn. Så vi kan kalde dette en buffer.

470
00:27:58,870 --> 00:28:02,920
Det er teknisk kaldes c, men en buffer i programmeringen betyder bare en flok plads

471
00:28:02,920 --> 00:28:04,800
at du kan sætte nogle ting i.

472
00:28:04,800 --> 00:28:07,940
Så endelig memcpy vi har ikke brugt før, men du kan sikkert gætte hvad det gør.

473
00:28:07,940 --> 00:28:10,480
Den kopierer hukommelse. Hvad gør det?

474
00:28:10,480 --> 00:28:19,270
Det tilsyneladende kopierer bar, dens input, til c men kun op til længden af ​​baren.

475
00:28:19,270 --> 00:28:24,930
Men der er en fejl her. >> [Studerende] Du skal bruge sizeof karakter. >> Okay.

476
00:28:24,930 --> 00:28:30,860
Teknisk set skal vi virkelig gøre strlen (bar) * sizeof (char)). Det er korrekt.

477
00:28:30,860 --> 00:28:33,930
Men i værste fald her, lad os antage, at that's -

478
00:28:33,930 --> 00:28:35,950
Okay. Så er der to fejl.

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

480
00:28:39,160 --> 00:28:41,290
Lad os gøre dette til en lidt bredere.

481
00:28:41,290 --> 00:28:44,910
Så nu er der stadig en fejl, hvilket er hvad? >> [Uhørlig student svar]

482
00:28:44,910 --> 00:28:46,990
Check for hvad? >> [Studerende] Check for NULL.

483
00:28:46,990 --> 00:28:50,270
Vi bør generelt kontrollere for NULL fordi dårlige ting ske

484
00:28:50,270 --> 00:28:53,200
når markøren er NULL fordi du måske ender med at gå der,

485
00:28:53,200 --> 00:28:57,630
og du bør aldrig gå til NULL ved dereferere den med stjernen operatør.

486
00:28:57,630 --> 00:29:01,050
Så det er godt. Og hvad skal vi ellers gøre? Logisk, der er en brist her også.

487
00:29:01,050 --> 00:29:04,450
[Studerende] Tjek om argc er> = til 2.

488
00:29:04,450 --> 00:29:10,550
Så tjek hvis argc er> = 2. Okay, så der er tre fejl i dette program her.

489
00:29:10,550 --> 00:29:16,630
Vi overvåger nu kontrollere, om brugeren rent faktisk har skrevet i noget i argv [1]. Godt.

490
00:29:16,630 --> 00:29:20,950
Så hvad er den tredje bug? Yeah. >> [Studerende] C muligvis ikke stor nok.

491
00:29:20,950 --> 00:29:23,320
Godt. Vi kontrolleres ene scenarie.

492
00:29:23,320 --> 00:29:29,520
Vi implicit kontrolleres ikke kopiere mere hukommelse end det ville overstige længden af ​​baren.

493
00:29:29,520 --> 00:29:32,510
Så hvis strengen brugeren har indtastet i er 10 tegn lang,

494
00:29:32,510 --> 00:29:36,020
dette siger kun kopiere 10 tegn. Og det er okay.

495
00:29:36,020 --> 00:29:39,940
Men hvad nu, hvis brugeren har indtastet et ord ved prompten ligesom en 20-tegn ord?

496
00:29:39,940 --> 00:29:44,900
Dette siger eksemplar 20 karakterer fra bar til hvad?

497
00:29:44,900 --> 00:29:49,750
C, også kendt som vores buffer, hvilket betyder, at du lige har skrevet data

498
00:29:49,750 --> 00:29:52,540
til 8 byte steder, du ikke ejer,

499
00:29:52,540 --> 00:29:54,870
og du ikke ejer dem i den forstand, at du aldrig tildelt dem.

500
00:29:54,870 --> 00:30:00,370
Så dette er hvad der almindeligvis kendt som buffer overflow angreb eller bufferoverløb angreb.

501
00:30:00,370 --> 00:30:05,580
Og det er et angreb i den forstand, at hvis brugeren eller det program, der kalder din funktion

502
00:30:05,580 --> 00:30:10,490
gør dette skadeligt, hvad der rent faktisk sker næste kunne faktisk være temmelig dårlig.

503
00:30:10,490 --> 00:30:12,450
>> Så lad os tage et kig på dette billede her.

504
00:30:12,450 --> 00:30:16,060
Dette billede repræsenterer din stak af hukommelse.

505
00:30:16,060 --> 00:30:19,580
Husk på, at hver gang du kalder en funktion, du får denne lille ramme på stakken

506
00:30:19,580 --> 00:30:21,520
og derefter en anden og derefter en anden og en anden.

507
00:30:21,520 --> 00:30:24,300
Og hidtil, vi har bare lidt indvindes disse som rektangler

508
00:30:24,300 --> 00:30:26,290
enten på tavlen eller på skærmen her.

509
00:30:26,290 --> 00:30:30,580
Men hvis vi zoome ind på en af ​​disse rektangler, når du kalder en funktion foo,

510
00:30:30,580 --> 00:30:35,880
viser det sig, at der er mere på stakken indersiden af ​​rammen i dette rektangel

511
00:30:35,880 --> 00:30:40,060
end blot x og y og a og b, ligesom vi gjorde tale om swap.

512
00:30:40,060 --> 00:30:44,410
Det viser sig, at der er nogle laverestående detaljer, blandt dem returadressen.

513
00:30:44,410 --> 00:30:49,550
Så det viser sig, når main kalder foo, main skal underrette Foo

514
00:30:49,550 --> 00:30:53,520
hvad main adresse er i computerens hukommelse

515
00:30:53,520 --> 00:30:57,770
fordi ellers så snart Foo gjort udføre, som i dette tilfælde her,

516
00:30:57,770 --> 00:31:00,830
når du når denne lukkede klammeparentes i slutningen af ​​foo,

517
00:31:00,830 --> 00:31:05,310
hvordan dælen gør Foo vide, hvor kontrol af programmet er meningen at gå?

518
00:31:05,310 --> 00:31:08,970
Det viser sig, at svaret på det spørgsmål er i denne røde rektangel her.

519
00:31:08,970 --> 00:31:12,670
Dette er en pointer, og det er op til computeren til midlertidig opbevaring

520
00:31:12,670 --> 00:31:17,030
på den såkaldte stak adressen på main således at så snart Foo sker udførelse,

521
00:31:17,030 --> 00:31:21,120
computeren ved, hvor og hvilken linje i main at gå tilbage til.

522
00:31:21,120 --> 00:31:23,940
Gemte Frame pointer angår ligeledes til dette.

523
00:31:23,940 --> 00:31:26,310
Char * bar her repræsenterer hvad?

524
00:31:26,310 --> 00:31:31,350
Nu er denne blå segment her er Foo ramme. Hvad er bar?

525
00:31:31,570 --> 00:31:35,010
Bar er bare det argument til Foo funktionen.

526
00:31:35,010 --> 00:31:37,500
Så nu er vi tilbage ved slags det velkendte billede.

527
00:31:37,500 --> 00:31:39,850
Der er flere ting og flere distraktioner på skærmen,

528
00:31:39,850 --> 00:31:43,380
men dette lys blå segment er bare hvad vi har at trække på tavlen

529
00:31:43,380 --> 00:31:45,790
for noget som swap. Det er rammen for foo.

530
00:31:45,790 --> 00:31:51,490
Og det eneste i det lige nu er bar, som er denne parameter.

531
00:31:51,490 --> 00:31:55,220
Men hvad der ellers burde være i stakken i henhold til denne kode?

532
00:31:55,220 --> 00:31:57,760
[Studerende] char c [12]. >> [Malan] char c [12].

533
00:31:57,760 --> 00:32:02,810
Vi bør også se 12 kvadrater af hukommelse tildelt en variabel kaldet c,

534
00:32:02,810 --> 00:32:04,970
og faktisk vi har det på skærmen.

535
00:32:04,970 --> 00:32:08,480
Den meget toppen er der c [0], og derefter forfatteren af ​​dette diagram

536
00:32:08,480 --> 00:32:11,850
gider ikke at tegne alle de firkanter, men der er faktisk 12 er der

537
00:32:11,850 --> 00:32:16,590
for hvis man ser nederst til højre, c [11] hvis man tæller fra 0 er den 12. sådan byte.

538
00:32:16,590 --> 00:32:18,400
Men her er problemet.

539
00:32:18,400 --> 00:32:22,390
I hvilken retning c vokser?

540
00:32:22,390 --> 00:32:27,080
Sorter af top-down, hvis den begynder ved toppen og vokser til bunden.

541
00:32:27,080 --> 00:32:30,110
Det ser ikke ud som vi forlod os meget landingsbane her overhovedet.

542
00:32:30,110 --> 00:32:32,090
Vi har slags malet os op i et hjørne,

543
00:32:32,090 --> 00:32:36,940
og at c [11] er ret op imod bar, som er lige op imod Gemt Frame pointer,

544
00:32:36,940 --> 00:32:39,960
som er lige op imod returadressen. Der er ikke mere plads.

545
00:32:39,960 --> 00:32:42,810
Så hvad er konsekvenserne så hvis du skruer op

546
00:32:42,810 --> 00:32:46,500
og du prøver at læse 20 bytes i en 12-byte buffer?

547
00:32:46,500 --> 00:32:50,060
Hvor er disse 8 yderligere byte kommer til at gå? >> [Studerende] Inside -

548
00:32:50,060 --> 00:32:53,200
Inde alt andet, er hvoraf nogle super vigtigt.

549
00:32:53,200 --> 00:32:57,260
Og det vigtigste, potentielt er den røde boks der, afsenderadresse,

550
00:32:57,260 --> 00:33:03,560
fordi formoder, at du enten ved et uheld eller adversarially overskrive disse 4 bytes,

551
00:33:03,560 --> 00:33:07,260
denne pegepind adresse, ikke bare med skrald, men med en række

552
00:33:07,260 --> 00:33:09,810
der sker for at repræsentere en egentlig adresse i hukommelsen.

553
00:33:09,810 --> 00:33:13,880
Hvad er konsekvenserne, logisk? >> [Studerende] Funktion vil vende tilbage til et andet sted.

554
00:33:13,880 --> 00:33:15,250
Præcis.

555
00:33:15,250 --> 00:33:19,170
Når foo afkast og hits som klammeparentes er programmet kommer til at fortsætte

556
00:33:19,170 --> 00:33:25,060
ikke at vende tilbage til main, det vil vende tilbage til, hvad adressen er på denne røde kasse.

557
00:33:25,060 --> 00:33:28,600
>> I forbindelse med omgåelse software registrering,

558
00:33:28,600 --> 00:33:32,260
hvad nu hvis den adresse, der bliver returneret til er den funktion, der normalt bliver kaldt

559
00:33:32,260 --> 00:33:35,690
efter du har betalt for softwaren og indtastet dit registreringskode?

560
00:33:35,690 --> 00:33:39,870
Du kan sortere i trick computeren i ikke går her, men i stedet går op her.

561
00:33:39,870 --> 00:33:45,100
Eller hvis du er virkelig dygtig, kan en modstander faktisk skrive på tastaturet, for eksempel,

562
00:33:45,100 --> 00:33:50,690
ikke en egentlig ord, ikke 20 tegn, men formoder han eller hun faktisk typer i

563
00:33:50,690 --> 00:33:52,770
nogle tegn, der repræsenterer kode.

564
00:33:52,770 --> 00:33:55,320
Og det kommer ikke til at være C-kode, er det faktisk kommer til at være de tegn

565
00:33:55,320 --> 00:33:59,290
der repræsenterer binær maskinkode, 0'er og 1'ere.

566
00:33:59,290 --> 00:34:01,290
Men formoder, at de er kloge nok til at gøre det,

567
00:34:01,290 --> 00:34:06,500
en eller anden måde indsætte i GetString prompt noget, der er det væsentlige kompileret kode,

568
00:34:06,500 --> 00:34:09,980
og de sidste 4 bytes overskrive at returadresse.

569
00:34:09,980 --> 00:34:13,360
Og hvad adressen betyder det input gøre?

570
00:34:13,360 --> 00:34:18,630
Det faktisk gemmer i denne røde rektangel adressen på den første byte af bufferen.

571
00:34:18,630 --> 00:34:23,070
Så du er nødt til at være virkelig klog, og det er en masse trial and error for dårlige mennesker derude,

572
00:34:23,070 --> 00:34:25,639
men hvis du kan finde ud af hvor stor denne buffer er

573
00:34:25,639 --> 00:34:28,820
sådan, at de sidste par bytes i input, du giver til programmet

574
00:34:28,820 --> 00:34:33,540
tilfældigvis svarer til adressen på starten af ​​din buffer, kan du gøre det her.

575
00:34:33,540 --> 00:34:39,320
Hvis vi siger normalt goddag og \ 0, det er, hvad ender i bufferen.

576
00:34:39,320 --> 00:34:44,420
Men hvis vi er klogere, og vi fylder denne buffer med, hvad vi vil generisk kalde angreb kode -

577
00:34:44,420 --> 00:34:48,860
AAA, angreb, angreb, angreb - hvor det er bare noget, der gør noget slemt,

578
00:34:48,860 --> 00:34:51,820
hvad sker der hvis du er virkelig dygtig, kan du gøre det her.

579
00:34:51,820 --> 00:34:58,610
I det røde felt her er en sekvens af tal - 80, C0, 35, 08.

580
00:34:58,610 --> 00:35:01,610
Bemærk, at der matcher det nummer, der er heroppe.

581
00:35:01,610 --> 00:35:04,430
Det er i omvendt rækkefølge, men mere om det en anden gang.

582
00:35:04,430 --> 00:35:08,140
Bemærk, at denne returadresse er blevet modificeret

583
00:35:08,140 --> 00:35:12,020
at svare til den adresse op her, ikke adressen på main.

584
00:35:12,020 --> 00:35:17,500
Så hvis den dårlige fyr er super smart, er han eller hun kommer til at omfatte i angrebet kode

585
00:35:17,500 --> 00:35:20,930
noget lignende slette alle brugerens filer eller kopiere adgangskoderne

586
00:35:20,930 --> 00:35:24,680
eller opret en brugerkonto, som jeg så kan logge på - noget som helst.

587
00:35:24,680 --> 00:35:26,950
>> Og det er både faren og magt C.

588
00:35:26,950 --> 00:35:29,840
Fordi du har adgang til hukommelse via pegepinde

589
00:35:29,840 --> 00:35:32,520
og du kan derfor skrive noget, du ønsker i en computers hukommelse,

590
00:35:32,520 --> 00:35:35,080
du kan gøre en computer gøre noget, du ønsker

591
00:35:35,080 --> 00:35:39,550
blot ved at have den hoppe rundt i sin egen hukommelse.

592
00:35:39,550 --> 00:35:44,650
Og så den dag i dag så mange programmer og så mange websteder, som er kompromitteret

593
00:35:44,650 --> 00:35:46,200
koges ned til mennesker, der tager fordel af dette.

594
00:35:46,200 --> 00:35:50,760
Og det kan synes som en super sofistikeret angreb, men det behøver ikke altid starte på den måde.

595
00:35:50,760 --> 00:35:53,560
Virkeligheden er, at hvad onde mennesker vil typisk gøre, er,

596
00:35:53,560 --> 00:35:58,200
uanset om det er et program på en kommandolinje eller en GUI program eller en hjemmeside,

597
00:35:58,200 --> 00:35:59,940
du bare begynde at tilbyde noget vrøvl.

598
00:35:59,940 --> 00:36:03,980
Du skriver i en rigtig stor ord i søgefeltet og tryk på Enter,

599
00:36:03,980 --> 00:36:05,780
og du vente at se, om hjemmesiden går ned

600
00:36:05,780 --> 00:36:09,990
eller du vente med at se, om programmet manifesterer nogle fejlmeddelelse

601
00:36:09,990 --> 00:36:14,330
fordi hvis du får heldige som bad guy, og du giver nogle vanvittige input

602
00:36:14,330 --> 00:36:18,980
der går ned programmet, det betyder, at programmøren ikke havde forudset din dårlige opførsel,

603
00:36:18,980 --> 00:36:23,630
hvilket betyder, at du kan sandsynligvis med nok indsats, nok trial and error,

604
00:36:23,630 --> 00:36:26,650
finde ud af at føre en mere præcis angreb.

605
00:36:26,650 --> 00:36:31,410
Så lige så meget en del af sikkerheden ikke bare at undgå disse angreb helt

606
00:36:31,410 --> 00:36:34,100
men afsløre dem, og faktisk ser på logs

607
00:36:34,100 --> 00:36:36,780
og se, hvad skøre input har folk skrevet ind på din hjemmeside,

608
00:36:36,780 --> 00:36:38,960
hvilke søgeord har folk skrevet ind på din hjemmeside

609
00:36:38,960 --> 00:36:42,870
i håb om overfyldte nogle buffer.

610
00:36:42,870 --> 00:36:45,500
Og alt dette kan koges ned til de enkle grundlæggende i, hvad er et array

611
00:36:45,500 --> 00:36:49,080
og hvad betyder det at allokere og bruge hukommelsen.

612
00:36:49,080 --> 00:36:51,710
>> Relateret til det så også er det.

613
00:36:51,710 --> 00:36:54,280
Lad os bare kigge inde i en harddisk endnu en gang.

614
00:36:54,280 --> 00:36:58,440
Du husker fra en uge eller to siden, at når du trækker filer til din papirkurven eller papirkurven,

615
00:36:58,440 --> 00:37:03,710
hvad sker der? >> [Studerende] Ingenting. >> Absolut intet, right?

616
00:37:03,710 --> 00:37:05,740
Til sidst, hvis du løber tør for diskplads,

617
00:37:05,740 --> 00:37:08,190
Windows eller Mac OS vil begynde at slette filer for dig.

618
00:37:08,190 --> 00:37:10,390
Men hvis du trækker noget derinde, der er slet ikke sikkert.

619
00:37:10,390 --> 00:37:13,800
Alle dine roommate eller ven eller et familiemedlem har at gøre, er dobbelt klikke og, voila,

620
00:37:13,800 --> 00:37:16,310
Der er alle de magre filer, som du forsøgte at slette.

621
00:37:16,310 --> 00:37:19,590
De fleste af os i det mindste vide, at du er nødt til at højreklikke eller kontrol klik

622
00:37:19,590 --> 00:37:22,310
og tømme papirkurven eller noget i den stil.

623
00:37:22,310 --> 00:37:25,000
Men selv da, der ikke helt gøre det trick

624
00:37:25,000 --> 00:37:28,010
fordi hvad der sker, når du har en fil på din harddisk

625
00:37:28,010 --> 00:37:32,770
, som repræsenterer nogle Word-dokument eller nogle JPEG, og dette repræsenterer din harddisk,

626
00:37:32,770 --> 00:37:35,350
og lad os sige dette splint her repræsenterer den pågældende fil,

627
00:37:35,350 --> 00:37:38,390
og det er sammensat af en hel bunke af 0'er og 1'ere.

628
00:37:38,390 --> 00:37:42,470
Hvad sker der, når du ikke kun trække filen til papirkurven kan eller genbruge bin

629
00:37:42,470 --> 00:37:48,020
men også tømme den? Sorter af ingenting.

630
00:37:48,020 --> 00:37:49,640
Det er ikke absolut intet nu.

631
00:37:49,640 --> 00:37:54,290
Nu er det bare noget, fordi en lille ting der sker i form af denne tabel.

632
00:37:54,290 --> 00:37:58,370
Så der er en slags database eller tabel inde i en computers hukommelse

633
00:37:58,370 --> 00:38:03,850
der hovedsagelig har en kolonne for filer navne og en kolonne for filer 'placering,

634
00:38:03,850 --> 00:38:07,720
hvor det kan blive placering 123, bare et tilfældigt tal.

635
00:38:07,720 --> 00:38:14,560
Så vi kunne have noget lignende x.jpeg og placering 123.

636
00:38:14,560 --> 00:38:18,800
Hvad sker der så når du rent faktisk tømme din papirkurv?

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

638
00:38:20,330 --> 00:38:23,610
Men hvad der ikke går væk er den 0'er og 1'ere.

639
00:38:23,610 --> 00:38:26,270
>> Så hvad er så forbindelsen til pset4?

640
00:38:26,270 --> 00:38:31,240
Nå, med pset4, bare fordi vi ved et uheld har slettet den compact flash card

641
00:38:31,240 --> 00:38:35,750
der havde alle disse billeder, eller bare fordi det ved uheld blev ødelagt

642
00:38:35,750 --> 00:38:38,000
betyder ikke, at den 0'er og 1-taller ikke er der stadig.

643
00:38:38,000 --> 00:38:40,410
Måske et par af dem går tabt, fordi noget fik ødelagt

644
00:38:40,410 --> 00:38:43,320
i den forstand, at nogle 0'er blev 1s og 1s blev 0'erne.

645
00:38:43,320 --> 00:38:47,240
Dårlige ting kan ske på grund af buggy software eller defekt hardware.

646
00:38:47,240 --> 00:38:50,370
Men mange af disse bits, måske endda 100% af dem, er der stadig.

647
00:38:50,370 --> 00:38:55,050
Det er bare at computeren eller kameraet ikke ved, hvor JPEG1 startede

648
00:38:55,050 --> 00:38:56,910
og hvor JPEG2 startede.

649
00:38:56,910 --> 00:39:01,070
Men hvis du, programmøren, vide med en smule af kyndige, når disse JPEG er

650
00:39:01,070 --> 00:39:06,010
eller hvordan de ser ud, så du kan analysere den 0'er og 1-taller og sige JPEG, JPEG,

651
00:39:06,010 --> 00:39:09,440
du kan skrive et program med væsentlige blot et for eller while-løkke

652
00:39:09,440 --> 00:39:12,820
der genvinder hver af disse filer.

653
00:39:12,820 --> 00:39:16,030
Så den lektie så er at starte sikkert slette dine filer

654
00:39:16,030 --> 00:39:18,340
Hvis du gerne vil undgå dette helt. Ja.

655
00:39:18,340 --> 00:39:21,010
>> [Studerende] Hvordan kommer det siger om din computer

656
00:39:21,010 --> 00:39:23,550
at du har mere hukommelse end du gjorde før?

657
00:39:23,550 --> 00:39:27,820
Har mere hukommelse end du gjorde før - >> [studerende] Mere tilgængelig hukommelse.

658
00:39:27,820 --> 00:39:29,630
Oh. Godt spørgsmål.

659
00:39:29,630 --> 00:39:32,360
Så hvorfor så efter tømning af skrald har computeren fortælle dig

660
00:39:32,360 --> 00:39:34,910
at du har mere ledig plads end du gjorde før?

661
00:39:34,910 --> 00:39:36,770
I en nøddeskal, fordi lyver.

662
00:39:36,770 --> 00:39:40,740
Mere teknisk, har du mere plads, fordi du nu har sagt

663
00:39:40,740 --> 00:39:43,680
du kan sætte andre ting, hvor den pågældende fil var engang.

664
00:39:43,680 --> 00:39:45,450
Men det betyder ikke, at de bits går væk,

665
00:39:45,450 --> 00:39:48,590
og det betyder ikke bittene bliver ændret til 0'er, for eksempel

666
00:39:48,590 --> 00:39:50,150
for din beskyttelse.

667
00:39:50,150 --> 00:39:54,640
Så ved Derimod, hvis du sikkert slette filer eller fysisk ødelægge enheden

668
00:39:54,640 --> 00:39:57,300
der virkelig er den eneste måde til tider omkring dette.

669
00:39:57,300 --> 00:40:02,020
>> Så hvorfor gør vi ikke forlade på at semi-skræmmende note, og vi vil se dig på mandag.

670
00:40:02,020 --> 00:40:07,000
[Bifald]

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