1
00:00:00,000 --> 00:00:02,730
[Powered by Google Translate] [धारा 5: कम आरामदायक]

2
00:00:02,730 --> 00:00:05,180
[नैट Hardison, हार्वर्ड विश्वविद्यालय]

3
00:00:05,180 --> 00:00:08,260
[यह CS50 है.] [CS50.TV]

4
00:00:08,260 --> 00:00:11,690
तो वापस स्वागत करते हैं, लोग.

5
00:00:11,690 --> 00:00:16,320
धारा 5 के लिए आपका स्वागत है.

6
00:00:16,320 --> 00:00:20,220
इस बिंदु पर, प्रश्नोत्तरी 0 पूरा होने और देखा कि कैसे तुमने किया है,

7
00:00:20,220 --> 00:00:25,770
उम्मीद है कि तुम सच में अच्छा लगता है, क्योंकि मैं इस खंड में स्कोर द्वारा बहुत प्रभावित हुआ था.

8
00:00:25,770 --> 00:00:28,050
हमारे ऑनलाइन दर्शकों के लिए, हम सवालों के एक जोड़े को मिला है

9
00:00:28,050 --> 00:00:33,680
समस्या के सेट पर पिछले दो समस्याओं के बारे में या प्रश्नोत्तरी पर, बल्कि.

10
00:00:33,680 --> 00:00:39,690
तो हम वास्तव में उन पर जल्दी जाने के लिए इतना है कि हर कोई देखता है क्या हुआ जा रहे हैं

11
00:00:39,690 --> 00:00:45,060
और कैसे सिर्फ समाधान ही देखने के बजाय वास्तविक समाधान के माध्यम से जाने के लिए.

12
00:00:45,060 --> 00:00:50,330
हम समस्याओं का पिछले कुछ पर बहुत जल्दी जा रहे हैं, 32 और 33.

13
00:00:50,330 --> 00:00:53,240
बस फिर, तो ऑनलाइन दर्शकों को लगता है कि यह देख सकते हैं.

14
00:00:53,240 --> 00:00:59,080
>> यदि आप अपने 32 समस्या है, जो 13 पृष्ठ पर है बारी

15
00:00:59,080 --> 00:01:02,730
16 में से 13, 32 समस्या स्वैप सब के बारे में है.

16
00:01:02,730 --> 00:01:05,010
यह दो integers गमागमन के बारे में सब कुछ था.

17
00:01:05,010 --> 00:01:08,740
यह समस्या है कि हम व्याख्यान में कई बार के एक जोड़े पर चला गया था.

18
00:01:08,740 --> 00:01:13,590
और यहाँ में, हम आपको करने के लिए पूछ रहे थे कि क्या एक त्वरित स्मृति ट्रेस है.

19
00:01:13,590 --> 00:01:17,000
चर के मूल्यों में भरने के रूप में वे ढेर पर हैं

20
00:01:17,000 --> 00:01:20,250
कोड के रूप में इस स्वैप समारोह के माध्यम से चला जाता है.

21
00:01:20,250 --> 00:01:24,500
विशेष रूप से, हम पर क्या देख रहे हैं - कर रहा हूँ इस iPad डाल नीचे जा रहा है -

22
00:01:24,500 --> 00:01:29,650
विशेष रूप से, हम देख रहे हैं क्या है इस लाइन 6 सही यहाँ गिने.

23
00:01:29,650 --> 00:01:36,740
और यह सिर्फ पिछले एक समस्या के साथ समीपता के लिए 6 गिने है.

24
00:01:36,740 --> 00:01:41,720
हम क्या करना चाहते हैं प्रदर्शित करने के लिए या स्मृति लेबल

25
00:01:41,720 --> 00:01:46,090
के रूप में यह समय है जब हम इस लाइन संख्या 6 निष्पादित,

26
00:01:46,090 --> 00:01:52,540
जो प्रभावी रूप से हमारे स्वैप समारोह से एक सही यहाँ वापसी है.

27
00:01:52,540 --> 00:01:59,450
अगर हम यहाँ नीचे स्क्रॉल, हमने देखा है कि स्मृति में सब कुछ के पते हमारे लिए उपलब्ध कराया गया था.

28
00:01:59,450 --> 00:02:02,540
यह बहुत ही महत्वपूर्ण है, हम वापस बस एक पल में यह करने के लिए आया हूँ.

29
00:02:02,540 --> 00:02:09,240
और फिर यहाँ नीचे तल पर, हम एक छोटे स्मृति आरेख था कि हम उल्लेख करने के लिए जा रहे हैं.

30
00:02:09,240 --> 00:02:12,490
मैं वास्तव में इस किया है मेरी iPad पर बाहर.

31
00:02:12,490 --> 00:02:20,720
तो मैं और संदर्भ के लिए इस कोड iPad के बीच आगे और पीछे वैकल्पिक करने के लिए जा रहा हूँ.

32
00:02:20,720 --> 00:02:26,540
>> शुरु करते हैं. पहले, चलो यहाँ की मुख्य लाइनों की पहली जोड़ी पर सही से ध्यान केंद्रित.

33
00:02:26,540 --> 00:02:30,220
शुरू करने के लिए, हम 1 और y 2 एक्स इनिशियलाइज़ करने के लिए जा रहे हैं.

34
00:02:30,220 --> 00:02:33,040
तो हम दो पूर्णांक चर है, वे दोनों के ढेर पर रखा जा जा रहे हैं.

35
00:02:33,040 --> 00:02:36,050
हम उन्हें में 1 और 2 एक डाल करने के लिए जा रहे हैं.

36
00:02:36,050 --> 00:02:43,150
तो अगर मैं अपने iPad पर फ्लिप, उम्मीद है कि, चलो देखते हैं -

37
00:02:43,150 --> 00:02:48,660
एप्पल टीवी mirroring, और हम वहाँ जाओ. ठीक है.

38
00:02:48,660 --> 00:02:51,670
तो अगर मैं अपने iPad पर फ्लिप,

39
00:02:51,670 --> 00:02:56,220
मैं 1 और y 2 एक्स इनिशियलाइज़ चाहते हैं.

40
00:02:56,220 --> 00:03:00,580
हम जानते हैं कि एक्स के रूप में चिह्नित बॉक्स में 1 एक लेखन के द्वारा काफी बस

41
00:03:00,580 --> 00:03:07,730
और एक बॉक्स में 2 y के रूप में चिह्नित है. काफी सरल है.

42
00:03:07,730 --> 00:03:11,620
तो अब चलो लैपटॉप के लिए वापस जाने के लिए देखते हैं, आगे क्या होता है.

43
00:03:11,620 --> 00:03:15,810
तो यह अगली पंक्ति है जहाँ चीजें मुश्किल हो.

44
00:03:15,810 --> 00:03:28,110
हम पैरामीटर्स के रूप में एक्स के पते और y के पते पास एक और स्वैप समारोह के लिए बी.

45
00:03:28,110 --> 00:03:32,380
एक्स और y के पते का पता चीजें हैं जो हम गणना नहीं कर सकते हैं

46
00:03:32,380 --> 00:03:36,360
इन बुलेट के लिए बात कर के बिना सही नीचे अंक यहाँ.

47
00:03:36,360 --> 00:03:39,750
और सौभाग्य से, पहले दो गोली अंक हमें बताओ कि क्या वास्तव जवाब हैं.

48
00:03:39,750 --> 00:03:44,740
स्मृति में x का पता 10, और स्मृति में 14 y के पते है.

49
00:03:44,740 --> 00:03:51,870
तो उन मूल्यों है कि के रूप में पारित हो जाता है एक और ख हमारे स्वैप समारोह में शीर्ष.

50
00:03:51,870 --> 00:04:00,760
तो फिर, हमारे आरेख के लिए वापस स्विचन, मैं एक एक में 10 लिख सकते हैं

51
00:04:00,760 --> 00:04:07,400
और ख में 14.

52
00:04:07,400 --> 00:04:11,610
अब, इस बिंदु है जहां हम स्वैप के साथ आगे बढ़ना है.

53
00:04:11,610 --> 00:04:14,520
तो लैपटॉप के लिए फिर से वापस flipping,

54
00:04:14,520 --> 00:04:21,079
हम देखते हैं कि स्वैप काम करता है जिस तरह से मैं पहली बार एक और दुकान भिन्नता tmp में परिणाम है.

55
00:04:21,079 --> 00:04:27,650
तो भिन्नता ऑपरेटर का कहना है कि, "अरे, एक पते के रूप में चर की सामग्री समझो.

56
00:04:27,650 --> 00:04:33,830
जो भी उस पते पर संग्रहीत किया जाता है पर जाएँ, और इसे लोड. "

57
00:04:33,830 --> 00:04:41,720
क्या आप चर के बाहर लोड हमारे tmp चर में संग्रहित किया जा रहा है.

58
00:04:41,720 --> 00:04:45,150
IPad करने के लिए वापस Flipping.

59
00:04:45,150 --> 00:04:51,690
अगर हम 10 को संबोधित करने के लिए जाना है, हम जानते हैं कि 10 पता varible x

60
00:04:51,690 --> 00:04:55,480
क्योंकि हम हमारे बुलेट बिंदु है कि स्मृति में 10 x के पते के द्वारा कहा गया था.

61
00:04:55,480 --> 00:05:00,180
तो हम वहाँ जाना है, इसका मूल्य है, जो 1 प्राप्त कर सकते हैं, जैसा कि हम हमारे iPad पर देखते हैं,

62
00:05:00,180 --> 00:05:06,300
और tmp में है कि लोड.

63
00:05:06,300 --> 00:05:08,250
फिर, यह अंतिम सामग्री नहीं है.

64
00:05:08,250 --> 00:05:14,350
हम के माध्यम से चलने के लिए जा रहे हैं और हम अंत में हमारे कार्यक्रम के अंतिम राज्य के लिए मिल जाएगा.

65
00:05:14,350 --> 00:05:17,210
लेकिन अब ठीक है, हम मूल्य 1 tmp में संग्रहीत है.

66
00:05:17,210 --> 00:05:19,210
>> और यहाँ पर एक त्वरित सवाल है.

67
00:05:19,210 --> 00:05:23,980
[अलेक्जेंडर] भिन्नता ऑपरेटर है - कि अभी चर के सामने सितारा सही है?

68
00:05:23,980 --> 00:05:27,600
हाँ. >> भिन्नता ऑपरेटर तो, जैसा कि हम अपने लैपटॉप के लिए एक बार फिर से वापस फ्लिप,

69
00:05:27,600 --> 00:05:33,780
सामने सही में इस स्टार है.

70
00:05:33,780 --> 00:05:37,460
उस अर्थ में, यह है - आप यह गुणा ऑपरेटर के साथ विपरीत

71
00:05:37,460 --> 00:05:42,400
जो दो चीजों की आवश्यकता है, भिन्नता ऑपरेटर एक एकल ऑपरेटर है.

72
00:05:42,400 --> 00:05:46,130
बस एक मूल्य लागू एक द्विआधारी ऑपरेटर के रूप में करने का विरोध किया है,

73
00:05:46,130 --> 00:05:48,810
जहां आप दो विभिन्न मूल्यों के लिए लागू होते हैं.

74
00:05:48,810 --> 00:05:52,080
तो है कि इस लाइन में क्या होता है.

75
00:05:52,080 --> 00:05:58,390
हम मान 1 भरी हुई है और यह हमारे अस्थायी पूर्णांक चर में संग्रहीत.

76
00:05:58,390 --> 00:06:05,800
अगली पंक्ति, हम में ख की सामग्री की दुकान -

77
00:06:05,800 --> 00:06:12,630
या, बल्कि, हम सामग्री है कि ख के लिए जगह है जहाँ एक ओर इशारा करते है में इशारा कर रहा है की दुकान.

78
00:06:12,630 --> 00:06:17,690
अगर हम छोड़ दिया करने के लिए सही से इस का विश्लेषण, हम भिन्नता ख के लिए जा रहे हैं,

79
00:06:17,690 --> 00:06:23,580
हम 14 को संबोधित करने के लिए जा रहे हैं, हम पूर्णांक है कि वहाँ है हड़पने के लिए जा रहे हैं,

80
00:06:23,580 --> 00:06:26,900
और फिर हम 10 पते पर जाने के लिए जा रहे हैं,

81
00:06:26,900 --> 00:06:34,240
और हम ख के हमारे भिन्नता का परिणाम है कि अंतरिक्ष में फेंक करने के लिए जा रहे हैं.

82
00:06:34,240 --> 00:06:40,080
हमारे iPad, जहाँ हम इस एक छोटे से अधिक ठोस कर सकते हैं वापस Flipping,

83
00:06:40,080 --> 00:06:44,070
यह अगर मैं सभी पतों की संख्या यहाँ लिखने के लिए मदद कर सकता है.

84
00:06:44,070 --> 00:06:53,820
तो हम जानते हैं है कि y पर, हम 14 पते पर हैं, x 10 पते पर है.

85
00:06:53,820 --> 00:07:00,180
जब हम ख में शुरू, हम भिन्नता ख, हम मान 2 हड़पने के लिए जा रहे हैं.

86
00:07:00,180 --> 00:07:08,320
क्योंकि कि मूल्य है कि 14 पते पर रहता है हम इस मूल्य हड़पने के लिए जा रहे हैं.

87
00:07:08,320 --> 00:07:15,700
और हम यह चर कि 10 पते पर रहता है में डाल जा रहे हैं,

88
00:07:15,700 --> 00:07:19,160
जो अभी भी वहाँ है, हमारे चर x करने के लिए इसी.

89
00:07:19,160 --> 00:07:21,810
तो हम यहाँ overwriting का एक छोटा सा कर सकते हैं

90
00:07:21,810 --> 00:07:35,380
जहां हम 1 हमारे के छुटकारा पाने के लिए और बजाय हम एक 2 लिखने.

91
00:07:35,380 --> 00:07:39,560
तो सब ठीक है और दुनिया में अच्छा है, यहां तक ​​कि हालांकि हम अधिलेखित x अब लिया है.

92
00:07:39,560 --> 00:07:44,890
हम x हमारे tmp चर में पुराने मूल्य संग्रहीत है.

93
00:07:44,890 --> 00:07:50,210
तो हम अगली पंक्ति के साथ स्वैप को पूरा कर सकते हैं.

94
00:07:50,210 --> 00:07:53,030
हमारे लैपटॉप के लिए वापस Flipping.

95
00:07:53,030 --> 00:07:58,150
अब सब कि रहता सामग्री हमारे अस्थायी पूर्णांक चर के बाहर ले जाना है

96
00:07:58,150 --> 00:08:05,630
और उन्हें चर है कि पता है कि ख पकड़ रहा है पर रहता है में स्टोर.

97
00:08:05,630 --> 00:08:10,230
तो हम भिन्नता ख के लिए प्रभावी ढंग से चर तक पहुँच पाने के लिए जा रहे हैं

98
00:08:10,230 --> 00:08:14,340
है कि पता है कि ख में यह धारण है,

99
00:08:14,340 --> 00:08:19,190
और हम मूल्य है कि tmp इसे में पकड़े हुए है सामान के लिए जा रहे हैं.

100
00:08:19,190 --> 00:08:23,280
वापस iPad करने के लिए एक बार और अधिक Flipping.

101
00:08:23,280 --> 00:08:31,290
मैं यह मान मिटा सकते हैं, 2,

102
00:08:31,290 --> 00:08:41,010
और बदले हम इसे में 1 सही कॉपी कर देंगे.

103
00:08:41,010 --> 00:08:43,059
फिर अगले पाठ्यक्रम की है कि executes लाइन,

104
00:08:43,059 --> 00:08:47,150
अगर हम लैपटॉप वापस फ्लिप - इस बिंदु 6 है,

105
00:08:47,150 --> 00:08:52,500
जो बिंदु है जिस पर हम हमारे आरेख पूरी तरह से भरे चाहता है.

106
00:08:52,500 --> 00:08:58,940
तो iPad वापस flipping एक बार अधिक है, सिर्फ इतना आप पूरा आरेख देख सकते हैं,

107
00:08:58,940 --> 00:09:06,610
आप देख सकते हैं कि हम एक में 10, ख में एक 14, एक tmp में 1, 2 एक्स और एक y में 1 है.

108
00:09:06,610 --> 00:09:11,000
क्या इस बारे में कोई सवाल है?

109
00:09:11,000 --> 00:09:14,640
क्या यह और अधिक समझ बनाने के लिए, यह माध्यम से चला गया?

110
00:09:14,640 --> 00:09:24,850
कम समझ है? उम्मीद है कि नहीं है. ठीक है.

111
00:09:24,850 --> 00:09:28,230
>> सूचक एक बहुत मुश्किल विषय हैं.

112
00:09:28,230 --> 00:09:33,420
लोग हम साथ काम करने का एक बहुत ही आम कहावत है:

113
00:09:33,420 --> 00:09:36,590
"करने के लिए संकेत समझने के लिए, आप पहली बार संकेत समझना चाहिए."

114
00:09:36,590 --> 00:09:40,530
जो मुझे लगता है कि बहुत सही है. यह एक जबकि इसकी आदत हो ले.

115
00:09:40,530 --> 00:09:45,360
चित्रों का बहुत आकर्षित, यह एक तरह स्मृति चित्र के बहुत ड्राइंग बहुत मददगार रहे हैं,

116
00:09:45,360 --> 00:09:49,480
और उसके बाद आप उदाहरण के बाद उदाहरण के बाद उदाहरण के माध्यम से चलना,

117
00:09:49,480 --> 00:09:54,450
यह एक छोटे से अधिक भावना और एक छोटे से अधिक भावना और एक छोटे से अधिक भावना बनाना शुरू करेंगे.

118
00:09:54,450 --> 00:10:01,560
अंत में, एक दिन, तुम होगा यह सब पूरी तरह में महारत हासिल है.

119
00:10:01,560 --> 00:10:13,800
कोई सवाल इससे पहले कि हम अगले समस्या पर चाल? सही सभी.

120
00:10:13,800 --> 00:10:18,840
तो लैपटॉप वापस फ्लिप.

121
00:10:18,840 --> 00:10:23,300
अगले समस्या हम समस्या 33 संख्या फ़ाइल पर मैं / ओ

122
00:10:23,300 --> 00:10:26,350
यह एक छोटा सा पर ज़ूम.

123
00:10:26,350 --> 00:10:28,710
33 समस्या - हाँ?

124
00:10:28,710 --> 00:10:32,110
>> [डैनियल] मैं बस एक त्वरित सवाल था. इस स्टार, या तारांकन,

125
00:10:32,110 --> 00:10:35,590
यह अपसंदर्भन जब आप एक asterisk से पहले का उपयोग कहा जाता है.

126
00:10:35,590 --> 00:10:38,820
यह क्या है जब आप पहले एम्परसेंड का उपयोग कहा जाता है?

127
00:10:38,820 --> 00:10:43,140
>> एम्परसेंड ऑपरेटर के पहले पता है.

128
00:10:43,140 --> 00:10:45,880
तो चलो वापस ऊपर स्क्रॉल.

129
00:10:45,880 --> 00:10:49,310
उफ़! मैं इसलिए मैं वास्तव में नहीं स्क्रॉल कर सकते हैं ज़ूम मोड में हूँ.

130
00:10:49,310 --> 00:10:52,780
यदि हम इस कोड को सच में जल्दी देखो यहीं,

131
00:10:52,780 --> 00:10:54,980
फिर, एक ही बात हो रहा है.

132
00:10:54,980 --> 00:10:59,180
यदि हम इस कोड को सही यहाँ देखो, इस लाइन पर जहां हम कॉल स्वैप करने के लिए बना है,

133
00:10:59,180 --> 00:11:10,460
एम्परसेंड बस कह रहा है "पता जिस पर चर x जीवन मिलता है."

134
00:11:10,460 --> 00:11:14,460
जब अपने संकलक अपने कोड compiles,

135
00:11:14,460 --> 00:11:20,590
यह वास्तव में शारीरिक रूप से अपने को जीने चर के सभी के लिए स्मृति में एक जगह चिह्नित है.

136
00:11:20,590 --> 00:11:24,910
और तो संकलक क्या फिर एक बार यह सब कुछ संकलित कर सकते हैं,

137
00:11:24,910 --> 00:11:31,110
यह जानता है, "ओह, मैं एक्स 10 पते पर डाल मैं 14 पते पर y डाला."

138
00:11:31,110 --> 00:11:34,640
यह तो आप के लिए इन मूल्यों में भर सकते हैं.

139
00:11:34,640 --> 00:11:44,740
तो तुम तो कर सकते हैं यह तो कर सकते हैं और के रूप में अच्छी तरह से पास वाई में यह पारित.

140
00:11:44,740 --> 00:11:50,730
इन लोगों को पता हो, लेकिन वे भी, जब आप उन्हें स्वैप समारोह में पारित

141
00:11:50,730 --> 00:11:55,690
इस प्रकार की जानकारी प्राप्त करने के लिए, यह int यहाँ * सही, संकलक बताता है,

142
00:11:55,690 --> 00:12:01,350
"ठीक है, हम एक पूर्णांक चर के एक पते के रूप में इस पते की व्याख्या हो जा रहे हैं."

143
00:12:01,350 --> 00:12:05,900
एक int के एक पते के रूप में, जो एक चरित्र चर के पते से अलग है

144
00:12:05,900 --> 00:12:09,930
क्योंकि एक int एक 32-bit मशीन पर लेता है, अंतरिक्ष के 4 बाइट्स लेता है,

145
00:12:09,930 --> 00:12:13,310
जबकि एक चरित्र केवल अंतरिक्ष के 1 बाइट लेता है.

146
00:12:13,310 --> 00:12:17,310
तो यह भी पता है क्या है के लिए महत्वपूर्ण है - क्या रहता है, मान किस प्रकार

147
00:12:17,310 --> 00:12:20,340
पता है कि अंदर पारित कर दिया गया पर रहने वाले

148
00:12:20,340 --> 00:12:22,020
या पता है कि आप के साथ काम कर रहे हैं.

149
00:12:22,020 --> 00:12:29,020
इस तरह, आप कैसे जानकारी के कई बाइट्स वास्तव में अपने रैम के लिए बाहर लोड पता है.

150
00:12:29,020 --> 00:12:31,780
और फिर, हाँ, आप इस तरह भिन्नता ऑपरेटर, पूछ रहे थे,

151
00:12:31,780 --> 00:12:37,200
चला जाता है और एक विशेष पते पर जानकारी तक पहुंचता है.

152
00:12:37,200 --> 00:12:42,820
तो यह यह एक चर के साथ कहते हैं, यहाँ, एक पते के रूप में एक की सामग्री का इलाज,

153
00:12:42,820 --> 00:12:47,880
कि पता करने के लिए जाना है, और बाहर खींच, प्रोसेसर, एक रजिस्टर में लोड में लोड

154
00:12:47,880 --> 00:12:56,340
वास्तविक मूल्यों या सामग्री है कि उस पते पर रहते हैं.

155
00:12:56,340 --> 00:12:59,620
अधिक कोई सवाल? ये अच्छे सवाल हैं.

156
00:12:59,620 --> 00:13:01,650
यह नई शब्दावली का एक बहुत कुछ है.

157
00:13:01,650 --> 00:13:09,800
यह भी कायरता की तरह है, और विभिन्न स्थानों में और * देख.

158
00:13:09,800 --> 00:13:13,180
>> सही सभी.

159
00:13:13,180 --> 00:13:18,530
तो 33 समस्या वापस दर्ज करने के लिए, मैं / ओ

160
00:13:18,530 --> 00:13:22,540
यह उन समस्याओं में से एक है कि मुझे लगता है कि चीजों की एक जोड़ी हुआ था.

161
00:13:22,540 --> 00:13:25,400
एक, यह एक काफी नया विषय है.

162
00:13:25,400 --> 00:13:30,590
यह बहुत जल्द प्रश्नोत्तरी के समक्ष प्रस्तुत किया गया था,

163
00:13:30,590 --> 00:13:33,400
और फिर मुझे लगता है कि यह एक गणित में उन समस्याओं के शब्द की तरह की तरह था

164
00:13:33,400 --> 00:13:39,720
वे तुम्हें जहां जानकारी का एक बहुत देते हैं, लेकिन आप वास्तव में अंत नहीं है के लिए यह एक टन का उपयोग कर रही है.

165
00:13:39,720 --> 00:13:44,060
इस समस्या के पहले भाग का वर्णन है एक CSV फ़ाइल क्या है.

166
00:13:44,060 --> 00:13:50,620
अब, एक CSV फ़ाइल, वर्णन के अनुसार, एक कॉमा सेपरेटेड मान फ़ाइल है.

167
00:13:50,620 --> 00:13:55,300
कारण इन सब मजे में हैं, और कारण है कि आप कभी भी उन्हें का उपयोग करें,

168
00:13:55,300 --> 00:14:00,800
है, क्योंकि आप में से कितने कभी एक्सेल जैसे सामान का इस्तेमाल किया है?

169
00:14:00,800 --> 00:14:03,240
आप में से ज्यादातर के चित्रा, शायद है, या अपने जीवन में कुछ बिंदु पर का उपयोग करेगा.

170
00:14:03,240 --> 00:14:06,430
आप Excel की तरह कुछ का उपयोग करेंगे.

171
00:14:06,430 --> 00:14:10,940
, आदेश में डेटा प्राप्त करने के लिए एक एक्सेल स्प्रेडशीट के बाहर या इसके साथ प्रसंस्करण के किसी भी प्रकार के कर

172
00:14:10,940 --> 00:14:17,240
अगर आप एक सी प्रोग्राम या अजगर कार्यक्रम, जावा प्रोग्राम लिखना चाहता था,

173
00:14:17,240 --> 00:14:20,070
डेटा आप वहाँ में संग्रहीत है के साथ सौदा करने के लिए,

174
00:14:20,070 --> 00:14:23,170
एक सबसे आम तरीके इसे पाने के लिए बाहर की एक CSV फ़ाइल में है.

175
00:14:23,170 --> 00:14:26,850
और आप Excel खोलने के लिए और कर सकते हैं जब आप बातचीत रूप में सहेजें 'के लिए जाना है,

176
00:14:26,850 --> 00:14:32,840
तुम बाहर एक वास्तविक CSV फ़ाइल प्राप्त कर सकते हैं.

177
00:14:32,840 --> 00:14:35,890
>> जानते हैं कि कैसे इन सब बातों के साथ निपटने के लिए आसान.

178
00:14:35,890 --> 00:14:42,010
जिस तरह से यह काम करता है कि यह करने के लिए इसी तरह की है - मेरा मतलब है, यह अनिवार्य रूप से एक स्प्रेडशीट नकल उतार रहा है,

179
00:14:42,010 --> 00:14:47,590
, के रूप में हम यहाँ देख बहुत छोड़ दिया सबसे टुकड़ा में, जहां,

180
00:14:47,590 --> 00:14:49,910
हम सभी अंतिम नाम है.

181
00:14:49,910 --> 00:14:54,670
तो हम Malan, तो Hardison, और फिर Bowden, MacWilliam, और फिर चान है.

182
00:14:54,670 --> 00:14:59,470
सभी अंतिम नाम. और फिर एक अल्पविराम पहला नाम से अंतिम नामों को अलग करती है.

183
00:14:59,470 --> 00:15:02,970
डेविड, नैट, रोब, टॉमी, और Zamyla.

184
00:15:02,970 --> 00:15:06,850
मैं हमेशा रॉबी और टॉम मिश्रण.

185
00:15:06,850 --> 00:15:10,940
और फिर, अंत में, तीसरे स्तंभ ईमेल पतों है.

186
00:15:10,940 --> 00:15:18,500
एक बार जब आप समझते हैं कि, इस कार्यक्रम के बाकी को लागू करने के लिए काफी सरल है.

187
00:15:18,500 --> 00:15:23,850
क्या हम क्रम में हमारे सी कार्यक्रम में यह एक ही संरचना की नकल करने के लिए किया है

188
00:15:23,850 --> 00:15:27,510
हम एक संरचना का उपयोग किया है.

189
00:15:27,510 --> 00:15:30,520
हम इन के रूप में अच्छी तरह से एक छोटे से अधिक के साथ खेल शुरू करेंगे.

190
00:15:30,520 --> 00:15:35,790
हम उन्हें समस्या 3 सेट में, जब हम शब्दकोशों के साथ काम कर रहे थे 1 थोड़ा के लिए देखा था.

191
00:15:35,790 --> 00:15:40,290
लेकिन यह स्टाफ struct कोई अंतिम नाम, प्रथम नाम, और एक ईमेल संग्रहीत करता है.

192
00:15:40,290 --> 00:15:44,500
बस हमारे CSV फ़ाइल की तरह भंडारण किया गया था.

193
00:15:44,500 --> 00:15:47,950
तो यह सिर्फ एक प्रारूप से दूसरे में परिवर्तित होता है.

194
00:15:47,950 --> 00:15:54,630
हम इस मामले में कनवर्ट करने के लिए, एक लाइन में एक कर्मचारी struct,

195
00:15:54,630 --> 00:15:59,060
ऐसे ही एक कॉमा सेपरेटेड लाइन.

196
00:15:59,060 --> 00:16:01,500
क्या इसका यह मतलब है? तुम लोग सब प्रश्नोत्तरी ले लिया है,

197
00:16:01,500 --> 00:16:07,680
तो मैं कल्पना आप कम से कम इस बारे में सोचने के लिए कुछ समय दिया है.

198
00:16:07,680 --> 00:16:16,410
>> किराया समारोह में, हमें समस्या में लेने के लिए पूछता है - यह एक छोटा सा पर we'll ज़ूम

199
00:16:16,410 --> 00:16:22,480
नाम के साथ एक कर्मचारी संरचना, एक कर्मचारी struct में ले,

200
00:16:22,480 --> 00:16:30,900
और हमारे staff.csv फाइल करने के लिए अपनी सामग्री संलग्न.

201
00:16:30,900 --> 00:16:34,230
यह पता चला है कि यह काफी का उपयोग करने के लिए सरल है.

202
00:16:34,230 --> 00:16:37,430
हम किस तरह का ये एक छोटा सा और अधिक कार्य करता है के साथ आज के आसपास खेलेंगे.

203
00:16:37,430 --> 00:16:44,510
लेकिन इस मामले में, fprintf समारोह वास्तव में महत्वपूर्ण है.

204
00:16:44,510 --> 00:16:51,960
तो fprintf साथ, हम मुद्रित करने के लिए, बस तुम जैसे लोगों printf इस पूरे शब्द का उपयोग किया गया है.

205
00:16:51,960 --> 00:16:55,050
आप printf एक फाइल करने के लिए एक लाइन कर सकते हैं.

206
00:16:55,050 --> 00:16:59,030
तो सिर्फ सामान्य printf कॉल बनाने के बजाय जहां आप इसे प्रारूप स्ट्रिंग दे

207
00:16:59,030 --> 00:17:05,380
और फिर आप निम्न तर्क के साथ सभी चर की जगह,

208
00:17:05,380 --> 00:17:11,290
fprintf के साथ अपने पहले ही तर्क के बजाय फ़ाइल आप लिखना चाहते है.

209
00:17:11,290 --> 00:17:21,170
अगर हम इस उपकरण में लग रही है, उदाहरण के लिए थे, fprintf आदमी,

210
00:17:21,170 --> 00:17:25,980
हम printf और fprintf के बीच अंतर देख सकते हैं.

211
00:17:25,980 --> 00:17:28,960
मैं यहाँ एक छोटा सा ज़ूम करेंगे.

212
00:17:28,960 --> 00:17:33,140
तो printf के साथ, हम इसे देने के लिए एक प्रारूप स्ट्रिंग, और फिर बाद में तर्क

213
00:17:33,140 --> 00:17:37,580
या हमारे प्रारूप स्ट्रिंग में प्रतिस्थापन प्रतिस्थापन के लिए सभी चर रहे हैं.

214
00:17:37,580 --> 00:17:47,310
Fprintf साथ जबकि, पहला तर्क वास्तव में इस फाइल एक धारा * कहा जाता है.

215
00:17:47,310 --> 00:17:51,800
>> यहाँ पर हमारे विमानों को वापस चल रहा है,

216
00:17:51,800 --> 00:17:54,550
हम पहले से ही मिल गया है हमारे फ़ाइल * धारा हमारे लिए खोला गया.

217
00:17:54,550 --> 00:17:57,810
यही इस पहली पंक्ति क्या करता है, यह staff.csv फ़ाइल को खोलता है,

218
00:17:57,810 --> 00:18:01,690
यह जोड़ विधा में खुलती है, और है कि सभी के लिए हमें करने के लिए छोड़ दिया है

219
00:18:01,690 --> 00:18:08,640
कर्मचारियों को फाइल करने के लिए संरचना लिखने.

220
00:18:08,640 --> 00:18:10,870
और, चलो देखते हैं, मैं iPad का उपयोग करना चाहते हैं?

221
00:18:10,870 --> 00:18:17,900
मैं iPad इस्तेमाल करेंगे. हम शून्य है - चलो मेज पर इस डाल तो मैं थोड़ा बेहतर लिख सकते हैं -

222
00:18:17,900 --> 00:18:33,680
भाड़े के शून्य और यह एक बहस में लेता है, एक कर्मचारी संरचना बुलाया.

223
00:18:33,680 --> 00:18:44,120
हमारे ब्रेसिज़ समझे, हम हमारे फ़ाइल बुलाया * मिल गया है,

224
00:18:44,120 --> 00:18:48,380
हम हमारे fopen लाइन हमें करने के लिए दिया है,

225
00:18:48,380 --> 00:18:51,890
और मैं सिर्फ यह डॉट्स के रूप में लिखने के बाद से यह पिडिया में पहले से ही है.

226
00:18:51,890 --> 00:19:00,530
और फिर हमारी अगली पंक्ति पर, हम fprintf के लिए एक कॉल करने के लिए जा रहे हैं

227
00:19:00,530 --> 00:19:03,700
और हम फ़ाइल में पारित करने के लिए जा रहे हैं कि हम मुद्रित करने के लिए करना चाहते हैं,

228
00:19:03,700 --> 00:19:10,290
और फिर हमारे प्रारूप स्ट्रिंग, जो -

229
00:19:10,290 --> 00:19:14,300
मैं दूँगा आप लोग मुझे बता सकते हैं कि यह क्या की तरह दिखता है.

230
00:19:14,300 --> 00:19:20,500
कैसे तुम्हारे बारे में, स्टैला? क्या आप जानते हैं क्या प्रारूप स्ट्रिंग के पहले भाग की तरह लग रहा है?

231
00:19:20,500 --> 00:19:24,270
[स्टेला] मुझे यकीन नहीं कर रहा हूँ. >> जिमी पूछने के लिए स्वतंत्र महसूस.

232
00:19:24,270 --> 00:19:27,690
क्या आप जानते हैं, जिमी?

233
00:19:27,690 --> 00:19:31,000
[जिमी] यह सिर्फ पिछले होना चाहेंगे? मुझे नहीं मालूम. मैं पूरी तरह यकीन नहीं कर रहा हूँ.

234
00:19:31,000 --> 00:19:39,020
ठीक है. >> कैसे के बारे में किसी को भी परीक्षा पर यह सही है?

235
00:19:39,020 --> 00:19:41,770
सब ठीक नहीं है.

236
00:19:41,770 --> 00:19:47,920
यह पता चला है कि यहाँ हम सभी को करना है कि हम हमारे स्टाफ संरचना के प्रत्येक भाग चाहते

237
00:19:47,920 --> 00:19:53,290
हमारे फ़ाइल में एक स्ट्रिंग के रूप में मुद्रित किया जा.

238
00:19:53,290 --> 00:19:59,900
हम सिर्फ स्ट्रिंग प्रतिस्थापन चरित्र तीन अलग अलग समय का उपयोग करें, क्योंकि हम एक अंतिम नाम है

239
00:19:59,900 --> 00:20:07,160
अल्पविराम द्वारा पीछा किया, तो पहला नाम एक अल्पविराम के द्वारा पीछा किया,

240
00:20:07,160 --> 00:20:12,430
और फिर अंत में ईमेल पते जो पीछा किया जाता है - जो नहीं है

241
00:20:12,430 --> 00:20:15,140
अपनी स्क्रीन पर फिटिंग लेकिन यह एक newline चरित्र द्वारा पीछा है.

242
00:20:15,140 --> 00:20:20,060
तो मैं यह सिर्फ वहाँ नीचे लिखने के लिए जा रहा हूँ.

243
00:20:20,060 --> 00:20:23,560
और फिर हमारे प्रारूप स्ट्रिंग के बाद,

244
00:20:23,560 --> 00:20:27,880
हम सिर्फ substitutions है, जो हम डॉट संकेतन का उपयोग का उपयोग

245
00:20:27,880 --> 00:20:31,370
कि हम समस्या 3 सेट में देखा.

246
00:20:31,370 --> 00:20:48,820
हम s.last, s.first का उपयोग कर सकते हैं, और s.email

247
00:20:48,820 --> 00:20:58,990
हमारे प्रारूप स्ट्रिंग में उन तीन मूल्यों में स्थानापन्न.

248
00:20:58,990 --> 00:21:06,190
तो कैसे जाना था? मतलब होता है?

249
00:21:06,190 --> 00:21:09,700
हाँ? नहीं? संभवतः? ठीक है.

250
00:21:09,700 --> 00:21:14,180
>> अंतिम बात यह है कि हम ऐसा करने के बाद हम और मुद्रित है के बाद हम अपने फ़ाइल खोल दिया है:

251
00:21:14,180 --> 00:21:17,370
जब भी हम एक फ़ाइल खोल दिया है, हम हमेशा के लिए इसे बंद करने के लिए याद है.

252
00:21:17,370 --> 00:21:19,430
क्योंकि अन्यथा हम अंत में स्मृति लीक कर रहा हूँ,

253
00:21:19,430 --> 00:21:22,500
फ़ाइल descriptors का उपयोग.

254
00:21:22,500 --> 00:21:25,950
तो इसे बंद करने के लिए, समारोह जो हम इस्तेमाल करते हैं? डेनियल?

255
00:21:25,950 --> 00:21:30,120
[डैनियल] fclose? >> Fclose, बिल्कुल.

256
00:21:30,120 --> 00:21:37,520
तो इस समस्या के अंतिम भाग के लिए ठीक से फ़ाइल करीब था, fclose समारोह का उपयोग कर,

257
00:21:37,520 --> 00:21:40,370
जो ऐसे ही लग रहा है.

258
00:21:40,370 --> 00:21:43,880
नहीं भी पागल.

259
00:21:43,880 --> 00:21:46,990
कूल.

260
00:21:46,990 --> 00:21:49,520
तो यह है कि 33 प्रश्नोत्तरी पर समस्या है.

261
00:21:49,520 --> 00:21:52,480
हम निश्चित रूप से अधिक फ़ाइल मैं / हे आ रहा हूँ.

262
00:21:52,480 --> 00:21:55,130
हम थोड़ा अधिक आज के व्याख्यान में करते हैं, या अनुभाग में आज,

263
00:21:55,130 --> 00:22:01,710
क्योंकि है कि क्या करने के लिए इस आगामी pset के थोक रूप जा रहा है.

264
00:22:01,710 --> 00:22:05,020
चलो इस बिंदु पर प्रश्नोत्तरी से स्थानांतरित. हाँ?

265
00:22:05,020 --> 00:22:10,880
>> [Charlotte]] क्यों fclose के बजाय (फ़ाइल) fclose (staff.csv)?

266
00:22:10,880 --> 00:22:19,100
आह. >> क्योंकि यह पता चला है कि - तो सवाल है, जो एक महान एक है,

267
00:22:19,100 --> 00:22:27,800
है, जब हम fclose लिखना क्यों, हम fclose (फ़ाइल) स्टार चर लिख रहे हैं

268
00:22:27,800 --> 00:22:33,680
के रूप में फ़ाइल नाम, staff.csv विरोध? कि सही है? हाँ.

269
00:22:33,680 --> 00:22:39,570
तो चलो एक नज़र रखना. यदि मैं अपने लैपटॉप के लिए वापस स्विच,

270
00:22:39,570 --> 00:22:45,040
और fclose समारोह में देखो.

271
00:22:45,040 --> 00:22:51,460
तो fclose समारोह एक धारा को बंद कर देता है और यह सूचक में धारा है कि हम बंद करना चाहते हैं पर ले जाता है,

272
00:22:51,460 --> 00:22:57,010
के रूप में वास्तविक फ़ाइल नाम है कि हम बंद करना चाहते हैं विरोध.

273
00:22:57,010 --> 00:23:01,620
और इस वजह से पर्दे के पीछे है, जब आप fopen के लिए एक फोन कर

274
00:23:01,620 --> 00:23:12,020
जब आप एक फ़ाइल खोलने के लिए, आप वास्तव में स्मृति आवंटन कर रहे हैं फ़ाइल के बारे में जानकारी की दुकान.

275
00:23:12,020 --> 00:23:16,380
तो आप फ़ाइल सूचक है कि फाइल के बारे में जानकारी नहीं है,

276
00:23:16,380 --> 00:23:23,080
इस तरह के रूप में यह खुला है, इसके आकार, जहां आप फ़ाइल में वर्तमान में कर रहे हैं,

277
00:23:23,080 --> 00:23:29,100
इतनी है कि आप पढ़ने और लेखन है कि विशेष रूप से जगह के लिए फ़ाइल के भीतर कॉल कर सकते हैं.

278
00:23:29,100 --> 00:23:38,060
तुम अंत में फ़ाइल नाम को बंद करने के बजाय सूचक बंद.

279
00:23:38,060 --> 00:23:48,990
>> हाँ? [डैनियल] तो क्रम में किराया का उपयोग करने के लिए, आप कहना होगा - यह उपयोगकर्ता इनपुट कैसे मिलता है?

280
00:23:48,990 --> 00:23:53,830
क्या fprintf भावना में GetString तरह कार्य है कि यह सिर्फ उपयोगकर्ता इनपुट के लिए इंतजार करेंगे

281
00:23:53,830 --> 00:23:57,180
और आप इस प्रकार के लिए पूछ - या इंतजार के लिए आप इन तीन बातों में टाइप करने के लिए?

282
00:23:57,180 --> 00:24:00,480
या आप कुछ का उपयोग भाड़े को लागू करने की जरूरत है?

283
00:24:00,480 --> 00:24:04,100
>> हाँ. सवाल, कैसे कर रहा था हम उपयोगकर्ता इनपुट मिल - तो हम नहीं कर रहे हैं

284
00:24:04,100 --> 00:24:09,220
क्रम में किराया को लागू करने के लिए? और क्या हम यहाँ है भाड़े के फोन करने वाले है,

285
00:24:09,220 --> 00:24:17,690
struct में पहले से संग्रहीत डेटा के सभी के साथ इस कर्मचारी struct में पारित कर दिया.

286
00:24:17,690 --> 00:24:22,990
तो fprintf सिर्फ इतना है कि डेटा फ़ाइल के लिए सीधे लिखने के लिए सक्षम है.

287
00:24:22,990 --> 00:24:25,690
वहाँ कोई उपयोगकर्ता इनपुट के लिए इंतज़ार कर रहे है.

288
00:24:25,690 --> 00:24:32,110
उपयोगकर्ता पहले से ही इसे ठीक इस स्टाफ struct में डाल इनपुट दिया.

289
00:24:32,110 --> 00:24:36,510
और चीजें हैं, निश्चित रूप से, अगर उन संकेत के किसी भी अशक्त थे तोड़ना होगा,

290
00:24:36,510 --> 00:24:40,370
तो हम वापस यहाँ स्क्रॉल करें और हम अपने struct को देखो.

291
00:24:40,370 --> 00:24:43,640
हम स्ट्रिंग अंतिम स्ट्रिंग, 1, स्ट्रिंग ईमेल है.

292
00:24:43,640 --> 00:24:48,530
अब हम जानते हैं कि उन वास्तव में सभी हुड के तहत, चार * चर रहे हैं.

293
00:24:48,530 --> 00:24:53,470
अशक्त करने की ओर इशारा करते हुए हो सकता है या नहीं.

294
00:24:53,470 --> 00:24:55,800
वे ढेर पर स्मृति की ओर इशारा करते हुए किया जा सकता है,

295
00:24:55,800 --> 00:24:59,650
शायद ढेर पर स्मृति.

296
00:24:59,650 --> 00:25:04,580
हम वास्तव में नहीं पता नहीं है, लेकिन अगर ये संकेत किसी भी अशक्त, या अवैध हैं,

297
00:25:04,580 --> 00:25:08,120
जो कि निश्चित रूप से हमारे किराया समारोह दुर्घटना करेंगे.

298
00:25:08,120 --> 00:25:11,050
यह कुछ ऐसा है कि परीक्षा के दायरे से परे तरह का था था.

299
00:25:11,050 --> 00:25:16,440
हम उस बारे में चिंता नहीं कर रहे हैं.

300
00:25:16,440 --> 00:25:22,170
बढ़िया है. ठीक है. तो प्रश्नोत्तरी से बढ़ रहा है.

301
00:25:22,170 --> 00:25:25,760
>> चलो इस आदमी को बंद करते हैं, और हम pset 4 में लग जा रहे हैं.

302
00:25:25,760 --> 00:25:34,700
तो अगर आप लोगों pset कल्पना को देखो, एक बार आप इसे का उपयोग कर सकते हैं, cs50.net/quizzes,

303
00:25:34,700 --> 00:25:42,730
हम अनुभाग आज की समस्याओं के कुछ के माध्यम से जाने के लिए जा रहे हैं.

304
00:25:42,730 --> 00:25:52,240
मैं नीचे स्क्रॉल कर रहा हूँ - सवालों के अनुभाग pset कल्पना की 3 पेज पर शुरू होता है.

305
00:25:52,240 --> 00:25:57,800
और 1 हिस्सा पूछता है तुम जाओ और पुनः निर्देशित कर और पाइप पर कम घड़ी.

306
00:25:57,800 --> 00:26:02,820
जो एक ठंडी कम की तरह था, तो आप कुछ नए, शांत कमांड लाइन चाल से पता चलता है कि आप उपयोग कर सकते हैं.

307
00:26:02,820 --> 00:26:06,050
और फिर हम आप के लिए कुछ सवाल के रूप में अच्छी तरह से मिल गया है.

308
00:26:06,050 --> 00:26:10,860
नदियों के बारे में यह पहला सवाल जो printf डिफ़ॉल्ट रूप से लिखते हैं,,

309
00:26:10,860 --> 00:26:15,920
हम किस तरह का सिर्फ एक छोटा सा पर एक पल पहले छुआ.

310
00:26:15,920 --> 00:26:22,380
इस fprintf कि हम चर्चा कर रहे थे अपने तर्क के रूप में एक फ़ाइल * धारा में लेता है.

311
00:26:22,380 --> 00:26:26,580
fclose एक फ़ाइल * धारा में के रूप में अच्छी तरह से लेता है,

312
00:26:26,580 --> 00:26:32,660
और fopen का वापसी मान आप एक फ़ाइल * धारा के रूप में अच्छी तरह से देता है.

313
00:26:32,660 --> 00:26:36,060
कारण है कि हम से पहले उन लोगों को नहीं देखा जब हम printf के साथ निपटा दिया है

314
00:26:36,060 --> 00:26:39,450
क्योंकि printf एक डिफ़ॉल्ट धारा है.

315
00:26:39,450 --> 00:26:41,810
और डिफ़ॉल्ट धारा है जो इसे लिखते

316
00:26:41,810 --> 00:26:45,190
तुम बाहर के बारे में संक्षेप में मिल जाएगा.

317
00:26:45,190 --> 00:26:50,080
तो निश्चित रूप से इस पर एक नज़र रखना.

318
00:26:50,080 --> 00:26:53,010
>> आज के अनुभाग में, हम GDB के बारे में थोड़ा बहुत बात करते जा रहे हैं,

319
00:26:53,010 --> 00:26:57,720
के बाद से अधिक परिचित आप इसके साथ कर रहे हैं, और अधिक अभ्यास आप इसके साथ मिलता है,

320
00:26:57,720 --> 00:27:01,390
बेहतर करने में सक्षम है कि आप वास्तव में अपने खुद के कोड में कीड़े का शिकार हो जाएगा.

321
00:27:01,390 --> 00:27:05,540
यह काफी debugging की प्रक्रिया को गति.

322
00:27:05,540 --> 00:27:09,230
तो printf का उपयोग करके, हर बार आपको लगता है कि आप अपने कोड recompile,

323
00:27:09,230 --> 00:27:13,000
आप इसे फिर से चलाने के लिए है, कभी कभी आप printf कॉल के आसपास स्थानांतरित करने के लिए किया है,

324
00:27:13,000 --> 00:27:17,100
बाहर कोड टिप्पणी करने के लिए, यह सिर्फ एक समय लेता है.

325
00:27:17,100 --> 00:27:20,850
हमारे लक्ष्य के लिए प्रयास करें और आपको समझाने की है कि GDB के साथ, आप अनिवार्य रूप से कर सकते हैं

326
00:27:20,850 --> 00:27:26,810
printf कुछ भी आप अपने कोड में किसी भी बिंदु पर है और कभी नहीं करने के लिए यह recompile.

327
00:27:26,810 --> 00:27:35,120
आप कभी नहीं शुरू करने के लिए और जहां printf अगले ख्याल रखना.

328
00:27:35,120 --> 00:27:40,910
पहली बात करने के लिए इस लाइन को कॉपी और अनुभाग कोड वेब का उतरना है.

329
00:27:40,910 --> 00:27:47,530
मैं कोड की इस पंक्ति है कि कहते हैं, 'wget http://cdn.cs50.net "की नकल कर रहा हूँ.

330
00:27:47,530 --> 00:27:49,510
मैं इसे कॉपी करने के लिए जा रहा हूँ.

331
00:27:49,510 --> 00:27:55,950
मैं अपने उपकरण के लिए जा रहा हूँ, बाहर ज़ूम तो आप देख सकते हैं कि मैं क्या कर रहा हूँ,

332
00:27:55,950 --> 00:28:01,890
यह वहाँ में चिपकाने, और जब मैं हिट दर्ज करें, इस wget समादेश सचमुच एक वेब मिल.

333
00:28:01,890 --> 00:28:06,210
यह नीचे इंटरनेट के इस फ़ाइल को खींचने के लिए रवाना हो रहा है,

334
00:28:06,210 --> 00:28:11,790
और इसे मौजूदा निर्देशिका में बचाने के लिए जा रहा है.

335
00:28:11,790 --> 00:28:21,630
अब अगर मैं अपने वर्तमान निर्देशिका की सूची आप देख सकते हैं कि मैं सही में वहाँ इस section5.zip फ़ाइल मिल गया है.

336
00:28:21,630 --> 00:28:25,260
उस आदमी के साथ सौदा करने के लिए जिस तरह से इसे खोलना है,

337
00:28:25,260 --> 00:28:27,650
जो आप कमांड लाइन में सिर्फ इस तरह कर सकते हैं.

338
00:28:27,650 --> 00:28:31,880
Section5.zip.

339
00:28:31,880 --> 00:28:36,980
कि इसे खोलना होगा, मेरे लिए फ़ोल्डर बनाने के लिए,

340
00:28:36,980 --> 00:28:40,410
सामग्री के सभी फुलाना, उन्हें वहाँ में डाल दिया.

341
00:28:40,410 --> 00:28:47,410
तो अब मैं अपने अनुभाग 5 सीडी कमांड का उपयोग निर्देशिका में जा सकते हैं.

342
00:28:47,410 --> 00:28:58,310
स्पष्ट का उपयोग कर स्क्रीन साफ. तो स्क्रीन साफ.

343
00:28:58,310 --> 00:29:02,280
अब मैं एक अच्छा साफ के साथ सौदा करने के लिए टर्मिनल के लिए मिल गया है.

344
00:29:02,280 --> 00:29:06,200
>> अब अगर मैं सभी फ़ाइलों है कि मैं इस निर्देशिका में देखने की सूची,

345
00:29:06,200 --> 00:29:12,270
आप देखते हैं कि मैं चार फाइलें मिल गया है: buggy1, buggy2, buggy3, और buggy4.

346
00:29:12,270 --> 00:29:16,180
मैं भी उनके इसी ग फ़ाइलें मिल गया है.

347
00:29:16,180 --> 00:29:20,400
हम अब के लिए ग फ़ाइलों को देखने के लिए नहीं जा रहे हैं.

348
00:29:20,400 --> 00:29:24,140
इसके बजाय, हम उन का उपयोग जब हम GDB को खोलने के लिए जा रहे हैं.

349
00:29:24,140 --> 00:29:28,220
हम उन्हें रखा है चारों ओर इतना है कि हम वास्तविक स्रोत कोड के लिए उपयोग कर सकते है जब हम GDB का उपयोग कर रहे हैं,

350
00:29:28,220 --> 00:29:32,740
लेकिन खंड के इस भाग के लक्ष्य GDB के साथ चारों ओर टिंकर करने के लिए है

351
00:29:32,740 --> 00:29:40,370
देखते हैं और कैसे हम इसे उपयोग करने के लिए बाहर निकालने के लिए इन चार छोटी गाड़ी कार्यक्रमों में से प्रत्येक के साथ क्या गलत हो रहा है कर सकते हैं.

352
00:29:40,370 --> 00:29:43,380
तो हम सिर्फ कमरे में चारों ओर कर रहे हैं सच में जल्दी जा रहा है,

353
00:29:43,380 --> 00:29:47,000
और मैं किसी को पूछने के लिए एक छोटी गाड़ी कार्यक्रमों के चलने के लिए जा रहा हूँ,

354
00:29:47,000 --> 00:29:54,730
और फिर हम GDB के माध्यम से एक समूह के रूप में जाना है, और हम देखेंगे कि हम क्या करने के लिए इन कार्यक्रमों को ठीक कर सकते हैं,

355
00:29:54,730 --> 00:29:58,460
या कम से कम की पहचान करने के लिए उनमें से प्रत्येक में क्या गलत हो रहा है.

356
00:29:58,460 --> 00:30:04,760
चलो डैनियल के साथ यहाँ शुरू. तुम buggy1 चलेगा? चलो देखते हैं कि क्या होता है.

357
00:30:04,760 --> 00:30:09,470
[डैनियल] यह कहना है कि वहाँ एक आवेदन गलती है. >> हाँ. बिल्कुल सही.

358
00:30:09,470 --> 00:30:12,460
तो अगर मैं buggy1 चलाने के लिए, मैं एक seg गलती मिलता है.

359
00:30:12,460 --> 00:30:16,210
इस बिंदु पर, मैं जाकर buggy1.c खोल सकता है,

360
00:30:16,210 --> 00:30:19,450
कोशिश करते हैं और पता लगाने की क्या गलत हो रहा है,

361
00:30:19,450 --> 00:30:22,000
लेकिन एक seg गलती त्रुटि के बारे में सबसे अप्रिय बातें

362
00:30:22,000 --> 00:30:27,610
यह है कि यह कार्यक्रम चीजों में से एक लाइन वास्तव में क्या गलत हो गया था और तोड़ दिया पर बता नहीं है.

363
00:30:27,610 --> 00:30:29,880
आप किस तरह का कोड को देखो

364
00:30:29,880 --> 00:30:33,990
और अनुमान का उपयोग कर बाहर आंकड़ा और जांच या printf देखने के लिए कि क्या गलत हो रहा है.

365
00:30:33,990 --> 00:30:37,840
GDB बारे में coolest चीजों में से एक यह है कि यह वास्तव में, वास्तव में आसान है

366
00:30:37,840 --> 00:30:42,170
करने के लिए बाहर आंकड़ा लाइन पर जो अपने कार्यक्रम दुर्घटनाओं.

367
00:30:42,170 --> 00:30:46,160
यह पूरी तरह से यह उपयोग करने के लिए लायक है, भले ही सिर्फ उस के लिए.

368
00:30:46,160 --> 00:30:56,190
GDB बूट तो, मैं GDB टाइप करें, और फिर मैं यह निष्पादन योग्य है कि मैं चलाने के लिए करना चाहते हैं के लिए रास्ता दे.

369
00:30:56,190 --> 00:31:01,960
यहाँ मैं ./buggy1 gdb टाइप कर रहा हूँ.

370
00:31:01,960 --> 00:31:06,600
हिट दर्ज करें. मुझे यह सब कॉपीराइट जानकारी देता है,

371
00:31:06,600 --> 00:31:13,000
और यहाँ नीचे आप इस लाइन कहते हैं, "घर / / से पढ़ना प्रतीकों देखेंगे

372
00:31:13,000 --> 00:31:17,680
jharvard/section5/buggy1. "

373
00:31:17,680 --> 00:31:22,060
और अगर सब कुछ ठीक हो जाता है, आप देखेंगे कि यह एक संदेश है कि इस तरह दिखता प्रिंट.

374
00:31:22,060 --> 00:31:25,500
यह प्रतीकों को पढ़ा होगा, यह कहना है "मैं अपने निष्पादन योग्य फ़ाइल से प्रतीक पढ़ रहा हूँ,"

375
00:31:25,500 --> 00:31:29,900
और फिर इसे यहाँ पर इस "किया" संदेश होगा.

376
00:31:29,900 --> 00:31:35,410
यदि आप इस के कुछ अन्य बदलाव देखते हैं, या आप देख यह प्रतीक नहीं मिल सकता है

377
00:31:35,410 --> 00:31:41,460
या कुछ की तरह है कि, क्या इसका मतलब है कि आप सिर्फ अपने निष्पादन ठीक नहीं संकलित किया है.

378
00:31:41,460 --> 00:31:49,980
GDB के साथ उपयोग करने के लिए जब हम कार्यक्रमों संकलन करने के लिए, हम कि विशेष जी ध्वज का उपयोग किया है,

379
00:31:49,980 --> 00:31:54,540
और जो मूलभूत रूप से किया है अगर आप अपने कार्यक्रमों संकलन सिर्फ टाइपिंग बनाने के द्वारा,

380
00:31:54,540 --> 00:31:59,320
या छोटी गाड़ी बनाने के लिए या ठीक बनाने के लिए, उन में से किसी के.

381
00:31:59,320 --> 00:32:07,800
लेकिन यदि आप मैन्युअल बजना साथ संकलन कर रहे हैं, तो आप में जाओ और है कि छ ध्वज शामिल होगा.

382
00:32:07,800 --> 00:32:10,310
>> इस बिंदु पर, अब है कि हम अपने GDB प्रॉम्प्ट है,

383
00:32:10,310 --> 00:32:12,310
यह बहुत आसान है इस कार्यक्रम को चलाने के.

384
00:32:12,310 --> 00:32:19,740
हम या तो रन टाइप कर सकते हैं, या हम सिर्फ r टाइप कर सकते हैं.

385
00:32:19,740 --> 00:32:22,820
अधिकांश GDB आज्ञाओं संक्षिप्त हो सकता है.

386
00:32:22,820 --> 00:32:25,940
आम तौर पर सिर्फ एक या दो पत्र है, जो बहुत अच्छा है.

387
00:32:25,940 --> 00:32:30,980
तो साद, अगर आप टाइप और हिट दर्ज करें, क्या होता है?

388
00:32:30,980 --> 00:32:39,390
[साद] मैं SIGSEGV, विभाजन गलती है, और फिर यह सब gobbledygook मिला.

389
00:32:39,390 --> 00:32:43,650
>> हाँ.

390
00:32:43,650 --> 00:32:47,990
जैसे हम स्क्रीन पर देख रहे हैं अभी, और जैसे साद ने कहा,

391
00:32:47,990 --> 00:32:53,430
जब हम भाग या r टाइप करें और हिट दर्ज करें, हम अभी भी एक ही seg गलती मिलता है.

392
00:32:53,430 --> 00:32:55,830
तो GDB का उपयोग हमारी समस्या का समाधान नहीं है.

393
00:32:55,830 --> 00:32:59,120
लेकिन यह हमें कुछ gobbledygook देता है, और यह पता चला है कि इस gobbledygook

394
00:32:59,120 --> 00:33:03,080
वास्तव में हमें बताता है जहां यह हो रहा है.

395
00:33:03,080 --> 00:33:10,680
यह एक छोटा सा पार्स, यह पहली बिट समारोह में सब कुछ गलत हो रहा है है.

396
00:33:10,680 --> 00:33:20,270
इस strcmp_sse4_2 __ है, और यह हमें बताता है कि यह इस फाइल में हो रहा है

397
00:33:20,270 --> 00:33:29,450
कहा जाता sysdeps/i386, यह सब, फिर से, एक गड़बड़ की तरह है - लेकिन 254 लाइन.

398
00:33:29,450 --> 00:33:31,670
उस तरह का पार्स करने के लिए मुश्किल है. आमतौर पर जब आप इस तरह से चीजें देखते हैं,

399
00:33:31,670 --> 00:33:38,770
इसका मतलब है कि यह एक प्रणाली पुस्तकालयों में दोषयुक्त seg है.

400
00:33:38,770 --> 00:33:43,220
तो strcmp साथ क्या करने के लिए कुछ है. तुम लोग strcmp पहले देखा है.

401
00:33:43,220 --> 00:33:52,730
पागल है, नहीं भी है, लेकिन इसका मतलब यह है कि strcmp या टूट जाता है कि वहाँ के साथ एक समस्या है strcmp करता है?

402
00:33:52,730 --> 00:33:57,110
तुझे क्या अलेक्जेंडर लगता है?

403
00:33:57,110 --> 00:34:04,890
[अलेक्जेंडर] है कि 254 लाइन है? और द्विपदीय नहीं है, लेकिन यह अपनी छत नहीं है,

404
00:34:04,890 --> 00:34:10,590
और फिर वहाँ प्रत्येक समारोह के लिए एक और भाषा है. यह है कि उस समारोह में 254 या?

405
00:34:10,590 --> 00:34:21,460
>> यह 254 लाइन है. यह इस फ़ाइल में की तरह लग रहा है, तो इसे विधानसभा शायद कोड.

406
00:34:21,460 --> 00:34:25,949
>> लेकिन, मुझे लगता है कि ज्यादा चिंताजनक बात है, क्योंकि हम एक seg गलती मिल गया है,

407
00:34:25,949 --> 00:34:29,960
और ऐसा लगता है जैसे यह strcmp समारोह से आ रहा है,

408
00:34:29,960 --> 00:34:38,030
क्या यह मतलब है, तो, कि strcmp टूट गया है?

409
00:34:38,030 --> 00:34:42,290
, उम्मीद है कि यह नहीं होना चाहिए. तो सिर्फ इसलिए कि आप एक विभाजन गलती

410
00:34:42,290 --> 00:34:49,480
एक प्रणाली के कार्यों में, आम तौर पर मतलब है कि है कि तुम सिर्फ इसे सही ढंग से नहीं बुलाया है.

411
00:34:49,480 --> 00:34:52,440
तेज बात यह पता लगाने की क्या वास्तव में चल रहा है

412
00:34:52,440 --> 00:34:55,500
, जब आप पागल कुछ इस तरह, जब भी आप एक seg गलती देख

413
00:34:55,500 --> 00:34:59,800
खासकर यदि आप एक प्रोग्राम है कि अधिक से अधिक सिर्फ मुख्य का उपयोग कर रहा है,

414
00:34:59,800 --> 00:35:03,570
एक backtrace का उपयोग करने के लिए है.

415
00:35:03,570 --> 00:35:13,080
मैं बीटी लेखन, रूप में पूर्ण बैकट्रैस शब्द विरोध बैकट्रैस संक्षिप्त.

416
00:35:13,080 --> 00:35:16,510
लेकिन Charlotte, क्या होता है जब आप बीटी टाइप और हिट दर्ज करें?

417
00:35:16,510 --> 00:35:23,200
[Charlotte] यह मुझे दो लाइनों, लाइन 0 और 1 लाइन से पता चलता है.

418
00:35:23,200 --> 00:35:26,150
>> हाँ. तो लाइन 0 और लाइन 1.

419
00:35:26,150 --> 00:35:34,560
वास्तविक ढेर फ्रेम कि नाटक में वर्तमान में थे जब अपने कार्यक्रम के दुर्घटनाग्रस्त हो जाने से हैं.

420
00:35:34,560 --> 00:35:42,230
सर्वोच्च फ्रेम, फ्रेम 0 से शुरू है, और सबसे नीचे है, जो 1 फ्रेम करने के लिए जा रही है.

421
00:35:42,230 --> 00:35:45,140
हमारी सर्वोच्च फ्रेम strcmp फ्रेम है.

422
00:35:45,140 --> 00:35:50,080
आप इस बारे में सोच के रूप में हम सिर्फ संकेत के साथ प्रश्नोत्तरी पर कर रहे थे कि समस्या की तरह कर सकते हैं,

423
00:35:50,080 --> 00:35:54,890
जहां हम मुख्य ढेर फ्रेम के शीर्ष पर स्टैक फ्रेम स्वैप था,

424
00:35:54,890 --> 00:35:59,700
और हम चर है कि स्वैप चर कि मुख्य का उपयोग कर रहा था के शीर्ष पर का उपयोग कर रहा था था.

425
00:35:59,700 --> 00:36:08,440
यहाँ हमारे दुर्घटना हमारे strcmp समारोह, जो हमारी मुख्य समारोह से बुलाया गया था में हुआ,

426
00:36:08,440 --> 00:36:14,370
और बैकट्रैस हमें न केवल कार्य करता है जो बातें में विफल रहा है दे रहा है,

427
00:36:14,370 --> 00:36:16,440
लेकिन यह भी हमें बता रहा है, जहां सब कुछ से बुलाया गया था.

428
00:36:16,440 --> 00:36:18,830
तो अगर मैं एक छोटे से अधिक से अधिक सही करने के लिए स्क्रॉल,

429
00:36:18,830 --> 00:36:26,110
हम देख सकते हैं कि हाँ, हम इस फ़ाइल strcmp sse4.s के 254 लाइन पर थे.

430
00:36:26,110 --> 00:36:32,540
लेकिन कॉल buggy1.c, 6 लाइन में बनाया गया था.

431
00:36:32,540 --> 00:36:35,960
तो इसका मतलब है कि हम क्या कर सकते है - हम सिर्फ बाहर की जाँच कर सकते हैं और देखने के लिए क्या हो रहा था

432
00:36:35,960 --> 00:36:39,930
buggy1.c, 6 लाइन में.

433
00:36:39,930 --> 00:36:43,780
फिर, वहाँ एक दो तरीके से ऐसा कर रहे हैं. GDB से बाहर निकलें

434
00:36:43,780 --> 00:36:49,460
है या अपने कोड एक और खिड़की और पार संदर्भ में खुला.

435
00:36:49,460 --> 00:36:54,740
यही है, और खुद की, बहुत आसान है क्योंकि अब अगर आप कार्यालय समय पर कर रहे हैं

436
00:36:54,740 --> 00:36:57,220
और आप एक seg गलती मिल गया है और अपने TF सोच रहा है जहां सब कुछ टूट गया था,

437
00:36:57,220 --> 00:36:59,710
आप बस का कहना है, "ओह, 6 लाइन कर सकते हैं मैं नहीं जानता कि क्या हो रहा है,

438
00:36:59,710 --> 00:37:03,670
लेकिन 6 लाइन के बारे में कुछ मेरे कार्यक्रम को तोड़ने के लिए पैदा कर रहा है. "

439
00:37:03,670 --> 00:37:10,430
अन्य तरीका यह करना है आप इस सूची GDB में बुलाया आदेश का उपयोग कर सकते हैं.

440
00:37:10,430 --> 00:37:13,650
आप यह भी एल के साथ संक्षिप्त कर सकते हैं.

441
00:37:13,650 --> 00:37:18,910
तो अगर हम एल मारा, हम यहाँ क्या मिलता है?

442
00:37:18,910 --> 00:37:21,160
हम अजीब सामान की एक पूरी गुच्छा मिलता है.

443
00:37:21,160 --> 00:37:26,030
यह वास्तविक विधानसभा कोड है

444
00:37:26,030 --> 00:37:29,860
है कि strcmp_sse4_2 में है.

445
00:37:29,860 --> 00:37:32,440
यह कायरता की तरह लग रहा है,

446
00:37:32,440 --> 00:37:36,520
और कारण है कि हम यह हो रही है क्योंकि अब ठीक है,

447
00:37:36,520 --> 00:37:40,160
GDB हमें 0 फ्रेम में है.

448
00:37:40,160 --> 00:37:43,070
>> तो हम कभी भी देखने के चर में, किसी भी समय हम स्रोत कोड को देखो,

449
00:37:43,070 --> 00:37:50,530
हम स्रोत कोड को देख रहे हैं कि स्टैक फ्रेम से संबंधित वर्तमान में हम अंदर हो

450
00:37:50,530 --> 00:37:53,200
तो क्रम में सार्थक कुछ भी प्राप्त करने के लिए, हम करने के लिए है

451
00:37:53,200 --> 00:37:57,070
एक ढेर फ्रेम कि अधिक समझ में आता है करने के लिए कदम.

452
00:37:57,070 --> 00:38:00,180
इस मामले में, मुख्य ढेर फ्रेम एक छोटे से अधिक मतलब होगा,

453
00:38:00,180 --> 00:38:02,680
क्योंकि है कि वास्तव में कोड है कि हम ने लिखा था.

454
00:38:02,680 --> 00:38:05,330
Strcmp कोड.

455
00:38:05,330 --> 00:38:08,650
जिस तरह से आप फ्रेम के बीच ले जाने के लिए, इस मामले में कर सकते हैं, क्योंकि हम दो है,

456
00:38:08,650 --> 00:38:10,430
हम 0 और 1,

457
00:38:10,430 --> 00:38:13,650
आप ऊपर और नीचे कमांड के साथ करते हैं कि.

458
00:38:13,650 --> 00:38:18,480
अगर मैं एक फ्रेम ले जाते हैं,

459
00:38:18,480 --> 00:38:21,770
अब मैं मुख्य ढेर फ्रेम में हूँ.

460
00:38:21,770 --> 00:38:24,330
मैं नीचे स्थानांतरित करने के लिए मैं कहाँ था वापस जा सकते हैं,

461
00:38:24,330 --> 00:38:32,830
फिर से जाने के लिए, फिर से जाना है, और फिर से जाना.

462
00:38:32,830 --> 00:38:39,750
यदि आप कभी भी GDB में अपने कार्यक्रम करते हैं, तो आप एक दुर्घटना हो, आप बैकट्रैस मिलता है,

463
00:38:39,750 --> 00:38:42,380
और आप देखेंगे कि यह कुछ फ़ाइल है कि तुम नहीं जानते कि क्या हो रहा है में है.

464
00:38:42,380 --> 00:38:45,460
आप सूची की कोशिश, कोड आप परिचित नहीं लगती है,

465
00:38:45,460 --> 00:38:48,150
अपने तख्ते पर एक नज़र रखना और बाहर आंकड़ा तुम कहाँ हो.

466
00:38:48,150 --> 00:38:51,010
आप शायद गलत ढेर फ्रेम में कर रहे हैं.

467
00:38:51,010 --> 00:38:58,760
या कम से कम आप एक ढेर फ्रेम कि एक नहीं है कि आप वास्तव में डिबग कर सकते हैं में कर रहे हैं.

468
00:38:58,760 --> 00:39:03,110
अब है कि हम उचित ढेर फ्रेम में कर रहे हैं, हम मुख्य हैं,

469
00:39:03,110 --> 00:39:08,100
अब हम सूची आदेश का उपयोग यह पता लगाने रेखा क्या कर सकते हैं.

470
00:39:08,100 --> 00:39:13,590
और आप इसे देख सकते हैं, यह हमारे लिए सही यहाँ मुद्रित.

471
00:39:13,590 --> 00:39:19,470
लेकिन हम सब एक ही सूची हिट कर सकते हैं, और सूची हमें यह अच्छा प्रिंटआउट देता है

472
00:39:19,470 --> 00:39:23,920
वास्तविक स्रोत कोड है कि यहाँ पर जा रहा है.

473
00:39:23,920 --> 00:39:26,420
>> विशेष रूप से, हम 6 लाइन पर देख सकते हैं.

474
00:39:26,420 --> 00:39:29,330
हम देख सकते हैं कि यहाँ क्या हो रहा है.

475
00:39:29,330 --> 00:39:31,250
और ऐसा लगता है जैसे हम एक स्ट्रिंग तुलना कर रहे हैं

476
00:39:31,250 --> 00:39:41,050
स्ट्रिंग "CS50 चट्टानों" और argv के बीच [1].

477
00:39:41,050 --> 00:39:45,700
इस बारे में कुछ दुर्घटनाग्रस्त था.

478
00:39:45,700 --> 00:39:54,120
Missy तो, तुम क्या हो रहा हो सकता है यहाँ पर कोई विचार है?

479
00:39:54,120 --> 00:39:59,400
[Missy] मैं क्यों यह दुर्घटनाग्रस्त है पता नहीं है. >> आप क्यों यह दुर्घटनाग्रस्त है पता नहीं है?

480
00:39:59,400 --> 00:40:02,700
जिमी, किसी भी विचार?

481
00:40:02,700 --> 00:40:06,240
[जिमी] मैं पूरी तरह यकीन नहीं कर रहा हूँ, लेकिन पिछली बार जब हम स्ट्रिंग इस्तेमाल किया की तुलना,

482
00:40:06,240 --> 00:40:10,260
या strcmp, हम इसके तहत तीन अलग - अलग मामलों की तरह था.

483
00:40:10,260 --> 00:40:12,800
हम एक == नहीं था, मैं सही है कि पहली पंक्ति में नहीं लगता है, नहीं है.

484
00:40:12,800 --> 00:40:16,700
इसके बजाय यह तीन में अलग हो गया था, और एक == 0 था,

485
00:40:16,700 --> 00:40:19,910
एक था <0, मुझे लगता है, और एक> 0.

486
00:40:19,910 --> 00:40:22,590
तो उस तरह शायद कुछ और? >> हाँ. तो इस मुद्दे

487
00:40:22,590 --> 00:40:27,200
हम तुलना कर रहे हैं सही ढंग से कर रहे हैं?

488
00:40:27,200 --> 00:40:31,660
स्टेला? किसी भी विचार?

489
00:40:31,660 --> 00:40:38,110
[स्टेला] मुझे यकीन नहीं कर रहा हूँ. सुनिश्चित नहीं हैं. >> डेनियल? विचार? ठीक है.

490
00:40:38,110 --> 00:40:44,770
यह पता चला है सही में यहाँ क्या हो रहा है जब हम कार्यक्रम भागा

491
00:40:44,770 --> 00:40:48,370
और हम seg गलती है, जब आप पहली बार के लिए कार्यक्रम, डैनियल दौड़ा,

492
00:40:48,370 --> 00:40:50,800
आप इसे किसी भी कमांड लाइन तर्क दे?

493
00:40:50,800 --> 00:40:58,420
[डैनियल] नहीं >> सं. उस मामले में, क्या argv के मूल्य [1]?

494
00:40:58,420 --> 00:41:00,920
>> का कोई मूल्य नहीं है. >> ठीक है.

495
00:41:00,920 --> 00:41:06,120
ठीक है, वहाँ कोई उपयुक्त स्ट्रिंग मान है.

496
00:41:06,120 --> 00:41:10,780
लेकिन वहाँ कुछ मूल्य है. क्या मूल्य है कि वहाँ में जमा हो जाता है?

497
00:41:10,780 --> 00:41:15,130
>> एक कचरा मूल्य है? >> यह या तो एक कचरा मान है या इस मामले में,

498
00:41:15,130 --> 00:41:19,930
argv सरणी के अंत हमेशा बातिल के साथ समाप्त होता है.

499
00:41:19,930 --> 00:41:26,050
तो क्या वास्तव में संग्रहीत गया रिक्त है.

500
00:41:26,050 --> 00:41:30,810
अन्य तरह से हल करने के लिए है, यह सोच के माध्यम से नहीं बल्कि,

501
00:41:30,810 --> 00:41:33,420
यह मुद्रण बाहर करने की कोशिश है.

502
00:41:33,420 --> 00:41:35,880
यह वह जगह है जहाँ मैं कह रहा था कि GDB का उपयोग महान है,

503
00:41:35,880 --> 00:41:40,640
क्योंकि तुम बाहर सभी चर मुद्रित कर सकते हैं, सभी मूल्यों है कि आप चाहते हैं

504
00:41:40,640 --> 00:41:43,230
इस काम - बांका पी आदेश का उपयोग.

505
00:41:43,230 --> 00:41:48,520
तो अगर मैं पी लिखें और फिर मैं एक चर या एक चर के नाम का मान लिखें,

506
00:41:48,520 --> 00:41:55,320
कहते हैं, argc, मैं देख रहा हूँ कि argc 1 है.

507
00:41:55,320 --> 00:42:01,830
अगर मैं बाहर argv मुद्रित करना चाहते [0], मैं तो बस ऐसे ही कर सकते हैं.

508
00:42:01,830 --> 00:42:04,840
और जैसा कि हमने देखा, argv [0] हमेशा अपने कार्यक्रम का नाम है,

509
00:42:04,840 --> 00:42:06,910
हमेशा निष्पादन के नाम.

510
00:42:06,910 --> 00:42:09,740
यहां आप देख यह पूर्ण पथ नाम मिल गया है.

511
00:42:09,740 --> 00:42:15,920
मैं भी बाहर प्रिंट argv [1] और देखो क्या होता है.

512
00:42:15,920 --> 00:42:20,890
>> यहाँ हम रहस्यमय मूल्य के इस तरह मिल गया.

513
00:42:20,890 --> 00:42:23,890
हम इस 0x0 मिला.

514
00:42:23,890 --> 00:42:27,850
अवधि की शुरुआत में जब हम षोडश संख्या के बारे में बात की याद है?

515
00:42:27,850 --> 00:42:34,680
या कैसे हेक्स में 50 का प्रतिनिधित्व करने के बारे में कि 0 pset के अंत में एक छोटे सवाल?

516
00:42:34,680 --> 00:42:39,410
जिस तरह से हम सीएस में हेक्स संख्या लिखते हैं, सिर्फ खुद को भ्रमित करने के लिए नहीं

517
00:42:39,410 --> 00:42:46,080
दशमलव संख्या के साथ है, हम हमेशा उन्हें 0x से उपसर्ग.

518
00:42:46,080 --> 00:42:51,420
तो इस 0x के हमेशा सिर्फ मतलब है कि एक हेक्साडेसिमल संख्या के रूप में निम्नलिखित संख्या व्याख्या,

519
00:42:51,420 --> 00:42:57,400
एक स्ट्रिंग के रूप में नहीं, नहीं एक दशमलव संख्या के रूप में नहीं एक द्विआधारी संख्या के रूप में.

520
00:42:57,400 --> 00:43:02,820
चूंकि 5-0 संख्या हेक्साडेसिमल में एक वैध संख्या है.

521
00:43:02,820 --> 00:43:06,240
और यह दशमलव, 50 में एक नंबर है.

522
00:43:06,240 --> 00:43:10,050
तो यह है कि बस कैसे हम disambiguate.

523
00:43:10,050 --> 00:43:14,860
तो 0x0 0 षोडश आधारी साधन है, जो भी दशमलव 0 0 द्विआधारी.

524
00:43:14,860 --> 00:43:17,030
यह सिर्फ मान 0 है.

525
00:43:17,030 --> 00:43:22,630
यह पता चला है कि इस अशक्त क्या है, वास्तव में स्मृति में.

526
00:43:22,630 --> 00:43:25,940
अशक्त है 0.

527
00:43:25,940 --> 00:43:37,010
यहाँ, तत्व argv [1] में संग्रहीत रिक्त है.

528
00:43:37,010 --> 00:43:45,220
तो हम एक रिक्त स्ट्रिंग के लिए हमारे "CS50 चट्टानों" स्ट्रिंग की तुलना करने की कोशिश कर रहे हैं.

529
00:43:45,220 --> 00:43:48,130
तो अशक्त अपसंदर्भन, अशक्त में चीजों का उपयोग करने की कोशिश कर रहा है,

530
00:43:48,130 --> 00:43:55,050
वे आम तौर पर विभाजन गलती या अन्य बुरी बातें होने का किसी प्रकार का कारण करने के लिए जा रहे हैं.

531
00:43:55,050 --> 00:43:59,350
और यह पता चला कि strcmp देखना जाँच नहीं करता

532
00:43:59,350 --> 00:44:04,340
चाहे या नहीं आप एक मूल्य है कि अशक्त में पारित कर दिया है.

533
00:44:04,340 --> 00:44:06,370
बल्कि, यह सिर्फ आगे चला जाता है, अपनी बात करने की कोशिश करता है,

534
00:44:06,370 --> 00:44:14,640
और अगर यह दोष seg, यह दोष seg, और यह आपकी समस्या है. तुम जाने के लिए इसे ठीक कर दिया है.

535
00:44:14,640 --> 00:44:19,730
वास्तव में, जल्दी से, कैसे हम इस समस्या को ठीक कर सकता है? Charlotte?

536
00:44:19,730 --> 00:44:23,540
[Charlotte] यदि आप का उपयोग की जांच कर सकते हैं.

537
00:44:23,540 --> 00:44:32,240
तो अगर argv [1] रिक्त है, == 0, तो 1 लौटने के लिए, या कुछ [unintelligible]

538
00:44:32,240 --> 00:44:34,590
>> हाँ. तो यह है कि एक महान तरीका यह करना है, जैसा कि हम देखने के लिए जाँच कर सकते हैं,

539
00:44:34,590 --> 00:44:39,230
मूल्य के बारे में हम strcmp में पारित करने के लिए कर रहे हैं, argv [1], यह रिक्त है?

540
00:44:39,230 --> 00:44:45,830
अगर यह अशक्त है, तो हम ठीक कहते हैं, गर्भपात कर सकते हैं.

541
00:44:45,830 --> 00:44:49,450
>> एक अधिक सामान्य तरीका यह करने के लिए argc मूल्य का उपयोग करने के लिए है.

542
00:44:49,450 --> 00:44:52,040
तुम यहीं मुख्य की शुरुआत में देख सकते हैं,

543
00:44:52,040 --> 00:44:58,040
हम कि पहला परीक्षण लोप कर दिया है कि हम आम तौर पर जब हम कमांड लाइन तर्क का उपयोग,

544
00:44:58,040 --> 00:45:05,240
जो परीक्षण करने के लिए किया जाए या नहीं, हमारे argc मूल्य है कि हम क्या उम्मीद है.

545
00:45:05,240 --> 00:45:10,290
इस मामले में, हम कम से कम दो तर्कों की उम्मीद कर रहे हैं,

546
00:45:10,290 --> 00:45:13,660
कार्यक्रम के नाम के साथ एक अन्य.

547
00:45:13,660 --> 00:45:17,140
क्योंकि हम दूसरा तर्क के बारे में सही यहाँ का उपयोग कर रहे हैं.

548
00:45:17,140 --> 00:45:21,350
तो परीक्षण के कुछ प्रकार पहले हमारे strcmp फोन से पहले,

549
00:45:21,350 --> 00:45:37,390
कि परीक्षण किया जाए या नहीं argv कम से कम 2 है, भी बात की ही तरह करना होगा.

550
00:45:37,390 --> 00:45:40,620
हम देख सकते हैं कि अगर उस कार्यक्रम फिर से चलाने के द्वारा काम करता है.

551
00:45:40,620 --> 00:45:45,610
तुम हमेशा GDB, जो वास्तव में अच्छा है के भीतर अपने कार्यक्रम को पुनः आरंभ कर सकते हैं.

552
00:45:45,610 --> 00:45:49,310
आप चलाने के लिए, और जब आप अपने कार्यक्रम के लिए बहस में पारित कर सकते हैं,

553
00:45:49,310 --> 00:45:53,060
आप उन्हें जब आप चलाने के फोन में पारित नहीं, जब आप GDB बूट.

554
00:45:53,060 --> 00:45:57,120
इस तरह आप अलग तर्क के साथ अपने कार्यक्रम हर बार लागू रख सकते हैं.

555
00:45:57,120 --> 00:46:08,080
तो चलाने के लिए, या फिर, मैं r टाइप कर सकते हैं, और देखते हैं क्या होगा अगर हम टाइप होता है "नमस्ते".

556
00:46:08,080 --> 00:46:11,140
यह हमेशा आप से पूछना अगर आप शुरू से ही इसे फिर से शुरू करना चाहते हैं.

557
00:46:11,140 --> 00:46:17,490
आमतौर पर, आप शुरू से ही इसे फिर से शुरू करना चाहते हैं.

558
00:46:17,490 --> 00:46:25,010
और इस बिंदु पर, यह restarts इसे फिर से, यह बाहर प्रिंट

559
00:46:25,010 --> 00:46:28,920
प्रोग्राम है कि हम चल रहे हैं, रहे हैं तर्क नमस्ते के साथ buggy1,,

560
00:46:28,920 --> 00:46:32,720
और यह इस मानक बाहर प्रिंट, इसे कहते हैं, "आप एक डी मिलता है," उदास चेहरे.

561
00:46:32,720 --> 00:46:37,610
लेकिन हम गलती नहीं seg था. यह कहा कि प्रक्रिया सामान्य रूप से बाहर निकल गया.

562
00:46:37,610 --> 00:46:39,900
तो यह है कि बहुत अच्छा लग रहा है.

563
00:46:39,900 --> 00:46:43,050
कोई और अधिक seg गलती है, हम यह पिछले बनाया,

564
00:46:43,050 --> 00:46:48,190
तो यह लगता है कि वास्तव में हो रहे थे कि हम seg गलती बग था.

565
00:46:48,190 --> 00:46:51,540
दुर्भाग्य से, यह हमें बताता है कि हम एक डी. हो रही है

566
00:46:51,540 --> 00:46:54,090
>> हम वापस जाने के लिए और कोड को देखो कर सकते हैं और वहाँ क्या हो रहा था

567
00:46:54,090 --> 00:46:57,980
पता लगाने की क्या था - क्यों यह हमें बता रहा था कि हम एक डी. मिला

568
00:46:57,980 --> 00:47:03,690
चलो देखते हैं, यहाँ इस printf कह रही है कि आप एक डी. मिला

569
00:47:03,690 --> 00:47:08,540
अगर हम सूची टाइप करें, के रूप में आप टाइप सूची रखने के लिए, अपने कार्यक्रम के माध्यम से यह नीचे iterating रहता है,

570
00:47:08,540 --> 00:47:10,940
तो यह आप अपने कार्यक्रम के पहले कुछ लाइनों दिखाता हूँ.

571
00:47:10,940 --> 00:47:15,450
तो यह आप अगले कुछ लाइनों, और अगले हिस्सा और अगले हिस्सा दिखाता हूँ.

572
00:47:15,450 --> 00:47:18,240
और यह करने के लिए नीचे जाने की कोशिश करते रहेंगे.

573
00:47:18,240 --> 00:47:21,180
और अब हम "16 नंबर लाइन सीमा से बाहर है." मिलेगा

574
00:47:21,180 --> 00:47:23,940
क्योंकि यह केवल 15 लाइनें है.

575
00:47:23,940 --> 00:47:30,310
यदि आप इस बात पर आते हैं और अपनी सोच, "मैं क्या करूँ?" आप मदद आदेश का उपयोग कर सकते हैं.

576
00:47:30,310 --> 00:47:34,340
मदद करने के लिए और फिर यह एक आदेश के नाम दे प्रयोग करें.

577
00:47:34,340 --> 00:47:36,460
और आप देख GDB हमें सामान के सभी इस तरह देता है.

578
00:47:36,460 --> 00:47:43,870
इसे कहते हैं, "कोई तर्क के साथ, के बाद या आसपास पिछले लिस्टिंग दस अधिक लाइनों की सूची.

579
00:47:43,870 --> 00:47:47,920
सूची के पहले दस लाइनों सूचियों -

580
00:47:47,920 --> 00:47:52,960
तो चलो सूची ऋण का उपयोग करने की कोशिश.

581
00:47:52,960 --> 00:47:57,000
और कहा कि 10 लाइनों पिछले सूची बद्ध करता है, आप के आसपास की सूची के साथ एक छोटा सा खेल सकते हैं.

582
00:47:57,000 --> 00:48:02,330
आप सूची, सूची कर सकते हैं, आप भी सूची एक नंबर दे सकते हैं और 8 सूची की तरह,

583
00:48:02,330 --> 00:48:07,500
और यह 8 रेखा के आसपास 10 लाइनों को सूचीबद्ध करेंगे.

584
00:48:07,500 --> 00:48:10,290
और तुम यहाँ क्या हो रहा है देखने के लिए आप एक और अगर सरल मिल गया है सकते हैं.

585
00:48:10,290 --> 00:48:13,980
यदि आप CS50 चट्टानों में टाइप करते हैं, यह बाहर प्रिंट "आप एक ए मिलता है"

586
00:48:13,980 --> 00:48:16,530
अन्यथा यह बाहर प्रिंट "आप एक डी."

587
00:48:16,530 --> 00:48:23,770
Bummer शहर. सही सभी. हाँ?

588
00:48:23,770 --> 00:48:26,730
>> [डैनियल] तो, जब मैं उद्धरणों के बिना CS50 चट्टानों करने की कोशिश की

589
00:48:26,730 --> 00:48:29,290
यह कहते हैं, "आप एक डी."

590
00:48:29,290 --> 00:48:32,560
मैं उद्धरण की जरूरत के लिए यह काम करने के लिए मिलता है, ऐसा क्यों है?

591
00:48:32,560 --> 00:48:38,490
>> हाँ. यह पता चला है कि जब - यह एक और मजेदार छोटे से tidbit है -

592
00:48:38,490 --> 00:48:47,900
, जब आप प्रोग्राम चलाने के लिए, अगर हम इसे चलाने के लिए और हम CS50 चट्टानों में टाइप

593
00:48:47,900 --> 00:48:50,800
बस की तरह डैनियल कह रहा था वह किया था, और आप हिट दर्ज करें,

594
00:48:50,800 --> 00:48:52,870
यह अभी भी कहते हैं, हम एक डी.

595
00:48:52,870 --> 00:48:55,580
और सवाल है, ऐसा क्यों है?

596
00:48:55,580 --> 00:49:02,120
और यह पता चला है कि हमारे दोनों टर्मिनल और GDB इन दो अलग - अलग तर्क के रूप में व्याकरण के नियमों के अनुसार या व्याकरण सम्मत (शब्द की) व्याख्या करना.

597
00:49:02,120 --> 00:49:04,800
जब वहाँ एक अंतरिक्ष, के रूप में निहित है, क्योंकि

598
00:49:04,800 --> 00:49:08,730
पहले तर्क समाप्त हो गया, अगले तर्क शुरू करने के बारे में है.

599
00:49:08,730 --> 00:49:13,260
उन दो में गठबंधन तरीका है, या माफ करना, एक बहस में,

600
00:49:13,260 --> 00:49:18,510
उद्धरण का उपयोग करने के लिए है.

601
00:49:18,510 --> 00:49:29,560
तो अब, अगर हम यह उद्धरण में डाल दिया है और इसे फिर से चलाने के लिए, हम एक ए

602
00:49:29,560 --> 00:49:38,780
तो बस संक्षिप्त करने के लिए, कोई उद्धरण, CS50 और चट्टानों के रूप में दो अलग - अलग तर्क विश्लेषित कर रहे हैं.

603
00:49:38,780 --> 00:49:45,320
उद्धरण के साथ, यह एक तर्क के रूप में पूरी तरह पार्स है.

604
00:49:45,320 --> 00:49:53,070
>> हम एक breakpoint के साथ देख सकते हैं.

605
00:49:53,070 --> 00:49:54,920
अब तक हम अपने कार्यक्रम चल रहा है, और यह चल रहा है

606
00:49:54,920 --> 00:49:58,230
या तो यह दोष या हिट एक त्रुटि seg तक

607
00:49:58,230 --> 00:50:05,930
या जब तक यह exited और सभी पूरी तरह से ठीक हो गया है.

608
00:50:05,930 --> 00:50:08,360
यह जरूरी सबसे उपयोगी बात नहीं है, क्योंकि कभी कभी

609
00:50:08,360 --> 00:50:11,840
आप अपने प्रोग्राम में एक त्रुटि है, लेकिन यह एक विभाजन गलती नहीं पैदा कर रहा है.

610
00:50:11,840 --> 00:50:16,950
यह अपने कार्यक्रम को रोकने के लिए या ऐसा कुछ नहीं पैदा कर रहा है.

611
00:50:16,950 --> 00:50:20,730
एक खास बिंदु पर थामने के लिए GDB अपने कार्यक्रम के लिए रास्ता

612
00:50:20,730 --> 00:50:23,260
एक breakpoint सेट है.

613
00:50:23,260 --> 00:50:26,520
आप या तो एक समारोह के नाम पर एक breakpoint स्थापित करके यह कर सकता

614
00:50:26,520 --> 00:50:30,770
या आप कोड की एक विशेष लाइन पर एक breakpoint सेट कर सकते हैं.

615
00:50:30,770 --> 00:50:34,450
मैं समारोह के नाम पर breakpoints सेट की तरह है, क्योंकि याद करने के लिए आसान है,

616
00:50:34,450 --> 00:50:37,700
और अगर आप वास्तव में जाने के लिए और एक छोटा सा अपने स्रोत कोड बदलने,

617
00:50:37,700 --> 00:50:42,020
तो अपने breakpoint वास्तव में अपने कोड के भीतर एक ही जगह पर रहना होगा.

618
00:50:42,020 --> 00:50:44,760
जबकि अगर आप पंक्ति संख्या का उपयोग कर रहे हैं, और लाइन नंबर बदलने

619
00:50:44,760 --> 00:50:51,740
क्योंकि आप जोड़ने या कुछ कोड को नष्ट करने के लिए, तो आपके breakpoints पूरी तरह से कर रहे हैं बँधा हुआ.

620
00:50:51,740 --> 00:50:58,590
सबसे आम बातें मैं मुख्य समारोह पर एक ब्रेकपाइंट सेट कर दिया जाता है.

621
00:50:58,590 --> 00:51:05,300
अक्सर मैं GDB बूट हूँ, मैं ख मुख्य लिखें, हिट दर्ज करें, और कि एक breakpoint निर्धारित करेंगे

622
00:51:05,300 --> 00:51:10,630
मुख्य समारोह जो सिर्फ कहते हैं, "कार्यक्रम के रूप में जल्द ही के रूप में आप चल रहा शुरू रोकें",

623
00:51:10,630 --> 00:51:17,960
और कहा कि इस तरह, जब मैं कहता हूँ, साथ CS50 चट्टानों के रूप में अपने कार्यक्रम चलाने के लिए दो तर्कों

624
00:51:17,960 --> 00:51:24,830
और हिट दर्ज करें, यह मुख्य समारोह के लिए हो जाता है और यह सही बहुत पहली पंक्ति में बंद हो जाता है,

625
00:51:24,830 --> 00:51:30,620
सही से पहले यह strcmp समारोह का मूल्यांकन किया जाता है.

626
00:51:30,620 --> 00:51:34,940
>> चूंकि मैं रुका हुआ हूँ, अब मैं आसपास mucking शुरू कर सकते हैं और देख रहा है क्या हो रहा है

627
00:51:34,940 --> 00:51:40,250
सभी विभिन्न चर कि मेरे कार्यक्रम में पारित कर रहे हैं की साथ.

628
00:51:40,250 --> 00:51:43,670
यहाँ मैं बाहर argc मुद्रित करने के लिए कर सकते हैं और देखने के लिए क्या हो रहा है.

629
00:51:43,670 --> 00:51:50,030
देखें कि argc 3 है, क्योंकि यह 3 भिन्न मान मिला है.

630
00:51:50,030 --> 00:51:54,060
यह प्रोग्राम का नाम है, यह पहला तर्क और दूसरा तर्क मिल गया है.

631
00:51:54,060 --> 00:52:09,330
हम उन argv में देख कर बाहर मुद्रित कर सकते हैं [0] argv [1], और argv [2]

632
00:52:09,330 --> 00:52:12,030
तो अब आप भी क्यों इस strcmp कॉल करने के लिए असफल हो रहा है और देख सकते हैं,

633
00:52:12,030 --> 00:52:21,650
क्योंकि आप देखते हैं कि यह दो अलग - अलग तर्क में CS50 चट्टानों विभाजित किया था.

634
00:52:21,650 --> 00:52:27,250
इस बिंदु पर, एक बार आप एक breakpoint मारा है, तो आप अपने कार्यक्रम के माध्यम से कदम जारी रख सकते हैं

635
00:52:27,250 --> 00:52:32,920
लाइन से लाइन, के रूप में अपने कार्यक्रम को फिर से शुरू करने का विरोध किया.

636
00:52:32,920 --> 00:52:35,520
तो अगर आप अपने कार्यक्रम को फिर से और बस शुरू नहीं करना चाहता है यहाँ से जारी रखने के लिए,

637
00:52:35,520 --> 00:52:41,970
आप जारी रखने के आदेश का उपयोग कर सकते हैं और कार्यक्रम को समाप्त करने के लिए चलाने के लिए जारी रहेगा.

638
00:52:41,970 --> 00:52:45,010
बस इसे यहाँ किया.

639
00:52:45,010 --> 00:52:54,880
हालांकि, अगर मैं कार्यक्रम, CS50 चट्टानों को पुनः आरंभ करने के लिए, यह मेरे ब्रेकपाइंट फिर हिट,

640
00:52:54,880 --> 00:52:59,670
और इस बार, अगर मैं सिर्फ कार्यक्रम के बाकी के माध्यम से सभी तरह से जाना नहीं चाहते हो,

641
00:52:59,670 --> 00:53:08,040
मैं अगले आदेश, जो मैं भी n के साथ संक्षिप्त का उपयोग कर सकते हैं.

642
00:53:08,040 --> 00:53:12,960
और इस कार्यक्रम लाइन के माध्यम से लाइन से कदम होगा.

643
00:53:12,960 --> 00:53:17,530
तो आप के रूप में चीजों को निष्पादित करने के लिए घड़ी के रूप में चर परिवर्तन कर सकते हैं, के रूप में बातें अद्यतन मिलता है.

644
00:53:17,530 --> 00:53:21,550
जो बहुत अच्छा है.

645
00:53:21,550 --> 00:53:26,570
अन्य शांत बात के बजाय और अधिक और अधिक से अधिक एक ही कमांड फिर दोहरा है,

646
00:53:26,570 --> 00:53:30,670
अगर तुम सिर्फ हिट दर्ज करें तो यहाँ आप देखने के लिए मैं कुछ भी नहीं टाइप किया है -

647
00:53:30,670 --> 00:53:33,780
अगर मैं सिर्फ हिट दर्ज करें, यह पिछले आदेश दोहराना होगा,

648
00:53:33,780 --> 00:53:36,900
या पिछले GDB आदेश है कि मैं बस के अंदर डाल

649
00:53:36,900 --> 00:53:56,000
मैं दर्ज मार रखने कर सकते हैं और यह मेरे कोड लाइन द्वारा लाइन के माध्यम से कदम रख सकते हैं.

650
00:53:56,000 --> 00:53:59,310
मैं तुम लोगों को बाहर अन्य छोटी गाड़ी कार्यक्रम की जांच के रूप में अच्छी तरह से जाने के लिए प्रोत्साहित करेगा.

651
00:53:59,310 --> 00:54:01,330
हम उनमें से आज अनुभाग में सभी के माध्यम से प्राप्त करने के लिए समय नहीं है.

652
00:54:01,330 --> 00:54:05,890
स्रोत कोड है, तो आप देखते हैं क्या हो रहा है की तरह कर सकते हैं

653
00:54:05,890 --> 00:54:07,730
अगर तुम सच में अटक जाते हैं दृश्यों के पीछे,

654
00:54:07,730 --> 00:54:11,940
लेकिन बहुत कम से कम अभी तक GDB बूटिंग अभ्यास,

655
00:54:11,940 --> 00:54:13,940
कार्यक्रम चल रहा है जब तक आप इसे पर टूटता है,

656
00:54:13,940 --> 00:54:18,260
बैकट्रैस हो रही है, पता लगाना क्या समारोह दुर्घटना में था,

657
00:54:18,260 --> 00:54:24,450
क्या यह लाइन पर था, बाहर कुछ चर मान छपाई,

658
00:54:24,450 --> 00:54:30,140
अभी तो आप इसके लिए एक महसूस हो, कि क्योंकि वास्तव में आप आगे जाने में मदद मिलेगी.

659
00:54:30,140 --> 00:54:36,340
इस बिंदु पर, हम GDB के बाहर छोड़ दिया है, जो तुम छोड़ दिया है का उपयोग कर या बस क्ष करने के लिए जा रहे हैं.

660
00:54:36,340 --> 00:54:40,460
यदि आपके कार्यक्रम अभी भी चल रहा है के बीच में है, और यह नहीं exited है,

661
00:54:40,460 --> 00:54:43,510
यह हमेशा आप से पूछना होगा, "क्या आप सुनिश्चित करें कि आप वास्तव में छोड़ने के लिए चाहते हैं?"

662
00:54:43,510 --> 00:54:48,770
आप सिर्फ हाँ हिट कर सकते हैं.

663
00:54:48,770 --> 00:54:55,250
>> अब हम अगले समस्या है, हम जो बिल्ली कार्यक्रम है को देखने के लिए जा रहे हैं.

664
00:54:55,250 --> 00:54:59,880
यदि आप पुनः निर्देशित कर और पाइप पर कम देखो, तो आप देखेंगे कि टॉमी इस कार्यक्रम का उपयोग करता है

665
00:54:59,880 --> 00:55:07,540
है कि मूल रूप से स्क्रीन के लिए एक फ़ाइल के सभी उत्पादन प्रिंट.

666
00:55:07,540 --> 00:55:12,660
तो अगर मैं बिल्ली चलाते हैं, तो यह वास्तव में एक कार्यक्रम में निर्मित उपकरण को,

667
00:55:12,660 --> 00:55:16,860
और अगर आप एमएसीएस है आप अपने मैक पर यह भी कर सकते हैं, अगर आप टर्मिनल खोलने.

668
00:55:16,860 --> 00:55:25,630
और हम बिल्ली - चलो कहते हैं, cp.c, और हिट दर्ज करें.

669
00:55:25,630 --> 00:55:29,640
यह क्या किया है, अगर हम एक छोटा सा और देखने के लिए जहां हम लाइन भागा,

670
00:55:29,640 --> 00:55:40,440
या जहाँ हम बिल्ली आदेश दौड़ा, यह सचमुच सिर्फ बाहर हमारे स्क्रीन पर मुद्रित की सामग्री cp.c.

671
00:55:40,440 --> 00:55:44,140
हम इसे फिर से चलाने के लिए और कर सकते हैं आप एकाधिक फ़ाइलों में एक साथ रख सकते हैं.

672
00:55:44,140 --> 00:55:49,880
तो आप बिल्ली cp.c करते हैं, और कर सकते हैं तो हम भी cat.c फ़ाइल जोड़ना कर सकते हैं,

673
00:55:49,880 --> 00:55:53,250
जो हम कर रहे हैं के बारे में लिखने के कार्यक्रम है,

674
00:55:53,250 --> 00:55:58,140
और यह दोनों फाइलों को वापस मुद्रित करने के लिए हमारे स्क्रीन पर वापस करेंगे.

675
00:55:58,140 --> 00:56:05,490
तो अगर हम एक छोटा सा, हम देखते हैं कि जब हम इस बिल्ली cp.c, cat.c भागा,

676
00:56:05,490 --> 00:56:17,110
पहली बार इसे सी.पी. फ़ाइल मुद्रित, और फिर, यह नीचे यह बाहर cat.c फ़ाइल मुद्रित सही यहाँ नीचे.

677
00:56:17,110 --> 00:56:19,650
हम इस प्रयोग को सिर्फ हमारे पैरों को गीला करने के लिए जा रहे हैं.

678
00:56:19,650 --> 00:56:25,930
टर्मिनल के लिए सरल मुद्रण के साथ खेलने के आसपास देखने के लिए, यह कैसे काम करता है.

679
00:56:25,930 --> 00:56:39,170
अगर आप लोग जीएडिट cat.c के साथ खुला, हिट दर्ज करें,

680
00:56:39,170 --> 00:56:43,760
आप प्रोग्राम है कि हम लिखने के बारे में कर रहे हैं देख सकते हैं.

681
00:56:43,760 --> 00:56:48,980
हम यह अच्छा बॉयलर प्लेट को शामिल किया है, इसलिए, हम है कि सभी बाहर टाइपिंग के लिए समय बिताने के लिए नहीं है.

682
00:56:48,980 --> 00:56:52,310
हम भी तर्कों की संख्या की जांच अंदर पारित कर दिया

683
00:56:52,310 --> 00:56:56,910
हम बाहर एक अच्छा प्रयोग संदेश मुद्रित.

684
00:56:56,910 --> 00:57:00,950
>> यह बात यह है कि, फिर से, जैसे हम के बारे में बात कर रहा है की तरह है,

685
00:57:00,950 --> 00:57:04,490
यह मांसपेशियों की स्मृति की तरह लगभग है.

686
00:57:04,490 --> 00:57:07,190
बस के लिए सामान की एक ही प्रकार के कर याद रखना

687
00:57:07,190 --> 00:57:11,310
और हमेशा उपयोगी संदेश के कुछ प्रकार के मुद्रण

688
00:57:11,310 --> 00:57:17,670
इतना है कि लोगों को पता है कि कैसे अपने कार्यक्रम चलाने के लिए.

689
00:57:17,670 --> 00:57:21,630
बिल्ली के साथ, यह बहुत आसान है, हम सिर्फ अलग तर्क के सभी के माध्यम से जा रहे हैं

690
00:57:21,630 --> 00:57:24,300
कि हमारे कार्यक्रम के लिए पारित किया गया है, और हम मुद्रण के लिए जा रहे हैं

691
00:57:24,300 --> 00:57:29,950
एक समय में एक स्क्रीन उनके बाहर सामग्री.

692
00:57:29,950 --> 00:57:35,670
आदेश में फ़ाइलों को मुद्रित करने के लिए स्क्रीन से बाहर है, हम बहुत कुछ इसी तरह करने के लिए जा रहे हैं

693
00:57:35,670 --> 00:57:38,120
के लिए हम क्या प्रश्नोत्तरी के अंत में किया था.

694
00:57:38,120 --> 00:57:45,350
प्रश्नोत्तरी, कि कार्यक्रम किराया के अंत में, हम करने के लिए एक फ़ाइल खोलने था,

695
00:57:45,350 --> 00:57:48,490
और फिर हम यह करने के लिए प्रिंट था.

696
00:57:48,490 --> 00:57:54,660
इस मामले में, हम करने के लिए एक फ़ाइल खोलने जा रहे हैं, और हम इसे से बजाय पढ़ने के लिए जा रहे हैं.

697
00:57:54,660 --> 00:58:00,630
फिर हम एक फाइल करने के बजाय प्रिंट लिए जा रहे हैं, हम करने के लिए स्क्रीन पर मुद्रित करने के लिए जा रहे हैं.

698
00:58:00,630 --> 00:58:05,830
तो स्क्रीन आप सभी printf साथ पहले किया मुद्रण.

699
00:58:05,830 --> 00:58:08,290
तो वह भी पागल नहीं है.

700
00:58:08,290 --> 00:58:12,190
लेकिन एक फ़ाइल को पढ़ने में अजीब तरह का है.

701
00:58:12,190 --> 00:58:17,300
हम यह है कि एक छोटा सा के माध्यम से एक समय में जाना होगा.

702
00:58:17,300 --> 00:58:20,560
यदि आप लोगों कि पिछले समस्या के लिए वापस अपने प्रश्नोत्तरी, 33 समस्या पर जाना है,

703
00:58:20,560 --> 00:58:27,280
पहली पंक्ति है कि हम यहाँ क्या करने जा रहे हैं, फ़ाइल खोलने, हम वहाँ क्या किया था के लिए इसी तरह की है.

704
00:58:27,280 --> 00:58:36,370
स्टेला तो, क्या की तरह है, जब हम एक फ़ाइल खोलने कि लाइन दिखती है?

705
00:58:36,370 --> 00:58:47,510
[स्टेला] कैपिटल फ़ाइल *, फ़ाइल - >> ठीक है. >> Fopen के बराबर है. >> हाँ.

706
00:58:47,510 --> 00:58:55,980
इस मामले में कौन सा है? यह टिप्पणी में है.

707
00:58:55,980 --> 00:59:06,930
>> यह टिप्पणी में है? argv [i] और r?

708
00:59:06,930 --> 00:59:11,300
वास्तव में. >> ठीक है. तो स्टेला पूरी तरह से सही है.

709
00:59:11,300 --> 00:59:13,720
यह क्या लाइन की तरह लग रहा है.

710
00:59:13,720 --> 00:59:19,670
हम एक फ़ाइल स्ट्रीम चर प्राप्त करने के लिए, यह एक फ़ाइल * में स्टोर करने के लिए जा रहे हैं, तो सभी टोपियां,

711
00:59:19,670 --> 00:59:25,720
फ़ाइल, *, और इस चर के नाम फाइल किया जाएगा.

712
00:59:25,720 --> 00:59:32,250
हम इसे कहते हैं कि जो कुछ भी हम जैसे हो सकता है. हम यह first_file, या file_i, जो कुछ भी हम चाहते हैं कह सकते हैं.

713
00:59:32,250 --> 00:59:37,590
और फिर फ़ाइल का नाम कमांड लाइन पर इस कार्यक्रम के लिए पारित किया गया था.

714
00:59:37,590 --> 00:59:44,450
तो यह argv में संग्रहित है [i] और फिर हम पढ़ने के मोड में इस फाइल को खोलने जा रहे हैं.

715
00:59:44,450 --> 00:59:48,100
अब है कि हम फ़ाइल को खोल दिया है, क्या बात है कि हम हमेशा के लिए याद है

716
00:59:48,100 --> 00:59:52,230
जब भी हम एक फ़ाइल खोल दिया है? इसे बंद करो.

717
00:59:52,230 --> 00:59:57,220
तो Missy, कैसे हम एक फ़ाइल बंद करते हैं?

718
00:59:57,220 --> 01:00:01,020
[Missy] fclose (फाइल) >> fclose (फ़ाइल). बिल्कुल सही.

719
01:00:01,020 --> 01:00:05,340
बढ़िया है. ठीक है. यदि हम इस पर देखने के लिए टिप्पणी करना ठीक है यहाँ,

720
01:00:05,340 --> 01:00:11,940
इसे कहते हैं, "ओपन argv [i] और stdout के लिए अपनी सामग्री मुद्रित करने के लिए."

721
01:00:11,940 --> 01:00:15,460
>> मानक बाहर एक अजीब नाम है. Stdout सिर्फ इतना कह का हमारा तरीका है

722
01:00:15,460 --> 01:00:22,880
हम यह टर्मिनल मुद्रित करना चाहते हैं, हम यह मानक निर्गम धारा मुद्रित करना चाहते हैं.

723
01:00:22,880 --> 01:00:26,450
हम वास्तव में इस टिप्पणी से छुटकारा मिल सकता है यहाँ.

724
01:00:26,450 --> 01:00:36,480
मैं इसे कॉपी और पेस्ट के बाद से है कि हम क्या किया है के लिए जा रहा हूँ.

725
01:00:36,480 --> 01:00:41,290
इस बिंदु पर, अब हम बिट द्वारा फ़ाइल थोड़ा पढ़ा है.

726
01:00:41,290 --> 01:00:46,300
हम पढ़ने फ़ाइलों के तरीके के एक जोड़े पर चर्चा की है.

727
01:00:46,300 --> 01:00:51,830
जो लोगों को अपने पसंदीदा अब तक कर रहे हैं?

728
01:00:51,830 --> 01:00:57,960
तरीके जो आप या देखा है क्या तुम्हें याद है, फ़ाइलों को पढ़ने?

729
01:00:57,960 --> 01:01:04,870
[डैनियल] fread? Fread? >> Fread तो एक है. जिमी, तो आप किसी भी अन्य लोगों को जानते हो?

730
01:01:04,870 --> 01:01:12,150
[जिमी] नहीं >> ठीक है. नहीं. Charlotte? अलेक्जेंडर? किसी भी दूसरों? ठीक है.

731
01:01:12,150 --> 01:01:20,740
तो अन्य लोगों fgetc हैं, एक है कि हम एक बहुत इस्तेमाल करेंगे है.

732
01:01:20,740 --> 01:01:26,410
वहाँ भी fscanf, तुम लोगों को एक पैटर्न यहाँ देखें?

733
01:01:26,410 --> 01:01:29,170
वे सब च के साथ शुरू करते हैं. एक फ़ाइल के साथ क्या करने के लिए कुछ भी.

734
01:01:29,170 --> 01:01:35,260
वहाँ fread है, fgetc, fscanf. ये पढ़ने के कार्यों के सभी कर रहे हैं.

735
01:01:35,260 --> 01:01:49,120
हम fwrite है लेखन के लिए, हम fgetc के बजाय fputc है.

736
01:01:49,120 --> 01:01:58,250
हम भी fprintf की तरह हम प्रश्नोत्तरी पर देखा.

737
01:01:58,250 --> 01:02:01,680
चूंकि यह एक समस्या यह है कि एक फ़ाइल से पढ़ने शामिल है,

738
01:02:01,680 --> 01:02:04,940
हम इन तीन कार्यों में से एक का उपयोग करने के लिए जा रहे हैं.

739
01:02:04,940 --> 01:02:10,890
हम यहाँ नीचे इन कार्यों का उपयोग करने के लिए नहीं जा रहे हैं.

740
01:02:10,890 --> 01:02:14,880
इन कार्यों के सभी मानक पुस्तकालय मैं / हे में पाए जाते हैं.

741
01:02:14,880 --> 01:02:17,510
तो अगर आप इस कार्यक्रम के शीर्ष पर देखो,

742
01:02:17,510 --> 01:02:24,110
आप देख सकते हैं कि हम पहले से ही मानक पुस्तकालय मैं / ओ के लिए हेडर फाइल शामिल है.

743
01:02:24,110 --> 01:02:27,120
यदि हम यह पता लगाने चाहते हैं जो हम एक का उपयोग करना चाहते हैं,

744
01:02:27,120 --> 01:02:29,690
हम हमेशा मैन पेज खोल सकते हैं.

745
01:02:29,690 --> 01:02:34,350
तो हम आदमी stdio टाइप कर सकते हैं

746
01:02:34,350 --> 01:02:43,180
और stdio और सी में इनपुट, आउटपुट कार्य के बारे में पढ़ा

747
01:02:43,180 --> 01:02:49,870
और हम पहले से ही देख ओह देखो, कर सकते हैं. यह fgetc उल्लेख है, यह fputc उल्लेख है.

748
01:02:49,870 --> 01:02:57,220
तो आप नीचे एक छोटा सा ड्रिल कर सकते हैं और को देखो, कहते हैं, fgetc

749
01:02:57,220 --> 01:03:00,060
और इसके मैन पेज को देखो.

750
01:03:00,060 --> 01:03:03,430
आप देख सकते हैं कि यह अन्य कार्यों की एक पूरी गुच्छा के साथ चला जाता है:

751
01:03:03,430 --> 01:03:12,640
fgetc, fgets, जीइ टीसी, getchar हो जाता है, ungetc, और वर्ण और तार के अपने इनपुट.

752
01:03:12,640 --> 01:03:19,180
तो यह है कि हम मानक इनपुट से फाइलों से अक्षर और तार में पढ़ा,

753
01:03:19,180 --> 01:03:21,990
जो उपयोगकर्ता से अनिवार्य रूप से है.

754
01:03:21,990 --> 01:03:24,780
और यह है कि हम इसे वास्तविक सी में

755
01:03:24,780 --> 01:03:30,850
तो यह GetString और getchar कार्यों का उपयोग नहीं कर रहा है

756
01:03:30,850 --> 01:03:36,840
कि हम CS50 पुस्तकालय से इस्तेमाल किया.

757
01:03:36,840 --> 01:03:39,710
हम तरीके के एक जोड़े में इस समस्या को करने जा रहे हैं

758
01:03:39,710 --> 01:03:43,430
इतनी है कि आप इसे करने के दो अलग अलग तरीकों से देख सकते हैं.

759
01:03:43,430 --> 01:03:48,490
दोनों fread समारोह कि डैनियल उल्लेख किया और fgetc अच्छे तरीके से ऐसा कर रहे हैं.

760
01:03:48,490 --> 01:03:53,790
मुझे लगता है कि fgetc थोड़ा आसान है, क्योंकि यह ही है, जैसा कि आप देख,

761
01:03:53,790 --> 01:03:59,660
एक तर्क है, फ़ाइल * कि हम चरित्र से पढ़ने की कोशिश कर रहे हैं,

762
01:03:59,660 --> 01:04:02,740
और अपनी वापसी के मूल्य एक int है.

763
01:04:02,740 --> 01:04:05,610
और यह एक छोटे से भ्रामक है, सही है?

764
01:04:05,610 --> 01:04:11,450
>> क्योंकि हम एक चरित्र हो रही है, तो क्यों इस वापसी चार नहीं करता है?

765
01:04:11,450 --> 01:04:18,700
तुम लोग क्यों यह एक चार वापस नहीं हो सकता है पर कोई विचार है?

766
01:04:18,700 --> 01:04:25,510
[Missy जवाब, unintelligible] >> हाँ. तो Missy पूरी तरह से सही है.

767
01:04:25,510 --> 01:04:31,570
यदि यह ASCII है, तो इस पूर्णांक एक वास्तविक चार को मैप किया जा सकता है.

768
01:04:31,570 --> 01:04:33,520
एक ASCII वर्ण हो सकता है, और यह सही है.

769
01:04:33,520 --> 01:04:36,220
यह वास्तव में क्या हो रहा है.

770
01:04:36,220 --> 01:04:39,190
हम एक int का उपयोग कर रहे हैं बस, क्योंकि यह अधिक बिट्स है.

771
01:04:39,190 --> 01:04:44,750
यह एक चार से भी बड़ा है, हमारे चार केवल 8 बिट है कि हमारे 32 बिट मशीनों पर 1 बाइट.

772
01:04:44,750 --> 01:04:48,520
और एक int सभी 4 बाइट्स 'अंतरिक्ष के लायक है.

773
01:04:48,520 --> 01:04:50,940
और यह पता चला है कि जिस तरह से fgetc काम करता है,

774
01:04:50,940 --> 01:04:53,940
, अगर हम अपने सार में इस आदमी को एक छोटा सा पृष्ठ में नीचे स्क्रॉल

775
01:04:53,940 --> 01:05:05,000
सभी तरह से नीचे स्क्रॉल. यह पता चला है कि वे इस विशेष EOF बुलाया मूल्य का उपयोग करें.

776
01:05:05,000 --> 01:05:09,640
यह fgetc समारोह की वापसी मूल्य के रूप में एक विशेष निरंतर

777
01:05:09,640 --> 01:05:14,570
जब भी आप फ़ाइल के अंत हिट या अगर आपको कोई त्रुटि मिलती.

778
01:05:14,570 --> 01:05:18,170
और यह पता चला है कि EOF साथ इन तुलना करने के लिए ठीक है,

779
01:05:18,170 --> 01:05:24,060
आप एक int में जानकारी की है कि अतिरिक्त राशि है कि आप चाहते हैं

780
01:05:24,060 --> 01:05:28,420
के रूप में एक चार चर का उपयोग करने का विरोध किया.

781
01:05:28,420 --> 01:05:32,130
हालांकि fgetc प्रभावी रूप से एक फ़ाइल से एक चरित्र हो रही है,

782
01:05:32,130 --> 01:05:38,450
आप को याद है कि यह कुछ है कि int प्रकार आप के लिए है लौट रहा है चाहते हैं.

783
01:05:38,450 --> 01:05:41,360
उस ने कहा, यह काफी का उपयोग करने के लिए आसान है.

784
01:05:41,360 --> 01:05:44,960
यह हमें एक चरित्र देने के लिए जा रहा है, तो हम सभी को करना है फ़ाइल पूछते रहते हैं,

785
01:05:44,960 --> 01:05:48,440
"मुझे अगले चरित्र दे दो, मुझे अगले चरित्र दे, मुझे अगले चरित्र दे,

786
01:05:48,440 --> 01:05:51,400
जब तक हम फ़ाइल का अंत करने के लिए मिलता है.

787
01:05:51,400 --> 01:05:54,730
और कहा कि हमारे फ़ाइल से एक समय में एक चरित्र में खींच जाएगा,

788
01:05:54,730 --> 01:05:56,250
और फिर हम क्या कर सकते हैं जो कुछ भी हम इसके साथ पसंद है.

789
01:05:56,250 --> 01:06:00,160
हम इसे स्टोर कर सकते हैं, हम इसे एक स्ट्रिंग के लिए जोड़ने के लिए, हम इसे बाहर प्रिंट कर सकते हैं कर सकते हैं.

790
01:06:00,160 --> 01:06:04,630
कि किसी भी मत करो.

791
01:06:04,630 --> 01:06:09,600
>> वापस Zooming बाहर और हमारे cat.c कार्यक्रम के लिए वापस जा रहा,

792
01:06:09,600 --> 01:06:16,170
अगर हम fgetc का उपयोग करने के लिए जा रहे हैं,

793
01:06:16,170 --> 01:06:21,710
हम कैसे कोड के इस अगली पंक्ति दृष्टिकोण हो सकता है?

794
01:06:21,710 --> 01:06:26,020
हम प्रयोग करने जा रहे हैं - fread कुछ अलग करना होगा.

795
01:06:26,020 --> 01:06:32,600
और इस समय हम सिर्फ fgetc का उपयोग करने के लिए एक समय में एक चरित्र पाने के लिए जा रहे हैं.

796
01:06:32,600 --> 01:06:40,910
एक पूरे फ़ाइल प्रक्रिया है, हम क्या करने के लिए क्या हो सकता है?

797
01:06:40,910 --> 01:06:44,030
कितने वर्ण एक फ़ाइल में हैं?

798
01:06:44,030 --> 01:06:47,390
वहाँ एक बहुत कुछ कर रहे हैं. तो आप शायद एक पाने के लिए करना चाहते हैं

799
01:06:47,390 --> 01:06:49,860
और फिर एक और पाने के लिए और एक और पाने के लिए और एक अन्य मिल.

800
01:06:49,860 --> 01:06:53,330
एल्गोरिथ्म की तरह तुम्हें क्या लगता है हम यहाँ का उपयोग करने के लिए हो सकता है?

801
01:06:53,330 --> 01:06:55,470
किस तरह का है? [अलेक्जेंडर] एक पाश के लिए? वास्तव में. >>

802
01:06:55,470 --> 01:06:57,500
लूप के कुछ प्रकार.

803
01:06:57,500 --> 01:07:03,380
पाश के लिए इस मामले में वास्तव में महान है.

804
01:07:03,380 --> 01:07:08,620
और तुम कह रहे थे की तरह, यह लगता है जैसे आप पूरे फ़ाइल पर एक पाश चाहते,

805
01:07:08,620 --> 01:07:11,820
एक समय में एक चरित्र हो रही है.

806
01:07:11,820 --> 01:07:13,850
क्या पर कोई सुझाव है कि तरह लग सकता है?

807
01:07:13,850 --> 01:07:22,090
[अलेक्जेंडर, unintelligible]

808
01:07:22,090 --> 01:07:30,050
>> ठीक है, मुझे अंग्रेजी में बताओ कि तुम क्या करने की कोशिश कर रहे हैं? [अलेक्जेंडर, unintelligible]

809
01:07:30,050 --> 01:07:36,270
तो इस मामले में, ऐसा लगता है जैसे हम सिर्फ पूरे फ़ाइल पर पाश करने के लिए कोशिश कर रहे हैं.

810
01:07:36,270 --> 01:07:45,330
[अलेक्जेंडर] तो मैं <int के आकार? >> का आकार -?

811
01:07:45,330 --> 01:07:49,290
मैं फाइल के आकार को सही लगता है? आकार - we'll बस इसे इस तरह से लिख.

812
01:07:49,290 --> 01:07:57,470
फ़ाइल के समय के लिए आकार में किया जा रहा है, मैं + +.

813
01:07:57,470 --> 01:08:04,610
तो यह पता चला है कि जिस तरह से आप इस fgetc का उपयोग करते हैं, और यह नया है,

814
01:08:04,610 --> 01:08:10,460
यह है कि वहाँ कोई आसान करने के लिए सिर्फ एक फ़ाइल के आकार पाने के लिए रास्ता है

815
01:08:10,460 --> 01:08:16,979
निर्माण कि आप पहले देखा है के इस "sizeof" प्रकार के साथ.

816
01:08:16,979 --> 01:08:20,910
जब हम उस fgetc समारोह का उपयोग करें, हम किसी तरह की शुरू कर रहे हैं

817
01:08:20,910 --> 01:08:29,069
नया, पाश के लिए इस कायरता वाक्यविन्यास, जहां सिर्फ एक बुनियादी काउंटर का उपयोग करने के बजाय

818
01:08:29,069 --> 01:08:33,920
चरित्र द्वारा चरित्र जाना है, हम एक समय में एक चरित्र खींचने के लिए जा रहे हैं,

819
01:08:33,920 --> 01:08:37,120
एक समय में एक चरित्र है, और जिस तरह से हम जानते हैं कि हम अंत में कर रहे हैं

820
01:08:37,120 --> 01:08:41,290
है जब हम अक्षरों की एक निश्चित संख्या में नहीं गिना है,

821
01:08:41,290 --> 01:08:49,939
लेकिन जब हम चरित्र बाहर खींच फ़ाइल चरित्र की है कि विशेष अंत है.

822
01:08:49,939 --> 01:08:58,689
इसलिए हम इस से कर सकते हैं - मैं इस चर्चा कहते हैं, और हम यह इनिशियलाइज़ करने के लिए जा रहे हैं

823
01:08:58,689 --> 01:09:08,050
हमारी पहली फ़ाइल से बाहर 1 चरित्र मिलता है कॉल के साथ.

824
01:09:08,050 --> 01:09:14,979
यह सही यहाँ हिस्सा तो, इस फ़ाइल का एक चरित्र बाहर ले जा रहा है

825
01:09:14,979 --> 01:09:20,840
और यह चर चर्चा में स्टोर.

826
01:09:20,840 --> 01:09:25,420
हम यह कर रखने के लिए जा रहे हैं जब तक हम फाइल के अंत करने के लिए,

827
01:09:25,420 --> 01:09:41,170
जो हम चरित्र के लिए परीक्षण किया जा रहा है कि विशेष EOF चरित्र के बराबर नहीं है.

828
01:09:41,170 --> 01:09:48,750
और फिर चर्चा कर के बजाय + +, जो बस मान वेतन वृद्धि चाहते हैं,

829
01:09:48,750 --> 01:09:52,710
यदि ऐसा है तो हम फ़ाइल की एक बाहर है, एक राजधानी कहते हैं, पढ़ा,

830
01:09:52,710 --> 01:09:56,810
चर्चा + + हमें दे ख होगा, और फिर हम ग और फिर घ मिलता था.

831
01:09:56,810 --> 01:09:59,310
यह स्पष्ट रूप से नहीं है कि हम क्या चाहते हैं. यहाँ हम क्या चाहते हैं

832
01:09:59,310 --> 01:10:05,830
इस अंतिम बिट में हम फ़ाइल से अगले वर्ण प्राप्त करना चाहते है.

833
01:10:05,830 --> 01:10:09,500
>> तो हम कैसे फ़ाइल से अगले चरित्र हो सकता है?

834
01:10:09,500 --> 01:10:13,470
हम कैसे फ़ाइल से 1 चरित्र मिलता है?

835
01:10:13,470 --> 01:10:17,200
[छात्र] fgetfile? Fgetc >>, या, माफ करना, तो आप पूरी तरह से सही थे.

836
01:10:17,200 --> 01:10:20,470
मैं इसे सही वहाँ गलत वर्तनी. तो हाँ.

837
01:10:20,470 --> 01:10:26,240
यहाँ चर्चा कर के बजाय + +,

838
01:10:26,240 --> 01:10:29,560
हम सिर्फ fgetc (फ़ाइल) फिर से फोन करने के लिए जा रहे हैं

839
01:10:29,560 --> 01:10:39,180
और हमारे एक ही चर्चा चर में परिणाम की दुकान.

840
01:10:39,180 --> 01:10:43,730
[छात्र सवाल है, unintelligible]

841
01:10:43,730 --> 01:10:52,390
>> यह है कि जहां इन फ़ाइल * लोग विशेष कर रहे हैं.

842
01:10:52,390 --> 01:10:59,070
जिस तरह से वे काम करते हैं वे है - जब आप पहली बार खुला जब आप पहली बार है कि fopen कॉल करते हैं,

843
01:10:59,070 --> 01:11:04,260
फ़ाइल * प्रभावी रूप से फ़ाइल की शुरुआत करने के लिए एक संकेत के रूप में कार्य करता है.

844
01:11:04,260 --> 01:11:12,830
और फिर हर बार जब आप fgetc कॉल, यह फाइल के माध्यम से एक चरित्र चाल.

845
01:11:12,830 --> 01:11:23,280
तो जब भी आप यह कहते हैं, आप एक चरित्र से फ़ाइल सूचक incrementing रहे हैं.

846
01:11:23,280 --> 01:11:26,210
और जब आप फिर fgetc, आप इसे एक और चरित्र आगे बढ़ रहे हैं

847
01:11:26,210 --> 01:11:28,910
और एक अन्य चरित्र और दूसरे चरित्र और एक अन्य चरित्र.

848
01:11:28,910 --> 01:11:32,030
[छात्र सवाल है, unintelligible] >> और that's - हाँ.

849
01:11:32,030 --> 01:11:34,810
यह हुड के तहत यह जादू की तरह है.

850
01:11:34,810 --> 01:11:37,930
आप बस के माध्यम से incrementing रखने.

851
01:11:37,930 --> 01:11:46,510
इस बिंदु पर, आप के लिए वास्तव में एक चरित्र के साथ काम करने में सक्षम हो.

852
01:11:46,510 --> 01:11:52,150
तो कैसे हम स्क्रीन करने के लिए इस बाहर प्रिंट सकता है अब?

853
01:11:52,150 --> 01:11:58,340
हम printf एक ही बात है कि हम पहले प्रयोग किया जाता का उपयोग कर सकते हैं.

854
01:11:58,340 --> 01:12:00,330
कि हम सभी सेमेस्टर का उपयोग किया गया.

855
01:12:00,330 --> 01:12:05,450
हम printf कॉल कर सकते हैं,

856
01:12:05,450 --> 01:12:21,300
और हम ऐसे ही चरित्र में पारित कर सकते हैं.

857
01:12:21,300 --> 01:12:27,430
Printf का उपयोग कर और इस प्रारूप स्ट्रिंग होने के बजाय एक और तरीका यह करना है,

858
01:12:27,430 --> 01:12:29,490
हम भी एक अन्य कार्यों का उपयोग कर सकते हैं.

859
01:12:29,490 --> 01:12:40,090
हम fputc, जो स्क्रीन के एक चरित्र प्रिंट का उपयोग कर सकते हैं,

860
01:12:40,090 --> 01:12:52,580
अलावा अगर हम fputc को देखो - मुझे बाहर एक छोटा सा ज़ूम.

861
01:12:52,580 --> 01:12:56,430
हम देखते हैं कि क्या अच्छा है यह चरित्र में लेता है कि हम बाहर पढ़ने के fgetc का उपयोग कर,

862
01:12:56,430 --> 01:13:05,100
लेकिन फिर हम इसे एक मुद्रित करने के लिए धारा दे है.

863
01:13:05,100 --> 01:13:11,850
हम भी putchar समारोह का उपयोग कर सकते हैं, जो सीधे मानक बाहर रखा जाएगा.

864
01:13:11,850 --> 01:13:16,070
तो वहाँ विभिन्न विकल्प है कि हम मुद्रण के लिए उपयोग कर सकते हैं की एक पूरी गुच्छा हैं.

865
01:13:16,070 --> 01:13:19,580
वे मानक पुस्तकालय मैं / हे में सभी कर रहे हैं.

866
01:13:19,580 --> 01:13:25,150
जब भी आप मुद्रित करना चाहते हैं - तो printf डिफ़ॉल्ट रूप से, धारा बाहर विशेष मानक के लिए मुद्रित होगा,

867
01:13:25,150 --> 01:13:27,910
जो कि stdout है.

868
01:13:27,910 --> 01:13:41,300
तो हम सिर्फ इस जादू मान, यहाँ stdout की तरह के रूप में यह उल्लेख कर सकते हैं.

869
01:13:41,300 --> 01:13:48,410
उफ़! सेमीकोलन बाहर रखो.

870
01:13:48,410 --> 01:13:52,790
>> यह नया, यहाँ में कायरता जानकारी का एक बहुत कुछ है.

871
01:13:52,790 --> 01:13:58,600
यह एक बहुत बहुत मुहावरेदार इस अर्थ में है कि इस कोड है,

872
01:13:58,600 --> 01:14:05,700
कि इस तरह से लिखा है बस, क्योंकि यह साफ है पढ़ने के लिए, पढ़ने के लिए आसान है.

873
01:14:05,700 --> 01:14:11,520
वहाँ कई अलग अलग तरीके से ऐसा कर, कई विभिन्न कार्यों को आप उपयोग कर सकते हैं,

874
01:14:11,520 --> 01:14:14,680
लेकिन हम सिर्फ अधिक से अधिक है और ये एक ही पैटर्न का पालन करते हैं.

875
01:14:14,680 --> 01:14:20,180
तो अगर आप को फिर से आ रहा है और फिर से इस तरह कोड देख आश्चर्य नहीं करना चाहिए.

876
01:14:20,180 --> 01:14:25,690
सही सभी. इस बिंदु पर, हम दिन के लिए तोड़ने की जरूरत है.

877
01:14:25,690 --> 01:14:31,300
आने के लिए धन्यवाद. देख अगर आप ऑनलाइन कर रहे हैं के लिए धन्यवाद. और हम अगले सप्ताह आप देखेंगे.

878
01:14:31,300 --> 01:14:33,890
[CS50.TV]