1
00:00:00,000 --> 00:00:02,760
[Powered by Google Translate] [UKE 5]

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

3
00:00:04,760 --> 00:00:11,990
[Dette er CS50.] [CS50.TV]

4
00:00:11,990 --> 00:00:17,780
[Voksen] Han lyver, om hva, vet jeg ikke.

5
00:00:17,780 --> 00:00:20,300
[Man] Så hva vet vi?

6
00:00:20,300 --> 00:00:24,120
[Woman] That på 9:15, Ray Santoya var på ATM.

7
00:00:24,120 --> 00:00:27,420
[Man] Så spørsmålet er, hva han gjorde på 9:16?

8
00:00:27,420 --> 00:00:29,980
[Kvinne] Skyting på 9 mm på noe.

9
00:00:29,980 --> 00:00:31,900
Kanskje han så snikskytter.

10
00:00:31,900 --> 00:00:34,000
[Man] Eller han jobbet med ham.

11
00:00:34,000 --> 00:00:36,330
[Voksen] Vent. Gå tilbake ett.

12
00:00:36,330 --> 00:00:38,330
[Man] Hva ser du?

13
00:00:38,330 --> 00:00:44,520
[♫ Spennende musikk ♫]

14
00:00:44,520 --> 00:00:48,320
[Voksen] Ta ansiktet opp. Full skjerm.

15
00:00:48,320 --> 00:00:51,230
[Man] brillene. >> Det er en refleksjon.

16
00:00:51,230 --> 00:01:00,810
[♫ Spennende musikk ♫]

17
00:01:00,810 --> 00:01:03,580
[Man] Det er Nuevita baseball team. Det er deres logo.

18
00:01:03,580 --> 00:01:07,790
[Kvinne] Og han snakker til den som har på seg den jakken.

19
00:01:07,790 --> 00:01:13,730
>> [David Malan] Så dette er CS50 uke 5, og i dag har vi ødelegge litt av TV og film for deg.

20
00:01:13,730 --> 00:01:16,170
Så når du ser et show som dette her,

21
00:01:16,170 --> 00:01:19,910
og politiet sier "Kan du rydde opp?" eller "Forbedre"

22
00:01:19,910 --> 00:01:21,900
det er ingen styrke i den virkelige verden.

23
00:01:21,900 --> 00:01:25,220
Faktisk, hva du egentlig får er en litt noe sånt som dette.

24
00:01:25,220 --> 00:01:27,570
Jeg har trukket opp en av de ansatte bildene fra siden.

25
00:01:27,570 --> 00:01:30,980
Dette er et program som heter Photoshop. Dette er en av to Bowdens,

26
00:01:30,980 --> 00:01:36,300
1 av 3 Bowdens faktisk, i dag, fordi vi har Mrs. Bowden her også, med Rob og Paul.

27
00:01:36,300 --> 00:01:41,950
Men her er Rob på skjermen, og hvis vi zoomer inn på den glimt han har alltid hatt i øyet,

28
00:01:41,950 --> 00:01:47,600
hva du faktisk ser er at det du ser er hva du får.

29
00:01:47,600 --> 00:01:51,690
Dette er "forbedret", så "CSI" har det litt galt.

30
00:01:51,690 --> 00:01:55,190
Det er en annen klipp, hvis vi kan plukke på "CSI" bare litt lenger.

31
00:01:55,190 --> 00:01:58,500
Dette er en fin setning å ytre heretter hvis du ønsker å

32
00:01:58,500 --> 00:02:10,280
høres teknisk med vennene dine når, egentlig, du sier absolutt ingenting.

33
00:02:10,280 --> 00:02:12,970
>> [Man] For ukene har jeg vært å undersøke Cabby Killer drapene

34
00:02:12,970 --> 00:02:15,360
med en viss morbid fascinasjon.

35
00:02:15,360 --> 00:02:17,160
[Woman # 1] Dette er i sanntid.

36
00:02:17,160 --> 00:02:22,930
[Woman # 2] Jeg skal lage et GUI-grensesnitt ved hjelp av Visual Basic, se om jeg kan spore en IP-adresse.

37
00:02:22,930 --> 00:02:29,570
>> [Malan] Så lyd ute av sync side, skaper en GUI grensesnitt ved hjelp av Visual Basic

38
00:02:29,570 --> 00:02:31,820
å spore en IP-adresse er fullstendig meningsløst.

39
00:02:31,820 --> 00:02:33,840
Disse dager du ikke ville bruke Visual Basic,

40
00:02:33,840 --> 00:02:38,920
Det er ikke behov for en GUI, og IP-adresse var en teknisk nøyaktige betegnelsen.

41
00:02:38,920 --> 00:02:41,730
Så hold et øye for disse, og en av mine favoritter:

42
00:02:41,730 --> 00:02:45,070
Dette er litt mer uforståelige, fordi du trenger å vite et annet språk.

43
00:02:45,070 --> 00:02:47,860
Det er et språk som kalles Objective-C, som er et overordnet C.

44
00:02:47,860 --> 00:02:51,960
Noe som betyr at det er C pluss noen ekstra funksjoner, blant dem objektorientert programmering.

45
00:02:51,960 --> 00:02:55,070
Og dette er det språket som Apple har popularisert for iOS programmering.

46
00:02:55,070 --> 00:02:58,760
Og så her et klipp fra et annet program helt, fra "Numbers"

47
00:02:58,760 --> 00:03:02,450
at hvis du faktisk ser nøye på TiVo og pause på riktig tidspunkt,

48
00:03:02,450 --> 00:03:07,700
vil du se at det de ser på er ikke helt hva som blir beskrevet.

49
00:03:07,700 --> 00:03:11,170
Og la meg prøve en annen lydkontakt her og se om vi ikke kan

50
00:03:11,170 --> 00:03:13,780
holde lyden i sync denne gangen.

51
00:03:13,780 --> 00:03:20,530
Jeg gir deg "Numbers".

52
00:03:20,530 --> 00:03:23,240
>> [Man # 1] Det er en 32-bit IPv4-adresse.

53
00:03:23,240 --> 00:03:38,930
[Man # 2] IP, som er Internett. >> Privat nettverk. Det er Anita private nettverk.

54
00:03:38,930 --> 00:03:43,810
[Malan] Okay. Dette er Objective-C, og det er for noen gutt coloring program,

55
00:03:43,810 --> 00:03:51,140
som du kan kanskje antyde fra navnet på variabelen der.

56
00:03:51,140 --> 00:03:54,410
Slik at da var "Numbers". Så i dag og denne uken introduserer vi

57
00:03:54,410 --> 00:03:57,740
en liten bit av verden forensics og konteksten i problemene derfor.

58
00:03:57,740 --> 00:04:00,590
I dag vil være en forkortet foredrag fordi det er en spesiell hendelse her

59
00:04:00,590 --> 00:04:05,530
etterpå, så vi får ta en titt, og erte både elever og foreldre alike dag

60
00:04:05,530 --> 00:04:07,420
med noen av de tingene som er på horisonten.

61
00:04:07,420 --> 00:04:12,240
Blant dem, og med mandag, vil du ha noen flere klassekamerater.

62
00:04:12,240 --> 00:04:16,050
EDX, Harvard og MITs nye online initiativ for åpen courseware

63
00:04:16,050 --> 00:04:19,120
og mer, lanserer på Harvard campus på mandag.

64
00:04:19,120 --> 00:04:21,490
Noe som betyr kommer mandag vil du ha - som i forrige telling,

65
00:04:21,490 --> 00:04:26,210
86000 flere klassekamerater skal følge sammen med CS50 foredrag

66
00:04:26,210 --> 00:04:29,170
og seksjoner og gjennomgang og øvingsoppgaver.

67
00:04:29,170 --> 00:04:32,350
Og som en del av dette, vil du bli medlemmer av innvielses klasse

68
00:04:32,350 --> 00:04:35,090
CS50 og nå CS50x.

69
00:04:35,090 --> 00:04:39,310
>> Som en del av dette, nå skjønner at det vil være noen oppsider også.

70
00:04:39,310 --> 00:04:43,790
Å bli klar for dette, for det massive antall studenter,

71
00:04:43,790 --> 00:04:47,180
nok det å si at selv om vi har 108 TFS og CAS,

72
00:04:47,180 --> 00:04:50,790
ikke helt den beste student / lærer ratio når vi treffer 80000 andre studenter.

73
00:04:50,790 --> 00:04:52,850
Så vi kommer ikke til å bli gradering så mange problem setter manuelt.

74
00:04:52,850 --> 00:04:55,920
Så introduserte denne uken i oppgavesettet vil være CS50 Check,

75
00:04:55,920 --> 00:04:58,450
som kommer til å bli en kommandolinje verktøy i apparatet

76
00:04:58,450 --> 00:05:01,200
at du får når du oppdatere den senere denne helgen,

77
00:05:01,200 --> 00:05:03,200
og du vil være i stand til å kjøre en kommando, sjekk 50,

78
00:05:03,200 --> 00:05:06,500
på din egen pset, og du får noen tilbakemelding på om programmet er

79
00:05:06,500 --> 00:05:11,160
riktig eller feil i henhold til ulike design spesifikasjoner som vi har gitt.

80
00:05:11,160 --> 00:05:13,580
Så mer på det, og problemet sett spesifikasjonen og

81
00:05:13,580 --> 00:05:17,240
de CS50x klassekamerater skal bruke dette også.

82
00:05:17,240 --> 00:05:19,230
>> Så problemet sett 4 handler om etterforskning.

83
00:05:19,230 --> 00:05:21,940
Og dette stykket var inspirert av noen virkelige ting,

84
00:05:21,940 --> 00:05:24,620
der da jeg var i gradsstudier, internert jeg for en stund med

85
00:05:24,620 --> 00:05:28,650
Middlesex Countys statsadvokat kontor gjør rettsmedisin

86
00:05:28,650 --> 00:05:31,650
med sin leder rettsmedisinske etterforsker, og hva dette utgjorde

87
00:05:31,650 --> 00:05:35,260
er, jeg tror jeg nevnte et par uke fortid, er massen State politiet eller andre

88
00:05:35,260 --> 00:05:39,000
ville komme inn, ville de slippe av ting som harddisker og CDer og disketter

89
00:05:39,000 --> 00:05:42,340
og lignende, og deretter mål forensics kontoret var å fastslå om

90
00:05:42,340 --> 00:05:44,600
det var eller ikke var bevis av noe slag.

91
00:05:44,600 --> 00:05:48,010
Dette var den Special Investigations Unit, så det var økonomisk kriminalitet,

92
00:05:48,010 --> 00:05:52,350
det var mer problematisk slags forbrytelser,

93
00:05:52,350 --> 00:05:55,990
noe som involverer noen form for digitale medier, viser seg at ikke så mange mennesker

94
00:05:55,990 --> 00:05:59,370
skrive en e-post som sier "jeg gjorde det."

95
00:05:59,370 --> 00:06:03,290
Så ganske ofte disse etterforskning søk ikke skru opp så mye frukt,

96
00:06:03,290 --> 00:06:05,850
men noen ganger folk ville skrive slike e-poster.

97
00:06:05,850 --> 00:06:08,490
Så noen ganger innsatsen ble belønnet.

98
00:06:08,490 --> 00:06:14,420
>> Men å lede opp til dette rettsmedisinske pset, vil vi innføre i pset 4 litt grafikk.

99
00:06:14,420 --> 00:06:18,260
Så du sannsynligvis ta disse tingene for gitt, JPEG, GIF og lignende i disse dager,

100
00:06:18,260 --> 00:06:21,640
men hvis du virkelig tenker over det, et bilde, omtrent som Rob ansikt,

101
00:06:21,640 --> 00:06:24,430
kunne bli modellert som en sekvens av punkter eller piksler.

102
00:06:24,430 --> 00:06:26,680
Nå, i tilfelle av Rob ansikt, er det alle slags farger,

103
00:06:26,680 --> 00:06:29,940
og vi begynte å se de enkelte punkter, otherwide kjent som piksler,

104
00:06:29,940 --> 00:06:31,610
når vi begynte å zoome inn

105
00:06:31,610 --> 00:06:35,590
Men hvis vi forenkle verden litt, og bare si at dette her er Rob

106
00:06:35,590 --> 00:06:40,560
i svart-hvitt, vel, til å representere svart og hvitt kan vi bare bruke binær.

107
00:06:40,560 --> 00:06:44,960
Og hvis vi kommer til å bruke binære, 1 eller 0, kan vi uttrykke dette samme bildet

108
00:06:44,960 --> 00:06:51,970
av Rob smilende ansikt med dette mønsteret av biter: 11000011 representerer

109
00:06:51,970 --> 00:06:55,160
hvit, hvit, svart, svart, svart, svart, hvit.

110
00:06:55,160 --> 00:06:59,290
Og så det er ikke et stort sprang, da, for å begynne å snakke om fargerike fotografier.

111
00:06:59,290 --> 00:07:01,920
Ting som du ville se på Facebook eller ta med et digitalt kamera,

112
00:07:01,920 --> 00:07:04,730
men, sikkert, når det kommer til farger, trenger du flere biter.

113
00:07:04,730 --> 00:07:08,470
Og ganske vanlig i verden av fotografier er å bruke ikke 1-bit farge,

114
00:07:08,470 --> 00:07:12,730
da dette antyder, men 24-bits farger, hvor du faktisk får millioner av farger.

115
00:07:12,730 --> 00:07:15,430
Så som i tilfelle når vi zoomet inn på Rob øye,

116
00:07:15,430 --> 00:07:19,270
det var en rekke av millioner av forskjellige fargerike muligheter.

117
00:07:19,270 --> 00:07:22,260
>> Så vi vil innføre dette i oppgavesettet 4 samt i walkthrough,

118
00:07:22,260 --> 00:07:27,050
som vil være i dag kl 03:30 i stedet for den vanlige 02:30 på grunn av fredagens foredrag her.

119
00:07:27,050 --> 00:07:29,930
Men videoen vil være online, som vanlig, i morgen.

120
00:07:29,930 --> 00:07:31,880
Vi vil også introdusere deg til et annet filformat.

121
00:07:31,880 --> 00:07:34,150
Så dette er bevisst ment å se skremmende i starten,

122
00:07:34,150 --> 00:07:38,980
men dette er bare noen dokumentasjon for en C struct.

123
00:07:38,980 --> 00:07:42,280
Det viser seg at Microsoft, år siden, hjalp popularisere dette formatet,

124
00:07:42,280 --> 00:07:46,630
kalt bitmap filformat, BMP, og dette var en super-enkel,

125
00:07:46,630 --> 00:07:50,390
fargerike grafiske filformat som ble brukt i ganske lang tid

126
00:07:50,390 --> 00:07:53,640
og noen ganger fortsatt for bakgrunnsbilder på stasjonære maskiner.

127
00:07:53,640 --> 00:07:57,410
Hvis du tenker tilbake til Windows XP og bølgende åser og blå himmel,

128
00:07:57,410 --> 00:08:00,660
som var typisk en BMP, eller punktgrafikkbilde, og punktgrafikk

129
00:08:00,660 --> 00:08:03,340
er moro for oss fordi de har litt mer kompleksitet.

130
00:08:03,340 --> 00:08:05,640
Det er ikke fullt så enkelt som dette rutenettet av 0 og 1-ere;

131
00:08:05,640 --> 00:08:10,680
stedet, har du ting som en overskrift i begynnelsen av en fil.

132
00:08:10,680 --> 00:08:15,520
Så med andre ord, inne i en. Bmp-fil er en hel haug av 0 og 1-ere,

133
00:08:15,520 --> 00:08:18,070
men det er litt ekstra 0 og 1-ere der.

134
00:08:18,070 --> 00:08:21,450
Og det viser seg at det vi har sikkert tatt for gitt i mange år,

135
00:08:21,450 --> 00:08:27,040
filformater som. doc eller. xls eller. mp3 eller. mp4,

136
00:08:27,040 --> 00:08:29,910
uansett filformater som du er kjent med.

137
00:08:29,910 --> 00:08:31,900
Vel, hva betyr det også bety å være et filformat?

138
00:08:31,900 --> 00:08:35,740
Fordi på slutten av dagen, alle disse filene vi bruker har bare 0 og 1-ere

139
00:08:35,740 --> 00:08:39,950
og kanskje de 0 og 1-ere representerer a, b, c, gjennom ASCII eller lignende,

140
00:08:39,950 --> 00:08:42,030
men gjennom slutten av dagen, er det bare 0 og 1-ere.

141
00:08:42,030 --> 00:08:45,300
>> Så mennesker bare sporadisk bestemmer seg for å oppfinne et nytt filformat

142
00:08:45,300 --> 00:08:49,420
hvor de standardisere hva punktmønstre faktisk vil bety.

143
00:08:49,420 --> 00:08:52,790
Og i dette tilfellet her, folk som designet bitmap filformat

144
00:08:52,790 --> 00:08:58,260
sa at i det første byte i en bitmap fil, som vist ved offset 0, der,

145
00:08:58,260 --> 00:09:02,320
det kommer til å være noen kryptisk navngitt variabel kalt bfType,

146
00:09:02,320 --> 00:09:06,510
som står bare for bitmap filtype, hva slags bitmap fil dette er.

147
00:09:06,510 --> 00:09:10,780
Du kan antyde, kanskje, fra den andre raden at offset 2, byte nummer 2,

148
00:09:10,780 --> 00:09:15,980
har et mønster av 0 og 1-ere som representerer hva?

149
00:09:15,980 --> 00:09:18,320
Størrelsen på noe, og det går derfra.

150
00:09:18,320 --> 00:09:20,660
Så i oppgavesettet 4, vil du bli gått gjennom noen av disse tingene.

151
00:09:20,660 --> 00:09:24,480
>> Vi vil ikke ende opp å bry seg om dem alle, men merker det begynner å bli interessant

152
00:09:24,480 --> 00:09:30,780
rundt linje eller byte 54, rgbtBlue, grønn og rød.

153
00:09:30,780 --> 00:09:35,280
Hvis du noen gang har hørt forkortelsen RGB, rød grønn blå, dette er en referanse til det.

154
00:09:35,280 --> 00:09:37,840
Fordi det viser seg at du kan male alle farger i regnbuen

155
00:09:37,840 --> 00:09:41,580
med en kombinasjon av rødt og blått og grønt.

156
00:09:41,580 --> 00:09:46,560
Og, faktisk, kan foreldrene i rommet husker noen av de tidligste projektorer.

157
00:09:46,560 --> 00:09:49,360
I disse dager, du bare se en lys kommer ut av en linse.

158
00:09:49,360 --> 00:09:52,870
Men tilbake i dag, hadde du rødt lykteglass, den blå linsen, og den grønne linse

159
00:09:52,870 --> 00:09:56,620
og sammen rettet mot skjermen og dannet et fargerikt bilde.

160
00:09:56,620 --> 00:09:59,590
Og ganske ofte ungdomsskoler og videregående skoler vil ha disse linsene

161
00:09:59,590 --> 00:10:02,680
aldri så litt skjevt, så du var liksom se doble eller triple bilder,

162
00:10:02,680 --> 00:10:07,500
men det var ideen. Du hadde rød og grønn og blå lys male et bilde.

163
00:10:07,500 --> 00:10:09,570
Og at samme prinsipp er benyttet i datamaskiner.

164
00:10:09,570 --> 00:10:12,000
>> Så blant de utfordringene, da, for deg i problemet sett 4

165
00:10:12,000 --> 00:10:16,080
kommer til å være et par ting, den ene er å faktisk endre størrelsen på et bilde.

166
00:10:16,080 --> 00:10:18,050
Å ta i et mønster av 0 og 1-ere,

167
00:10:18,050 --> 00:10:22,840
finne ut hvilke biter av 0 og 1-ere representerer det i en struktur som dette,

168
00:10:22,840 --> 00:10:26,800
og deretter finne ut hvordan man kan gjenskape piksler: røde, blues, greener

169
00:10:26,800 --> 00:10:32,460
innsiden slik at når et bilde ser slik ut i utgangspunktet, kan se ut som dette i stedet etter det.

170
00:10:32,460 --> 00:10:35,590
Blant de andre utfordringene, også kommer til å være at du vil bli overlevert

171
00:10:35,590 --> 00:10:38,900
en rettsmedisinsk bilde av en faktisk fil fra et digitalt kamera

172
00:10:38,900 --> 00:10:42,410
og på det kameraet, en gang i tiden var en hel haug med bilder.

173
00:10:42,410 --> 00:10:47,030
Problemet er, vi slettet ved et uhell eller hadde bildet ødelagt eller annen måte.

174
00:10:47,030 --> 00:10:51,040
Dårlige ting skje med digitale kameraer, og så vi raskt kopiert alle 0 og 1-ere

175
00:10:51,040 --> 00:10:55,410
ut av dette kortet for deg, lagret dem alle i en stor fil, og vi vil overlate dem til deg

176
00:10:55,410 --> 00:11:00,000
i problemet sett 4, slik at du kan skrive et program i C som å gjenopprette

177
00:11:00,000 --> 00:11:02,660
alle disse JPEG, ideelt.

178
00:11:02,660 --> 00:11:06,280
Og det viser seg at JPEG, selv om de er litt av en kompleks filformat,

179
00:11:06,280 --> 00:11:09,580
de er mye mer komplisert enn dette smilende ansikt her.

180
00:11:09,580 --> 00:11:14,320
Det viser seg at hver JPEG starter med de samme mønstre av 0 og 1-ere.

181
00:11:14,320 --> 00:11:18,820
Så bruke en stund sløyfe eller en for løkke eller lignende,

182
00:11:18,820 --> 00:11:22,350
du kan iterere over alle 0 og 1-ere i denne rettsmedisinske bilde

183
00:11:22,350 --> 00:11:26,670
og hver gang du ser den spesielle mønster som er definert i oppgavesettet spesifikasjoner,

184
00:11:26,670 --> 00:11:29,770
du kan anta, 'Oh, her er, med svært høy sannsynlighet

185
00:11:29,770 --> 00:11:33,520
starten på en JPEG ", og så snart du finner det samme mønsteret,

186
00:11:33,520 --> 00:11:36,050
et antall byte eller kilobyte eller megabyte senere,

187
00:11:36,050 --> 00:11:40,550
du kan anta, 'Ooh! Her er en annen JPEG, bildet jeg tok etter den første.

188
00:11:40,550 --> 00:11:44,720
La meg slutte å lese den første filen, begynner å skrive denne nye. '

189
00:11:44,720 --> 00:11:49,980
Og resultatet av programmet for pset 4 kommer til å være så mange som 50 JPEG-bilder.

190
00:11:49,980 --> 00:11:52,400
Og hvis det ikke er 50 JPEG-bilder, har du litt av en loop.

191
00:11:52,400 --> 00:11:55,580
Hvis du har et uendelig antall JPEG, har du en uendelig loop.

192
00:11:55,580 --> 00:11:58,280
Slik at også vil være en ganske vanlig sak.

193
00:11:58,280 --> 00:12:00,280
Det er hva som skjer på horisonten.

194
00:12:00,280 --> 00:12:03,740
>> Quiz 0, bak oss. Realiser, per e-posten min, som alltid er det folk

195
00:12:03,740 --> 00:12:06,820
som er både glade, liksom nøytral, og trist rundt quiz 0 time.

196
00:12:06,820 --> 00:12:10,160
Og vennligst nå ut til meg, hodet TFS, Zamyla, din egen TF

197
00:12:10,160 --> 00:12:14,120
eller en av de sertifikatutstedere som du vet om du ønsker å diskutere hvordan det gikk.

198
00:12:14,120 --> 00:12:16,460
>> Så for å imponere foreldrene her i rommet,

199
00:12:16,460 --> 00:12:23,990
hva er CS50 biblioteket? God jobb.

200
00:12:23,990 --> 00:12:32,280
Hva er CS50 biblioteket? Ja? [Student svar, uforståelig]

201
00:12:32,280 --> 00:12:35,730
>> Ok, bra. Så det er en forhåndsskrevet sett med kode som vi, de ansatte, skrev

202
00:12:35,730 --> 00:12:38,460
vi gir deg, for å gi noen vanlige funksjoner.

203
00:12:38,460 --> 00:12:42,290
Ting som får meg en streng, få meg en int, alle funksjoner som er oppført her.

204
00:12:42,290 --> 00:12:45,260
Starter nå, begynner vi å virkelig ta disse trening hjul av.

205
00:12:45,260 --> 00:12:48,230
Så vi kommer til å begynne å ta bort en "streng" fra deg,

206
00:12:48,230 --> 00:12:52,790
som husker, var bare et synonym for hva som faktisk datatype? char *.

207
00:12:52,790 --> 00:12:57,020
Så for foreldre, som var trolig - det er bra, så char * vi vil begynne å se

208
00:12:57,020 --> 00:13:00,810
på skjermen desto mer som vi fjerner "streng" fra vårt vokabular,

209
00:13:00,810 --> 00:13:02,760
i hvert fall når det gjelder å faktisk skrive kode.

210
00:13:02,760 --> 00:13:06,240
Tilsvarende vil vi slutte å bruke noen av disse funksjonene så mye,

211
00:13:06,240 --> 00:13:08,390
fordi våre programmer kommer til å få mer sofistikert

212
00:13:08,390 --> 00:13:11,370
snarere enn å bare skrive programmer som sitter der med en rask blinkende,

213
00:13:11,370 --> 00:13:13,580
venter for brukeren å skrive noe i.

214
00:13:13,580 --> 00:13:15,220
Du får dine innspill fra andre steder.

215
00:13:15,220 --> 00:13:18,720
For eksempel, vil du få dem fra en rekke biter på den lokale harddisken.

216
00:13:18,720 --> 00:13:23,340
Du vil i stedet få dem i fremtiden fra en nettverkstilkobling, noen nettside eller annet sted.

217
00:13:23,340 --> 00:13:27,460
Så la oss skrelle tilbake dette laget for første gang, og trekk opp CS50 apparatet

218
00:13:27,460 --> 00:13:32,300
og denne filen som heter CS50.h, som du har vært skarp inkludert i ukevis.

219
00:13:32,300 --> 00:13:34,380
>> Men la oss faktisk se hva som er på innsiden av dette.

220
00:13:34,380 --> 00:13:38,250
Så toppen av filen i blått er bare en hel haug med kommentarer,

221
00:13:38,250 --> 00:13:41,340
garanti samt lisensiering. Dette er liksom en felles paradigme

222
00:13:41,340 --> 00:13:44,600
i programvare, fordi mye av programvaren i disse dager er det som kalles "open source"

223
00:13:44,600 --> 00:13:46,940
noe som betyr at noen har skrevet inn koden

224
00:13:46,940 --> 00:13:50,060
og gjorde det fritt tilgjengelig, ikke bare for å kjøre og å bruke,

225
00:13:50,060 --> 00:13:53,660
men faktisk lese og endre og integrere i ditt eget arbeid.

226
00:13:53,660 --> 00:13:55,790
Så det er hva du har brukt, åpen kildekode,

227
00:13:55,790 --> 00:13:58,030
riktignok i en svært liten form.

228
00:13:58,030 --> 00:14:01,860
Hvis jeg ruller nedover forbi kommentarene, men vil vi begynne å se noen mer kjente ting.

229
00:14:01,860 --> 00:14:08,090
Så merker på toppen her, at CS50.h filen inneholder en hel haug med header filer.

230
00:14:08,090 --> 00:14:11,160
Nå er de fleste av disse vi ikke har sett før, men en er

231
00:14:11,160 --> 00:14:15,640
kjent; hvilke av disse har vi sett, om enn kort, så langt?

232
00:14:15,640 --> 00:14:18,720
Ja, standard biblioteker. Stdlib.h har malloc,

233
00:14:18,720 --> 00:14:21,590
så når vi begynte å snakke om dynamisk minne allokering,

234
00:14:21,590 --> 00:14:24,960
som vi vil komme tilbake til neste uke også, begynte vi med den filen.

235
00:14:24,960 --> 00:14:29,660
Det viser seg at bool og sant og usant ikke egentlig eksisterer i C, per se,

236
00:14:29,660 --> 00:14:32,460
med mindre du inkluderer denne filen her.

237
00:14:32,460 --> 00:14:35,770
Så vi har, i uker, vært inkludert standard bool.h

238
00:14:35,770 --> 00:14:39,020
slik at du kan bruke tanken om en bool, sant eller usant.

239
00:14:39,020 --> 00:14:41,830
Uten dette, ville du må sortere av falske det og bruke en int

240
00:14:41,830 --> 00:14:45,920
og bare vilkårlig anta at 0 er falsk og en er sant.

241
00:14:45,920 --> 00:14:49,980
>> Nå, hvis vi blar ned ytterligere, her er vår definisjon av en streng.

242
00:14:49,980 --> 00:14:54,820
Det viser seg, som vi har sagt før, at der dette * er ikke virkelig betyr noe.

243
00:14:54,820 --> 00:14:56,750
Du kan selv ha plass rundt.

244
00:14:56,750 --> 00:15:01,550
Vi, dette semesteret, har vært fremme det som dette for å gjøre det klart at den * har å gjøre med typen.

245
00:15:01,550 --> 00:15:05,370
Men innser, akkurat som vanlig, om ikke litt mer vanlig, er å sette den der

246
00:15:05,370 --> 00:15:07,480
men funksjonelt er det det samme.

247
00:15:07,480 --> 00:15:11,070
Men nå, hvis vi leser ned ytterligere, la oss ta en titt på si, GetInt,

248
00:15:11,070 --> 00:15:15,350
fordi vi brukte det, kanskje, før noe annet dette semesteret.

249
00:15:15,350 --> 00:15:19,620
Og her er GetInt. Dette er hva?

250
00:15:19,620 --> 00:15:24,650
Dette er prototypen. Så ofte, har vi satt prototyper på toppen av vår. C-filer,

251
00:15:24,650 --> 00:15:28,190
men du kan også sette prototyper i header-filer,. h-filer,

252
00:15:28,190 --> 00:15:32,110
som en dette her, slik at når du skriver noen funksjoner

253
00:15:32,110 --> 00:15:36,790
at du vil at andre skal kunne bruke, som er akkurat det tilfellet med CS50 bibliotek,

254
00:15:36,790 --> 00:15:40,900
du ikke bare implementere dine funksjoner i noe som CS50.c,

255
00:15:40,900 --> 00:15:46,720
du også sette prototypene ikke på toppen av denne filen, men på toppen av en header-fil,

256
00:15:46,720 --> 00:15:50,810
da at header-fil er hva venner og kolleger inkluderer,

257
00:15:50,810 --> 00:15:52,800
med skarpe inkludere i sin egen kode.

258
00:15:52,800 --> 00:15:55,440
Så hele denne tiden har du blitt inkludert alle disse prototypene

259
00:15:55,440 --> 00:15:59,870
effektivt på toppen av filen, men ved hjelp av denne skarpe inkluderer mekanismen

260
00:15:59,870 --> 00:16:03,320
at vesentlig kopierer og limer denne filen til din egen.

261
00:16:03,320 --> 00:16:06,400
Nå, her er noen ganske detaljert dokumentasjon.

262
00:16:06,400 --> 00:16:08,880
>> Vi har ganske mye tatt for gitt at GetInt får en int,

263
00:16:08,880 --> 00:16:10,740
men det viser seg at det er noen hjørne tilfeller, ikke sant?

264
00:16:10,740 --> 00:16:14,320
Hva om brukeren skriver inn et tall som er altfor stor?

265
00:16:14,320 --> 00:16:17,350
En kvintillioner, som bare ikke kan passe inn i en int?

266
00:16:17,350 --> 00:16:21,180
Hva er forventet oppførsel? Vel, ideelt sett, er det forutsigbart.

267
00:16:21,180 --> 00:16:23,460
Så i dette tilfellet, hvis du faktisk lese de fine print,

268
00:16:23,460 --> 00:16:27,850
vil du se at hvis linjen ikke kan leses, dette returnerer INT_MAX.

269
00:16:27,850 --> 00:16:30,800
Vi har aldri snakket om dette, men basert på kapitalisering sin,

270
00:16:30,800 --> 00:16:33,030
hva er det, sannsynligvis?

271
00:16:33,030 --> 00:16:36,610
Det er en konstant, så det er noen spesiell konstant som sannsynligvis erklært

272
00:16:36,610 --> 00:16:39,460
i en av disse header-filer som er opp høyere i filen,

273
00:16:39,460 --> 00:16:43,400
og INT_MAX er sannsynligvis noe sånt som, omtrent, 2 milliarder kroner.

274
00:16:43,400 --> 00:16:48,160
Tanken er at fordi vi trenger å liksom bety at noe gikk galt,

275
00:16:48,160 --> 00:16:51,090
Vi, ja, har 4000 millioner tallene til rådighet,

276
00:16:51,090 --> 00:16:53,980
negative 2 milliarder på opptil 2 milliarder kroner, gi eller ta.

277
00:16:53,980 --> 00:16:58,030
Vel, hva er vanlig i programmering er du stjeler bare ett av disse tallene.

278
00:16:58,030 --> 00:17:02,250
Kanskje 0, kanskje 2 milliarder kroner, kanskje negative 2 milliarder kroner.

279
00:17:02,250 --> 00:17:06,720
Så du bruke en av dine mulige verdier, slik at du kan forplikte seg til hele verden

280
00:17:06,720 --> 00:17:10,089
at hvis noe går galt, vil jeg returnere denne super-stor verdi.

281
00:17:10,089 --> 00:17:13,329
Men du ikke vil at brukeren skrive noe kryptisk som "2, 3, 4 ..."

282
00:17:13,329 --> 00:17:17,079
av virkelig store tall, der du generalisere stedet som en konstant.

283
00:17:17,079 --> 00:17:19,380
Så egentlig, hvis du var å være anal de siste ukene,

284
00:17:19,380 --> 00:17:23,800
når du kaller GetInt, bør du ha vært sjekke med en hvis tilstanden.

285
00:17:23,800 --> 00:17:27,109
Gjorde brukeren skriver inn INT_MAX, eller mer spesifikt,

286
00:17:27,109 --> 00:17:29,900
gjorde GetInt tilbake INT_MAX? Fordi hvis det gjorde,

287
00:17:29,900 --> 00:17:35,140
som faktisk betyr at de ikke skriver det, noe gikk galt i dette tilfellet.

288
00:17:35,140 --> 00:17:38,970
Så dette er hva som vanligvis kjent som en "sentinel" verdi, noe som betyr bare spesiell.

289
00:17:38,970 --> 00:17:41,020
>> Vel, la oss nå slå inn til. C-filer.

290
00:17:41,020 --> 00:17:44,500
C-filen har eksistert i apparatet i lengre tid,

291
00:17:44,500 --> 00:17:47,540
og, faktisk, har apparatet den ferdigbygd for deg

292
00:17:47,540 --> 00:17:49,720
inn i den tingen som kalles vi "objektkode"

293
00:17:49,720 --> 00:17:52,940
men det bare ikke noe for deg hvor det er fordi systemet vet,

294
00:17:52,940 --> 00:17:54,780
i dette tilfellet, hvor det er, apparatet.

295
00:17:54,780 --> 00:18:00,620
Men la oss rulle ned nå for å GetInt, og se hvordan GetInt har jobbet hele tiden.

296
00:18:00,620 --> 00:18:02,380
Så her har vi lignende kommentarer fra før.

297
00:18:02,380 --> 00:18:04,930
La meg zoome inn på akkurat den koden delen,

298
00:18:04,930 --> 00:18:07,410
og hva vi har for GetInt er følgende.

299
00:18:07,410 --> 00:18:12,770
Det tar ingen innspill og den returnerer en int, while (true), så vi har en bevisst uendelig loop

300
00:18:12,770 --> 00:18:16,560
men, formodentlig, vil vi bryte ut av dette liksom, eller returnere fra innenfor dette.

301
00:18:16,560 --> 00:18:19,890
Så la oss se hvordan dette fungerer. Vel, vi synes å bruke GetString

302
00:18:19,890 --> 00:18:22,550
i denne første linje inne i sløyfen, 166.

303
00:18:22,550 --> 00:18:25,320
Dette er nå god praksis fordi under hvilke omstendigheter

304
00:18:25,320 --> 00:18:30,820
kunne GetString returnere denne spesielle søkeord, NULL?

305
00:18:30,820 --> 00:18:38,460
Hvis noe går galt. Hva som kan gå galt når du kaller noe som GetString?

306
00:18:38,460 --> 00:18:42,550
Ja? [Student svar, uforståelig] >> Ja. Så kanskje malloc mislykkes.

307
00:18:42,550 --> 00:18:45,310
Somewhere under panseret GetString ringer malloc,

308
00:18:45,310 --> 00:18:48,210
som tildeler minne, som lar datamaskinen butikken

309
00:18:48,210 --> 00:18:50,950
alle de tegnene som brukeren skriver inn i tastaturet.

310
00:18:50,950 --> 00:18:53,270
Og anta at brukeren hadde en hel masse ledig tid

311
00:18:53,270 --> 00:18:56,470
og skrevet mer, for eksempel enn 2000000000 tegn.

312
00:18:56,470 --> 00:18:59,600
Flere tegn enn datamaskinen har selv RAM.

313
00:18:59,600 --> 00:19:02,350
Vel, har GetString å kunne betegne det til deg,

314
00:19:02,350 --> 00:19:05,650
selv om dette er en super, super uvanlig hjørne saken.

315
00:19:05,650 --> 00:19:08,490
Det har å liksom være i stand til å håndtere dette, og så GetString,

316
00:19:08,490 --> 00:19:11,850
hvis vi går tilbake og lese dokumentasjonen, betyr faktisk tilbake NULL.

317
00:19:11,850 --> 00:19:16,150
Nå hvis GetString mislykkes ved å returnere NULL, er GetInt kommer til å mislykkes

318
00:19:16,150 --> 00:19:19,370
ved å returnere INT_MAX, akkurat som en vaktpost.

319
00:19:19,370 --> 00:19:22,650
Dette er bare menneskelige konvensjoner. Den eneste måten du ville vite dette er tilfelle

320
00:19:22,650 --> 00:19:24,840
er ved å lese dokumentasjonen.

321
00:19:24,840 --> 00:19:28,200
Så la oss bla ned til der int er faktisk GotInt.

322
00:19:28,200 --> 00:19:34,220
>> Så hvis jeg ruller nedover et stykke, i tråd 170 har vi en kommentar ovenfor disse linjene.

323
00:19:34,220 --> 00:19:38,470
Så vi erklærer i 172, en int n og en røye c, og deretter den nye funksjonen

324
00:19:38,470 --> 00:19:41,870
som noen av dere har snublet over før, men sscanf.

325
00:19:41,870 --> 00:19:44,190
Dette står for streng scan f.

326
00:19:44,190 --> 00:19:48,580
Med andre ord, gi meg en streng og jeg vil skanne den for opplysninger av interesse.

327
00:19:48,580 --> 00:19:53,820
Så hva betyr det? Vel, antar at jeg skriver i, bokstavelig talt, 1 2 3 på tastaturet,

328
00:19:53,820 --> 00:19:59,730
og deretter trykk enter. Hva er datatypen for 1 2 3 da tilbake etter GetString?

329
00:19:59,730 --> 00:20:05,010
Det er åpenbart en streng, ikke sant? Jeg fikk en streng, så 1 2 3 er virkelig "1 2 3"

330
00:20:05,010 --> 00:20:07,260
med \ 0 på slutten av den. Det er ikke en int.

331
00:20:07,260 --> 00:20:10,420
Det er ikke et tall. Det ser ut som et tall, men det er faktisk ikke.

332
00:20:10,420 --> 00:20:14,680
Så hva har GetInt å gjøre? Det har å skanne strengen venstre til høyre,

333
00:20:14,680 --> 00:20:19,010
1 2 3 \ 0, og noe konvertere den til en faktisk heltall.

334
00:20:19,010 --> 00:20:21,010
Nå kan du finne ut hvordan du gjør dette.

335
00:20:21,010 --> 00:20:24,240
Hvis du tenker tilbake til pset 2, har du antagelig fått litt behagelig

336
00:20:24,240 --> 00:20:26,810
med Caesar eller vigenere slik at du kan iterere over en streng,

337
00:20:26,810 --> 00:20:29,800
du kan konvertere tegn til ints med hakke. Det er en hel masse arbeid.

338
00:20:29,800 --> 00:20:32,800
Hvorfor ikke kalle en funksjon som sscanf som gjør det for deg?

339
00:20:32,800 --> 00:20:37,520
Så sscanf forventer et argument, i dette tilfellet kalles linje, som er en streng.

340
00:20:37,520 --> 00:20:41,310
Du kan deretter angi, i anførselstegn, svært lik printf,

341
00:20:41,310 --> 00:20:44,960
hva gjør du forventer å se i denne strengen?

342
00:20:44,960 --> 00:20:52,980
Hva jeg sier her er, forventer jeg å se et desimaltall og kanskje et tegn.

343
00:20:52,980 --> 00:20:54,990
Og vi vil se hvorfor dette er tilfellet i bare et øyeblikk.

344
00:20:54,990 --> 00:20:58,440
Det viser seg at denne notasjonen er nå minner om ting

345
00:20:58,440 --> 00:21:00,840
vi begynte å snakke om litt over en uke siden.

346
00:21:00,840 --> 00:21:05,430
>> Hva er & n og & c gjør for oss her? [Student svar, uforståelig]

347
00:21:05,430 --> 00:21:07,610
>> Ja. Det gir meg adressen til n og adresse c.

348
00:21:07,610 --> 00:21:10,440
Nå, hvorfor er det viktig? Vel, du vet at med funksjoner i C

349
00:21:10,440 --> 00:21:13,440
du kan alltid gå tilbake en verdi eller ingen verdi i det hele tatt.

350
00:21:13,440 --> 00:21:16,630
Du kan returnere en int, en streng, en flåte, en røye, uansett.

351
00:21:16,630 --> 00:21:21,150
Eller du kan gå tilbake ugyldig, men du kan bare returnere en ting maksimalt.

352
00:21:21,150 --> 00:21:26,100
Men her vi ønsker sscanf å returnere meg kanskje en int, et desimaltall,

353
00:21:26,100 --> 00:21:29,240
og også en røye, og jeg skal forklare hvorfor røye i et øyeblikk.

354
00:21:29,240 --> 00:21:34,250
Så du effektivt vil f å returnere to ting, det er bare ikke mulig i C.

355
00:21:34,250 --> 00:21:38,460
Så du kan omgå det ved å sende inn 2 adresser,

356
00:21:38,460 --> 00:21:43,710
fordi så snart du hånden en funksjon 2 adresser, hva kan denne funksjonen gjøre med dem?

357
00:21:43,710 --> 00:21:49,880
Det kan skrive til disse adressene. Du kan bruke * drift og "gå dit" til hver av disse adressene.

358
00:21:49,880 --> 00:21:54,320
Det er liksom dette bakdør mekanisme, men veldig vanlig for å endre verdiene av variablene

359
00:21:54,320 --> 00:21:58,020
i mer enn bare en sted, i dette tilfellet to.

360
00:21:58,020 --> 00:22:04,590
Nå merker jeg sjekker for == to1, og deretter returnere n hvis det ikke faktisk vurdere å true.

361
00:22:04,590 --> 00:22:09,340
Så hva er det som skjer? Vel, teknisk sett, er alt vi virkelig ønsker å skje i GetInt dette.

362
00:22:09,340 --> 00:22:12,340
Vi ønsker å analysere, så å si, vi ønsker å lese strengen

363
00:22:12,340 --> 00:22:16,210
"1 2 3" og hvis det ser ut som det er en rekke det,

364
00:22:16,210 --> 00:22:21,360
hva vi forteller sscanf å gjøre er å sette det nummeret, 1 2 3, i denne variabelen n for meg.

365
00:22:21,360 --> 00:22:26,060
Hvorfor da, jeg har dette også?

366
00:22:26,060 --> 00:22:33,750
Hva er rollen til også å si, sscanf, kan du også få en karakter her.

367
00:22:33,750 --> 00:22:36,890
[Student sett uforståelig] >> Ikke - desimaltegn kunne fungere.

368
00:22:36,890 --> 00:22:40,650
La oss holde det trodde et øyeblikk. Hva annet?

369
00:22:40,650 --> 00:22:42,570
[Student, uforståelig] >> Så god tanke, kan det være den NULL karakter.

370
00:22:42,570 --> 00:22:44,970
Det er faktisk ikke i dette tilfellet. Ja? [Student, uforståelig]

371
00:22:44,970 --> 00:22:47,100
>> >> ASCII. Eller, la meg generalisere ytterligere.

372
00:22:47,100 --> 00:22:49,670
Den% c det er bare for feil-sjekking.

373
00:22:49,670 --> 00:22:52,510
Vi ønsker ikke at det skal være tegnet etter tallet,

374
00:22:52,510 --> 00:22:54,980
men hva dette tillater meg å gjøre er følgende:

375
00:22:54,980 --> 00:23:01,270
Det viser seg at sscanf foruten lagring verdier i n og C, i dette eksemplet her,

376
00:23:01,270 --> 00:23:08,170
hva det også gjør er det returnerer antall variabler det satt verdier i.

377
00:23:08,170 --> 00:23:13,330
Så hvis du bare skrive inn 1 2 3, da bare% d kommer til å matche

378
00:23:13,330 --> 00:23:18,830
og bare n blir lagret med en verdi som 1 2 3 og ingenting blir satt i c;

379
00:23:18,830 --> 00:23:20,870
c fortsatt en søppel verdi, så å si.

380
00:23:20,870 --> 00:23:23,550
Søpla fordi det er aldri blitt initialisert som noen verdi.

381
00:23:23,550 --> 00:23:29,390
Så i det tilfellet, returnerer sscanf 1 fordi jeg befolket en av disse markørene,

382
00:23:29,390 --> 00:23:33,650
i så fall, flott. Jeg har en int, så befri jeg linjen for å frigjøre minne

383
00:23:33,650 --> 00:23:37,150
som GetString faktisk tildelt, og da jeg kommer tilbake n.

384
00:23:37,150 --> 00:23:42,210
Annet, hvis du noen gang lurt på hvor den retry uttalelsen kommer fra, kommer fra høyre her.

385
00:23:42,210 --> 00:23:45,770
Hvis derimot, skriver jeg i 1 2 3 foo,

386
00:23:45,770 --> 00:23:48,640
bare noen tilfeldig rekkefølge av tekst, er sscanf kommer til å se,

387
00:23:48,640 --> 00:23:51,500
ooh, nummer, ooh, nummer, ooh, nummer, ooh - f.

388
00:23:51,500 --> 00:23:54,190
Og det kommer til å sette 1 2 3 i n.

389
00:23:54,190 --> 00:23:59,970
Det kommer til å sette f i c, og deretter tilbake to.

390
00:23:59,970 --> 00:24:02,980
Så vi har, bare ved hjelp av grunnleggende definisjonen av scanf atferd,

391
00:24:02,980 --> 00:24:06,170
en svært enkel måte - vel, kompleks ved første øyekast, men på slutten av dagen,

392
00:24:06,170 --> 00:24:11,460
ganske enkel mekanisme for å si, er det en int, og hvis så, er at det eneste som jeg fant?

393
00:24:11,460 --> 00:24:14,950
Og det hvite området her er bevisst. Hvis du leser dokumentasjonen for sscanf,

394
00:24:14,950 --> 00:24:18,690
det forteller deg at hvis du inkluderer et stykke hvit mellomrom på begynnelsen eller slutten,

395
00:24:18,690 --> 00:24:24,990
sscanf vil også tillate brukeren, uansett grunn, å treffe mellomromstasten 1 2 3, og som vil være legitime.

396
00:24:24,990 --> 00:24:28,310
Det vil ikke kjefte på brukeren bare fordi de treffer mellomromstasten på begynnelsen eller slutten,

397
00:24:28,310 --> 00:24:32,160
som er bare litt mer brukervennlig.

398
00:24:32,160 --> 00:24:34,160
>> Eventuelle spørsmål, da, på GetInts? Ja?

399
00:24:34,160 --> 00:24:36,820
[Student spørsmål, uforståelig]

400
00:24:36,820 --> 00:24:40,740
>> Godt spørsmål. Hva om du nettopp skrev i en røye, som f, og trykk enter

401
00:24:40,740 --> 00:24:47,830
uten noen gang å skrive 1 2 3, hva tror du oppførselen til denne linjen med kode vil da være?

402
00:24:47,830 --> 00:24:50,500
Så sscanf kan dekke det også, fordi i så fall,

403
00:24:50,500 --> 00:24:56,280
det er ikke til å fylle n eller c, det kommer til å i stedet returnere 0.

404
00:24:56,280 --> 00:25:01,540
I så fall, er jeg også oppsiktsvekkende at scenario, fordi den forventede verdien jeg ønsker er en.

405
00:25:01,540 --> 00:25:07,310
Jeg vil bare ha en, og bare en ting å bli fylt. Godt spørsmål. Andre?

406
00:25:07,310 --> 00:25:09,610
>> All right, så la oss gå ikke gjennom alle funksjonene i her,

407
00:25:09,610 --> 00:25:11,820
men den som synes å være, kanskje, av gjenværende interesse

408
00:25:11,820 --> 00:25:14,530
er GetString fordi det viser seg at GetFloat, GetInt,

409
00:25:14,530 --> 00:25:19,490
GetDouble, GetLongLong alle punt mye av sin funksjonalitet til GetString.

410
00:25:19,490 --> 00:25:22,860
Så la oss ta en titt på hvordan han er implementert her.

411
00:25:22,860 --> 00:25:27,040
Dette ser litt komplisert, men det bruker de samme grunnleggende

412
00:25:27,040 --> 00:25:29,680
at vi begynte å snakke om forrige uke. Så i GetString,

413
00:25:29,680 --> 00:25:32,670
som tar ingen argument som per tomrommet her oppe,

414
00:25:32,670 --> 00:25:37,110
og den returnerer en streng, så jeg erklære en streng som heter buffer.

415
00:25:37,110 --> 00:25:39,670
Jeg vet egentlig ikke hva som kommer til å bli brukt til ennå, men vi får se.

416
00:25:39,670 --> 00:25:42,950
Ser ut som kapasiteten er som standard 0; ikke helt sikker på hvor dette går.

417
00:25:42,950 --> 00:25:44,920
Ikke sikker på hva n kommer til å bli brukt til ennå.

418
00:25:44,920 --> 00:25:47,860
Men nå er det å få en litt mer interessant, så i tråd 243,

419
00:25:47,860 --> 00:25:51,760
Vi erklærer en int c, dette er liksom en dum detalj.

420
00:25:51,760 --> 00:25:58,080
En røye er 8 bits, og 8 bits kan lagre hvor mange ulike verdier?

421
00:25:58,080 --> 00:26:03,310
256. Problemet er, hvis du ønsker å ha 256 forskjellige ASCII-tegn,

422
00:26:03,310 --> 00:26:06,210
som det er, hvis du tenker tilbake, og dette er ikke noe å huske.

423
00:26:06,210 --> 00:26:09,100
Men hvis du tenker tilbake til den store ASCII diagrammet vi hadde uker siden,

424
00:26:09,100 --> 00:26:13,780
Det var i så fall, 128 eller 256 ASCII-tegn.

425
00:26:13,780 --> 00:26:16,220
Vi brukte alle mønstre av 0 og 1-ere opp.

426
00:26:16,220 --> 00:26:19,410
Det er et problem hvis du ønsker å være i stand til å oppdage en feil.

427
00:26:19,410 --> 00:26:23,290
Fordi hvis du allerede bruker 256 verdier for figurene dine,

428
00:26:23,290 --> 00:26:26,390
du egentlig ikke planlegge, fordi nå har du ingen måte å si,

429
00:26:26,390 --> 00:26:29,750
"Dette er ikke en legit karakter, dette er noen feilaktige meldingen."

430
00:26:29,750 --> 00:26:32,430
Så hva verden gjør er, de bruker den neste største verdien,

431
00:26:32,430 --> 00:26:35,790
noe sånt som en int, slik at du har en sprø antall biter,

432
00:26:35,790 --> 00:26:39,610
32 for 4000 millioner mulige verdier, slik at du kan bare ende opp med å bruke,

433
00:26:39,610 --> 00:26:44,800
hovedsak, 257 av dem, en av dem har noen spesiell betydning som en feil.

434
00:26:44,800 --> 00:26:49,190
>> Så la oss se hvordan dette fungerer. I tråd 246, har jeg denne store mens loop

435
00:26:49,190 --> 00:26:54,530
som ringer fgetc f mening fil, getc, og deretter stdin.

436
00:26:54,530 --> 00:26:59,030
Det viser seg at dette er bare mer presis måte å si "lese inndata fra tastaturet."

437
00:26:59,030 --> 00:27:02,730
Standard inngang betyr tastatur, betyr standard ut skjermen,

438
00:27:02,730 --> 00:27:06,920
og standard feil, som vi vil se i pset 4 betyr skjermen,

439
00:27:06,920 --> 00:27:09,670
men en spesiell del av skjermen, slik at det ikke er smeltet sammen

440
00:27:09,670 --> 00:27:13,760
med den faktiske produksjonen som du hadde tenkt til å skrive ut, men mer om det i fremtiden.

441
00:27:13,760 --> 00:27:19,430
Så fgetc betyr bare lese ett tegn fra tastaturet, og lagre det der?

442
00:27:19,430 --> 00:27:24,000
Oppbevar den i c, og deretter sjekke, så jeg bare bruker noen logiske konjunksjoner her,

443
00:27:24,000 --> 00:27:28,430
sjekk at den ikke er lik \ n, slik at brukeren har rammet inn.

444
00:27:28,430 --> 00:27:31,510
Vi ønsker å stoppe på dette punktet, slutten av løkken, og vi ønsker også å sjekke

445
00:27:31,510 --> 00:27:36,170
for den spesielle konstant, EOF, som hvis du vet eller antar - Hva står det for?

446
00:27:36,170 --> 00:27:39,860
Slutten av filen. Så dette er slags nonsens, fordi hvis jeg skriver på tastaturet,

447
00:27:39,860 --> 00:27:41,900
det er egentlig ingen fil som er involvert i dette,

448
00:27:41,900 --> 00:27:44,330
men dette er liksom bare av den generelle termen brukes til å bety

449
00:27:44,330 --> 00:27:50,320
at ingenting annet kommer fra menneskelige fingre. EOF. Slutten av filen.

450
00:27:50,320 --> 00:27:52,600
Som en side, hvis du noen gang har truffet kontroll d på tastaturet,

451
00:27:52,600 --> 00:27:54,680
ikke at du ville ha ennå, du har truffet kontroll c.

452
00:27:54,680 --> 00:27:57,920
Men kontroll d sender denne spesielle konstant kalt EOF.

453
00:27:57,920 --> 00:28:03,100
>> Så nå er det bare noen dynamisk minne allokering.

454
00:28:03,100 --> 00:28:06,460
Så hvis n + 1> kapasitet, nå skal jeg forklare n.

455
00:28:06,460 --> 00:28:09,380
n er bare hvor mange byte er for tiden i buffer,

456
00:28:09,380 --> 00:28:11,970
strengen som du bygger opp fra brukeren.

457
00:28:11,970 --> 00:28:16,240
Hvis du har flere tegn i buffer din enn du har kapasitet i buffer,

458
00:28:16,240 --> 00:28:20,760
intuitivt, hva vi trenger å gjøre da tildele mer kapasitet.

459
00:28:20,760 --> 00:28:24,490
Jeg kommer til å skumme over noen av aritmetiske her

460
00:28:24,490 --> 00:28:26,900
og fokusere bare på denne funksjonen her.

461
00:28:26,900 --> 00:28:29,170
Du vet hva malloc er, eller i det minste generelt kjent.

462
00:28:29,170 --> 00:28:32,380
Ta en gjetning hva RealLOC gjør. [Student svar, uforståelig]

463
00:28:32,380 --> 00:28:35,690
>> Ja. Og det er ikke helt legge til minne, det reallocates minne som følger:

464
00:28:35,690 --> 00:28:40,530
Hvis det fortsatt er plass på slutten av strengen for å gi deg mer av det minne

465
00:28:40,530 --> 00:28:43,370
enn det opprinnelig gir deg, så du får det ekstra minne.

466
00:28:43,370 --> 00:28:46,640
Så du kan bare sette strenger tegn rygg mot rygg til rygg mot rygg.

467
00:28:46,640 --> 00:28:49,290
Men hvis det ikke er tilfelle, fordi du ventet for lenge

468
00:28:49,290 --> 00:28:51,700
og noe tilfeldig fikk plopped i minnet der, men det er ekstra

469
00:28:51,700 --> 00:28:56,480
minne her nede, det er greit. RealLOC kommer til å gjøre alle de tunge løftene for deg,

470
00:28:56,480 --> 00:28:58,810
flytte strengen du har lest i så langt herfra,

471
00:28:58,810 --> 00:29:02,550
legge det ned der, og deretter gi deg noen mer rullebanen på det tidspunktet.

472
00:29:02,550 --> 00:29:05,610
Så med en bølge av hånden, la meg si at det GetString gjør

473
00:29:05,610 --> 00:29:09,540
er det å starte med en liten buffer, kanskje en enkelt karakter,

474
00:29:09,540 --> 00:29:12,300
og hvis brukeren skriver inn 2 tegn, ender GetString opp

475
00:29:12,300 --> 00:29:15,210
ringer RealLOC og sier: «Ooh, var en karakter ikke nok.

476
00:29:15,210 --> 00:29:18,480
Gi meg 2 tegn. Så hvis du leser gjennom logikken i loop,

477
00:29:18,480 --> 00:29:21,070
det kommer til å si: "Ooh, brukeren har skrevet i tre tegn.

478
00:29:21,070 --> 00:29:25,690
Gi meg nå ikke 2, men 4 tegn, og deretter gi meg 8, og deretter gi meg 16 og 32 ".

479
00:29:25,690 --> 00:29:28,180
Det faktum at jeg dobler kapasiteten hver gang

480
00:29:28,180 --> 00:29:30,320
betyr at bufferen ikke kommer til å vokse langsomt.

481
00:29:30,320 --> 00:29:35,870
Det kommer til å vokse super rask, og hva som kan være fordelen av det?

482
00:29:35,870 --> 00:29:38,540
Hvorfor jeg doble størrelsen på bufferen, selv om brukeren

483
00:29:38,540 --> 00:29:41,450
kanskje bare trenger en ekstra tegn på tastaturet?

484
00:29:41,450 --> 00:29:44,830
[Student svar, uforståelig]. >> Hva er det?

485
00:29:44,830 --> 00:29:46,750
Akkurat. Du trenger ikke å dyrke den så ofte.

486
00:29:46,750 --> 00:29:48,870
Og dette er bare en slags - du sikring dine spill her.

487
00:29:48,870 --> 00:29:54,150
Tanken er at du ikke ønsker å kalle RealLOC mye, fordi det har en tendens til å være treg.

488
00:29:54,150 --> 00:29:56,840
Hver gang du spør operativsystemet for hukommelse, så vil du snart se

489
00:29:56,840 --> 00:30:00,620
i en fremtidig problem sett, pleier det å ta litt tid.

490
00:30:00,620 --> 00:30:04,980
Så minimere den tiden, selv om du kaster bort litt plass, har en tendens til å være en god ting.

491
00:30:04,980 --> 00:30:07,250
>> Men hvis vi leser gjennom den avsluttende delen av GetString her,

492
00:30:07,250 --> 00:30:10,880
og igjen, forstå hver enkelt linje her er ikke så viktig i dag.

493
00:30:10,880 --> 00:30:14,830
Men merker at det til slutt kaller malloc igjen, og den fordeler

494
00:30:14,830 --> 00:30:16,980
akkurat som mange bytes som det er behov for streng

495
00:30:16,980 --> 00:30:21,620
og kaster deretter bort ved å ringe gratis, for stor buffer,

496
00:30:21,620 --> 00:30:23,510
hvis det faktisk ble doblet for mange ganger.

497
00:30:23,510 --> 00:30:25,970
Kort sagt, det er hvordan GetString har jobbet hele tiden.

498
00:30:25,970 --> 00:30:30,100
Alt den gjør er lest ett tegn om gangen igjen og igjen og igjen

499
00:30:30,100 --> 00:30:37,930
og hver gang det er behov for noen ekstra minne, spør den operativsystemet for det ved å kalle RealLOC.

500
00:30:37,930 --> 00:30:41,660
Eventuelle spørsmål? OK.

501
00:30:41,660 --> 00:30:45,220
>> Et angrep. Nå som vi forstår pekere, eller i det minste

502
00:30:45,220 --> 00:30:47,560
blir stadig kjent med pekere,

503
00:30:47,560 --> 00:30:50,020
la oss vurdere hvordan hele verden begynner å kollapse

504
00:30:50,020 --> 00:30:53,160
Hvis du ikke helt forsvare seg mot fiendtlige brukere,

505
00:30:53,160 --> 00:30:55,180
folk som prøver å hacke seg inn i systemet ditt.

506
00:30:55,180 --> 00:31:00,260
Folk som prøver å stjele programvare ved å omgå noen registreringskode

507
00:31:00,260 --> 00:31:02,150
at de kanskje ellers å skrive i.

508
00:31:02,150 --> 00:31:04,860
Ta en titt på dette eksempelet her, som er bare C-kode

509
00:31:04,860 --> 00:31:07,920
som har en funksjon main nederst, anrop som en funksjon foo,

510
00:31:07,920 --> 00:31:12,100
og hva er det passerer til foo? [Student] Et enkelt argument.

511
00:31:12,100 --> 00:31:15,660
>> Enkelt argument. Så argv [1], som betyr det første ordet som brukeren skrev

512
00:31:15,660 --> 00:31:19,150
på kommandolinjen etter a.out eller hva programmet heter.

513
00:31:19,150 --> 00:31:24,920
Så foo, på toppen, tar i et char *, men char * er akkurat hva?

514
00:31:24,920 --> 00:31:28,860
Streng. Det er ikke noe nytt her, og at strengen er vilkårlig å bli kalt bar.

515
00:31:28,860 --> 00:31:36,090
I denne linjen her, røye c [12], i form av semi-teknisk engelsk, hva denne linjen gjør?

516
00:31:36,090 --> 00:31:40,640
Array of -? Tegn. Gi meg en rekke 12 tegn.

517
00:31:40,640 --> 00:31:44,970
Så vi kan kalle dette en buffer. Det er teknisk kalt c, men en buffer i programmering

518
00:31:44,970 --> 00:31:47,890
betyr bare en haug med plass som du kan sette noen ting i.

519
00:31:47,890 --> 00:31:49,940
>> Så til slutt, memcpy, har vi ikke brukt før.

520
00:31:49,940 --> 00:31:52,380
Men du kan sikkert gjette hva det gjør. Det kopierer minnet.

521
00:31:52,380 --> 00:31:58,790
Hva gjør den? Vel, det tilsynelatende kopierer bar, sin inngang, i c,

522
00:31:58,790 --> 00:32:03,420
men bare opp til lengden av linjen.

523
00:32:03,420 --> 00:32:07,440
Men det er en feil her.

524
00:32:07,440 --> 00:32:14,500
Ok, så teknisk vi skal virkelig gjøre strlen (bar) x sizeof (char), det er riktig.

525
00:32:14,500 --> 00:32:17,920
Men i verste tilfelle her, la oss anta at that - så greit.

526
00:32:17,920 --> 00:32:23,760
Så er det to feil. Så sizeof (char), greit, la oss gjøre dette litt bredere.

527
00:32:23,760 --> 00:32:28,860
Så nå er det fortsatt en bug, som er hva?

528
00:32:28,860 --> 00:32:31,630
[Student svar, uforståelig] >> Se etter hva? Ok, så vi bør sjekke

529
00:32:31,630 --> 00:32:35,010
for NULL, fordi dårlige ting skje når pekeren er NULL,

530
00:32:35,010 --> 00:32:38,490
Fordi du kan ende opp med å gå der, og du bør aldri gå til NULL

531
00:32:38,490 --> 00:32:40,890
ved dereferencing den med * operatør.

532
00:32:40,890 --> 00:32:45,250
Så det er bra, og hva annet gjør vi? Logisk det er en feil her også.

533
00:32:45,250 --> 00:32:47,650
[Student svar, uforståelig]

534
00:32:47,650 --> 00:32:51,340
>> Så sjekk om argc ≥ 2?

535
00:32:51,340 --> 00:32:54,130
Ok, så det er 3 feil i dette programmet her.

536
00:32:54,130 --> 00:33:00,080
Vi er ikke sjekker om brukeren faktisk skrevet i noe inn argv [1], bra.

537
00:33:00,080 --> 00:33:02,240
Så hva er den tredje bug? Ja?

538
00:33:02,240 --> 00:33:04,420
[Student svar, uforståelig] >> Good.

539
00:33:04,420 --> 00:33:09,590
Så vi sjekket ett scenario. Vi implisitt sjekket ikke kopiere mer minne

540
00:33:09,590 --> 00:33:12,800
enn det som ville overskride lengden bar.

541
00:33:12,800 --> 00:33:15,720
Så hvis strengen brukeren skrev inn er 10 tegn lang,

542
00:33:15,720 --> 00:33:18,260
dette sier, 'Kun kopiere 10 tegn.

543
00:33:18,260 --> 00:33:21,140
Og det er greit, men hva om brukeren har skrevet inn et ord når du får beskjeden

544
00:33:21,140 --> 00:33:29,360
som en 20 tegn ord, dette er, sier kopiere 20 tegn fra bar til hva?

545
00:33:29,360 --> 00:33:32,840
c, ellers kjent som buffer vår, noe som betyr at du nettopp skrev data

546
00:33:32,840 --> 00:33:35,950
til 8 byte steder som du ikke eier,

547
00:33:35,950 --> 00:33:38,320
og du ikke eier dem i den forstand at du aldri tildelt dem.

548
00:33:38,320 --> 00:33:41,190
Så dette er hva som vanligvis kjent som buffer overflow angrep,

549
00:33:41,190 --> 00:33:46,650
eller bufferoverløp angrep, og det angrep i den forstand at dersom brukeren

550
00:33:46,650 --> 00:33:50,650
eller programmet som kaller din funksjon gjør dette skadelig,

551
00:33:50,650 --> 00:33:53,780
hva skjer egentlig neste kan være ganske ille.

552
00:33:53,780 --> 00:33:55,690
>> La oss ta en titt på dette bildet her.

553
00:33:55,690 --> 00:33:59,070
Dette bildet representerer bunke med minne.

554
00:33:59,070 --> 00:34:01,050
Og huske at hver gang du ringer en funksjon,

555
00:34:01,050 --> 00:34:04,520
du får denne lille rammen på stakken og deretter en annen og deretter en annen og deretter en annen.

556
00:34:04,520 --> 00:34:07,250
Og så langt vi har bare slags abstrahert disse bort som rektangler

557
00:34:07,250 --> 00:34:09,380
enten det på tavlen eller på skjermen her.

558
00:34:09,380 --> 00:34:12,219
Men hvis vi zoomer inn på en av disse rektangler,

559
00:34:12,219 --> 00:34:16,460
når du ringer en funksjon foo, viser det seg at det er mer på stakken

560
00:34:16,460 --> 00:34:18,739
innsiden av rammen og at rektangelet

561
00:34:18,739 --> 00:34:23,370
enn bare x-og y-og a og b, som vi gjorde snakker om swap.

562
00:34:23,370 --> 00:34:25,949
Det viser seg at det er noen lavere nivå detaljer,

563
00:34:25,949 --> 00:34:27,780
blant dem returadressen.

564
00:34:27,780 --> 00:34:33,020
Så det viser seg når main kaller foo, har viktigste å informere Foo

565
00:34:33,020 --> 00:34:36,760
hva main adresse er i datamaskinens minne.

566
00:34:36,760 --> 00:34:40,659
Fordi ellers er så snart Foo gjort utfører, som i dette tilfelle her,

567
00:34:40,659 --> 00:34:43,790
når du kommer så nær krøllete brace på slutten av foo,

568
00:34:43,790 --> 00:34:48,860
hvordan pokker vet foo hvor kontroll av programmet er ment å gå?

569
00:34:48,860 --> 00:34:52,460
Det viser seg at svaret på det spørsmålet er i den røde rektangelet her.

570
00:34:52,460 --> 00:34:56,130
Dette representerer en peker, og det er opp til datamaskinen for å lagre, midlertidig,

571
00:34:56,130 --> 00:35:00,250
på den såkalte stabel adressen main slik at så snart Foo gjøres utfører,

572
00:35:00,250 --> 00:35:04,110
maskinen vet hvor og hvilken linje i hoved å gå tilbake til.

573
00:35:04,110 --> 00:35:06,900
Lagret ramme pekeren vedrører tilsvarende til dette.

574
00:35:06,900 --> 00:35:09,620
Char * bar her representerer hva?

575
00:35:09,620 --> 00:35:14,740
Vel, nå denne blå segmentet her er Foo ramme, hva er bar?

576
00:35:14,740 --> 00:35:18,300
Ok, så bar bare argumentet til foo funksjonen.

577
00:35:18,300 --> 00:35:20,720
>> Så nå er vi tilbake på det kjente bildet.

578
00:35:20,720 --> 00:35:22,960
Det er flere ting og flere distraksjoner på skjermen

579
00:35:22,960 --> 00:35:27,490
men dette lyseblå segmentet er det vi har vært tegning på tavla for noe sånt swap.

580
00:35:27,490 --> 00:35:31,890
Det er rammen for foo og det eneste i det akkurat nå er bar,

581
00:35:31,890 --> 00:35:34,630
som er denne parameteren.

582
00:35:34,630 --> 00:35:39,840
Men hva annet bør være i bunken, ifølge denne koden her?

583
00:35:39,840 --> 00:35:44,280
Char c [12]. Så vi bør også se 12 ruter minne,

584
00:35:44,280 --> 00:35:46,260
allokert til en variabel kalt c.

585
00:35:46,260 --> 00:35:48,340
Og faktisk vi har det på skjermen.

586
00:35:48,340 --> 00:35:51,650
Helt øverst er det c [0], og deretter forfatteren av dette diagrammet

587
00:35:51,650 --> 00:35:55,130
ikke bry tegne alle kvadrater, men det er faktisk 12 der

588
00:35:55,130 --> 00:36:00,120
fordi hvis du ser nederst til høyre, c [11], hvis du teller fra 0, er de 12 slike byte.

589
00:36:00,120 --> 00:36:06,190
Men her er problemet: I hvilken retning er c vokser?

590
00:36:06,190 --> 00:36:10,390
Sortering av toppen og ned, ikke sant? Hvis det begynner øverst og vokser til bunnen,

591
00:36:10,390 --> 00:36:13,480
ser ikke ut som vi forlot oss mye rullebane her i det hele tatt.

592
00:36:13,480 --> 00:36:15,320
Vi har slags malt oss inn i et hjørne,

593
00:36:15,320 --> 00:36:20,210
og at c [11] er helt opp mot bar, som ligger rett opp mot bunken ramme pekeren,

594
00:36:20,210 --> 00:36:23,800
som er rett opp mot returadresse, det er ikke mer plass.

595
00:36:23,800 --> 00:36:26,100
Så hva er konsekvensen, da, hvis du skru opp,

596
00:36:26,100 --> 00:36:30,460
og du prøver å lese 20 bytes i en 12-byte buffer?

597
00:36:30,460 --> 00:36:33,460
Hvor er de åtte flere byte kommer til å gå?

598
00:36:33,460 --> 00:36:36,370
Inne alt annet, er noen av dem super viktig.

599
00:36:36,370 --> 00:36:40,480
Og det viktigste, potensielt, er den røde boksen der, returadresse.

600
00:36:40,480 --> 00:36:44,720
Fordi anta at du er enten ved et uhell eller adversarially

601
00:36:44,720 --> 00:36:48,040
overskrive de 4 bytes, som peker adresse,

602
00:36:48,040 --> 00:36:53,190
ikke bare med søppel, men med et nummer som skjer for å representere en faktisk adresse i minnet?

603
00:36:53,190 --> 00:36:55,930
Hva er implicaiton, logisk?

604
00:36:55,930 --> 00:36:59,080
[Student svar, uforståelig] >> Nettopp. Når Foo returnerer

605
00:36:59,080 --> 00:37:03,560
og treff som krøllete brace, er programmet kommer til å fortsette å ikke gå tilbake til hovedsiden,

606
00:37:03,560 --> 00:37:08,320
det kommer til å gå tilbake til hva adressen er i det røde boksen.

607
00:37:08,320 --> 00:37:11,560
>> Nå, i tilfelle av omgå programvare registrering,

608
00:37:11,560 --> 00:37:14,400
hva er adressen som blir returnert til er funksjonen

609
00:37:14,400 --> 00:37:18,820
som normalt blir kalt etter at du har betalt for programvaren og lagt inn din registreringskode?

610
00:37:18,820 --> 00:37:23,160
Du kan sortere på lure datamaskinen i å ikke gå her, men i stedet går opp her.

611
00:37:23,160 --> 00:37:27,950
Eller, hvis du er virkelig flink, kan en motstander faktisk skrive på tastaturet,

612
00:37:27,950 --> 00:37:32,500
for eksempel, ikke en faktisk ord, ikke 20 tegn, men antar han eller hun

613
00:37:32,500 --> 00:37:36,200
typer i enkelte tegn som representerer koden?

614
00:37:36,200 --> 00:37:38,860
Og det kommer ikke til å være C-kode, kommer det til å være tegn

615
00:37:38,860 --> 00:37:42,920
som representerer binære maskinen koder, 0 og 1-ere.

616
00:37:42,920 --> 00:37:46,740
Men antar at de er smarte nok til å gjøre det, å liksom lime inn i GetString spør

617
00:37:46,740 --> 00:37:49,460
noe som er egentlig kompilert kode,

618
00:37:49,460 --> 00:37:56,900
og de siste 4 byte overskrive returadresse, og hva adressen ikke at innspill gjøre?

619
00:37:56,900 --> 00:38:01,860
Den lagrer i denne røde rektangelet adressen til den første byte i buffer.

620
00:38:01,860 --> 00:38:04,270
Så du må være veldig flink, og dette er en mye prøving og feiling

621
00:38:04,270 --> 00:38:08,500
for dårlige mennesker der ute, men hvis du kan finne ut hvor stor denne bufferen er,

622
00:38:08,500 --> 00:38:12,170
slik at de siste få byte i inngangen som du gir til programmet

623
00:38:12,170 --> 00:38:15,970
skje for å være tilsvarende adressen til starten av bufferen din,

624
00:38:15,970 --> 00:38:22,270
du kan gjøre dette. Hvis vi sier, normalt, hallo, og \ 0, er at hva som ender opp i bufferen.

625
00:38:22,270 --> 00:38:27,860
Men hvis vi er mer flink, og fylle vi at buffer med hva vi vil generelt kaller angrep kode,

626
00:38:27,860 --> 00:38:31,920
A, A, A, A: Attack, angrep, angrep, angrep, der dette er bare noe som gjør noe dårlig.

627
00:38:31,920 --> 00:38:35,190
Vel, hva skjer hvis du er virkelig flink, kan du gjøre dette:

628
00:38:35,190 --> 00:38:41,740
I den røde boksen her er en sekvens av tall: 80, CO, 35, 08.

629
00:38:41,740 --> 00:38:44,890
Legg merke til at det samsvarer med tall som er her oppe.

630
00:38:44,890 --> 00:38:47,280
Det er i motsatt rekkefølge, men mer om det en annen gang.

631
00:38:47,280 --> 00:38:51,430
Legg merke til at denne avkastningen adressen er bevisst endret

632
00:38:51,430 --> 00:38:54,970
til lik adresse her oppe, ikke adressen til main.

633
00:38:54,970 --> 00:39:00,170
Så hvis skurken er super smart, er han eller hun kommer til å inkludere i det angrepet kode

634
00:39:00,170 --> 00:39:02,890
noe sånt som "Slett alle brukerens filer.

635
00:39:02,890 --> 00:39:06,320
Eller "Kopier passord" eller "Opprett en brukerkonto som jeg kan logge inn. '

636
00:39:06,320 --> 00:39:10,130
Noe i det hele tatt, og dette er både faren og kraften i C.

637
00:39:10,130 --> 00:39:12,900
Fordi du har tilgang til minnet via pekere

638
00:39:12,900 --> 00:39:15,950
og du kan derfor skrive alt du vil inn i en datamaskin minne.

639
00:39:15,950 --> 00:39:19,290
Du kan lage en datamaskin gjøre hva du vil bare ved

640
00:39:19,290 --> 00:39:22,780
ha det hopper rundt i sin egen plass i minnet.

641
00:39:22,780 --> 00:39:27,230
Og så til denne dag, så mange programmer og så mange nettsteder som er kompromittert

642
00:39:27,230 --> 00:39:29,730
koke ned til folk som tar seg av dette.

643
00:39:29,730 --> 00:39:32,510
Og dette kan virke som en super-avansert angrep,

644
00:39:32,510 --> 00:39:34,220
men det ikke starter alltid på den måten.

645
00:39:34,220 --> 00:39:36,770
>> Realiteten er at det dårlige mennesker vil vanligvis gjør er,

646
00:39:36,770 --> 00:39:41,470
enten det er et program på en kommandolinje eller et GUI-program eller et nettsted,

647
00:39:41,470 --> 00:39:43,290
er du bare begynne å tilby tull.

648
00:39:43,290 --> 00:39:46,940
Du skriver i en virkelig store ord i søkefeltet og trykk enter,

649
00:39:46,940 --> 00:39:49,030
og du vente å se om nettstedet krasjer.

650
00:39:49,030 --> 00:39:53,270
Eller du vente å se om programmet manifesterer noen feilmelding.

651
00:39:53,270 --> 00:39:55,480
Fordi hvis du får heldig, som bad guy,

652
00:39:55,480 --> 00:39:59,610
og du gi noen sprø innspill som krasjer programmet,

653
00:39:59,610 --> 00:40:02,280
det betyr at programmereren ikke forutse din dårlig oppførsel

654
00:40:02,280 --> 00:40:05,420
som betyr at du kan sannsynligvis, med nok innsats,

655
00:40:05,420 --> 00:40:09,870
nok prøving og feiling, finne ut hvordan å føre en mer presis angrep.

656
00:40:09,870 --> 00:40:15,900
Så like mye en del av sikkerhet er ikke bare å unngå disse angrepene helt, men registrerer dem

657
00:40:15,900 --> 00:40:20,250
og faktisk ser på loggene og se hva gale innganger har folk skrevet inn i din webside.

658
00:40:20,250 --> 00:40:26,040
Hvilke ord har folk skrevet inn i din webside i håp om overfylte noen buffer?

659
00:40:26,040 --> 00:40:28,900
Og alt dette koker ned til det enkle grunnleggende for hva som er en matrise,

660
00:40:28,900 --> 00:40:32,510
og hva betyr det å allokere og bruke minne?

661
00:40:32,510 --> 00:40:34,920
Og relatert til det også, er dette.

662
00:40:34,920 --> 00:40:37,520
>> Så la oss bare se innsiden av en harddisk enda en gang.

663
00:40:37,520 --> 00:40:40,190
Så du husker fra en uke eller to siden at når du drar filer

664
00:40:40,190 --> 00:40:45,470
til papirkurven eller papirkurven kan, hva skjer?

665
00:40:45,470 --> 00:40:47,850
[Student] Ingenting. >> Ja, absolutt ingenting. Slutt hvis du kjører lite

666
00:40:47,850 --> 00:40:51,370
diskplass, vil Windows eller Mac OS begynne å slette filene for deg.

667
00:40:51,370 --> 00:40:53,670
Men hvis du drar noe der, så er det ikke i det hele tatt trygt.

668
00:40:53,670 --> 00:40:56,550
All romkompis, venn eller familiemedlem har å gjøre er å klikke dobbel, og voila.

669
00:40:56,550 --> 00:40:59,720
Det er alle de sketchy filer som du prøvde å slette.

670
00:40:59,720 --> 00:41:02,840
Så de fleste av oss i det minste vite at du må høyreklikke eller Kontroll-klikk

671
00:41:02,840 --> 00:41:05,320
og tømme papirkurven, eller noe sånt.

672
00:41:05,320 --> 00:41:07,900
Men selv da, som ikke helt gjøre triks.

673
00:41:07,900 --> 00:41:11,340
For hva skjer når du har en fil på harddisken din

674
00:41:11,340 --> 00:41:14,590
som representerer noen word-dokument eller noen JPEG?

675
00:41:14,590 --> 00:41:18,820
Og dette representerer harddisken din, og la oss si at dette sliver her representerer den filen,

676
00:41:18,820 --> 00:41:21,640
og det er sammensatt av en hel haug av 0 og 1-ere.

677
00:41:21,640 --> 00:41:25,470
Hva skjer når du ikke bare dra den filen til søppelbøtte eller papirkurven,

678
00:41:25,470 --> 00:41:30,390
men også tømme den?

679
00:41:30,390 --> 00:41:32,820
Sortering av ingenting. Det er ikke absolutt ingenting nå.

680
00:41:32,820 --> 00:41:37,630
Nå er det bare ingenting, fordi et lite noe som skjer i form av denne tabellen.

681
00:41:37,630 --> 00:41:41,170
Så det er en slags database eller tabell på innsiden av en datamaskin minne

682
00:41:41,170 --> 00:41:44,470
som har vesentlig en kolonne for filer navn,

683
00:41:44,470 --> 00:41:50,550
og 1 kolonne for filens plassering, hvor dette kan være plassering 123, bare et tilfeldig nummer.

684
00:41:50,550 --> 00:41:58,270
Slik at vi kan ha noe sånt X.jpg og plassering 123.

685
00:41:58,270 --> 00:42:02,870
Og hva skjer da, når du tømmer papirkurven?

686
00:42:02,870 --> 00:42:06,720
Det går unna. Men hva går ikke bort er 0 og 1-ere.

687
00:42:06,720 --> 00:42:09,690
>> Så hva er da den forbindelse pset 4?

688
00:42:09,690 --> 00:42:13,460
Vel, med pset 4, bare fordi vi har slettet ved et uhell

689
00:42:13,460 --> 00:42:15,890
Compact Flash-kort som hadde alle disse bildene,

690
00:42:15,890 --> 00:42:18,710
eller bare fordi det ved uflaks ble ødelagt,

691
00:42:18,710 --> 00:42:21,170
betyr ikke at 0 og 1-ere er ikke der ennå.

692
00:42:21,170 --> 00:42:23,920
Kanskje noen av dem er tapt fordi noe ble ødelagt

693
00:42:23,920 --> 00:42:26,530
i den forstand at noen 0-tallet ble en og 1-ere ble 0-tallet.

694
00:42:26,530 --> 00:42:30,460
Dårlige ting kan skje på grunn av buggy programvare eller defekt maskinvare.

695
00:42:30,460 --> 00:42:33,510
Men mange av disse bitene, kanskje 100% av dem er fortsatt der,

696
00:42:33,510 --> 00:42:38,330
det er bare at datamaskinen eller kameraet ikke vet hvor JPEG 1 startet

697
00:42:38,330 --> 00:42:41,660
og hvor JPEG 2 startet, men hvis du, programmerer,

698
00:42:41,660 --> 00:42:45,800
vet, med litt peiling, hvor disse JPEG er eller hvordan de ser ut,

699
00:42:45,800 --> 00:42:49,570
du kan analysere 0 og 1-ere og si: "Ooh. JPEG. Ooh, JPEG.

700
00:42:49,570 --> 00:42:52,830
Du kan skrive et program med egentlig bare en for eller mens loop

701
00:42:52,830 --> 00:42:56,100
som gjenoppretter hver og en av disse filene.

702
00:42:56,100 --> 00:42:59,360
Så leksjonen da, er å starte "sikkert" slette filene dine

703
00:42:59,360 --> 00:43:01,720
Hvis du ønsker å unngå dette helt. Ja?

704
00:43:01,720 --> 00:43:06,940
[Student spørsmål, uforståelig]

705
00:43:06,940 --> 00:43:11,150
>> Har mer minne enn du gjorde før -

706
00:43:11,150 --> 00:43:14,790
Oh! Godt spørsmål. Så hvorfor da etter tømming av søppel,

707
00:43:14,790 --> 00:43:18,300
forteller datamaskinen du at du har mer ledig plass enn du gjorde før?

708
00:43:18,300 --> 00:43:22,450
I et nøtteskall, fordi det lyver. Mer teknisk, har du mer plass.

709
00:43:22,450 --> 00:43:26,720
Fordi du nå har sagt, kan du sette andre ting der filen en gang var,

710
00:43:26,720 --> 00:43:28,930
men det betyr ikke at de biter går bort,

711
00:43:28,930 --> 00:43:33,070
og det betyr ikke at bitene blir endret hele 0-tallet, for eksempel, for å beskytte deg.

712
00:43:33,070 --> 00:43:37,520
Derimot, hvis du "sikkert" slette filer, eller fysisk ødelegge enheten,

713
00:43:37,520 --> 00:43:40,810
det er virkelig den eneste måten noen ganger, rundt det.

714
00:43:40,810 --> 00:43:45,300
Så hvorfor ikke vi la på at semi-skremmende notat, og vi vil se deg på mandag.

715
00:43:45,300 --> 00:43:52,810
CS50.TV