1
00:00:00,000 --> 00:00:09,780
>> [MUSIK SPELA]

2
00:00:09,780 --> 00:00:11,150
>> ZAMYLA CHAN: Låt oss ta itu med återhämta sig.

3
00:00:11,150 --> 00:00:14,030
Recover är nog min favorit PSET,
och främst för att jag tycker det är

4
00:00:14,030 --> 00:00:15,650
riktigt, riktigt coolt.

5
00:00:15,650 --> 00:00:19,040
I grund och botten, du får ett minne
kort fil där

6
00:00:19,040 --> 00:00:20,900
bilder har raderats.

7
00:00:20,900 --> 00:00:23,650
Men vad du ska
göra är att återvinna dem alla.

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

9
00:00:24,250 --> 00:00:28,230
Så det är verkligen spännande, men kanske
lite skrämmande, eftersom du är

10
00:00:28,230 --> 00:00:32,430
ges en tom C-fil och
du måste fylla den i.

11
00:00:32,430 --> 00:00:36,250
OK, så låt oss bryta detta
i hanterbara delar.

12
00:00:36,250 --> 00:00:38,160
Du vill öppna
minneskort fil.

13
00:00:38,160 --> 00:00:39,900
Det verkar enkelt nog.

14
00:00:39,900 --> 00:00:43,030
Sedan, gå till början
av en JPG-bild.

15
00:00:43,030 --> 00:00:46,740
Alla filer på detta minne
kort kommer att vara JPG.

16
00:00:46,740 --> 00:00:50,840
Sedan, när du hittar början,
du kommer att öppna en ny JPG, att

17
00:00:50,840 --> 00:00:57,610
är, liksom, skapa en JPG, och skriva 512
byte i taget tills en ny JPG är

18
00:00:57,610 --> 00:01:02,930
hittats, och att programmet har avslutats, när
du upptäcker slutet på filen.

19
00:01:02,930 --> 00:01:06,400
>> Så första stegen först är att öppna
minneskortet filen.

20
00:01:06,400 --> 00:01:09,850
Men du vet detta redan, och det finns
en fil I / O-funktion som kommer att

21
00:01:09,850 --> 00:01:12,030
vara mycket användbar.

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

23
00:01:12,820 --> 00:01:14,760
Så vad är jpgs?

24
00:01:14,760 --> 00:01:16,330
Därför att vi måste början den.

25
00:01:16,330 --> 00:01:21,310
Tja, jpgs, precis som bitmappar,
är bara sekvenser av byte.

26
00:01:21,310 --> 00:01:30,660
Lyckligtvis varje JPG börjar med antingen
0xff, 0xd8, 0xff, 0xe0, en sekvens

27
00:01:30,660 --> 00:01:33,610
av byte, eller en annan
bytesekvensen.

28
00:01:33,610 --> 00:01:37,250
>> Så de fyra byte anger
början på en JPG.

29
00:01:37,250 --> 00:01:40,780
Annat än dessa två kombinationer Inga
av fyra byte.

30
00:01:40,780 --> 00:01:44,840
Och lyckligtvis för oss, en annan att vi
kan dra nytta av är att varje

31
00:01:44,840 --> 00:01:48,550
JPG lagras sida vid sida
på minneskortet.

32
00:01:48,550 --> 00:01:52,210
Jag har representerat strukturen i en
minneskort schematiskt på detta

33
00:01:52,210 --> 00:01:53,310
Skjut här.

34
00:01:53,310 --> 00:01:59,270
Här, varje torg, varje rektangel,
representerar 512 byte, och det börjar

35
00:01:59,270 --> 00:02:01,750
med en grå i att vi inte
verkligen har en JPG.

36
00:02:01,750 --> 00:02:05,700
>> Men så till slut slog vi
ett block med en stjärna.

37
00:02:05,700 --> 00:02:10,940
Det innebär att de första fyra bytes ut
av dem 512 är en av de som två

38
00:02:10,940 --> 00:02:13,230
börjar sekvenser av en JPG.

39
00:02:13,230 --> 00:02:17,340
Och vi går därifrån, och sedan en gång
en JPG slutar, nästa börjar.

40
00:02:17,340 --> 00:02:20,990
Vi behöver aldrig mer
grått utrymme i-mellan.

41
00:02:20,990 --> 00:02:25,550
>> Men hur vi faktiskt läser detta, och
läs 512 byte så att vi kan göra

42
00:02:25,550 --> 00:02:27,500
jämförelsen första hand?

43
00:02:27,500 --> 00:02:33,470
Nåväl, låt oss gå tillbaka till fread, vilket
tar i struct som kommer att innehålla

44
00:02:33,470 --> 00:02:34,470
de byte som du läser.

45
00:02:34,470 --> 00:02:36,570
Så du kommer att sätta
de i det -

46
00:02:36,570 --> 00:02:42,192
storlek, antal, och sedan inpointer
att du läser från.

47
00:02:42,192 --> 00:02:49,900
Nu vill vi läsa 512 åt gången, och
vi vill lagra detta i en buffert,

48
00:02:49,900 --> 00:02:50,700
Jag ska kalla det.

49
00:02:50,700 --> 00:02:54,100
>> I grund och botten, vi kommer att hålla
på de 512 byte och göra

50
00:02:54,100 --> 00:02:55,500
saker med det, eller hur?

51
00:02:55,500 --> 00:02:58,260
Vi ska antingen kommer att jämföra den första
fyra byte, eller vi ska

52
00:02:58,260 --> 00:02:59,830
läste det i, OK?

53
00:02:59,830 --> 00:03:05,050
Så då datapekaren kommer då
fungera som din buffert, och

54
00:03:05,050 --> 00:03:07,745
inpointer, ja, det är bara att gå
vara minneskortet.

55
00:03:07,745 --> 00:03:09,500
>> Tillbaka till vårt minneskort schema.

56
00:03:09,500 --> 00:03:14,690
Vi kommer att läsa 512 byte i taget,
lagra alla 512-byte blocket

57
00:03:14,690 --> 00:03:19,190
in i en buffert, hålla på dem
buffert, de 512 byte, tills vi vet

58
00:03:19,190 --> 00:03:22,000
exakt vad de ska göra dem.

59
00:03:22,000 --> 00:03:25,960
Så i början är inte något, så
Vi ska läsa bufferten, jämföra det, och

60
00:03:25,960 --> 00:03:28,160
Vi behöver inte göra något med det.

61
00:03:28,160 --> 00:03:32,030
Och då, äntligen slog vi en stjärna
blockera, vilket innebär att vi har

62
00:03:32,030 --> 00:03:33,630
hittade vår första JPG.

63
00:03:33,630 --> 00:03:36,560
Så bufferten nu håller
byte från det JPG.

64
00:03:36,560 --> 00:03:40,220
>> Nästa gång 512 byte, eftersom de är
inte en stjärna blocket, också är

65
00:03:40,220 --> 00:03:41,740
en del av denna JPG.

66
00:03:41,740 --> 00:03:47,630
Och jpgs är kontinuerliga däri
på i, tills vi träffade nästa JPG.

67
00:03:47,630 --> 00:03:51,880
Och då bufferten håller sedan
512 byte för att JPG, och

68
00:03:51,880 --> 00:03:53,580
så vidare, och så vidare.

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

70
00:03:54,250 --> 00:03:58,980
>> Så när du träffar den första stjärnmärkta
blocket, den första JPG, hur gör du

71
00:03:58,980 --> 00:04:01,910
faktiskt, ja, öppna den?

72
00:04:01,910 --> 00:04:04,990
Låt oss göra en ny JPG.

73
00:04:04,990 --> 00:04:08,846
Filnamnen för en JPG ska
vara i det formatet, antal, nummer,

74
00:04:08,846 --> 00:04:13,830
number.jpg, i att de är namngiven i
den ordning i vilken de finns,

75
00:04:13,830 --> 00:04:14,780
med början på 0.

76
00:04:14,780 --> 00:04:19,890
>> Så den första JPG som du
hitta kommer 000.jpg.

77
00:04:19,890 --> 00:04:26,560
Så, förmodligen en bra idé att hålla koll
hur många jpgs du har hittat hittills.

78
00:04:26,560 --> 00:04:27,610
Så det är filnamnet.

79
00:04:27,610 --> 00:04:29,660
Men hur gör man egentligen göra det?

80
00:04:29,660 --> 00:04:34,310
Nåväl, vi kommer att använda en
Funktionen kallas sprintf.

81
00:04:34,310 --> 00:04:38,260
Lite liknar printf, där
du kan använda platshållare för stråkar,

82
00:04:38,260 --> 00:04:42,420
förutom att i detta fall kommer sprintf ut
filen ut i den aktuella

83
00:04:42,420 --> 00:04:45,550
katalog, inte in i terminalen.

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

85
00:04:46,120 --> 00:04:49,950
Så här ser vi att vi har titel,
en char array som kommer att lagra de

86
00:04:49,950 --> 00:04:55,120
resulte sträng, och vi passerar på
Titeln på den färdiga strängen med en

87
00:04:55,120 --> 00:04:58,720
platshållare, precis som vi har
lärt sig att göra med printf.

88
00:04:58,720 --> 00:05:05,530
Men denna kod som jag har här
ger 2.jpg, inte 002.jpg.

89
00:05:05,530 --> 00:05:09,920
Så jag lämnar till dig att ta reda på hur man
ändra platshållaren för att göra

90
00:05:09,920 --> 00:05:11,920
rätt namn.

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 då du kan
öppna filen, eftersom den existerar i

93
00:05:17,390 --> 00:05:22,690
din katalog, med fopen, med hjälp av
titel, och sedan vad läge du vill

94
00:05:22,690 --> 00:05:25,140
öppna filen i.

95
00:05:25,140 --> 00:05:30,260
Så nu när vi har öppnat en ny JPG-fil,
Nu kan vi skriva 512 byte vid en

96
00:05:30,260 --> 00:05:33,320
tid, till dess att en ny JPG hittas.

97
00:05:33,320 --> 00:05:36,640
Så låt oss ta en titt
vid syntax fwrite.

98
00:05:36,640 --> 00:05:40,060
>> Jag vet att jag visar denna bild en
mycket, men jag vill bara se till att

99
00:05:40,060 --> 00:05:43,530
ni får inte alltför förvirrad, eftersom
Jag vet att det är mycket lätt att

100
00:05:43,530 --> 00:05:47,000
blanda upp den första och den sista
argument, i synnerhet.

101
00:05:47,000 --> 00:05:54,390
Men kom ihåg att du skriver från
din buffert i ut filen bilderna.

102
00:05:54,390 --> 00:05:59,250
>> Nu när du vet hur skriv-512
bytes in din JPG-fil som du har

103
00:05:59,250 --> 00:06:03,230
skapat, bra, vi vill stoppa det
process när vi har kommit till slutet av

104
00:06:03,230 --> 00:06:06,720
våra kort, eftersom det inte kommer att finnas
några fler bilder som finns.

105
00:06:06,720 --> 00:06:10,760
Så låt oss gå tillbaka till fread
en gång, jag lovar.

106
00:06:10,760 --> 00:06:15,600
fread returnerar hur många objekt av storlek,
storlek, var redo att framgångsrikt.

107
00:06:15,600 --> 00:06:19,440
Helst detta kommer att bli allt
du skickar in för nummer, eller hur?

108
00:06:19,440 --> 00:06:24,140
Eftersom du försöker läsa nummer
av element av storlek, storlek.

109
00:06:24,140 --> 00:06:29,380
Men om fread inte kan läsa det
antal element, då det kommer tillbaka

110
00:06:29,380 --> 00:06:32,530
oavsett nummer det läser framgångsrikt.

111
00:06:32,530 --> 00:06:36,310
>> Nu är en viktig sak att notera
att om du använder en annan fil I / O

112
00:06:36,310 --> 00:06:43,860
fungerar som fgetc, kommer det också tillbaka
hur många objekt det läste framgångsrikt.

113
00:06:43,860 --> 00:06:48,000
Vad är bra om den här funktionen är
att om du använder funktioner inne i en

114
00:06:48,000 --> 00:06:53,190
skick, det ska själv utföra medan
bestämma detta villkor, vilket är

115
00:06:53,190 --> 00:06:54,340
bara riktigt användbart.

116
00:06:54,340 --> 00:07:00,440
Så om du har detta villkor, säg,
om fread buffert, sizeof DOG, 2,

117
00:07:00,440 --> 00:07:04,870
pekare, är lika med är lika med 1, att
betyder att jag vill läsa

118
00:07:04,870 --> 00:07:06,540
2 hundar på den tiden.

119
00:07:06,540 --> 00:07:13,490
Men om fread returnerar en istället för två som
väntat, innebär det att det finns 2

120
00:07:13,490 --> 00:07:16,480
hundar kvar i min fil, utan snarare 1.

121
00:07:16,480 --> 00:07:22,450
Men om den returnerar 2, då jag fortfarande har
dessa två hundar inuti min buffert.

122
00:07:22,450 --> 00:07:26,280
>> Så nu som ger dig en känsla för hur man
kontrollera för slutet av filen, men

123
00:07:26,280 --> 00:07:28,940
vi går igenom nu logiken.

124
00:07:28,940 --> 00:07:32,460
Hur vi faktiskt pussla alla
av dessa element?

125
00:07:32,460 --> 00:07:36,880
När vi träffade vår första JPG, eftersom
vi vet att jpgs lagras

126
00:07:36,880 --> 00:07:40,910
intill varandra, kommer vi att skriva till
vi når slutet på kort fil.

127
00:07:40,910 --> 00:07:43,950
Men vi vill inte skriva
något förrän dess.

128
00:07:43,950 --> 00:07:48,710
Så det spelar roll, inte bara att vi är på
början på en ny JPG, men om

129
00:07:48,710 --> 00:07:50,655
Vi har redan hittat en JPG eller inte.

130
00:07:50,655 --> 00:07:55,390
>> Om det är början på en ny JPG, vi ska
vill stänga vårt nuvarande JPG-fil om

131
00:07:55,390 --> 00:07:59,110
vi har en öppen och öppen
en ny för att skriva in.

132
00:07:59,110 --> 00:08:03,340
Om det inte är början på den nya JPG,
Men ska vi hålla samma JPG-fil

133
00:08:03,340 --> 00:08:05,910
öppna och skriva in det.

134
00:08:05,910 --> 00:08:10,100
Vi ska skriva vår buffert i vilket som
JPG-fil som vi har öppet, under förutsättning att

135
00:08:10,100 --> 00:08:12,120
Vi har en öppen, förstås.

136
00:08:12,120 --> 00:08:16,190
Om vi ​​inte har hittat vår första JPG
Ännu vet vi inte skriva något.

137
00:08:16,190 --> 00:08:20,290
Och denna process fortsätter tills du
nå slutet på kort fil.

138
00:08:20,290 --> 00:08:23,410
>> Och slutligen, kommer du vill göra
Se till att du fclose någon

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

140
00:08:25,800 --> 00:08:28,360
När du är bekväm med det
begrepp, ta en titt på några

141
00:08:28,360 --> 00:08:30,840
pseudokod, som jag har tagit med här.

142
00:08:30,840 --> 00:08:34,830
Först vill du öppna kort fil,
och sedan upprepa följande process

143
00:08:34,830 --> 00:08:37,144
tills du har nått den
änden av kortet.

144
00:08:37,144 --> 00:08:40,880
Du vill läsa 512 bytes
in i en buffert.

145
00:08:40,880 --> 00:08:43,934
Med hjälp av denna buffert, kommer du vill kontrollera
oavsett om du är i början av en

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

147
00:08:45,300 --> 00:08:48,400
Och svaret på den frågan kommer
påverka din filhantering -

148
00:08:48,400 --> 00:08:51,940
vilka filer som du öppnar, vilket
kära ni stänger.

149
00:08:51,940 --> 00:08:55,220
>> Då har du redan fått JPG?

150
00:08:55,220 --> 00:08:57,740
Hur har ni hållit
reda på det?

151
00:08:57,740 --> 00:09:01,735
Sedan, beroende på det, kommer du antingen
skriva in den aktuella JPG som du

152
00:09:01,735 --> 00:09:07,090
har öppet, eller inte skriva det alls,
eftersom du inte har hittat en JPG ännu.

153
00:09:07,090 --> 00:09:10,870
Slutligen, när du har nått slutet av
filen, men du vill stänga alla

154
00:09:10,870 --> 00:09:12,590
resterande filer som du har öppna.

155
00:09:12,590 --> 00:09:14,590
Vi vill vara snyggt här.

156
00:09:14,590 --> 00:09:18,790
>> Och med det, du har återhämtat alla
de saknade filerna från att minnet

157
00:09:18,790 --> 00:09:21,620
kort, vilket är en ganska fantastisk bedrift.

158
00:09:21,620 --> 00:09:23,430
Så klappa dig själv på ryggen.

159
00:09:23,430 --> 00:09:27,560
Men det finns ytterligare en faktor till
den PSET, som är tävlingen.

160
00:09:27,560 --> 00:09:30,920
Du kommer att upptäcka att alla bilder
att du har återhämtat sig faktiskt

161
00:09:30,920 --> 00:09:32,820
bilder av CS50 personal.

162
00:09:32,820 --> 00:09:38,500
Så om du är på campus eller någonstans
nära, då kan du ta bilder med

163
00:09:38,500 --> 00:09:42,600
personal, och den sektion som har de
de flesta bilder med personal

164
00:09:42,600 --> 00:09:46,940
från sin återvunna filer kommer
få en fantastisk vinst.

165
00:09:46,940 --> 00:09:50,650
Med det, då du är klar
återvinnings PSET.

166
00:09:50,650 --> 00:09:53,600
Mitt namn är Zamyla, och detta är CS50.

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