1
00:00:00,000 --> 00:00:09,780
>> [संगीत खेल]

2
00:00:09,780 --> 00:00:11,150
>> ZAMYLA चान: उबरने के निपटने.

3
00:00:11,150 --> 00:00:14,030
की वसूली शायद मेरी पसंदीदा PSET है,
और मुख्य रूप से मुझे लगता है कि क्योंकि

4
00:00:14,030 --> 00:00:15,650
वास्तव में, वास्तव में अच्छा.

5
00:00:15,650 --> 00:00:19,040
असल में, आप एक स्मृति दिया हो
कार्ड फ़ाइल जिसमें

6
00:00:19,040 --> 00:00:20,900
चित्र हटा दिया गया है.

7
00:00:20,900 --> 00:00:23,650
लेकिन क्या आप करने जा रहे हैं
उन्हें पूरी तरह से ठीक है.

8
00:00:23,650 --> 00:00:24,250
>> ठीक है.

9
00:00:24,250 --> 00:00:28,230
तो यह हो सकता है वास्तव में रोमांचक है, लेकिन एक
आप कर रहे हैं, क्योंकि थोड़ा डरा देता है

10
00:00:28,230 --> 00:00:32,430
एक खाली सी फ़ाइल और दिए
आप इसे अंदर भरने के लिए है

11
00:00:32,430 --> 00:00:36,250
ठीक है, तो चलो इस तोड़
प्रबंधनीय भागों में.

12
00:00:36,250 --> 00:00:38,160
आप खोलना चाहता हूँ
मेमोरी कार्ड फ़ाइल.

13
00:00:38,160 --> 00:00:39,900
यह काफी आसान लगता है.

14
00:00:39,900 --> 00:00:43,030
फिर, शुरुआत लगता है
एक JPG छवि की.

15
00:00:43,030 --> 00:00:46,740
इस स्मृति पर सभी फाइलें
कार्ड JPGs होने जा रहे हैं.

16
00:00:46,740 --> 00:00:50,840
फिर, एक बार आप शुरुआत लगता है
यदि आप एक New तस्वीरें खोलने के लिए जा रहे हैं कि

17
00:00:50,840 --> 00:00:57,610
, जैसे, एक JPG बनाने, और 512 लिखना है
एक New तस्वीरें है जब तक एक समय में बाइट

18
00:00:57,610 --> 00:01:02,930
पाया, और कार्यक्रम समाप्त, एक बार
आप फ़ाइल के अंत का पता लगाने.

19
00:01:02,930 --> 00:01:06,400
>> तो पहला कदम पहले खोलने के लिए है
मेमोरी कार्ड फ़ाइल.

20
00:01:06,400 --> 00:01:09,850
लेकिन अगर आप पहले से ही यह पता है, और वहाँ
जा रहा है कि एक फाइल मैं / ओ समारोह

21
00:01:09,850 --> 00:01:12,030
बहुत उपयोगी साबित होते हैं.

22
00:01:12,030 --> 00:01:12,820
ठीक है.

23
00:01:12,820 --> 00:01:14,760
तो JPGs क्या कर रहे हैं?

24
00:01:14,760 --> 00:01:16,330
हम शुरुआत करने के लिए इसकी जरूरत है.

25
00:01:16,330 --> 00:01:21,310
खैर, JPGs, बस थोड़ा और नक्शे की तरह,
बाइट्स की सिर्फ दृश्यों हैं.

26
00:01:21,310 --> 00:01:30,660
सौभाग्य से, हर JPG किसी के साथ शुरू होता है
0xFF, 0xd8, 0xff, 0xe0, एक अनुक्रम

27
00:01:30,660 --> 00:01:33,610
बाइट्स, या किसी अन्य
बाइट्स का अनुक्रम.

28
00:01:33,610 --> 00:01:37,250
>> तो उन चार बाइट्स का संकेत
एक JPG की शुरुआत.

29
00:01:37,250 --> 00:01:40,780
उन दो संयोजनों के अलावा अन्य कोई नहीं
चार बाइट्स की.

30
00:01:40,780 --> 00:01:44,840
और सौभाग्य से हमारे लिए, एक और तथ्य यह है कि हम
का लाभ ले सकते है कि हर

31
00:01:44,840 --> 00:01:48,550
JPG पक्ष द्वारा साइड संग्रहीत किया जाता है
मेमोरी कार्ड पर.

32
00:01:48,550 --> 00:01:52,210
मैं एक की संरचना में प्रतिनिधित्व किया है
रेखाचित्र के रूप में इस पर मेमोरी कार्ड

33
00:01:52,210 --> 00:01:53,310
यहाँ स्लाइड.

34
00:01:53,310 --> 00:01:59,270
यहाँ, हर वर्ग, हर आयत,
512 बाइट्स का प्रतिनिधित्व करता है, और यह शुरू होता है

35
00:01:59,270 --> 00:02:01,750
हम नहीं करते कि में एक भूरे रंग के साथ
वास्तव में एक JPG है.

36
00:02:01,750 --> 00:02:05,700
>> लेकिन फिर हम अंत में मारा
एक स्टार के साथ एक ब्लॉक.

37
00:02:05,700 --> 00:02:10,940
इसका मतलब है कि पहले चार बाइट्स बाहर
उन में से 512 उन दो में से एक हैं

38
00:02:10,940 --> 00:02:13,230
एक JPG के दृश्यों शुरू.

39
00:02:13,230 --> 00:02:17,340
और हम एक बार फिर वहाँ से चले जाओ, और
एक JPG अगले एक शुरू होता है, समाप्त हो जाती है.

40
00:02:17,340 --> 00:02:20,990
हम कभी भी किसी भी अधिक नहीं है
बीच में ग्रे अंतरिक्ष.

41
00:02:20,990 --> 00:02:25,550
>> लेकिन यह कैसे हम वास्तव में इस पढ़ा है, और है
हम कर सकते हैं ताकि 512 बाइट्स पढ़ा

42
00:02:25,550 --> 00:02:27,500
तुलना पहली जगह?

43
00:02:27,500 --> 00:02:33,470
ठीक है, चलो, वापस fread के लिए चलते हैं जो
में शामिल होंगे कि संरचना में ले जाता है

44
00:02:33,470 --> 00:02:34,470
आप पढ़ रहे हैं कि बाइट्स.

45
00:02:34,470 --> 00:02:36,570
तो तुम डाल करने के लिए जा रहे हैं
वहाँ में उन -

46
00:02:36,570 --> 00:02:42,192
आकार, संख्या, और फिर inpointer
आप से पढ़ रहे हैं.

47
00:02:42,192 --> 00:02:49,900
अब, हम एक समय में 512 पढ़ना चाहते हैं, और
हम एक बफर में इस संग्रहीत करना चाहते हैं,

48
00:02:49,900 --> 00:02:50,700
मैं यह कॉल करने के लिए जा रहा हूँ.

49
00:02:50,700 --> 00:02:54,100
>> असल में, हम आयोजित करने जा रहे हैं
उन 512 बाइट्स पर और कर

50
00:02:54,100 --> 00:02:55,500
इसके साथ बातें, है ना?

51
00:02:55,500 --> 00:02:58,260
हम या तो पहले की तुलना करने के लिए जा रहे हैं
चार बाइट्स, या हम करने जा रहे हैं

52
00:02:58,260 --> 00:02:59,830
ठीक है, उस में पढ़ा है?

53
00:02:59,830 --> 00:03:05,050
तो फिर डेटा सूचक तो होगा
अपने बफर के रूप में सेवा, और

54
00:03:05,050 --> 00:03:07,745
inpointer, ठीक है, कि बस हो रहा है
अपनी स्मृति कार्ड होने के लिए.

55
00:03:07,745 --> 00:03:09,500
>> हमारी स्मृति कार्ड योजनाबद्ध के लिए वापस.

56
00:03:09,500 --> 00:03:14,690
हम एक समय में 512 बाइट्स पढ़ने के लिए जा रहे हैं,
हर 512 बाइट ब्लॉक के संचय

57
00:03:14,690 --> 00:03:19,190
एक बफर में पकड़े उन पर
हम जानते हैं, जब तक उन 512 बाइट्स बफर

58
00:03:19,190 --> 00:03:22,000
वास्तव में क्या उन्हें ऐसा करने के लिए.

59
00:03:22,000 --> 00:03:25,960
तो शुरुआत में कुछ भी नहीं है, तो
हम बफर पढ़ा इसकी तुलना करें, और हूँ

60
00:03:25,960 --> 00:03:28,160
हम इसके साथ कुछ भी करने की जरूरत नहीं होगी.

61
00:03:28,160 --> 00:03:32,030
और फिर, हम अंत में एक सितारा मारा
हम है जिसका अर्थ है कि ब्लॉक

62
00:03:32,030 --> 00:03:33,630
हमारी पहली JPG पाया.

63
00:03:33,630 --> 00:03:36,560
तो बफर अब पकड़
कि JPG से बाइट्स.

64
00:03:36,560 --> 00:03:40,220
>> वे कर रहे हैं 512 बाइट्स, क्योंकि अगली बार
नहीं एक सितारा ब्लॉक, भी कर रहे हैं

65
00:03:40,220 --> 00:03:41,740
कि JPG का हिस्सा है.

66
00:03:41,740 --> 00:03:47,630
और JPGs वहाँ से लगातार कर रहे हैं
पर हम अगले JPG मारा, जब तक में.

67
00:03:47,630 --> 00:03:51,880
और फिर बफर तो रखती है
512 कि JPG लिए बाइट्स, और

68
00:03:51,880 --> 00:03:53,580
इतने पर है, और बहुत आगे है.

69
00:03:53,580 --> 00:03:54,250
ठीक है.

70
00:03:54,250 --> 00:03:58,980
>> आप पहले तारांकित मारा तो एक बार
ब्लॉक, पहले जेपीजी, आप कैसे करते हैं

71
00:03:58,980 --> 00:04:01,910
वास्तव में, ठीक है, इसे खोलने?

72
00:04:01,910 --> 00:04:04,990
चलो एक New तस्वीरें बनाते हैं.

73
00:04:04,990 --> 00:04:08,846
एक JPG लिए filenames के लिए जा रहे हैं
प्रारूप में होना, संख्या, संख्या,

74
00:04:08,846 --> 00:04:13,830
number.jpg, उस में वे में नामित कर रहे हैं
वे पाए जाते हैं जिस क्रम में,

75
00:04:13,830 --> 00:04:14,780
0 से शुरू.

76
00:04:14,780 --> 00:04:19,890
>> तो पहले JPG कि आप
खोजने 000.jpg किया जाएगा.

77
00:04:19,890 --> 00:04:26,560
तो, शायद एक अच्छा विचार ट्रैक रखने के लिए
आप अब तक पाया है की कितने JPGs.

78
00:04:26,560 --> 00:04:27,610
तो उस फ़ाइल का नाम है.

79
00:04:27,610 --> 00:04:29,660
लेकिन यह कैसे आप वास्तव में है कि कैसे कर सकता हूँ?

80
00:04:29,660 --> 00:04:34,310
खैर, हम प्रयोग करने जा रहे हैं एक
समारोह sprintf कहा जाता है.

81
00:04:34,310 --> 00:04:38,260
Printf के लिए इसी तरह एक छोटा सा, जहां
आप, तार के लिए प्लेसहोल्डर का उपयोग कर सकते हैं

82
00:04:38,260 --> 00:04:42,420
इस मामले में छोड़कर, sprintf मुद्रित होगा
वर्तमान में फाइल बाहर

83
00:04:42,420 --> 00:04:45,550
निर्देशिका, नहीं टर्मिनल में.

84
00:04:45,550 --> 00:04:46,120
>> ठीक है.

85
00:04:46,120 --> 00:04:49,950
तो यहाँ हम हम शीर्षक देखते हैं कि,
दुकान होगी कि एक चार सरणी

86
00:04:49,950 --> 00:04:55,120
परिणामी स्ट्रिंग, और हम में पारित
एक साथ वास्तविक स्ट्रिंग का शीर्षक

87
00:04:55,120 --> 00:04:58,720
प्लेसहोल्डर, बस हम है जैसे
printf के साथ क्या करना सीखा.

88
00:04:58,720 --> 00:05:05,530
लेकिन मैं यहाँ है कि इस कोड
2.jpg, नहीं 002.jpg दे देंगे.

89
00:05:05,530 --> 00:05:09,920
तो मैं पता लगाने के लिए आप के लिए छोड़ दूँगा कैसे करने के लिए
बनाने के लिए प्लेसहोल्डर संशोधित

90
00:05:09,920 --> 00:05:11,920
सही नाम.

91
00:05:11,920 --> 00:05:12,610
>> ठीक है.

92
00:05:12,610 --> 00:05:17,390
तो एक बार आप आप कर सकते हैं तो sprintf'd गया है
इसमें मौजूद है, क्योंकि उस फ़ाइल को खोलने

93
00:05:17,390 --> 00:05:22,690
fopen के साथ अपने निर्देशिका, का उपयोग
शीर्षक है, और आप चाहते हैं तो जो कुछ मोड

94
00:05:22,690 --> 00:05:25,140
अंदर उस फ़ाइल को खोलने के लिए

95
00:05:25,140 --> 00:05:30,260
तो अब हम एक नई JPG फ़ाइल खोल दिया है कि,
अब हम एक पर 512 बाइट्स लिख सकते हैं

96
00:05:30,260 --> 00:05:33,320
एक New तस्वीरें पाया जाता है जब तक समय,.

97
00:05:33,320 --> 00:05:36,640
तो चलो एक और नज़र रखना
fwrite के वाक्यविन्यास पर.

98
00:05:36,640 --> 00:05:40,060
>> मुझे लगता है मैं इस स्लाइड एक दिखा रहा हूँ कि पता
बहुत कुछ है, लेकिन मैं सिर्फ यकीन है कि बनाने के लिए चाहते हैं

99
00:05:40,060 --> 00:05:43,530
तुम लोग, भी उलझन में नहीं मिलता है क्योंकि
मैं यह बहुत आसान है कि पता

100
00:05:43,530 --> 00:05:47,000
पहली और आखिरी मिश्रण
तर्क, विशेष रूप से.

101
00:05:47,000 --> 00:05:54,390
लेकिन आप से लिख रहे हैं कि याद
बाहर फ़ाइल छवियों में अपने बफर.

102
00:05:54,390 --> 00:05:59,250
>> अब तुम्हें पता है कि कैसे लिखने के 512
आप है कि आपके JPG फ़ाइल में बाइट्स

103
00:05:59,250 --> 00:06:03,230
बनाया, ठीक है, हम उस बंद करना चाहते हैं
हम अंत में पहुँच चुके हैं प्रक्रिया एक बार

104
00:06:03,230 --> 00:06:06,720
हमारे कार्ड, क्योंकि वहाँ नहीं होगा
पाया जा के लिए किसी भी अधिक छवियों.

105
00:06:06,720 --> 00:06:10,760
तो चलो fread के लिए वापस जाओ
एक बार फिर, मैं वादा करता हूँ.

106
00:06:10,760 --> 00:06:15,600
fread आकार के कितने आइटम देता है,
आकार, सफलतापूर्वक में तैयार थे.

107
00:06:15,600 --> 00:06:19,440
आदर्श रूप में, यह होने जा रहा है जो कुछ भी
आप सही, संख्या के लिए में पास?

108
00:06:19,440 --> 00:06:24,140
आप संख्या को पढ़ने के लिए कोशिश कर रहे हैं क्योंकि
आकार, आकार के तत्वों की.

109
00:06:24,140 --> 00:06:29,380
लेकिन fread कि पढ़ने में सक्षम नहीं है, तो
तत्वों की संख्या है, तो यह वापस कर देंगे

110
00:06:29,380 --> 00:06:32,530
इसे सफलतापूर्वक पढ़ने के लिए जो कुछ भी संख्या.

111
00:06:32,530 --> 00:06:36,310
>> अब, एक नोट के लिए महत्वपूर्ण बात है
कि तुम मैं / ओ अन्य फ़ाइल का उपयोग करें

112
00:06:36,310 --> 00:06:43,860
fgetc जैसे समारोह, यह भी वापस कर देंगे
इसे सफलतापूर्वक पढ़ने के कितने आइटम नहीं है.

113
00:06:43,860 --> 00:06:48,000
क्या इस समारोह के बारे में उपयोगी है है
कि आप एक के अंदर कार्यों का उपयोग अगर

114
00:06:48,000 --> 00:06:53,190
हालत, जबकि यह खुद पर अमल करेंगे
है जो कि हालत, का निर्धारण

115
00:06:53,190 --> 00:06:54,340
सिर्फ सच में उपयोगी.

116
00:06:54,340 --> 00:07:00,440
तो अगर आप इस स्थिति है, कहते हैं,
अगर fread बफर, sizeof कुत्ते, 2,

117
00:07:00,440 --> 00:07:04,870
सूचक, 1 बराबर है कि
मैं पढ़ने के लिए करना चाहते हैं इसका मतलब है कि

118
00:07:04,870 --> 00:07:06,540
समय पर 2 कुत्तों.

119
00:07:06,540 --> 00:07:13,490
लेकिन fread के रूप में 2 के बजाय 1 लौटता है
उम्मीद है, कि वहाँ 2 का मतलब है कि

120
00:07:13,490 --> 00:07:16,480
कुत्तों मेरी फाइल में छोड़ दिया, बल्कि 1.

121
00:07:16,480 --> 00:07:22,450
लेकिन यह 2 देता है, तो मैं अब भी है
मेरे बफर के अंदर उन 2 कुत्तों.

122
00:07:22,450 --> 00:07:26,280
>> तो अब है कि आप कैसे करने के लिए की भावना देता है
फ़ाइल के अंत के लिए जाँच, लेकिन

123
00:07:26,280 --> 00:07:28,940
चलो अब तर्क के माध्यम से चलते हैं.

124
00:07:28,940 --> 00:07:32,460
कैसे हम वास्तव में सभी टुकड़ा
एक साथ इन तत्वों की?

125
00:07:32,460 --> 00:07:36,880
हम हमारी पहली JPG हिट एक बार, के बाद से
हम JPGs जमा हो जाती है कि पता

126
00:07:36,880 --> 00:07:40,910
समीप से, हम तक लिख सकता हूँ
हम कार्ड फ़ाइल के अंत तक पहुँचते हैं.

127
00:07:40,910 --> 00:07:43,950
लेकिन हम लिखने के लिए नहीं करना चाहती
कुछ भी तो जब तक.

128
00:07:43,950 --> 00:07:48,710
तो यह हम पर कर रहे हैं कि न केवल मायने रखती है
एक नए JPG की शुरुआत है, लेकिन चाहे

129
00:07:48,710 --> 00:07:50,655
हम पहले से ही एक JPG या नहीं पाया है.

130
00:07:50,655 --> 00:07:55,390
>> यह एक नया JPG की शुरुआत है, हम करेंगे
हमारे वर्तमान JPG फाइल अगर बंद करना चाहते हैं

131
00:07:55,390 --> 00:07:59,110
हम एक खुला, और खुला है
में लिखने के लिए एक नया एक.

132
00:07:59,110 --> 00:08:03,340
यह New तस्वीरें की शुरुआत नहीं है,
हालांकि, हम एक ही JPG फ़ाइल रखेंगे

133
00:08:03,340 --> 00:08:05,910
खोलने और उस में लिखें.

134
00:08:05,910 --> 00:08:10,100
हम जो भी हमारे बफर लिख देंगे
हम खुला है JPG फ़ाइल, बशर्ते कि

135
00:08:10,100 --> 00:08:12,120
हम निश्चित रूप से, एक खुला है.

136
00:08:12,120 --> 00:08:16,190
हम हमारी पहली JPG नहीं मिला है
फिर भी, हम कुछ भी नहीं लिख सकता हूँ.

137
00:08:16,190 --> 00:08:20,290
और इस प्रक्रिया को आप तक जारी है
कार्ड फ़ाइल के अंत तक पहुँचते हैं.

138
00:08:20,290 --> 00:08:23,410
>> और अंत में, आप करना चाहते हैं
आप किसी भी fclose यह सुनिश्चित करें कि

139
00:08:23,410 --> 00:08:25,800
आप fopened किया है कि फ़ाइलें.

140
00:08:25,800 --> 00:08:28,360
आप के साथ आराम कर रहे हैं एक बार
अवधारणाओं, कुछ पर एक नज़र रखना

141
00:08:28,360 --> 00:08:30,840
मैं यहाँ शामिल किया है जो pseudocode,.

142
00:08:30,840 --> 00:08:34,830
सबसे पहले, आप कार्ड फ़ाइल को खोलने के लिए चाहते हैं,
और उसके बाद निम्न प्रक्रिया को दोहराने

143
00:08:34,830 --> 00:08:37,144
आप पहुँच चुके हैं जब तक
कार्ड का अंत.

144
00:08:37,144 --> 00:08:40,880
आप 512 बाइट्स पढ़ना चाहते हैं
एक बफर में.

145
00:08:40,880 --> 00:08:43,934
कि बफर का उपयोग कर, आप जाँच करना चाहते हूँ
आप एक के शुरू में कर रहे हैं कि क्या

146
00:08:43,934 --> 00:08:45,300
New तस्वीरें या नहीं.

147
00:08:45,300 --> 00:08:48,400
और उस सवाल का जवाब देना होगा
आपकी फ़ाइल प्रबंधन को प्रभावित -

148
00:08:48,400 --> 00:08:51,940
जो आप खुली फ़ाइलों, जो
लोगों को आप को बंद करते हैं.

149
00:08:51,940 --> 00:08:55,220
>> उसके बाद, आप पहले से ही एक JPG मिल गया है?

150
00:08:55,220 --> 00:08:57,740
आप कैसे रख दिया गया है
इस बात का ट्रैक?

151
00:08:57,740 --> 00:09:01,735
उसके बाद, उस पर निर्भर करता है, आप या तो
वर्तमान JPG में लिखना है कि आप

152
00:09:01,735 --> 00:09:07,090
यह सब पर लिखना खुला, या नहीं है,
आप अभी तक एक JPG नहीं मिला है क्योंकि.

153
00:09:07,090 --> 00:09:10,870
अंत में, एक बार आप अंत में पहुँच चुके हैं
फ़ाइल, आप किसी भी बंद करने के लिए चाहता हूँ

154
00:09:10,870 --> 00:09:12,590
आप खुले फ़ाइलें शेष.

155
00:09:12,590 --> 00:09:14,590
हम यहाँ सुथरा होना चाहते हैं.

156
00:09:14,590 --> 00:09:18,790
>> और उस के साथ, आप सभी को बरामद किया
कि स्मृति से लापता फ़ाइलों

157
00:09:18,790 --> 00:09:21,620
एक सुंदर और अद्भुत उपलब्धि है जो कार्ड,.

158
00:09:21,620 --> 00:09:23,430
तो पीठ पर अपने आप को थपथपाना.

159
00:09:23,430 --> 00:09:27,560
लेकिन, एक और तत्व है
प्रतियोगिता है जो PSET,.

160
00:09:27,560 --> 00:09:30,920
आप पाएंगे कि सभी चित्रों का
तुम बरामद किया है कि वास्तव में कर रहे हैं

161
00:09:30,920 --> 00:09:32,820
CS50 के कर्मचारियों की तस्वीरें.

162
00:09:32,820 --> 00:09:38,500
तो आप परिसर में या कहीं रहे हैं
पास, तो आप के साथ तस्वीरें ले सकता है

163
00:09:38,500 --> 00:09:42,600
स्टाफ, और है कि अनुभाग
स्टाफ के सदस्यों के साथ सबसे अधिक चित्रों

164
00:09:42,600 --> 00:09:46,940
उनकी बरामद फाइलों से होगा
एक भयानक पुरस्कार मिलेगा.

165
00:09:46,940 --> 00:09:50,650
उस के साथ, तो तुम खत्म कर दिया है
PSET ठीक हो.

166
00:09:50,650 --> 00:09:53,600
मेरा नाम Zamyla है, और इस CS50 है.

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