1
00:00:00,000 --> 00:00:11,200

2
00:00:11,200 --> 00:00:12,580
>> DAVID MALAN: Okej, välkommen tillbaka.

3
00:00:12,580 --> 00:00:13,290
Detta är CS50.

4
00:00:13,290 --> 00:00:15,130
Detta är början på vecka sju.

5
00:00:15,130 --> 00:00:18,890
Så det har varit ett tag, så jag tänkte att vi skulle
ta en virvlande tur av var vi

6
00:00:18,890 --> 00:00:20,760
slutade och där vi är nu på väg.

7
00:00:20,760 --> 00:00:23,310
>> Så denna sak här kan ha
orsakade viss ångest i början.

8
00:00:23,310 --> 00:00:27,680
Men förhoppningsvis, du börjar
anpassa sig till vad det betecknar här -

9
00:00:27,680 --> 00:00:32,670
stjärna som representerar en pekare, som är
precis vad, i mer lekmannaspråk?

10
00:00:32,670 --> 00:00:33,400
Så det är en adress.

11
00:00:33,400 --> 00:00:35,490
>> Så det är adressen till
något i minnet.

12
00:00:35,490 --> 00:00:38,260
Och vi började skära ner lagren
ett par veckor sedan, saker gillar

13
00:00:38,260 --> 00:00:41,800
GetString och andra sådana funktioner
hela denna tid har återvänt

14
00:00:41,800 --> 00:00:46,010
adresser saker i minnet, såsom
adress för det första tecknet i

15
00:00:46,010 --> 00:00:46,990
viss sekvens.

16
00:00:46,990 --> 00:00:50,360
>> Så vi introducerade också Valgrind, vilket
du börjar att använda för detta problem

17
00:00:50,360 --> 00:00:53,380
ställa, i synnerhet för nästa
Problemet satt liksom.

18
00:00:53,380 --> 00:00:54,980
Och Valgrind gör vad för oss?

19
00:00:54,980 --> 00:00:57,520

20
00:00:57,520 --> 00:01:01,020
Den kontrollerar för minnesläckor, och det
kontrollerar också för missbruk av minnet.

21
00:01:01,020 --> 00:01:05,890
>> Det kan, med viss sannolikhet, upptäcka om
din kod kommer att beröra minne

22
00:01:05,890 --> 00:01:07,100
att det borde helt enkelt inte.

23
00:01:07,100 --> 00:01:10,410
Så inte nödvändigtvis en läcka, men om du
går utöver gränserna för vissa

24
00:01:10,410 --> 00:01:14,730
array, och du kör faktiskt valgrind
och framkalla detta beteende medan

25
00:01:14,730 --> 00:01:17,870
Valgrind körs i ditt program är
kör inne i den, får du

26
00:01:17,870 --> 00:01:21,460
meddelanden som detta - "ogiltigt skriver om
storlek 4, "där, minns ett par

27
00:01:21,460 --> 00:01:25,880
veckor innebar sedan att jag hade av misstag
gillar på en int för långt

28
00:01:25,880 --> 00:01:27,250
utanför gränserna för en array.

29
00:01:27,250 --> 00:01:30,790
Och så storlek 4 betyder här storleken
av just int.

30
00:01:30,790 --> 00:01:35,260
>> Så ta trygghet i det faktum att
valgrind s produktion, formatet för den,

31
00:01:35,260 --> 00:01:36,170
är bara avskyvärda.

32
00:01:36,170 --> 00:01:40,180
Det är verkligen svårt att se igenom röran
för den intressanta informationen.

33
00:01:40,180 --> 00:01:42,910
Så vad vi har gjort här är bara utdrag
några av de par mer

34
00:01:42,910 --> 00:01:43,850
intressanta linjer.

35
00:01:43,850 --> 00:01:46,760
Men inser att 80% av valgrind s
produktionen kommer att vara lite av en

36
00:01:46,760 --> 00:01:47,650
distraktion.

37
00:01:47,650 --> 00:01:52,820
>> Bara leta efter mönster som dessa -
ogiltig rätt, ogiltig läsa, 40 byte

38
00:01:52,820 --> 00:01:56,690
och några antal block är definitivt
förlorade, sökord som.

39
00:01:56,690 --> 00:02:01,920
Och vad kommer du förhoppningsvis se en viss
typ av spår av vilken funktion

40
00:02:01,920 --> 00:02:03,340
misstag är faktiskt i.

41
00:02:03,340 --> 00:02:07,195
I det här fallet, i vilken linje
min kod var felet tydligen?

42
00:02:07,195 --> 00:02:09,729

43
00:02:09,729 --> 00:02:14,130
>> 26 i en fil som kallas memory.c, som var
exemplet vi spelade med

44
00:02:14,130 --> 00:02:14,890
vid den tidpunkten.

45
00:02:14,890 --> 00:02:16,460
Så det är nog inte i malloc.

46
00:02:16,460 --> 00:02:18,630
Det var nog i min kod istället.

47
00:02:18,630 --> 00:02:20,910
Så vi får se detta igen
och igen innan lång.

48
00:02:20,910 --> 00:02:24,080
>> Så scanf, kom detta upp i en
par blanketter hittills.

49
00:02:24,080 --> 00:02:26,410
Vi såg sscanf kortfattat.

50
00:02:26,410 --> 00:02:28,330
Det var något som ett antal
du dök in i din

51
00:02:28,330 --> 00:02:29,535
förberedelserna för frågesport.

52
00:02:29,535 --> 00:02:33,130
Och scanf är faktiskt vad CS50
Biblioteket har använt under

53
00:02:33,130 --> 00:02:36,560
huva för ganska länge för
att få input från användaren.

54
00:02:36,560 --> 00:02:40,420
>> Till exempel, om jag flyttar över till CS50
apparaten här, låt mig öppna upp en

55
00:02:40,420 --> 00:02:45,315
exempel idag som heter scanf-0.c
Och det är super enkelt.

56
00:02:45,315 --> 00:02:46,590
Det är bara några få rader kod.

57
00:02:46,590 --> 00:02:50,880
Men det visar verkligen hur getInt
har arbetat hela denna tid.

58
00:02:50,880 --> 00:02:54,710
>> I detta program här, i linje 16
, Märker att jag deklarera en int.

59
00:02:54,710 --> 00:02:57,270
Så inga pekare, inget magiskt
där, bara en int.

60
00:02:57,270 --> 00:03:00,330
Sedan i linje 17, meddelar jag
användaren för ett antal, tack.

61
00:03:00,330 --> 00:03:02,930
Sedan i slutet av 18, jag använder scanf här.

62
00:03:02,930 --> 00:03:06,910
Och jag specificerade, ungefär som printf,
att jag väntar citat

63
00:03:06,910 --> 00:03:08,110
unquote procent i.

64
00:03:08,110 --> 00:03:10,920
>> Så procent i, naturligtvis,
betecknar en int.

65
00:03:10,920 --> 00:03:14,580
Men märker vad den andra
argument till scanf är.

66
00:03:14,580 --> 00:03:17,350
Hur skulle du beskriva den andra
argument efter kommatecknet?

67
00:03:17,350 --> 00:03:19,450
Vad är det?

68
00:03:19,450 --> 00:03:20,670
>> Det är den adress x.

69
00:03:20,670 --> 00:03:25,490
Så detta är användbart eftersom genom att tillhandahålla
scanf med adressen till x, vad

70
00:03:25,490 --> 00:03:29,560
att ge den funktionen att göra?

71
00:03:29,560 --> 00:03:33,010
Inte bara åka dit, men också göra det?

72
00:03:33,010 --> 00:03:34,060
>> Gör en ändring till den.

73
00:03:34,060 --> 00:03:38,080
Eftersom du kan åka dit, det är typ av
som en karta till en plats i minnet.

74
00:03:38,080 --> 00:03:41,900
Och så länge du ger scanf, eller
någon funktion med en sådan karta, som

75
00:03:41,900 --> 00:03:45,840
Funktionen kan åka dit, och inte bara
titta på värdet, men det kan också

76
00:03:45,840 --> 00:03:49,670
ändra detta värde, vilket är användbart om
syftet i livet med scanf är att

77
00:03:49,670 --> 00:03:53,060
skanna inmatning från användaren, särskilt
från tangentbordet.

78
00:03:53,060 --> 00:03:57,830
Och f betecknar formaterade, precis som
printf, betecknar f ett formaterat

79
00:03:57,830 --> 00:03:58,930
sträng som du vill skriva ut.

80
00:03:58,930 --> 00:04:04,430
>> Så kort sagt, denna linje 18 bara säger,
försöker läsa ett int från användarens

81
00:04:04,430 --> 00:04:10,420
tangentbord och förvara den inne i x, vid
oavsett adress x råkar leva på.

82
00:04:10,420 --> 00:04:14,860
Och sedan slutligen, linje 19 bara säger,
tack för int, i det här fallet.

83
00:04:14,860 --> 00:04:15,940
>> Så låt mig gå vidare och göra det.

84
00:04:15,940 --> 00:04:18,570
Så gör scanf 0.

85
00:04:18,570 --> 00:04:20,130
Låt mig gå vidare och zooma in

86
00:04:20,130 --> 00:04:22,960
Jag ska gå och köra med
prickar slash scanf 0.

87
00:04:22,960 --> 00:04:24,020
Number, snälla?

88
00:04:24,020 --> 00:04:24,720
50.

89
00:04:24,720 --> 00:04:25,730
Tack för 50.

90
00:04:25,730 --> 00:04:27,270
Så det är ganska enkelt.

91
00:04:27,270 --> 00:04:28,160
>> Nu vad gör inte?

92
00:04:28,160 --> 00:04:29,940
Det gör inte en hel massa
av felkontroll.

93
00:04:29,940 --> 00:04:33,000
Till exempel, om jag inte samarbetar,
och jag skriver inte på ett nummer, men

94
00:04:33,000 --> 00:04:37,860
istället skriver jag något som "hej"
det är bara slags märkligt.

95
00:04:37,860 --> 00:04:41,130
Och så en av de saker de CS50
Biblioteket har gjort för oss för några

96
00:04:41,130 --> 00:04:43,440
tiden är att reprompting
och reprompting.

97
00:04:43,440 --> 00:04:49,320
>> Den retry frasen minns var i cs50.c,
och det är anledningen till att getInt i

98
00:04:49,320 --> 00:04:51,670
den CS50 biblioteket är faktiskt en hel
gäng rader lång, eftersom vi är

99
00:04:51,670 --> 00:04:53,190
kontroll för dumma saker som denna.

100
00:04:53,190 --> 00:04:55,730
Har användaren inte ge
oss, i själva verket, en int?

101
00:04:55,730 --> 00:04:57,910
Har han eller hon ge oss något
som en alfabetisk bokstav?

102
00:04:57,910 --> 00:05:01,410
Om så, vill vi att upptäcka
det och skrika på dem.

103
00:05:01,410 --> 00:05:03,915
>> Men det blir mer intressant
i nästa exempel.

104
00:05:03,915 --> 00:05:09,840
Om jag går till scanf-1 c, är vad en
sak som ändras radikalt i

105
00:05:09,840 --> 00:05:11,135
nästa exempel?

106
00:05:11,135 --> 00:05:13,690

107
00:05:13,690 --> 00:05:16,010
Jag använder char *, naturligtvis,
istället för int.

108
00:05:16,010 --> 00:05:19,210
>> Så det här är intressant, eftersom char *,
minns, är egentligen bara

109
00:05:19,210 --> 00:05:20,190
Samma sak som sträng.

110
00:05:20,190 --> 00:05:23,840
Så det känns som det kanske detta är en super
enkel implementering av GetString.

111
00:05:23,840 --> 00:05:26,010
Men jag har skalat tillbaka lagret
av CS50 biblioteket, så jag är

112
00:05:26,010 --> 00:05:27,550
kallar denna char * nu.

113
00:05:27,550 --> 00:05:30,070
Så låt oss se var, om någonstans,
vi går fel.

114
00:05:30,070 --> 00:05:30,840
>> Linje 17 -

115
00:05:30,840 --> 00:05:33,950
Jag säger det igen, ge mig något,
i detta fall en sträng.

116
00:05:33,950 --> 00:05:37,940
Och sedan i nästa rad, kallar jag scanf,
igen, ge det ett format kod,

117
00:05:37,940 --> 00:05:39,310
men denna gång procent s.

118
00:05:39,310 --> 00:05:41,900
Och så den här gången, jag är
ge den buffert.

119
00:05:41,900 --> 00:05:43,550
>> Nu märker, jag inte använder
et-tecknet.

120
00:05:43,550 --> 00:05:47,120
Men varför är det förmodligen OK här?

121
00:05:47,120 --> 00:05:49,760
För vad är bufferten redan?

122
00:05:49,760 --> 00:05:50,770
Det är redan en pekare.

123
00:05:50,770 --> 00:05:51,650
Det är redan en adress.

124
00:05:51,650 --> 00:05:54,510
>> Och låt oss detta ord "förvirra," låt mig
bara kalla det s, till exempel för

125
00:05:54,510 --> 00:05:55,050
enkelhet.

126
00:05:55,050 --> 00:05:58,250
Men jag har kallat den buffert eftersom
allmänhet, i programmering, om du har en

127
00:05:58,250 --> 00:06:02,130
bit av minnet, som en sträng egentligen
bara är, kan man kalla det en buffert.

128
00:06:02,130 --> 00:06:04,460
Det är en plats att lagra information.

129
00:06:04,460 --> 00:06:07,400
>> Liknar saker som YouTube, då
de är buffring, så att säga, att

130
00:06:07,400 --> 00:06:10,270
bara betyder det att ladda ner bitar från
Internet och lagra dem i en

131
00:06:10,270 --> 00:06:14,160
lokal array, en lokal del av minnet så
att du kan titta på det senare utan

132
00:06:14,160 --> 00:06:16,830
det hoppar eller hänger på
du under uppspelning.

133
00:06:16,830 --> 00:06:20,930
>> Så det finns ett problem här men,
eftersom jag säger scanf, förvänta sig en

134
00:06:20,930 --> 00:06:22,320
strängen från användaren.

135
00:06:22,320 --> 00:06:24,410
Här är adressen till
en bit av minnet.

136
00:06:24,410 --> 00:06:26,180
Sätt den strängen där.

137
00:06:26,180 --> 00:06:31,230
Varför är det bundet ge
oss problem, men?

138
00:06:31,230 --> 00:06:33,490
>> Vad är det?

139
00:06:33,490 --> 00:06:35,510
Får jag komma
den del av minnet?

140
00:06:35,510 --> 00:06:36,250
Du vet, jag vet inte.

141
00:06:36,250 --> 00:06:39,210
Eftersom har buffert initierats
till någonting?

142
00:06:39,210 --> 00:06:39,820
Inte riktigt.

143
00:06:39,820 --> 00:06:43,090
Och så det är vad vi har ringt
ett skräp värde, vilket

144
00:06:43,090 --> 00:06:44,040
är inte ett formellt ord.

145
00:06:44,040 --> 00:06:49,200
Det betyder bara att vi har ingen aning om vad bitar
är inne på de fyra byte som

146
00:06:49,200 --> 00:06:51,240
Jag har tilldelats som buffert.

147
00:06:51,240 --> 00:06:52,450
>> Jag har inte kallat malloc.

148
00:06:52,450 --> 00:06:53,940
Jag har definitivt inte kallas GetString.

149
00:06:53,940 --> 00:06:56,380
Så vem vet vad som faktiskt
insidan av buffert?

150
00:06:56,380 --> 00:07:00,550
Och ändå säger scanf blint, dit
och ange vad användaren skrivit.

151
00:07:00,550 --> 00:07:04,460
>> Så vad är sannolikt att orsaka
i vår kod, om vi kör det?

152
00:07:04,460 --> 00:07:05,700
Förmodligen en segfault.

153
00:07:05,700 --> 00:07:07,970
Kanske inte, men förmodligen en segfault.

154
00:07:07,970 --> 00:07:10,620
Och jag säger kanske inte eftersom det ibland
du gör, ibland

155
00:07:10,620 --> 00:07:11,380
du får inte en segfault.

156
00:07:11,380 --> 00:07:14,280
Ibland får man bara tur, men
det ändå kommer att vara

157
00:07:14,280 --> 00:07:15,340
en bugg i vårt program.

158
00:07:15,340 --> 00:07:17,060
>> Så låt mig gå vidare och sammanställa detta.

159
00:07:17,060 --> 00:07:18,280
Jag kommer att göra det enligt den gamla skolan.

160
00:07:18,280 --> 00:07:23,825
Så klang dash 0, scanf-1,
scanf-1.c, Enter.

161
00:07:23,825 --> 00:07:24,720
Oops, för gammal skola.

162
00:07:24,720 --> 00:07:26,550
Låt oss se.

163
00:07:26,550 --> 00:07:28,440
Vart tog jag vägen?

164
00:07:28,440 --> 00:07:29,700
Åh, char * buffert.

165
00:07:29,700 --> 00:07:33,595

166
00:07:33,595 --> 00:07:35,130
Åh, tack -

167
00:07:35,130 --> 00:07:36,930
Spara, OK -

168
00:07:36,930 --> 00:07:37,690
mycket gamla skolan.

169
00:07:37,690 --> 00:07:38,900
Okej, det har varit ett tag.

170
00:07:38,900 --> 00:07:41,720
>> Så jag har bara sparat filen efter
vilket gör att tillfälliga

171
00:07:41,720 --> 00:07:42,700
ändra en stund sedan.

172
00:07:42,700 --> 00:07:46,090
Och nu har jag sammanställt det
manuellt med Clang.

173
00:07:46,090 --> 00:07:49,500
Och nu ska jag gå vidare
och kör scanf-1, Enter.

174
00:07:49,500 --> 00:07:50,290
String vänligen.

175
00:07:50,290 --> 00:07:51,600
Jag ska skriva in "hej."

176
00:07:51,600 --> 00:07:54,070
>> Och nu, här där, uppriktigt sagt, printf
kan är lite irriterande.

177
00:07:54,070 --> 00:07:56,020
Det är faktiskt inte kommer att
segfault i detta fall.

178
00:07:56,020 --> 00:07:59,860
Printf är lite speciell eftersom
det är så super vanligt att

179
00:07:59,860 --> 00:08:03,570
huvudsak printf gör
oss en tjänst och inse,

180
00:08:03,570 --> 00:08:04,830
det är inte en giltig pekare.

181
00:08:04,830 --> 00:08:09,080
Låt mig ta det på mig att bara skriva ut
anges i parentes null, även

182
00:08:09,080 --> 00:08:13,340
men det är inte nödvändigtvis vad
vi själva förväntat.

183
00:08:13,340 --> 00:08:16,940
>> Så vi kan inte riktigt lätt framkalla en
segfault med detta, men tydligt detta

184
00:08:16,940 --> 00:08:18,600
är inte det beteende som jag ville.

185
00:08:18,600 --> 00:08:19,800
Så vad är den enkla lösningen?

186
00:08:19,800 --> 00:08:25,650
Tja, i scanf-2, låt mig föreslå att
stället för att faktiskt bara allokera en

187
00:08:25,650 --> 00:08:30,100
char *, låt mig vara lite smartare om
detta, och låt mig allokera buffert

188
00:08:30,100 --> 00:08:32,940
som en sekvens av 16 tecken.

189
00:08:32,940 --> 00:08:34,200
>> Så jag kan göra detta på ett par olika sätt.

190
00:08:34,200 --> 00:08:35,610
Jag skulle absolut använda malloc.

191
00:08:35,610 --> 00:08:38,980
Men jag kan gå tillbaka till vecka två när
Jag behövde bara en massa

192
00:08:38,980 --> 00:08:39,620
tecken.

193
00:08:39,620 --> 00:08:40,860
Det är bara en array.

194
00:08:40,860 --> 00:08:44,870
Så låt mig i stället omdefiniera buffert
att vara en matris med 16 tecken.

195
00:08:44,870 --> 00:08:47,340
>> Och nu, när jag passerar buffert -

196
00:08:47,340 --> 00:08:49,940
och detta är något vi inte
prata om i vecka två -

197
00:08:49,940 --> 00:08:53,730
men du kan behandla en array som
även om det är en adress.

198
00:08:53,730 --> 00:08:56,390
Tekniskt, som vi har sett, de är
lite annorlunda.

199
00:08:56,390 --> 00:09:01,290
Men scanf inget emot om du klarar det
namnet på en matris, eftersom det

200
00:09:01,290 --> 00:09:05,030
Klang kommer att göra för oss är i huvudsak
behandla namnet på den matris som

201
00:09:05,030 --> 00:09:08,280
adressen för den bit av 16 byte.

202
00:09:08,280 --> 00:09:09,550
>> Så det här är bättre.

203
00:09:09,550 --> 00:09:12,110
Detta innebär nu att jag kan förhoppningsvis
gör följande.

204
00:09:12,110 --> 00:09:16,800
Låt mig zooma ut för ett ögonblick och
gör att scanf-2, sammanställs OK.

205
00:09:16,800 --> 00:09:19,390
Nu låt mig göra fick slash scanf-2.

206
00:09:19,390 --> 00:09:22,430
String vänligen. "Hej." Och det
verkade fungera den här gången.

207
00:09:22,430 --> 00:09:26,020
>> Men kan någon föreslå ett scenario
där det kanske inte fortfarande fungerar?

208
00:09:26,020 --> 00:09:28,550
Yeah?

209
00:09:28,550 --> 00:09:30,640
Något längre än 16 tecken.

210
00:09:30,640 --> 00:09:32,020
Och faktiskt, kan vi vara
lite mer exakt.

211
00:09:32,020 --> 00:09:36,540
Något längre än 15 tecken,
eftersom vi verkligen behöver för att hålla i minnet

212
00:09:36,540 --> 00:09:39,920
att vi behöver att backslash noll
implicit i slutet av strängen,

213
00:09:39,920 --> 00:09:42,950
vilket är en åt sidan scanf kommer typiskt
ta hand om för oss.

214
00:09:42,950 --> 00:09:46,210
>> Så låt mig göra något liknande -

215
00:09:46,210 --> 00:09:48,040
Ibland kan vi bara
lämna det så.

216
00:09:48,040 --> 00:09:50,630
OK, så vi har nu inducerad
vår segmentering fel.

217
00:09:50,630 --> 00:09:51,000
Varför?

218
00:09:51,000 --> 00:09:54,940
Eftersom jag skrev till mer än 15
tecken, och så vi har faktiskt

219
00:09:54,940 --> 00:09:58,280
rörd minne som jag faktiskt
bör inte ha.

220
00:09:58,280 --> 00:10:00,180
>> Så vad är egentligen lösningen här?

221
00:10:00,180 --> 00:10:02,210
Tja, vad händer om vi behöver en längre sträng?

222
00:10:02,210 --> 00:10:03,960
Tja, gör vi det kanske 32 bytes.

223
00:10:03,960 --> 00:10:05,160
Tja, tänk om det inte är länge nog?

224
00:10:05,160 --> 00:10:06,040
Vad sägs om 64 byte?

225
00:10:06,040 --> 00:10:07,080
Tänk om det inte är länge nog?

226
00:10:07,080 --> 00:10:09,640
Vad sägs om 128 eller 200 byte?

227
00:10:09,640 --> 00:10:12,660
Vad är egentligen lösningen här i
allmänna fallet, om vi inte vet i

228
00:10:12,660 --> 00:10:14,460
förhand vad användaren kommer att skriva?

229
00:10:14,460 --> 00:10:20,000

230
00:10:20,000 --> 00:10:23,050
>> Det är bara typ av en stor smärta i röven,
att vara ärlig, vilket är anledningen till den

231
00:10:23,050 --> 00:10:29,050
CS50 biblioteket har några dussin rader
kod som kollektivt genomföra

232
00:10:29,050 --> 00:10:32,390
GetString sträng på ett sätt som vi inte
måste veta i förväg vad

233
00:10:32,390 --> 00:10:33,430
Användaren kommer att skriva.

234
00:10:33,430 --> 00:10:37,370
I synnerhet om man ser tillbaka på
cs50.c från två veckor sedan, kommer du att se

235
00:10:37,370 --> 00:10:40,480
att GetString gör faktiskt
inte använda scanf på detta sätt.

236
00:10:40,480 --> 00:10:43,720
Snarare, läser den ett tecken
åt gången.

237
00:10:43,720 --> 00:10:46,010
>> Eftersom den ena fina
läser ett tecken är att vi kan

238
00:10:46,010 --> 00:10:48,490
garantera oss att alltid
ha minst en röding.

239
00:10:48,490 --> 00:10:51,740
Jag kan bara förklara en röding, och sedan ta
dessa verkligt baby steg till strax

240
00:10:51,740 --> 00:10:54,380
Läs ett tecken in på en
tiden från tangentbordet.

241
00:10:54,380 --> 00:10:58,240
Och sedan, vad du ser GetString
gör är varje gång det tar slut,

242
00:10:58,240 --> 00:11:02,280
säga, 16 byte minne, använder den
malloc, eller en kusin därav, att

243
00:11:02,280 --> 00:11:06,810
allokera mer minne, kopierar den gamla
minnet i den nya, och sedan krypa

244
00:11:06,810 --> 00:11:09,900
tillsammans, att få ett tecken i tiden,
och när det tar slut i det

245
00:11:09,900 --> 00:11:13,370
bit av minnet, kastar bort det, grabs
en större bit av minnet, kopierar gamla

246
00:11:13,370 --> 00:11:14,750
till nya, och upprepar.

247
00:11:14,750 --> 00:11:18,480
Och det är verkligen en smärta att faktiskt
genomföra något så enkelt som

248
00:11:18,480 --> 00:11:19,710
få input från en användare.

249
00:11:19,710 --> 00:11:21,090
>> Så du kan använda scanf.

250
00:11:21,090 --> 00:11:22,430
Du kan använda andra liknande funktioner.

251
00:11:22,430 --> 00:11:25,420
Och en hel del läroböcker och nätet
exempel gör, men de är alla

252
00:11:25,420 --> 00:11:27,210
sårbara för problem som detta.

253
00:11:27,210 --> 00:11:29,550
Och slutligen, få en segfault
är typ av irriterande.

254
00:11:29,550 --> 00:11:30,680
Det är inte bra för användaren.

255
00:11:30,680 --> 00:11:33,560
>> Men i värsta fall, vad gör
det lägger grunden din

256
00:11:33,560 --> 00:11:37,160
kod vid risk?

257
00:11:37,160 --> 00:11:39,250
Något slags angrepp, potentiellt.

258
00:11:39,250 --> 00:11:41,680
Vi pratade om en sådan attack -
överfyllda bunten.

259
00:11:41,680 --> 00:11:44,660
Men i allmänhet, om du får
spilla en buffert, som vi gjorde en

260
00:11:44,660 --> 00:11:48,070
par veckor sedan, med bara skriva
mer än "hej" på stacken, du

261
00:11:48,070 --> 00:11:52,330
kan faktiskt ta över, potentiellt, en
dator, eller åtminstone komma på data som

262
00:11:52,330 --> 00:11:53,510
tillhör inte dig.

263
00:11:53,510 --> 00:11:55,970
>> Så kort sagt, det är därför vi har
dessa stödhjul.

264
00:11:55,970 --> 00:11:59,090
Men nu börjar vi att ta bort dem,
eftersom våra program inte längre behöver,

265
00:11:59,090 --> 00:12:00,610
nödvändigtvis, inmatning från användaren.

266
00:12:00,610 --> 00:12:03,960
Men i fallet med problem som sex,
din inmatning kommer från en enorm

267
00:12:03,960 --> 00:12:07,520
ordlistefilen med 150 några
udda tusen ord.

268
00:12:07,520 --> 00:12:10,330
>> Så du inte behöver oroa dig
användarens godtyckliga indata.

269
00:12:10,330 --> 00:12:13,720
Vi kommer att ge dig några antaganden
om den filen.

270
00:12:13,720 --> 00:12:20,340
Eventuella frågor om pekare eller scanf
eller användarens input i allmänhet?

271
00:12:20,340 --> 00:12:24,450
>> Okej, så en snabb titt och sedan på en
släpande ämne från två veckor sedan.

272
00:12:24,450 --> 00:12:28,590
Och det var denna föreställning om en struct.

273
00:12:28,590 --> 00:12:34,180
Inte att - denna föreställning om en
struct, vilket var vad?

274
00:12:34,180 --> 00:12:35,430
Vad gjorde struct göra för oss?

275
00:12:35,430 --> 00:12:39,280

276
00:12:39,280 --> 00:12:39,860
>> Define -

277
00:12:39,860 --> 00:12:41,710
ledsen?

278
00:12:41,710 --> 00:12:42,820
Definiera en variabel typ.

279
00:12:42,820 --> 00:12:44,410
Så sortera om.

280
00:12:44,410 --> 00:12:46,180
Vi är faktiskt kombinera två ämnen.

281
00:12:46,180 --> 00:12:49,510
Så med typedef, minns att vi kan
deklarera en typ av vår egen, som en

282
00:12:49,510 --> 00:12:51,500
synonym, liksom sträng för char *.

283
00:12:51,500 --> 00:12:56,200
Men med hjälp av typedef och struct, kan vi
skapa verkligt egna datastrukturer.

284
00:12:56,200 --> 00:12:59,600
>> Till exempel, om jag går tillbaka in i gedit
här för bara ett ögonblick, och jag går vidare

285
00:12:59,600 --> 00:13:08,230
och göra något liknande, låt mig sparar
detta som, låt oss säga, structs.c

286
00:13:08,230 --> 00:13:10,840
tillfälligt, jag ska bara
att gå vidare och inkludera

287
00:13:10,840 --> 00:13:14,360
standardio.h, int main tomrum.

288
00:13:14,360 --> 00:13:18,960
Och sedan i här, antar att jag vill ha
att skriva ett program som lagrar

289
00:13:18,960 --> 00:13:21,840
flera studenter från flera
hus, till exempel.

290
00:13:21,840 --> 00:13:24,430
Så det är som en registrarial
databas av något slag.

291
00:13:24,430 --> 00:13:29,550
>> Så om jag behöver namnet en student, jag
kanske göra något liknande char * namn,

292
00:13:29,550 --> 00:13:31,570
och jag ska göra något liknande -

293
00:13:31,570 --> 00:13:34,410
faktiskt, låt oss använda CS50 biblioteket
för bara en stund för att göra detta till en

294
00:13:34,410 --> 00:13:38,380
lite enklare, så att vi kan låna
de dussintals rader kod.

295
00:13:38,380 --> 00:13:39,340
Och låt oss bara hålla det enkelt.

296
00:13:39,340 --> 00:13:42,610
Vi ska hålla det sträng,
och nu getString.

297
00:13:42,610 --> 00:13:47,420
>> Så jag hävdar nu att jag har sparat namnet
av någon elev, och hus

298
00:13:47,420 --> 00:13:50,240
vissa studerande, helt enkelt med hjälp av variabler
som vi gjorde, och i vecka ett.

299
00:13:50,240 --> 00:13:52,370
Men antar att jag nu vill stödja
flera studenter.

300
00:13:52,370 --> 00:13:58,460
Okej, så min instinkt är att göra
string namn2, blir GetString, sträng

301
00:13:58,460 --> 00:14:01,370
house2 blir GetString.

302
00:14:01,370 --> 00:14:05,850
Och då vår tredje elev,
låt oss göra NAME3 GetString.

303
00:14:05,850 --> 00:14:09,170
>> Okej, så det är förhoppningsvis slående
dig som ett slags dum,

304
00:14:09,170 --> 00:14:11,580
eftersom denna process är egentligen aldrig
kommer att sluta, och det kommer bara att

305
00:14:11,580 --> 00:14:13,130
gör min kod ser värre
och värre och värre.

306
00:14:13,130 --> 00:14:14,810
Men vi löste det också i vecka två.

307
00:14:14,810 --> 00:14:19,450
Vad var vår relativt ren lösning
när vi hade flera variabler av

308
00:14:19,450 --> 00:14:23,580
samma datatyp som alla är relaterade, men
Vi ville inte att denna fruktansvärda röran

309
00:14:23,580 --> 00:14:26,870
av liknande namn variabler?

310
00:14:26,870 --> 00:14:30,060
Vad gjorde vi i stället?

311
00:14:30,060 --> 00:14:31,260
>> Så jag tror att jag hörde ett par ställen.

312
00:14:31,260 --> 00:14:32,590
Vi hade en matris.

313
00:14:32,590 --> 00:14:37,110
Om du vill ha flera instanser av
något, varför inte vi rengöra alla

314
00:14:37,110 --> 00:14:39,540
upp och bara säga, ge mig
array kallas namn?

315
00:14:39,540 --> 00:14:41,640
>> Och för nu, låt oss hårt kod 3.

316
00:14:41,640 --> 00:14:44,450
Och sedan ge mig en annan array
kallas hus, och låt mig för

317
00:14:44,450 --> 00:14:45,800
nu hårt kod 3.

318
00:14:45,800 --> 00:14:49,220
Och jag har massivt städas upp
förstöra som jag nyss skapat.

319
00:14:49,220 --> 00:14:52,400
Nu har jag fortfarande svårt kodad 3, men även
3 kunde dynamiskt komma från

320
00:14:52,400 --> 00:14:54,350
användare eller argv, eller liknande.

321
00:14:54,350 --> 00:14:55,720
Så detta är redan renare.

322
00:14:55,720 --> 00:15:00,100
>> Men vad är irriterande med detta är att
Nu är även ett namn på något sätt

323
00:15:00,100 --> 00:15:02,280
fundamentalt kopplad till
en students hus -

324
00:15:02,280 --> 00:15:04,720
det är en elev som jag verkligen
vill representera -

325
00:15:04,720 --> 00:15:08,080
Jag har nu två arrayer som är parallella
i den meningen att de är de

326
00:15:08,080 --> 00:15:13,930
samma storlek och namn konsol 0
förmodligen kartor till hus konsol 0,

327
00:15:13,930 --> 00:15:16,600
och namn på konsolen 1 kartor
till hus bracket 1.

328
00:15:16,600 --> 00:15:19,280
Med andra ord, den studerande bor i
det huset, och att andra studerande

329
00:15:19,280 --> 00:15:20,530
bor i det andra huset.

330
00:15:20,530 --> 00:15:23,720
Men visst kan detta vara
gjort ännu renare.

331
00:15:23,720 --> 00:15:24,990
>> Tja, det kan i själva verket.

332
00:15:24,990 --> 00:15:28,730
Och låt mig gå vidare och öppna
upp structs.h, och du kommer

333
00:15:28,730 --> 00:15:31,130
se denna idé här.

334
00:15:31,130 --> 00:15:34,905
Lägg märke till att jag har använt typedef, som ni
hänvisade till för en stund sedan att förklara vår

335
00:15:34,905 --> 00:15:35,570
egen datatyp.

336
00:15:35,570 --> 00:15:39,660
Men jag använder också denna andra sökord
kallas struct som ger mig en ny

337
00:15:39,660 --> 00:15:40,790
datastruktur.

338
00:15:40,790 --> 00:15:43,980
>> Och denna datastruktur jag hävdar går
att ha två saker inuti

339
00:15:43,980 --> 00:15:47,060
det - en sträng som heter namn, och
en sträng som kallas hus.

340
00:15:47,060 --> 00:15:49,820
Och namnet jag ska ge till
denna datastruktur kommer

341
00:15:49,820 --> 00:15:51,005
att kallas student.

342
00:15:51,005 --> 00:15:54,030
Jag skulle kunna kalla det vad jag vill,
men detta göra semantiskt

343
00:15:54,030 --> 00:15:55,810
meningsfullt för mig i mitt sinne.

344
00:15:55,810 --> 00:15:59,160
>> Så nu, om jag öppnar upp en bättre version
av det program jag började skriva

345
00:15:59,160 --> 00:16:00,390
det, låt mig rulla till toppen.

346
00:16:00,390 --> 00:16:03,190
Och det finns några fler rader kod
här, men låt mig fokusera för

347
00:16:03,190 --> 00:16:04,160
det ögonblick på en.

348
00:16:04,160 --> 00:16:07,790
Jag har förklarat en konstant kallade studenter
och hårdkodade 3 för nu.

349
00:16:07,790 --> 00:16:11,110
Men nu, märker hur ren
min kod börjar komma.

350
00:16:11,110 --> 00:16:15,030
>> I linje 22, förklarar jag
samling av studenter.

351
00:16:15,030 --> 00:16:18,760
Och märker att studenten är tydligen
nu en datatyp.

352
00:16:18,760 --> 00:16:23,360
Eftersom på toppen av denna fil, märker
Jag har bland annat varit sidhuvudfilen

353
00:16:23,360 --> 00:16:24,820
att jag drog upp nyss.

354
00:16:24,820 --> 00:16:28,820
Och att header-fil helt enkelt hade
denna definition av en elev.

355
00:16:28,820 --> 00:16:32,470
>> Så nu har jag skapat min egna uppgifter
typ att författarna C år

356
00:16:32,470 --> 00:16:33,890
sedan inte tänka på i förväg.

357
00:16:33,890 --> 00:16:34,570
Men inga problem.

358
00:16:34,570 --> 00:16:35,870
Jag kan göra det själv.

359
00:16:35,870 --> 00:16:39,050
Så detta är en array kallas studenter,
vars samtliga medlemmar

360
00:16:39,050 --> 00:16:41,100
är en student struktur.

361
00:16:41,100 --> 00:16:44,270
Och jag vill ha tre av dem
i arrayen.

362
00:16:44,270 --> 00:16:46,030
>> Och nu, vad gör resten
av detta program göra?

363
00:16:46,030 --> 00:16:47,550
Jag behövde något lite godtyckligt.

364
00:16:47,550 --> 00:16:51,450
Så från nätet 24 och framåt,
Jag iterera från 0 till 3.

365
00:16:51,450 --> 00:16:54,000
Jag frågar då användaren för
studentens namn.

366
00:16:54,000 --> 00:16:56,110
Och då jag använder getString som förut.

367
00:16:56,110 --> 00:16:59,410
Då frågar jag för elevens huset,
och jag använder getString som tidigare.

368
00:16:59,410 --> 00:17:01,780
>> Men varsel - något nytt
bit syntax -

369
00:17:01,780 --> 00:17:07,010
Jag kan fortfarande index till det i: te studerande,
men hur får jag på de specifika uppgifter

370
00:17:07,010 --> 00:17:08,354
fält inne i struct?

371
00:17:08,354 --> 00:17:11,770
Tja, vad är uppenbarligen
ny bit av syntax?

372
00:17:11,770 --> 00:17:13,339
Det är bara pricken operatören.

373
00:17:13,339 --> 00:17:14,510
>> Vi har inte riktigt sett det här förut.

374
00:17:14,510 --> 00:17:17,819
Du har sett det i pset fem om du har
dök redan med bitmap-filer.

375
00:17:17,819 --> 00:17:22,372
Men pricken betyder precis innanför detta
struct eller flera fält, ger prick

376
00:17:22,372 --> 00:17:24,510
namn, eller ge mig dot hus.

377
00:17:24,510 --> 00:17:28,690
Det innebär att gå in i struct
och få dessa särskilda områden.

378
00:17:28,690 --> 00:17:30,200
>> Vad gör resten av det här programmet?

379
00:17:30,200 --> 00:17:31,190
Det är inte så sexigt.

380
00:17:31,190 --> 00:17:34,640
Observera att jag iterera från 0 till 3 igen,
och jag skapar helt enkelt en engelsk

381
00:17:34,640 --> 00:17:40,500
fras som så och så är i en sådan och
ett sådant hus, passerar i prick namn från

382
00:17:40,500 --> 00:17:43,320
den i: te student och deras
huset också.

383
00:17:43,320 --> 00:17:47,560
>> Och sedan sist, nu ska vi börja för att få
anal om detta, nu när vi är

384
00:17:47,560 --> 00:17:49,580
bekant med vad malloc och
andra funktioner har varit

385
00:17:49,580 --> 00:17:50,570
gör hela tiden.

386
00:17:50,570 --> 00:17:54,220
Varför måste jag befria både namn
och hus, även om jag

387
00:17:54,220 --> 00:17:56,960
inte ringa malloc?

388
00:17:56,960 --> 00:17:58,020
>> GetString gjorde.

389
00:17:58,020 --> 00:18:00,930
Och det var den smutsiga lilla hemlighet för
flera veckor, men GetString har

390
00:18:00,930 --> 00:18:03,530
läckt minne hela
placera hela terminen hittills.

391
00:18:03,530 --> 00:18:05,990
Och Valgrand kommer slutligen
avslöja detta för oss.

392
00:18:05,990 --> 00:18:10,730
>> Men det är inte en stor sak, eftersom jag vet
att jag kan helt enkelt frigöra namnet

393
00:18:10,730 --> 00:18:15,750
och huset, men tekniskt sett, att
vara super, super säker, ska jag vara

394
00:18:15,750 --> 00:18:17,890
gör vissa felkontroll här.

395
00:18:17,890 --> 00:18:19,040
Vilka är dina instinkter säger dig?

396
00:18:19,040 --> 00:18:22,480
Vad bör jag kontrollera om
innan jag gratis Vad är en

397
00:18:22,480 --> 00:18:25,470
string, aka som en char *?

398
00:18:25,470 --> 00:18:33,460
>> Jag borde verkligen kontrollera om eleverna
fäste i prick namn inte

399
00:18:33,460 --> 00:18:34,840
lika null.

400
00:18:34,840 --> 00:18:40,400
Sedan ska det vara OK att gå vidare och gratis
som pekare, och samma eller det andra

401
00:18:40,400 --> 00:18:41,160
en också.

402
00:18:41,160 --> 00:18:46,860
Om eleverna fäste i dot hus är inte
lika med noll, detta nu kommer att skydda

403
00:18:46,860 --> 00:18:52,520
mot hörnet fall där
GetString returnerar något som null.

404
00:18:52,520 --> 00:18:57,310
Och vi såg en stund sedan, printf kommer
skydda oss här uppe genom att bara säga

405
00:18:57,310 --> 00:18:58,990
null, vilket går att se konstigt.

406
00:18:58,990 --> 00:19:02,340
Men åtminstone det inte kommer segfault,
som vi har sett.

407
00:19:02,340 --> 00:19:05,990
>> Nåväl, låt mig göra en sak här.
structs-0 är lite av en dum program

408
00:19:05,990 --> 00:19:09,700
eftersom jag in alla dessa data, och sedan
det förlorat när programmet avslutas.

409
00:19:09,700 --> 00:19:10,940
Men låt mig gå vidare och göra det.

410
00:19:10,940 --> 00:19:12,830
Låt mig göra terminalen
fönstret lite större.

411
00:19:12,830 --> 00:19:17,000
Låt mig göra structs-1, vilket
är en ny version av detta.

412
00:19:17,000 --> 00:19:18,520
>> Jag kommer in i en liten bit.

413
00:19:18,520 --> 00:19:21,620
Och låt mig nu kör prick
snedstreck structs-1.

414
00:19:21,620 --> 00:19:22,590
Studentens namn -

415
00:19:22,590 --> 00:19:31,500
David Mather, låt oss göra Rob Kirkland,
låt oss göra Lauren Leverett.

416
00:19:31,500 --> 00:19:33,650
Vad är intressant nu är varsel -

417
00:19:33,650 --> 00:19:35,540
och jag vet att bara detta eftersom
Jag skrev programmet -

418
00:19:35,540 --> 00:19:38,930
det finns en fil nu på min nuvarande
katalog som heter students.csv.

419
00:19:38,930 --> 00:19:40,420
Några av er kanske har sett
dessa i den verkliga världen.

420
00:19:40,420 --> 00:19:42,980
>> Vad är en CSV-fil?

421
00:19:42,980 --> 00:19:44,170
Kommaavgränsade värden.

422
00:19:44,170 --> 00:19:46,670
Det är ungefär som en fattig mans
version av en Excel-fil.

423
00:19:46,670 --> 00:19:50,580
Det är en tabell med rader och kolumner som
du kan öppna i ett program som Excel,

424
00:19:50,580 --> 00:19:51,800
eller siffror på en Mac.

425
00:19:51,800 --> 00:19:55,180
>> Och om jag öppnar den här filen här på gedit,
varsel - och siffrorna är inte där.

426
00:19:55,180 --> 00:19:57,360
Det är bara gedit berätta
mig radnummer.

427
00:19:57,360 --> 00:19:59,740
Tillkännagivande om den första raden i detta
filen är David och Mather.

428
00:19:59,740 --> 00:20:01,450
Nästa rad är Rob kommatecken Kirkland.

429
00:20:01,450 --> 00:20:04,170
Och den tredje raden är Lauren
kommatecken Leverett.

430
00:20:04,170 --> 00:20:05,480
>> Så vad har jag skapat?

431
00:20:05,480 --> 00:20:09,580
Jag har nu skrivit ett C-program som
effektivt kan generera kalkylblad

432
00:20:09,580 --> 00:20:11,840
som kan öppnas i en
program som Excel.

433
00:20:11,840 --> 00:20:15,520
Inte så övertygande en datamängd, men
om du har mycket större bitar av

434
00:20:15,520 --> 00:20:18,440
data som du verkligen vill
manipulera och göra grafer av och

435
00:20:18,440 --> 00:20:21,260
liknande, är detta kanske en
sätt att skapa dessa uppgifter.

436
00:20:21,260 --> 00:20:25,370
Dessutom CSVs är faktiskt super gemensamma
bara för lagring av enkel data -

437
00:20:25,370 --> 00:20:28,940
Yahoo Finance, till exempel, om du får
aktiekurser via deras så kallade

438
00:20:28,940 --> 00:20:33,180
API, gratis tjänst som låter dig
få aktuell up-to-the-date lager

439
00:20:33,180 --> 00:20:35,650
offerter för företagen, de
ge tillbaka data i

440
00:20:35,650 --> 00:20:37,800
super enkel CSV-format.

441
00:20:37,800 --> 00:20:39,380
>> Så hur har vi det?

442
00:20:39,380 --> 00:20:42,530
Väl att märka, de flesta av programmets
nästan samma.

443
00:20:42,530 --> 00:20:46,870
Men märker här nere, snarare än utskrift
eleverna ute på linje 35

444
00:20:46,870 --> 00:20:51,040
framåt, hävdar jag att jag sparar den
studenter till disk, så sparar en fil.

445
00:20:51,040 --> 00:20:53,630
>> Så märker jag att förklara en FIL * -

446
00:20:53,630 --> 00:20:57,260
nu, är denna typ av en anomali i C.
Av någon anledning är FILE versaler,

447
00:20:57,260 --> 00:21:00,690
vilket är inte som de flesta andra datatyper
i C. Men detta är en inbyggd

448
00:21:00,690 --> 00:21:02,320
datatyp, FILE *.

449
00:21:02,320 --> 00:21:05,900
Och jag förklara en pekare till en fil,
är hur du kan tänka på det.

450
00:21:05,900 --> 00:21:08,070
>> fopen betyder öppen fil.

451
00:21:08,070 --> 00:21:09,470
Vilken fil vill du öppna?

452
00:21:09,470 --> 00:21:12,620
Jag vill öppna en fil som jag kommer
godtyckligt ringa students.csv.

453
00:21:12,620 --> 00:21:14,480
Jag skulle kalla det vad jag vill.

454
00:21:14,480 --> 00:21:15,200
>> Och sedan ta en gissning.

455
00:21:15,200 --> 00:21:18,960
Vad innebär det andra argumentet
till fopen betyda förmodligen?

456
00:21:18,960 --> 00:21:21,480
Höger, w för write, kunde
vara r för läsning.

457
00:21:21,480 --> 00:21:24,120
Det finns en för append om du
vill lägga till rader och inte

458
00:21:24,120 --> 00:21:25,200
skriva över det hela.

459
00:21:25,200 --> 00:21:28,005
>> Men jag vill bara skapa den här filen
en gång, så jag ska använda citat unquote w.

460
00:21:28,005 --> 00:21:31,880
Och jag vet att det bara från att ha läst
dokumentationen, eller man-sidan.

461
00:21:31,880 --> 00:21:35,100
Om filen inte är null - med andra ord,
Om något gick fel där -

462
00:21:35,100 --> 00:21:37,820
låt mig iterera över
studenter från 0 till 3.

463
00:21:37,820 --> 00:21:40,410
>> Och nu märker att det är något
någonsin så något annorlunda

464
00:21:40,410 --> 00:21:42,110
kring linjen 41 här.

465
00:21:42,110 --> 00:21:42,960
Det är inte printf.

466
00:21:42,960 --> 00:21:46,530
Det är fprintf för filen printf.

467
00:21:46,530 --> 00:21:47,790
Så det kommer att skriva till fil.

468
00:21:47,790 --> 00:21:48,860
Vilken fil?

469
00:21:48,860 --> 00:21:53,630
Den vars pekare du anger
som det första argumentet.

470
00:21:53,630 --> 00:21:55,940
>> Då kan vi ange ett format sträng.

471
00:21:55,940 --> 00:21:59,660
Då kan vi ange vilken sträng som vi vill
plug in för den första procent s, och

472
00:21:59,660 --> 00:22:04,320
sedan en annan variabel eller
den andra procent s.

473
00:22:04,320 --> 00:22:06,760
Då kan vi avsluta ärendet med fclose.

474
00:22:06,760 --> 00:22:09,380
Än jag frigöra minne som förut, men
Jag ska gå tillbaka in och lägga

475
00:22:09,380 --> 00:22:10,540
vissa kontroller för null.

476
00:22:10,540 --> 00:22:12,090
>> Och det är det.

477
00:22:12,090 --> 00:22:16,960
fopen, fprintf ger fclose mig
förmåga att skapa textfiler.

478
00:22:16,960 --> 00:22:19,640
Nu ser du i problem set fem,
som innebär bilder, ska du använda

479
00:22:19,640 --> 00:22:20,990
binära filer i stället.

480
00:22:20,990 --> 00:22:24,200
Men i grunden är idén densamma,
även om de funktioner du

481
00:22:24,200 --> 00:22:28,710
se är lite annorlunda.

482
00:22:28,710 --> 00:22:32,580
>> Så virvlande tur, men du kommer att få
alltför bekant med fil I/O--

483
00:22:32,580 --> 00:22:34,960
ingång och utgång - med pset fem.

484
00:22:34,960 --> 00:22:38,607
Och några frågor om
första grunderna här?

485
00:22:38,607 --> 00:22:39,857
Yeah?

486
00:22:39,857 --> 00:22:41,880

487
00:22:41,880 --> 00:22:43,710
>> Vad händer om du försöker att frigöra ett null-värde?

488
00:22:43,710 --> 00:22:48,880
Jag tror, ​​om inte gratis har blivit en
lite mer användarvänliga, kan du

489
00:22:48,880 --> 00:22:49,890
potentiellt segfault.

490
00:22:49,890 --> 00:22:54,160
Förbi det null är dåligt eftersom jag inte
tro gratis stör att kontrollera dig,

491
00:22:54,160 --> 00:22:57,330
eftersom det skulle kunna vara ett slöseri
tid för den att göra sig till

492
00:22:57,330 --> 00:22:59,022
alla i världen.

493
00:22:59,022 --> 00:23:00,590
Bra fråga, men.

494
00:23:00,590 --> 00:23:04,300
>> Okej, så denna typ av får
oss till ett intressant ämne.

495
00:23:04,300 --> 00:23:07,010
Temat för problemet set
fem är kriminalteknik.

496
00:23:07,010 --> 00:23:08,420
Åtminstone det är en del
av problemet set.

497
00:23:08,420 --> 00:23:12,030
Forensics hänvisar i allmänhet till
återvinning av information som kan eller

498
00:23:12,030 --> 00:23:14,110
kanske inte har tagits bort
avsiktligt.

499
00:23:14,110 --> 00:23:18,680
Och så jag trodde jag skulle ge dig en snabb
smakprov på vad som verkligen händer alla

500
00:23:18,680 --> 00:23:21,230
denna gång under
huven på din dator.

501
00:23:21,230 --> 00:23:23,960
>> Till exempel, om du har insidan av din
bärbara eller stationära dator en

502
00:23:23,960 --> 00:23:28,040
hårddisk, det är antingen en mekanisk
enhet som faktiskt snurrar -

503
00:23:28,040 --> 00:23:31,650
det finns cirkulära saker som kallas Platters
som helt ser ut som vad jag

504
00:23:31,650 --> 00:23:34,540
bara hade upp på skärmen här, men
detta är allt gamla skolan.

505
00:23:34,540 --> 00:23:37,370
Detta är en tre-och en halv tum
hårddisk.

506
00:23:37,370 --> 00:23:40,070
Och tre och en halv inches hänvisar i
med den saken när du installerar det

507
00:23:40,070 --> 00:23:40,890
i en dator.

508
00:23:40,890 --> 00:23:44,890
>> Många av er i era laptops nu
har solid-state-enheter eller SSD,

509
00:23:44,890 --> 00:23:46,260
som inte har några rörliga delar.

510
00:23:46,260 --> 00:23:49,170
De är mer som RAM och mindre som
Dessa mekaniska anordningar.

511
00:23:49,170 --> 00:23:51,450
Men idéerna är fortfarande samma,
säkerligen de rör

512
00:23:51,450 --> 00:23:52,790
att problemet satt fem.

513
00:23:52,790 --> 00:23:57,400
>> Och om du tycker om nu en hårddisk
föreställer att vara en cirkel, som

514
00:23:57,400 --> 00:23:58,930
Jag ska göra som det här.

515
00:23:58,930 --> 00:24:02,290
När du skapar en fil på din dator,
oavsett om det är en SSD, eller i

516
00:24:02,290 --> 00:24:06,610
detta fall, en äldre skola hårddisk,
den filen innefattar flera bitar.

517
00:24:06,610 --> 00:24:10,510
Låt oss säga att det är det här 0 och 1,
en hel massa av 0 och 1.

518
00:24:10,510 --> 00:24:11,660
Så detta är hela min hårddisk.

519
00:24:11,660 --> 00:24:13,225
Detta är uppenbarligen en ganska stor fil.

520
00:24:13,225 --> 00:24:18,080
Och det använder upp 0s och 1s vid den
del av den fysiska diskens.

521
00:24:18,080 --> 00:24:19,750
>> Nå, vad är det fysiska delen?

522
00:24:19,750 --> 00:24:25,310
Jo, visar det sig att på en hårddisk,
åtminstone av denna typ, det finns

523
00:24:25,310 --> 00:24:27,340
dessa små små magnetiska partiklar.

524
00:24:27,340 --> 00:24:32,630
Och de har i huvudsak norr och
sydpoler till dem, så att om du

525
00:24:32,630 --> 00:24:35,710
vända ett av dessa magnetiska partiklar
detta sätt kan man säga att det är

526
00:24:35,710 --> 00:24:36,720
som representerar en 1.

527
00:24:36,720 --> 00:24:39,340
Och om det är upp och ner söderut till
norr, kan man säga att det är

528
00:24:39,340 --> 00:24:40,390
representerar en 0.

529
00:24:40,390 --> 00:24:43,660
>> Så i den verkliga fysiska världen, är det
hur man kan representera något i

530
00:24:43,660 --> 00:24:45,670
binära tillståndet av 0 och en 1.

531
00:24:45,670 --> 00:24:46,720
Så det är allt en fil.

532
00:24:46,720 --> 00:24:49,300
Det finns en hel drös med magnetisk
partiklar som är deras på detta sätt eller

533
00:24:49,300 --> 00:24:51,920
detta sätt, vilket skapar mönster
av 0 och 1.

534
00:24:51,920 --> 00:24:56,760
>> Men det visar sig när du sparar en fil,
viss information sparas separat.

535
00:24:56,760 --> 00:25:00,000
Så det här är ett litet bord,
en katalog, så att säga.

536
00:25:00,000 --> 00:25:05,810
Och jag ska kalla denna kolumn namn, och
Jag ringer denna kolumn plats.

537
00:25:05,810 --> 00:25:08,850
>> Och jag ska säga, antar
detta är mitt CV.

538
00:25:08,850 --> 00:25:14,050
Min resume.doc lagras vid
plats, låt oss säga 123.

539
00:25:14,050 --> 00:25:15,390
Jag går alltid för det numret.

540
00:25:15,390 --> 00:25:18,810
Men det räcker att säga att precis som
i RAM, kan du ta en hårddisk

541
00:25:18,810 --> 00:25:22,350
det är en gigabyte eller 200 gigabyte
eller en terabyte, och du kan

542
00:25:22,350 --> 00:25:23,750
antal alla byte.

543
00:25:23,750 --> 00:25:26,480
Du kan numrera alla bitar av 8 bitar.

544
00:25:26,480 --> 00:25:29,030
>> Så vi säger att detta
är plats 123.

545
00:25:29,030 --> 00:25:32,070
Så här katalogen insidan av mitt operativsystem
Systemet kommer ihåg att min

546
00:25:32,070 --> 00:25:34,250
CV är på plats 123.

547
00:25:34,250 --> 00:25:36,850
Men det blir intressant när
du raderar en fil.

548
00:25:36,850 --> 00:25:37,820
>> Så till exempel -

549
00:25:37,820 --> 00:25:40,790
och tack och lov, har de flesta av världens
fångas på detta - vad händer när

550
00:25:40,790 --> 00:25:45,040
du drar en fil till din Mac OS Papperskorgen
eller din Windows Papperskorgen?

551
00:25:45,040 --> 00:25:48,290

552
00:25:48,290 --> 00:25:50,510
Vad är syftet med att göra det?

553
00:25:50,510 --> 00:25:53,860
Det är självklart att bli av med filen,
men vad gör handlingen att dra och

554
00:25:53,860 --> 00:25:57,550
släppa in papperskorgen eller din
Recycle Bin göra på en dator?

555
00:25:57,550 --> 00:25:59,230
>> Absolut ingenting, egentligen.

556
00:25:59,230 --> 00:26:00,320
Det är precis som en mapp.

557
00:26:00,320 --> 00:26:01,800
Det är en särskild mapp, för att vara säker.

558
00:26:01,800 --> 00:26:04,460
Men tar inte bort det faktiskt filen?

559
00:26:04,460 --> 00:26:06,780
>> Tja, nej, eftersom vissa av er förmodligen
ha varit som, åh fan, det gjorde du inte

560
00:26:06,780 --> 00:26:07,420
menar att göra det.

561
00:26:07,420 --> 00:26:09,130
Så du dubbelklicka på
Papperskorgen eller Papperskorgen.

562
00:26:09,130 --> 00:26:11,630
Du har petade runt och du har återhämtat
filen bara genom att dra den

563
00:26:11,630 --> 00:26:12,110
av där.

564
00:26:12,110 --> 00:26:14,420
Så klart, det är inte nödvändigtvis
radera det.

565
00:26:14,420 --> 00:26:15,990
>> OK, du är smartare än så.

566
00:26:15,990 --> 00:26:18,860
Du vet att bara dra den till
Papperskorgen eller Papperskorgen betyder inte

567
00:26:18,860 --> 00:26:19,930
du tömma papperskorgen.

568
00:26:19,930 --> 00:26:24,110
Så du gå upp till menyn, och du säger
Töm papperskorgen eller Töm papperskorgen.

569
00:26:24,110 --> 00:26:25,360
Vad händer då?

570
00:26:25,360 --> 00:26:29,070

571
00:26:29,070 --> 00:26:32,530
>> Ja, så det tas bort mer så.

572
00:26:32,530 --> 00:26:37,660
Men allt som händer är detta.

573
00:26:37,660 --> 00:26:45,350
Datorn glömmer där
resume.doc var.

574
00:26:45,350 --> 00:26:47,400
>> Men vad har inte förändrats tydligen
på bilden?

575
00:26:47,400 --> 00:26:51,390

576
00:26:51,390 --> 00:26:55,570
Bitarna är 0 och 1 som jag hävdar är
på platsen för några fysiska aspekten av

577
00:26:55,570 --> 00:26:56,280
hårdvaran.

578
00:26:56,280 --> 00:26:57,110
De är fortfarande där.

579
00:26:57,110 --> 00:26:58,930
Det är bara att datorn har
glömt vad de är.

580
00:26:58,930 --> 00:27:03,160
>> Så det är i huvudsak befriade filens
bitar så att de kan återanvändas.

581
00:27:03,160 --> 00:27:06,940
Men inte förrän du skapar fler filer,
och fler filer och mer filer

582
00:27:06,940 --> 00:27:12,150
probabilistiskt, de 0s och 1s,
dessa magnetiska partiklar, får återanvändas,

583
00:27:12,150 --> 00:27:16,220
upp eller med rätt sida upp, för
andra filer, 0 och 1.

584
00:27:16,220 --> 00:27:17,980
>> Så du har detta tidsfönster.

585
00:27:17,980 --> 00:27:19,860
Och det är inte för förutsägbar
längd, egentligen.

586
00:27:19,860 --> 00:27:22,240
Det beror på storleken på din hårddisk
kör och hur många filer du har och

587
00:27:22,240 --> 00:27:23,490
hur snabbt du göra nya.

588
00:27:23,490 --> 00:27:27,050
Men det är det här fönstret för tid under
som att filen är fortfarande helt

589
00:27:27,050 --> 00:27:27,770
ersättningsgilla.

590
00:27:27,770 --> 00:27:31,050
>> Så om du använder någonsin program som McAfee
eller Norton att försöka återvinna

591
00:27:31,050 --> 00:27:35,680
uppgifter, är allt de gör försöker
återvinna denna så kallade katalogen

592
00:27:35,680 --> 00:27:37,340
räkna ut var filen fanns.

593
00:27:37,340 --> 00:27:40,605
Och ibland Norton och kommer att säga,
filen är 93% återvinningsbart.

594
00:27:40,605 --> 00:27:42,020
Tja, vad betyder det?

595
00:27:42,020 --> 00:27:45,690
Det betyder bara att någon annan fil
tillfällighet slutade med, säg,

596
00:27:45,690 --> 00:27:48,920
dessa bitar ur din ursprungliga filen.

597
00:27:48,920 --> 00:27:51,950
>> Så vad är egentligen inblandade
att återskapa data?

598
00:27:51,950 --> 00:27:55,720
Tja, om du inte har något som
Norton förinstallerat på datorn,

599
00:27:55,720 --> 00:27:59,510
det bästa du kan ibland göra är att titta
på hela hårddisken söker

600
00:27:59,510 --> 00:28:00,510
mönster av bitar.

601
00:28:00,510 --> 00:28:05,350
Och ett av de teman som problem set
fem är att du kommer att söka

602
00:28:05,350 --> 00:28:09,570
motsvarande en hårddisk, en rättsmedicinsk
bilden av ett compact flash-kort från en

603
00:28:09,570 --> 00:28:13,660
digitalkamera, söka efter 0s
och 1s som normalt, med hög

604
00:28:13,660 --> 00:28:16,720
sannolikhet, företräda
start av en JPEG-bild.

605
00:28:16,720 --> 00:28:21,120
>> Och ni kan återställa dessa bilder genom
antar, om jag ser detta mönster av

606
00:28:21,120 --> 00:28:24,380
bitar på rättsmedicinska bilden, med
hög sannolikhet, som markerar

607
00:28:24,380 --> 00:28:25,650
början av en JPEG.

608
00:28:25,650 --> 00:28:29,520
Och om jag ser samma mönster igen,
som markerar förmodligen starten av

609
00:28:29,520 --> 00:28:32,440
annat JPEG, och en annan
JPEG, och annat JPEG.

610
00:28:32,440 --> 00:28:34,970
Och detta är typiskt hur
Data Recovery fungerar.

611
00:28:34,970 --> 00:28:37,870
Vad är trevligt om JPEG är trots
filformatet i sig är något

612
00:28:37,870 --> 00:28:44,400
komplex, i början av varje sådan
filen är faktiskt ganska identifierbar

613
00:28:44,400 --> 00:28:47,370
och enkel, som ni kommer att se,
om du har inte redan.

614
00:28:47,370 --> 00:28:50,270
>> Så låt oss ta en närmare titt under
huven till exakt vad som har varit

615
00:28:50,270 --> 00:28:53,360
pågår, och vad dessa 0s och 1s
är, för att ge dig lite mer av en

616
00:28:53,360 --> 00:28:55,330
sammanhanget för denna utmaning.

617
00:28:55,330 --> 00:28:55,510
>> [VIDEO SPELA]

618
00:28:55,510 --> 00:28:58,700
>> -Om din dator lagrar mest
av dess permanenta uppgifter.

619
00:28:58,700 --> 00:29:03,390
För att göra detta, reser data från RAM
tillsammans med programvara signaler som talar

620
00:29:03,390 --> 00:29:06,110
hårddisken hur man lagrar dessa data.

621
00:29:06,110 --> 00:29:09,410
De hårda drivkretsar översätta
dessa signaler till spänning

622
00:29:09,410 --> 00:29:10,870
fluktuationer.

623
00:29:10,870 --> 00:29:14,970
Dessa, i sin tur, kontrollera hårddiskens
rörliga delar, några av de få

624
00:29:14,970 --> 00:29:17,910
rörliga delar kvar i
modern dator.

625
00:29:17,910 --> 00:29:22,130
>> Några av de signaler styr en motor
som snurrar metall-belagda skivorna.

626
00:29:22,130 --> 00:29:25,470
Dina uppgifter lagras i själva verket
på dessa fat.

627
00:29:25,470 --> 00:29:28,610
Andra signaler flytta läs / skriv
huvuden att läsa eller

628
00:29:28,610 --> 00:29:30,710
skriva data på skivorna.

629
00:29:30,710 --> 00:29:35,450
Denna maskin så precisa att en människa
håret kunde inte ens passera mellan

630
00:29:35,450 --> 00:29:37,280
huvuden och snurrande skivorna.

631
00:29:37,280 --> 00:29:40,316
Ändå fungerar det på fantastiska hastigheter.

632
00:29:40,316 --> 00:29:40,660
>> [END VIDEOAVSPELNING]

633
00:29:40,660 --> 00:29:42,190
>> DAVID MALAN: Zooma in lite
djupare nu på vad som är

634
00:29:42,190 --> 00:29:44,360
faktiskt på dessa fat.

635
00:29:44,360 --> 00:29:44,720
>> [VIDEO SPELA]

636
00:29:44,720 --> 00:29:47,660
>> -Låt oss titta på vad vi just
såg i slow motion.

637
00:29:47,660 --> 00:29:51,710
När en kort puls av el är
skickas till läs / skrivhuvudet, om flips

638
00:29:51,710 --> 00:29:54,650
på en liten elektromagnetisk för
en bråkdel av en sekund.

639
00:29:54,650 --> 00:29:58,970
Magneten skapar ett fält, vilket
ändrar polaritet av en liten, liten

640
00:29:58,970 --> 00:30:02,850
del av metallpartiklar som
päls varje tallrik yta.

641
00:30:02,850 --> 00:30:05,940
>> Ett mönster serie av dessa små,
laddade-up områden på disken

642
00:30:05,940 --> 00:30:08,470
representerar en enda bit av
data i det binära talet

643
00:30:08,470 --> 00:30:10,530
system som används av datorer.

644
00:30:10,530 --> 00:30:13,775
Nu, om ström sänds ett sätt
genom läs / skriv huvudet, området

645
00:30:13,775 --> 00:30:15,970
är polariserat i en riktning.

646
00:30:15,970 --> 00:30:17,950
Om ström sänds i
motsatt riktning, den

647
00:30:17,950 --> 00:30:19,930
polarisering är omvänd.

648
00:30:19,930 --> 00:30:22,370
>> Hur du får data från hårddisken?

649
00:30:22,370 --> 00:30:24,090
Bara vända processen.

650
00:30:24,090 --> 00:30:26,550
Så det är partiklarna på disken
att få strömmen i

651
00:30:26,550 --> 00:30:27,960
läs / skrivhuvudet rör sig.

652
00:30:27,960 --> 00:30:30,700
Sätt ihop miljontals dessa
magnetiserade segment, och

653
00:30:30,700 --> 00:30:32,160
du har en fil.

654
00:30:32,160 --> 00:30:36,060
>> Nu, bitar av en enda fil kan
vara utspridda över ett enhetens

655
00:30:36,060 --> 00:30:39,970
skivorna, ungefär som röran
av papper på skrivbordet.

656
00:30:39,970 --> 00:30:43,500
Så en särskild extra fil håller koll
av där allt är.

657
00:30:43,500 --> 00:30:45,985
Önskar du inte att du hade
nåt sånt?

658
00:30:45,985 --> 00:30:46,470
>> [END VIDEOAVSPELNING]

659
00:30:46,470 --> 00:30:47,820
>> DAVID MALAN: OK, förmodligen inte.

660
00:30:47,820 --> 00:30:52,070
Så hur många av er killar
växte upp med dessa?

661
00:30:52,070 --> 00:30:53,970
OK, så det är färre och färre
händer varje år.

662
00:30:53,970 --> 00:30:56,550
Men jag är glad att du är minst bekant
med dem, eftersom detta och vår egen

663
00:30:56,550 --> 00:31:00,520
bok demo, tyvärr, dör en mycket
långsam död här i förtrolighet.

664
00:31:00,520 --> 00:31:04,010
>> Men detta är vad jag, åtminstone, tillbaka i
gymnasiet, använde användning för säkerhetskopior.

665
00:31:04,010 --> 00:31:08,110
Och det var fantastiskt, eftersom du
kunde lagra 1.4 megabyte på

666
00:31:08,110 --> 00:31:08,930
denna speciella skivan.

667
00:31:08,930 --> 00:31:12,260
Och detta var den höga tätheten versionen,
såsom indikeras av HD, som har

668
00:31:12,260 --> 00:31:14,240
menande före dagens HD-videor.

669
00:31:14,240 --> 00:31:16,400
>> Standard densiteten var 800 kilobyte.

670
00:31:16,400 --> 00:31:18,640
Och innan det fanns
400-kilobyte diskar.

671
00:31:18,640 --> 00:31:23,120
Och innan dess fanns det 5 och 1/4
tums disketter, som var riktigt diskett,

672
00:31:23,120 --> 00:31:25,680
och lite bredare och högre
än dessa saker här.

673
00:31:25,680 --> 00:31:29,150
Men du kan faktiskt se den så kallade
floppy aspekt av dessa diskar.

674
00:31:29,150 --> 00:31:32,630
>> Och funktionellt, är de faktiskt
ganska lik hårddiskar på

675
00:31:32,630 --> 00:31:33,570
minst denna typ.

676
00:31:33,570 --> 00:31:37,270
Återigen, SSDs i nyare datorer
fungerar lite annorlunda.

677
00:31:37,270 --> 00:31:41,530
Men om du flyttar den lilla metall flik,
Du kan faktiskt se en liten kaka,

678
00:31:41,530 --> 00:31:42,560
eller tallrik.

679
00:31:42,560 --> 00:31:43,830
>> Det är inte metall som den här.

680
00:31:43,830 --> 00:31:46,000
Detta är faktiskt lite billigare
plastmaterial.

681
00:31:46,000 --> 00:31:46,750
Och du kan typ av vicka.

682
00:31:46,750 --> 00:31:50,310
Och du har trully bara torkas av vissa
antalet bitar eller magnetiska partiklar

683
00:31:50,310 --> 00:31:51,220
från denna skiva.

684
00:31:51,220 --> 00:31:52,710
>> Så tack och lov, det finns inget på det.

685
00:31:52,710 --> 00:31:55,790
Om den saken är i vägen - och täcker
dina ögon och de av din granne -

686
00:31:55,790 --> 00:31:58,865
du kan bara typ av drag här
Hela skidan iväg så där.

687
00:31:58,865 --> 00:32:01,900
Men det finns en liten fjäder, så att
medveten om det med dina ögon.

688
00:32:01,900 --> 00:32:03,620
Så nu har du verkligen en diskett.

689
00:32:03,620 --> 00:32:07,090
>> Och vad är anmärkningsvärt om detta
är att i så mycket som detta är en

690
00:32:07,090 --> 00:32:10,830
småskalig representation av en större
hårddisk, dessa saker är super,

691
00:32:10,830 --> 00:32:11,590
super enkelt.

692
00:32:11,590 --> 00:32:15,170
Om du nyper botten med det, nu när
att metall sak är avstängd, och skal

693
00:32:15,170 --> 00:32:20,990
dem öppna, är allt som finns två stycken
filt och den så kallade diskett

694
00:32:20,990 --> 00:32:22,930
med en bit metall på insidan.

695
00:32:22,930 --> 00:32:25,990
>> Och där går hälften av
min diskens innehåll.

696
00:32:25,990 --> 00:32:27,540
Det går en annan halva av dem.

697
00:32:27,540 --> 00:32:31,375
Men det är allt som snurrar inuti
av datorn i förr.

698
00:32:31,375 --> 00:32:35,220

699
00:32:35,220 --> 00:32:38,310
>> Och återigen, att sätta detta i perspektiv,
hur stort är det mesta av din

700
00:32:38,310 --> 00:32:39,560
hårddiskar dessa dagar?

701
00:32:39,560 --> 00:32:41,960

702
00:32:41,960 --> 00:32:46,230
500 gigabyte, en terabyte, kanske i
en stationär dator, 2 terabyte, 3

703
00:32:46,230 --> 00:32:47,630
terabyte, 4 terabyte, eller hur?

704
00:32:47,630 --> 00:32:52,480
Detta är en megabyte, ge eller ta,
som inte ens kan passa en typisk MP3

705
00:32:52,480 --> 00:32:55,310
längre dessa dagar, eller några
liknande musikfil.

706
00:32:55,310 --> 00:32:59,500
>> Så en liten souvenir för dig idag, och
också att hjälpa kontextualisera vad

707
00:32:59,500 --> 00:33:03,570
Vi kommer att ta för givet
nu i problem som fem.

708
00:33:03,570 --> 00:33:04,820
Så de är din att behålla.

709
00:33:04,820 --> 00:33:07,340

710
00:33:07,340 --> 00:33:13,370
Så låt mig övergång till där blir
spendera nästa pset liksom.

711
00:33:13,370 --> 00:33:18,470
Så vi har nu satt den här sidan för - åh,
ett par meddelanden snabbt.

712
00:33:18,470 --> 00:33:21,730
>> Denna fredag, om du vill gå CS50
för lunch, gå till det vanliga stället,

713
00:33:21,730 --> 00:33:23,610
cs50.net/rsvp.

714
00:33:23,610 --> 00:33:25,100
Och slutprojekt -

715
00:33:25,100 --> 00:33:28,520
så per kursplanen, har vi lagt upp
slutprojekt specifikationen redan.

716
00:33:28,520 --> 00:33:31,410
Inse att det inte betyder
det beror särskilt snart.

717
00:33:31,410 --> 00:33:33,990
Det har publicerats, egentligen, bara för att få
ni tänker på det.

718
00:33:33,990 --> 00:33:37,620
Och faktiskt, en super betydande
procentandel av er kommer att ta itu med

719
00:33:37,620 --> 00:33:40,780
slutarbeten på material som vi
har inte ens fått i klassen,

720
00:33:40,780 --> 00:33:42,730
men kommer så tidigt som nästa vecka.

721
00:33:42,730 --> 00:33:45,530
>> Observera dock att den spec kräver
några olika komponenter i

722
00:33:45,530 --> 00:33:46,190
slutprojekt.

723
00:33:46,190 --> 00:33:49,590
Den första, i ett par veckor, är en
pre-förslag, en ganska casual e-post till

724
00:33:49,590 --> 00:33:52,760
din TF för att berätta för honom eller vad du är
tänka på för ditt projekt, med

725
00:33:52,760 --> 00:33:53,650
inget åtagande.

726
00:33:53,650 --> 00:33:56,710
Förslaget kommer att vara din
engagemang, ordstäv, här, är detta vad

727
00:33:56,710 --> 00:33:57,770
Jag skulle vilja göra för mitt projekt.

728
00:33:57,770 --> 00:33:58,250
Vad tycker du?

729
00:33:58,250 --> 00:33:58,650
För stor?

730
00:33:58,650 --> 00:33:59,145
För liten?

731
00:33:59,145 --> 00:34:00,330
Är det hanterbart?

732
00:34:00,330 --> 00:34:02,230
Och du ser spec för mer information.

733
00:34:02,230 --> 00:34:05,060
>> Par veckor efter det är statusen
Rapporten, som är en liknande

734
00:34:05,060 --> 00:34:08,260
tillfällig e-post till din TF att säga precis hur
långt efter du är i din sista

735
00:34:08,260 --> 00:34:12,360
projektets genomförande, följt av
den CS50 Hackathon som alla

736
00:34:12,360 --> 00:34:17,520
är inbjudna, vilket kommer att vara en händelse från
20:00 på en kväll till 07:00

737
00:34:17,520 --> 00:34:19,150
AM nästa morgon.

738
00:34:19,150 --> 00:34:22,560
Pizza, som jag kanske har nämnt i veckan
noll, vara til serveras vid 9:00,

739
00:34:22,560 --> 00:34:24,120
Kinesisk mat på 1:00 AM.

740
00:34:24,120 --> 00:34:27,929
Och om du fortfarande vaken klockan 5:00,
Vi tar dig till IHOP för frukost.

741
00:34:27,929 --> 00:34:31,310
>> Så Hackathon är en av de mer
minnesvärda upplevelser i klassen.

742
00:34:31,310 --> 00:34:35,290
Då genomförandet beror, och
då den kulminerande CS50 Fair.

743
00:34:35,290 --> 00:34:38,070
Mer information om alla dessa
under de kommande veckorna.

744
00:34:38,070 --> 00:34:40,739
>> Men låt oss gå tillbaka till något
old school -

745
00:34:40,739 --> 00:34:41,920
igen, en array.

746
00:34:41,920 --> 00:34:45,040
Så en array var trevligt, eftersom det löser
problem som vi såg bara en

747
00:34:45,040 --> 00:34:49,290
stund sedan med studerande strukturer
få en lite ur kontroll om vi

748
00:34:49,290 --> 00:34:52,405
vill ha eleven en, student två,
Studenten tre, student dot dot dot,

749
00:34:52,405 --> 00:34:54,400
några godtyckligt antal studenter.

750
00:34:54,400 --> 00:34:58,850
>> Så arrayer, för några veckor sedan, svepte in
och löste alla våra problem med inte

751
00:34:58,850 --> 00:35:03,340
att veta i förväg hur många saker
av något slag som vi kanske vill.

752
00:35:03,340 --> 00:35:07,390
Och vi har sett att structs kan hjälpa oss
ytterligare organisera vår kod och hålla

753
00:35:07,390 --> 00:35:11,660
begreppsmässigt likartade variabler, t.ex. en
namn och ett hus, tillsammans, så att vi

754
00:35:11,660 --> 00:35:15,570
kan behandla dem som en enhet, insida
av vilka det finns mindre bitar.

755
00:35:15,570 --> 00:35:17,810
>> Men arrayer har vissa nackdelar.

756
00:35:17,810 --> 00:35:19,780
Vilka är några av de nackdelar
vi har stött

757
00:35:19,780 --> 00:35:22,320
med arrayer hittills?

758
00:35:22,320 --> 00:35:23,450
Vad är det?

759
00:35:23,450 --> 00:35:28,130
Fast storlek - så även om du kanske
kunna allokera minne för ett

760
00:35:28,130 --> 00:35:32,310
array, när du vet hur många studenter
du har, hur många tecken du har

761
00:35:32,310 --> 00:35:35,460
från användaren, när du har tilldelats
arrayen, har du typ av målade

762
00:35:35,460 --> 00:35:36,740
själv i ett hörn.

763
00:35:36,740 --> 00:35:40,600
>> Eftersom du inte kan infoga nya element
i mitten av en array.

764
00:35:40,600 --> 00:35:43,660
Du kan inte sätta in fler element
vid slutet av en array.

765
00:35:43,660 --> 00:35:47,750
Verkligen, du måste ta till att skapa en
helt ny array, som vi har diskuterat,

766
00:35:47,750 --> 00:35:49,320
kopiera det gamla till det nya.

767
00:35:49,320 --> 00:35:52,610
Och återigen, är att huvudvärken som
GetString erbjudanden med för dig.

768
00:35:52,610 --> 00:35:56,170
>> Men återigen, kan du inte ens sätta
något i mitten av uppsättningen

769
00:35:56,170 --> 00:35:58,200
Om räntan inte är helt fylld.

770
00:35:58,200 --> 00:36:03,010
Till exempel, om denna array här av storlek
sex har bara fem saker i den,

771
00:36:03,010 --> 00:36:06,080
Tja, kan du bara please
något på änden.

772
00:36:06,080 --> 00:36:08,200
Men vad händer om du vill infoga något
in i mitten av den

773
00:36:08,200 --> 00:36:11,280
array, även om det kan ha
fem av sex saker i den?

774
00:36:11,280 --> 00:36:14,250
>> Nå, vad vi gör när vi hade alla
av våra frivilliga på scenen i

775
00:36:14,250 --> 00:36:15,110
veckor tidigare?

776
00:36:15,110 --> 00:36:18,710
Om vi ​​ville sätta någon här, antingen
dessa människor hur man flyttar detta

777
00:36:18,710 --> 00:36:22,540
sätt, eller dessa människor hur man flyttar detta
sätt, och det blev dyrt.

778
00:36:22,540 --> 00:36:26,950
Vid förflyttningen av människor inne i en
array hamnade lägga upp och kostnadsberäkning

779
00:36:26,950 --> 00:36:31,240
oss tid, alltså mycket av vår n kvadrat
rinnande tider som insättning sortera, för

780
00:36:31,240 --> 00:36:32,550
Exempelvis, i värsta fall.

781
00:36:32,550 --> 00:36:36,520
Så arrayer är bra, men du måste
vet i förväg hur stor du vill ha dem.

782
00:36:36,520 --> 00:36:38,030
>> Så OK, här är en lösning.

783
00:36:38,030 --> 00:36:43,860
Om jag inte vet i förväg hur många
elever jag kan ha, och jag vet en gång

784
00:36:43,860 --> 00:36:47,870
Jag bestämmer, men jag fastnade med att
många studenter, varför gör inte jag bara alltid

785
00:36:47,870 --> 00:36:51,740
fördela dubbelt så mycket utrymme
så jag tror jag behöver?

786
00:36:51,740 --> 00:36:54,450
Är det inte en rimlig lösning?

787
00:36:54,450 --> 00:36:58,240
>> Realistiskt, jag tror inte att vi är
kommer att behöva mer än 50 platser

788
00:36:58,240 --> 00:37:02,190
i en matris för en medelstor klass,
så låt oss bara runda upp.

789
00:37:02,190 --> 00:37:07,040
Jag ska göra 100 slots i min samling, precis
så att vi kan definitivt få

790
00:37:07,040 --> 00:37:10,330
Antalet elever jag förväntar
vara i någon medelstor klass.

791
00:37:10,330 --> 00:37:14,320
Så varför inte bara runda upp och fördela
mer minne, typiskt, för en samling

792
00:37:14,320 --> 00:37:16,290
än du tror att du ens behöver?

793
00:37:16,290 --> 00:37:20,190
Vad är det här enkla stift
till den idén?

794
00:37:20,190 --> 00:37:21,440
>> Du är bara slöseri med minne.

795
00:37:21,440 --> 00:37:25,350
Bokstavligen varje program du skriver sedan
är kanske använder dubbelt så mycket minne som

796
00:37:25,350 --> 00:37:26,680
du behöver faktiskt.

797
00:37:26,680 --> 00:37:28,990
Och det bara inte känns som en
särskilt elegant lösning.

798
00:37:28,990 --> 00:37:31,990
Dessutom minskar det bara
sannolikheten för ett problem.

799
00:37:31,990 --> 00:37:35,300
Om du råkar ha en populär kurs
en termin och du har 101

800
00:37:35,300 --> 00:37:39,610
studenter, är programmet fortfarande
grunden inför samma fråga.

801
00:37:39,610 --> 00:37:44,280
>> Så tack och lov, det finns en lösning på
denna annons alla våra problem i form

802
00:37:44,280 --> 00:37:46,790
av datastrukturer som
mer komplex än de som

803
00:37:46,790 --> 00:37:47,970
vi har sett hittills.

804
00:37:47,970 --> 00:37:50,530
Detta, hävdar jag, är en länkad lista.

805
00:37:50,530 --> 00:37:51,920
Detta är en lista med tal -

806
00:37:51,920 --> 00:37:54,970
9, 17, 22, 26, och 34 -

807
00:37:54,970 --> 00:38:00,120
som har länkats samman genom
av vad jag har ritat som pilar.

808
00:38:00,120 --> 00:38:03,580
>> Med andra ord, om jag ville representera
en matris, kunde jag göra

809
00:38:03,580 --> 00:38:04,910
ungefär så här.

810
00:38:04,910 --> 00:38:07,310
Och jag ska sätta detta på overhead
på bara ett ögonblick.

811
00:38:07,310 --> 00:38:09,970
Jag kunde göra -

812
00:38:09,970 --> 00:38:12,520
hej, okej.

813
00:38:12,520 --> 00:38:14,470
Stand by.

814
00:38:14,470 --> 00:38:17,360
Ny dator här, klart -

815
00:38:17,360 --> 00:38:18,090
okej.

816
00:38:18,090 --> 00:38:21,730
>> Så om jag har dessa siffror i rad -

817
00:38:21,730 --> 00:38:28,880
9, 17, 22, 26, 24 -

818
00:38:28,880 --> 00:38:30,530
inte nödvändigtvis i skala.

819
00:38:30,530 --> 00:38:33,730
Okej, så här är min samling -

820
00:38:33,730 --> 00:38:34,980
oh my god.

821
00:38:34,980 --> 00:38:38,700

822
00:38:38,700 --> 00:38:40,395
Okej, så här är min samling.

823
00:38:40,395 --> 00:38:44,110

824
00:38:44,110 --> 00:38:45,050
Herregud.

825
00:38:45,050 --> 00:38:48,820
>> [SKRATT]

826
00:38:48,820 --> 00:38:49,440
>> DAVID MALAN: Pretend.

827
00:38:49,440 --> 00:38:52,330
Det är för mycket ansträngning för att gå tillbaka
och fixa det, så det -

828
00:38:52,330 --> 00:38:54,290
26.

829
00:38:54,290 --> 00:38:57,650
Så vi har denna samling av
9, 17, 22, 26, och 34.

830
00:38:57,650 --> 00:39:00,260
För de av er kan se
pinsamt misstag jag gjorde precis,

831
00:39:00,260 --> 00:39:00,830
det är det.

832
00:39:00,830 --> 00:39:04,490
>> Så jag hävdar att detta är en
mycket effektiv lösning.

833
00:39:04,490 --> 00:39:07,310
Jag har tilldelats lika många ints som
Jag behöver - ett, två, tre,

834
00:39:07,310 --> 00:39:09,100
fyra, fem eller sex -

835
00:39:09,100 --> 00:39:11,660
och jag har sedan lagrat numren
insidan av denna matris.

836
00:39:11,660 --> 00:39:15,220
Men anta, då vill jag att infoga
ett värde som nummer 8?

837
00:39:15,220 --> 00:39:16,100
Tja, inte var det går?

838
00:39:16,100 --> 00:39:18,530
Anta att jag vill infoga
ett antal som 20.

839
00:39:18,530 --> 00:39:19,790
Tja, inte var det går?

840
00:39:19,790 --> 00:39:23,160
Någonstans där i mitten,
eller antalet 35 måste gå

841
00:39:23,160 --> 00:39:24,010
någonstans i slutet.

842
00:39:24,010 --> 00:39:25,320
Men jag är allt ut i rymden.

843
00:39:25,320 --> 00:39:29,120
>> Och så detta är en grundläggande utmaning
av matriser det betyder är lösningen.

844
00:39:29,120 --> 00:39:32,280
Jag hävdade en stund sedan, getString
löser detta problem.

845
00:39:32,280 --> 00:39:37,380
Om du vill infoga en sjätte nummer
in i denna matris, vilka är åtminstone en

846
00:39:37,380 --> 00:39:40,090
lösning du kan falla tillbaka på för säker,
precis som vi gör med GetString?

847
00:39:40,090 --> 00:39:44,340

848
00:39:44,340 --> 00:39:46,030
Vad är det?

849
00:39:46,030 --> 00:39:48,190
>> Tja, göra det större är
lättare sagt än gjort.

850
00:39:48,190 --> 00:39:52,810
Vi kan inte nödvändigtvis göra arrayen
större, men vad kan vi göra?

851
00:39:52,810 --> 00:39:56,570
Gör en ny array som är större, av storlek
6, eller kanske storlek 10, om vi vill

852
00:39:56,570 --> 00:40:00,490
att få ett försprång på saker, och sedan kopiera
den gamla arrayen i den nya, och sedan

853
00:40:00,490 --> 00:40:01,680
frigöra den gamla matrisen.

854
00:40:01,680 --> 00:40:05,770
>> Men vad är det gångtid
nu i den processen?

855
00:40:05,770 --> 00:40:09,870
Det är stort O n, eftersom kopiering
kommer att kosta dig några enheter

856
00:40:09,870 --> 00:40:13,480
tid, så inte så perfekt om vi måste
allokera en ny array, som kommer

857
00:40:13,480 --> 00:40:15,610
att konsumera dubbelt så mycket
minnet tillfälligt.

858
00:40:15,610 --> 00:40:16,660
Kopiera gammalt till nytt -

859
00:40:16,660 --> 00:40:18,800
Jag menar, det är bara en huvudvärk, som
är, återigen, varför vi skrev

860
00:40:18,800 --> 00:40:19,920
GetString för dig.

861
00:40:19,920 --> 00:40:21,380
>> Så vad kan vi göra i stället?

862
00:40:21,380 --> 00:40:25,000
Tja, tänk om vår datastruktur
faktiskt har luckor i det?

863
00:40:25,000 --> 00:40:30,790
Antag att jag slappna av mitt mål att ha
sammanhängande bitar av minnet, där 9

864
00:40:30,790 --> 00:40:34,500
är rätt bredvid 17, vilket är
precis intill 22, och så vidare.

865
00:40:34,500 --> 00:40:39,570
>> Och antar att 9 kan vara över här i
RAM och 17 kan vara över här i RAM,

866
00:40:39,570 --> 00:40:40,990
och 22 kan vara över här i RAM.

867
00:40:40,990 --> 00:40:43,610
Med andra ord, jag behöver inte dem
även tillbaka till tillbaka längre.

868
00:40:43,610 --> 00:40:47,850
Jag måste bara något trä en nål
genom alla dessa siffror, eller varje

869
00:40:47,850 --> 00:40:51,010
av dessa noder, som vi kallar
rektanglar som jag har ritat dem,

870
00:40:51,010 --> 00:40:55,670
ihåg hur man får till den sista
sådan nod från det första.

871
00:40:55,670 --> 00:40:59,940
>> Så vad är programmering konstruktion
Vi har sett ganska nyligen som jag

872
00:40:59,940 --> 00:41:03,030
kan genomföra denna tråd, eller
dras här, som jag kan

873
00:41:03,030 --> 00:41:05,430
genomföra dessa pilar?

874
00:41:05,430 --> 00:41:06,500
Så pekare, eller hur?

875
00:41:06,500 --> 00:41:09,560
Om jag inte allokera bara en
int, men en nod - och genom

876
00:41:09,560 --> 00:41:10,810
nod, menar jag bara behållare.

877
00:41:10,810 --> 00:41:12,900
Och visuellt, menar jag en rektangel.

878
00:41:12,900 --> 00:41:16,420
Så en nod behöver tydligen
att innehålla två värden -

879
00:41:16,420 --> 00:41:21,490
int själv, och sedan, underförstådda som genom
den nedre halvan av rektangeln,

880
00:41:21,490 --> 00:41:23,010
tillräckligt med utrymme för en int.

881
00:41:23,010 --> 00:41:26,130
>> Så bara tänka framåt här,
hur stor är denna nod, detta

882
00:41:26,130 --> 00:41:27,170
container i fråga?

883
00:41:27,170 --> 00:41:29,250
Hur många bytes för int?

884
00:41:29,250 --> 00:41:31,310
Förmodligen 4, om det är
samma som vanligt.

885
00:41:31,310 --> 00:41:33,270
Och sedan hur många bytes
för pekaren?

886
00:41:33,270 --> 00:41:33,650
4.

887
00:41:33,650 --> 00:41:37,940
Så här containern, eller denna nod, är
kommer att vara en 8-byte struktur.

888
00:41:37,940 --> 00:41:41,760
Åh, och det är ett lyckligt sammanträffande att
Vi introducerade just denna föreställning om

889
00:41:41,760 --> 00:41:44,400
en struct, eller en C-struktur.

890
00:41:44,400 --> 00:41:48,890
>> Så jag hävdar att jag vill ta ett steg
mot detta mer sofistikerade

891
00:41:48,890 --> 00:41:52,560
Genomförandet av en lista med tal, en
länkad lista med siffror, måste jag göra en

892
00:41:52,560 --> 00:41:56,920
lite mer tänkande fram och
förklarar inte bara en int, men en struct

893
00:41:56,920 --> 00:41:58,620
att jag ringer, konventionellt
här, nod.

894
00:41:58,620 --> 00:42:01,630
Vi kan kalla det vad vi vill ha, men
nod kommer att vara tematiskt i en hel

895
00:42:01,630 --> 00:42:03,560
av de saker vi börja titta på nu.

896
00:42:03,560 --> 00:42:06,480
>> Insidan av den noden är en int n.

897
00:42:06,480 --> 00:42:09,350
Och sedan denna syntax, lite
konstig vid första anblicken -

898
00:42:09,350 --> 00:42:12,960
struct node * nästa.

899
00:42:12,960 --> 00:42:16,900
Väl bildmässigt, vad är det?

900
00:42:16,900 --> 00:42:21,000
Det är den nedre halvan av
rektangeln som vi såg

901
00:42:21,000 --> 00:42:22,730
bara en stund sedan.

902
00:42:22,730 --> 00:42:27,600
>> Men varför säger jag struct node *
i motsats till bara nod *?

903
00:42:27,600 --> 00:42:31,370
För om det pekaren pekar
på en annan nod, det är bara

904
00:42:31,370 --> 00:42:32,760
adressen för en nod.

905
00:42:32,760 --> 00:42:35,630
Det är i linje med vad vi har
diskuteras om pekare hittills.

906
00:42:35,630 --> 00:42:39,690
Men varför, om jag hävdar denna struktur är
kallas nod, måste jag säga struct

907
00:42:39,690 --> 00:42:42,660
nod inne här?

908
00:42:42,660 --> 00:42:43,190
>> Exakt.

909
00:42:43,190 --> 00:42:46,490
Det blir liksom en dum verklighet C.
Den typedef, så att säga, har inte

910
00:42:46,490 --> 00:42:47,220
hänt ännu.

911
00:42:47,220 --> 00:42:48,510
C är SUPER bokstavlig.

912
00:42:48,510 --> 00:42:51,050
Den läser din kod topp till
botten, vänster till höger.

913
00:42:51,050 --> 00:42:54,930
Och tills den träffar den semikolon på
bottom line, gissa vad som inte

914
00:42:54,930 --> 00:42:57,590
existera som en datatyp?

915
00:42:57,590 --> 00:42:59,060
Node, citationstecken unquote nod.

916
00:42:59,060 --> 00:43:03,050
>> Men på grund av den mer utförliga
förklaring jag gjorde på första raden -

917
00:43:03,050 --> 00:43:05,340
typedef struct node -

918
00:43:05,340 --> 00:43:08,790
eftersom det kom först, innan
klammerparenteser, som är ungefär som

919
00:43:08,790 --> 00:43:11,800
pre-utbilda klang som du
vet vad, ge mig en struct

920
00:43:11,800 --> 00:43:13,570
kallas struct node.

921
00:43:13,570 --> 00:43:16,270
Ärligt talat, jag gillar inte kalla saker
struct node, struct node alla

922
00:43:16,270 --> 00:43:17,090
hela min kod.

923
00:43:17,090 --> 00:43:20,660
Men jag ska bara använda den en gång, strax innanför,
så att jag kan effektivt

924
00:43:20,660 --> 00:43:25,010
skapa ett slags cirkulär referens, inte
en pekare till mig själv per se, men en

925
00:43:25,010 --> 00:43:29,400
pekare till en annan av
identisk typ.

926
00:43:29,400 --> 00:43:32,330
>> Så visar det sig att på en datastruktur
så här, det finns ett fåtal

927
00:43:32,330 --> 00:43:34,470
verksamheter som kan vara
av intresse för oss.

928
00:43:34,470 --> 00:43:37,460
Vi kanske vill infoga
in i en lista som denna.

929
00:43:37,460 --> 00:43:39,850
Vi kanske vill ta bort
från en lista som denna.

930
00:43:39,850 --> 00:43:43,490
Vi kanske vill söka i listan för en
värde, eller mer generellt, travers.

931
00:43:43,490 --> 00:43:46,410
Och travers är bara ett finare sätt att
säger start till vänster och flytta alla

932
00:43:46,410 --> 00:43:47,650
vägen till höger.

933
00:43:47,650 --> 00:43:52,640
>> Och varsel, även med denna något mer
sofistikerade datastruktur, låt

934
00:43:52,640 --> 00:43:56,510
jag föreslår att vi kan låna några av
idéer de senaste två veckorna och

935
00:43:56,510 --> 00:43:58,410
implementera en funktion som kallas
söka så här.

936
00:43:58,410 --> 00:44:01,360
Det kommer att returnera sant eller
falskt, vilket indikerar, ja eller

937
00:44:01,360 --> 00:44:03,390
nej, n är i listan.

938
00:44:03,390 --> 00:44:05,960
Dess andra argumentet är en pekare
till själva listan, så en

939
00:44:05,960 --> 00:44:07,920
pekare till en nod.

940
00:44:07,920 --> 00:44:10,350
>> Allt jag ska gör sedan är deklarera
en temporär variabel.

941
00:44:10,350 --> 00:44:12,730
Vi kallar det ptr av konvention,
för pekaren.

942
00:44:12,730 --> 00:44:15,220
Och jag tilldelar det lika med
början av listan.

943
00:44:15,220 --> 00:44:16,680
>> Och nu märker while-slingan.

944
00:44:16,680 --> 00:44:20,640
Så länge pekaren är inte lika
till null, jag ska kolla.

945
00:44:20,640 --> 00:44:24,520
Är Pilpekaren n lika med
n som antogs i?

946
00:44:24,520 --> 00:44:26,410
Och vänta en minut - ny
bit syntax.

947
00:44:26,410 --> 00:44:29,324
Vad är pil helt plötsligt?

948
00:44:29,324 --> 00:44:30,574
Yeah?

949
00:44:30,574 --> 00:44:34,200

950
00:44:34,200 --> 00:44:34,810
>> Exakt.

951
00:44:34,810 --> 00:44:38,860
Så medan några minuter sedan, använde vi
dot notation för att komma åt något

952
00:44:38,860 --> 00:44:43,080
inne i en struct, om variabeln
du har inte den struct

953
00:44:43,080 --> 00:44:47,420
själv, men en pekare till en struct,
tack och lov, en bit av syntax som

954
00:44:47,420 --> 00:44:48,620
äntligen gör intuitiv känsla.

955
00:44:48,620 --> 00:44:52,360
Pilen betyder att följa pekaren,
som våra pilar betyder vanligen

956
00:44:52,360 --> 00:44:56,570
bildmässigt, och gå på
datafält inuti.

957
00:44:56,570 --> 00:44:59,700
Så pil är samma sak som prick, men
du använda det när du har en pekare.

958
00:44:59,700 --> 00:45:05,270
>> Så bara för att sammanfatta då, om n fältet
insidan av struct kallas pekaren

959
00:45:05,270 --> 00:45:07,760
lika lika n, return true.

960
00:45:07,760 --> 00:45:11,970
Annars denna linje här - pekare
lika pekare nästa.

961
00:45:11,970 --> 00:45:17,540
Så vad detta gör, varsel, är om jag
är för närvarande pekar på struct

962
00:45:17,540 --> 00:45:21,430
innehållande 9, och 9 är inte antalet
Jag letar efter - antar jag letar

963
00:45:21,430 --> 00:45:22,830
för n är lika med 50 -

964
00:45:22,830 --> 00:45:25,930
Jag kommer att uppdatera min tillfälliga pekare
att inte peka på denna nod

965
00:45:25,930 --> 00:45:31,190
längre, men pekaren pilen bredvid, vilket
kommer att sätta mig upp hit.

966
00:45:31,190 --> 00:45:34,270
>> Nu insåg jag är en virvelvind
introduktion.

967
00:45:34,270 --> 00:45:37,380
På onsdag ska vi faktiskt göra detta
med vissa människor och med lite mer

968
00:45:37,380 --> 00:45:38,900
kod i en långsammare takt.

969
00:45:38,900 --> 00:45:42,990
Men inse, gör vi nu våra data
strukturer mer komplex så att vår

970
00:45:42,990 --> 00:45:45,780
algoritmer kan få mer effektiva, vilket
kommer att vara nödvändiga för

971
00:45:45,780 --> 00:45:50,500
pset sex, när vi laddar in, igen, de
150.000 ord, men måste göra det

972
00:45:50,500 --> 00:45:55,650
effektivt, och helst skapa en
program som körs för våra användare inte

973
00:45:55,650 --> 00:46:00,460
linjär, inte i n kvadrat, men i
konstant tid, i den ideala.

974
00:46:00,460 --> 00:46:02,300
>> Vi ses på onsdag.

975
00:46:02,300 --> 00:46:07,240
>> Speak: Vid nästa CS50, David
glömmer sin basfallet.

976
00:46:07,240 --> 00:46:12,770
>> DAVID MALAN: Och det är hur du skickar
textmeddelanden med C. Vad -

977
00:46:12,770 --> 00:46:14,020
>> [Blandat TEXTMEDDELANDE
Meddelandeljud]

978
00:46:14,020 --> 00:46:19,734