1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [4 सप्ताह]

2
00:00:03,000 --> 00:00:05,000
[डेविड जे Malan] [हार्वर्ड विश्वविद्यालय]

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

4
00:00:08,000 --> 00:00:12,000
>> ठीक है, यह CS50 है, और यह 4 सप्ताह की शुरुआत है,

5
00:00:12,000 --> 00:00:16,000
और यह एक धीमी संभव छँटाई एल्गोरिदम की है.

6
00:00:16,000 --> 00:00:19,000
जो एक यह है कि हम सिर्फ वहाँ देखा था?

7
00:00:19,000 --> 00:00:24,000
बुलबुला तरह था, क्रम में बड़ा हे (एन ^ 2) राशि +

8
00:00:24,000 --> 00:00:28,000
और वास्तव में हम इस दुनिया में ही लोगों को पता करने के लिए नहीं लगते हैं

9
00:00:28,000 --> 00:00:30,000
क्या बुलबुला तरह है या अपने समय चल रहा है.

10
00:00:30,000 --> 00:00:33,000
वास्तव में, यह गूगल के एरिक श्मिट के साथ एक साक्षात्कार किया गया था

11
00:00:33,000 --> 00:00:45,000
और पूर्व सीनेटर बराक ओबामा अभी कुछ साल पहले.

12
00:00:45,000 --> 00:00:48,000
>> अब, सीनेटर, आप गूगल पर यहाँ कर रहे हैं,

13
00:00:48,000 --> 00:00:54,000
और मैं एक नौकरी के साक्षात्कार के रूप में राष्ट्रपति पद के बारे में सोचना अच्छा लगता है.

14
00:00:54,000 --> 00:00:58,000
अब, यह राष्ट्रपति के रूप में एक नौकरी मिल मुश्किल है, और आप अब कठोरता के माध्यम से जा रहे हैं.

15
00:00:58,000 --> 00:01:00,000
यह भी गूगल पर एक नौकरी पाने के लिए मुश्किल है.

16
00:01:00,000 --> 00:01:05,000
हम प्रश्न हैं, और हम अपने उम्मीदवारों सवालों पूछते हैं,

17
00:01:05,000 --> 00:01:10,000
और इस एक लैरी Schwimmer से है.

18
00:01:10,000 --> 00:01:14,000
आप लोगों को लगता है कि मैं मज़ाक कर रहा हूँ? यह यहीं पर है.

19
00:01:14,000 --> 00:01:18,000
के लिए एक लाख 32 बिट पूर्णांक तरह सबसे कुशल तरीका क्या है?

20
00:01:18,000 --> 00:01:21,000
[हँसी]

21
00:01:21,000 --> 00:01:24,000
अच्छी तरह से

22
00:01:24,000 --> 00:01:26,000
मैं माफी चाहता >> हूँ. नहीं, नहीं, नहीं, नहीं.

23
00:01:26,000 --> 00:01:34,000
मुझे लगता है कि बुलबुला तरह गलत रास्ता तय करना होगा.

24
00:01:34,000 --> 00:01:39,000
>> चलो, जो उसे यह बताया था?

25
00:01:39,000 --> 00:01:43,000
पिछले हफ्ते याद है हम कम से कम एक दिन के लिए कोड से एक ब्रेक ले लिया,

26
00:01:43,000 --> 00:01:46,000
और कुछ उच्च स्तर के विचारों को और अधिक आम तौर पर समस्या को सुलझाने पर ध्यान केंद्रित करना शुरू कर दिया है

27
00:01:46,000 --> 00:01:49,000
खोज और छँटाई के संदर्भ में,

28
00:01:49,000 --> 00:01:53,000
और हम कुछ है कि हम पिछले हफ्ते पर इस नाम थप्पड़ नहीं था शुरू की है,

29
00:01:53,000 --> 00:01:56,000
लेकिन उपगामी संकेतन, बिग हे, बिग ओमेगा,

30
00:01:56,000 --> 00:02:00,000
और कभी कभी बिग थीटा संकेतन, और इन बस तरीके थे

31
00:02:00,000 --> 00:02:02,000
एल्गोरिदम के समय चल रहा है का वर्णन करने के,

32
00:02:02,000 --> 00:02:05,000
कितना समय यह एक एल्गोरिथ्म को चलाने के लिए लेता है.

33
00:02:05,000 --> 00:02:08,000
>> और आप कि आप समय चल रहा है के बारे में बात की थी आकार के संदर्भ में याद कर सकते हैं

34
00:02:08,000 --> 00:02:11,000
इनपुट, जो हम आम तौर पर पता फोन है, जो भी समस्या हो सकता है की,

35
00:02:11,000 --> 00:02:13,000
जहां n कमरे में लोगों की संख्या है,

36
00:02:13,000 --> 00:02:17,000
एक फोन की किताब में पृष्ठों की संख्या है, और हम बातें लिखने से बाहर करने के लिए शुरू

37
00:02:17,000 --> 00:02:21,000
हे की तरह, (n ^ 2) या हे (एन) या हे (n लॉग एन)

38
00:02:21,000 --> 00:02:24,000
और यहां तक ​​कि जब गणित काफी बाहर काम नहीं किया, तो पूरी तरह से

39
00:02:24,000 --> 00:02:28,000
और यह पता था ² n / 2 या उस तरह कुछ

40
00:02:28,000 --> 00:02:31,000
हम बजाय सिर्फ निचले क्रम शर्तों के कुछ दूर फेंक देना होगा,

41
00:02:31,000 --> 00:02:34,000
और प्रेरणा है कि हम वास्तव में चाहते हैं

42
00:02:34,000 --> 00:02:37,000
के मूल्यांकन के के उद्देश्य तरह की तरह

43
00:02:37,000 --> 00:02:39,000
कार्यक्रमों के निष्पादन या एल्गोरिदम के प्रदर्शन

44
00:02:39,000 --> 00:02:42,000
कि दिन के अंत में करने के लिए कुछ भी नहीं है, उदाहरण के लिए,

45
00:02:42,000 --> 00:02:45,000
आपके कंप्यूटर की गति के साथ आज.

46
00:02:45,000 --> 00:02:47,000
>> उदाहरण के लिए, यदि आप बुलबुला तरह लागू करने के लिए,

47
00:02:47,000 --> 00:02:50,000
या आप आज के कंप्यूटर पर तरह का या चयन छंटाई मर्ज को लागू करने के लिए,

48
00:02:50,000 --> 00:02:53,000
एक 2 गीगा कंप्यूटर, और आप इसे चलाने के लिए,

49
00:02:53,000 --> 00:02:56,000
और यह सेकंड के कुछ नंबर लेता है, अगले साल वहाँ एक 3 गीगा

50
00:02:56,000 --> 00:02:59,000
या एक 4 गीगा कंप्यूटर, और आप तो है कि "वाह, मेरे एल्गोरिथ्म दावा कर सकते हैं

51
00:02:59,000 --> 00:03:03,000
अब दो बार उपवास के रूप में है, "जब वास्तविकता में है कि स्पष्ट रूप से मामला नहीं है.

52
00:03:03,000 --> 00:03:06,000
यह सिर्फ हार्डवेयर तेजी से हो गया है, लेकिन अपने कंप्यूटर

53
00:03:06,000 --> 00:03:10,000
है और इसलिए नहीं है, हम वास्तव में दूर की तरह बातें फेंक करना चाहते हैं

54
00:03:10,000 --> 00:03:13,000
2 के गुणकों या 3 के गुणकों जब यह वर्णन करने के लिए आता है

55
00:03:13,000 --> 00:03:17,000
कितनी तेजी से या कैसे धीमी गति से एक एल्गोरिथ्म है और वास्तव में सिर्फ ध्यान

56
00:03:17,000 --> 00:03:20,000
n या कुछ तत्संबंधी कारक पर,

57
00:03:20,000 --> 00:03:24,000
उसके कुछ बिजली के रूप में पिछले सप्ताह से एक तरह के मामले में.

58
00:03:24,000 --> 00:03:27,000
और मर्ज तरह की मदद के साथ याद करते हैं

59
00:03:27,000 --> 00:03:31,000
हम इतना बुलबुला तरह और चयन छंटाई की तुलना में बेहतर करने के लिए सक्षम थे

60
00:03:31,000 --> 00:03:33,000
और यहां तक ​​कि प्रविष्टि तरह.

61
00:03:33,000 --> 00:03:36,000
>> हम n लॉग एन के लिए नीचे मिला, और फिर,

62
00:03:36,000 --> 00:03:39,000
याद है कि लॉग n आम तौर पर कुछ है कि बढ़ता को संदर्भित करता है

63
00:03:39,000 --> 00:03:43,000
अधिक धीरे धीरे फिर n है, तो n लॉग n इस प्रकार अब तक अच्छा था

64
00:03:43,000 --> 00:03:45,000
क्योंकि यह कम से कम n ² था.

65
00:03:45,000 --> 00:03:47,000
लेकिन प्राप्त n करने के लिए मर्ज प्रकार के साथ n लॉग इन

66
00:03:47,000 --> 00:03:51,000
एक विचार है कि हम का लाभ उठाने के लिए किया था की बुनियादी रोगाणु क्या था

67
00:03:51,000 --> 00:03:54,000
कि हम भी 0 सप्ताह में वापस leveraged?

68
00:03:54,000 --> 00:03:58,000
हम छँटाई समस्या कैसे बड़ी चतुराई से निपटने मर्ज प्रकार के साथ?

69
00:03:58,000 --> 00:04:04,000
क्या महत्वपूर्ण अंतर्दृष्टि शायद था?

70
00:04:04,000 --> 00:04:07,000
किसी को भी सब पर.

71
00:04:07,000 --> 00:04:09,000
ठीक है, चलो एक कदम वापस ले.

72
00:04:09,000 --> 00:04:11,000
अपने खुद के शब्दों में तरह मर्ज का वर्णन करें.

73
00:04:11,000 --> 00:04:15,000
यह कैसे काम किया है?

74
00:04:15,000 --> 00:04:17,000
ठीक है, हम वापस सप्ताह 0 पंक्ति हूँ.

75
00:04:17,000 --> 00:04:19,000
ठीक है, हाँ.

76
00:04:19,000 --> 00:04:22,000
[अश्राव्य छात्र]

77
00:04:22,000 --> 00:04:26,000
ठीक है, अच्छा है, इसलिए हम 2 टुकड़ों में संख्याओं की सरणी में विभाजित है.

78
00:04:26,000 --> 00:04:29,000
हम उन टुकड़ों में से प्रत्येक पर छाँटा है, और फिर हम उन्हें विलय कर दिया,

79
00:04:29,000 --> 00:04:33,000
और हम इस विचार से पहले देखा है की एक समस्या यह है कि इस बड़े ले

80
00:04:33,000 --> 00:04:36,000
और यह एक समस्या यह है कि इस बड़े या इस बड़े में काट.

81
00:04:36,000 --> 00:04:38,000
>> फोन की किताब उदाहरण याद.

82
00:04:38,000 --> 00:04:42,000
स्वयं गिनती सप्ताह पहले से एल्गोरिथ्म याद,

83
00:04:42,000 --> 00:04:45,000
इतना मर्ज तरह इस pseudocode से यहाँ संक्षेप किया गया था.

84
00:04:45,000 --> 00:04:48,000
जब आप n तत्वों दिया रहे हैं, पहले यह था मानसिक स्वास्थ्य की जांच.

85
00:04:48,000 --> 00:04:51,000
यदि n <2 तो सभी में कुछ भी नहीं करते हैं

86
00:04:51,000 --> 00:04:55,000
क्योंकि अगर n <2 फिर n 0 या 1 जाहिर है,

87
00:04:55,000 --> 00:04:57,000
और यदि ऐसा है तो यह या तो 0 या 1 सॉर्ट करने के लिए कुछ भी नहीं है.

88
00:04:57,000 --> 00:04:59,000
तुम कर रहे हैं.

89
00:04:59,000 --> 00:05:01,000
अपनी सूची में पहले से ही तुच्छता हल है.

90
00:05:01,000 --> 00:05:04,000
लेकिन अन्यथा यदि आप 2 या अधिक तत्वों मिल गया है आगे जाओ और उन्हें विभाजित

91
00:05:04,000 --> 00:05:06,000
2 हिस्सों में, बाएँ और दाएँ.

92
00:05:06,000 --> 00:05:09,000
उन हिस्सों में से प्रत्येक सॉर्ट करने के लिए, और फिर क्रमबद्ध halves विलय.

93
00:05:09,000 --> 00:05:13,000
लेकिन यहाँ समस्या यह है कि पहली नज़र में यह लगता है जैसे हम punting रहे हैं.

94
00:05:13,000 --> 00:05:17,000
यह उस में एक परिपत्र परिभाषा है अगर मैं आप से पूछा है इन n तत्वों तरह

95
00:05:17,000 --> 00:05:22,000
और आप मुझे कह रहे हैं "ठीक है, ठीक है, हम उन तत्वों n / 2 और उन n / 2 सुलझा लेंगे"

96
00:05:22,000 --> 00:05:27,000
तो मेरा अगला सवाल हो जा रहा है "ठीक है, तुम कैसे n / 2 तत्वों तरह है?"

97
00:05:27,000 --> 00:05:30,000
>> लेकिन इस कार्यक्रम की संरचना की वजह से,

98
00:05:30,000 --> 00:05:33,000
क्योंकि वहाँ इस आधार का मामला है, तो बात है,

99
00:05:33,000 --> 00:05:39,000
इस विशेष मामले में कहते हैं कि यदि n 2 वापसी की तरह कुछ निश्चित मूल्य <तुरंत.

100
00:05:39,000 --> 00:05:42,000
कि एक ही परिपत्र जवाब के साथ जवाब मत करो.

101
00:05:42,000 --> 00:05:46,000
इस प्रक्रिया, इस cyclicity अंततः खत्म हो जाएगा.

102
00:05:46,000 --> 00:05:50,000
अगर मैं तुम्हें "क्रमबद्ध इन n तत्वों," पूछना है और आप कहते हैं, "ठीक है, इन n / 2 सॉर्ट करने के लिए,"

103
00:05:50,000 --> 00:05:53,000
तो आप कहते हैं, "ठीक है, की तरह इन n / 4, 8 / n, n/16,"

104
00:05:53,000 --> 00:05:56,000
अंत में आप एक बड़ा पर्याप्त संख्या से विभाजित करेंगे

105
00:05:56,000 --> 00:05:59,000
जो बिंदु पर आप कह सकते हैं कि आप सिर्फ 1 तत्व बाईं हूँ,

106
00:05:59,000 --> 00:06:02,000
"यहाँ, यहाँ एक क्रमबद्ध एक तत्व है."

107
00:06:02,000 --> 00:06:06,000
तो इस एल्गोरिथ्म की प्रतिभा को यहाँ इस तथ्य से प्राप्त है

108
00:06:06,000 --> 00:06:09,000
कि एक बार आप इन व्यक्तिगत क्रमबद्ध सूचियों के सभी है,

109
00:06:09,000 --> 00:06:12,000
जो सभी के 1 आकार, जो बेकार हो रहा है,

110
00:06:12,000 --> 00:06:15,000
एक बार आप उन्हें विलय और उन्हें विलय शुरू

111
00:06:15,000 --> 00:06:19,000
आप अंत में निर्माण के रूप में में रोब वीडियो एक अंततः क्रमबद्ध सूची में किया था.

112
00:06:19,000 --> 00:06:22,000
>> लेकिन इस विचार छँटाई परे फैली हुई है.

113
00:06:22,000 --> 00:06:26,000
इस विचार recursion के रूप में जाना जाता है इस कार्यक्रम में एम्बेडेड है,

114
00:06:26,000 --> 00:06:29,000
विचार है जिससे आप एक कार्यक्रम कर रहे हैं,

115
00:06:29,000 --> 00:06:32,000
और कुछ समस्या आप अपने फोन को हल करने के लिए,

116
00:06:32,000 --> 00:06:36,000
या आप एक समारोह कर रहे हैं प्रोग्रामिंग भाषाओं के संदर्भ में डाल दिया,

117
00:06:36,000 --> 00:06:39,000
और आदेश में एक समस्या को हल करने के लिए, आप अपने आप समारोह कॉल

118
00:06:39,000 --> 00:06:42,000
फिर से और फिर, लेकिन आप समारोह

119
00:06:42,000 --> 00:06:44,000
असीम रूप से कई बार फोन नहीं खुद कर सकते हैं.

120
00:06:44,000 --> 00:06:47,000
अंततः तुम बाहर नीचे करने के लिए है, तो बात है,

121
00:06:47,000 --> 00:06:49,000
और कुछ आधार हार्ड कोडित शर्त है कि कहते हैं,

122
00:06:49,000 --> 00:06:53,000
इस बिंदु पर अपने आप को इतना फोन बंद है कि पूरी प्रक्रिया

123
00:06:53,000 --> 00:06:56,000
अंत में वास्तव में रोक नहीं है.

124
00:06:56,000 --> 00:06:58,000
यह वास्तव में क्या recurse करने के लिए क्या मतलब है?

125
00:06:58,000 --> 00:07:01,000
>> चलो देखते हैं, अगर हम एक सरल, तुच्छ उदाहरण के साथ कहते हैं, क्या कर सकते हैं,

126
00:07:01,000 --> 00:07:03,000
यहाँ मंच पर मेरे साथ 3 लोगों को, अगर कोई सहज है.

127
00:07:03,000 --> 00:07:06,000
1, 2, और 3 पर आते हैं.

128
00:07:06,000 --> 00:07:09,000
अगर आप 3 करने के लिए यहाँ आने के लिए करना चाहते हैं.

129
00:07:09,000 --> 00:07:12,000
यदि आप मेरे लिए सही बगल में एक लाइन में खड़ा करना चाहते हैं, लगता है कि हाथ में समस्या

130
00:07:12,000 --> 00:07:15,000
बहुत तुच्छता से लोग हैं, जो यहाँ की संख्या गिनती.

131
00:07:15,000 --> 00:07:18,000
लेकिन स्पष्ट रूप से, मैं इन सभी की गिनती उदाहरण के थक गया हूँ.

132
00:07:18,000 --> 00:07:21,000
यह कुछ समय, 1, 2, और डॉट, डॉट, डॉट ले जा रहा है.

133
00:07:21,000 --> 00:07:23,000
यह हमेशा के लिए ले जा रहा है.

134
00:07:23,000 --> 00:07:25,000
मैं नहीं बल्कि सिर्फ मदद के साथ इस समस्या को पूरी तरह बाज़ी - तुम्हारा नाम क्या है? था

135
00:07:25,000 --> 00:07:27,000
सारा. >> सारा, सब ठीक है.

136
00:07:27,000 --> 00:07:29,000
केली >> केली और?

137
00:07:29,000 --> 00:07:31,000
>> विली >> विली, सारा, केली, और विली.

138
00:07:31,000 --> 00:07:34,000
अभी मैं किसी के द्वारा किया गया है प्रश्न पूछा

139
00:07:34,000 --> 00:07:37,000
कितने लोगों को इस स्तर पर कर रहे हैं, और मुझे पता नहीं है.

140
00:07:37,000 --> 00:07:40,000
यह एक बहुत लंबी सूची है, और इसलिए बजाय मैं इस चाल के लिए जा रहा हूँ.

141
00:07:40,000 --> 00:07:43,000
मैं काम के सबसे करने के लिए मेरे लिए अगले व्यक्ति को पूछने के लिए जा रहा हूँ,

142
00:07:43,000 --> 00:07:46,000
और एक बार वह काम के सबसे कर किया जाता है

143
00:07:46,000 --> 00:07:49,000
मैं काम करने के कम से कम राशि संभव करने के लिए जा रहा हूँ और बस 1 जोड़ने

144
00:07:49,000 --> 00:07:51,000
जो कुछ भी उसका जवाब है, तो यहाँ हम चले.

145
00:07:51,000 --> 00:07:54,000
मुझे कहा गया है कि कितने लोगों को मंच पर हैं.

146
00:07:54,000 --> 00:07:57,000
कितने लोगों को मंच पर आप की बाईं के लिए कर रहे हैं?

147
00:07:57,000 --> 00:08:00,000
>> मुझे के छोड़ दिया है? ठीक है, लेकिन धोखा नहीं है.

148
00:08:00,000 --> 00:08:04,000
यह अच्छी बात है, यह सही है, लेकिन अगर हम इस तर्क को जारी रखना चाहते हैं

149
00:08:04,000 --> 00:08:08,000
चलो मान लेते हैं कि आप इसी तरह इस समस्या की बाईं बाज़ी के लिए करना चाहते हैं,

150
00:08:08,000 --> 00:08:11,000
तो जवाब के बजाय सीधे आगे जाना है और सिर्फ पैसा देने.

151
00:08:11,000 --> 00:08:14,000
ओह, कितने लोगों को मुझे छोड़ दिया करने के लिए कर रहे हैं?

152
00:08:14,000 --> 00:08:16,000
कितने लोगों को छोड़ दिया करने के लिए कर रहे हैं?

153
00:08:16,000 --> 00:08:18,000
1.

154
00:08:18,000 --> 00:08:27,000
[हँसी]

155
00:08:27,000 --> 00:08:30,000
ठीक है, तो 0, तो अब क्या विली किया है

156
00:08:30,000 --> 00:08:33,000
आप अपने जवाब इस दिशा 0 कह लौटा दिया है.

157
00:08:33,000 --> 00:08:36,000
अब, तुम क्या >> 1? करना चाहिए.

158
00:08:36,000 --> 00:08:39,000
सब ठीक है, ठीक है, तो आप एक कर रहे हैं, तो आप कह "मैं 1 जोड़ने के लिए जा रहा हूँ

159
00:08:39,000 --> 00:08:41,000
विली गिनती था, "इसलिए एक 0 + जो भी हो.

160
00:08:41,000 --> 00:08:43,000
अब आप कर रहे हैं 1 इसलिए अपने अधिकार के लिए जवाब है अब

161
00:08:43,000 --> 00:08:45,000
1. >> मेरा और 2 होगा.

162
00:08:45,000 --> 00:08:48,000
अच्छा, तो तुम 1 के पिछले जवाब ले जा रहे हैं,

163
00:08:48,000 --> 00:08:51,000
जोड़ने के काम की न्यूनतम राशि है जो आप करना चाहते हैं, जो एक है.

164
00:08:51,000 --> 00:08:55,000
अब आप 2 है, और आप तो मुझे मूल्य जो हाथ?

165
00:08:55,000 --> 00:08:57,000
3, मेरा मतलब है, माफ करना, 2.

166
00:08:57,000 --> 00:08:59,000
अच्छा है.

167
00:08:59,000 --> 00:09:02,000
>> खैर, हम छोड़ दिया करने के लिए 0 था.

168
00:09:02,000 --> 00:09:05,000
फिर हम 1 था, और फिर हम 2 जोड़ने के,

169
00:09:05,000 --> 00:09:07,000
और अब आप मुझे 2 संख्या सौंप रहे हैं,

170
00:09:07,000 --> 00:09:10,000
और इसलिए मैं कह रहा हूँ, ठीक है, एक, 3.

171
00:09:10,000 --> 00:09:13,000
वहाँ वास्तव में 3 लोगों को इस मंच पर मेरे बगल में खड़ा है,

172
00:09:13,000 --> 00:09:16,000
तो हम स्पष्ट रूप से यह हो सकता है बहुत रैखिक से किया,

173
00:09:16,000 --> 00:09:19,000
स्पष्ट फैशन में बहुत ज्यादा है, लेकिन क्या हम वास्तव में क्या किया?

174
00:09:19,000 --> 00:09:21,000
हम 3 आकार के एक समस्या शुरू लिया.

175
00:09:21,000 --> 00:09:24,000
हम तो यह 2 आकार की एक समस्या में टूट गया,

176
00:09:24,000 --> 00:09:27,000
फिर 1 आकार की एक समस्या है, और फिर अंत में आधार के मामले

177
00:09:27,000 --> 00:09:29,000
वास्तव में था, ओह, वहां कोई नहीं है,

178
00:09:29,000 --> 00:09:33,000
पर जो बात विली प्रभावी रूप से एक हार्ड कोडित जवाब समय की एक जोड़ी लौटे,

179
00:09:33,000 --> 00:09:36,000
और दूसरा एक तो ऊपर bubbled bubbled किया गया था, ऊपर bubbled,

180
00:09:36,000 --> 00:09:39,000
और तब से यह एक अतिरिक्त 1 में जोड़ने

181
00:09:39,000 --> 00:09:41,000
हम recursion की इस मूल विचार को क्रियान्वित किया है.

182
00:09:41,000 --> 00:09:44,000
>> अब, इस मामले में यह वास्तव में एक समस्या नहीं हल किया

183
00:09:44,000 --> 00:09:46,000
किसी भी और अधिक प्रभावी ढंग से तो हम इस प्रकार अब तक देखा है.

184
00:09:46,000 --> 00:09:48,000
लेकिन एल्गोरिदम हम मंच पर इस प्रकार दूर किया है के बारे में सोचते हैं.

185
00:09:48,000 --> 00:09:51,000
हम चॉकबोर्ड पर कागज के 8 टुकड़े था,

186
00:09:51,000 --> 00:09:55,000
वीडियो पर जब शॉन नंबर 7 के लिए देख रहा था, और क्या वह वास्तव में क्या किया?

187
00:09:55,000 --> 00:09:58,000
खैर, वह विभाजन के किसी भी तरह नहीं करना था और जीत के लिए.

188
00:09:58,000 --> 00:10:01,000
वह recursion की किसी भी तरह नहीं किया.

189
00:10:01,000 --> 00:10:03,000
बल्कि वह सिर्फ इस रैखिक एल्गोरिथ्म किया.

190
00:10:03,000 --> 00:10:07,000
लेकिन जब हम मंच पर क्रमबद्ध संख्या के विचार की शुरुआत पिछले सप्ताह जीने

191
00:10:07,000 --> 00:10:09,000
फिर हम बीच करने के लिए जा रहा है की इस वृत्ति था,

192
00:10:09,000 --> 00:10:13,000
जो बिंदु पर हम 4 आकार या 4 आकार की एक सूची की एक छोटी सूची था,

193
00:10:13,000 --> 00:10:17,000
और फिर हम सटीक एक ही समस्या थी, तो हम दोहराया, कई बार दोहराया.

194
00:10:17,000 --> 00:10:19,000
दूसरे शब्दों में, हम recursed.

195
00:10:19,000 --> 00:10:24,000
हमारे 3 स्वयंसेवकों के लिए आपको बहुत बहुत हमारे साथ recursion का प्रदर्शन करने के लिए धन्यवाद.

196
00:10:24,000 --> 00:10:28,000
>> चलो देखते हैं अगर हम यह नहीं अब एक छोटे से अधिक ठोस कर सकते हैं,

197
00:10:28,000 --> 00:10:30,000
एक समस्या यह है कि फिर से हम बहुत आसानी से कर सकता को हल,

198
00:10:30,000 --> 00:10:34,000
लेकिन हम इसे इस मूल विचार को लागू करने के लिए एक कदम पत्थर के रूप में इस्तेमाल करेंगे.

199
00:10:34,000 --> 00:10:37,000
अगर मैं संख्या का एक गुच्छा के योग की गणना करने के लिए करना चाहते हैं,

200
00:10:37,000 --> 00:10:39,000
उदाहरण के लिए, अगर आप 3 संख्या में पारित,

201
00:10:39,000 --> 00:10:42,000
मैं आप 3 सिग्मा के मूल्य देना चाहता हूँ,

202
00:10:42,000 --> 00:10:46,000
तो 3 का योग 2 + 1 + 0 +.

203
00:10:46,000 --> 00:10:48,000
मैं वापस 6 जवाब प्राप्त करना चाहते हैं,

204
00:10:48,000 --> 00:10:51,000
इसलिए हम इस सिग्मा समारोह, इस समेशन समारोह लागू करेंगे

205
00:10:51,000 --> 00:10:54,000
कि, फिर से, इनपुट में लेता है, और फिर समेशन रिटर्न

206
00:10:54,000 --> 00:10:57,000
उस नंबर के नीचे 0 से रास्ता.

207
00:10:57,000 --> 00:10:59,000
हम यह बहुत आसानी से कर सकता है, है ना?

208
00:10:59,000 --> 00:11:01,000
हम पाशन संरचना के कुछ प्रकार के साथ यह कर सकता है,

209
00:11:01,000 --> 00:11:04,000
तो मुझे आगे जाना है और यह शुरू कर दिया.

210
00:11:04,000 --> 00:11:07,000
>> Stdio.h शामिल करें.

211
00:11:07,000 --> 00:11:09,000
मुझे अपने आप को मुख्य में पाने के लिए यहाँ के साथ काम.

212
00:11:09,000 --> 00:11:12,000
चलो sigma.c के रूप में बचाने के लिए.

213
00:11:12,000 --> 00:11:14,000
तो मैं यहाँ में जाने के लिए जा रहा हूँ, और मैं एक int n की घोषणा करने के लिए जा रहा हूँ,

214
00:11:14,000 --> 00:11:18,000
और मैं निम्नलिखित करने की जबकि उपयोगकर्ता सहयोग नहीं करने के लिए जा रहा हूँ.

215
00:11:18,000 --> 00:11:22,000
जबकि उपयोगकर्ता मुझे एक सकारात्मक संख्या नहीं दिया है

216
00:11:22,000 --> 00:11:26,000
मुझे आगे जाना है और उन्हें n = GetInt के लिए संकेत करने के लिए,

217
00:11:26,000 --> 00:11:28,000
और मुझे उन्हें क्या करना है के रूप में कुछ निर्देश दे,

218
00:11:28,000 --> 00:11:33,000
अब printf ("सकारात्मक पूर्णांक कृपया").

219
00:11:33,000 --> 00:11:39,000
बस इस तरह अपेक्षाकृत सरल तो कुछ उस समय तक हम 14 लाइन मारा

220
00:11:39,000 --> 00:11:42,000
अब हम n में एक सकारात्मक पूर्णांक संभाव्यतः है.

221
00:11:42,000 --> 00:11:44,000
>> अब इसके साथ कुछ करना है.

222
00:11:44,000 --> 00:11:50,000
मुझे आगे जाना है और समेशन की गणना करने के लिए, तो int राशि = सिग्मा (एन).

223
00:11:50,000 --> 00:11:54,000
सिग्मा बस संकलन, इसलिए मैं सिर्फ शौक़ीन रास्ते में यह लेखन कर रहा हूँ.

224
00:11:54,000 --> 00:11:56,000
हम सिर्फ यह वहाँ सिग्मा फोन करता हूँ.

225
00:11:56,000 --> 00:11:58,000
वह राशि है, और अब मैं बाहर परिणाम मुद्रित जा रहा हूँ,

226
00:11:58,000 --> 00:12:08,000
printf (राशि है, "योग% d, \ n").

227
00:12:08,000 --> 00:12:11,000
और फिर मैं अच्छे उपाय के लिए 0 वापस कर देंगे.

228
00:12:11,000 --> 00:12:15,000
हम दिलचस्प हिस्सा के अलावा सब कुछ किया है कि इस कार्यक्रम की आवश्यकता है,

229
00:12:15,000 --> 00:12:18,000
जो वास्तव में सिग्मा समारोह को लागू करने के लिए है.

230
00:12:18,000 --> 00:12:22,000
>> मुझे यहाँ नीचे नीचे करने के लिए जाने के लिए और मुझे समारोह सिग्मा घोषित.

231
00:12:22,000 --> 00:12:26,000
यह एक चर कि प्रकार पूर्णांक के ले गया है,

232
00:12:26,000 --> 00:12:30,000
और क्या डेटा प्रकार मैं सिग्मा से शायद वापस करना चाहते हैं?

233
00:12:30,000 --> 00:12:34,000
Int, क्योंकि मैं यह 15 लाइन पर मेरी उम्मीदों से मिलान करने के लिए करना चाहते हैं.

234
00:12:34,000 --> 00:12:37,000
यहाँ मुझे आगे जाना है और इस को लागू करने

235
00:12:37,000 --> 00:12:41,000
एक बहुत ही सरल तरीके में.

236
00:12:41,000 --> 00:12:45,000
>> चलो आगे जाओ और int राशि = 0 कहना,

237
00:12:45,000 --> 00:12:47,000
और अब मैं पाश के लिए एक छोटे से यहाँ है जाने के लिए जा रहा हूँ

238
00:12:47,000 --> 00:12:50,000
कि इस तरह से कुछ कहने जा रहा है,

239
00:12:50,000 --> 00:13:01,000
के लिए (int i = 0, मैं <= संख्या, मैं + +) राशि + i =.

240
00:13:01,000 --> 00:13:05,000
और फिर मैं राशि वापस जा रहा हूँ.

241
00:13:05,000 --> 00:13:07,000
मैं किसी भी तरीके की संख्या में यह लागू किया जा सकता है.

242
00:13:07,000 --> 00:13:09,000
मैं एक समय पाश इस्तेमाल किया जा सकता है.

243
00:13:09,000 --> 00:13:11,000
मैं योग चर का उपयोग अगर मैं सच में चाहता था छोड़ दिया सकता है,

244
00:13:11,000 --> 00:13:15,000
लेकिन संक्षेप में, हम सिर्फ एक समारोह में कहा कि अगर मैं नहीं था मूर्ख वाणी योग 0 है.

245
00:13:15,000 --> 00:13:18,000
तो यह 0 से नंबर के माध्यम से दोहराता है,

246
00:13:18,000 --> 00:13:23,000
और योग करने के लिए प्रत्येक यात्रा पर यह कहते हैं कि वर्तमान मूल्य और फिर राशि देता है.

247
00:13:23,000 --> 00:13:25,000
>> अब, वहाँ एक मामूली अनुकूलन यहाँ है.

248
00:13:25,000 --> 00:13:29,000
यह शायद एक बेकार कदम है, लेकिन ऐसा ही होगा. यह ठीक है अब के लिए.

249
00:13:29,000 --> 00:13:32,000
हम कम से कम पूरी तरह से किया जा रहा है और ऊपर पर 0 सभी रास्ते पर जा रहे हैं.

250
00:13:32,000 --> 00:13:34,000
नहीं बहुत कठिन है और बहुत सीधा है,

251
00:13:34,000 --> 00:13:37,000
लेकिन यह पता चला है कि सिग्मा समारोह के साथ हम एक ही मौका है

252
00:13:37,000 --> 00:13:39,000
के रूप में हम मंच पर यहाँ था.

253
00:13:39,000 --> 00:13:42,000
मंच पर हम सिर्फ गिनता है कि कितने लोगों को मेरे बगल में थे,

254
00:13:42,000 --> 00:13:47,000
लेकिन इसके बजाय अगर हम 3 + 1 + 2 संख्या गिनती करना चाहता था

255
00:13:47,000 --> 00:13:51,000
0 नीचे पर हम एक समारोह के लिए इसी तरह बाज़ी

256
00:13:51,000 --> 00:13:55,000
कि मैं बजाय पुनरावर्ती होने के रूप में वर्णन करेंगे.

257
00:13:55,000 --> 00:13:57,000
यहाँ एक त्वरित विवेक और सुनिश्चित करें कि मैं मूर्ख नहीं था.

258
00:13:57,000 --> 00:14:00,000
>> मैं जानता हूँ कि इस कार्यक्रम में कम से कम एक बात यह है कि मैं गलत क्या किया है.

259
00:14:00,000 --> 00:14:04,000
जब मैं हिट दर्ज करें मैं मुझ पर चिल्ला के किसी भी प्रकार प्राप्त करने के लिए जा रहा हूँ?

260
00:14:04,000 --> 00:14:06,000
मैं क्या करने के बारे में चिल्लाया जा रहा हूँ?

261
00:14:06,000 --> 00:14:11,000
हाँ, मैं प्रोटोटाइप भूल गया तो, मैं 15 लाइन पर सिग्मा बुलाया समारोह का उपयोग कर रहा हूँ,

262
00:14:11,000 --> 00:14:16,000
लेकिन यह 22 लाइन तक घोषित नहीं किया है, तो मैं सबसे अच्छा लगातार यहाँ जाना

263
00:14:16,000 --> 00:14:22,000
और एक प्रोटोटाइप की घोषणा, और मैं कहता हूँ int सिग्मा (int संख्या), और यह बात है.

264
00:14:22,000 --> 00:14:24,000
यह नीचे में कार्यान्वित किया है.

265
00:14:24,000 --> 00:14:27,000
>> या किसी अन्य तरह से मैं इस को हल कर सकता है,

266
00:14:27,000 --> 00:14:30,000
मैं वहाँ ऊपर समारोह में ले जाने के लिए, जो बुरा नहीं है हो सकता है,

267
00:14:30,000 --> 00:14:32,000
लेकिन कम से कम जब अपने कार्यक्रमों के लिए लंबे समय स्पष्ट रूप से शुरू करते हैं,

268
00:14:32,000 --> 00:14:35,000
मुझे लगता है कि वहाँ हमेशा शीर्ष पर मुख्य होने में कुछ मूल्य है

269
00:14:35,000 --> 00:14:38,000
इतना है कि आप रीडर में फ़ाइल खोलने के लिए और फिर तुरंत देखने के कर सकते हैं

270
00:14:38,000 --> 00:14:40,000
क्या कार्यक्रम के माध्यम से यह खोज करने के लिए बिना कर रही है

271
00:14:40,000 --> 00:14:42,000
कि मुख्य समारोह के लिए देख रहे हैं.

272
00:14:42,000 --> 00:14:49,000
चलो मेरे टर्मिनल विंडो के लिए यहाँ नीचे जाना, सिग्मा सिग्मा बनाने की कोशिश,

273
00:14:49,000 --> 00:14:51,000
और मैं यहाँ भी खराब कर दिया है.

274
00:14:51,000 --> 00:14:55,000
समारोह GetInt के निहित घोषणा का मतलब है मैं और क्या करने के लिए भूल गए हैं?

275
00:14:55,000 --> 00:14:57,000
[अश्राव्य छात्र]

276
00:14:57,000 --> 00:15:00,000
अच्छा, तो जाहिरा तौर पर एक आम गलती है, तो हम इस यहाँ डाल,

277
00:15:00,000 --> 00:15:04,000
cs50.h, और अब मेरे टर्मिनल विंडो में वापस जाना है.

278
00:15:04,000 --> 00:15:08,000
>> मैं स्क्रीन को साफ कर देंगे, और मैं सिग्मा बनाने फिर से दौड़ना होगा.

279
00:15:08,000 --> 00:15:11,000
यह संकलित किया है लगता है. मुझे अब सिग्मा चलाने.

280
00:15:11,000 --> 00:15:15,000
मैं 3 संख्या में टाइप करें, और मैं 6 मिला, तो एक कठोर चेक नहीं,

281
00:15:15,000 --> 00:15:18,000
लेकिन कम से कम यह पहली नज़र में काम किया जा रहा है, लेकिन अब हम इसे अलावा चीर,

282
00:15:18,000 --> 00:15:21,000
और हम वास्तव में recursion की फिर से विचार का लाभ उठाने,

283
00:15:21,000 --> 00:15:24,000
इतना है कि एक बहुत ही सरल संदर्भ में कुछ सप्ताह का समय में

284
00:15:24,000 --> 00:15:27,000
जब हम arrays की तुलना शौक़ीन डेटा संरचनाओं की खोज शुरू

285
00:15:27,000 --> 00:15:30,000
हम Toolkit में एक और उपकरण के साथ करने के लिए जो किया है

286
00:15:30,000 --> 00:15:33,000
उन डेटा संरचनाओं में हेरफेर के रूप में हम देखेंगे.

287
00:15:33,000 --> 00:15:36,000
यह दृष्टिकोण चलने पाश आधारित दृष्टिकोण है.

288
00:15:36,000 --> 00:15:39,000
>> मुझे बजाय अब यह करना है.

289
00:15:39,000 --> 00:15:44,000
मुझे बजाय कहते हैं कि संख्या के योग

290
00:15:44,000 --> 00:15:48,000
नीचे 0 करने के लिए वास्तव में के रूप में एक ही बात है

291
00:15:48,000 --> 00:15:53,000
+ संख्या सिग्मा (संख्या - 1).

292
00:15:53,000 --> 00:15:57,000
दूसरे शब्दों में, मंच पर बस की तरह मैं मेरे बगल में लोगों में से प्रत्येक के लिए punted

293
00:15:57,000 --> 00:16:00,000
और वे बदले में जब तक हम अंततः विली पर बाहर तली punting रखा,

294
00:16:00,000 --> 00:16:03,000
जो 0 की तरह एक हार्ड कोडित जवाब लौटना पड़ा.

295
00:16:03,000 --> 00:16:07,000
अब यहाँ हम इसी तरह सिग्मा punting रहे हैं

296
00:16:07,000 --> 00:16:10,000
एक ही समारोह के रूप में मूल बुलाया गया था, लेकिन महत्वपूर्ण अंतर्दृष्टि यहाँ

297
00:16:10,000 --> 00:16:12,000
यह है कि हम सिग्मा हूबहू नहीं बुला रहे हैं.

298
00:16:12,000 --> 00:16:14,000
हम n में नहीं गुजर रहे हैं.

299
00:16:14,000 --> 00:16:17,000
हम स्पष्ट रूप से संख्या में गुजर रहे हैं - 1,

300
00:16:17,000 --> 00:16:20,000
तो एक थोड़ा छोटे समस्या, थोड़ा छोटा समस्या.

301
00:16:20,000 --> 00:16:23,000
>> दुर्भाग्य से, यह काफी एक समाधान अभी तक नहीं है, और इससे पहले कि हम तय

302
00:16:23,000 --> 00:16:26,000
स्पष्ट रूप में बाहर हो सकता है आप में से कुछ पर कूद

303
00:16:26,000 --> 00:16:28,000
मुझे आगे जाने के लिए और फिर से दौड़ना.

304
00:16:28,000 --> 00:16:30,000
यह ठीक संकलन लगता है.

305
00:16:30,000 --> 00:16:32,000
मुझे साथ 6 सिग्मा फिर से दौड़ना.

306
00:16:32,000 --> 00:16:37,000
वूप्स, मुझे साथ 6 सिग्मा फिर से दौड़ना.

307
00:16:37,000 --> 00:16:42,000
हमने यह देखा है पहले, हालांकि गलती से पिछली बार के रूप में अच्छी तरह से.

308
00:16:42,000 --> 00:16:48,000
मैं इस गुप्त विभाजन गलती क्यों मिला? हाँ.

309
00:16:48,000 --> 00:16:50,000
[अश्राव्य छात्र]

310
00:16:50,000 --> 00:16:53,000
वहाँ कोई आधार मामला है, और अधिक विशेष रूप से, शायद क्या हुआ?

311
00:16:53,000 --> 00:16:58,000
यह क्या व्यवहार का एक लक्षण है?

312
00:16:58,000 --> 00:17:00,000
यह थोड़ा जोर से कहो.

313
00:17:00,000 --> 00:17:02,000
[अश्राव्य छात्र]

314
00:17:02,000 --> 00:17:05,000
यह एक अनंत पाश प्रभावी ढंग से, और अनंत loops के साथ समस्या है

315
00:17:05,000 --> 00:17:08,000
जब वे इस मामले में recursion शामिल है, एक समारोह ही बुला रहा था,

316
00:17:08,000 --> 00:17:10,000
क्या हर बार जब आप एक समारोह फोन होता है?

317
00:17:10,000 --> 00:17:13,000
खैर, कैसे हम एक कंप्यूटर में स्मृति रखी वापस लगता है.

318
00:17:13,000 --> 00:17:16,000
हम ने कहा कि स्मृति के इस हिस्सा ढेर है कि नीचे बुलाया है,

319
00:17:16,000 --> 00:17:19,000
और हर बार जब आप एक समारोह में एक छोटे से अधिक स्मृति फोन डाल दिया जाता है

320
00:17:19,000 --> 00:17:24,000
इस तथाकथित कि समारोह स्थानीय चर या पैरामीटर युक्त ढेर पर,

321
00:17:24,000 --> 00:17:27,000
यदि ऐसा है तो सिग्मा सिग्मा कॉल कॉल सिग्मा सिग्मा कॉल

322
00:17:27,000 --> 00:17:29,000
 सिग्मा कॉल जहां इस कहानी का अंत नहीं है?

323
00:17:29,000 --> 00:17:31,000
>> खैर, यह अंततः कुल राशि overruns

324
00:17:31,000 --> 00:17:33,000
स्मृति है कि आप अपने कंप्यूटर के लिए उपलब्ध है.

325
00:17:33,000 --> 00:17:37,000
आप खंड है कि आप के भीतर रहने के लिए चाहिए रहे हैं उग आया है,

326
00:17:37,000 --> 00:17:40,000
और आप इस विभाजन गलती हो, कोर फेंक दिया,

327
00:17:40,000 --> 00:17:43,000
और कोर फेंक दिया इसका मतलब यह है कि मैं अब एक कोर नामक एक फाइल है

328
00:17:43,000 --> 00:17:46,000
जो शून्य और लोगों से युक्त फ़ाइल है

329
00:17:46,000 --> 00:17:49,000
कि भविष्य में वास्तव में लक्षणपूर्वक उपयोगी होगा.

330
00:17:49,000 --> 00:17:52,000
यदि यह आप के लिए स्पष्ट नहीं है, जहां अपने बग है

331
00:17:52,000 --> 00:17:54,000
आप वास्तव में फोरेंसिक विश्लेषण के एक बिट कर इतनी बात करने के लिए कर सकते हैं,

332
00:17:54,000 --> 00:17:58,000
इस कोर डंप फ़ाइल पर, फिर से, जो सिर्फ शून्य और लोगों की एक पूरी गुच्छा है

333
00:17:58,000 --> 00:18:02,000
है कि अनिवार्य रूप से अपने कार्यक्रम की स्मृति में राज्य का प्रतिनिधित्व करता है

334
00:18:02,000 --> 00:18:05,000
फिलहाल यह इस रास्ते में दुर्घटनाग्रस्त हो गया.

335
00:18:05,000 --> 00:18:11,000
>> यहाँ ठीक है कि हम बस आँख बंद करके सिग्मा नहीं लौट सकते हैं,

336
00:18:11,000 --> 00:18:14,000
+ संख्या एक थोड़ा छोटे समस्या के सिग्मा.

337
00:18:14,000 --> 00:18:16,000
हम आधार मामले की किसी तरह का यहाँ की जरूरत है,

338
00:18:16,000 --> 00:18:19,000
और क्या आधार मामला शायद होना चाहिए?

339
00:18:19,000 --> 00:18:22,000
[अश्राव्य छात्र]

340
00:18:22,000 --> 00:18:25,000
ठीक है, इतने लंबे समय के रूप में संख्या धनात्मक है हम वास्तव में यह वापस आ जाना चाहिए,

341
00:18:25,000 --> 00:18:29,000
या दूसरे तरीके से रखा है, अगर संख्या है, कहते हैं, <= 0 से

342
00:18:29,000 --> 00:18:32,000
तुम्हें पता है, मुझे आगे जाना है और 0 वापस कर देंगे,

343
00:18:32,000 --> 00:18:36,000
बहुत पसंद किया विली, और कुछ, मुझे आगे जाना है जा रहा हूँ

344
00:18:36,000 --> 00:18:41,000
और यह वापस, तो यह है कि छोटे ज्यादा नहीं है

345
00:18:41,000 --> 00:18:44,000
संस्करण चलने का है कि हम मार पड़ी 1 पाश के लिए एक का उपयोग कर से,

346
00:18:44,000 --> 00:18:48,000
लेकिन नोटिस कि वहाँ यह करने के लिए शान की इस तरह है.

347
00:18:48,000 --> 00:18:51,000
इसके बजाय कुछ संख्या लौटने और यह सब गणित प्रदर्शन

348
00:18:51,000 --> 00:18:54,000
और बातें स्थानीय चर के साथ जोड़ने

349
00:18:54,000 --> 00:18:57,000
आप के बजाय कह रहे हैं, "ठीक है, अगर यह एक सुपर आसान समस्या है,

350
00:18:57,000 --> 00:19:01,000
तरह की संख्या <0 है, मुझे तुरंत 0 वापसी. "

351
00:19:01,000 --> 00:19:03,000
>> हम समर्थन करने के लिए नकारात्मक संख्या को परेशान करने के लिए नहीं जा रहे हैं,

352
00:19:03,000 --> 00:19:05,000
तो मैं मुश्किल कोड 0 के मूल्य जा रहा हूँ.

353
00:19:05,000 --> 00:19:08,000
लेकिन अन्यथा, संक्षेप के इस विचार को लागू करने के लिए

354
00:19:08,000 --> 00:19:11,000
इन नंबरों के सभी एक साथ आप प्रभावी रूप से एक छोटा सा टुकड़ा ले जा सकते हैं

355
00:19:11,000 --> 00:19:14,000
समस्या से बाहर बहुत पसंद है, हम यहाँ मंच पर किया था,

356
00:19:14,000 --> 00:19:18,000
तो बाज़ी समस्या का अगले व्यक्ति को आराम

357
00:19:18,000 --> 00:19:20,000
लेकिन इस मामले में अगले व्यक्ति अपने आप को.

358
00:19:20,000 --> 00:19:22,000
यह एक समान समारोह का नाम है.

359
00:19:22,000 --> 00:19:25,000
बस इसे एक और छोटे छोटे और छोटे समस्या हर बार पास,

360
00:19:25,000 --> 00:19:28,000
और फिर भी हम नहीं कोड में चीजें काफी औपचारिक रूप यहाँ है

361
00:19:28,000 --> 00:19:33,000
यह ठीक है कि फोन की किताब के साथ 0 सप्ताह में जा रहा था.

362
00:19:33,000 --> 00:19:36,000
यह ठीक है कि पिछले कुछ हफ्तों में शॉन के साथ जा रहा था

363
00:19:36,000 --> 00:19:39,000
और हमारे प्रदर्शनों के साथ संख्या के लिए खोज की.

364
00:19:39,000 --> 00:19:42,000
यह एक समस्या को ले जा रहा है और इसे फिर से और फिर से विभाजित है.

365
00:19:42,000 --> 00:19:44,000
>> दूसरे शब्दों में, वहाँ एक रास्ता अब अनुवाद करने के

366
00:19:44,000 --> 00:19:47,000
यह असली दुनिया का निर्माण, इस उच्च स्तर का निर्माण

367
00:19:47,000 --> 00:19:51,000
के विभाजन और जीत और कुछ फिर से और फिर कर

368
00:19:51,000 --> 00:19:56,000
कोड में है, तो यह कुछ हम फिर से समय के साथ देखेंगे.

369
00:19:56,000 --> 00:20:00,000
अब, एक अलग रूप में, अगर आप recursion के लिए नए हैं आप कम से कम अब समझना चाहिए

370
00:20:00,000 --> 00:20:02,000
क्यों यह हास्यास्पद है.

371
00:20:02,000 --> 00:20:05,000
मैं google.com पर जाने के लिए जा रहा हूँ,

372
00:20:05,000 --> 00:20:17,000
और मैं recursion पर कुछ युक्तियाँ और चालें के लिए खोज करने के लिए जा रहा हूँ, दर्ज करें.

373
00:20:17,000 --> 00:20:21,000
आप अगले व्यक्ति बताओ कि यदि वे अभी नहीं हँस रहे थे.

374
00:20:21,000 --> 00:20:23,000
क्या आप recursion क्या मतलब है?

375
00:20:23,000 --> 00:20:25,000
क्या आपका मतलब है आह, वहाँ हम चले.

376
00:20:25,000 --> 00:20:28,000
ठीक है, अब है कि हर किसी के बाकी है.

377
00:20:28,000 --> 00:20:30,000
एक छोटी सी ईस्टर अंडे गूगल में कहीं वहाँ एम्बेडेड.

378
00:20:30,000 --> 00:20:33,000
एक तरफ, एक लिंक हम पाठ्यक्रम वेबसाइट पर डाल के रूप में

379
00:20:33,000 --> 00:20:36,000
सिर्फ आज के लिए विभिन्न छँटाई एल्गोरिदम के इस ग्रिड है,

380
00:20:36,000 --> 00:20:39,000
जिनमें से कुछ हम पिछले हफ्ते में देखा है, लेकिन इस दृश्य के बारे में क्या अच्छा है

381
00:20:39,000 --> 00:20:43,000
के रूप में आप विभिन्न एल्गोरिदम से संबंधित बातों के आसपास अपने मन लपेटो करने की कोशिश

382
00:20:43,000 --> 00:20:46,000
पता है कि तुम बहुत आसानी अब आदानों की विभिन्न प्रकार के साथ शुरू कर सकते हैं.

383
00:20:46,000 --> 00:20:50,000
आदानों सभी आदानों ज्यादातर क्रमबद्ध, उलट आदानों यादृच्छिक और बहुत आगे है.

384
00:20:50,000 --> 00:20:53,000
जैसा कि आप, फिर कोशिश करें, अपने मन में इन बातों को भेद

385
00:20:53,000 --> 00:20:57,000
एहसास है कि व्याख्यान पृष्ठ पर पाठ्यक्रम की वेबसाइट पर इस URL

386
00:20:57,000 --> 00:21:00,000
आप उन लोगों में से कुछ के माध्यम से कारण मदद कर सकता है.

387
00:21:00,000 --> 00:21:05,000
>> आज हम अंत में एक देर से इस समस्या हल करने के लिए मिलता है,

388
00:21:05,000 --> 00:21:08,000
जो कि इस स्वैप समारोह सिर्फ काम नहीं किया था,

389
00:21:08,000 --> 00:21:12,000
और क्या इस समारोह स्वैप के साथ मौलिक समस्या थी,

390
00:21:12,000 --> 00:21:15,000
जो लक्ष्य में से एक था, फिर से, यहाँ और यहाँ का आदान - प्रदान करने के लिए एक मूल्य

391
00:21:15,000 --> 00:21:17,000
ऐसा है कि ऐसा होता है?

392
00:21:17,000 --> 00:21:20,000
यह वास्तव में काम नहीं किया. क्यों?

393
00:21:20,000 --> 00:21:22,000
हाँ.

394
00:21:22,000 --> 00:21:28,000
[अश्राव्य छात्र]

395
00:21:28,000 --> 00:21:31,000
वास्तव में, इस bugginess के लिए विवरण

396
00:21:31,000 --> 00:21:34,000
बस गया था क्योंकि जब आप सी में कार्य कॉल

397
00:21:34,000 --> 00:21:38,000
और उन कार्यों तर्क एक और ख यहाँ की तरह लेते हैं,

398
00:21:38,000 --> 00:21:42,000
आप जो कुछ भी आपको लगता है कि समारोह के लिए मूल्य प्रदान कर रहे हैं की प्रतियां में गुजर रहे हैं.

399
00:21:42,000 --> 00:21:46,000
आप मूल मान नहीं प्रदान कर खुद को कर रहे हैं,

400
00:21:46,000 --> 00:21:49,000
तो हम buggyc के संदर्भ में यह देखा,

401
00:21:49,000 --> 00:21:52,000
buggy3.c है, जो इस तरह एक छोटे से कुछ देखा.

402
00:21:52,000 --> 00:21:57,000
>> याद है कि हम x और y 1 और 2 के लिए initialized, क्रमशः था.

403
00:21:57,000 --> 00:21:59,000
हम तो बाहर मुद्रित है कि वे क्या कर रहे थे.

404
00:21:59,000 --> 00:22:03,000
मैं तो दावा किया है कि मैं उन्हें एक्स, वाई के स्वैप फोन करके गमागमन था.

405
00:22:03,000 --> 00:22:06,000
लेकिन समस्या यह थी कि गमागमन काम किया,

406
00:22:06,000 --> 00:22:10,000
लेकिन खुद स्वैप के दायरे में ही कार्य करते हैं.

407
00:22:10,000 --> 00:22:13,000
जैसे ही हम 40 लाइन उन बदली मूल्यों मारा

408
00:22:13,000 --> 00:22:16,000
दूर फेंक दिया गया तो, और कुछ नहीं

409
00:22:16,000 --> 00:22:21,000
मूल समारोह में मुख्य वास्तव में बिल्कुल बदल गया था,

410
00:22:21,000 --> 00:22:26,000
यदि ऐसा है तो आप वापस तो लगता है कि यह क्या हमारी स्मृति के मामले में की तरह लग रहा है के रूप में

411
00:22:26,000 --> 00:22:29,000
अगर बोर्ड के इस बाएँ हाथ की ओर का प्रतिनिधित्व करता है

412
00:22:29,000 --> 00:22:33,000
और मैं हर किसी के लिए अपना सर्वश्रेष्ठ करने के देखेंगे इस अगर बोर्ड के इस बाएँ हाथ की ओर

413
00:22:33,000 --> 00:22:37,000
कहते हैं, अपने राम, का प्रतिनिधित्व करता है और ढेर करने के लिए इस तरह से ऊपर पर बढ़ती जा रही है,

414
00:22:37,000 --> 00:22:43,000
और हम मुख्य तरह एक समारोह फोन, और मुख्य 2 स्थानीय चर, x और y है,

415
00:22:43,000 --> 00:22:48,000
चलो एक्स के रूप में उन लोगों के यहाँ का वर्णन है, और हम y के रूप में इन यहाँ का वर्णन,

416
00:22:48,000 --> 00:22:55,000
और 1 और 2 मूल्यों में डाल दिया तो, यहाँ इस मुख्य है,

417
00:22:55,000 --> 00:22:58,000
और जब मुख्य स्वैप समारोह ऑपरेटिंग सिस्टम कॉल

418
00:22:58,000 --> 00:23:02,000
स्वैप समारोह ढेर पर स्मृति के अपने खुद कटी हुई घास देता है,

419
00:23:02,000 --> 00:23:04,000
ढेर पर अपने स्वयं के फ्रेम, तो बात करो.

420
00:23:04,000 --> 00:23:08,000
यह भी इन ints के लिए 32 बिट का आवंटन है.

421
00:23:08,000 --> 00:23:11,000
यह एक और ख उन्हें फोन करने के लिए होता है, लेकिन यह है कि पूरी तरह से मनमाना है.

422
00:23:11,000 --> 00:23:13,000
यह उन्हें बुलाया हो सकता है जो यह चाहता है, लेकिन क्या होता है मुख्य जब

423
00:23:13,000 --> 00:23:19,000
कॉल स्वैप है यह इस 1 लेता है, वहाँ की नकल कहते हैं, वहाँ एक प्रतिलिपि डालता है.

424
00:23:19,000 --> 00:23:23,000
>> वहाँ 1 स्वैप में अन्य स्थानीय चर है, हालांकि, क्या >> tmp बुलाया है?.

425
00:23:23,000 --> 00:23:27,000
Tmp, तो मुझे अपने आप को एक और 32 बिट यहाँ दे,

426
00:23:27,000 --> 00:23:29,000
और क्या मैं इस समारोह में क्या किया?

427
00:23:29,000 --> 00:23:34,000
मैं ने कहा कि int tmp हो जाता है, तो एक 1 है, इसलिए मैं इस किया था जब हम पिछले इस उदाहरण के साथ खेला.

428
00:23:34,000 --> 00:23:39,000
फिर एक ख हो जाता है, तो बी 2 है, तो अब यह 2 हो जाता है,

429
00:23:39,000 --> 00:23:42,000
और अब अस्थायी ख हो जाता है, तो अस्थायी 1 है,

430
00:23:42,000 --> 00:23:44,000
तो अब ख हो जाता है.

431
00:23:44,000 --> 00:23:46,000
यह बहुत अच्छा है. यह काम किया.

432
00:23:46,000 --> 00:23:49,000
लेकिन तब के रूप में जल्द ही समारोह रिटर्न के रूप में

433
00:23:49,000 --> 00:23:52,000
स्वैप स्मृति को प्रभावी ढंग से गायब हो जाता है इतना है कि यह reused किया जा सकता है

434
00:23:52,000 --> 00:23:58,000
भविष्य में कुछ अन्य समारोह से, और मुख्य स्पष्ट रूप से पूरी तरह से अपरिवर्तित है.

435
00:23:58,000 --> 00:24:00,000
हम मौलिक इस समस्या के हल के लिए एक तरह की जरूरत है,

436
00:24:00,000 --> 00:24:03,000
और आज हम अंत में यह कर रही है जिससे की एक तरीका होगा

437
00:24:03,000 --> 00:24:06,000
हम कुछ एक सूचक बुलाया शुरू कर सकते हैं.

438
00:24:06,000 --> 00:24:09,000
यह पता चला है कि हम इस समस्या को हल कर सकते हैं

439
00:24:09,000 --> 00:24:12,000
एक्स और वाई की प्रतियां में पारित नहीं

440
00:24:12,000 --> 00:24:18,000
लेकिन बदले में क्या गुजर द्वारा, आप स्वैप समारोह के लिए लगता है?

441
00:24:18,000 --> 00:24:20,000
हाँ, पते के बारे में क्या?

442
00:24:20,000 --> 00:24:22,000
हम वास्तव में पतों के बारे में ज्यादा विस्तार से बात नहीं की है,

443
00:24:22,000 --> 00:24:25,000
लेकिन अगर इस ब्लैकबोर्ड अपने कंप्यूटर की स्मृति का प्रतिनिधित्व करता है

444
00:24:25,000 --> 00:24:28,000
हम निश्चित रूप से मेरे राम में बाइट्स नंबरिंग शुरू कर सकता है

445
00:24:28,000 --> 00:24:31,000
और कहते हैं कि यह # 1 बाइट है, इस बाइट # 2, # 3 बाइट,

446
00:24:31,000 --> 00:24:35,000
बाइट # 4, बाइट ... 2 अरब अगर मैं राम का 2 गीगाबाइट है,

447
00:24:35,000 --> 00:24:38,000
तो हम निश्चित रूप से कुछ मनमाने ढंग से क्रमांकन योजना के साथ आ सकता है

448
00:24:38,000 --> 00:24:41,000
मेरे कंप्यूटर की स्मृति में सभी व्यक्तिगत बाइट्स के लिए.

449
00:24:41,000 --> 00:24:43,000
>> अगर बजाय क्या जब मैं स्वैप कॉल

450
00:24:43,000 --> 00:24:47,000
एक्स और वाई के बजाय पास प्रतियों में

451
00:24:47,000 --> 00:24:51,000
मैं बजाय एक्स के पते में यहाँ क्यों पास नहीं है,

452
00:24:51,000 --> 00:24:55,000
यहाँ y के पते, अनिवार्य रूप से डाक पते

453
00:24:55,000 --> 00:24:59,000
एक्स और वाई की वजह से तो स्वैप, अगर उन्होंने बताया है

454
00:24:59,000 --> 00:25:01,000
एक्स और वाई की स्मृति में पते की,

455
00:25:01,000 --> 00:25:04,000
तो स्वैप, अगर हम उसे एक छोटा सा प्रशिक्षित,

456
00:25:04,000 --> 00:25:07,000
वह संभवतः उस पते पर ड्राइव इतनी बात करने के लिए कर सकता है,

457
00:25:07,000 --> 00:25:11,000
x, और वहाँ नंबर बदलने के लिए, तो y के पते पर ड्राइव,

458
00:25:11,000 --> 00:25:16,000
नंबर बदलने के लिए, यहाँ तक कि जब उन मूल्यों खुद की प्रतियां वास्तव में नहीं हो रही है,

459
00:25:16,000 --> 00:25:19,000
तो भले ही हम मुख्य स्मृति के रूप में किया जा रहा इस बारे में बात की थी

460
00:25:19,000 --> 00:25:23,000
और इस के रूप में किया जा रहा स्वैप स्मृति शक्तिशाली और सी के खतरनाक भाग

461
00:25:23,000 --> 00:25:28,000
यह है कि किसी भी समारोह में स्मृति कंप्यूटर में कहीं भी स्पर्श कर सकते हैं,

462
00:25:28,000 --> 00:25:32,000
और इस शक्तिशाली है कि आप सी में कंप्यूटर प्रोग्राम के साथ बहुत फैंसी बातें कर सकते हैं

463
00:25:32,000 --> 00:25:36,000
यह खतरनाक है क्योंकि आप भी बहुत आसानी से बिगाड़ सकता है.

464
00:25:36,000 --> 00:25:39,000
वास्तव में, कार्यक्रमों के लिए सबसे आम तरीके इन दिनों में से शोषण किया जा

465
00:25:39,000 --> 00:25:42,000
अभी भी है के लिए एक प्रोग्रामर का एहसास करने के लिए नहीं

466
00:25:42,000 --> 00:25:45,000
कि वह या वह एक डेटा की अनुमति है

467
00:25:45,000 --> 00:25:49,000
स्मृति में एक स्थान है कि इरादा नहीं था में लिखा हो.

468
00:25:49,000 --> 00:25:51,000
>> उदाहरण के लिए, वह या वह 10 आकार की एक सरणी की घोषणा

469
00:25:51,000 --> 00:25:56,000
लेकिन फिर गलती से स्मृति की कि सरणी में 11 बाइट्स डाल करने की कोशिश करता है,

470
00:25:56,000 --> 00:25:59,000
और आप स्मृति के कुछ हिस्सों कि अब वैध नहीं हैं छू शुरू.

471
00:25:59,000 --> 00:26:02,000
प्रासंगिक इस बस के लिए, आप में से कुछ पता चल सकता है कि

472
00:26:02,000 --> 00:26:06,000
सॉफ्टवेयर अक्सर आप सीरियल नंबर या पंजीकरण कुंजी के लिए संकेत देता है,

473
00:26:06,000 --> 00:26:08,000
Photoshop और वर्ड और इस तरह से प्रोग्राम.

474
00:26:08,000 --> 00:26:12,000
वहाँ दरारें मौजूद हैं, आप में से कुछ के रूप में जानते हैं, ऑनलाइन जहाँ आप एक छोटे से कार्यक्रम चला सकते हैं,

475
00:26:12,000 --> 00:26:14,000
और देखा, एक सीरियल नंबर के लिए कोई अनुरोध.

476
00:26:14,000 --> 00:26:16,000
कैसे है कि काम कर रहा है?

477
00:26:16,000 --> 00:26:21,000
कई मामलों में ये बातें बस कंप्यूटर में पा रहे हैं

478
00:26:21,000 --> 00:26:24,000
कंप्यूटर के वास्तविक शून्य और लोगों में पाठ क्षेत्रों

479
00:26:24,000 --> 00:26:28,000
कहाँ है कि समारोह है जहां सीरियल नंबर का अनुरोध किया जाता है,

480
00:26:28,000 --> 00:26:31,000
और आपको लगता है कि अंतरिक्ष अधिलेखित, या जब प्रोग्राम चल रहा है

481
00:26:31,000 --> 00:26:33,000
तुम बाहर आंकड़ा जहां कुंजी वास्तव में संग्रहित है

482
00:26:33,000 --> 00:26:37,000
कुछ का उपयोग करने के लिए एक डिबगर कहा जाता है, और आप सॉफ्टवेयर तरीका है कि दरार कर सकते हैं.

483
00:26:37,000 --> 00:26:40,000
यह करने के लिए अगले कुछ दिनों के लिए कहते हैं कि यह हमारा उद्देश्य है नहीं है,

484
00:26:40,000 --> 00:26:42,000
लेकिन यह बहुत वास्तविक दुनिया असर है.

485
00:26:42,000 --> 00:26:45,000
यह एक सॉफ्टवेयर की चोरी को शामिल करने के लिए होता है,

486
00:26:45,000 --> 00:26:47,000
लेकिन वहाँ भी पूरे मशीनों के समझौता है.

487
00:26:47,000 --> 00:26:50,000
>> वास्तव में, वेबसाइटों इन दिनों जब शोषण कर रहे हैं

488
00:26:50,000 --> 00:26:53,000
और समझौता और डेटा लीक है और पासवर्ड चोरी हो रहे हैं

489
00:26:53,000 --> 00:26:58,000
यह बहुत अक्सर एक स्मृति के गरीब प्रबंधन से संबंधित है,

490
00:26:58,000 --> 00:27:01,000
या, डेटाबेस के मामले में, विफलता को आशा

491
00:27:01,000 --> 00:27:03,000
adversarial इनपुट, तो सप्ताह में उस पर और अधिक के लिए आने के,

492
00:27:03,000 --> 00:27:07,000
लेकिन अभी के लिए क्षति की तरह का एक पूर्वावलोकन चुपके है कि आप कर सकते हैं

493
00:27:07,000 --> 00:27:11,000
समझ कैसे चीजें हुड के नीचे काम नहीं काफी.

494
00:27:11,000 --> 00:27:14,000
चलो समझ क्यों यह टूट गया है के बारे में जाना

495
00:27:14,000 --> 00:27:17,000
एक उपकरण के साथ कि अधिक से अधिक उपयोगी हो जाएगा

496
00:27:17,000 --> 00:27:19,000
हमारे कार्यक्रमों के रूप में और अधिक जटिल हो.

497
00:27:19,000 --> 00:27:21,000
इस प्रकार अब तक जब आप अपने कार्यक्रम में एक बग था

498
00:27:21,000 --> 00:27:23,000
आप इसे debugging के बारे में कैसे चले गए हैं?

499
00:27:23,000 --> 00:27:25,000
अपनी तकनीक इस प्रकार अब तक क्या किया गया है, चाहे अपने TF द्वारा सिखाया

500
00:27:25,000 --> 00:27:27,000
या सिर्फ आत्म सिखाया?

501
00:27:27,000 --> 00:27:29,000
[छात्र] printf.

502
00:27:29,000 --> 00:27:31,000
Printf, तो printf शायद उस में अपने दोस्त किया गया है अगर आप देखना चाहते हैं

503
00:27:31,000 --> 00:27:33,000
क्या हो रहा है अपने कार्यक्रम के अंदर

504
00:27:33,000 --> 00:27:36,000
तुम सिर्फ printf यहाँ रखा, यहाँ printf printf यहाँ.

505
00:27:36,000 --> 00:27:38,000
तब आप इसे चलाने के लिए, और आप स्क्रीन पर एक सामान की एक पूरी गुच्छा ले आओ

506
00:27:38,000 --> 00:27:43,000
कि तुम तो परिणाम निकालना क्या वास्तव में अपने कार्यक्रम में गलत हो रहा है के लिए उपयोग कर सकते हैं.

507
00:27:43,000 --> 00:27:45,000
>> Printf करने के लिए एक बहुत शक्तिशाली बात हो जाता है,

508
00:27:45,000 --> 00:27:47,000
लेकिन यह एक बहुत मैन्युअल प्रक्रिया है.

509
00:27:47,000 --> 00:27:49,000
आप एक printf यहाँ डाल दिया है एक printf यहाँ,,

510
00:27:49,000 --> 00:27:51,000
और यदि आप इसे एक पाश के अंदर रख दिया आप 100 लाइनों मिल सकता है

511
00:27:51,000 --> 00:27:53,000
उत्पादन है कि आप फिर के माध्यम से कपड़छान की.

512
00:27:53,000 --> 00:27:58,000
यह डिबगिंग कार्यक्रमों के लिए एक बहुत उपयोगकर्ता के अनुकूल या इंटरैक्टिव तंत्र नहीं है,

513
00:27:58,000 --> 00:28:00,000
लेकिन शुक्र है वहाँ विकल्प मौजूद है.

514
00:28:00,000 --> 00:28:03,000
उदाहरण के लिए एक कार्यक्रम है,, GDB कहा जाता है, GNU डिबगर है,

515
00:28:03,000 --> 00:28:06,000
जो कि कैसे आप इसे उपयोग में एक छोटे से रहस्यमय है.

516
00:28:06,000 --> 00:28:08,000
यह थोड़ा जटिल है, लेकिन स्पष्ट रूप से,

517
00:28:08,000 --> 00:28:11,000
यह उन चीजों है जहां अगर आप इस सप्ताह में डाल दिया है और एक अगले है

518
00:28:11,000 --> 00:28:14,000
अतिरिक्त GDB की तरह कुछ को समझने के लिए एक घंटे

519
00:28:14,000 --> 00:28:18,000
यह आप लंबे समय में घंटे की शायद दसियों बचा होगा,

520
00:28:18,000 --> 00:28:21,000
तो उस के साथ, मुझे तुम कैसे काम करता है इस बात का एक नमूना दे.

521
00:28:21,000 --> 00:28:23,000
>> मैं अपने टर्मिनल विंडो में हूँ.

522
00:28:23,000 --> 00:28:26,000
मुझे आगे जाना है और इस कार्यक्रम, buggy3 संकलन.

523
00:28:26,000 --> 00:28:28,000
यह पहले से ही ऊपर है तिथि करने के लिए है.

524
00:28:28,000 --> 00:28:31,000
मुझे इसे चलाने जैसे हम एक समय पहले किया था, और वास्तव में यह टूट गया है.

525
00:28:31,000 --> 00:28:34,000
लेकिन ऐसा क्यों है? शायद मैं स्वैप समारोह खराब कर दिया है.

526
00:28:34,000 --> 00:28:37,000
शायद यह एक और ख है. मैं उन्हें काफी नहीं जा रहा हूँ सही ढंग से चारों ओर.

527
00:28:37,000 --> 00:28:39,000
मुझे आगे जाना है और यह नहीं है.

528
00:28:39,000 --> 00:28:43,000
के बजाय सिर्फ buggy3 चलाने के बजाय मुझे इस कार्यक्रम GDB चलाने,

529
00:28:43,000 --> 00:28:48,000
और मैं यह बताने के लिए buggy3 चलाने के लिए जा रहा हूँ,

530
00:28:48,000 --> 00:28:52,000
और मैं एक कमांड लाइन तर्क, tui को शामिल करने के लिए जा रहा हूँ,

531
00:28:52,000 --> 00:28:55,000
और हम कल्पना में भविष्य की समस्याओं के लिए याद दिलाना में डाल देता हूँ.

532
00:28:55,000 --> 00:28:57,000
और अब इस काले और सफेद इंटरफ़ेस popped है कि फिर से,

533
00:28:57,000 --> 00:28:59,000
पहली बार में थोड़ा भारी है क्योंकि वहाँ यह सब क्या है

534
00:28:59,000 --> 00:29:02,000
यहाँ नीचे वारंटी जानकारी है, लेकिन कम से कम कुछ परिचित है.

535
00:29:02,000 --> 00:29:04,000
विंडो के शीर्ष में मेरी वास्तविक कोड है,

536
00:29:04,000 --> 00:29:08,000
और अगर मैं यहाँ स्क्रॉल मुझे बहुत मेरी फ़ाइल के शीर्ष करने के लिए स्क्रॉल,

537
00:29:08,000 --> 00:29:11,000
और वास्तव में, इस विंडो के नीचे buggy3.c और नोटिस

538
00:29:11,000 --> 00:29:13,000
मैं इस GDB संकेत है.

539
00:29:13,000 --> 00:29:16,000
>> यह मेरे सामान्य जॉन हार्वर्ड संकेत के रूप में ही नहीं है.

540
00:29:16,000 --> 00:29:19,000
यह एक संकेत है कि मुझे GDB को नियंत्रित करने के लिए अनुमति देने के लिए जा रहा है है.

541
00:29:19,000 --> 00:29:21,000
GDB एक डिबगर है.

542
00:29:21,000 --> 00:29:24,000
डीबगर एक प्रोग्राम है जो आप के माध्यम से चलना है

543
00:29:24,000 --> 00:29:27,000
अपने प्रोग्राम लाइन की लाइन से लाइन से निष्पादन,

544
00:29:27,000 --> 00:29:30,000
जिस तरह से कुछ भी आप इस कार्यक्रम के लिए चाहते हैं कर के साथ,

545
00:29:30,000 --> 00:29:33,000
भी कार्यों बुला देख रहे हैं या अधिक महत्वपूर्ण बात,

546
00:29:33,000 --> 00:29:35,000
विभिन्न चर के मूल्यों में.

547
00:29:35,000 --> 00:29:37,000
चलो आगे बढ़ो और इस करना.

548
00:29:37,000 --> 00:29:40,000
मुझे आगे जाना है और GDB शीघ्र चलाने में टाइप करने के लिए जा रहा हूँ,

549
00:29:40,000 --> 00:29:43,000
तो स्क्रीन मैं टाइप चलाने की है के नीचे छोड़ दिया पर नोटिस

550
00:29:43,000 --> 00:29:45,000
और मैं दर्ज मारा है, और कहा कि क्या किया?

551
00:29:45,000 --> 00:29:50,000
यह सचमुच मेरे कार्यक्रम भाग गया, लेकिन मैं वास्तव में बहुत यहाँ पर जाना नहीं देखा था

552
00:29:50,000 --> 00:29:55,000
क्योंकि मैं वास्तव में डिबगर नहीं बताया है

553
00:29:55,000 --> 00:29:57,000
समय में एक खास पल में थामने के लिए.

554
00:29:57,000 --> 00:29:59,000
बस चलाने के लिए टाइपिंग कार्यक्रम चलाता है.

555
00:29:59,000 --> 00:30:01,000
मैं वास्तव में कुछ भी नहीं दिख रहा है. मैं यह हेरफेर नहीं कर सकते.

556
00:30:01,000 --> 00:30:03,000
>> इसके बजाय मुझे यह करना.

557
00:30:03,000 --> 00:30:08,000
इस GDB प्रॉम्प्ट पर मुझे बजाय ब्रेक लिखें, दर्ज करें.

558
00:30:08,000 --> 00:30:10,000
यही नहीं मैं क्या टाइप करने का मतलब है.

559
00:30:10,000 --> 00:30:13,000
बदले जाने को तोड़ने के मुख्य लिखें.

560
00:30:13,000 --> 00:30:15,000
दूसरे शब्दों में, मैं एक breakpoint कहलाती सेट करना चाहते हैं,

561
00:30:15,000 --> 00:30:18,000
जो aptly क्योंकि इसे तोड़ने या को थामने के नाम पर रखा गया है

562
00:30:18,000 --> 00:30:21,000
कि विशेष जगह पर अपने कार्यक्रम के निष्पादन.

563
00:30:21,000 --> 00:30:23,000
मुख्य समारोह के नाम है.

564
00:30:23,000 --> 00:30:25,000
सूचना है कि GDB बहुत चालाक है.

565
00:30:25,000 --> 00:30:28,000
यह पता लगा है कि मुख्य लगभग 18 लाइन पर शुरू होता है

566
00:30:28,000 --> 00:30:32,000
buggy3.c, और फिर ऊपर छोड़ दिया पर नोटिस

567
00:30:32,000 --> 00:30:34,000
बी + 18 लाइन के बगल में है.

568
00:30:34,000 --> 00:30:38,000
कि मुझे याद दिलाता है कि मैं 18 लाइन पर एक ब्रेकपाइंट सेट है.

569
00:30:38,000 --> 00:30:42,000
इस बार जब मैं रन लिखते हैं, मैं अपने कार्यक्रम चलाने के लिए जा रहा हूँ

570
00:30:42,000 --> 00:30:45,000
जब तक यह है कि breakpoint हिट,

571
00:30:45,000 --> 00:30:48,000
तो प्रोग्राम मेरे लिए 18 लाइन पर रुकेगा.

572
00:30:48,000 --> 00:30:50,000
यहाँ हम चले, चलाते हैं.

573
00:30:50,000 --> 00:30:53,000
कुछ भी नहीं हुआ है प्रकट होता है, लेकिन तल पर नोटिस छोड़ दिया

574
00:30:53,000 --> 00:30:58,000
कार्यक्रम शुरू करने, buggy3, मुख्य buggy3.c 18 लाइन पर ब्रेकपाइंट 1.

575
00:30:58,000 --> 00:31:00,000
अब मैं क्या कर सकते हैं?

576
00:31:00,000 --> 00:31:03,000
>> सूचना मैंने प्रिंट की तरह बातें लिखना शुरू कर सकते हैं,

577
00:31:03,000 --> 00:31:08,000
printf नहीं, प्रिंट x, और अब यह अजीब है.

578
00:31:08,000 --> 00:31:11,000
$ 1 बस एक जिज्ञासा है, जैसा कि हम देखेंगे

579
00:31:11,000 --> 00:31:14,000
हर बार जब आप कुछ प्रिंट आप एक नया मान $ मिलता है.

580
00:31:14,000 --> 00:31:18,000
ऐसा है कि तुम वापस बस के मामले में पिछले मूल्यों का उल्लेख कर सकते हैं,

581
00:31:18,000 --> 00:31:21,000
लेकिन अब के लिए क्या है प्रिंट मुझे बता रहा है कि कहानी में इस बिंदु पर एक्स का मान

582
00:31:21,000 --> 00:31:26,000
जाहिरा तौर पर है 134514032.

583
00:31:26,000 --> 00:31:29,000
क्या? कहाँ है कि भी से आए हो?

584
00:31:29,000 --> 00:31:31,000
[अश्राव्य छात्र]

585
00:31:31,000 --> 00:31:34,000
वास्तव में, यह है कि क्या हम एक कचरा मूल्य फोन करता हूँ, और हम इस बारे में अभी तक बात नहीं की है,

586
00:31:34,000 --> 00:31:37,000
लेकिन कारण है कि आप चर इनिशियलाइज़

587
00:31:37,000 --> 00:31:40,000
जाहिर है इतना है कि वे कुछ मूल्य है कि आप उन्हें चाहते है.

588
00:31:40,000 --> 00:31:44,000
लेकिन पकड़ याद है कि आप चर घोषणा कर सकते हैं

589
00:31:44,000 --> 00:31:46,000
जैसे मैं मेरी सिग्मा उदाहरण में एक पल पहले किया था

590
00:31:46,000 --> 00:31:48,000
वास्तव में उन्हें एक मूल्य देने के बिना.

591
00:31:48,000 --> 00:31:50,000
याद है कि मैं क्या सिग्मा में यहाँ था.

592
00:31:50,000 --> 00:31:52,000
मैं n की घोषणा की है, लेकिन क्या मूल्य मैं इसे देने के लिए किया था?

593
00:31:52,000 --> 00:31:56,000
कोई नहीं, क्योंकि मैं जानता था कि अगले कुछ लाइनों में

594
00:31:56,000 --> 00:31:59,000
GetInt n के अंदर एक मूल्य डालने की समस्या का ख्याल रखना होगा.

595
00:31:59,000 --> 00:32:02,000
>> लेकिन 11 लाइन की कहानी में इस बिंदु पर

596
00:32:02,000 --> 00:32:05,000
लाइन और 12 और 13 लाइन और 14 लाइन

597
00:32:05,000 --> 00:32:08,000
उन कई पंक्तियों में n के मूल्य क्या है?

598
00:32:08,000 --> 00:32:10,000
सी में आप अभी पता नहीं है.

599
00:32:10,000 --> 00:32:14,000
यह आम तौर पर कुछ कचरा मान, कुछ पूरी तरह से यादृच्छिक संख्या

600
00:32:14,000 --> 00:32:17,000
पर छोड़ दिया है कि अनिवार्य रूप से पिछले कुछ समारोह से

601
00:32:17,000 --> 00:32:21,000
होने चलाने के लिए किया गया है ताकि अपने कार्यक्रम चलाता

602
00:32:21,000 --> 00:32:24,000
याद है कि समारोह समारोह, समारोह, समारोह, हो जाता है.

603
00:32:24,000 --> 00:32:27,000
इन सभी फ्रेम स्मृति पर डाल दिया हो, और फिर उन कार्यों वापसी

604
00:32:27,000 --> 00:32:31,000
और बस की तरह मैं रबड़ अंततः उनकी स्मृति reused किया है के साथ सुझाव दिया.

605
00:32:31,000 --> 00:32:37,000
ठीक है, यह सिर्फ इतना है कि इस कार्यक्रम में इस चर x होता है

606
00:32:37,000 --> 00:32:41,000
जैसे कुछ कचरा मान 134514032 निहित है लगता है

607
00:32:41,000 --> 00:32:44,000
पिछले कुछ समारोह से एक नहीं है कि मैं ने लिखा.

608
00:32:44,000 --> 00:32:47,000
यह कुछ ऐसा है कि ऑपरेटिंग सिस्टम के साथ प्रभावी ढंग से आता है हो सकता है,

609
00:32:47,000 --> 00:32:49,000
हुड के नीचे कुछ समारोह.

610
00:32:49,000 --> 00:32:52,000
>> ठीक है, ठीक है, लेकिन अब हम अगली पंक्ति के लिए अग्रिम.

611
00:32:52,000 --> 00:32:55,000
यदि मैं अपने GDB प्रांप्ट पर "अगले" टाइप करें और मैं हिट दर्ज करें,

612
00:32:55,000 --> 00:32:58,000
सूचना है कि चाल हाइलाइटिंग 19 लाइन के लिए नीचे,

613
00:32:58,000 --> 00:33:01,000
लेकिन तार्किक निहितार्थ यह है कि 18 लाइन

614
00:33:01,000 --> 00:33:06,000
अब समाप्त हो गया है, "प्रिंट x" को क्रियान्वित करने, यदि ऐसा है तो मैं फिर से लिखें

615
00:33:06,000 --> 00:33:10,000
अब मैं 1 देखें चाहिए, और वास्तव में, मैं.

616
00:33:10,000 --> 00:33:14,000
फिर, सामान $ GDB तुम्हें याद दिलाने का एक तरीका है

617
00:33:14,000 --> 00:33:17,000
प्रिंट के इतिहास किया है कि आप क्या कर रहे हैं.

618
00:33:17,000 --> 00:33:21,000
अब मुझे आगे जाना है और बाहर y मुद्रित करने के लिए, और वास्तव, y कुछ पागल मूल्य के रूप में अच्छी तरह से है,

619
00:33:21,000 --> 00:33:24,000
लेकिन कोई बड़ी बात नहीं है क्योंकि 19 लाइन में, हम इसके बारे में आवंटित करने के लिए कर रहे हैं

620
00:33:24,000 --> 00:33:27,000
मूल्य 2, तो मुझे "अगले" फिर से लिखें.

621
00:33:27,000 --> 00:33:29,000
और अब हम printf लाइन पर हैं.

622
00:33:29,000 --> 00:33:31,000
मुझे प्रिंट x.

623
00:33:31,000 --> 00:33:34,000
मुझे प्रिंट y करते हैं. सच कहूँ तो, मैं एक छोटे से इस मुद्रण के थक चुका हूँ.

624
00:33:34,000 --> 00:33:38,000
मुझे बजाय "प्रदर्शन x" और "प्रदर्शन y," टाइप

625
00:33:38,000 --> 00:33:41,000
और अब हर बार मैं भविष्य में एक आदेश टाइप करें

626
00:33:41,000 --> 00:33:45,000
मैं क्या याद दिलाया जाएगा एक्स और वाई, क्या है एक्स और वाई, एक्स और वाई.

627
00:33:45,000 --> 00:33:48,000
>> मैं भी, एक अलग प्रकार, "जानकारी स्थानीय लोगों के रूप में कर सकते हैं."

628
00:33:48,000 --> 00:33:50,000
जानकारी एक विशेष आदेश है.

629
00:33:50,000 --> 00:33:52,000
स्थानीय लोगों का मतलब है कि यह मेरे स्थानीय चर से पता चलता है.

630
00:33:52,000 --> 00:33:55,000
सिर्फ मामले में मैं भूल जाते हैं या यह एक पागल, जटिल समारोह है

631
00:33:55,000 --> 00:33:57,000
कि मैं या किसी और ने लिखा है की जानकारी स्थानीय लोगों को आपको बता देगा

632
00:33:57,000 --> 00:34:00,000
इस स्थानीय समारोह के अंदर सभी स्थानीय चर क्या कर रहे हैं

633
00:34:00,000 --> 00:34:03,000
है कि आप अगर आप चारों ओर ढकेलना चाहते हैं के बारे में परवाह सकता है.

634
00:34:03,000 --> 00:34:07,000
अब, printf निष्पादित करने के बारे में है, तो मुझे आगे और बस प्रकार जाना "अगले."

635
00:34:07,000 --> 00:34:10,000
क्योंकि हम इस माहौल में कर रहे हैं हम वास्तव में यह नहीं देख रहे हैं

636
00:34:10,000 --> 00:34:14,000
यहाँ नीचे निष्पादित, लेकिन यह एक छोटे से घायल हो रही है नोटिस.

637
00:34:14,000 --> 00:34:17,000
नोटिस लेकिन यह स्क्रीन अधिभावी वहाँ,

638
00:34:17,000 --> 00:34:21,000
तो यह एक सही यहाँ कार्यक्रम नहीं है, लेकिन यह ठीक है क्योंकि मैं हमेशा के आसपास प्रहार कर सकते हैं

639
00:34:21,000 --> 00:34:23,000
प्रिंट का उपयोग अगर मैं चाहता हूँ.

640
00:34:23,000 --> 00:34:26,000
>> मुझे अगले फिर से लिखें, और अब यहाँ दिलचस्प हिस्सा है.

641
00:34:26,000 --> 00:34:29,000
कहानी में इस बिंदु पर y 2 है, और एक्स 1 है,

642
00:34:29,000 --> 00:34:32,000
के रूप में यहाँ का सुझाव दिया, और फिर,

643
00:34:32,000 --> 00:34:35,000
कारण है कि अब यह स्वचालित रूप से प्रदर्शित कर रहा है क्योंकि मैं कमांड का इस्तेमाल किया है

644
00:34:35,000 --> 00:34:40,000
प्रदर्शन एक्स और प्रदर्शन y, तो पल मैं अगले प्रकार

645
00:34:40,000 --> 00:34:43,000
सिद्धांत एक्स और वाई में बदली हो जाना चाहिए.

646
00:34:43,000 --> 00:34:45,000
अब, हम पहले से ही जानते हैं कि इस मामले होना नहीं जा रहा है,

647
00:34:45,000 --> 00:34:49,000
लेकिन हम एक पल में देखते हैं कि हम गहरा गोता के लिए बाहर आंकड़ा क्यों कि यह सच है.

648
00:34:49,000 --> 00:34:54,000
अगला, और दुर्भाग्य से, y अभी भी 2 और एक्स अभी भी है 1, और मैं के रूप में ज्यादा की पुष्टि कर सकते हैं.

649
00:34:54,000 --> 00:34:56,000
प्रिंट x, प्रिंट y.

650
00:34:56,000 --> 00:34:59,000
दरअसल, गमागमन कोई वास्तव में हुआ है, तो हम इस पर शुरू.

651
00:34:59,000 --> 00:35:01,000
जाहिर स्वैप टूट गया है.

652
00:35:01,000 --> 00:35:04,000
चलो बजाय "रन" पुन: लिखें.

653
00:35:04,000 --> 00:35:07,000
मुझे हाँ कहने के, मैं इसे शुरू से पुनः आरंभ करना चाहते हैं.

654
00:35:07,000 --> 00:35:09,000
>> अब मैं वापस 18 लाइन पर हूँ.

655
00:35:09,000 --> 00:35:11,000
अब नोटिस एक्स और वाई कचरा मूल्यों फिर से कर रहे हैं.

656
00:35:11,000 --> 00:35:15,000
अगले, अगले, अगले, अगले.

657
00:35:15,000 --> 00:35:17,000
यदि मैं ऊब मैं भी बस के लिए अगले n टाइप कर सकते हैं.

658
00:35:17,000 --> 00:35:21,000
आप इसे वर्णों की कम से कम संभव अनुक्रम को संक्षिप्त कर सकते हैं.

659
00:35:21,000 --> 00:35:23,000
स्वैप अब टूट गया है.

660
00:35:23,000 --> 00:35:25,000
गोता में, चलो इतना के बजाय अगले टाइपिंग की,

661
00:35:25,000 --> 00:35:30,000
अब मैं करने के लिए कदम लिखने जा रहा हूँ इतना है कि मैं इस समारोह के अंदर कदम रख रहा हूँ

662
00:35:30,000 --> 00:35:33,000
इतना है कि मैं इसे माध्यम से चल सकता है तो, मैं कदम मारा और फिर दर्ज करें.

663
00:35:33,000 --> 00:35:37,000
ध्यान दें कि हाइलाइटिंग कूदता नीचे अपने कार्यक्रम में 36 लाइन के लिए कम.

664
00:35:37,000 --> 00:35:39,000
अब स्थानीय चर क्या कर रहे हैं?

665
00:35:39,000 --> 00:35:41,000
जानकारी स्थानीय लोगों को.

666
00:35:41,000 --> 00:35:43,000
बस अभी तक कुछ भी नहीं है क्योंकि हम उस लाइन के लिए नहीं मिल गया है,

667
00:35:43,000 --> 00:35:47,000
तो चलो आगे जाना है और कहते हैं, "अगले."

668
00:35:47,000 --> 00:35:50,000
अब हम tmp, प्रिंट tmp है लगता है.

669
00:35:50,000 --> 00:35:52,000
कचरा मूल्य, है ना? एसा मुझे मालूम होता हैं

670
00:35:52,000 --> 00:35:55,000
कैसे के बारे में एक, प्रिंट, ख, 1 और 2 प्रिंट?

671
00:35:55,000 --> 00:35:58,000
एक पल में, जैसे ही मैं अगले दोबारा लिखें

672
00:35:58,000 --> 00:36:02,000
tmp 1 के एक मूल्य पर ले, उम्मीद की जा रही है,

673
00:36:02,000 --> 00:36:05,000
क्योंकि tmp करने के लिए एक मूल्य सौंपा जा रहा है.

674
00:36:05,000 --> 00:36:08,000
>> अब चलो एक, प्रिंट ख मुद्रित करते हैं,

675
00:36:08,000 --> 00:36:11,000
लेकिन अब tmp मुद्रित करने के लिए, और यह वास्तव में है 1.

676
00:36:11,000 --> 00:36:14,000
मुझे आगे क्या करना है. मुझे आगे क्या करना है.

677
00:36:14,000 --> 00:36:16,000
मैं स्वैप समारोह समाप्त हो गया है.

678
00:36:16,000 --> 00:36:19,000
मैं अभी भी अंदर 40 लाइन में हूँ, तो मुझे एक प्रिंट

679
00:36:19,000 --> 00:36:22,000
प्रिंट ख, और मैं नहीं परवाह नहीं tmp क्या है.

680
00:36:22,000 --> 00:36:27,000
ऐसा लगता है कि स्वैप सही है जब यह ए और बी गमागमन आता.

681
00:36:27,000 --> 00:36:31,000
लेकिन अगर मैं अब अगले टाइप करें, मैं 25 लाइन के लिए वापस कूद,

682
00:36:31,000 --> 00:36:34,000
और जाहिर है, अगर मैं एक्स और प्रिंट y में प्रकार

683
00:36:34,000 --> 00:36:38,000
वे अभी भी अपरिवर्तित रहे हैं, तो हम इस समस्या को तय नहीं किया है.

684
00:36:38,000 --> 00:36:41,000
लेकिन अब शायद diagnostically इस GDB कार्यक्रम के साथ

685
00:36:41,000 --> 00:36:44,000
हम कम से कम एक कदम को समझने के लिए करीब मिल गया है

686
00:36:44,000 --> 00:36:47,000
कूड़े को एक printf यहाँ डालने से हमारे कोड के लिए बिना क्या गलत हो रहा है,

687
00:36:47,000 --> 00:36:50,000
printf यहाँ, printf यहाँ और फिर इसे फिर से और फिर से चलाने

688
00:36:50,000 --> 00:36:52,000
पता लगाने की क्या गलत हो रहा है की कोशिश कर रहा है.

689
00:36:52,000 --> 00:36:55,000
>> मुझे आगे जाना है और इस के बाहर छोड़ छोड़ने के साथ पूरी तरह करने के लिए जा रहा हूँ.

690
00:36:55,000 --> 00:36:57,000
"वैसे भी छोड़ो?" यह तो कहने जा रहा है हां.

691
00:36:57,000 --> 00:37:00,000
अब मैं अपने सामान्य प्रॉम्प्ट पर वापस आ गया हूँ, और मैं GDB का उपयोग कर रहा हूँ.

692
00:37:00,000 --> 00:37:03,000
एक अलग रूप में, आप इस tui ध्वज का उपयोग करने की जरूरत नहीं है.

693
00:37:03,000 --> 00:37:07,000
वास्तव में, यदि आप यह न आना तुम अनिवार्य रूप से स्क्रीन के नीचे आधा मिलता है.

694
00:37:07,000 --> 00:37:11,000
अगर मैं तब को तोड़ने के मुख्य लिखें और फिर चलाने

695
00:37:11,000 --> 00:37:15,000
मैं अभी भी अपने कार्यक्रम चलाने के लिए, कर सकते हैं, लेकिन क्या यह करना होगा और अधिक पाठ की दृष्टि से है

696
00:37:15,000 --> 00:37:18,000
बस मुझे एक समय में वर्तमान लाइन एक दिखाने.

697
00:37:18,000 --> 00:37:21,000
TUI, शाब्दिक उपयोगकर्ता इंटरफ़ेस,

698
00:37:21,000 --> 00:37:25,000
सिर्फ आपको पता चलता है एक बार, जो शायद एक बिट धारणात्मक आसान है पर कार्यक्रम की अधिक है.

699
00:37:25,000 --> 00:37:27,000
लेकिन वास्तव में, मैं सिर्फ अगले, अगले, अगले कर सकते हैं,

700
00:37:27,000 --> 00:37:30,000
और मैं एक समय में एक लाइन को देखने के लिए जा रहा हूँ, और अगर मैं वास्तव में देखने के लिए क्या हो रहा है

701
00:37:30,000 --> 00:37:35,000
मैं सूची लिखें और पड़ोसी लाइनों की एक पूरी गुच्छा देख सकते हैं.

702
00:37:35,000 --> 00:37:39,000
>> वहाँ एक वीडियो है कि हमने कहा है कि आपको देखने के लिए समस्या है 3 सेट

703
00:37:39,000 --> 00:37:43,000
जिसमें नैट GDB का जटिलताओं के कुछ शामिल है,

704
00:37:43,000 --> 00:37:46,000
और यह उन चीजों में से एक है, ईमानदारी से, जहां आप में से कुछ प्रतिशत गैर तुच्छ

705
00:37:46,000 --> 00:37:49,000
को छूने, कभी नहीं होगा GDB और कि एक बुरी बात हो जाएगा

706
00:37:49,000 --> 00:37:53,000
क्योंकि सचमुच तुम अंत में अधिक समय बाद में इस सेमेस्टर खर्च करेगा

707
00:37:53,000 --> 00:37:56,000
नीचे कीड़े का पीछा करते हुए तो आप अगर आप कि आधे घंटे / घंटे में डाल दिया होगा

708
00:37:56,000 --> 00:38:00,000
इस सप्ताह और अगले सीखने GDB के साथ आराम मिलता है.

709
00:38:00,000 --> 00:38:02,000
Printf तुम्हारा दोस्त था.

710
00:38:02,000 --> 00:38:05,000
GDB अब अपने दोस्त होना चाहिए.

711
00:38:05,000 --> 00:38:08,000
>> GDB पर कोई सवाल?

712
00:38:08,000 --> 00:38:12,000
और यहाँ सबसे शक्तिशाली और उपयोगी आदेशों में से कुछ की एक त्वरित सूची है.

713
00:38:12,000 --> 00:38:15,000
हाँ. >> आप एक स्ट्रिंग मुद्रित कर सकते हैं?

714
00:38:15,000 --> 00:38:17,000
आप एक स्ट्रिंग प्रिंट कर सकते हैं? बिल्कुल.

715
00:38:17,000 --> 00:38:19,000
यह बस हो integers नहीं है.

716
00:38:19,000 --> 00:38:22,000
यदि एक चर के एक प्रिंट है में बस प्रकार स्ट्रिंग है.

717
00:38:22,000 --> 00:38:24,000
यह आपको दिखाने के लिए क्या है कि स्ट्रिंग चर.

718
00:38:24,000 --> 00:38:26,000
[अश्राव्य छात्र]

719
00:38:26,000 --> 00:38:28,000
यह आपको पता और स्ट्रिंग ही दे देंगे.

720
00:38:28,000 --> 00:38:32,000
यह आप दोनों को दिखा देंगे.

721
00:38:32,000 --> 00:38:34,000
और एक आखिरी बात, सिर्फ इसलिए कि ये भी पता करने के लिए अच्छा कर रहे हैं.

722
00:38:34,000 --> 00:38:37,000
बैकट्रैस और फ्रेम, मुझे यह एक पिछले समय में गोता

723
00:38:37,000 --> 00:38:39,000
GDB के साथ एक ही सटीक कार्यक्रम.

724
00:38:39,000 --> 00:38:44,000
मुझे आगे जाना है और शाब्दिक उपयोगकर्ता इंटरफ़ेस संस्करण को चलाने,

725
00:38:44,000 --> 00:38:46,000
मुख्य तोड़ने के लिए.

726
00:38:46,000 --> 00:38:49,000
मुझे आगे जाना है और फिर से चलाने के. मैं यहाँ हूँ.

727
00:38:49,000 --> 00:38:55,000
अब मुझे अगले, अगले, अगले, अगले, अगले जाना, कदम दर्ज करें.

728
00:38:55,000 --> 00:39:00,000
>> और अब लगता है कि मैं स्वैप में अब जानबूझ कर रहा हूँ, लेकिन मैं जैसा हूँ "अरे, एक्स का मान क्या था?"

729
00:39:00,000 --> 00:39:02,000
मैं एक्स और नहीं कर सकता.

730
00:39:02,000 --> 00:39:05,000
मैं y नहीं है क्योंकि वे दायरे में नहीं हो सकता है.

731
00:39:05,000 --> 00:39:07,000
वे संदर्भ में नहीं हो, लेकिन कोई समस्या नहीं है.

732
00:39:07,000 --> 00:39:09,000
मैं बैकट्रैस लिख सकते हैं.

733
00:39:09,000 --> 00:39:13,000
कि मुझे सभी कार्य करता है कि समय में इस बिंदु को मार डाला है पता चलता है.

734
00:39:13,000 --> 00:39:16,000
सूचना है कि मुख्य तल पर एक साथ, मुख्य, अप लाइन

735
00:39:16,000 --> 00:39:18,000
यहाँ हमारी तस्वीर के नीचे जा रहा है.

736
00:39:18,000 --> 00:39:22,000
तथ्य यह है कि स्वैप स्वैप स्मृति में यह ऊपर जा रहा है यह लाइनों के ऊपर के साथ है,

737
00:39:22,000 --> 00:39:26,000
और अगर मैं मुख्य वापस करने के लिए अस्थायी रूप से प्राप्त करना चाहते हैं तो मैं "फ्रेम." कह सकते हैं

738
00:39:26,000 --> 00:39:30,000
संख्या क्या है? मुख्य # 1 फ्रेम है.

739
00:39:30,000 --> 00:39:32,000
मुझे आगे जाना है और कहने जा रहा हूँ "1 फ्रेम."

740
00:39:32,000 --> 00:39:36,000
>> अब मैं मुख्य में वापस आ गया हूँ, और मैं x मुद्रित कर सकते हैं, और मैं y मुद्रित कर सकते हैं,

741
00:39:36,000 --> 00:39:40,000
लेकिन मैं एक ख या मुद्रित नहीं कर सकते.

742
00:39:40,000 --> 00:39:43,000
लेकिन अगर मैं कहूँ कि मैं कर सकते हैं, "ठीक है, एक मिनट रुको स्वैप कहाँ था?"

743
00:39:43,000 --> 00:39:46,000
मुझे आगे जाना है और कहते हैं, "फ्रेम 0."

744
00:39:46,000 --> 00:39:48,000
अब मैं वापस आ गया हूँ जहाँ मैं बनना चाहता हूँ, और एक अलग रूप में,

745
00:39:48,000 --> 00:39:52,000
वहाँ अन्य आज्ञाओं का भी है, अगर आप की तरह सच में ऊब टाइपिंग अगले, अगले, अगले, अगले हो रही है,

746
00:39:52,000 --> 00:39:56,000
आप आम तौर पर की तरह बातें कह सकते हैं "अगले 10," और कहा कि अगले 10 लाइनों के माध्यम से कदम होगा.

747
00:39:56,000 --> 00:39:59,000
आप भी लिख "जारी रखें" जब आप वास्तव में इसे माध्यम से कदम से तंग आ चुके हो सकते हैं.

748
00:39:59,000 --> 00:40:05,000
जारी बिना किसी रुकावट के अपने कार्यक्रम चलाने के लिए जब तक यह एक और breakpoint हिट होगा,

749
00:40:05,000 --> 00:40:07,000
एक पाश में चाहे या अपने कार्यक्रम में कम नीचे हैं.

750
00:40:07,000 --> 00:40:11,000
>> इस मामले में हम अंत करने के लिए जारी रखा, और कार्यक्रम आम तौर से बाहर निकल गया.

751
00:40:11,000 --> 00:40:13,000
यह एक अच्छा तरीका है, अवर प्रक्रिया है.

752
00:40:13,000 --> 00:40:16,000
बस अपने कार्यक्रम सामान्य रूप से बाहर हुआ.

753
00:40:16,000 --> 00:40:24,000
वीडियो में और सत्र के लिए आने के debugging में उस पर और अधिक.

754
00:40:24,000 --> 00:40:26,000
यह एक बहुत कुछ था.

755
00:40:26,000 --> 00:40:35,000
चलो हमारे यहाँ 5 मिनट का ब्रेक लेते हैं, और हम structs और फ़ाइलों के साथ वापस कर देंगे.

756
00:40:35,000 --> 00:40:38,000
>> यदि आप पहले से ही इस सप्ताह के pset में डुबकी लगाई है

757
00:40:38,000 --> 00:40:41,000
आपको पता चल जाएगा कि हम वितरण कोड में उपयोग,

758
00:40:41,000 --> 00:40:45,000
स्रोत कोड है कि हम आप के लिए एक प्रारंभिक बिंदु, कुछ नई तकनीकों के रूप में प्रदान करते हैं.

759
00:40:45,000 --> 00:40:50,000
विशेष रूप से, हम संरचना के लिए इस नई संरचना बुलाया कीवर्ड शुरू की,

760
00:40:50,000 --> 00:40:53,000
इतना है कि हम एक तरह की अनुकूलित चर बना सकते हैं.

761
00:40:53,000 --> 00:40:57,000
हम भी फ़ाइल मैं / हे, इनपुट और आउटपुट के शुरू की धारणा है,

762
00:40:57,000 --> 00:41:00,000
और यह है कि इतना है कि हम राज्य को बचाने के लिए कर सकते हैं

763
00:41:00,000 --> 00:41:03,000
डिस्क पर अपने हाथापाई बोर्ड के एक फाइल करने के लिए

764
00:41:03,000 --> 00:41:06,000
इतना है कि शिक्षण साथियों और मैं समझ सकता हूँ

765
00:41:06,000 --> 00:41:09,000
क्या अपने कार्यक्रम के अंदर पर मैन्युअल खेलने के बिना जा रहा है

766
00:41:09,000 --> 00:41:11,000
हाथापाई के खेल के दर्जनों.

767
00:41:11,000 --> 00:41:13,000
हम यह automatedly अधिक कर सकते हैं.

768
00:41:13,000 --> 00:41:18,000
>> एक struct का यह विचार काफी सम्मोहक समस्या हल करती है.

769
00:41:18,000 --> 00:41:21,000
मान लीजिए कि हम कुछ कार्यक्रम को लागू करना चाहते हैं

770
00:41:21,000 --> 00:41:25,000
कि किसी भी तरह से छात्रों पर जानकारी का ट्रैक रखता है,

771
00:41:25,000 --> 00:41:28,000
और छात्रों को, उदाहरण के लिए, एक आईडी है, हो सकता है एक नाम

772
00:41:28,000 --> 00:41:31,000
और हार्वर्ड की तरह एक जगह पर एक घर है, इसलिए इन सूचना के 3 टुकड़े कर रहे हैं

773
00:41:31,000 --> 00:41:34,000
हम चारों ओर रखना चाहते हैं, तो मुझे आगे जाना है और एक छोटे से कार्यक्रम यहाँ लिख शुरू,

774
00:41:34,000 --> 00:41:38,000
stdio.h शामिल हैं.

775
00:41:38,000 --> 00:41:42,000
मुझे cs50.h. शामिल

776
00:41:42,000 --> 00:41:44,000
और फिर मेरे मुख्य समारोह शुरू.

777
00:41:44,000 --> 00:41:46,000
मैं किसी भी कमांड लाइन तर्क के साथ परेशान नहीं करेगा,

778
00:41:46,000 --> 00:41:49,000
और यहाँ मैं एक छात्र के लिए करना चाहते हैं, तो मैं कहने जा रहा हूँ

779
00:41:49,000 --> 00:41:54,000
एक छात्र एक नाम है, तो मैं कहने जा रहा हूँ "स्ट्रिंग नाम."

780
00:41:54,000 --> 00:41:59,000
तो मैं करने के लिए कहते हैं कि एक छात्र एक आईडी है, तो int आईडी के लिए जा रहा हूँ,

781
00:41:59,000 --> 00:42:03,000
और एक छात्र को एक घर है, इसलिए मैं यह भी कहने जा रहा हूँ "स्ट्रिंग घर है."

782
00:42:03,000 --> 00:42:06,000
तो मैं इन एक छोटे से इस तरह से अधिक सफाई आदेश देंगे.

783
00:42:06,000 --> 00:42:11,000
ठीक है, अब मैं 3 चर के साथ जो एक छात्र का प्रतिनिधित्व करने के लिए है, तो "एक छात्र है."

784
00:42:11,000 --> 00:42:15,000
>> और अब मैं इन मूल्यों को आबाद करना चाहते हैं, तो मुझे आगे जाना है और कुछ कहने की तरह

785
00:42:15,000 --> 00:42:18,000
"आईडी = 123."

786
00:42:18,000 --> 00:42:21,000
नाम डेविड पाने के लिए जा रहा है.

787
00:42:21,000 --> 00:42:24,000
चलो का कहना है कि घर के लिए माथर पाने के लिए जा रहा है,

788
00:42:24,000 --> 00:42:31,000
और फिर मैं printf की तरह मनमाने ढंग से कुछ करने के लिए जा रहा हूँ ("% s,

789
00:42:31,000 --> 00:42:37,000
जिसका आईडी% d,% s में रहता है.

790
00:42:37,000 --> 00:42:41,000
और अब, मैं क्या करने के लिए यहाँ में प्लग करना चाहते हैं, एक दूसरे के बाद?

791
00:42:41,000 --> 00:42:47,000
नाम, आईडी, घर वापसी, 0.

792
00:42:47,000 --> 00:42:50,000
ठीक है, जब तक मैं यहीं कहीं खराब कर दिया है

793
00:42:50,000 --> 00:42:54,000
मुझे लगता है कि हम एक बहुत अच्छा कार्यक्रम है कि भंडार एक छात्र है.

794
00:42:54,000 --> 00:42:57,000
बेशक, यह है कि सभी दिलचस्प नहीं है. क्या होगा यदि मैं 2 छात्रों के लिए करना चाहते हैं?

795
00:42:57,000 --> 00:42:59,000
यह कोई बड़ी बात नहीं है. मैं 2 लोगों का समर्थन कर सकते हैं.

796
00:42:59,000 --> 00:43:03,000
मुझे आगे जाना है और इस पर प्रकाश डाला और यहाँ नीचे जाना,

797
00:43:03,000 --> 00:43:09,000
और मैं "आईडी = 456" रोब की तरह है जो Kirkland में रहता है के लिए कह सकते हैं.

798
00:43:09,000 --> 00:43:12,000
>> ठीक है, इंतजार है, लेकिन मैं एक ही बात इन फोन नहीं कर सकते हैं,

799
00:43:12,000 --> 00:43:15,000
और ऐसा लगता है जैसे मैं इस की नकल करने के लिए किया जा रहा हूँ,

800
00:43:15,000 --> 00:43:19,000
तो मुझे कहना है कि इन दाऊद के चर हो जाएगा,

801
00:43:19,000 --> 00:43:23,000
और मुझे रोब के लिए इनमें से कुछ प्रतियां प्राप्त कर सकते हैं.

802
00:43:23,000 --> 00:43:27,000
हम इन रोब कॉल, लेकिन यह काम करने के लिए अब नहीं जा रहा है

803
00:43:27,000 --> 00:43:33,000
क्योंकि मैं प्रतीक्षा है, चलो मुझे id1 के लिए बदल, NAME1 और house1.

804
00:43:33,000 --> 00:43:35,000
रोब 2, 2.

805
00:43:35,000 --> 00:43:42,000
मैं इस यहाँ, यहाँ, यहाँ, यहाँ, यहाँ, बदल गया है.

806
00:43:42,000 --> 00:43:45,000
रुको, टॉमी के बारे में क्या? यह फिर से करना.

807
00:43:45,000 --> 00:43:49,000
जाहिर है अगर आप अभी भी लगता है कि यह ऐसा करने का एक अच्छा तरीका है, यह नहीं है,

808
00:43:49,000 --> 00:43:52,000
तो कॉपी / पेस्ट करें बुरा.

809
00:43:52,000 --> 00:43:55,000
लेकिन हम इस पर एक सप्ताह पहले हल.

810
00:43:55,000 --> 00:43:59,000
>> हमारे समाधान क्या था जब हम एक ही डेटा प्रकार के कई उदाहरण हैं चाहता था?

811
00:43:59,000 --> 00:44:01,000
[छात्र] एक सरणी.

812
00:44:01,000 --> 00:44:03,000
एक सरणी है, तो मुझे यह साफ करने की कोशिश है.

813
00:44:03,000 --> 00:44:07,000
मुझे शीर्ष पर खुद के लिए कुछ कमरे बनाने के लिए, और मुझे बजाय यहाँ यह सब कर.

814
00:44:07,000 --> 00:44:12,000
हम इन लोगों को फोन करेंगे और इसके बजाय मैं कहने जा रहा हूँ "int आईडी,"

815
00:44:12,000 --> 00:44:14,000
और मैं अब के लिए हम में से 3 का समर्थन करने के लिए जा रहा हूँ.

816
00:44:14,000 --> 00:44:18,000
मैं जा रहा हूँ "स्ट्रिंग नामों," कहते हैं और मैं हम में से 3 का समर्थन करेंगे,

817
00:44:18,000 --> 00:44:22,000
और फिर मैं "स्ट्रिंग घरों," कहते हैं और मैं हम में से 3 का समर्थन करने के लिए जा रहा हूँ जा रहा हूँ.

818
00:44:22,000 --> 00:44:26,000
अब दाऊद ने अपने अपने स्थानीय चर होने की बजाय यहाँ

819
00:44:26,000 --> 00:44:28,000
हम उन लोगों से छुटकारा मिल सकता है.

820
00:44:28,000 --> 00:44:30,000
यह अच्छा है कि हम इस सफाई कर रहे हैं लगता है.

821
00:44:30,000 --> 00:44:35,000
मैं तो कहना है कि दाऊद और नाम [0] [0] होने जा रहा है

822
00:44:35,000 --> 00:44:38,000
और घरों [0].

823
00:44:38,000 --> 00:44:41,000
और फिर रोब हम इसी तरह इस पर बचा सकता है.

824
00:44:41,000 --> 00:44:46,000
चलो इस यहाँ नीचे रखा, तो वह मनमाने ढंग से [1] आईडी होने जा रहा है.

825
00:44:46,000 --> 00:44:50,000
वह नाम होने जा रहा है [1],

826
00:44:50,000 --> 00:44:53,000
और फिर अंत में, घरों [1].

827
00:44:53,000 --> 00:44:57,000
>> अभी भी एक छोटे से कठिन है, और अब मैं यह समझ से बाहर है,

828
00:44:57,000 --> 00:45:03,000
तो हम कहते हैं "के नाम [0], आईडी [0], घरों [0],

829
00:45:03,000 --> 00:45:06,000
और इस बहुवचन में अभिव्यक्त करना.

830
00:45:06,000 --> 00:45:09,000
आईडी, आईडी, आईडी.

831
00:45:09,000 --> 00:45:12,000
और फिर, मैं कर रहा हूँ, तो फिर, मैं पहले से ही कॉपी / दोबारा पेस्ट resorting रहा हूँ,

832
00:45:12,000 --> 00:45:14,000
तो बाधाओं रहे हैं वहाँ एक समाधान है.

833
00:45:14,000 --> 00:45:18,000
मैं शायद इस एक या कुछ की तरह है कि पाश के साथ साफ कर सकते हैं आगे

834
00:45:18,000 --> 00:45:21,000
संक्षेप में, यह थोड़ा बेहतर है, लेकिन अभी भी तरह लगता है

835
00:45:21,000 --> 00:45:24,000
मैं कॉपी पेस्ट / resorting रहा हूँ, लेकिन यह भी, मैं दावा है,

836
00:45:24,000 --> 00:45:27,000
वास्तव में मौलिक सही समाधान नहीं है, क्योंकि

837
00:45:27,000 --> 00:45:29,000
क्या होगा अगर कुछ समय हम तय तुम क्या जानते हो?

838
00:45:29,000 --> 00:45:32,000
हम वास्तव में दाऊद और रोब के लिए किया गया है चाहिए ईमेल पते भंडारण

839
00:45:32,000 --> 00:45:34,000
और इस कार्यक्रम में हर किसी के.

840
00:45:34,000 --> 00:45:36,000
हम भी फोन नंबर स्टोर चाहिए.

841
00:45:36,000 --> 00:45:39,000
हम भी आपातकालीन संपर्क नंबर स्टोर करना चाहिए.

842
00:45:39,000 --> 00:45:41,000
हम सभी डेटा के इन टुकड़ों है कि हम चाहते हैं की दुकान है,

843
00:45:41,000 --> 00:45:43,000
तो आप करने के बारे में कैसे जाना है?

844
00:45:43,000 --> 00:45:46,000
>> आप शीर्ष पर एक और सरणी की घोषणा, और फिर आप मैन्युअल रूप से जोड़ने

845
00:45:46,000 --> 00:45:49,000
एक ईमेल पते [0], ईमेल [1] पता

846
00:45:49,000 --> 00:45:51,000
दाऊद और रोब के लिए और बहुत आगे है.

847
00:45:51,000 --> 00:45:56,000
लेकिन वास्तव में सिर्फ एक इस डिजाइन अंतर्निहित धारणा है

848
00:45:56,000 --> 00:45:59,000
कि मैं सम्मान प्रणाली का उपयोग कर रहा हूँ पता है कि

849
00:45:59,000 --> 00:46:03,000
[I] कई arrays के प्रत्येक में

850
00:46:03,000 --> 00:46:06,000
सिर्फ इतना एक ही व्यक्ति का उल्लेख होता है,

851
00:46:06,000 --> 00:46:10,000
तो [0] आईडी में 123 नंबर है,

852
00:46:10,000 --> 00:46:13,000
और मैं कि नाम मान जा रहा हूँ [0]

853
00:46:13,000 --> 00:46:16,000
एक ही व्यक्ति का नाम और [0] मकान

854
00:46:16,000 --> 00:46:21,000
एक ही व्यक्ति और विभिन्न arrays कि मैं बनाने के सभी के लिए घर में इतना आगे है.

855
00:46:21,000 --> 00:46:24,000
लेकिन नोटिस कि वहाँ कोई मौलिक उठाना

856
00:46:24,000 --> 00:46:27,000
जानकारी, आईडी, नाम, और घर के उन 3 टुकड़ों के बीच,

857
00:46:27,000 --> 00:46:32,000
भले ही हम इस कार्यक्रम में मॉडल के लिए कोशिश कर रहे हैं इकाई arrays नहीं है.

858
00:46:32,000 --> 00:46:35,000
Arrays सिर्फ इस कर के इस प्रोग्रामेटिक तरीका है.

859
00:46:35,000 --> 00:46:38,000
क्या हम वास्तव में हमारे कार्यक्रम में मॉडल चाहते हैं एक व्यक्ति है

860
00:46:38,000 --> 00:46:41,000
डेविड, जो के अंदर रोब तरह एक व्यक्ति की तरह

861
00:46:41,000 --> 00:46:46,000
या encapsulating एक नाम और आईडी और एक घर है.

862
00:46:46,000 --> 00:46:49,000
>> हम किसी भी तरह encapsulation के इस विचार व्यक्त कर सकते हैं

863
00:46:49,000 --> 00:46:52,000
जिससे एक व्यक्ति को एक आईडी, एक नाम और एक घर है

864
00:46:52,000 --> 00:46:55,000
वास्तव में इस हैक करने के लिए सहारा नहीं है और अभी हम जिससे

865
00:46:55,000 --> 00:46:58,000
कि ब्रैकेट कुछ पर भरोसा

866
00:46:58,000 --> 00:47:02,000
इन असमान arrays के प्रत्येक में एक ही मानव संस्था को दर्शाता है?

867
00:47:02,000 --> 00:47:04,000
हम वास्तव में यह कर सकते हैं.

868
00:47:04,000 --> 00:47:08,000
चलो मेरे ऊपर अब के लिए मुख्य जाना, और मुझे अपने डेटा प्रकार बनाने

869
00:47:08,000 --> 00:47:10,000
वास्तव में पहली बार के लिए.

870
00:47:10,000 --> 00:47:14,000
हम हाथापाई में इस तकनीक का इस्तेमाल किया है,

871
00:47:14,000 --> 00:47:17,000
लेकिन यहाँ मैं आगे जाना है और एक डेटा प्रकार बनाने जा रहा हूँ,

872
00:47:17,000 --> 00:47:19,000
और तुम्हें पता है, मैं यह छात्र या व्यक्ति फोन करने के लिए जा रहा हूँ,

873
00:47:19,000 --> 00:47:23,000
और मैं typedef का उपयोग करने के लिए एक प्रकार को परिभाषित करने के लिए जा रहा हूँ.

874
00:47:23,000 --> 00:47:25,000
मैं कहना है कि यह एक संरचना है करने के लिए जा रहा हूँ,

875
00:47:25,000 --> 00:47:29,000
और फिर इस संरचना प्रकार छात्र का हो, तो हम कहेंगे जा रहा है,

876
00:47:29,000 --> 00:47:31,000
भले ही यह एक छोटे से मेरे लिए अब दिनांकित है.

877
00:47:31,000 --> 00:47:33,000
हम "int आईडी कहता हूँ."

878
00:47:33,000 --> 00:47:35,000
हम "स्ट्रिंग नाम कहता हूँ."

879
00:47:35,000 --> 00:47:37,000
तो फिर हम "स्ट्रिंग घर," कह देंगे

880
00:47:37,000 --> 00:47:40,000
अब तो कोड के इन कुछ लाइनों के अंत तक

881
00:47:40,000 --> 00:47:45,000
मैं सिर्फ बजना सिखाया है कि वहाँ मौजूद है

882
00:47:45,000 --> 00:47:49,000
ints के अलावा एक डेटा प्रकार, तार के अलावा, के अलावा है मंगाई के अलावा डबल्स,.

883
00:47:49,000 --> 00:47:54,000
>> समय 11 लाइन में इस क्षण के रूप में, वहाँ अब एक नया डेटा प्रकार छात्रों को कहा जाता है,

884
00:47:54,000 --> 00:47:58,000
और अब मैं एक छात्र चर मैं चाहता हूँ कि कहीं भी घोषित कर सकते हैं,

885
00:47:58,000 --> 00:48:01,000
तो मुझे नीचे स्क्रॉल लोगों को यहाँ.

886
00:48:01,000 --> 00:48:05,000
अब मैं इस से छुटकारा मिलता है, कर सकते हैं और मैं वापस जाने के लिए नीचे दाऊद के पास कर सकते हैं यहाँ

887
00:48:05,000 --> 00:48:10,000
और डेविड के लिए मैं वास्तव में दाऊद कि कह सकते हैं,

888
00:48:10,000 --> 00:48:13,000
हम सचमुच अपने आप के बाद चर नाम कर सकते हैं,

889
00:48:13,000 --> 00:48:16,000
प्रकार छात्र का होने जा रहा है.

890
00:48:16,000 --> 00:48:18,000
यह थोड़ा अजीब लग सकता है, लेकिन यह है कि सभी अलग नहीं है

891
00:48:18,000 --> 00:48:22,000
एक int या एक स्ट्रिंग या एक नाव के रूप में कुछ की घोषणा से.

892
00:48:22,000 --> 00:48:24,000
यह सिर्फ इतना करने के लिए छात्र अब कहा जा होता है,

893
00:48:24,000 --> 00:48:28,000
और अगर मैं इस संरचना के अंदर कुछ डाल करना चाहते हैं

894
00:48:28,000 --> 00:48:31,000
मैं अब वाक्यविन्यास का एक नया टुकड़ा का उपयोग करने के लिए है, लेकिन यह बहुत स्पष्ट है,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = पूंजी विकास में "दाऊद",

896
00:48:39,000 --> 00:48:42,000
और david.house = "माथर"

897
00:48:42,000 --> 00:48:46,000
और अब मैं यहाँ इस सामान से छुटकारा मिल सकता है.

898
00:48:46,000 --> 00:48:51,000
नोटिस अब हम वास्तव में एक बेहतर तरीका में हमारे कार्यक्रम बदल दिया है

899
00:48:51,000 --> 00:48:54,000
कि अब हमारे कार्यक्रम में असली दुनिया दर्पण.

900
00:48:54,000 --> 00:48:57,000
>> एक व्यक्ति या एक छात्र वास्तविक दुनिया की धारणा है.

901
00:48:57,000 --> 00:49:02,000
यहाँ हम अब एक व्यक्ति या अधिक विशेष रूप से एक छात्र की एक सी संस्करण है.

902
00:49:02,000 --> 00:49:05,000
उस व्यक्ति के अंदर इन प्रासंगिक विशेषताएं हैं,

903
00:49:05,000 --> 00:49:10,000
आईडी, नाम, और घर, तो रोब अनिवार्य रूप से एक ही बात यहाँ नीचे हो जाता है,

904
00:49:10,000 --> 00:49:14,000
इसलिए छात्र लूटने, और अब 456 = rob.id,

905
00:49:14,000 --> 00:49:17,000
rob.name = "रोब."

906
00:49:17,000 --> 00:49:20,000
तथ्य यह है कि चर रोब कहा जाता है व्यर्थ की तरह है.

907
00:49:20,000 --> 00:49:22,000
हम यह एक्स या वाई या जेड कहा हो सकता है.

908
00:49:22,000 --> 00:49:25,000
हम सिर्फ यह शब्दार्थ अनुरूप होना लूटने का नाम है,

909
00:49:25,000 --> 00:49:28,000
लेकिन वास्तव में नाम के अंदर है कि क्षेत्र में ही है,

910
00:49:28,000 --> 00:49:30,000
तो अब मैं इस है.

911
00:49:30,000 --> 00:49:33,000
यह भी सर्वश्रेष्ठ डिजाइन में है कि मैं कड़ी मेहनत डेविड कोडित है की तरह महसूस नहीं करता है.

912
00:49:33,000 --> 00:49:35,000
मैं कठिन कोडित रोब है.

913
00:49:35,000 --> 00:49:39,000
और मैं अभी भी किसी की नकल करने के लिए सहारा और हर बार जब मैं नई चर चाहते पेस्ट है.

914
00:49:39,000 --> 00:49:43,000
इसके अलावा, मैं जाहिरा तौर पर इन चर के हर एक नाम दे दिया है,

915
00:49:43,000 --> 00:49:46,000
भले ही मैं बहुत बल्कि इन चर का वर्णन था

916
00:49:46,000 --> 00:49:48,000
 अधिक generically छात्रों.

917
00:49:48,000 --> 00:49:52,000
>> अब हम विचार है कि हमारे लिए अच्छी तरह से काम किया गया है विलय कर सकते हैं

918
00:49:52,000 --> 00:49:56,000
और बजाय कहते हैं, "तुम्हें पता है, मुझे एक चर बुलाया छात्रों को देने,

919
00:49:56,000 --> 00:50:01,000
चलो, तो यह 3 आकार के हो गए हैं, "अब मैं इस आगे परिष्कृत कर सकते हैं,

920
00:50:01,000 --> 00:50:04,000
मैन्युअल घोषित दाऊद से छुटकारा पाने के लिए,

921
00:50:04,000 --> 00:50:08,000
और मैं बजाय छात्रों की तरह [0] यहाँ कुछ कह सकते हैं.

922
00:50:08,000 --> 00:50:11,000
मैं तो छात्रों [0] यहाँ कह सकते हैं,

923
00:50:11,000 --> 00:50:14,000
यहाँ, और इतना आगे [0] छात्रों, और मैं चारों ओर जा सकते हैं

924
00:50:14,000 --> 00:50:16,000
और कि रोब के लिए साफ.

925
00:50:16,000 --> 00:50:19,000
मैं भी अब शायद एक पाश जोड़ने के बारे में जा सकते हैं

926
00:50:19,000 --> 00:50:23,000
और GetString और GetInt का उपयोग करने के लिए वास्तव में उपयोगकर्ता से इन मूल्यों को प्राप्त है.

927
00:50:23,000 --> 00:50:27,000
मैं एक निरंतर जोड़ने के बारे में जाना है क्योंकि यह आम तौर पर बुरा व्यवहार हो सकता है हो सकता है

928
00:50:27,000 --> 00:50:29,000
हार्ड कोड के लिए 3 तरह कुछ मनमाने ढंग से संख्या सही यहाँ

929
00:50:29,000 --> 00:50:33,000
और फिर बस याद है कि आप इसे में कोई 3 से अधिक छात्रों को रखा जाना चाहिए.

930
00:50:33,000 --> 00:50:36,000
यह शायद बेहतर होगा # मेरी फाइल के शीर्ष पर परिभाषित करने के लिए उपयोग होगा

931
00:50:36,000 --> 00:50:40,000
और कारक है कि बाहर है, तो वास्तव में चलो, मुझे आगे जाना है और इस सामान्यीकरण.

932
00:50:40,000 --> 00:50:43,000
>> मुझे एक उदाहरण है कि आज के बीच खुला

933
00:50:43,000 --> 00:50:46,000
अग्रिम में उदाहरण, structs1.

934
00:50:46,000 --> 00:50:49,000
यह एक अधिक पूरा कार्यक्रम का उपयोग करता है कि # यहाँ को परिभाषित है

935
00:50:49,000 --> 00:50:51,000
कहते हैं और हम डिफ़ॉल्ट रूप से 3 छात्रों के लिए जा रहे हैं.

936
00:50:51,000 --> 00:50:54,000
यहाँ मैं छात्रों के एक वर्ग के लायक घोषणा कर रहा हूँ,

937
00:50:54,000 --> 00:50:57,000
तो छात्रों की एक कक्षा, और अब मैं एक पाश का उपयोग कर रहा हूँ

938
00:50:57,000 --> 00:51:00,000
सिर्फ कोड थोड़ा और अधिक सुंदर बनाने के लिए, वर्ग पॉप्युलेट करने के लिए

939
00:51:00,000 --> 00:51:05,000
उपयोगकर्ता इनपुट के साथ है, तो छात्रों, जो 3 i = 0 से पुनरावृति.

940
00:51:05,000 --> 00:51:07,000
और फिर मैं इस संस्करण में उपयोगकर्ता prompt

941
00:51:07,000 --> 00:51:10,000
 क्या छात्र आईडी है, और मैं यह GetInt साथ मिलता है.

942
00:51:10,000 --> 00:51:13,000
छात्र का नाम क्या है, और फिर मैं यह GetString साथ मिल.

943
00:51:13,000 --> 00:51:15,000
छात्र घर क्या है? मैं यह GetString के साथ मिलता है.

944
00:51:15,000 --> 00:51:19,000
और फिर यहाँ तल पर मैं सिर्फ बदलने का फैसला किया

945
00:51:19,000 --> 00:51:22,000
, मैं इन कैसे मुद्रण कर रहा हूँ बाहर है और वास्तव में एक पाश का उपयोग

946
00:51:22,000 --> 00:51:24,000
और मैं जो मुद्रण कर रहा हूँ?

947
00:51:24,000 --> 00:51:27,000
टिप्पणी के अनुसार मैं माथर में किसी मुद्रण कर रहा हूँ,

948
00:51:27,000 --> 00:51:30,000
और यह है कि रोब और टॉमी इतना पर और आगे वास्तव में टॉमी माथर में.

949
00:51:30,000 --> 00:51:34,000
टॉमी और दाऊद ने इस मामले में मुद्रित किया जाएगा, लेकिन यह कैसे काम कर रहा है?

950
00:51:34,000 --> 00:51:40,000
हम इस समारोह से पहले नहीं देखा है, लेकिन यह क्या करता है के रूप में एक अनुमान ले.

951
00:51:40,000 --> 00:51:42,000
तार की तुलना करता है.

952
00:51:42,000 --> 00:51:45,000
>> यह एक छोटी सी गैर स्पष्ट है कि यह कैसे तार तुलना क्योंकि यह पता चला है

953
00:51:45,000 --> 00:51:49,000
अगर यह 0 देता है इसका मतलब है कि तार के बराबर हैं.

954
00:51:49,000 --> 00:51:53,000
यदि यह एक -1 देता है इसका मतलब है कि एक दूसरे से पहले वर्णानुक्रम में आता है,

955
00:51:53,000 --> 00:51:57,000
और अगर यह एक रिटर्न वर्णानुक्रम में आता है कि अन्य शब्द का अर्थ

956
00:51:57,000 --> 00:52:00,000
दूसरे से पहले, और आप ऑनलाइन या आदमी पेज पर देख सकते हैं

957
00:52:00,000 --> 00:52:04,000
को देखने के ठीक तरह से जो है, लेकिन अब यह सब कर रही है यह कह रहा है

958
00:52:04,000 --> 00:52:09,000
अगर [i]. घर माथर "के बराबर है

959
00:52:09,000 --> 00:52:13,000
तो आगे जाओ और बाहर तो प्रिंट और इतने माथर में है.

960
00:52:13,000 --> 00:52:16,000
लेकिन यहाँ कुछ हम पहले नहीं देखा है, और हम इस के लिए आया हूँ.

961
00:52:16,000 --> 00:52:21,000
मैं कभी भी अपने कार्यक्रमों में से किसी में यह कर रहा याद नहीं है.

962
00:52:21,000 --> 00:52:24,000
मुफ्त जाहिरा तौर पर याद करने के लिए बात कर रहा है, स्मृति मुक्त,

963
00:52:24,000 --> 00:52:31,000
लेकिन स्मृति क्या मैं जाहिरा तौर पर इस कार्यक्रम के नीचे में इस पाश में मुक्त?

964
00:52:31,000 --> 00:52:34,000
ऐसा लगता है कि मैं एक व्यक्ति के नाम मुक्त कर रहा हूँ

965
00:52:34,000 --> 00:52:37,000
और एक व्यक्ति के घर में है, लेकिन ऐसा क्यों है?

966
00:52:37,000 --> 00:52:41,000
>> यह इन सभी सप्ताह पता चला है कि आप GetString का उपयोग किया गया

967
00:52:41,000 --> 00:52:45,000
हम किस तरह से अपने कार्यक्रमों के हर एक में किया गया है एक बग शुरू.

968
00:52:45,000 --> 00:52:51,000
डिजाइन का आवंटन स्मृति द्वारा GetString इतना है कि यह आप एक स्ट्रिंग के लिए लौट सकते हैं,

969
00:52:51,000 --> 00:52:55,000
जैसे डेविड, या रोब, आप और फिर आप जो चाहते हैं कर सकते हैं

970
00:52:55,000 --> 00:52:59,000
क्योंकि हम आप के लिए स्मृति आरक्षित है कि अपने कार्यक्रम में स्ट्रिंग के साथ.

971
00:52:59,000 --> 00:53:02,000
यह सब समय समस्या हर बार जब आप GetString कॉल

972
00:53:02,000 --> 00:53:05,000
हम, के लेखकों के GetString, ऑपरेटिंग सिस्टम पूछ रहा है

973
00:53:05,000 --> 00:53:07,000
हमें इस स्ट्रिंग के लिए राम की एक बिट दे.

974
00:53:07,000 --> 00:53:09,000
हमें यह अगले स्ट्रिंग के लिए राम की एक बिट दे.

975
00:53:09,000 --> 00:53:11,000
हमें यह अगले स्ट्रिंग के लिए कुछ अधिक रैम दे.

976
00:53:11,000 --> 00:53:13,000
क्या तुम, प्रोग्रामर कर रही है, कभी नहीं किया गया है

977
00:53:13,000 --> 00:53:15,000
हमें कि याददाश्त वापस दे,

978
00:53:15,000 --> 00:53:17,000
तो इन कई हफ्तों के लिए कार्यक्रमों के सभी लिखा है

979
00:53:17,000 --> 00:53:20,000
किया था कि क्या एक स्मृति छलांग कहा जाता है जिससे वे का उपयोग कर रखना

980
00:53:20,000 --> 00:53:24,000
अधिक से अधिक स्मृति हर बार जब आप GetString कहते हैं, और वह ठीक है.

981
00:53:24,000 --> 00:53:27,000
हम जानबूझ कि पहले सप्ताह में नहीं है क्योंकि यह दिलचस्प नहीं है कि

982
00:53:27,000 --> 00:53:29,000
जहां स्ट्रिंग से आ रहा है के बारे में चिंता करने की ज़रूरत है.

983
00:53:29,000 --> 00:53:34,000
सब तुम चाहते है शब्द वापस आ जब उपयोगकर्ता यह प्रकार अंदर रोब

984
00:53:34,000 --> 00:53:38,000
>> लेकिन आगे बढ़ने अब हम इस बारे में और अधिक परिष्कृत हो रही शुरू कर दिया है.

985
00:53:38,000 --> 00:53:42,000
हम किसी भी समय हम स्मृति आवंटित करने के बेहतर अंततः इसे वापस हाथ.

986
00:53:42,000 --> 00:53:45,000
अन्यथा अपने मैक या पीसी पर असली दुनिया में आप कभी कभी अनुभवी हो सकता है

987
00:53:45,000 --> 00:53:50,000
लक्षण है जहाँ आपके कंप्यूटर के एक पड़ाव पर पीस अंततः

988
00:53:50,000 --> 00:53:54,000
या बेवकूफ कताई समुद्र तट गेंद सिर्फ कंप्यूटर कब्जे में है

989
00:53:54,000 --> 00:53:56,000
पूरे ध्यान और आप कुछ नहीं कर सकते.

990
00:53:56,000 --> 00:54:00,000
कीड़े के किसी भी संख्या से समझाया जा सकता है, लेकिन उन संभव कीड़े के बीच

991
00:54:00,000 --> 00:54:03,000
बातें कर रहे हैं स्मृति लीक कहा जिससे कोई है जो सॉफ्टवेयर का टुकड़ा है कि लिखा

992
00:54:03,000 --> 00:54:07,000
आप स्मृति मुक्त करने के लिए याद नहीं किया था का उपयोग कर रहे हैं

993
00:54:07,000 --> 00:54:10,000
कि वह या वह संचालन के लिए प्रणाली से पूछा,

994
00:54:10,000 --> 00:54:14,000
उपयोग नहीं GetString कि क्योंकि एक CS50 बात है, लेकिन इसी तरह के कार्यों का उपयोग

995
00:54:14,000 --> 00:54:16,000
कि स्मृति के लिए ऑपरेटिंग सिस्टम पूछना.

996
00:54:16,000 --> 00:54:19,000
यदि आप या वे पेंच और है कि स्मृति वास्तव में कभी नहीं लौटने

997
00:54:19,000 --> 00:54:24,000
का एक लक्षण है कि हो सकता है कि एक कार्यक्रम धीमा कर देती है और धीमा है और नीचे धीमा कर देती है

998
00:54:24,000 --> 00:54:26,000
जब तक आप के लिए मुक्त कर याद है.

999
00:54:26,000 --> 00:54:28,000
>> हम वापस आने के लिए जब क्यों और आप मुफ्त फोन होगा,

1000
00:54:28,000 --> 00:54:32,000
लेकिन अच्छे उपाय के लिए बस आगे बढ़ो और इस विशेष कार्यक्रम चलाने की कोशिश करें.

1001
00:54:32,000 --> 00:54:35,000
इस structs1 बुलाया गया था, दर्ज करें.

1002
00:54:35,000 --> 00:54:40,000
मुझे आगे जाना है और structs1 चलाने के, 123, डेविड माथर,

1003
00:54:40,000 --> 00:54:47,000
456, रोब Kirkland, 789,

1004
00:54:47,000 --> 00:54:50,000
टॉमी माथर, और हम माथर में डेविड देखते, टॉमी माथर में.

1005
00:54:50,000 --> 00:54:53,000
यह सिर्फ एक छोटे से मानसिक स्वास्थ्य की जांच है कि इस कार्यक्रम के काम कर रहा है है.

1006
00:54:53,000 --> 00:54:56,000
अब, दुर्भाग्य से, इस कार्यक्रम में है कि एक छोटे से निराशा होती है

1007
00:54:56,000 --> 00:55:00,000
मुझे लगता है कि सब काम किया था, मैं 9 अलग तार में टाइप, हिट दर्ज करें,

1008
00:55:00,000 --> 00:55:04,000
बताया गया था जो माथर में था, अभी तक स्पष्ट रूप से मैं जानता था कि जो माथर में पहले से ही था, क्योंकि मैं इसे टाइप.

1009
00:55:04,000 --> 00:55:07,000
यह कम से कम अच्छा होगा अगर इस कार्यक्रम और एक डेटाबेस की तरह होता है

1010
00:55:07,000 --> 00:55:10,000
और यह वास्तव में याद है कि मैं क्या में टाइप किया है

1011
00:55:10,000 --> 00:55:12,000
इसलिए मैं इन छात्र रिकॉर्ड इनपुट के लिए फिर कभी नहीं होगा.

1012
00:55:12,000 --> 00:55:15,000
शायद यह एक registrarial प्रणाली की तरह है.

1013
00:55:15,000 --> 00:55:21,000
>> हम यह नहीं है इस फ़ाइल मैं / हे, इनपुट और आउटपुट के रूप में जाना तकनीक का उपयोग कर सकते हैं,

1014
00:55:21,000 --> 00:55:24,000
किसी भी समय आप फ़ाइलों को पढ़ने या फ़ाइलों लिखना चाहते हैं कह रही है की एक बहुत सामान्य तरीके

1015
00:55:24,000 --> 00:55:26,000
आप कार्यों की एक निश्चित सेट के साथ कर सकते हैं.

1016
00:55:26,000 --> 00:55:29,000
मुझे आगे जाना है और इस उदाहरण structs2.c खुला,

1017
00:55:29,000 --> 00:55:33,000
जो लगभग समान है, लेकिन देखते हैं कि यह क्या करता है अब.

1018
00:55:33,000 --> 00:55:36,000
फ़ाइल के शीर्ष पर मैं छात्रों के एक वर्ग की घोषणा.

1019
00:55:36,000 --> 00:55:38,000
मैं तो उपयोगकर्ता इनपुट के साथ कक्षा आबाद,

1020
00:55:38,000 --> 00:55:41,000
तो कोड के उन लाइनों बिल्कुल पहले की तरह कर रहे हैं.

1021
00:55:41,000 --> 00:55:45,000
तो अगर मैं यहाँ नीचे स्क्रॉल मैं प्रिंट हर कोई है जो माथर में मनमाने ढंग से पहले की तरह,

1022
00:55:45,000 --> 00:55:47,000
लेकिन यह एक दिलचस्प नई सुविधा है.

1023
00:55:47,000 --> 00:55:51,000
कोड के इन लाइनों के लिए नए हैं, और वे कुछ यहाँ शुरू,

1024
00:55:51,000 --> 00:55:55,000
फ़ाइल, सभी टोपियां, और यह यहाँ * के रूप में अच्छी तरह से किया गया है.

1025
00:55:55,000 --> 00:55:58,000
मुझे यहाँ पर ले जाने के लिए, यहाँ पर एक * के रूप में अच्छी तरह से.

1026
00:55:58,000 --> 00:56:00,000
>> इस समारोह में हम पहले नहीं देखा है, fopen,

1027
00:56:00,000 --> 00:56:03,000
लेकिन यह फाइल का मतलब है खुला है, तो इन के माध्यम से चलो किसी पदार्थ का उत्तम तत्त्व ले लेना,

1028
00:56:03,000 --> 00:56:05,000
और यह कुछ हम वापस करने के लिए भविष्य psets में आ जाएगा,

1029
00:56:05,000 --> 00:56:10,000
लेकिन यहाँ इस लाइन अनिवार्य रूप से कहा जाता है एक डेटाबेस फ़ाइल को खोलता है,

1030
00:56:10,000 --> 00:56:13,000
और यह विशेष रूप से यह इस तरह है कि यह करने के लिए क्या कर सकते हैं में खुलती है?

1031
00:56:13,000 --> 00:56:15,000
[अश्राव्य छात्र]

1032
00:56:15,000 --> 00:56:19,000
ठीक है, तो बस "w" मतलब है कि यह ऑपरेटिंग सिस्टम बता रहा है

1033
00:56:19,000 --> 00:56:21,000
इस तरह है कि मैं यह करने के लिए लिख सकते हैं में इस फाइल को खोलने.

1034
00:56:21,000 --> 00:56:23,000
मैं इसे पढ़ने के लिए नहीं करना चाहती. मैं सिर्फ यह देखना नहीं चाहती.

1035
00:56:23,000 --> 00:56:26,000
मैं इसे बदलने के लिए और सामान के लिए संभावित जोड़ चाहते हैं,

1036
00:56:26,000 --> 00:56:28,000
और फाइल करने के लिए डेटाबेस कहा जा रहा है.

1037
00:56:28,000 --> 00:56:30,000
यह कुछ भी कहा जा सकता है.

1038
00:56:30,000 --> 00:56:32,000
यह database.txt हो सकता है. इस DB हो सकता है.

1039
00:56:32,000 --> 00:56:37,000
यह foo की तरह एक शब्द हो सकता है, लेकिन मैं मनमाने ढंग से फ़ाइल डेटाबेस का नाम चुना.

1040
00:56:37,000 --> 00:56:42,000
यह एक छोटे से मानसिक स्वास्थ्य की जांच है कि हम वापस करने के लिए समय के साथ महान विस्तार में आया हूँ,

1041
00:56:42,000 --> 00:56:47,000
अगर fp, फ़ाइल सूचक के लिए, बराबर रिक्त नहीं है इसका मतलब है कि सब कुछ ठीक है.

1042
00:56:47,000 --> 00:56:51,000
>> लंबी कहानी कम, fopen की तरह कार्य करता है कभी कभी असफल.

1043
00:56:51,000 --> 00:56:53,000
शायद फ़ाइल मौजूद नहीं है. शायद आप डिस्क स्थान से बाहर रहे हैं.

1044
00:56:53,000 --> 00:56:55,000
शायद आप उस फ़ोल्डर के लिए अनुमति नहीं है,

1045
00:56:55,000 --> 00:56:58,000
यदि ऐसा है तो fopen अशक्त कुछ देता बुरा हुआ है.

1046
00:56:58,000 --> 00:57:02,000
इसके विपरीत, यदि fopen अशक्त वापस नहीं करता है सब कुछ ठीक है

1047
00:57:02,000 --> 00:57:04,000
और मैं इस फ़ाइल के लिए लिखना शुरू कर सकते हैं.

1048
00:57:04,000 --> 00:57:06,000
यहाँ एक नई चाल है.

1049
00:57:06,000 --> 00:57:08,000
यह एक के लिए पाश है कि अपने छात्रों के प्रत्येक iterating है,

1050
00:57:08,000 --> 00:57:10,000
और यह तो हम क्या पहले किया है के लिए इसी तरह लग रहा है,

1051
00:57:10,000 --> 00:57:15,000
लेकिन इस समारोह का एक चचेरा भाई printf printf फ़ाइल के लिए fprintf कहा जाता है,

1052
00:57:15,000 --> 00:57:18,000
नोटिस और यह केवल 2 मायनों में अलग है.

1053
00:57:18,000 --> 00:57:20,000
एक, यह पी के बजाय च के साथ शुरू होता है,

1054
00:57:20,000 --> 00:57:23,000
लेकिन तब क्या जाहिरा तौर पर अपनी पहली तर्क है?

1055
00:57:23,000 --> 00:57:25,000
[छात्र] फ़ाइल. >> यह एक फ़ाइल है.

1056
00:57:25,000 --> 00:57:30,000
यह fp बुलाया बात है, जो हम अंततः अलग चिढ़ाने के एक फ़ाइल सूचक है,

1057
00:57:30,000 --> 00:57:35,000
लेकिन अब के लिए fp बस फ़ाइल का प्रतिनिधित्व करता है कि मैं खोल दिया है,

1058
00:57:35,000 --> 00:57:41,000
तो fprintf यहाँ कह रहा है इस उपयोगकर्ता फ़ाइल आईडी प्रिंट स्क्रीन करने के लिए नहीं.

1059
00:57:41,000 --> 00:57:44,000
उपयोगकर्ता फाइल करने के लिए नाम, प्रिंट स्क्रीन करने के लिए नहीं,

1060
00:57:44,000 --> 00:57:47,000
फ़ाइल के लिए, नहीं स्क्रीन करने के लिए, और फिर यहाँ नीचे, जाहिर है घर,

1061
00:57:47,000 --> 00:57:50,000
फ़ाइल को बंद करें, और फिर नीचे मुक्त स्मृति.

1062
00:57:50,000 --> 00:57:53,000
>> इस संस्करण 2 और 1 संस्करण के बीच फर्क सिर्फ इतना

1063
00:57:53,000 --> 00:57:58,000
fopen का परिचय और * के साथ इस फ़ाइल

1064
00:57:58,000 --> 00:58:01,000
और fprintf की इस धारणा है, तो हम देखते हैं कि अंत परिणाम क्या है.

1065
00:58:01,000 --> 00:58:03,000
मुझे अपने टर्मिनल विंडो में जाने.

1066
00:58:03,000 --> 00:58:06,000
मुझे structs2 चलाने के लिए, दर्ज करें.

1067
00:58:06,000 --> 00:58:09,000
लगता है जैसे सब कुछ ठीक है. चलो structs2 फिर से दौड़ना.

1068
00:58:09,000 --> 00:58:15,000
123, डेविड माथर, 456, रोब Kirkland,

1069
00:58:15,000 --> 00:58:19,000
789, टॉमी माथर दर्ज करें.

1070
00:58:19,000 --> 00:58:23,000
जैसे कि यह वही व्यवहार दिखता है, लेकिन अगर मैं अब रास

1071
00:58:23,000 --> 00:58:28,000
नोटिस क्या मेरे सभी कोड के बीच यहाँ फ़ाइल में है, डेटाबेस,

1072
00:58:28,000 --> 00:58:32,000
तो चलो कि डेटाबेस के जीएडिट, और देखो, उस पर खुला.

1073
00:58:32,000 --> 00:58:34,000
यह फ़ाइल स्वरूपों के कामुक नहीं है.

1074
00:58:34,000 --> 00:58:38,000
यह वास्तव में प्रति पंक्ति प्रति पंक्ति डेटा लाइन का एक टुकड़ा है,

1075
00:58:38,000 --> 00:58:42,000
लेकिन आप में से उन लोगों के लिए, जो Excel या CSV फ़ाइलों का उपयोग अल्पविराम मूल्यों अलग है,

1076
00:58:42,000 --> 00:58:47,000
मैं निश्चित रूप से fprintf बजाय शायद कुछ इस तरह करते के लिए इस्तेमाल किया जा सकता है

1077
00:58:47,000 --> 00:58:50,000
इतना है कि मैं वास्तव में एक Excel फ़ाइल के बराबर बना सकते हैं

1078
00:58:50,000 --> 00:58:53,000
, सिर्फ नई लाइनें नहीं अल्पविराम के साथ चीजों को अलग - अलग करके.

1079
00:58:53,000 --> 00:58:56,000
>> इस मामले में अगर मैं बजाय अल्पविराम के बजाय नई लाइनों का इस्तेमाल किया था

1080
00:58:56,000 --> 00:59:01,000
मैं सचमुच Excel में इस डेटाबेस फ़ाइल खोल सकता है अगर मैं बजाय यह इस तरह दिखेगा.

1081
00:59:01,000 --> 00:59:03,000
संक्षेप में, अब है कि हम फाइल करने के लिए लिखने की शक्ति है

1082
00:59:03,000 --> 00:59:07,000
हम अब बने डेटा शुरू कर सकते हैं, यह डिस्क पर आसपास रखने

1083
00:59:07,000 --> 00:59:10,000
इतना है कि हम जानकारी के आसपास फिर से और फिर से रख सकते हैं.

1084
00:59:10,000 --> 00:59:14,000
अन्य चीजें हैं जो अब कर रहे हैं थोड़ा और अधिक परिचित के एक जोड़े पर ध्यान दें.

1085
00:59:14,000 --> 00:59:16,000
इस सी फ़ाइल के शीर्ष पर हम एक typedef

1086
00:59:16,000 --> 00:59:21,000
क्योंकि हम एक डेटा प्रकार है कि एक शब्द बनाना चाहता था,

1087
00:59:21,000 --> 00:59:25,000
तो इस प्रकार के शब्द कहा जाता है, और अंदर इस संरचना की

1088
00:59:25,000 --> 00:59:27,000
अब यह एक छोटे से शौक़ीन है.

1089
00:59:27,000 --> 00:59:30,000
जाहिरा तौर पर एक सरणी के एक शब्द क्यों बनाया है?

1090
00:59:30,000 --> 00:59:33,000
Intuitively सिर्फ एक शब्द क्या है?

1091
00:59:33,000 --> 00:59:35,000
>> यह वर्णों की एक सरणी है.

1092
00:59:35,000 --> 00:59:37,000
यह वर्णों के क्रम वापस आ गया है पर वापस.

1093
00:59:37,000 --> 00:59:41,000
सभी टोपियां में पत्र के लिए हो सकता है हम मनमाने ढंग से कहना होता है अधिकतम लंबाई

1094
00:59:41,000 --> 00:59:44,000
शब्दकोश है कि हम हाथापाई के लिए प्रयोग कर रहे हैं में किसी भी शब्द का.

1095
00:59:44,000 --> 00:59:46,000
मैं एक एक क्यों है?

1096
00:59:46,000 --> 00:59:48,000
अशक्त चरित्र.

1097
00:59:48,000 --> 00:59:51,000
याद जब हम Bananagrams उदाहरण हम एक विशेष मूल्य की जरूरत

1098
00:59:51,000 --> 00:59:55,000
शब्द के अंत में क्रम में ट्रैक रखने के लिए

1099
00:59:55,000 --> 00:59:59,000
जहां शब्द वास्तव में समाप्त के रूप में, और समस्या सेट विनिर्देश कहते हैं

1100
00:59:59,000 --> 01:00:03,000
यहाँ हम एक भी शब्द के साथ एक बूलीयन मान जोड़ रहे हैं,

1101
01:00:03,000 --> 01:00:05,000
एक ध्वज है, तो बात है, सही है या गलत.

1102
01:00:05,000 --> 01:00:09,000
क्या आप इस शब्द के पहले ही मिल गया है, क्योंकि हम एहसास

1103
01:00:09,000 --> 01:00:13,000
हम वास्तव में याद करने का एक तरीका की जरूरत है न केवल हाथापाई में एक शब्द है

1104
01:00:13,000 --> 01:00:15,000
लेकिन चाहे या नहीं, मानव, यह मिल गया है

1105
01:00:15,000 --> 01:00:20,000
इसलिए कि यदि आप मिल कर शब्द "" आप न सिर्फ टाइप दर्ज कर सकते हैं, दर्ज करें, दर्ज करें,

1106
01:00:20,000 --> 01:00:23,000
और 3 अंक, 3 अंक, 3 अंक, 3 अंक मिलता है.

1107
01:00:23,000 --> 01:00:26,000
हम एक bool सेटिंग के द्वारा उस शब्द को साल के लिए करने में सक्षम होना चाहते हैं

1108
01:00:26,000 --> 01:00:29,000
सच करने के लिए अगर आप पहले से ही पाया है, और इतना है कि क्यों हम है

1109
01:00:29,000 --> 01:00:31,000
इस संरचना में समझाया.

1110
01:00:31,000 --> 01:00:35,000
>> अब, यहाँ नीचे हाथापाई में यह अन्य शब्दकोश struct कहा जाता है.

1111
01:00:35,000 --> 01:00:39,000
यहाँ अनुपस्थित शब्द है typedef है क्योंकि इस मामले में

1112
01:00:39,000 --> 01:00:43,000
हम एक शब्दकोश के विचार encapsulate की जरूरत है,

1113
01:00:43,000 --> 01:00:46,000
और एक शब्दकोश में शब्दों की एक पूरी गुच्छा है,

1114
01:00:46,000 --> 01:00:49,000
इस सरणी के रूप में निहित है, और उन शब्दों में से कितने हैं?

1115
01:00:49,000 --> 01:00:51,000
खैर, जो भी इस चर बुलाया आकार कहते हैं.

1116
01:00:51,000 --> 01:00:53,000
लेकिन हम सिर्फ एक शब्दकोश की जरूरत है.

1117
01:00:53,000 --> 01:00:55,000
हम एक डेटा शब्दकोश बुलाया प्रकार की जरूरत नहीं है.

1118
01:00:55,000 --> 01:00:58,000
हम उनमें से सिर्फ एक है, तो यह सी में पता चला है

1119
01:00:58,000 --> 01:01:03,000
कि अगर आप typedef कहना नहीं है, तुम सिर्फ struct कहते हैं, तो घुंघराले ब्रेसिज़ के अंदर

1120
01:01:03,000 --> 01:01:05,000
आप अपने चर रखा है, तो आप का नाम डाल दिया.

1121
01:01:05,000 --> 01:01:09,000
यह एक चर बुलाया शब्दकोश की घोषणा

1122
01:01:09,000 --> 01:01:11,000
कि इस तरह दिखता है.

1123
01:01:11,000 --> 01:01:16,000
इसके विपरीत करके, इन पंक्तियों के एक पुन: प्रयोज्य डेटा शब्द नामक संरचना पैदा कर रहे हैं

1124
01:01:16,000 --> 01:01:19,000
कि आप के कई प्रतियां बनाने के लिए कर सकते हैं, जैसे हम बनाया

1125
01:01:19,000 --> 01:01:22,000
छात्रों की कई प्रतियां.

1126
01:01:22,000 --> 01:01:24,000
>> यह अंततः क्या करता है हमें ऐसा करने की अनुमति है?

1127
01:01:24,000 --> 01:01:30,000
मुझे वापस जाने में, हम कहते हैं, सरल समय से एक सरल उदाहरण,

1128
01:01:30,000 --> 01:01:34,000
और मुझे खोलने के लिए, हम कहते हैं, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
हाथ में यहाँ समस्या वास्तव में वापस छील है

1130
01:01:38,000 --> 01:01:41,000
एक स्ट्रिंग की परत और बंद इन प्रशिक्षण पहियों लेने शुरू

1131
01:01:41,000 --> 01:01:44,000
क्योंकि यह है कि एक स्ट्रिंग यह सब समय बदल जाता है

1132
01:01:44,000 --> 01:01:47,000
के रूप में हम वास्तव में एक सप्ताह में सिर्फ एक उपनाम का वादा किया है,

1133
01:01:47,000 --> 01:01:51,000
एक पर्याय CS50 पुस्तकालय से कुछ है कि एक छोटे से अधिक गुप्त लग रहा है के लिए,

1134
01:01:51,000 --> 01:01:53,000
* चार, और हम इस स्टार देखा है पहले.

1135
01:01:53,000 --> 01:01:55,000
हम यह फाइलों के संदर्भ में देखा था.

1136
01:01:55,000 --> 01:01:59,000
>> चलो अब हम देखते हैं कि हम कुछ समय के लिए किया गया है अब इस विस्तार छुपा.

1137
01:01:59,000 --> 01:02:02,000
यहाँ एक compare1.c नामक एक फाइल है,

1138
01:02:02,000 --> 01:02:07,000
और यह स्पष्ट तौर पर 2 तार के लिए उपयोगकर्ता पूछता है, और एस टी

1139
01:02:07,000 --> 01:02:11,000
और फिर यह लाइन 26 में समानता के लिए उन तार की तुलना करने की कोशिश करता है,

1140
01:02:11,000 --> 01:02:14,000
और अगर वे बराबर यह कहते हैं, "आप एक ही बात लिखा है,"

1141
01:02:14,000 --> 01:02:17,000
और अगर वे बराबर नहीं कर रहे हैं यह कहते हैं, "आप अलग अलग चीजें टाइप."

1142
01:02:17,000 --> 01:02:19,000
मुझे आगे जाना है और इस कार्यक्रम को चलाने.

1143
01:02:19,000 --> 01:02:23,000
मुझे अपने स्रोत निर्देशिका में चलते हैं, एक compare1. यह ठीक संकलित.

1144
01:02:23,000 --> 01:02:25,000
मुझे compare1 चलाने के.

1145
01:02:25,000 --> 01:02:27,000
मैं में ज़ूम प्रवेश करेंगे.

1146
01:02:27,000 --> 01:02:29,000
कुछ तो कहो. नमस्कार.

1147
01:02:29,000 --> 01:02:32,000
मैं कुछ फिर से कहूँगा. नमस्कार.

1148
01:02:32,000 --> 01:02:34,000
मैं निश्चित रूप से अलग अलग बातें नहीं लिखें.

1149
01:02:34,000 --> 01:02:37,000
>> मुझे यह फिर से कोशिश. अलविदा.

1150
01:02:37,000 --> 01:02:40,000
निश्चित रूप से अलग नहीं है तो, यहां क्या हो रहा है?

1151
01:02:40,000 --> 01:02:44,000
खैर, क्या वास्तव में 26 लाइन में तुलना की जा रही है?

1152
01:02:44,000 --> 01:02:46,000
[अश्राव्य छात्र]

1153
01:02:46,000 --> 01:02:49,000
हाँ, तो यह पता चला है कि एक स्ट्रिंग, डेटा प्रकार, एक सफेद झूठ की तरह है.

1154
01:02:49,000 --> 01:02:53,000
एक स्ट्रिंग एक चार * है, लेकिन एक चार * क्या है?

1155
01:02:53,000 --> 01:02:56,000
एक चार *, के रूप में वे कहते हैं, एक सूचक है,

1156
01:02:56,000 --> 01:03:00,000
और एक सूचक को प्रभावी ढंग से पता है,

1157
01:03:00,000 --> 01:03:05,000
स्मृति में एक राशि स्थान है, और यदि आप एक शब्द में नमस्ते की तरह टाइप किया होगा,

1158
01:03:05,000 --> 01:03:08,000
तार के पिछले चर्चा से याद

1159
01:03:08,000 --> 01:03:16,000
इस शब्द की तरह है, नमस्कार.

1160
01:03:16,000 --> 01:03:19,000
याद रखें कि HELLO तरह एक शब्द का प्रतिनिधित्व किया जा सकता है

1161
01:03:19,000 --> 01:03:22,000
इस तरह वर्णों की एक सरणी के रूप में

1162
01:03:22,000 --> 01:03:25,000
और फिर अंत में एक विशेष चरित्र के साथ अशक्त चरित्र कहा जाता है,

1163
01:03:25,000 --> 01:03:27,000
\ अर्थ के रूप में.

1164
01:03:27,000 --> 01:03:29,000
क्या वास्तव में एक स्ट्रिंग है?

1165
01:03:29,000 --> 01:03:32,000
सूचना है कि इस स्मृति के कई हिस्सा है,

1166
01:03:32,000 --> 01:03:36,000
और वास्तव में, यह के अंत में केवल एक बार आप पूरे तार के माध्यम से देखो में जाना जाता है

1167
01:03:36,000 --> 01:03:38,000
विशेष अशक्त चरित्र के लिए देख रहे हैं.

1168
01:03:38,000 --> 01:03:41,000
लेकिन अगर यह मेरे कंप्यूटर की स्मृति से स्मृति का एक हिस्सा है,

1169
01:03:41,000 --> 01:03:44,000
चलो मनमाने ढंग से कहना है कि इस स्ट्रिंग सिर्फ भाग्यशाली है,

1170
01:03:44,000 --> 01:03:47,000
और यह मेरे कंप्यूटर रैम के बहुत शुरुआत में रखा गया.

1171
01:03:47,000 --> 01:03:54,000
यह बाइट 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> जब मैं GetString की तरह कुछ कहते हैं और मैं स्ट्रिंग एस = GetString

1173
01:04:02,000 --> 01:04:04,000
क्या वास्तव में वापस आ रहा है जा रहा है?

1174
01:04:04,000 --> 01:04:08,000
इन पिछले कई हफ्तों के लिए, क्या वास्तव में एस में संग्रहित किया जा रहा

1175
01:04:08,000 --> 01:04:13,000
से प्रति इस स्ट्रिंग नहीं है, लेकिन इस मामले में क्या है संग्रहित किया जा रहा है

1176
01:04:13,000 --> 01:04:18,000
क्या वास्तव में GetString करता है क्योंकि संख्या 0

1177
01:04:18,000 --> 01:04:20,000
यह शारीरिक रूप से एक स्ट्रिंग वापस नहीं करता है.

1178
01:04:20,000 --> 01:04:22,000
वह भी वास्तव में वैचारिक समझ नहीं पड़ता है.

1179
01:04:22,000 --> 01:04:24,000
यह क्या करता वापसी एक संख्या है.

1180
01:04:24,000 --> 01:04:28,000
उस नंबर HELLO के स्मृति में पता है,

1181
01:04:28,000 --> 01:04:32,000
और स्ट्रिंग तो, अगर हम इस परत वापस छील, स्ट्रिंग वास्तव में नहीं मौजूद नहीं है.

1182
01:04:32,000 --> 01:04:35,000
यह केवल CS50 पुस्तकालय में सरलीकरण है.

1183
01:04:35,000 --> 01:04:38,000
>> यह वास्तव में कुछ चार * कहा जाता है.

1184
01:04:38,000 --> 01:04:41,000
चार समझ में आता है, क्योंकि जो एक शब्द की तरह है,?

1185
01:04:41,000 --> 01:04:44,000
खैर, यह वर्ण की एक श्रृंखला है, वर्णों की एक श्रृंखला है.

1186
01:04:44,000 --> 01:04:47,000
चार * एक चरित्र का पता होता है,

1187
01:04:47,000 --> 01:04:50,000
तो क्या यह एक स्ट्रिंग वापस करने के लिए क्या मतलब है?

1188
01:04:50,000 --> 01:04:53,000
एक अच्छा, एक स्ट्रिंग लौटने का आसान तरीका

1189
01:04:53,000 --> 01:04:57,000
बजाय पता लगाने की कैसे मैं 5 या 6 अलग बाइट्स के लिए वापस करने की कोशिश

1190
01:04:57,000 --> 01:05:01,000
मुझे जो बाइट के पते पर लौटने के लिए?

1191
01:05:01,000 --> 01:05:03,000
पहले एक.

1192
01:05:03,000 --> 01:05:06,000
दूसरे शब्दों में, मुझे तुम स्मृति में एक चरित्र का पता दे.

1193
01:05:06,000 --> 01:05:10,000
यही कारण है कि क्या चार * का प्रतिनिधित्व करता है, स्मृति में एक ही चरित्र का पता.

1194
01:05:10,000 --> 01:05:12,000
कि चर के कॉल.

1195
01:05:12,000 --> 01:05:15,000
एस में स्टोर है कि विशेष रूप से पता है, जो मैं मनमाने ढंग से कहा 0 है,

1196
01:05:15,000 --> 01:05:19,000
सिर्फ बातें सरल रखने के लिए है, लेकिन वास्तविकता में यह आम तौर पर एक बड़ी संख्या है.

1197
01:05:19,000 --> 01:05:21,000
>> एक मिनट रुको.

1198
01:05:21,000 --> 01:05:23,000
यदि आप केवल मुझे पहली चरित्र का पता दे रहे हैं, मैं नहीं जानता कि कैसे पता क्या है

1199
01:05:23,000 --> 01:05:25,000
चरित्र के 2, 3, 4 और 5?

1200
01:05:25,000 --> 01:05:27,000
[अश्राव्य छात्र]

1201
01:05:27,000 --> 01:05:31,000
आप सिर्फ इतना पता है कि जहां स्ट्रिंग के अंत इस काम चाल की जिस तरह से है,

1202
01:05:31,000 --> 01:05:35,000
इसलिए जब आप की तरह कुछ printf का उपयोग करें, क्या printf सचमुच अपने तर्क के रूप में लेता है,

1203
01:05:35,000 --> 01:05:39,000
याद है कि हम इस% s प्लेसहोल्डर का उपयोग करते हैं, और फिर तुम में पारित

1204
01:05:39,000 --> 01:05:41,000
चर कि एक स्ट्रिंग भंडारण है.

1205
01:05:41,000 --> 01:05:47,000
क्या तुम सच में गुजर रहे हैं कि स्ट्रिंग के पहले चरित्र का पता है.

1206
01:05:47,000 --> 01:05:50,000
Printf तो पाश या एक समय पाश के लिए उस पते प्राप्त करने पर एक का उपयोग करता है,

1207
01:05:50,000 --> 01:05:53,000
उदाहरण के लिए, 0, इसलिए मुझे अब यह कर,

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n");

1209
01:06:02,000 --> 01:06:07,000
जब मैं कॉल printf ("% s \ n" s), मैं क्या सच के साथ रहा हूँ printf उपलब्ध कराने के

1210
01:06:07,000 --> 01:06:13,000
एस में 1 चरित्र का पता है, जो इस मनमाने ढंग से मामले में एच.

1211
01:06:13,000 --> 01:06:16,000
>> Printf कैसे पता है कि क्या वास्तव में स्क्रीन पर प्रदर्शित करने के लिए?

1212
01:06:16,000 --> 01:06:19,000
व्यक्ति जो कार्यान्वित किया printf एक समय या पाश के लिए एक पाश लागू

1213
01:06:19,000 --> 01:06:23,000
कि का कहना है कि इस चरित्र विशेष अशक्त चरित्र के बराबर है?

1214
01:06:23,000 --> 01:06:25,000
यदि नहीं, तो इसे प्रिंट. यह कैसे एक के बारे में?

1215
01:06:25,000 --> 01:06:28,000
यदि यह मुद्रित नहीं, इसे प्रिंट, इसे प्रिंट, इसे मुद्रित.

1216
01:06:28,000 --> 01:06:32,000
ओह, यह एक खास बात है. मुद्रण बंद करो और उपयोगकर्ता के लिए लौटने.

1217
01:06:32,000 --> 01:06:35,000
और कि सचमुच सब कि हुड के नीचे हो रहा है,

1218
01:06:35,000 --> 01:06:38,000
और कहा कि एक वर्ग के पहले दिन में पचाने के लिए एक बहुत कुछ है,

1219
01:06:38,000 --> 01:06:43,000
लेकिन अब के लिए यह वास्तव में समझ सब कुछ के निर्माण खंड

1220
01:06:43,000 --> 01:06:46,000
कि हमारे कंप्यूटर की स्मृति के अंदर चल रहा है,

1221
01:06:46,000 --> 01:06:49,000
और अंततः हम एक छोटी सी मदद के साथ अलग चिढ़ाने के हूँ

1222
01:06:49,000 --> 01:06:51,000
हमारे मित्रों में से एक से स्टैनफोर्ड में.

1223
01:06:51,000 --> 01:06:56,000
>> स्टैनफोर्ड में प्रोफेसर निक Parlante इस अद्भुत वीडियो अनुक्रम किया है

1224
01:06:56,000 --> 01:06:58,000
अलग अलग भाषाओं कि शुरू के सभी प्रकार से

1225
01:06:58,000 --> 01:07:00,000
इस छोटे claymation चरित्र Binky.

1226
01:07:00,000 --> 01:07:03,000
आवाज़ आप कर रहे हैं के बारे में बस कुछ ही 2 पूर्वावलोकन चुपके में सुनना

1227
01:07:03,000 --> 01:07:05,000
स्टैनफोर्ड में प्रोफेसर की है, और तुम हो रही है

1228
01:07:05,000 --> 01:07:07,000
अब इस अधिकार के केवल 5 या 6 सेकंड,

1229
01:07:07,000 --> 01:07:09,000
लेकिन इस नोट जिस पर हम आज समाप्त होगा

1230
01:07:09,000 --> 01:07:11,000
और बुधवार को शुरू करते हैं.

1231
01:07:11,000 --> 01:07:15,000
मैं आप सूचक Binky पूर्वावलोकन के साथ मज़ा दे.

1232
01:07:15,000 --> 01:07:18,000
[♪ ♪ संगीत] [प्रोफेसर Parlante] अरे, Binky.

1233
01:07:18,000 --> 01:07:21,000
जागो. यह सूचक मज़ा के लिए समय है.

1234
01:07:21,000 --> 01:07:24,000
[Binky] वह क्या है? संकेत के बारे में जानें?

1235
01:07:24,000 --> 01:07:26,000
ओह, वाह!

1236
01:07:26,000 --> 01:07:29,000
>> हम बुधवार को देखेंगे.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]