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

2
00:00:09,500 --> 00:00:12,350
>> ZAMYLA चान: यह मिस स्कारलेट था
मोमबत्ती के साथ.

3
00:00:12,350 --> 00:00:13,560
Whodunit?

4
00:00:13,560 --> 00:00:15,030
खैर, हम पता लगाने के लिए जा रहे हैं.

5
00:00:15,030 --> 00:00:20,870
बोर्ड खेल सुराग में, आप कर सकते हैं
एक भौतिक लाल छवि दी जानी.

6
00:00:20,870 --> 00:00:24,120
और उस छवि बहुत लाल और है
धब्बेदार, और अपने काम के लिए है

7
00:00:24,120 --> 00:00:25,490
छिपा संदेश प्रकट करते हैं.

8
00:00:25,490 --> 00:00:29,740
और आम तौर पर आप एक लाल के साथ प्रदान कर रहे हैं
आवर्धक कांच, या करने के लिए एक लाल स्क्रीन

9
00:00:29,740 --> 00:00:31,410
उस छिपा संदेश प्रकट करते हैं.

10
00:00:31,410 --> 00:00:33,340
ठीक है, हम है कि नकल करने के लिए जा रहे हैं.

11
00:00:33,340 --> 00:00:37,960
>> Whodunit में, आप एक बिटमैप छवि दी रहे हैं
कि, बहुत धब्बेदार और लाल दिखता है

12
00:00:37,960 --> 00:00:43,430
और फिर whodunit कार्यक्रम चलाने
एक छिपा संदेश प्रकट करने के लिए.

13
00:00:43,430 --> 00:00:45,650
>> तो चलो चरणों में यह टूट जाने.

14
00:00:45,650 --> 00:00:50,390
सबसे पहले, आप फ़ाइल को खोलने के लिए चाहते हैं -
तुम्हें दे दिया गया है कि सुराग.

15
00:00:50,390 --> 00:00:53,880
और फिर भी एक बना
फैसले बिटमैप फ़ाइल.

16
00:00:53,880 --> 00:00:58,240
तो फिर तुम बिटमैप अद्यतन करना चाहते हैं
फैसले outfile के लिए जानकारी हैडर.

17
00:00:58,240 --> 00:00:59,920
बाद में उस पर और अधिक.

18
00:00:59,920 --> 00:01:04,319
और उसके बाद में पढ़ने के लिए जा रहे हैं
सुराग, scanline, पिक्सेल द्वारा पिक्सेल,

19
00:01:04,319 --> 00:01:07,320
के रूप में पिक्सेल रंग बदल रहा है
आवश्यक है, और लेखन

20
00:01:07,320 --> 00:01:08,960
फैसले में उन -

21
00:01:08,960 --> 00:01:12,000
में पिक्सेल द्वारा पिक्सेल
फैसले scanline.

22
00:01:12,000 --> 00:01:13,780
>> हम कैसे इस बारे में जाने शुरू कर दिया?

23
00:01:13,780 --> 00:01:16,940
खैर, सौभाग्य से, हम copy.c है
वितरण कोड में.

24
00:01:16,940 --> 00:01:21,240
और यह साबित करने के लिए जा रहा है
हमारे लिए काफी उपयोगी है.

25
00:01:21,240 --> 00:01:29,700
Copy.c, एक फ़ाइल को खोलता है कि में पढ़ता
फिर infile का शीर्षक है, और अपडेट

26
00:01:29,700 --> 00:01:31,070
outfile के हैडर.

27
00:01:31,070 --> 00:01:37,010
और फिर इसमें प्रत्येक पिक्सेल पढ़ता
फिर scanline, पिक्सेल द्वारा पिक्सेल, और

28
00:01:37,010 --> 00:01:42,390
outfile में है कि पिक्सेल लिखते हैं.

29
00:01:42,390 --> 00:01:45,020
>> तो, अपना पहला कदम हो सकता है
निम्नलिखित चलाने के लिए हो

30
00:01:45,020 --> 00:01:46,420
टर्मिनल में कमांड -

31
00:01:46,420 --> 00:01:50,270
सी.पी. copy.c whodunit.c.

32
00:01:50,270 --> 00:01:55,320
इस की एक प्रतिलिपि बनाएगा
copy.c whodunit.c नाम दिया है.

33
00:01:55,320 --> 00:01:58,320
तो खोलने के लिए हमारा पहला कदम
फ़ाइल, ठीक है, एक सटीक नहीं है

34
00:01:58,320 --> 00:02:00,070
copy.c. में उस की प्रतिकृति

35
00:02:00,070 --> 00:02:03,360
तो मैं उस पर विचार करने के लिए छोड़ देंगे.

36
00:02:03,360 --> 00:02:07,860
>> हम इस PSET में साथ है क्या कर रहे हैं
फाइल मैं / हे, मूल रूप से फाइलें ले रही है,

37
00:02:07,860 --> 00:02:10,229
पढ़ना, लेखन, संपादन उन्हें.

38
00:02:10,229 --> 00:02:12,650
कैसे आप पहली बार एक फ़ाइल खुला है?

39
00:02:12,650 --> 00:02:16,800
ठीक है, तुम एक फ़ाइल की घोषणा करने जा रहे हैं
सूचक, और उसके बाद आप कॉल

40
00:02:16,800 --> 00:02:18,670
समारोह fopen.

41
00:02:18,670 --> 00:02:23,150
पथ, या उस के नाम में पारित
फ़ाइल, और तब इच्छित मोड

42
00:02:23,150 --> 00:02:24,700
अंदर उस फ़ाइल को खोलने के लिए

43
00:02:24,700 --> 00:02:28,620
एक अनुसंधान में पासिंग खुलेगा
पढ़ने के लिए foo.bmp.

44
00:02:28,620 --> 00:02:35,670
जबकि एक w में गुजरने के साथ fopen होगा
खुले bar.bmp, फाइल लिखने के लिए और

45
00:02:35,670 --> 00:02:37,020
वास्तव में यह संपादन.

46
00:02:37,020 --> 00:02:41,970
>> तो अब हम फ़ाइल खोल दिया है कि, हमारे
अगले कदम के हैडर जानकारी अद्यतन करने के लिए है

47
00:02:41,970 --> 00:02:43,230
outfile के लिए.

48
00:02:43,230 --> 00:02:44,610
एक हैडर जानकारी क्या है?

49
00:02:44,610 --> 00:02:48,160
खैर, सबसे पहले हम पता करने की जरूरत
क्या एक बिटमैप है.

50
00:02:48,160 --> 00:02:51,000
एक बिटमैप सिर्फ एक सरल है
बाइट्स की व्यवस्था.

51
00:02:51,000 --> 00:02:55,480
और वे इस फाइल में घोषित कर रहे हैं
के एक समूह के साथ यहां, bmp.h,

52
00:02:55,480 --> 00:02:58,610
क्या एक बिटमैप की जानकारी
वास्तव में से बाहर कर दिया है.

53
00:02:58,610 --> 00:03:05,730
लेकिन क्या हम वास्तव में के बारे में परवाह है
बिटमैप फ़ाइल शीर्षक, यहीं है, और

54
00:03:05,730 --> 00:03:08,460
यहाँ पर बिटमैप जानकारी हेडर,.

55
00:03:08,460 --> 00:03:13,170
हैडर एक जोड़ी के से बना है
बहुत उपयोगी साबित होगा कि चर.

56
00:03:13,170 --> 00:03:18,400
जो biSizeImage, वहाँ है
बाइट्स में छवि का कुल आकार.

57
00:03:18,400 --> 00:03:20,890
और इस पिक्सल और पैडिंग भी शामिल है.

58
00:03:20,890 --> 00:03:24,210
गद्दी बहुत महत्वपूर्ण है, लेकिन
हम है कि बाद में मिल जाएगा.

59
00:03:24,210 --> 00:03:30,000
>> BiWidth की चौड़ाई का प्रतिनिधित्व करता है
पिक्सल शून्य से गद्दी में छवि.

60
00:03:30,000 --> 00:03:34,220
BiHeight भी तो ऊंचाई है
पिक्सल में छवि की.

61
00:03:34,220 --> 00:03:38,240
और फिर BITMAPFILEHEADER और
जैसा कि मैंने उल्लेख BITMAPINFOHEADER,

62
00:03:38,240 --> 00:03:40,900
इससे पहले, उन प्रतिनिधित्व कर रहे हैं
structs के रूप में.

63
00:03:40,900 --> 00:03:45,410
तो, आप फ़ाइल शीर्षक का उपयोग नहीं कर सकते
ही है, लेकिन आप को प्राप्त करना चाहते हूँ

64
00:03:45,410 --> 00:03:47,370
अंदर उन चर.

65
00:03:47,370 --> 00:03:48,170
>> ठीक है.

66
00:03:48,170 --> 00:03:50,600
तो हम कैसे हैडर जानकारी अद्यतन करते हैं?

67
00:03:50,600 --> 00:03:54,020
खैर, सबसे पहले हमें देखना है कि हम चाहे
किसी भी जानकारी से बदलने की जरूरत

68
00:03:54,020 --> 00:03:58,480
को infile, सुराग,
outfile, फैसले.

69
00:03:58,480 --> 00:04:00,250
कुछ भी इस मामले में बदल रहा है?

70
00:04:00,250 --> 00:04:04,320
खैर, असल में, हम जा रहे हैं नहीं, क्योंकि
बस रंग बदल रही हो.

71
00:04:04,320 --> 00:04:07,550
हम फ़ाइल को बदलने नहीं जा रहे हैं
आकार, छवि आकार, चौड़ाई,

72
00:04:07,550 --> 00:04:08,310
या ऊंचाई.

73
00:04:08,310 --> 00:04:14,010
तो आप ने अब सभी के लिए सही हो
बस प्रत्येक पिक्सेल नकल.

74
00:04:14,010 --> 00:04:14,840
>> ठीक है.

75
00:04:14,840 --> 00:04:20,720
तो अब यह कैसे हम वास्तव में हम देखते हैं
फ़ाइल से हर पिक्सेल पढ़ सकते हैं.

76
00:04:20,720 --> 00:04:23,640
एक और फाइल मैं / ओ समारोह
खेलने में आ जाएगा -

77
00:04:23,640 --> 00:04:24,700
fread.

78
00:04:24,700 --> 00:04:28,440
यह संरचना के लिए एक संकेत में लेता है
जो बाइट्स में शामिल होंगे

79
00:04:28,440 --> 00:04:30,110
आप पढ़ रहे हैं.

80
00:04:30,110 --> 00:04:31,890
तो तुम उस में पढ़ रहे हैं.

81
00:04:31,890 --> 00:04:36,090
और फिर आप जो, एक आकार में पारित
हर तत्व का आकार है कि आप

82
00:04:36,090 --> 00:04:37,360
पढ़ने के लिए चाहते हैं.

83
00:04:37,360 --> 00:04:40,640
इधर, समारोह sizeof
काम में आ जाएगा.

84
00:04:40,640 --> 00:04:45,570
तो फिर तुम संख्या में पारित जो
के तत्वों की संख्या का प्रतिनिधित्व करता है

85
00:04:45,570 --> 00:04:47,480
पढ़ने के लिए आकार.

86
00:04:47,480 --> 00:04:51,180
और फिर अंत में, inptr, जो है
आप कर रहे हैं कि फाइल सूचक

87
00:04:51,180 --> 00:04:52,530
से पढ़ने के लिए जा रहा है.

88
00:04:52,530 --> 00:04:58,650
तो उन तत्वों के सभी के अंदर कर रहे हैं
inptr और वे डेटा के लिए जा रहे हैं.

89
00:04:58,650 --> 00:05:01,660
>> के एक छोटे से उदाहरण देखते हैं.

90
00:05:01,660 --> 00:05:07,590
मैं डेटा दो कुत्तों में पढ़ना चाहते हैं,
ठीक है, मैं इसे दो तरीके से कर सकते हैं.

91
00:05:07,590 --> 00:05:15,250
मैं या तो आकार के दो वस्तुओं में पढ़ सकते हैं
मेरे inptr से कुत्ता, या मैं पढ़ सकते हैं

92
00:05:15,250 --> 00:05:19,280
एक में दो कुत्तों के आकार पर आपत्ति.

93
00:05:19,280 --> 00:05:23,580
तो आप देखते हैं कि रास्ते पर निर्भर करता है
आप, आप आकार और संख्या की व्यवस्था है कि

94
00:05:23,580 --> 00:05:25,840
बैट का यही संख्या में पढ़ सकते हैं.

95
00:05:25,840 --> 00:05:28,720

96
00:05:28,720 --> 00:05:33,020
>> तो अब, चलो बदल सकते हैं
हम जरूरत के रूप में पिक्सेल रंग.

97
00:05:33,020 --> 00:05:37,320
आप फिर से bmp.h को देखो, तो
आप नीचे देखेंगे कि

98
00:05:37,320 --> 00:05:42,920
RGBTRIPLEs, एक और संरचना हैं, जहां
वे तीन बाइट्स के शामिल हैं.

99
00:05:42,920 --> 00:05:49,220
एक, rgbtBlue, rgbtGreen, और rgbtRed.

100
00:05:49,220 --> 00:05:52,480
इसलिए इनमें से प्रत्येक राशि का प्रतिनिधित्व करता है
नीले रंग की, हरे रंग की राशि, और

101
00:05:52,480 --> 00:05:57,250
इस पिक्सेल के अंदर लाल की राशि, जहां
प्रत्येक राशि एक द्वारा प्रतिनिधित्व किया है

102
00:05:57,250 --> 00:05:58,670
हेक्साडेसिमल संख्या.

103
00:05:58,670 --> 00:06:04,370
>> तो FF0000 एक नीले रंग का हो जाएगा,
यह नीले रंग से चला जाता है, क्योंकि

104
00:06:04,370 --> 00:06:05,850
लाल करने के लिए, हरे रंग के लिए.

105
00:06:05,850 --> 00:06:09,300
और फिर सब च के सफेद हो जाएगा.

106
00:06:09,300 --> 00:06:13,440
के smiley.bmp पर एक नज़र, लेते हैं जो
आप अपने वितरण कोड में है.

107
00:06:13,440 --> 00:06:15,690
आप सिर्फ एक छवि में यह खुला
दर्शक, तो आप हूँ

108
00:06:15,690 --> 00:06:17,080
सिर्फ एक लाल स्माइली देखें.

109
00:06:17,080 --> 00:06:20,380
लेकिन हम करेंगे, में एक गहरी डुबकी ले जा
देखना है कि संरचना

110
00:06:20,380 --> 00:06:22,340
यह सिर्फ पिक्सल है.

111
00:06:22,340 --> 00:06:25,880
हम सफेद पिक्सल है,
और फिर लाल पिक्सल.

112
00:06:25,880 --> 00:06:31,000
के सभी तो, सफेद FFFFFF, और
मैं तुम्हारे लिए रंग में रंग दिया है लाल पिक्सल

113
00:06:31,000 --> 00:06:35,440
यहां, और आप वे 0000FF रहे हैं देखते हैं.

114
00:06:35,440 --> 00:06:39,760
शून्य नीले, शून्य, हरे और पूर्ण लाल.

115
00:06:39,760 --> 00:06:45,350
और स्माइली आठ पिक्सल चौड़ा है के बाद से,
हम किसी भी गद्दी नहीं है.

116
00:06:45,350 --> 00:06:47,360
ठीक है.

117
00:06:47,360 --> 00:06:53,310
>> मैं विभिन्न मूल्यों आवंटित करने थे तो अगर
एक RGBTRIPLE के लिए और मैं चाहता था

118
00:06:53,310 --> 00:06:58,350
यह हरे रंग बनाने के लिए, तो मुझे क्या करना होगा है
मैं नामित एक RGBTRIPLE, घोषित होगा

119
00:06:58,350 --> 00:07:02,660
ट्रिपल, और फिर हर पहुँचने के लिए
उस संरचना मैं भीतर बाइट

120
00:07:02,660 --> 00:07:04,030
डॉट ऑपरेटर का प्रयोग करेंगे.

121
00:07:04,030 --> 00:07:08,430
तो triple.rgbtBlue, मैं कर सकता हूँ
0 तक कि आवंटित.

122
00:07:08,430 --> 00:07:13,460
ग्रीन मुझे पूरा करने के लिए आवंटित कर सकते हैं - किसी भी
संख्या, वास्तव में, 0 और एफएफ के बीच.

123
00:07:13,460 --> 00:07:15,470
और फिर लाल, मैं भी 0 कहने जा रहा हूँ.

124
00:07:15,470 --> 00:07:19,160
तो फिर उस ने मुझे एक हरे पिक्सेल देता है.

125
00:07:19,160 --> 00:07:23,030
>> अगला, मैं जाँच करने के लिए क्या चाहते हैं
कुछ का मूल्य?

126
00:07:23,030 --> 00:07:27,250
मैं जाँच करता है कि कुछ हो सकता है
ट्रिपल के rgbtBlue मूल्य है कि क्या

127
00:07:27,250 --> 00:07:31,080
एफएफ और फिर प्रिंट, "मैं महसूस कर रहा हूँ
नीले! ", एक परिणाम के रूप में.

128
00:07:31,080 --> 00:07:35,640
अब, यह जरूरी है कि इसका मतलब यह नहीं
पिक्सेल सही, नीला है कि?

129
00:07:35,640 --> 00:07:40,060
पिक्सेल की हरी और लाल मूल्यों क्योंकि
यह भी गैर 0 मान हो सकता है.

130
00:07:40,060 --> 00:07:43,470
इसका मतलब यह है कि सभी, और कहा कि सभी
यह है के लिए जाँच कर रहा है

131
00:07:43,470 --> 00:07:45,610
एक पूर्ण नीले रंग के लिए.

132
00:07:45,610 --> 00:07:50,050
लेकिन सभी पिक्सल भी आंशिक हो सकता था
इस तरह रंग मूल्यों,

133
00:07:50,050 --> 00:07:52,180
यहां अगले उदाहरण.

134
00:07:52,180 --> 00:07:55,400
>> यह थोड़ा कठिन देखने के लिए है
इस छवि अब क्या है.

135
00:07:55,400 --> 00:08:00,320
यह थोड़ा और अधिक की तरह दिखता है
आप भी दिया जाएगा कि clue.bmp.

136
00:08:00,320 --> 00:08:03,600
अब, शारीरिक रूप से, आप इस का समाधान हो सकता है,
द्वारा लाल रंग का एक बहुत कुछ है क्योंकि

137
00:08:03,600 --> 00:08:07,040
छवि के लिए एक लाल स्क्रीन को पकड़े तो
अन्य रंग प्रदर्शित कर सकते हैं.

138
00:08:07,040 --> 00:08:10,968
तो हम कैसे ग के साथ इस की नकल करते हैं?

139
00:08:10,968 --> 00:08:15,640
खैर, हम सब लाल हटाई जा सकती है
छवि से पूरी तरह से.

140
00:08:15,640 --> 00:08:21,870
और इसलिए हम हर सेट चाहते हैं कि ऐसा करने के लिए
0 करने के लिए पिक्सेल के लाल मूल्य.

141
00:08:21,870 --> 00:08:25,020
और तो छवि एक छोटी सी लग रही होगी
हम कोई लाल है, जहां इस तरह, बिट

142
00:08:25,020 --> 00:08:26,300
जो भी.

143
00:08:26,300 --> 00:08:29,390
>> हम छिपा संदेश एक देख सकते हैं
थोड़ा और अधिक स्पष्ट रूप से अब.

144
00:08:29,390 --> 00:08:31,730
यह एक और स्माइली चेहरा है.

145
00:08:31,730 --> 00:08:33,870
या हो सकता है कि हम एक और तरीका इस्तेमाल कर सकते हैं.

146
00:08:33,870 --> 00:08:36,480
हो सकता है, हम पहचान सकता है
लाल पिक्सल के सब -

147
00:08:36,480 --> 00:08:41,100
कि, पिक्सल के सभी के साथ है
0 नीला, 0, हरे और 0 लाल -

148
00:08:41,100 --> 00:08:43,169
और सफेद करने के लिए उन बदल जाते हैं.

149
00:08:43,169 --> 00:08:45,470
और हमारी छवि लग सकता है
कुछ इस तरह.

150
00:08:45,470 --> 00:08:48,250
देखने के लिए थोड़ा आसान.

151
00:08:48,250 --> 00:08:51,170
>> उजागर करने के लिए अन्य तरीकों के बहुत सारे हैं
गुप्त संदेश के रूप में अच्छी तरह से,

152
00:08:51,170 --> 00:08:53,730
रंग में गड़बड़ी से निपटने.

153
00:08:53,730 --> 00:08:57,050
हो सकता है कि आप एक विधि का उपयोग कर सकते हैं
मैंने ऊपर कहा गया है कि.

154
00:08:57,050 --> 00:08:59,600
और इसके अलावा, आप चाहते हो सकता है
कुछ रंगों को बढ़ाने के लिए

155
00:08:59,600 --> 00:09:02,620
और उन बाहर लाने के लिए.

156
00:09:02,620 --> 00:09:06,190
>> तो अब हम पिक्सेल बदल दिया है कि
रंग, अगले हम सिर्फ उन्हें लिखने की जरूरत

157
00:09:06,190 --> 00:09:08,500
पिक्सेल द्वारा scanline करने में, पिक्सेल.

158
00:09:08,500 --> 00:09:11,860
और एक बार फिर, तुम वापस देखना चाहता हूँ
आप की नकल नहीं की है, तो copy.c को

159
00:09:11,860 --> 00:09:18,170
यह पहले से ही है, और fwrite पर देखने के लिए
डेटा लेता समारोह है, जो एक सूचक

160
00:09:18,170 --> 00:09:23,230
बाइट्स होता है कि संरचना के लिए
आप के आकार से पढ़ रहे हैं कि

161
00:09:23,230 --> 00:09:26,610
आइटम, आइटम की संख्या,
और फिर outptr -

162
00:09:26,610 --> 00:09:29,450
उन फ़ाइलों के गंतव्य.

163
00:09:29,450 --> 00:09:34,010
>> आप पिक्सल में लिखने के बाद, आप हूँ
भी गद्दी में लिखने के लिए है.

164
00:09:34,010 --> 00:09:34,970
गद्दी क्या है?

165
00:09:34,970 --> 00:09:38,670
खैर, हर rgbt पिक्सेल
तीन बाइट्स लंबा है.

166
00:09:38,670 --> 00:09:43,670
लेकिन, एक बिटमैप छवि के लिए scanline
चार बाइट का गुणक हो गया है.

167
00:09:43,670 --> 00:09:47,650
और पिक्सेल की संख्या नहीं है अगर एक
चार में से कई, तो हम जोड़ने की जरूरत

168
00:09:47,650 --> 00:09:48,880
इस गद्दी.

169
00:09:48,880 --> 00:09:51,420
गद्दी सिर्फ 0s का प्रतिनिधित्व करती है.

170
00:09:51,420 --> 00:09:54,380
तो, हम कैसे लिख सकते हैं, या इस पढ़ा है?

171
00:09:54,380 --> 00:09:59,280
खैर, यह पता चला है कि आप नहीं कर सकते हैं कि
वास्तव में fread गद्दी, लेकिन आप कर सकते हैं

172
00:09:59,280 --> 00:10:00,970
यह गणना.

173
00:10:00,970 --> 00:10:04,400
>> इस मामले में, सुराग और फैसले
एक ही चौड़ाई है, तो

174
00:10:04,400 --> 00:10:05,910
गद्दी ही है.

175
00:10:05,910 --> 00:10:09,370
और padding, जैसा कि आप देखेंगे
copy.c में, गणना की है

176
00:10:09,370 --> 00:10:11,790
नीचे दिए गए फार्मूले के साथ -

177
00:10:11,790 --> 00:10:16,690
bi.biWidth बार sizeof (RGBTRIPLE) होगा
कितने बाइट्स बीएमपी हमें दे

178
00:10:16,690 --> 00:10:18,280
हर पंक्ति में है.

179
00:10:18,280 --> 00:10:21,890
वहाँ से, modulos और subtractions
4 गणना कर सकते हैं साथ कैसे

180
00:10:21,890 --> 00:10:25,610
कई बाइट्स जोड़ा जाना है, तो
पर बाइट के गुणांकों

181
00:10:25,610 --> 00:10:27,250
हर पंक्ति चार है.

182
00:10:27,250 --> 00:10:30,490
>> अब हम के लिए फार्मूला है कि
जरूरत है कि हम कितना गद्दी, अब

183
00:10:30,490 --> 00:10:31,610
हम यह लिख सकते हैं.

184
00:10:31,610 --> 00:10:34,080
अब, मैं पहले उल्लेख किया है,
गद्दी सिर्फ 0s है.

185
00:10:34,080 --> 00:10:39,730
तो उस मामले में, हम सिर्फ डाल रहे हैं
में इस मामले में एक 0 एक चार, हमारे

186
00:10:39,730 --> 00:10:41,710
outptr - हमारे outfile.

187
00:10:41,710 --> 00:10:47,530
ताकि बस fputc हो सकता है
0, अल्पविराम outptr.

188
00:10:47,530 --> 00:10:52,400
>> तो, हम में पढ़ रहा था, जबकि हमारे
फ़ाइल, फ़ाइल i / O का ट्रैक रखा है हमारी

189
00:10:52,400 --> 00:10:57,440
कुछ के साथ उन फ़ाइलों में स्थिति
फ़ाइल स्थिति सूचक कहा जाता है.

190
00:10:57,440 --> 00:10:59,350
एक कर्सर के रूप में सोचो.

191
00:10:59,350 --> 00:11:03,550
असल में, यह हर समय अग्रिम
हम fread, लेकिन हम है कि

192
00:11:03,550 --> 00:11:05,671
भी, इस पर नियंत्रण.

193
00:11:05,671 --> 00:11:11,030
>> फ़ाइल स्थिति सूचक को स्थानांतरित करने के लिए,
आप समारोह fseek का उपयोग कर सकते हैं.

194
00:11:11,030 --> 00:11:15,600
Inptr फ़ाइल का प्रतिनिधित्व करता है
आप में मांग कर रहे हैं कि सूचक,

195
00:11:15,600 --> 00:11:20,370
राशि बाइट्स की संख्या है कि आप
से तो कर्सर ले जाएँ, और करना चाहते हैं

196
00:11:20,370 --> 00:11:23,470
संदर्भ बिंदु से संबंधित है
अपने कर्सर है जहां से.

197
00:11:23,470 --> 00:11:26,770
आप SEEK_CUR में पारित हो, तो उस
वर्तमान का प्रतिनिधित्व करता है

198
00:11:26,770 --> 00:11:28,100
फ़ाइल में स्थिति.

199
00:11:28,100 --> 00:11:31,020
या फिर आप कुछ अन्य मापदंडों का उपयोग कर सकते हैं.

200
00:11:31,020 --> 00:11:35,400
तो, हम छोड़ करने के लिए fseek उपयोग करने के लिए चाहते हो सकता है
में फ़ाइल की गद्दी पर.

201
00:11:35,400 --> 00:11:39,410
आप फँस रहे हैं और फिर से, वहाँ
copy.c. में इस बात का एक उदाहरण

202
00:11:39,410 --> 00:11:43,260
>> तो अब हम फ़ाइल खोल दिया है,
सुराग और फैसले.

203
00:11:43,260 --> 00:11:46,450
हम करने के लिए हैडर जानकारी अपडेट कर दिया है
हमारे फैसले, क्योंकि हर

204
00:11:46,450 --> 00:11:48,730
बिटमैप एक शीर्ष लेख की जरूरत है.

205
00:11:48,730 --> 00:11:52,280
हम तो सुराग के रूप में पढ़ा है
scanline, पिक्सेल द्वारा पिक्सेल, बदलते

206
00:11:52,280 --> 00:11:55,210
हर रंग के रूप में आवश्यक है, और
में उन लेखन

207
00:11:55,210 --> 00:11:57,340
फैसले, पिक्सेल द्वारा पिक्सेल.

208
00:11:57,340 --> 00:12:01,550
आप फैसले खोल लेते हैं, जैसा कि आप देख सकते हैं जो
अपराधी, या क्या रहस्य

209
00:12:01,550 --> 00:12:02,850
संदेश है.

210
00:12:02,850 --> 00:12:05,550
मेरा नाम Zamyla है, और
इस whodunit था.

211
00:12:05,550 --> 00:12:12,864