1
00:00:00,000 --> 00:00:02,860
[Powered by Google Translate] [Uke 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
>> Dette er CS50, uke 5.

5
00:00:09,740 --> 00:00:12,900
I dag og denne uken introduserer vi en liten bit av verden av forensics

6
00:00:12,900 --> 00:00:14,850
i sammenheng med problemet Set 4.

7
00:00:14,850 --> 00:00:18,480
I dag vil være en forkortet foredrag fordi det er en spesiell hendelse her etterpå.

8
00:00:18,480 --> 00:00:21,940
Så vi vil ta en titt og erte både elever og foreldre alike dag

9
00:00:21,940 --> 00:00:24,600
med noen av de tingene som er på horisonten.

10
00:00:24,600 --> 00:00:29,050
>> Blant dem, og med mandag, vil du ha noen flere klassekamerater.

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

12
00:00:32,980 --> 00:00:36,730
lanserer på Harvard campus på mandag, noe som betyr kommer mandag

13
00:00:36,730 --> 00:00:40,930
du vil ha, som i forrige telling, 86000 flere klassekamerater

14
00:00:40,930 --> 00:00:43,680
som skal følge sammen med CS50 foredrag og seksjoner

15
00:00:43,680 --> 00:00:45,890
og gjennomgang og øvingsoppgaver.

16
00:00:45,890 --> 00:00:51,870
Og som en del av dette, vil du bli medlemmer av innvielses klasse av CS50 og nå CS50x.

17
00:00:51,870 --> 00:00:56,150
Som en del av dette nå, innser at det vil være noen oppsider også.

18
00:00:56,150 --> 00:01:00,620
Å bli klar for dette, for det massive antall studenter,

19
00:01:00,620 --> 00:01:03,820
nok det å si at selv om vi har 108 TFS og CAS,

20
00:01:03,820 --> 00:01:07,560
det er ikke helt den beste student-lærer ratio når vi treffer 80.000 av elevene.

21
00:01:07,560 --> 00:01:09,830
Vi kommer ikke til å bli gradering så mange problem setter manuelt,

22
00:01:09,830 --> 00:01:13,050
så introdusert denne uken i oppgavesettet vil være CS50 Check,

23
00:01:13,050 --> 00:01:15,410
som kommer til å være en kommandolinjeverktøy i apparatet

24
00:01:15,410 --> 00:01:17,880
at du får når du oppdatere den senere denne helgen.

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

26
00:01:21,030 --> 00:01:24,770
og du vil få umiddelbar tilbakemelding på om programmet er riktig eller feil

27
00:01:24,770 --> 00:01:27,980
i henhold til ulike design spesifikasjoner som vi har gitt.

28
00:01:27,980 --> 00:01:30,310
Mer om det i oppgavesettet spesifikasjonen.

29
00:01:30,310 --> 00:01:34,220
De CS50x klassekamerater skal bruke dette også.

30
00:01:34,220 --> 00:01:36,170
>> Problem Set 4 handler om dataanalyse,

31
00:01:36,170 --> 00:01:38,630
og denne pset ble virkelig inspirert av noen virkelige ting

32
00:01:38,630 --> 00:01:41,210
der da jeg var i gradsstudier jeg internert for en stund

33
00:01:41,210 --> 00:01:45,270
med Middlesex County i statsadvokat kontor gjør rettsmedisin

34
00:01:45,270 --> 00:01:47,660
med sin leder rettsmedisinske etterforsker.

35
00:01:47,660 --> 00:01:50,280
Hva dette utgjorde, som jeg tror jeg har nevnt et par uker tidligere,

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

37
00:01:52,720 --> 00:01:56,150
de ville slippe av ting som harddisker og CDer og disketter og lignende,

38
00:01:56,150 --> 00:01:58,770
og deretter målet for etterforskning kontoret var å kartlegge

39
00:01:58,770 --> 00:02:01,470
om det var eller ikke var bevis av noe slag.

40
00:02:01,470 --> 00:02:04,730
Dette var den Special Investigations Unit, så det var økonomisk kriminalitet.

41
00:02:04,730 --> 00:02:10,949
Det var mer problematisk slags forbrytelser, noe som involverer noen form for digitale medier.

42
00:02:10,949 --> 00:02:16,450
Det viser seg at ikke så mange folk skrive en e-post som sier: "Jeg gjorde det."

43
00:02:16,450 --> 00:02:20,490
Så ganske ofte, disse rettsmedisinske søk ikke skru opp så mye frukt,

44
00:02:20,490 --> 00:02:22,820
men noen ganger folk ville skrive slike e-poster.

45
00:02:22,820 --> 00:02:25,240
Så noen ganger, ble innsatsen belønnet.

46
00:02:25,240 --> 00:02:31,210
>> Men å lede opp til dette rettsmedisinske pset, vil vi innføre i pset4 litt grafikk.

47
00:02:31,210 --> 00:02:35,410
Du har sannsynligvis ta disse tingene for gitt - JPEG, GIF, og lignende - i disse dager.

48
00:02:35,410 --> 00:02:38,320
Men hvis du virkelig tenker over det, et bilde, omtrent som Rob ansikt,

49
00:02:38,320 --> 00:02:41,270
kunne bli modellert som en sekvens av punkter eller piksler.

50
00:02:41,270 --> 00:02:43,380
I tilfelle av Rob ansikt, er det alle slags farger,

51
00:02:43,380 --> 00:02:46,760
og vi begynte å se de enkelte punkter, ellers kjent som piksler,

52
00:02:46,760 --> 00:02:48,610
når vi begynte å zoome inn

53
00:02:48,610 --> 00:02:54,660
Men hvis vi forenkle verden litt og bare si at dette her er Rob i svart og hvitt,

54
00:02:54,660 --> 00:02:57,490
å representere svart og hvitt, kan vi bare bruke binær.

55
00:02:57,490 --> 00:03:01,660
Og hvis vi kommer til å bruke binære, 1 eller 0, kan vi uttrykke dette samme bildet

56
00:03:01,660 --> 00:03:06,140
av Rob smilende ansikt med dette mønsteret av biter.

57
00:03:06,140 --> 00:03:12,100
11000011 representerer hvitt, hvitt, svart, svart, svart, svart, hvit, hvit.

58
00:03:12,100 --> 00:03:16,150
Og så det er ikke et stort sprang deretter å begynne å snakke om fargerike fotografier,

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

60
00:03:18,600 --> 00:03:21,410
Men sikkert når det kommer til farger, trenger du flere biter.

61
00:03:21,410 --> 00:03:25,690
Og ganske vanlig i verden av fotografier er å bruke ikke 1-bit farge,

62
00:03:25,690 --> 00:03:29,560
da dette antyder, men 24-bits farger, hvor du faktisk får millioner av farger.

63
00:03:29,560 --> 00:03:32,250
Så som i tilfelle når vi zoomet inn på Rob øye,

64
00:03:32,250 --> 00:03:36,370
det var en rekke av millioner av forskjellige fargerike muligheter.

65
00:03:36,370 --> 00:03:39,040
Så vi vil innføre dette i oppgavesettet 4 samt i walkthrough,

66
00:03:39,040 --> 00:03:43,370
som vil være i dag kl 03:30 i stedet for den vanlige 02:30 på grunn av fredagens foredrag her.

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

68
00:03:46,620 --> 00:03:48,820
>> Vi vil også introdusere deg til et annet filformat.

69
00:03:48,820 --> 00:03:51,270
Dette er bevisst ment å se skremmende i starten,

70
00:03:51,270 --> 00:03:55,670
men dette er bare noen dokumentasjon for en C struct.

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

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

73
00:04:05,150 --> 00:04:10,150
som ble brukt i lengre tid, og noen ganger fortsatt for bakgrunnsbilder på stasjonære maskiner.

74
00:04:10,150 --> 00:04:14,760
Hvis du tenker tilbake til Windows XP og bølgende åser og den blå himmelen,

75
00:04:14,760 --> 00:04:17,170
som var typisk en bmp eller punktgrafikkbilde.

76
00:04:17,170 --> 00:04:19,959
Punktgrafikk er moro for oss fordi de har litt mer kompleksitet.

77
00:04:19,959 --> 00:04:22,610
Det er ikke fullt så enkelt som dette rutenettet 0'er og 1'ere.

78
00:04:22,610 --> 00:04:27,510
I stedet har du ting som en overskrift i begynnelsen av en fil.

79
00:04:27,510 --> 00:04:31,990
Så med andre ord, inne i en. Bmp-fil er en hel haug med 0'er og 1'ere,

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

81
00:04:34,910 --> 00:04:38,220
Og det viser seg at det vi har sikkert tatt for gitt i årevis -

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

83
00:04:45,170 --> 00:04:48,480
at du er kjent med - hva betyr det også bety å være et filformat,

84
00:04:48,480 --> 00:04:52,480
fordi på slutten av dagen alle disse filene vi bruker har bare 0'er og 1'ere.

85
00:04:52,480 --> 00:04:56,810
Og kanskje de 0'er og 1'ere representerer ABC gjennom ASCII eller lignende,

86
00:04:56,810 --> 00:04:58,820
men på slutten av dagen, er det fortsatt bare 0'er og 1'ere.

87
00:04:58,820 --> 00:05:02,100
Så mennesker bare sporadisk bestemmer seg for å oppfinne et nytt filformat

88
00:05:02,100 --> 00:05:06,420
hvor de standardisere hva punktmønstre faktisk vil bety.

89
00:05:06,420 --> 00:05:09,220
Og i dette tilfellet her, folk som designet bitmap filformat

90
00:05:09,220 --> 00:05:15,620
sa at i det første byte i en bitmap fil, som vist ved offset 0 der,

91
00:05:15,620 --> 00:05:18,940
det kommer til å være noen kryptisk navngitt variabel kalt bfType,

92
00:05:18,940 --> 00:05:23,080
som bare står for bitmap filtype, hva slags bitmap fil er dette.

93
00:05:23,080 --> 00:05:27,700
Du kan antyde kanskje fra andre rad som offset 2, byte nummer 2,

94
00:05:27,700 --> 00:05:33,740
har et mønster av 0'er og 1'ere som representerer hva? Størrelsen på noe.

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

96
00:05:35,310 --> 00:05:37,410
Så i oppgavesettet 4, vil du bli gått gjennom noen av disse tingene.

97
00:05:37,410 --> 00:05:39,520
Vi vil ikke ende opp å bry seg om dem alle.

98
00:05:39,520 --> 00:05:47,510
Men merker det begynner å bli interessant rundt byte 54: rgbtBlue, grønn og rød.

99
00:05:47,510 --> 00:05:52,110
Hvis du noen gang har hørt forkortelsen RGB - rød, grønn, blå - dette er en referanse til at

100
00:05:52,110 --> 00:05:54,610
fordi det viser seg at du kan male alle farger i regnbuen

101
00:05:54,610 --> 00:05:58,180
med en kombinasjon av rødt og blått og grønt.

102
00:05:58,180 --> 00:06:03,320
Og faktisk, kan foreldrene i rommet husker noen av de tidligste projektorer.

103
00:06:03,320 --> 00:06:05,890
I disse dager, du bare se én lys kommer ut av et objektiv,

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

105
00:06:09,800 --> 00:06:13,380
og sammen med sikte på en skjerm og dannet et fargerikt bilde.

106
00:06:13,380 --> 00:06:16,270
Og ganske ofte, vil ungdomsskoler og videregående skoler har disse linsene

107
00:06:16,270 --> 00:06:19,720
aldri så litt skjevt, så du var liksom se doble eller triple bilder.

108
00:06:19,720 --> 00:06:24,100
Men det var ideen. Du hadde rød og grønn og blå lys male et bilde.

109
00:06:24,100 --> 00:06:26,590
Og at samme prinsipp er benyttet i datamaskiner.

110
00:06:26,590 --> 00:06:30,230
>> Så blant de utfordringene deretter for deg i oppgave Set 4 kommer til å være et par ting.

111
00:06:30,230 --> 00:06:34,800
Det ene er å faktisk endre størrelsen på et bilde, for å ta i et mønster av 0'er og 1'ere,

112
00:06:34,800 --> 00:06:40,200
finne ut hvilke biter av 0'er og 1'ere representerer det i en struktur som dette,

113
00:06:40,200 --> 00:06:43,630
og deretter finne ut hvordan man kan gjenskape piksler - den røde, blues, greener -

114
00:06:43,630 --> 00:06:46,660
innsiden, slik at når et bilde ser slik ut først,

115
00:06:46,660 --> 00:06:49,210
det kan se slik ut i stedet etter det.

116
00:06:49,210 --> 00:06:53,640
Blant de andre utfordringene for kommer til å være at du vil få utdelt en rettsmedisinsk bilde

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

118
00:06:56,030 --> 00:06:58,960
Og på det kameraet, en gang i tiden var en hel haug med bilder.

119
00:06:58,960 --> 00:07:03,760
Problemet er at vi ved et uhell slettet eller hadde bildet ødelagt eller annen måte.

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

121
00:07:05,750 --> 00:07:09,150
Og så vi raskt kopiert alle 0'er og 1'ere ut av dette kortet for deg,

122
00:07:09,150 --> 00:07:13,610
reddet dem alle i én stor fil, og vi vil overlate dem til deg i oppgave Set 4

123
00:07:13,610 --> 00:07:19,320
slik at du kan skrive et program i C som å gjenopprette alle disse JPEG, ideelt.

124
00:07:19,320 --> 00:07:23,330
Og det viser seg at JPEG, selv om de er litt av en kompleks filformat -

125
00:07:23,330 --> 00:07:26,360
de er mye mer komplisert enn dette smilende ansikt her -

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

127
00:07:31,160 --> 00:07:35,630
Så bruker, til slutt, en stund loop eller en for løkke eller lignende,

128
00:07:35,630 --> 00:07:38,880
du kan iterere over alle 0'er og 1'ere i denne rettsmedisinske bilde,

129
00:07:38,880 --> 00:07:43,150
og hver gang du ser den spesielle mønster som er definert i oppgavesettet spesifikasjonen,

130
00:07:43,150 --> 00:07:47,880
du kan anta her er, med svært høy sannsynlighet starten på en JPEG.

131
00:07:47,880 --> 00:07:51,230
Og så snart du finner det samme mønsteret et antall byte

132
00:07:51,230 --> 00:07:55,430
eller kilobytes eller megabyte senere, kan du anta her er en annen JPEG,

133
00:07:55,430 --> 00:07:57,380
bildet jeg tok etter den første.

134
00:07:57,380 --> 00:08:01,370
La meg slutte å lese den første filen, begynner å skrive denne nye,

135
00:08:01,370 --> 00:08:06,310
og resultatet av programmet for pset4 kommer til å være så mange som 50 JPEG-bilder.

136
00:08:06,310 --> 00:08:09,270
Og hvis det ikke er 50 JPEG-bilder, har du litt av en loop.

137
00:08:09,270 --> 00:08:12,490
Hvis du har et uendelig antall JPEG, har du en uendelig loop.

138
00:08:12,490 --> 00:08:14,910
Slik at også vil være ganske vanlig sak.

139
00:08:14,910 --> 00:08:16,600
Så det er det som er på horisonten.

140
00:08:16,600 --> 00:08:21,310
>> Quiz 0 bak oss, innser per e-posten min som alltid er det folk som er både glade,

141
00:08:21,310 --> 00:08:23,640
slags nøytral, og trist rundt quiz 0 time.

142
00:08:23,640 --> 00:08:26,800
Og vennligst nå ut til meg, hodet TF Zamyla, din egen TF,

143
00:08:26,800 --> 00:08:31,180
eller en av de sertifikatutstedere som du vet om du ønsker å diskutere hvordan det gikk.

144
00:08:31,180 --> 00:08:35,539
>> Så for å imponere foreldrene her i rommet, hva er CS50 biblioteket?

145
00:08:36,429 --> 00:08:40,390
[Latter] God jobb.

146
00:08:40,390 --> 00:08:48,340
Hva er CS50 biblioteket? Ja. >> [Student] Det er en pre-skrevet sett av koden [hørbar]

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

148
00:08:49,750 --> 00:08:53,240
Det er en pre-skrevet sett med kode som vi ansatte skrev, vi gir til deg,

149
00:08:53,240 --> 00:08:55,030
som gir noen felles funksjonalitet,

150
00:08:55,030 --> 00:08:59,020
ting som får meg en streng, få meg en int - alle funksjoner som er oppført her.

151
00:08:59,020 --> 00:09:02,260
>> Starter nå, begynner vi å virkelig ta disse trening hjul av.

152
00:09:02,260 --> 00:09:05,050
Vi kommer til å begynne å ta bort en streng fra deg,

153
00:09:05,050 --> 00:09:08,870
som tilbakekallingen var bare et synonym for hva som faktisk datatype? >> [Flere studenter] Char *.

154
00:09:08,870 --> 00:09:12,730
Char *. For foreldre, var at sannsynligvis [gjør susende lyd]. Det er bra.

155
00:09:12,730 --> 00:09:17,550
Char * vi vil begynne å se på skjermen hele mer som vi fjerner streng fra vårt vokabular,

156
00:09:17,550 --> 00:09:19,730
i hvert fall når det gjelder å faktisk skrive kode.

157
00:09:19,730 --> 00:09:22,840
Tilsvarende vil vi slutte å bruke noen av disse funksjonene så mye

158
00:09:22,840 --> 00:09:25,280
fordi våre programmer kommer til å få mer sofistikert.

159
00:09:25,280 --> 00:09:28,480
Snarere enn å bare skrive programmer som sitter der med en rask blinkende,

160
00:09:28,480 --> 00:09:31,870
venter på at brukeren skriver noe i, vil du få innspill fra andre steder.

161
00:09:31,870 --> 00:09:35,490
For eksempel, vil du få dem fra en rekke biter på den lokale harddisken.

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

163
00:09:38,580 --> 00:09:40,230
noen nettside eller annet sted.

164
00:09:40,230 --> 00:09:44,110
>> Så la oss skrelle tilbake dette laget for første gang, og dra opp CS50 Appliance

165
00:09:44,110 --> 00:09:49,010
og denne filen som heter cs50.h, som du har vært # inkludert i uker,

166
00:09:49,010 --> 00:09:51,140
men la oss faktisk se hva som er på innsiden av dette.

167
00:09:51,140 --> 00:09:54,430
Toppen av filen i blått er bare en hel haug med kommentarer:

168
00:09:54,430 --> 00:09:57,050
garanti samt lisensiering.

169
00:09:57,050 --> 00:09:59,050
Dette er liksom en felles paradigme i software

170
00:09:59,050 --> 00:10:01,580
fordi mye av programvaren i disse dager er det som kalles åpen kildekode,

171
00:10:01,580 --> 00:10:05,220
noe som betyr at noen har skrevet inn koden, og gjorde det fritt tilgjengelig

172
00:10:05,220 --> 00:10:10,470
ikke bare å løpe og å bruke, men å faktisk lese og endre og integrere i ditt eget arbeid.

173
00:10:10,470 --> 00:10:14,660
Så det er hva du har brukt, åpen kildekode, riktignok i en svært liten form.

174
00:10:14,660 --> 00:10:18,560
Hvis jeg ruller nedover forbi kommentarene, men vil vi begynne å se noen mer kjente ting.

175
00:10:18,560 --> 00:10:25,010
Varsel øverst her at cs50.h filen inneholder en hel haug med header filer.

176
00:10:25,010 --> 00:10:28,560
De fleste av disse har vi ikke sett før, men man er kjent.

177
00:10:28,560 --> 00:10:32,270
Hvilken av disse har vi sett, om enn kort, så langt? >> [Student] Standard biblioteket.

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 begynte å snakke om dynamisk minne allokering,

180
00:10:38,320 --> 00:10:41,650
som vi vil komme tilbake til neste uke også, begynte vi med den filen.

181
00:10:41,650 --> 00:10:46,640
Det viser seg at bool og sant og usant ikke egentlig eksisterer i C per se

182
00:10:46,640 --> 00:10:49,440
med mindre du inkluderer denne filen her.

183
00:10:49,440 --> 00:10:52,710
Vi har i flere uker vært inkludert stdbool.h

184
00:10:52,710 --> 00:10:55,620
slik at du kan bruke tanken om en bool, sant eller usant.

185
00:10:55,620 --> 00:10:58,620
Uten dette, ville du må sortere av falske det og bruke en int

186
00:10:58,620 --> 00:11:02,610
og bare vilkårlig anta at 0 er falsk og en er sant.

187
00:11:02,610 --> 00:11:07,150
Hvis vi blar ned ytterligere, her er vår definisjon av en streng.

188
00:11:07,150 --> 00:11:11,390
Det viser seg, som vi har sagt før, at der denne stjernen er ikke virkelig betyr noe.

189
00:11:11,390 --> 00:11:13,720
Du kan selv ha plass rundt.

190
00:11:13,720 --> 00:11:16,740
Vi dette semesteret har vært fremme det som dette for å gjøre det klart

191
00:11:16,740 --> 00:11:18,620
at stjernen har å gjøre med typen,

192
00:11:18,620 --> 00:11:21,700
men innser like vanlig, om ikke litt mer vanlig,

193
00:11:21,700 --> 00:11:24,430
er å sette det der, men funksjonelt er det det samme.

194
00:11:24,430 --> 00:11:27,720
Men nå hvis vi leser ned ytterligere, la oss ta en titt på GetInt

195
00:11:27,720 --> 00:11:32,190
fordi vi brukte som kanskje først før noe annet dette semesteret.

196
00:11:32,190 --> 00:11:37,440
Her er GetInt. Dette er hva? >> [Student] En prototype. >> Dette er bare en prototype.

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

198
00:11:41,410 --> 00:11:46,690
men du kan også sette prototyper i header-filer,. h-filer, som dette her

199
00:11:46,690 --> 00:11:50,840
slik at når du skrive noen funksjoner som du vil at andre skal kunne bruke,

200
00:11:50,840 --> 00:11:53,550
som er nøyaktig tilfelle med CS50 biblioteket,

201
00:11:53,550 --> 00:11:57,040
du ikke bare implementere dine funksjoner i noe som cs50.c,

202
00:11:57,040 --> 00:12:02,790
du også sette prototypene ikke på toppen av filen, men på toppen av en header-fil.

203
00:12:02,790 --> 00:12:07,170
Så at header-fil er hva venner og kolleger er

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

205
00:12:09,760 --> 00:12:12,210
Så hele denne tiden, du har inkludert alle disse prototypene,

206
00:12:12,210 --> 00:12:16,580
effektivt ved toppen av filen, men ved hjelp av denne # include mekanismen,

207
00:12:16,580 --> 00:12:20,070
som i hovedsak kopierer og limer denne filen til din egen.

208
00:12:20,070 --> 00:12:23,070
Her er noen ganske detaljert dokumentasjon.

209
00:12:23,070 --> 00:12:25,640
Vi har ganske mye tatt for gitt at GetInt får en int,

210
00:12:25,640 --> 00:12:27,640
men det viser seg at det er noen hjørne tilfeller.

211
00:12:27,640 --> 00:12:31,810
Hva om brukeren skriver inn et tall som er altfor stor, en kvintillioner,

212
00:12:31,810 --> 00:12:35,490
som bare ikke kan passe inn i en int? Hva er forventet oppførsel?

213
00:12:35,490 --> 00:12:38,020
Ideelt sett er det forutsigbart.

214
00:12:38,020 --> 00:12:40,280
Så i dette tilfellet, hvis du faktisk lese de fine print,

215
00:12:40,280 --> 00:12:44,500
du faktisk se at hvis linjen ikke kan leses, dette returnerer INT_MAX.

216
00:12:44,500 --> 00:12:48,320
Vi har aldri snakket om dette, men basert på kapitalisering sin, hva er det sannsynligvis?

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

218
00:12:50,640 --> 00:12:54,770
Det er noen spesielle konstant som sannsynligvis erklært i en av disse header filer

219
00:12:54,770 --> 00:13:00,090
det er høyere opp i filen, og INT_MAX er sannsynligvis noe sånt som omtrent 2 milliarder kroner,

220
00:13:00,090 --> 00:13:04,990
ideen er at fordi vi trenger å liksom bety at noe gikk galt,

221
00:13:04,990 --> 00:13:10,700
Vi, ja, har 4000 millioner tallene til rådighet: -2 milliarder opptil 2 milliarder kroner, gi eller ta.

222
00:13:10,700 --> 00:13:14,710
Vel, hva er vanlig i programmering er du stjeler bare ett av disse tallene,

223
00:13:14,710 --> 00:13:18,920
kanskje 0, kanskje 2 milliarder kroner, kanskje -2000000000,

224
00:13:18,920 --> 00:13:23,280
slik at du tilbringer en av dine mulige verdier, slik at du kan forplikte seg til hele verden

225
00:13:23,280 --> 00:13:26,820
at hvis noe går galt, vil jeg returnere denne super stor verdi.

226
00:13:26,820 --> 00:13:31,030
Men du ikke vil at brukeren skrive noe kryptisk som 234 ..., en virkelig stort antall.

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

228
00:13:34,060 --> 00:13:38,060
Så egentlig, hvis du var å være anal de siste ukene, hver gang du ringte GetInt,

229
00:13:38,060 --> 00:13:42,900
du burde ha vært sjekke med en hvis tilstanden gjorde brukeren skriver inn INT_MAX,

230
00:13:42,900 --> 00:13:46,590
eller, mer spesifikt, gjorde GetInt retur INT_MAX, fordi hvis det gjorde,

231
00:13:46,590 --> 00:13:51,830
som faktisk betyr at de ikke skriver det. Noe gikk galt i dette tilfellet.

232
00:13:51,830 --> 00:13:56,080
Så dette er hva som vanligvis kjent som en sentinel verdi, noe som betyr bare spesiell.

233
00:13:56,080 --> 00:13:58,120
>> La oss nå slå inn. C-fil.

234
00:13:58,120 --> 00:14:01,340
C-filen har eksistert i apparatet i noen tid.

235
00:14:01,340 --> 00:14:06,840
Og faktisk, har apparatet den pre-kompilert for deg inn at ting vi kalte objekt kode,

236
00:14:06,840 --> 00:14:09,540
men det bare ikke noe for deg hvor det er fordi systemet vet

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

238
00:14:11,730 --> 00:14:17,400
La oss bla ned nå for å GetInt og se hvordan GetInt har jobbet 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
La meg zoome inn på akkurat den koden delen.

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

242
00:14:23,900 --> 00:14:25,700
Det tar ingen innspill.

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

244
00:14:29,510 --> 00:14:33,180
men antagelig vil vi bryte ut av dette liksom eller gå tilbake fra innenfor dette.

245
00:14:33,180 --> 00:14:34,870
>> La oss se hvordan dette fungerer.

246
00:14:34,870 --> 00:14:39,240
Vi synes å være å bruke GetString i denne første linjen inne i loopen, 166.

247
00:14:39,240 --> 00:14:43,780
Dette er nå god praksis fordi under hvilke omstendigheter kunne GetString tilbake

248
00:14:43,780 --> 00:14:47,660
den spesielle nøkkelord NULL? >> [Student] Hvis noe går galt.

249
00:14:47,660 --> 00:14:51,630
Hvis noe går galt. Og hva som kan gå galt når du kaller noe som GetString?

250
00:14:54,960 --> 00:14:57,640
Ja. >> [Student] malloc ikke klarer å gi det de ints.

251
00:14:57,640 --> 00:14:59,150
Ja. Kanskje malloc mislykkes.

252
00:14:59,150 --> 00:15:03,190
Somewhere under panseret, er GetString ringer malloc, som tildeler minne,

253
00:15:03,190 --> 00:15:06,020
som lar datamaskinen butikken alle tegnene

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

255
00:15:07,750 --> 00:15:11,590
Og anta at brukeren hadde en hel masse ledig tid og skrevet mer, for eksempel,

256
00:15:11,590 --> 00:15:16,160
enn 2 milliarder tegn i, flere tegn enn datamaskinen har selv RAM.

257
00:15:16,160 --> 00:15:19,250
GetString må være i stand til å betegne det til deg.

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

259
00:15:22,560 --> 00:15:24,340
det må liksom være i stand til å håndtere dette,

260
00:15:24,340 --> 00:15:28,750
og så GetString, hvis vi gikk tilbake og lese dokumentasjon, gjør faktisk avkastning NULL.

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

262
00:15:34,460 --> 00:15:37,690
akkurat som en vaktpost. Dette er bare menneskelige konvensjoner.

263
00:15:37,690 --> 00:15:41,450
Den eneste måten du ville vite dette er tilfelle er ved å lese dokumentasjonen.

264
00:15:41,450 --> 00:15:45,040
>> La oss bla ned til der int faktisk fått.

265
00:15:45,040 --> 00:15:51,160
Hvis jeg ruller nedover et stykke, i tråd 170, har vi en kommentar ovenfor disse linjene.

266
00:15:51,160 --> 00:15:55,100
Vi erklærer 172 en int, n, og en røye, c, og deretter denne nye funksjonen,

267
00:15:55,100 --> 00:15:58,930
som noen av dere har snublet over før, sscanf.

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

269
00:16:00,870 --> 00:16:05,700
Med andre ord, gi meg en streng og jeg vil skanne den for opplysninger av interesse.

270
00:16:05,700 --> 00:16:07,360
Hva betyr det?

271
00:16:07,360 --> 00:16:11,800
Anta at jeg skriver i, bokstavelig talt, 123 ved tastaturet og deretter trykke Enter.

272
00:16:11,800 --> 00:16:16,470
Hva er datatypen for 123 da returnert av GetString? >> [Student] String.

273
00:16:16,470 --> 00:16:18,380
Det er åpenbart en streng, ikke sant? Jeg fikk en streng.

274
00:16:18,380 --> 00:16:23,220
Så 123 er virkelig, sitat-unquote, 123 med \ 0 på slutten av den.

275
00:16:23,220 --> 00:16:27,110
Det er ikke en int. Det er ikke et tall. Det ser ut som et tall, men det er faktisk ikke.

276
00:16:27,110 --> 00:16:29,080
Så hva har GetInt å gjøre?

277
00:16:29,080 --> 00:16:35,750
Det har å skanne strengen venstre til høyre - 123 \ 0 - og noe konvertere til en faktisk heltall.

278
00:16:35,750 --> 00:16:37,850
Du kan finne ut hvordan du gjør dette.

279
00:16:37,850 --> 00:16:41,450
Hvis du tenker tilbake til pset2, du antagelig fått litt komfortabel med Caesar

280
00:16:41,450 --> 00:16:44,820
eller Vigenere, slik at du kan iterere over en streng, kan du konvertere tegn til ints.

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

282
00:16:46,710 --> 00:16:49,860
Hvorfor ikke kalle en funksjon som sscanf som gjør det for deg?

283
00:16:49,860 --> 00:16:54,230
Så sscanf forventer et argument - i dette tilfellet kalles linje, som er en streng.

284
00:16:54,230 --> 00:17:01,840
Du kan deretter angi i anførselstegn, svært lik printf, hva du forventer å se i denne strengen.

285
00:17:01,840 --> 00:17:09,000
Og hva jeg sier her er jeg forvente å se et desimaltall og kanskje et tegn.

286
00:17:09,000 --> 00:17:12,000
Og vi vil se hvorfor dette er tilfellet i bare et øyeblikk.

287
00:17:12,000 --> 00:17:15,869
Og det viser seg at denne notasjonen er nå minner om ting vi begynte å snakke om

288
00:17:15,869 --> 00:17:17,619
litt over en uke siden.

289
00:17:17,619 --> 00:17:21,740
Hva er & n og & c gjør for oss her? >> [Student] Adressen n og adresse på ca.

290
00:17:21,740 --> 00:17:25,400
Ja. Det gir meg adressen til n og adresse c. Hvorfor er det viktig?

291
00:17:25,400 --> 00:17:30,220
Du vet at med funksjoner i C, kan du alltid returnere en verdi eller ingen verdi i det hele tatt.

292
00:17:30,220 --> 00:17:34,530
Du kan returnere en int, en streng, en flåte, en røye, uansett, eller du kan gå tilbake ugyldig,

293
00:17:34,530 --> 00:17:38,030
men du kan bare gå tilbake én ting maksimalt.

294
00:17:38,030 --> 00:17:42,760
Men her vi ønsker sscanf å returnere meg kanskje en int, et desimaltall,

295
00:17:42,760 --> 00:17:46,220
og også en røye, og jeg skal forklare hvorfor røye i et øyeblikk.

296
00:17:46,220 --> 00:17:51,460
Du effektivt vil sscanf å returnere to ting, men det er bare ikke mulig i C.

297
00:17:51,460 --> 00:17:55,200
Du kan omgå det ved å sende inn to adresser

298
00:17:55,200 --> 00:17:57,370
fordi så snart du hånden en funksjon to adresser,

299
00:17:57,370 --> 00:18:00,470
hva kan denne funksjonen gjøre med dem? >> [Student] Skriv til disse adressene.

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

301
00:18:02,010 --> 00:18:05,770
Du kan bruke stjerne drift og gå dit, til hver av disse adressene.

302
00:18:05,770 --> 00:18:11,260
Det er liksom dette bakdør mekanisme, men svært vanlig for å endre verdiene av variablene

303
00:18:11,260 --> 00:18:14,870
mer enn bare ett sted - i dette tilfellet, to.

304
00:18:14,870 --> 00:18:21,340
Nå merker jeg sjekker for == 1 og deretter retur n hvis det ikke faktisk vurdere å true.

305
00:18:21,340 --> 00:18:26,170
Så hva er det som skjer? Teknisk sett er alt vi virkelig ønsker å skje i GetInt dette.

306
00:18:26,170 --> 00:18:30,740
Vi ønsker å analysere, så å si, ønsker vi å lese strengen - sitat-unquote 123 -

307
00:18:30,740 --> 00:18:34,560
og hvis det ser ut som det er en rekke det, hva vi forteller sscanf å gjøre

308
00:18:34,560 --> 00:18:38,190
er satt som nummer - 123 - i denne variabelen n for meg.

309
00:18:38,190 --> 00:18:42,090
Så hvorfor da fikk jeg faktisk har dette også?

310
00:18:42,090 --> 00:18:48,220
Hva er rollen til sscanf sier du kan også få en karakter her?

311
00:18:48,220 --> 00:18:53,470
[Uhørlig student respons] >> En desimaltegn faktisk kan fungere.

312
00:18:53,470 --> 00:18:56,330
La oss holde det trodde et øyeblikk. Hva annet?

313
00:18:56,330 --> 00:18:59,270
[Student] Det kan være NULL. >> God tanke. Det kan være null karakter.

314
00:18:59,270 --> 00:19:01,660
Det er faktisk ikke i dette tilfellet. Ja. >> [Student] ASCII.

315
00:19:01,660 --> 00:19:04,340
ASCII. Eller la meg generalisere ytterligere.

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

317
00:19:06,640 --> 00:19:09,300
Vi ønsker ikke at det skal være et tegn etter tallet,

318
00:19:09,300 --> 00:19:11,870
men hva dette tillater meg å gjøre er følgende.

319
00:19:11,870 --> 00:19:18,210
Det viser seg at sscanf, foruten lagring verdier i n og c i dette eksemplet her,

320
00:19:18,210 --> 00:19:24,890
hva det også gjør er det returnerer antall variabler det satt verdier i.

321
00:19:24,890 --> 00:19:30,260
Så hvis du bare skriver i 123, da bare% d kommer til å matche,

322
00:19:30,260 --> 00:19:33,880
og bare n blir lagret med en verdi som 123,

323
00:19:33,880 --> 00:19:35,640
og ingenting blir satt i ca.

324
00:19:35,640 --> 00:19:37,620
C er fortsatt en søppel verdi, så å si -

325
00:19:37,620 --> 00:19:40,730
søppel fordi den aldri har blitt initialisert til en viss verdi.

326
00:19:40,730 --> 00:19:45,520
Så i dette tilfellet, returnerer sscanf 1 fordi jeg befolkede en av disse pekere,

327
00:19:45,520 --> 00:19:50,190
i så fall flott, jeg har en int, så jeg frigjøre linjen for å frigjøre minne

328
00:19:50,190 --> 00:19:54,000
at GetString faktisk tildelt, og da jeg kommer tilbake n,

329
00:19:54,000 --> 00:19:58,500
annet hvis du noen gang lurt på hvor den Retry uttalelsen kommer fra, kommer det fra høyre her.

330
00:19:58,500 --> 00:20:04,390
Så hvis, derimot, skriver jeg i 123foo - bare noen tilfeldige sekvens av tekst -

331
00:20:04,390 --> 00:20:08,490
sscanf kommer til å se, antall, nummer, f,

332
00:20:08,490 --> 00:20:16,410
og det kommer til å sette 123 i n, det kommer til å sette f i c og deretter gå tilbake to.

333
00:20:16,410 --> 00:20:20,640
Så vi har, bare ved hjelp av grunnleggende definisjonen av sscanf oppførsel, en veldig enkel måte -

334
00:20:20,640 --> 00:20:23,900
vel, komplekse ved første øyekast, men ved slutten av dagen ganske enkel mekanisme -

335
00:20:23,900 --> 00:20:28,320
å si er det en int og hvis så, er at det eneste som jeg fant?

336
00:20:28,320 --> 00:20:29,860
Og de tomme her er bevisst.

337
00:20:29,860 --> 00:20:34,000
Hvis du leser dokumentasjonen for sscanf, forteller det deg at hvis du inkluderer et stykke blanktegn

338
00:20:34,000 --> 00:20:38,810
på begynnelsen eller slutten, sscanf vil også tillate brukeren, uansett grunn,

339
00:20:38,810 --> 00:20:41,860
å treffe space bar 123 og som vil være legitime.

340
00:20:41,860 --> 00:20:44,150
Du vil ikke kjefte på brukeren bare fordi de treffer mellomromstasten

341
00:20:44,150 --> 00:20:48,640
på begynnelsen eller slutten, som er bare litt mer brukervennlig.

342
00:20:48,640 --> 00:20:52,300
>> Eventuelle spørsmål deretter på GetInt? Ja. >> [Student] Hva om du bare sette i en røye?

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

344
00:20:54,030 --> 00:20:59,890
Hva om du nettopp skrev i en røye som f og trykk Enter uten å skrive 123?

345
00:20:59,890 --> 00:21:02,420
Hva tror du oppførselen til denne linjen med kode vil da være?

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

347
00:21:04,730 --> 00:21:08,790
Ja, så sscanf kan dekke det også fordi i så fall, er det ikke kommer til å fylle n eller c.

348
00:21:08,790 --> 00:21:15,310
Det kommer til å i stedet returnere 0, og da er jeg også oppsiktsvekkende at scenario

349
00:21:15,310 --> 00:21:18,750
fordi den forventede verdien jeg ønsker er en.

350
00:21:18,750 --> 00:21:22,000
Jeg vil bare ha én og bare én ting å bli fylt. Godt spørsmål.

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

352
00:21:24,290 --> 00:21:26,250
>> La oss ikke gå gjennom alle funksjonene i her,

353
00:21:26,250 --> 00:21:29,500
men den som ser ut til å være kanskje av gjenværende interesse er GetString

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

355
00:21:32,790 --> 00:21:36,260
alle punt mye av sin funksjonalitet til GetString.

356
00:21:36,260 --> 00:21:39,750
Så la oss ta en titt på hvordan han er implementert her.

357
00:21:39,750 --> 00:21:43,630
Dette ser litt komplisert, men den bruker de samme grunnleggende

358
00:21:43,630 --> 00:21:45,670
at vi begynte å snakke om forrige uke.

359
00:21:45,670 --> 00:21:49,490
I GetString tar som ingen argument som per tomrommet opp her

360
00:21:49,490 --> 00:21:53,730
og den returnerer en streng, jeg tydeligvis er erklære en streng som heter buffer.

361
00:21:53,730 --> 00:21:56,270
Jeg vet egentlig ikke hva som kommer til å bli brukt til ennå, men vi får se.

362
00:21:56,270 --> 00:21:58,390
Det ser ut som kapasiteten er som standard 0.

363
00:21:58,390 --> 00:22:01,350
Ikke helt sikker på hvor dette går, ikke sikker på hva n kommer til å bli brukt til ennå,

364
00:22:01,350 --> 00:22:03,590
men nå er det å få en litt mer interessant.

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

366
00:22:06,520 --> 00:22:08,800
Dette er liksom en dum detalj.

367
00:22:08,800 --> 00:22:15,820
En røye er 8 bits, og 8 bits kan lagre hvor mange ulike verdier? >> [Student] 256. >> 256.

368
00:22:15,820 --> 00:22:20,730
Problemet er hvis du ønsker å ha 256 forskjellige ASCII-tegn, som det er

369
00:22:20,730 --> 00:22:23,340
Hvis du tenker tilbake - og dette er ikke noe å huske.

370
00:22:23,340 --> 00:22:25,710
Men hvis du tenker tilbake til den store ASCII diagrammet vi hadde uker siden,

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

372
00:22:30,600 --> 00:22:32,940
Vi brukte alle mønstre av 0'er og 1'ere opp.

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

374
00:22:36,210 --> 00:22:40,190
fordi hvis du allerede bruker 256 verdier for figurene dine,

375
00:22:40,190 --> 00:22:43,050
du egentlig ikke har tenkt fremover fordi nå har du ingen måte å si,

376
00:22:43,050 --> 00:22:46,270
dette er ikke en legit karakter, er dette noen feilaktige meldingen.

377
00:22:46,270 --> 00:22:50,270
Så hva verden gjør er at de bruker den neste største verdien, noe som en int,

378
00:22:50,270 --> 00:22:54,720
slik at du har en sprø antall biter, 32, for 4 milliard mulige verdier

379
00:22:54,720 --> 00:22:58,860
slik at du kan bare ende opp med å bruke hovedsak 257 av dem,

380
00:22:58,860 --> 00:23:01,720
1 som har noen spesiell betydning som en feil.

381
00:23:01,720 --> 00:23:03,120
>> Så la oss se hvordan dette fungerer.

382
00:23:03,120 --> 00:23:07,760
I tråd 246, har jeg denne store mens loop som ringer fgetc,

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

384
00:23:11,090 --> 00:23:15,520
Det viser seg at dette bare er mer presis måte å si lese inndata fra tastaturet.

385
00:23:15,520 --> 00:23:19,300
Standard inngang betyr tastatur, betyr standard ut skjermen,

386
00:23:19,300 --> 00:23:23,310
og standard feil, som vi vil se i pset4, betyr skjermen

387
00:23:23,310 --> 00:23:27,490
men en spesiell del av skjermen, slik at det ikke er smeltet sammen med den faktiske produksjonen

388
00:23:27,490 --> 00:23:30,750
at du hadde tenkt til å skrive ut. Men mer om det i fremtiden.

389
00:23:30,750 --> 00:23:34,440
Så fgetc betyr bare lese ett tegn fra tastaturet og lagrer det der?

390
00:23:34,440 --> 00:23:37,350
Oppbevar den i ca.

391
00:23:37,350 --> 00:23:41,360
Og deretter sjekke - så jeg bare bruker noen Boolske konjunksjoner her -

392
00:23:41,360 --> 00:23:46,000
sjekk at den ikke er lik - \ n, slik at brukeren har rammet inn, ønsker vi å stoppe på dette punktet,

393
00:23:46,000 --> 00:23:49,850
slutten av loopen - og vi ønsker også å se etter den spesielle konstant EOF,

394
00:23:49,850 --> 00:23:53,610
som hvis du vet eller antar, hva står for? >> [Student] Slutt på filen. >> Slutten av filen.

395
00:23:53,610 --> 00:23:56,560
Dette er slags nonsens, fordi hvis jeg skriver på tastaturet,

396
00:23:56,560 --> 00:23:58,870
det er egentlig ingen fil som er involvert i dette,

397
00:23:58,870 --> 00:24:01,150
men dette er liksom bare av den generelle termen brukes til å bety

398
00:24:01,150 --> 00:24:04,220
at ingenting annet kommer fra menneskelige fingre.

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

400
00:24:06,460 --> 00:24:09,920
Som en side, hvis du noen gang har truffet Kontroll D på tastaturet, ikke at du ville ha ennå -

401
00:24:09,920 --> 00:24:15,230
du har truffet Kontroll C - Control D sender denne spesielle konstant kalt EOF.

402
00:24:15,230 --> 00:24:19,850
Så nå er det bare noen dynamisk minne allokering.

403
00:24:19,850 --> 00:24:23,440
>> Så hvis (n + 1> kapasitet). Nå skal jeg forklare n.

404
00:24:23,440 --> 00:24:26,100
N er bare hvor mange byte er for tiden i buffer,

405
00:24:26,100 --> 00:24:28,620
strengen som du bygger opp fra brukeren.

406
00:24:28,620 --> 00:24:33,450
Hvis du har flere tegn i buffer din enn du har kapasitet i buffer,

407
00:24:33,450 --> 00:24:37,410
intuitivt hva vi trenger å gjøre da er tildele mer kapasitet.

408
00:24:37,410 --> 00:24:43,330
Så jeg kommer til å skumme over noen av aritmetiske her og fokusere bare på denne funksjonen her.

409
00:24:43,330 --> 00:24:46,070
Du vet hva malloc er eller er minst generelt kjent.

410
00:24:46,070 --> 00:24:48,970
Ta en gjetning hva RealLOC gjør. >> [Student] Legger minne.

411
00:24:48,970 --> 00:24:52,920
Det er ikke helt legge til minne. Det reallocates minne som følger.

412
00:24:52,920 --> 00:24:57,220
Hvis det fortsatt er plass på slutten av strengen for å gi deg mer av det minne

413
00:24:57,220 --> 00:25:00,000
enn det opprinnelig gir deg, så du får det ekstra minne.

414
00:25:00,000 --> 00:25:03,460
Så du kan bare fortsette å sette strengen karakterer rygg mot rygg til rygg mot rygg.

415
00:25:03,460 --> 00:25:05,830
Men hvis det ikke er tilfelle, fordi du ventet for lenge

416
00:25:05,830 --> 00:25:07,940
og noe tilfeldig fikk plopped i minnet der

417
00:25:07,940 --> 00:25:10,290
men det er ekstra minne her nede, det er greit.

418
00:25:10,290 --> 00:25:13,100
RealLOC kommer til å gjøre alle de tunge løftene for deg,

419
00:25:13,100 --> 00:25:16,750
flytte strengen du har lest i så langt herfra, legg det ned der,

420
00:25:16,750 --> 00:25:19,460
og deretter gi deg litt mer rullebanen på det tidspunktet.

421
00:25:19,460 --> 00:25:22,550
>> Så med en bølge av hånden, la meg si at det GetString gjør

422
00:25:22,550 --> 00:25:26,330
er det å starte med en liten buffer, kanskje en enkelt karakter,

423
00:25:26,330 --> 00:25:30,820
og hvis brukeren skriver inn to tegn, ender GetString opp med å kalle RealLOC og sier

424
00:25:30,820 --> 00:25:33,150
ett tegn var ikke nok, gi meg to tegn.

425
00:25:33,150 --> 00:25:35,950
Så hvis du leser gjennom logikken i loop, det kommer til å si

426
00:25:35,950 --> 00:25:39,600
brukeren har skrevet i tre tegn, gi meg nå ikke 2, men 4 tegn,

427
00:25:39,600 --> 00:25:42,320
så gi meg 8, og deretter gi meg 16 og 32.

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

429
00:25:45,000 --> 00:25:48,570
betyr at bufferen ikke kommer til å vokse sakte, det kommer til å vokse super fort.

430
00:25:48,570 --> 00:25:51,380
Og hva som kan være fordelen av det?

431
00:25:51,380 --> 00:25:54,600
Hvorfor jeg doble størrelsen på bufferen

432
00:25:54,600 --> 00:25:58,020
selv om brukeren kan bare trenger én ekstra tegn på tastaturet?

433
00:25:58,020 --> 00:26:01,750
[Uhørlig student respons] >> Hva er det? >> [Student] Du trenger ikke å dyrke den så ofte.

434
00:26:01,750 --> 00:26:03,300
Akkurat. Du trenger ikke å dyrke den så ofte.

435
00:26:03,300 --> 00:26:05,510
Og dette er bare slags du sikring dine spill her,

436
00:26:05,510 --> 00:26:10,850
ideen er at du ikke ønsker å kalle RealLOC mye fordi det har en tendens til å være treg.

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

438
00:26:12,910 --> 00:26:16,990
som du vil snart se i en fremtidig problem sett, pleier det å ta litt tid.

439
00:26:16,990 --> 00:26:20,010
Så minimere den tiden, selv om du kaster bort litt plass,

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

441
00:26:21,900 --> 00:26:24,060
>> Men hvis vi leser gjennom den avsluttende delen av GetString her -

442
00:26:24,060 --> 00:26:27,950
og igjen forstå hver enkelt linje her er ikke så viktig i dag -

443
00:26:27,950 --> 00:26:30,530
legge merke til at det til slutt kaller malloc igjen

444
00:26:30,530 --> 00:26:33,880
og den fordeler akkurat som mange bytes som det er behov for streng

445
00:26:33,880 --> 00:26:38,060
og kaster deretter bort ved å ringe gratis overdrevet store buffer

446
00:26:38,060 --> 00:26:40,080
hvis det faktisk ble doblet for mange ganger.

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

448
00:26:42,730 --> 00:26:47,060
Alt den gjør er lest ett tegn om gangen igjen og igjen og igjen,

449
00:26:47,060 --> 00:26:50,750
og hver gang det er behov for noen ekstra minne, spør den operativsystemet for det

450
00:26:50,750 --> 00:26:53,670
ved å ringe RealLOC.

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

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

453
00:26:59,270 --> 00:27:04,060
Nå som vi forstår pekere eller i det minste blir stadig kjent med pekere,

454
00:27:04,060 --> 00:27:06,700
la oss vurdere hvordan hele verden begynner å kollapse

455
00:27:06,700 --> 00:27:10,030
Hvis du ikke helt forsvare seg mot fiendtlige brukere,

456
00:27:10,030 --> 00:27:11,850
folk som prøver å hacke seg inn i systemet ditt,

457
00:27:11,850 --> 00:27:16,890
folk som prøver å stjele programvare ved å omgå noen registreringskode

458
00:27:16,890 --> 00:27:19,090
at de kanskje ellers å skrive i.

459
00:27:19,090 --> 00:27:22,990
>> Ta en titt på dette eksempelet her, som er bare C-kode som har en funksjon viktigste nederst

460
00:27:22,990 --> 00:27:26,380
som kaller en funksjon foo. Og hva er det passerer til foo?

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

462
00:27:29,680 --> 00:27:33,450
Så argv [1], som betyr det første ordet som brukeren har skrevet på kommandolinjen

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

464
00:27:36,360 --> 00:27:41,680
Så Foo på toppen tar i en char *. Men char * er akkurat hva? >> [Student] En streng.

465
00:27:41,680 --> 00:27:43,350
[Malan] En streng, så det er ikke noe nytt her.

466
00:27:43,350 --> 00:27:45,420
Strengen er vilkårlig å bli kalt bar.

467
00:27:45,420 --> 00:27:51,430
I denne linjen her, røye c [12], i form av semi-teknisk engelsk, hva denne linjen gjør?

468
00:27:51,430 --> 00:27:55,220
[Student] En rekke - >> Array av? >> [Student] tegn. >> Tegn.

469
00:27:55,220 --> 00:27:58,870
Gi meg en rekke 12 tegn. Så vi kan kalle dette en buffer.

470
00:27:58,870 --> 00:28:02,920
Det er teknisk kalt c, men en buffer i programmering betyr bare en haug med plass

471
00:28:02,920 --> 00:28:04,800
at du kan sette noen ting i.

472
00:28:04,800 --> 00:28:07,940
Så til slutt, memcpy vi ikke har brukt før, men du kan sikkert gjette hva det gjør.

473
00:28:07,940 --> 00:28:10,480
Det kopierer minnet. Hva gjør den?

474
00:28:10,480 --> 00:28:19,270
Det tilsynelatende kopierer bar, sin inngang, i c, men bare opp til lengden på baren.

475
00:28:19,270 --> 00:28:24,930
Men det er en feil her. >> [Student] Du trenger sizeof karakter. >> Ok.

476
00:28:24,930 --> 00:28:30,860
Teknisk sett bør vi egentlig gjøre strlen (bar) * sizeof (char)). Det er riktig.

477
00:28:30,860 --> 00:28:33,930
Men i verste tilfelle her, la oss anta at that -

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

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

480
00:28:39,160 --> 00:28:41,290
La oss gjøre dette litt bredere.

481
00:28:41,290 --> 00:28:44,910
Så nå er det fortsatt en bug, som er hva? >> [Uhørlig student respons]

482
00:28:44,910 --> 00:28:46,990
Sjekk for hva? >> [Student] Sjekk for NULL.

483
00:28:46,990 --> 00:28:50,270
Vi bør generelt være sjekker for NULL fordi dårlige ting skjer

484
00:28:50,270 --> 00:28:53,200
når pekeren er NULL fordi du kan ende opp med å gå der,

485
00:28:53,200 --> 00:28:57,630
og du ikke skulle gå til NULL ved dereferencing det med stjernen operatør.

486
00:28:57,630 --> 00:29:01,050
Så det er bra. Og hva annet gjør vi? Logisk, det er en feil her også.

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

488
00:29:04,450 --> 00:29:10,550
Så sjekk om argc er> = 2. Ok, så det er tre feil i dette programmet her.

489
00:29:10,550 --> 00:29:16,630
Vi overvåker nå sjekke om brukeren faktisk skrevet i noe inn argv [1]. Bra.

490
00:29:16,630 --> 00:29:20,950
Så hva er den tredje bug? Ja. >> [Student] C er kanskje ikke stor nok.

491
00:29:20,950 --> 00:29:23,320
Bra. Vi sjekket ett scenario.

492
00:29:23,320 --> 00:29:29,520
Vi implisitt sjekket ikke kopier mer minne enn det som ville overskride lengden bar.

493
00:29:29,520 --> 00:29:32,510
Så hvis strengen brukeren skrev inn er 10 tegn lang,

494
00:29:32,510 --> 00:29:36,020
dette sier bare kopiere 10 tegn. Og det er greit.

495
00:29:36,020 --> 00:29:39,940
Men hva om brukeren har skrevet inn et ord når du får beskjeden som en 20-tegns ord?

496
00:29:39,940 --> 00:29:44,900
Dette sier kopien 20 tegn fra bar til hva?

497
00:29:44,900 --> 00:29:49,750
C, ellers kjent som buffer vår, noe som betyr at du nettopp skrev data

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

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

500
00:29:54,870 --> 00:30:00,370
Så dette er hva som vanligvis kjent som buffer overflow angrep eller bufferoverløp angrep.

501
00:30:00,370 --> 00:30:05,580
Og det er et angrep i den forstand at hvis brukeren eller programmet som ringer din funksjon

502
00:30:05,580 --> 00:30:10,490
gjør dette skadelig, hva som faktisk skjer neste kan faktisk være ganske dårlig.

503
00:30:10,490 --> 00:30:12,450
>> Så la oss ta en titt på dette bildet her.

504
00:30:12,450 --> 00:30:16,060
Dette bildet representerer bunke med minne.

505
00:30:16,060 --> 00:30:19,580
Husker at hver gang du ringer en funksjon du får denne lille rammen på stakken

506
00:30:19,580 --> 00:30:21,520
og deretter en annen og deretter en annen og en annen.

507
00:30:21,520 --> 00:30:24,300
Og så langt, har vi bare slags abstrahert disse som rektangler

508
00:30:24,300 --> 00:30:26,290
enten på styret eller på skjermen her.

509
00:30:26,290 --> 00:30:30,580
Men hvis vi zoomer inn på en av disse rektangler, når du ringer en funksjon foo,

510
00:30:30,580 --> 00:30:35,880
det viser seg at det er mer på stakken innsiden av rammen i at rektangelet

511
00:30:35,880 --> 00:30:40,060
enn bare x-og y-og a og b, som vi gjorde snakker om swap.

512
00:30:40,060 --> 00:30:44,410
Det viser seg at det er noen lavere nivå detaljer, blant dem Returadresse.

513
00:30:44,410 --> 00:30:49,550
Så det viser seg når main kaller foo, har viktigste å informere Foo

514
00:30:49,550 --> 00:30:53,520
hva main adresse er i datamaskinens minne

515
00:30:53,520 --> 00:30:57,770
fordi ellers er så snart Foo gjort utfører, som i dette tilfelle her,

516
00:30:57,770 --> 00:31:00,830
Når du når dette lukkede krøllete brace på slutten av foo,

517
00:31:00,830 --> 00:31:05,310
hvordan pokker vet foo hvor kontrollen av programmet er ment å gå?

518
00:31:05,310 --> 00:31:08,970
Det viser seg at svaret på det spørsmålet er i denne røde rektangelet her.

519
00:31:08,970 --> 00:31:12,670
Dette representerer en peker, og det er opp til datamaskinen for å lagre midlertidig

520
00:31:12,670 --> 00:31:17,030
på den såkalte stabel adressen main slik at så snart Foo gjøres utfører,

521
00:31:17,030 --> 00:31:21,120
maskinen vet hvor og hvilken linje i hoved å gå tilbake til.

522
00:31:21,120 --> 00:31:23,940
Lagret Ramme pekeren vedrører tilsvarende til dette.

523
00:31:23,940 --> 00:31:26,310
Char * bar her representerer hva?

524
00:31:26,310 --> 00:31:31,350
Nå er dette blå segmentet er her Foo ramme. Hva er bar?

525
00:31:31,570 --> 00:31:35,010
Baren er bare argumentet til foo funksjonen.

526
00:31:35,010 --> 00:31:37,500
Så nå er vi tilbake på liksom den kjente bildet.

527
00:31:37,500 --> 00:31:39,850
Det er flere ting og flere distraksjoner på skjermen,

528
00:31:39,850 --> 00:31:43,380
men dette lyseblå segmentet er akkurat hva vi har å tegne på tavlen

529
00:31:43,380 --> 00:31:45,790
for noe sånt swap. Det er rammen for foo.

530
00:31:45,790 --> 00:31:51,490
Og det eneste i det akkurat nå er bar, som er denne parameteren.

531
00:31:51,490 --> 00:31:55,220
Men hva annet bør være i bunken i henhold til denne koden her?

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

533
00:31:57,760 --> 00:32:02,810
Vi bør også se 12 ruter minne som er tildelt en variabel kalt c,

534
00:32:02,810 --> 00:32:04,970
og faktisk vi ikke har det på skjermen.

535
00:32:04,970 --> 00:32:08,480
Helt øverst er det c [0], og deretter forfatteren av dette diagrammet

536
00:32:08,480 --> 00:32:11,850
ikke bry tegne alle rutene, men det er faktisk 12 der

537
00:32:11,850 --> 00:32:16,590
fordi hvis du ser nederst til høyre, c [11] hvis du teller fra 0 er den 12. slik 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 er c vokser?

540
00:32:22,390 --> 00:32:27,080
Sortering av toppen og ned hvis det begynner på toppen og vokser til bunnen.

541
00:32:27,080 --> 00:32:30,110
Det ser ikke ut som vi forlot oss mye rullebane her i det hele tatt.

542
00:32:30,110 --> 00:32:32,090
Vi har slags malt oss inn i et hjørne,

543
00:32:32,090 --> 00:32:36,940
og at c [11] er helt opp mot bar, som ligger rett opp mot Lagret Frame pekeren,

544
00:32:36,940 --> 00:32:39,960
som er rett opp mot Returadresse. Det er ikke mer plass.

545
00:32:39,960 --> 00:32:42,810
Så hva er konsekvensen så hvis du skru opp

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

547
00:32:46,500 --> 00:32:50,060
Hvor er de åtte flere byte kommer til å gå? >> [Student] Inside -

548
00:32:50,060 --> 00:32:53,200
Inne alt annet, er noen av dem super viktig.

549
00:32:53,200 --> 00:32:57,260
Og det viktigste, potensielt, er den røde boksen der, Returadresse,

550
00:32:57,260 --> 00:33:03,560
fordi anta at du enten ved et uhell eller adversarially overskrive de 4 bytes,

551
00:33:03,560 --> 00:33:07,260
at pekeren adresse, ikke bare med søppel, men med et antall

552
00:33:07,260 --> 00:33:09,810
som skjer for å representere en faktisk adresse i minnet.

553
00:33:09,810 --> 00:33:13,880
Hva er konsekvensen, logisk? >> [Student] Funksjon kommer til å gå tilbake til et annet sted.

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

555
00:33:15,250 --> 00:33:19,170
Når foo avkastning og treff som krøllete brace, er programmet kommer til å fortsette

556
00:33:19,170 --> 00:33:25,060
ikke å gå tilbake til hovedsiden, kommer det til å gå tilbake til hva adressen er i det røde boksen.

557
00:33:25,060 --> 00:33:28,600
>> I tilfelle av omgå programvare registrering,

558
00:33:28,600 --> 00:33:32,260
hva hvis adressen som blir returnert til er den funksjonen som normalt blir kalt

559
00:33:32,260 --> 00:33:35,690
etter at du har betalt for programvaren og lagt inn din registreringskode?

560
00:33:35,690 --> 00:33:39,870
Du kan liksom lure datamaskinen i å ikke gå her, men i stedet kommer opp her.

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

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

563
00:33:50,690 --> 00:33:52,770
enkelte tegn som representerer koden.

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

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

566
00:33:59,290 --> 00:34:01,290
Men antar de er smarte nok til å gjøre det,

567
00:34:01,290 --> 00:34:06,500
å liksom lime inn i GetString rask noe som er egentlig kompilert kode,

568
00:34:06,500 --> 00:34:09,980
og de siste 4 byte overskrive returadresse.

569
00:34:09,980 --> 00:34:13,360
Og hva adressen ikke at innspill gjøre?

570
00:34:13,360 --> 00:34:18,630
Den lagrer faktisk i denne røde rektangelet adressen til den første byte i buffer.

571
00:34:18,630 --> 00:34:23,070
Så du må være veldig flink, og dette er en mye prøving og feiling for dårlige mennesker der ute,

572
00:34:23,070 --> 00:34:25,639
men hvis du kan finne ut hvor stor denne bufferen er

573
00:34:25,639 --> 00:34:28,820
slik at de siste få byte i inngangen du gir til programmet

574
00:34:28,820 --> 00:34:33,540
skje for å være tilsvarende adressen til starten av bufferen, kan du gjøre dette.

575
00:34:33,540 --> 00:34:39,320
Hvis vi sier normalt hei og \ 0, er at hva som ender opp i bufferen.

576
00:34:39,320 --> 00:34:44,420
Men hvis vi er mer smart og fylle vi at buffer med hva vi vil generelt kaller angrep kode -

577
00:34:44,420 --> 00:34:48,860
AAA, angrep, angrep, angrep - der dette er bare noe som gjør noe dårlig,

578
00:34:48,860 --> 00:34:51,820
hva skjer hvis du er virkelig flink, kan du gjøre dette.

579
00:34:51,820 --> 00:34:58,610
I den røde boksen her er en sekvens av tall - 80, C0, 35, 08.

580
00:34:58,610 --> 00:35:01,610
Legg merke til at det samsvarer med tall som er her oppe.

581
00:35:01,610 --> 00:35:04,430
Det er i motsatt rekkefølge, men mer om det en annen gang.

582
00:35:04,430 --> 00:35:08,140
Legg merke til at denne avkastningen adressen er bevisst endret

583
00:35:08,140 --> 00:35:12,020
til lik adresse her oppe, ikke adressen til main.

584
00:35:12,020 --> 00:35:17,500
Så hvis skurken er super smart, er han eller hun kommer til å inkludere i det angrepet kode

585
00:35:17,500 --> 00:35:20,930
noe som sletter alle brukerens filer eller kopiere passord

586
00:35:20,930 --> 00:35:24,680
eller opprette en brukerkonto som jeg kan deretter logge deg på - noe som helst.

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

588
00:35:26,950 --> 00:35:29,840
Fordi du har tilgang til minnet via pekere

589
00:35:29,840 --> 00:35:32,520
og du kan derfor skrive alt du vil inn i datamaskinens minne,

590
00:35:32,520 --> 00:35:35,080
du kan gjøre en datamaskin gjøre hva du vil

591
00:35:35,080 --> 00:35:39,550
bare ved å ha den til å hoppe rundt i sin egen plass i minnet.

592
00:35:39,550 --> 00:35:44,650
Og så til denne dagen så mange programmer og så mange nettsteder som er kompromittert

593
00:35:44,650 --> 00:35:46,200
koke ned til folk som tar seg av dette.

594
00:35:46,200 --> 00:35:50,760
Og dette kan virke som en super sofistikert angrep, men det er ikke alltid starte på den måten.

595
00:35:50,760 --> 00:35:53,560
Realiteten er at det dårlige mennesker vil vanligvis gjør er,

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

597
00:35:58,200 --> 00:35:59,940
du bare begynne å tilby tull.

598
00:35:59,940 --> 00:36:03,980
Du skriver i en virkelig store ord i søkefeltet og trykke Enter,

599
00:36:03,980 --> 00:36:05,780
og du vente å se om nettstedet krasjer

600
00:36:05,780 --> 00:36:09,990
eller du vente å se om programmet manifesterer noen feilmelding

601
00:36:09,990 --> 00:36:14,330
fordi hvis du får heldig som skurken og du gi noen sprø innspill

602
00:36:14,330 --> 00:36:18,980
som krasjer programmet, som betyr at programmereren ikke forutse din dårlig oppførsel,

603
00:36:18,980 --> 00:36:23,630
som betyr at du kan sannsynligvis med nok innsats, nok prøving og feiling,

604
00:36:23,630 --> 00:36:26,650
finne ut hvordan å føre en mer presis angrep.

605
00:36:26,650 --> 00:36:31,410
Så like mye en del av sikkerhet er ikke bare å unngå disse angrepene helt

606
00:36:31,410 --> 00:36:34,100
men registrerer dem og faktisk ser på loggene

607
00:36:34,100 --> 00:36:36,780
og se hva gale innganger har folk skrevet inn i din webside,

608
00:36:36,780 --> 00:36:38,960
hvilke ord har folk skrevet inn i din webside

609
00:36:38,960 --> 00:36:42,870
i håp om overfylte noen buffer.

610
00:36:42,870 --> 00:36:45,500
Og alt dette koker ned til det enkle grunnleggende for hva som er en matrise

611
00:36:45,500 --> 00:36:49,080
og hva betyr det å allokere og bruke minne.

612
00:36:49,080 --> 00:36:51,710
>> Relatert til dette så altfor er dette.

613
00:36:51,710 --> 00:36:54,280
La oss bare se innsiden av en harddisk enda en gang.

614
00:36:54,280 --> 00:36:58,440
Du husker fra en uke eller to siden at når du drar filer til papirkurven eller papirkurven kan,

615
00:36:58,440 --> 00:37:03,710
hva skjer? >> [Student] Ingenting. >> Absolutt ingenting, ikke sant?

616
00:37:03,710 --> 00:37:05,740
Slutt hvis du kjører lite diskplass,

617
00:37:05,740 --> 00:37:08,190
Windows eller Mac OS vil begynne å slette filene for deg.

618
00:37:08,190 --> 00:37:10,390
Men hvis du drar noe der inne, er det ikke i det hele tatt trygt.

619
00:37:10,390 --> 00:37:13,800
All din samboer eller venn eller et familiemedlem har å gjøre er å klikke dobbelt, og voila,

620
00:37:13,800 --> 00:37:16,310
det er alle de sketchy filer som du prøvde å slette.

621
00:37:16,310 --> 00:37:19,590
De fleste av oss i det minste vite at du må høyreklikke eller Kontroll-klikk

622
00:37:19,590 --> 00:37:22,310
og tømme papirkurven eller noe sånt.

623
00:37:22,310 --> 00:37:25,000
Men selv da det ikke gjøre ganske triks

624
00:37:25,000 --> 00:37:28,010
fordi hva som skjer når du har en fil på harddisken din

625
00:37:28,010 --> 00:37:32,770
som representerer noen Word-dokument eller noen JPEG, og dette representerer harddisken din,

626
00:37:32,770 --> 00:37:35,350
og la oss si at dette sliver her representerer den filen,

627
00:37:35,350 --> 00:37:38,390
og det er sammensatt av en hel haug med 0'er og 1'ere.

628
00:37:38,390 --> 00:37:42,470
Hva skjer når du ikke bare dra filen til papirkurven kan eller resirkulere bin

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

630
00:37:48,020 --> 00:37:49,640
Det er ikke absolutt ingenting nå.

631
00:37:49,640 --> 00:37:54,290
Nå er det bare ingenting fordi en liten noe skjer i form av denne tabellen.

632
00:37:54,290 --> 00:37:58,370
Så det er en slags database eller tabell på innsiden av en datamaskin minne

633
00:37:58,370 --> 00:38:03,850
som har vesentlig én kolonne for filer navn og en kolonne for filer 'plassering,

634
00:38:03,850 --> 00:38:07,720
hvor dette kan være plassering 123, bare et tilfeldig nummer.

635
00:38:07,720 --> 00:38:14,560
Så vi kan ha noe som x.jpeg og plassering 123.

636
00:38:14,560 --> 00:38:18,800
Hva skjer så når du faktisk tømme papirkurven?

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

638
00:38:20,330 --> 00:38:23,610
Men hva går ikke bort er 0'er og 1'ere.

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

640
00:38:26,270 --> 00:38:31,240
Vel, med pset4, bare fordi vi har et uhell slettet compact flash-kort

641
00:38:31,240 --> 00:38:35,750
som hadde alle disse bildene, eller bare fordi det ved uflaks ble ødelagt

642
00:38:35,750 --> 00:38:38,000
betyr ikke at 0'er og 1'ere er ikke der ennå.

643
00:38:38,000 --> 00:38:40,410
Kanskje noen av dem er tapt fordi noe ble ødelagt

644
00:38:40,410 --> 00:38:43,320
i den forstand at noen 0s ble 1s og 1'ere ble 0s.

645
00:38:43,320 --> 00:38:47,240
Dårlige ting kan skje på grunn av buggy programvare eller defekt maskinvare.

646
00:38:47,240 --> 00:38:50,370
Men mange av disse bitene, kanskje 100% av dem, er der fremdeles.

647
00:38:50,370 --> 00:38:55,050
Det er bare det at datamaskinen eller kameraet ikke vet hvor JPEG1 startet

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

649
00:38:56,910 --> 00:39:01,070
Men hvis du, programmerer, vet med litt peiling hvor disse JPEG er

650
00:39:01,070 --> 00:39:06,010
eller hvordan de ser ut, slik at du kan analysere 0'er og 1'ere og si JPEG, JPEG,

651
00:39:06,010 --> 00:39:09,440
Du kan skrive et program med egentlig bare en for eller mens loop

652
00:39:09,440 --> 00:39:12,820
som gjenoppretter hver og en av disse filene.

653
00:39:12,820 --> 00:39:16,030
Så lærdommen er da å begynne sikkert slette filene dine

654
00:39:16,030 --> 00:39:18,340
Hvis du ønsker å unngå dette helt. Ja.

655
00:39:18,340 --> 00:39:21,010
>> [Student] Hvordan kommer det står på din datamaskin

656
00:39:21,010 --> 00:39:23,550
at du har mer minne enn du gjorde før?

657
00:39:23,550 --> 00:39:27,820
Ha mer minne enn du gjorde før - >> [student] Mer tilgjengelig minne.

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

659
00:39:29,630 --> 00:39:32,360
Så hvorfor da etter tømming av søppel forteller datamaskinen du

660
00:39:32,360 --> 00:39:34,910
at du har mer ledig plass enn du gjorde før?

661
00:39:34,910 --> 00:39:36,770
I et nøtteskall, fordi det lyver.

662
00:39:36,770 --> 00:39:40,740
Mer teknisk, har du mer plass fordi du nå har sagt

663
00:39:40,740 --> 00:39:43,680
du kan sette andre ting der filen en gang var.

664
00:39:43,680 --> 00:39:45,450
Men det betyr ikke at de biter går bort,

665
00:39:45,450 --> 00:39:48,590
og det betyr ikke at bitene blir endret til alle 0s, for eksempel,

666
00:39:48,590 --> 00:39:50,150
for å beskytte deg.

667
00:39:50,150 --> 00:39:54,640
Så derimot, hvis du sikkert slette filer eller fysisk ødelegge enheten,

668
00:39:54,640 --> 00:39:57,300
det er virkelig den eneste måten noen ganger rundt det.

669
00:39:57,300 --> 00:40:02,020
>> Så hvorfor ikke vi la på at semi-skremmende notat, og vi vil se deg på mandag.

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

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