1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [फ़ाइल मैं / हे]

2
00:00:02,000 --> 00:00:04,000
[जेसन Hirschhorn, हार्वर्ड विश्वविद्यालय]

3
00:00:04,000 --> 00:00:07,000
[यह CS50 है, CS50.TV]

4
00:00:07,000 --> 00:00:11,000
जब हम एक फ़ाइल के बारे में सोचना, जो मन में आता है, एक माइक्रोसॉफ्ट वर्ड दस्तावेज है,

5
00:00:11,000 --> 00:00:14,000
एक JPEG छवि, या एक एमपी 3 गीत,

6
00:00:14,000 --> 00:00:17,000
और हम अलग अलग तरीकों में फ़ाइलों के इन प्रकार के प्रत्येक के साथ बातचीत.

7
00:00:17,000 --> 00:00:20,000
उदाहरण के लिए, हम एक Word दस्तावेज़ में पाठ जोड़ने के लिए

8
00:00:20,000 --> 00:00:24,000
जबकि एक JPEG छवि के साथ हम बाहर किनारों फसल सकता है या रंग सुधारना.

9
00:00:24,000 --> 00:00:28,000
हुड के तहत हमारे कंप्यूटर में फाइल के सभी अधिक कुछ नहीं कर रहे हैं

10
00:00:28,000 --> 00:00:31,000
शून्य और लोगों की एक लंबी अनुक्रम से.

11
00:00:31,000 --> 00:00:33,000
यह विशिष्ट अनुप्रयोग है कि फाइल के साथ सूचना का आदान प्रदान करने के लिए है

12
00:00:33,000 --> 00:00:38,000
फैसला कैसे इस लंबी अनुक्रम पर कार्रवाई करने के लिए है और यह उपयोगकर्ता के लिए प्रस्तुत है.

13
00:00:38,000 --> 00:00:41,000
एक तरफ, एक दस्तावेज़ सिर्फ एक बाइट में लग सकता है,

14
00:00:41,000 --> 00:00:45,000
या 8 शून्य और लोगों, और स्क्रीन पर एक ASCII वर्ण प्रदर्शित करते हैं.

15
00:00:45,000 --> 00:00:48,000
दूसरी ओर, एक बिटमैप छवि 3 बाइट्स पर लग सकता है,

16
00:00:48,000 --> 00:00:50,000
या 24 शून्य और लोगों,

17
00:00:50,000 --> 00:00:53,000
और उन्हें 3 षोडश संख्या के रूप में व्याख्या

18
00:00:53,000 --> 00:00:56,000
लाल, हरे और नीले रंग के लिए मूल्यों का प्रतिनिधित्व

19
00:00:56,000 --> 00:00:58,000
एक छवि के एक पिक्सेल में.

20
00:00:58,000 --> 00:01:01,000
वे जो कुछ भी तरह अपनी स्क्रीन पर उनके मूल में, लग सकता है,

21
00:01:01,000 --> 00:01:05,000
फ़ाइलों का कुछ भी नहीं कर रहे हैं शून्य और लोगों के एक दृश्य की तुलना में अधिक है.

22
00:01:05,000 --> 00:01:08,000
तो चलो में गोता करने के लिए और कैसे हम वास्तव में इन शून्य और लोगों में हेरफेर पर देखो

23
00:01:08,000 --> 00:01:12,000
जब यह करने के लिए लिखने और एक फ़ाइल से पढ़ने के लिए आता है.

24
00:01:12,000 --> 00:01:15,000
>> मैं यह एक साधारण प्रक्रिया तीन भाग में टूट द्वारा शुरू करेंगे.

25
00:01:15,000 --> 00:01:19,000
अगले, मैं दो कोड उदाहरण है कि इन तीन भागों का प्रदर्शन में डुबकी हूँ.

26
00:01:19,000 --> 00:01:23,000
अंत में, मैं इस प्रक्रिया की समीक्षा के लिए और अपने सबसे महत्वपूर्ण विवरण के कुछ.

27
00:01:23,000 --> 00:01:25,000
किसी भी फ़ाइल है कि अपने डेस्कटॉप पर बैठता है के साथ के रूप में,

28
00:01:25,000 --> 00:01:28,000
पहली बात करने के लिए खुला है.

29
00:01:28,000 --> 00:01:31,000
सी में हम एक पूर्वनिर्धारित struct एक सूचक की घोषणा करके इस करते हैं

30
00:01:31,000 --> 00:01:33,000
कि डिस्क पर एक फ़ाइल का प्रतिनिधित्व करता है.

31
00:01:33,000 --> 00:01:38,460
इस समारोह कॉल में, हम यह भी तय करना होगा कि हम या फ़ाइल से पढ़ने लिखने के लिए करना चाहते हैं.

32
00:01:38,460 --> 00:01:41,660
अगला, हम वास्तविक पढ़ने और लिखने करते हैं.

33
00:01:41,660 --> 00:01:44,800
विशेष कार्यों के एक नंबर हम इस हिस्से में उपयोग कर सकते हैं,

34
00:01:44,800 --> 00:01:48,790
और उनमें से लगभग सभी पत्र एफ, जो फ़ाइल के लिए खड़ा के साथ शुरू करते हैं.

35
00:01:48,790 --> 00:01:53,560
अंतिम, फ़ाइलों के शीर्ष कोने में छोटे लाल एक्स के लिए जैसा आपके कंप्यूटर पर खोलते हैं,

36
00:01:53,560 --> 00:01:56,680
हम एक अंतिम समारोह कॉल के साथ फ़ाइल बंद करें.

37
00:01:56,680 --> 00:01:59,540
अब है कि हम हम क्या करने जा रहे हैं की एक सामान्य विचार है,

38
00:01:59,540 --> 00:02:02,000
कोड में डुबकी चलो.

39
00:02:02,000 --> 00:02:06,100
>> इस निर्देशिका में, हम दो सी फ़ाइलें और उनके इसी निष्पादन योग्य फ़ाइलों है.

40
00:02:06,100 --> 00:02:09,710
टाइपराइटर कार्यक्रम एक कमांड लाइन तर्क लेता है,

41
00:02:09,710 --> 00:02:12,060
दस्तावेज़ का नाम हम बनाना चाहते हैं.

42
00:02:12,060 --> 00:02:16,160
इस मामले में, हम यह doc.txt फोन करता हूँ.

43
00:02:16,160 --> 00:02:19,080
चलो कार्यक्रम चलाने के लिए और लाइनों की एक जोड़ी दर्ज करें.

44
00:02:19,080 --> 00:02:23,660
हाय. मेरा नाम जेसन है.

45
00:02:23,660 --> 00:02:26,710
अंत में, हम "टाइप कर छोड़ दिया."

46
00:02:26,710 --> 00:02:29,720
अगर हम अब इस निर्देशिका में फ़ाइलों के सभी सूची,

47
00:02:29,720 --> 00:02:33,770
हम देखते हैं कि एक नया दस्तावेज़ doc.txt बुलाया से विद्यमान है.

48
00:02:34,190 --> 00:02:36,110
उस फ़ाइल को इस कार्यक्रम अभी बनाया है.

49
00:02:36,110 --> 00:02:40,520
और जाहिर है, यह भी शून्य और लोगों की एक लंबी अनुक्रम से अधिक कुछ नहीं है.

50
00:02:41,100 --> 00:02:43,260
अगर हम इस नए फ़ाइल खोलने के लिए,

51
00:02:43,260 --> 00:02:45,870
हम कोड की 3 लाइनों हम अपने कार्यक्रम में प्रवेश किया देखते हैं -

52
00:02:46,060 --> 00:02:49,060
हाय. मई नाम जेसन है.

53
00:02:49,580 --> 00:02:52,090
लेकिन क्या वास्तव में जब typewriter.c पर चलता रहा है?

54
00:02:52,810 --> 00:02:55,520
हमारे लिए ब्याज की पहली पंक्ति 24 लाइन है.

55
00:02:55,560 --> 00:02:58,490
इस लाइन में, हम हमारे फ़ाइल सूचक की घोषणा.

56
00:02:59,080 --> 00:03:03,140
समारोह कि इस सूचक, fopen देता है, दो तर्क लेता है.

57
00:03:03,140 --> 00:03:07,440
1 फ़ाइल फ़ाइल अगर उपयुक्त विस्तार सहित नाम है.

58
00:03:07,440 --> 00:03:10,980
याद है कि एक फ़ाइल एक्सटेंशन के अपने न्यूनतम स्तर पर फाइल को प्रभावित नहीं करता है.

59
00:03:10,980 --> 00:03:14,640
हम हमेशा शून्य और लोगों की एक लंबी अनुक्रम के साथ काम कर रहे हैं.

60
00:03:14,640 --> 00:03:19,630
लेकिन यह प्रभाव करता है कैसे फ़ाइलों की व्याख्या और क्या आवेदन करने के लिए उन्हें खोलने के लिए उपयोग किया जाता है.

61
00:03:19,630 --> 00:03:22,290
fopen के लिए दूसरा तर्क एक पत्र है

62
00:03:22,290 --> 00:03:25,300
कि हम क्या करने के बाद हम फ़ाइल खोलने की योजना के लिए खड़ा है.

63
00:03:25,300 --> 00:03:30,630
इस तर्क के लिए तीन विकल्प हैं डब्ल्यू, आर, और ए -

64
00:03:30,630 --> 00:03:34,900
हम इस मामले में w चुना है क्योंकि हम फाइल करने के लिए लिखने के लिए चाहते हैं.

65
00:03:34,900 --> 00:03:38,820
आर, जैसा कि आप शायद अनुमान कर सकते हैं, फ़ाइल को पढ़ने के लिए है.

66
00:03:38,820 --> 00:03:41,760
और एक फाइल करने के लिए appending के लिए है.

67
00:03:41,760 --> 00:03:44,960
जबकि दोनों w और एक फाइल करने के लिए लिखने के लिए इस्तेमाल किया जा सकता है,

68
00:03:44,960 --> 00:03:47,460
w फ़ाइल की शुरुआत से लेखन शुरू कर देंगे

69
00:03:47,460 --> 00:03:50,810
और किसी भी संभावित डेटा है कि पहले से संग्रहीत किया गया है अधिलेखित.

70
00:03:50,810 --> 00:03:54,070
डिफ़ॉल्ट रूप से, फ़ाइल हम खोलने के लिए, अगर यह पहले से ही मौजूद नहीं है,

71
00:03:54,070 --> 00:03:57,180
हमारे वर्तमान कार्य निर्देशिका में बनाया है.

72
00:03:57,180 --> 00:04:00,540
हालांकि, अगर हम करने के लिए उपयोग करने के लिए या एक अलग स्थान में एक फ़ाइल बनाने चाहते हैं,

73
00:04:00,540 --> 00:04:02,650
fopen के पहले तर्क में,

74
00:04:02,650 --> 00:04:05,840
हम फ़ाइल नाम के अलावा कोई फ़ाइल पथ निर्दिष्ट कर सकते हैं.

75
00:04:05,840 --> 00:04:09,490
हालांकि इस प्रक्रिया के पहले भाग केवल लंबे समय से कोड की एक पंक्ति है,

76
00:04:09,490 --> 00:04:12,350
यह हमेशा अच्छा अभ्यास है लाइनों का एक और सेट शामिल

77
00:04:12,350 --> 00:04:15,930
कि जांच करने के लिए सुनिश्चित करें कि फ़ाइल सफलतापूर्वक खोला गया था या बनाया.

78
00:04:15,930 --> 00:04:20,300
यदि fopen अशक्त देता है, हम हमारे कार्यक्रम के साथ आगे बना नहीं चाहते हैं,

79
00:04:20,300 --> 00:04:23,270
और अगर इस ऑपरेटिंग सिस्टम स्मृति से बाहर हो सकता है

80
00:04:23,270 --> 00:04:27,940
या अगर हम जिसके लिए हम उचित अनुमति नहीं है था एक निर्देशिका में एक फ़ाइल खोलने की कोशिश करो.

81
00:04:27,940 --> 00:04:31,780
>> इस प्रक्रिया के भाग दो टाइपराइटर जबकि पाश में जगह लेता है.

82
00:04:31,780 --> 00:04:35,000
हम एक CS50 पुस्तकालय समारोह का उपयोग करने के लिए उपयोगकर्ता से इनपुट मिल,

83
00:04:35,000 --> 00:04:37,190
यह सोचते हैं और वे इस कार्यक्रम छोड़ने के लिए नहीं करना चाहती,

84
00:04:37,190 --> 00:04:41,940
हम समारोह fputs का उपयोग करने के लिए स्ट्रिंग ले और यह फाइल करने के लिए लिखने.

85
00:04:41,940 --> 00:04:46,700
fputs केवल कई कार्यों के एक हम फ़ाइल में लिखने के लिए इस्तेमाल कर सकते हैं.

86
00:04:46,700 --> 00:04:51,920
दूसरों fwrite, fputc, और भी fprintf शामिल हैं.

87
00:04:51,920 --> 00:04:54,840
विशेष समारोह के बावजूद हम का उपयोग कर हालांकि अंत,

88
00:04:54,840 --> 00:04:57,480
उनमें से सभी को पता है कि अपने तर्क के माध्यम से की जरूरत है,

89
00:04:57,480 --> 00:04:59,670
कम से कम दो बातें -

90
00:04:59,670 --> 00:05:03,140
क्या लिखा है और जहां यह करने के लिए लिखा जाना चाहिए की जरूरत है.

91
00:05:03,140 --> 00:05:07,240
हमारे मामले में, इनपुट स्ट्रिंग है कि लिखा जाना चाहिए

92
00:05:07,240 --> 00:05:11,290
और fp सूचक है कि हमें जहाँ हम लिख रहे हैं निर्देश है.

93
00:05:11,290 --> 00:05:15,330
इस कार्यक्रम में इस प्रक्रिया के दो भाग बल्कि सीधी है.

94
00:05:15,330 --> 00:05:17,360
हम बस उपयोगकर्ता से एक स्ट्रिंग ले रहे हैं

95
00:05:17,360 --> 00:05:22,120
और यह सीधे जोड़ने के साथ हमारे फाइल करने के लिए बहुत कम करने के लिए कोई इनपुट सत्यापन या सुरक्षा जांच.

96
00:05:22,120 --> 00:05:26,160
अक्सर बहरहाल, दो भाग अपने कोड के थोक ले जाएगा.

97
00:05:26,160 --> 00:05:30,580
अंत में, तीन भाग 58 लाइन पर है, जहां हम फ़ाइल बंद.

98
00:05:30,580 --> 00:05:34,860
यहाँ हम fclose और इसे पारित करने के लिए हमारी मूल फ़ाइल सूचक कहते हैं.

99
00:05:34,860 --> 00:05:39,500
बाद में लाइन में, हम शून्य लौटने के लिए, हमारे कार्यक्रम के अंत का संकेत है.

100
00:05:39,500 --> 00:05:42,630
और, हाँ, तीन भाग है कि जितना सरल है.

101
00:05:42,630 --> 00:05:45,260
>> फाइलों से पढ़ने के लिए आगे बढ़ना है.

102
00:05:45,260 --> 00:05:48,220
हमारी निर्देशिका में वापस हम एक printer.c नामक एक फाइल है.

103
00:05:48,220 --> 00:05:50,910
चलो यह हम अभी बनाया फ़ाइल के साथ चलाने के -

104
00:05:50,910 --> 00:05:53,350
doc.txt.

105
00:05:53,350 --> 00:05:58,150
इस कार्यक्रम, जैसा कि नाम से पता चलता है, बस से बाहर फ़ाइल की सामग्री मुद्रित करने के लिए यह करने के लिए पारित कर दिया जाएगा.

106
00:05:58,150 --> 00:06:00,230
और वहाँ हम यह है.

107
00:06:00,230 --> 00:06:03,780
कोड की लाइनों हम पहले टाइप था और doc.txt में बचाया.

108
00:06:03,780 --> 00:06:06,980
हाय. मेरा नाम जेसन है.

109
00:06:06,980 --> 00:06:09,120
यदि हम printer.c में गोता,

110
00:06:09,120 --> 00:06:13,570
हम देखते हैं कि कोड का एक बहुत कुछ करने के लिए इसी तरह लग रहा है क्या हम सिर्फ typewriter.c के माध्यम से चला गया.

111
00:06:13,570 --> 00:06:16,720
दरअसल 22 लाइन, जहाँ हम फ़ाइल खोला,

112
00:06:16,720 --> 00:06:19,220
और 39 लाइन, जहाँ हम फाइल बंद,

113
00:06:19,220 --> 00:06:23,890
दोनों हैं लगभग typewriter.c करने के लिए समान है, fopen दूसरा तर्क के लिए बचाने के लिए.

114
00:06:23,890 --> 00:06:26,510
इस समय हम एक फ़ाइल से पढ़ रहे हैं,

115
00:06:26,510 --> 00:06:29,040
इसलिए हम r चुना है w के बजाय.

116
00:06:29,040 --> 00:06:31,950
इस प्रकार, इस प्रक्रिया के दूसरे भाग पर ध्यान केंद्रित है.

117
00:06:31,950 --> 00:06:36,060
35 लाइन में, हमारे 4 पाश में दूसरी शर्त के रूप में,

118
00:06:36,060 --> 00:06:38,590
हम fgets के लिए एक फोन कर,

119
00:06:38,590 --> 00:06:42,190
साथी पहले से fputs समारोह.

120
00:06:42,190 --> 00:06:44,660
इस समय हम तीन तर्क है.

121
00:06:44,660 --> 00:06:48,810
पहले जहां स्ट्रिंग संग्रहीत किया जाएगा वर्णों की सरणी सूचक है.

122
00:06:48,810 --> 00:06:52,670
2 वर्णों की अधिकतम संख्या को पढ़ा जा है.

123
00:06:52,670 --> 00:06:56,010
और 3 फ़ाइल जिसके साथ हम काम कर रहे हैं सूचक है.

124
00:06:56,010 --> 00:07:00,780
आप देखेंगे कि पाश के लिए समाप्त हो जाती है जब fgets अशक्त रिटर्न.

125
00:07:00,780 --> 00:07:02,940
वहाँ दो कारण है कि यह हुआ हो सकता है.

126
00:07:02,940 --> 00:07:05,380
सबसे पहले, एक त्रुटि हुई हो सकती है.

127
00:07:05,380 --> 00:07:10,740
दूसरा, और अधिक संभावना है, फ़ाइल के अंत तक पहुँच गया था और कोई और अधिक वर्ण पढ़ रहे थे.

128
00:07:10,740 --> 00:07:14,040
मामले में आप सोच रहे हैं, दो कार्यों मौजूद नहीं है कि हमें बताने के लिए अनुमति

129
00:07:14,040 --> 00:07:17,160
कारण है जो इस विशेष रिक्त सूचक के लिए कारण है.

130
00:07:17,160 --> 00:07:21,090
और, आश्चर्य की बात नहीं है, क्योंकि वे फाइलों के साथ काम करने के साथ क्या करना है,

131
00:07:21,090 --> 00:07:26,940
दोनों ferror समारोह और पत्र च के साथ feof समारोह शुरू करते हैं.

132
00:07:26,940 --> 00:07:32,130
>> अंत में, इससे पहले कि हम निष्कर्ष है, एक फ़ाइल समारोह के अंत के बारे में जल्दी ध्यान दें,

133
00:07:32,130 --> 00:07:36,690
जो बस के रूप में उल्लेख किया है, feof के रूप में लिखा है.

134
00:07:36,690 --> 00:07:41,550
अक्सर आप अपने आप को मिल जबकि और loops के लिए उपयोग करने के लिए उत्तरोत्तर फ़ाइलों के माध्यम से अपनी तरह पढ़ा हूँ.

135
00:07:41,550 --> 00:07:45,790
इस प्रकार, आप इन loops को समाप्त करने के लिए एक तरह से करने के बाद आप इन फ़ाइलों के अंत तक पहुँच जायेंगे.

136
00:07:45,790 --> 00:07:50,510
अपनी फ़ाइल सूचक पर feof कॉलिंग और देखने के लिए अगर यह सच है की जाँच

137
00:07:50,510 --> 00:07:52,310
कि बस करना होगा.

138
00:07:52,310 --> 00:07:59,820
इस प्रकार, हालत (feof (एफ पी)) के साथ एक जबकि पाश एक पूरी तरह से उचित समाधान की तरह लग सकता है.

139
00:07:59,820 --> 00:08:03,770
हालांकि, कहते हैं, हम हमारे पाठ फ़ाइल में एक लाइन छोड़ दिया है.

140
00:08:03,770 --> 00:08:07,130
हम हमारे जबकि पाश में प्रवेश कर सकते हैं और सब कुछ बाहर काम के रूप में की योजना बनाई.

141
00:08:07,130 --> 00:08:12,750
अगले के माध्यम से दौर में, हमारे कार्यक्रम देखने के लिए अगर fp की feof सच है की जाँच करेगा,

142
00:08:12,750 --> 00:08:15,430
लेकिन और यहाँ समझने के लिए इस महत्वपूर्ण बिंदु है -

143
00:08:15,430 --> 00:08:17,770
बस अभी तक यह सच नहीं होगा.

144
00:08:17,770 --> 00:08:21,110
ऐसा इसलिए है क्योंकि उद्देश्य feof की जाँच करने के लिए नहीं है

145
00:08:21,110 --> 00:08:24,400
अगर अगले एक पढ़ा समारोह कॉल फ़ाइल के अंत मारा जाएगा,

146
00:08:24,400 --> 00:08:28,190
बल्कि जांच करने के लिए किया जाए या नहीं फ़ाइल का अंत पहले से ही पूरी हो चुकी है.

147
00:08:28,190 --> 00:08:30,140
इस उदाहरण के मामले में,

148
00:08:30,140 --> 00:08:32,780
हमारे फ़ाइल की अंतिम पंक्ति को पढ़ने के लिए पूरी तरह से सुचारू रूप से चला जाता है,

149
00:08:32,780 --> 00:08:36,210
लेकिन कार्यक्रम अभी तक कि हम हमारे फाइल के अंत मारा है पता नहीं है.

150
00:08:36,210 --> 00:08:40,549
यह नहीं है जब तक यह एक अतिरिक्त पढ़ा नहीं है कि यह फाइल के अंत काउंटर.

151
00:08:40,549 --> 00:08:43,210
इस प्रकार, एक सही हालत पालन होगा:

152
00:08:43,210 --> 00:08:49,330
fgets और अपने तीन तर्क - उत्पादन, उत्पादन के आकार, और एफपी -

153
00:08:49,330 --> 00:08:52,570
और बराबर नहीं है कि सभी को अशक्त करने के लिए.

154
00:08:52,570 --> 00:08:55,260
इस दृष्टिकोण हम printer.c में ले लिया है,

155
00:08:55,260 --> 00:08:57,890
और इस मामले में, पाश बाहर निकलता है के बाद,

156
00:08:57,890 --> 00:09:04,290
आप feof या ferror इस लूप से बाहर निकलने के लिए विशिष्ट तर्क के रूप में उपयोगकर्ता को सूचित करने के लिए कह सकते हैं.

157
00:09:04,290 --> 00:09:08,100
>> लेखन और एक फ़ाइल से पढ़ने के अपने सबसे बुनियादी है,

158
00:09:08,100 --> 00:09:10,150
एक साधारण प्रक्रिया 3-हिस्सा.

159
00:09:10,150 --> 00:09:12,530
सबसे पहले, हम फ़ाइल खोलें.

160
00:09:12,530 --> 00:09:16,740
दूसरा, हम हमारे फाइल में कुछ बातों को डाल दिया है या इसे से बाहर कुछ चीजें लेने के.

161
00:09:16,740 --> 00:09:19,200
तीसरा, हम फ़ाइल बंद करें.

162
00:09:19,200 --> 00:09:21,170
पहली और आखिरी भागों आसान कर रहे हैं.

163
00:09:21,170 --> 00:09:23,920
मध्य भाग है, जहां मुश्किल सामान है.

164
00:09:23,920 --> 00:09:27,760
और हालांकि हुड के नीचे हम हमेशा शून्य और लोगों की एक लंबी अनुक्रम के साथ काम कर रहे हैं,

165
00:09:27,760 --> 00:09:30,710
यह तब होता है जब अमूर्त की एक परत को जोड़ने के लिए कोडिंग में मदद करता है

166
00:09:30,710 --> 00:09:35,350
कि कुछ है कि और अधिक निकटता जैसा दिखता है क्या हम देखने के लिए इस्तेमाल कर रहे हैं में अनुक्रम बदल जाता है.

167
00:09:35,350 --> 00:09:39,570
उदाहरण के लिए, अगर हम एक बिटमैप 24 बिट फ़ाइल के साथ काम कर रहे हैं,

168
00:09:39,570 --> 00:09:43,290
हम संभावना या पढ़ने हो जाएगा एक समय में तीन बाइट्स लेखन.

169
00:09:43,290 --> 00:09:46,450
जो मामले में, यह समझ बनाने को परिभाषित करने और उचित नाम होगा

170
00:09:46,450 --> 00:09:48,980
एक struct कि 3 बाइट्स बड़ी है.

171
00:09:48,980 --> 00:09:51,410
>> हालांकि फाइलों के साथ काम जटिल लग सकता है,

172
00:09:51,410 --> 00:09:54,530
उन्हें उपयोग हमें वास्तव में उल्लेखनीय कुछ करने के लिए अनुमति देता है.

173
00:09:54,530 --> 00:09:58,880
हम हमारे कार्यक्रम के बाहर दुनिया की स्थिति को बदल सकते हैं,

174
00:09:58,880 --> 00:10:01,730
हम कुछ है कि हमारे कार्यक्रम के जीवन से परे रहता है बना सकते हैं,

175
00:10:01,730 --> 00:10:07,190
या हम कुछ भी बदल सकते हैं कि पहले हमारे कार्यक्रम चलाने शुरू कर दिया बनाया गया था.

176
00:10:07,190 --> 00:10:11,210
फाइलों के साथ बातचीत सी. में एक प्रोग्रामिंग के सही मायने में शक्तिशाली हिस्सा है

177
00:10:11,210 --> 00:10:15,300
और मैं देखने के लिए आप क्या करने के लिए आने के लिए कोड में इसके साथ बनाने जा रहे हैं के लिए उत्साहित हूँ.

178
00:10:15,300 --> 00:10:19,770
मेरा नाम जेसन Hirschhorn है. यह CS50 है.

179
00:10:19,770 --> 00:10:21,770
[CS50.TV]

180
00:10:21,770 --> 00:10:25,940
>> [हँसी]

181
00:10:25,940 --> 00:10:29,330
ठीक है. एक लो. यहाँ हम चले.

182
00:10:49,000 --> 00:10:52,140
जब हम एक फ़ाइल के बारे में सोच - ओह >> रुको. माफ़ कीजिए.

183
00:10:52,140 --> 00:10:56,800
[हँसी] ठीक है.

184
00:11:06,620 --> 00:11:09,970
वहाँ हे.

185
00:11:13,670 --> 00:11:16,310
जब हम एक फ़ाइल के बारे में सोच -

186
00:11:17,610 --> 00:11:20,710
जब आप एक फ़ाइल के बारे में सोच - ठीक है. मुझे बताओ कि जब आप तैयार हैं.

187
00:11:20,710 --> 00:11:22,520
ओह, बढ़िया.

188
00:11:22,520 --> 00:11:26,180
हालांकि एक teleprompter से पढ़ने लग सकता है - नहीं. मेरा बुरा.