1
00:00:00,000 --> 00:00:09,780
>> [Musikgengivelse]

2
00:00:09,780 --> 00:00:11,150
>> ZAMYLA CHAN: Lad os tage fat på fode igen.

3
00:00:11,150 --> 00:00:14,030
Recover er nok min favorit PSET,
og især fordi jeg synes det er

4
00:00:14,030 --> 00:00:15,650
virkelig, virkelig cool.

5
00:00:15,650 --> 00:00:19,040
Dybest set, får du en hukommelse
kartotek, hvor

6
00:00:19,040 --> 00:00:20,900
billeder er blevet slettet.

7
00:00:20,900 --> 00:00:23,650
Men hvad du vil
gøre, er at inddrive dem alle.

8
00:00:23,650 --> 00:00:24,250
>> OK.

9
00:00:24,250 --> 00:00:28,230
Så det er virkelig spændende, men måske en
lidt skræmmende, fordi du er

10
00:00:28,230 --> 00:00:32,430
givet en tom C-fil og
du nødt til at fylde det i.

11
00:00:32,430 --> 00:00:36,250
OK, så lad os bryde denne
i håndterbare dele.

12
00:00:36,250 --> 00:00:38,160
Du ønsker at åbne
hukommelseskort fil.

13
00:00:38,160 --> 00:00:39,900
Det virker simpelt nok.

14
00:00:39,900 --> 00:00:43,030
Derefter finde begyndelsen
en JPG-billede.

15
00:00:43,030 --> 00:00:46,740
Alle filer på denne hukommelse
kort vil være jpgs.

16
00:00:46,740 --> 00:00:50,840
Så, når du finde begyndelsen,
du kommer til at åbne en ny JPG, at

17
00:00:50,840 --> 00:00:57,610
er, ligesom, oprette en JPG, og skriv 512
byte ad gangen, indtil en ny JPG er

18
00:00:57,610 --> 00:01:02,930
fundet, og afslutning af programmet, når
du detektere slutningen af ​​filen.

19
00:01:02,930 --> 00:01:06,400
>> Så første skridt først er at åbne
hukommelseskortet fil.

20
00:01:06,400 --> 00:01:09,850
Men du kender det allerede, og der er
en fil I / O-funktion, der kommer til

21
00:01:09,850 --> 00:01:12,030
vise sig meget nyttig.

22
00:01:12,030 --> 00:01:12,820
OK.

23
00:01:12,820 --> 00:01:14,760
Så hvad er jpgs?

24
00:01:14,760 --> 00:01:16,330
Fordi vi har brug for til starten.

25
00:01:16,330 --> 00:01:21,310
Nå, jpgs, ligesom bit kort,
er blot sekvenser af byte.

26
00:01:21,310 --> 00:01:30,660
Heldigvis starter hver JPG med enten
0xFF, 0xd8, 0xff, 0xE0, én sekvens

27
00:01:30,660 --> 00:01:33,610
af bytes, eller en anden
sekvens af bytes.

28
00:01:33,610 --> 00:01:37,250
>> Så disse fire bytes angiver
starten på en JPG.

29
00:01:37,250 --> 00:01:40,780
Andre end de to kombinationer Ingen
fire byte.

30
00:01:40,780 --> 00:01:44,840
Og heldigvis for os, et andet faktum, at vi
kan drage fordel af, at hver

31
00:01:44,840 --> 00:01:48,550
JPG lagres side-by-side
på hukommelseskortet.

32
00:01:48,550 --> 00:01:52,210
Jeg har repræsenteret strukturen af ​​en
hukommelseskort skematisk på denne

33
00:01:52,210 --> 00:01:53,310
glide her.

34
00:01:53,310 --> 00:01:59,270
Her hvert kvadrat, hver rektangel,
repræsenterer 512 bytes, og det starter

35
00:01:59,270 --> 00:02:01,750
med en grå i, at vi ikke
virkelig har en JPG.

36
00:02:01,750 --> 00:02:05,700
>> Men derefter vi endelig ramt
en blok med en stjerne.

37
00:02:05,700 --> 00:02:10,940
Det betyder, at de første fire bytes ud
af de 512 er en af ​​de to

38
00:02:10,940 --> 00:02:13,230
start sekvenser af en JPG.

39
00:02:13,230 --> 00:02:17,340
Og vi går derfra, og derefter en gang
en JPG slutter, den næste begynder.

40
00:02:17,340 --> 00:02:20,990
Vi behøver ikke engang nogen mere
grå mellemrum imellem.

41
00:02:20,990 --> 00:02:25,550
>> Men hvordan får vi faktisk læst dette, og
læse 512 bytes, så vi kan gøre

42
00:02:25,550 --> 00:02:27,500
sammenligningen første omgang?

43
00:02:27,500 --> 00:02:33,470
Nå, lad os gå tilbage til fread, som
tager i struct, der indeholder

44
00:02:33,470 --> 00:02:34,470
bytes, du læser.

45
00:02:34,470 --> 00:02:36,570
Så du kommer til at sætte
dem, der -

46
00:02:36,570 --> 00:02:42,192
størrelse, antal og derefter inpointer
at du læser fra.

47
00:02:42,192 --> 00:02:49,900
Nu ønsker vi at læse 512 ad gangen, og
vi ønsker at gemme dette i en buffer,

48
00:02:49,900 --> 00:02:50,700
Jeg har tænkt mig at kalde det.

49
00:02:50,700 --> 00:02:54,100
>> Dybest set, vil vi holde
på de 512 byte og gøre

50
00:02:54,100 --> 00:02:55,500
ting med det, ikke?

51
00:02:55,500 --> 00:02:58,260
Vi enten kommer til at sammenligne den første
fire bytes, eller vi kommer til at

52
00:02:58,260 --> 00:02:59,830
læse det på, okay?

53
00:02:59,830 --> 00:03:05,050
Så datapositionsgiveren vil så
fungere som din buffer, og

54
00:03:05,050 --> 00:03:07,745
inpointer, godt, det er bare at gå
at være dit hukommelseskort.

55
00:03:07,745 --> 00:03:09,500
>> Tilbage til vores hukommelseskort skematiske.

56
00:03:09,500 --> 00:03:14,690
Vi kommer til at læse 512 bytes ad gangen,
lagring hver 512-byte blok

57
00:03:14,690 --> 00:03:19,190
ind i en buffer, holder fast dem
buffer, de 512 bytes, indtil vi ved

58
00:03:19,190 --> 00:03:22,000
præcis hvad de skal gøre dem.

59
00:03:22,000 --> 00:03:25,960
Så begyndelsen er ikke noget, så
vi vil læse den buffer, sammenligne det, og

60
00:03:25,960 --> 00:03:28,160
vi behøver ikke at gøre noget med det.

61
00:03:28,160 --> 00:03:32,030
Og så har vi endelig ramt en stjerne
blok, hvilket betyder, at vi har

62
00:03:32,030 --> 00:03:33,630
fundet vores første JPG.

63
00:03:33,630 --> 00:03:36,560
Så bufferen nu holder
bytes fra JPG.

64
00:03:36,560 --> 00:03:40,220
>> Næste gang 512 bytes, fordi de er
ikke en stjerne-blok, er også

65
00:03:40,220 --> 00:03:41,740
del af denne JPG.

66
00:03:41,740 --> 00:03:47,630
Og jpgs er kontinuerlige derfra
ind, indtil vi ramte den næste JPG.

67
00:03:47,630 --> 00:03:51,880
Og så buffer så besidder
512 bytes for at JPG og

68
00:03:51,880 --> 00:03:53,580
så videre, og så videre.

69
00:03:53,580 --> 00:03:54,250
OK.

70
00:03:54,250 --> 00:03:58,980
>> Så når du rammer den første stjerne
blok, den første JPG, hvordan gør du

71
00:03:58,980 --> 00:04:01,910
faktisk, ja, åbner den?

72
00:04:01,910 --> 00:04:04,990
Lad os lave en ny JPG.

73
00:04:04,990 --> 00:04:08,846
Filnavne for en JPG kommer til at
være i formatet, tal, tal,

74
00:04:08,846 --> 00:04:13,830
number.jpg, i, at de er navngivet i
den rækkefølge, hvori de findes,

75
00:04:13,830 --> 00:04:14,780
starter ved 0.

76
00:04:14,780 --> 00:04:19,890
>> Så den første JPG, du
find blive 000.jpg.

77
00:04:19,890 --> 00:04:26,560
Så nok en god idé at holde styr
hvor mange jpgs du har fundet indtil videre.

78
00:04:26,560 --> 00:04:27,610
Så det er filnavnet.

79
00:04:27,610 --> 00:04:29,660
Men hvordan kan du faktisk gøre det?

80
00:04:29,660 --> 00:04:34,310
Nå, vi kommer til at bruge en
funktion kaldet sprintf.

81
00:04:34,310 --> 00:04:38,260
En lille smule ligner printf, hvor
kan du bruge pladsholdere for strygere,

82
00:04:38,260 --> 00:04:42,420
undtagen i dette tilfælde, vil sprintf udskrive
filen ud i den aktuelle

83
00:04:42,420 --> 00:04:45,550
mappe, ikke i terminalen.

84
00:04:45,550 --> 00:04:46,120
>> OK.

85
00:04:46,120 --> 00:04:49,950
Så her ser vi, at vi har titel,
en char array, der gemmer

86
00:04:49,950 --> 00:04:55,120
resulterende streng, og vi passerer i
titel faktiske strengen med en

87
00:04:55,120 --> 00:04:58,720
pladsholder, ligesom vi har
lærte at gøre med printf.

88
00:04:58,720 --> 00:05:05,530
Men denne kode, som jeg har her
vil give 2.jpg ikke 002.jpg.

89
00:05:05,530 --> 00:05:09,920
Så jeg vil overlade til dig at finde ud af, hvordan
ændre pladsholder for at gøre

90
00:05:09,920 --> 00:05:11,920
korrekte navn.

91
00:05:11,920 --> 00:05:12,610
>> OK.

92
00:05:12,610 --> 00:05:17,390
Så når du har sprintf'd så kan du
åbner filen, fordi det findes i

93
00:05:17,390 --> 00:05:22,690
dit bibliotek med fopen, ved hjælp af
titel, og derefter den tilstand, du ønsker

94
00:05:22,690 --> 00:05:25,140
for at åbne filen i.

95
00:05:25,140 --> 00:05:30,260
Så nu, at vi har åbnet en ny JPG-fil,
nu kan vi skrive 512 bytes på en

96
00:05:30,260 --> 00:05:33,320
gang, indtil en ny JPG er fundet.

97
00:05:33,320 --> 00:05:36,640
Så lad os tage endnu et kig
på syntaksen i fwrite.

98
00:05:36,640 --> 00:05:40,060
>> Jeg ved, at jeg viser dette dias en
meget, men jeg vil bare sørge for, at

99
00:05:40,060 --> 00:05:43,530
du fyre ikke får alt for forvirret, fordi
Jeg ved, at det er meget nemt at

100
00:05:43,530 --> 00:05:47,000
blande det første og det sidste
argument i særdeleshed.

101
00:05:47,000 --> 00:05:54,390
Men husk, at du skriver fra
din buffer ind i de out file billeder.

102
00:05:54,390 --> 00:05:59,250
>> Nu, at du ved, hvordan skrive 512
bytes ind i din JPG-fil, som du har

103
00:05:59,250 --> 00:06:03,230
skabt, ja, vi ønsker at stoppe det
proces, når vi har nået slutningen af

104
00:06:03,230 --> 00:06:06,720
vores kort, fordi der ikke vil være
flere billeder, der skal findes.

105
00:06:06,720 --> 00:06:10,760
Så lad os gå tilbage til fread
en gang mere, det lover jeg.

106
00:06:10,760 --> 00:06:15,600
fread returnerer hvor mange elementer af størrelse,
størrelse, var klar i med succes.

107
00:06:15,600 --> 00:06:19,440
Ideelt set vil dette være, hvad
du passerer på for nummer, right?

108
00:06:19,440 --> 00:06:24,140
Fordi du forsøger at læse nummer
af elementer af størrelse, størrelse.

109
00:06:24,140 --> 00:06:29,380
Men hvis fread ikke er i stand til at læse, at
række elementer, så det vil vende tilbage

110
00:06:29,380 --> 00:06:32,530
uanset nummer det læses med succes.

111
00:06:32,530 --> 00:06:36,310
>> Nu, en vigtig ting at bemærke er
at hvis du bruger en anden fil I / O

112
00:06:36,310 --> 00:06:43,860
funktion som fgetc, vil det også vende tilbage
hvor mange varer det læste med succes.

113
00:06:43,860 --> 00:06:48,000
Hvad er nyttigt om denne funktion er
at hvis du bruger funktioner inde i en

114
00:06:48,000 --> 00:06:53,190
tilstand, vil det udføre sig selv, mens
bestemmelse af denne betingelse, som er

115
00:06:53,190 --> 00:06:54,340
bare virkelig nyttige.

116
00:06:54,340 --> 00:07:00,440
Så hvis du har dette forhold, siger,
hvis fread buffer, sizeof DOG, 2,

117
00:07:00,440 --> 00:07:04,870
pointer, lig er lig med 1, at
betyder, at jeg gerne vil læse

118
00:07:04,870 --> 00:07:06,540
2 hunde på det tidspunkt.

119
00:07:06,540 --> 00:07:13,490
Men hvis fread returnerer 1 i stedet for 2 som
forventet, det betyder, at der er 2

120
00:07:13,490 --> 00:07:16,480
hunde tilbage i min fil, men snarere 1..

121
00:07:16,480 --> 00:07:22,450
Men hvis det returnerer 2, da jeg stadig har
disse 2 hunde inde i min buffer.

122
00:07:22,450 --> 00:07:26,280
>> Så nu, der giver dig en fornemmelse af, hvordan
kontrollere, om slutningen af ​​filen, men

123
00:07:26,280 --> 00:07:28,940
lad os gå igennem nu logikken.

124
00:07:28,940 --> 00:07:32,460
Hvordan kan vi faktisk stykke alle
af disse elementer sammen?

125
00:07:32,460 --> 00:07:36,880
Når vi ramt vores første JPG, eftersom
vi ved, at jpgs gemmes

126
00:07:36,880 --> 00:07:40,910
contiguously, vil vi skrive, indtil
vi når enden af ​​kortet fil.

127
00:07:40,910 --> 00:07:43,950
Men vi ønsker ikke at skrive
noget indtil da.

128
00:07:43,950 --> 00:07:48,710
Så det betyder noget, ikke blot, at vi er på
starten på en ny JPG, men om

129
00:07:48,710 --> 00:07:50,655
vi har allerede fundet et JPG eller ej.

130
00:07:50,655 --> 00:07:55,390
>> Hvis det er starten på en ny JPG, vi får
ønsker at lukke vores aktuelle JPG fil, hvis

131
00:07:55,390 --> 00:07:59,110
vi har en åben og åben
en ny til at skrive ind.

132
00:07:59,110 --> 00:08:03,340
Hvis det ikke er starten på den nye JPG,
selv, vil vi holde den samme JPG-fil

133
00:08:03,340 --> 00:08:05,910
åbne og skrive ind.

134
00:08:05,910 --> 00:08:10,100
Vi skriver vores buffer ind i alt efter
JPG-fil vi har åbent, forudsat at

135
00:08:10,100 --> 00:08:12,120
vi har en åben, selvfølgelig.

136
00:08:12,120 --> 00:08:16,190
Hvis vi ikke har fundet vores første JPG
endnu, vi ikke skrive noget.

137
00:08:16,190 --> 00:08:20,290
Og denne proces fortsætter, indtil du
nå enden af ​​kortet fil.

138
00:08:20,290 --> 00:08:23,410
>> Og endelig, vil du ønsker at gøre
sikker på, at du fclose enhver

139
00:08:23,410 --> 00:08:25,800
filer, du har fopened.

140
00:08:25,800 --> 00:08:28,360
Når du er fortrolig med den
koncepter, tage et kig på nogle

141
00:08:28,360 --> 00:08:30,840
pseudokode, som jeg har medtaget her.

142
00:08:30,840 --> 00:08:34,830
Først, du ønsker at åbne kortet fil,
og derefter gentage følgende proces

143
00:08:34,830 --> 00:08:37,144
indtil du har nået
enden af ​​kortet.

144
00:08:37,144 --> 00:08:40,880
Du ønsker at læse 512 bytes
i en buffer.

145
00:08:40,880 --> 00:08:43,934
Ved hjælp af denne buffer, vil du ønsker at kontrollere
uanset om du er i starten af ​​en

146
00:08:43,934 --> 00:08:45,300
ny JPG eller ej.

147
00:08:45,300 --> 00:08:48,400
Og svaret på dette spørgsmål vil
påvirke din filhåndtering -

148
00:08:48,400 --> 00:08:51,940
hvilke filer, du åbner, hvilket
dem lukker du.

149
00:08:51,940 --> 00:08:55,220
>> Så har du allerede fundet en JPG?

150
00:08:55,220 --> 00:08:57,740
Hvordan har du været at holde
styr på det?

151
00:08:57,740 --> 00:09:01,735
Derefter afhængigt af dette, vil du enten
skrive i det aktuelle JPG du

152
00:09:01,735 --> 00:09:07,090
har åbne, eller ikke skrive det på alle,
fordi du ikke har fundet en JPG endnu.

153
00:09:07,090 --> 00:09:10,870
Endelig, når du har nået slutningen af
filen, vil du ønsker at lukke enhver

154
00:09:10,870 --> 00:09:12,590
resterende filer, du har åbne.

155
00:09:12,590 --> 00:09:14,590
Vi ønsker at være pæn her.

156
00:09:14,590 --> 00:09:18,790
>> Og med det, du har genvundet alle
de manglende filer fra at hukommelsen

157
00:09:18,790 --> 00:09:21,620
kort, hvilket er en temmelig fantastisk præstation.

158
00:09:21,620 --> 00:09:23,430
Så klappe dig selv på ryggen.

159
00:09:23,430 --> 00:09:27,560
Men der er endnu et element til
den PSET, hvilket er konkurrencen.

160
00:09:27,560 --> 00:09:30,920
Du vil opdage, at alle de billeder
at du har genvundet faktisk

161
00:09:30,920 --> 00:09:32,820
billeder af CS50 personale.

162
00:09:32,820 --> 00:09:38,500
Så hvis du er på campus eller andet sted
nær, så kan du tage billeder med

163
00:09:38,500 --> 00:09:42,600
personalet, og det afsnit, der har den
de fleste billeder med ansatte

164
00:09:42,600 --> 00:09:46,940
fra deres gendannede filer vil
få en awesome præmie.

165
00:09:46,940 --> 00:09:50,650
Med det, så har du færdig
den genvinde PSET.

166
00:09:50,650 --> 00:09:53,600
Mit navn er Zamyla, og det er CS50.

167
00:09:53,600 --> 00:10:01,835