1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [धारा 6] [अधिक आरामदायक]

2
00:00:01,000 --> 00:00:04,000
[रोब Bowden] [हार्वर्ड विश्वविद्यालय]

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

4
00:00:09,000 --> 00:00:11,000
>> हम सवालों के हमारे अनुभाग के लिए सिर कर सकते हैं.

5
00:00:11,000 --> 00:00:17,000
मैं पहले अंतरिक्ष के लिए URL को भेजा.

6
00:00:17,000 --> 00:00:22,000
सवालों के अनुभाग की शुरुआत का कहना है -

7
00:00:22,000 --> 00:00:26,000
जाहिरा तौर पर मैं पूरी तरह से एक बहुत ही आसान सवाल unsick है नहीं कर रहा हूँ

8
00:00:26,000 --> 00:00:28,000
बस क्या valgrind है?

9
00:00:28,000 --> 00:00:30,000
वेलग्रिंड क्या करता है?

10
00:00:30,000 --> 00:00:34,000
किसी कहना है वेलग्रिंड क्या करता करना चाहते हैं?

11
00:00:34,000 --> 00:00:36,000
[छात्र] चेक स्मृति लीक.

12
00:00:36,000 --> 00:00:41,000
हाँ, वेलग्रिंड एक सामान्य स्मृति चेकर है.

13
00:00:41,000 --> 00:00:44,000
यह अंत में, आपको बताता है कि अगर आप किसी भी स्मृति लीक है,

14
00:00:44,000 --> 00:00:49,000
जिनमें से ज्यादातर है कि हम क्या ऐसा इसलिए है क्योंकि के लिए उपयोग कर रहे हैं यदि आप चाहते हैं

15
00:00:49,000 --> 00:00:54,000
समस्या सेट में या आप चाहते हैं, तो अच्छी तरह से करने के

16
00:00:54,000 --> 00:00:59,000
बड़े बोर्ड पर मिलता है, तुम जो भी कोई स्मृति लीक की जरूरत है,

17
00:00:59,000 --> 00:01:01,000
और मामले में आप एक स्मृति रिसाव है कि तुम नहीं मिल सकता है,

18
00:01:01,000 --> 00:01:04,000
यह भी ध्यान में रखना है कि जब भी आप एक फ़ाइल खोलने

19
00:01:04,000 --> 00:01:07,000
और अगर आप इसे नहीं बंद करते हैं, कि एक स्मृति रिसाव है.

20
00:01:07,000 --> 00:01:10,000
>> लोगों का एक बहुत कुछ नोड के लिए देख रहे हैं कि वे मुक्त कराने के नहीं रहे हैं

21
00:01:10,000 --> 00:01:15,000
जब वास्तव में, वे बहुत पहले कदम में शब्दकोश नहीं बंद नहीं किया.

22
00:01:15,000 --> 00:01:19,000
यह आपको यह भी बताता है कि अगर आप किसी भी अवैध है पढ़ता है या लिखते हैं,

23
00:01:19,000 --> 00:01:22,000
जिसका मतलब है कि अगर आप कोशिश करते हैं और एक मूल्य निर्धारित

24
00:01:22,000 --> 00:01:26,000
कि ढेर के अंत से परे है और यह seg गलती के लिए नहीं होता है

25
00:01:26,000 --> 00:01:30,000
लेकिन वेलग्रिंड यह पकड़ता है, के रूप में आप वास्तव में नहीं वहाँ लेखन चाहिए,

26
00:01:30,000 --> 00:01:33,000
और इसलिए आप निश्चित रूप से उन दोनों में से किसी भी नहीं होना चाहिए.

27
00:01:33,000 --> 00:01:38,000
कैसे आप प्रयोग करते valgrind?

28
00:01:38,000 --> 00:01:42,000
कैसे आप प्रयोग करते valgrind?

29
00:01:42,000 --> 00:01:45,000
>> यह एक सामान्य सवाल है

30
00:01:45,000 --> 00:01:49,000
की तरह इसे चलाते हैं और उत्पादन को देखो.

31
00:01:49,000 --> 00:01:51,000
उत्पादन समय की एक बहुत भारी है.

32
00:01:51,000 --> 00:01:54,000
वहाँ भी मज़ा त्रुटियों जहां अगर आप कुछ बहुत गलत बात है

33
00:01:54,000 --> 00:01:59,000
एक पाश में हो रहा है, तो यह अंततः कहते हैं, "रास्ता भी कई त्रुटियों.

34
00:01:59,000 --> 00:02:03,000
मैं अब गिनती को रोकने के लिए जा रहा हूँ. "

35
00:02:03,000 --> 00:02:08,000
यह मूल रूप से है कि आप को पार्स शाब्दिक उत्पादन है.

36
00:02:08,000 --> 00:02:13,000
अंत में, यह है कि आप किसी भी स्मृति लीक बताना होगा,

37
00:02:13,000 --> 00:02:16,000
कितने ब्लॉक, जो उपयोगी हो सकता है क्योंकि

38
00:02:16,000 --> 00:02:20,000
अगर यह एक ब्लॉक unfreed है, तो यह आमतौर पर है खोजने के लिए आसान

39
00:02:20,000 --> 00:02:23,000
1,000 से अधिक ब्लॉकों unfreed.

40
00:02:23,000 --> 00:02:26,000
1000 unfreed ब्लॉकों शायद मतलब है कि आप को मुक्त कराने नहीं कर रहे हैं

41
00:02:26,000 --> 00:02:30,000
अपने लिंक उचित या कुछ सूचियों.

42
00:02:30,000 --> 00:02:32,000
कि valgrind है.

43
00:02:32,000 --> 00:02:35,000
>> अब हम हमारे सवालों के अनुभाग है,

44
00:02:35,000 --> 00:02:38,000
जो आप डाउनलोड की जरूरत नहीं है.

45
00:02:38,000 --> 00:02:41,000
आप मेरे नाम पर क्लिक करें और उन्हें अंतरिक्ष में खींच सकते हैं.

46
00:02:41,000 --> 00:02:44,000
अब मुझ पर क्लिक करें.

47
00:02:44,000 --> 00:02:46,000
1 अवतरण ढेर, जिसे हम पहली बार कर रहे हैं होगा.

48
00:02:46,000 --> 00:02:55,000
2 संशोधन कतार हो जाएगा, और 3 संशोधन अकेले लिंक सूची होगा.

49
00:02:55,000 --> 00:02:58,000
हमारे ढेर के साथ बंद शुरू.

50
00:02:58,000 --> 00:03:02,000
के रूप में यह यहाँ का कहना है, एक ढेर एक सबसे बुनियादी है,

51
00:03:02,000 --> 00:03:07,000
कंप्यूटर विज्ञान की मूलभूत डेटा संरचनाओं.

52
00:03:07,000 --> 00:03:11,000
बहुत prototypical उदाहरण है

53
00:03:11,000 --> 00:03:13,000
डायनिंग हॉल में ट्रे के ढेर.

54
00:03:13,000 --> 00:03:16,000
यह मूल रूप से जब भी आप एक ढेर करने के लिए शुरू की जा रही है,

55
00:03:16,000 --> 00:03:20,000
किसी को कहते हैं, जा रहा है "ओह ट्रे के एक ढेर की तरह."

56
00:03:20,000 --> 00:03:22,000
आप ट्रे धुआँरा.

57
00:03:22,000 --> 00:03:24,000
फिर जब आप एक ट्रे खींचने के लिए जाना,

58
00:03:24,000 --> 00:03:31,000
1 ट्रे खींच लिया हो रही है कि पिछले एक है कि ढेर पर डाल दिया गया है.

59
00:03:31,000 --> 00:03:34,000
यहाँ यह भी तरह ढेर कहते हैं

60
00:03:34,000 --> 00:03:37,000
हम स्मृति के खंड ढेर कहा जाता है.

61
00:03:37,000 --> 00:03:40,000
और यह ढेर क्यों कहा जाता है?

62
00:03:40,000 --> 00:03:42,000
>> क्योंकि एक ढेर डेटा संरचना की तरह,

63
00:03:42,000 --> 00:03:46,000
यह धक्का और चबूतरे ढेर पर ढेर फ्रेम,

64
00:03:46,000 --> 00:03:53,000
जहां ढेर फ्रेम एक समारोह के एक विशिष्ट कॉल की तरह कर रहे हैं.

65
00:03:53,000 --> 00:03:57,000
और एक ढेर की तरह, आप हमेशा के लिए वापसी करना होगा

66
00:03:57,000 --> 00:04:03,000
एक समारोह फोन से पहले आप नीचे कम ढेर फ्रेम में फिर से प्राप्त कर सकते हैं.

67
00:04:03,000 --> 00:04:08,000
आप मुख्य कॉल foo कॉल बार और बार मुख्य सीधे वापस नहीं हो सकता.

68
00:04:08,000 --> 00:04:14,000
यह हमेशा के लिए सही धक्का और popping ढेर का पालन करने के लिए मिल गया है.

69
00:04:14,000 --> 00:04:18,000
दो ऑपरेशन जैसा मैंने कहा था, धक्का और पॉप हैं.

70
00:04:18,000 --> 00:04:20,000
उन सार्वभौमिक शर्तों रहे हैं.

71
00:04:20,000 --> 00:04:26,000
आप धक्का और कोई बात नहीं क्या ढेर के मामले में पॉप पता होना चाहिए.

72
00:04:26,000 --> 00:04:28,000
हम देखेंगे पंक्तिज को संचित करना अलग की तरह कर रहे हैं.

73
00:04:28,000 --> 00:04:32,000
यह वास्तव में एक सार्वभौमिक शब्द नहीं है, लेकिन धक्का और पॉप के ढेर के लिए सार्वभौमिक हैं.

74
00:04:32,000 --> 00:04:34,000
पुश बस ढेर पर डाल दिया है.

75
00:04:34,000 --> 00:04:37,000
पॉप बंद ले चुकी है.

76
00:04:37,000 --> 00:04:43,000
और हम देखते हैं कि हम हमारे typedef struct ढेर,

77
00:04:43,000 --> 00:04:46,000
इसलिए हम char ** तार है.

78
00:04:46,000 --> 00:04:51,000
किसी भी ** से डर नहीं है.

79
00:04:51,000 --> 00:04:54,000
यह अंत में तार का एक सरणी होने जा रहा है

80
00:04:54,000 --> 00:04:58,000
या वर्ण के लिए संकेत की एक सरणी, जहां

81
00:04:58,000 --> 00:05:00,000
वर्ण के लिए संकेत करने के लिए तार हो जाते हैं.

82
00:05:00,000 --> 00:05:05,000
यह तार नहीं है, लेकिन यहाँ वे तार होने जा रहे हैं.

83
00:05:05,000 --> 00:05:08,000
>> हम तारों की एक सरणी है.

84
00:05:08,000 --> 00:05:14,000
हम एक आकार है, जो प्रतिनिधित्व करता है कि कितने तत्वों ढेर पर वर्तमान में कर रहे हैं,

85
00:05:14,000 --> 00:05:19,000
और फिर हम क्षमता है, जो है कि कितने तत्वों ढेर पर हो सकता है.

86
00:05:19,000 --> 00:05:22,000
क्षमता 1 से अधिक कुछ के रूप में शुरू कर देना चाहिए,

87
00:05:22,000 --> 00:05:27,000
लेकिन आकार 0 के रूप में शुरू करने जा रहा है.

88
00:05:27,000 --> 00:05:36,000
अब, वहाँ मूल रूप से कर रहे हैं तीन अलग अलग तरीकों से आप एक ढेर के बारे में सोच सकते हैं.

89
00:05:36,000 --> 00:05:39,000
खैर, वहाँ शायद अधिक है, लेकिन दो मुख्य तरीके हैं

90
00:05:39,000 --> 00:05:43,000
आप इसे लागू एक सरणी का उपयोग कर सकते हैं, या आप इसे लागू करने के लिए एक लिंक सूची का उपयोग कर सकते हैं.

91
00:05:43,000 --> 00:05:48,000
लिंक सूचियों तरह से ढेर बनाने के लिए तुच्छ है.

92
00:05:48,000 --> 00:05:51,000
यह बहुत आसान है के लिए एक लिंक सूचियों का उपयोग ढेर,

93
00:05:51,000 --> 00:05:55,000
तो यहाँ, हम एक ढेर arrays का उपयोग करने के लिए जा रहे हैं,

94
00:05:55,000 --> 00:05:59,000
और फिर arrays का उपयोग, वहाँ भी दो तरीकों से आप इसके बारे में सोच सकते हैं.

95
00:05:59,000 --> 00:06:01,000
इससे पहले, जब मैंने कहा कि हम ढेर के लिए एक क्षमता है,

96
00:06:01,000 --> 00:06:04,000
तो हम ढेर पर एक तत्व फिट कर सकते हैं.

97
00:06:04,000 --> 00:06:09,000
>> एक तरीका यह हो सकता है के रूप में के रूप में आप 10 तत्वों मारा, तो आप कर रहे हैं जल्द ही है.

98
00:06:09,000 --> 00:06:13,000
तुम जानते हो सकता है कि वहाँ एक ऊपरी दुनिया में 10 चीजों में से एक ही है

99
00:06:13,000 --> 00:06:16,000
कि आप 10 से अधिक बातें अपने ढेर पर कभी नहीं होगा,

100
00:06:16,000 --> 00:06:20,000
जो मामले में आप अपने ढेर के आकार पर ऊपरी बाध्य हो सकता है.

101
00:06:20,000 --> 00:06:23,000
या तुम हो सकता है अपने ढेर असीम हो,

102
00:06:23,000 --> 00:06:27,000
लेकिन अगर आप एक सरणी कर रहे हैं, इसका मतलब है कि हर बार जब आप 10 तत्वों मारा,

103
00:06:27,000 --> 00:06:29,000
तो आप करने के लिए 20 तत्वों को विकसित करने के लिए जा रहे हैं, और जब आप 20 तत्वों मारा,

104
00:06:29,000 --> 00:06:33,000
आप करने के लिए 30 तत्वों या 40 तत्वों को अपने सरणी बढ़ने जा रहे हैं.

105
00:06:33,000 --> 00:06:37,000
आप करने के लिए क्षमता है, जो हम यहाँ क्या करने जा रहे हैं बढ़ाने की आवश्यकता के लिए जा रहे हैं.

106
00:06:37,000 --> 00:06:40,000
हर बार जब हम हमारे ढेर के अधिकतम आकार तक पहुँचने,

107
00:06:40,000 --> 00:06:46,000
जब हम पर कुछ धक्का, हम करने के लिए क्षमता बढ़ाने की आवश्यकता के लिए जा रहे हैं.

108
00:06:46,000 --> 00:06:50,000
यहाँ, हम धक्का bool धक्का (चार * str) के रूप में घोषित किया है.

109
00:06:50,000 --> 00:06:54,000
चार * str स्ट्रिंग है कि हम ढेर पर जोर दे रहे हैं,

110
00:06:54,000 --> 00:06:58,000
और bool बस का कहना है कि हम सफल हो या असफल.

111
00:06:58,000 --> 00:07:00,000
>> हम कैसे विफल कर सकते हैं?

112
00:07:00,000 --> 00:07:04,000
केवल परिस्थिति है कि आप सोच सकते हैं क्या है

113
00:07:04,000 --> 00:07:07,000
जहाँ हम झूठी वापसी की आवश्यकता होगी?

114
00:07:07,000 --> 00:07:09,000
हाँ.

115
00:07:09,000 --> 00:07:12,000
[छात्र] यदि यह भरा हुआ है और हम एक घिरा कार्यान्वयन का उपयोग कर रहे हैं.

116
00:07:12,000 --> 00:07:17,000
हाँ, तो कैसे हम को परिभाषित वह जवाब दिए

117
00:07:17,000 --> 00:07:23,000
अगर यह भरा हुआ है और हम घिरा कार्यान्वयन का उपयोग कर रहे हैं.

118
00:07:23,000 --> 00:07:26,000
तो हम निश्चित रूप से झूठी वापस आ जाएगी.

119
00:07:26,000 --> 00:07:31,000
जैसे ही हम सरणी में 10 चीजें हिट, हम 11 फिट नहीं कर सकते, तो हम वापसी झूठी.

120
00:07:31,000 --> 00:07:32,000
अगर यह असीमित है तो क्या होगा? हाँ.

121
00:07:32,000 --> 00:07:38,000
यदि आप किसी कारण के लिए सरणी का विस्तार नहीं कर सकते हैं.

122
00:07:38,000 --> 00:07:43,000
हाँ, तो स्मृति एक सीमित संसाधन है,

123
00:07:43,000 --> 00:07:51,000
और अंत में, अगर हम ढेर पर पर और फिर से धक्का चीजें रखने के लिए,

124
00:07:51,000 --> 00:07:54,000
हम कोशिश करते हैं और एक बड़ा सरणी आवंटित करने के लिए फिट करने के लिए जा रहे हैं

125
00:07:54,000 --> 00:07:59,000
बड़ी क्षमता, और malloc या जो कुछ भी हम प्रयोग कर रहे हैं झूठी वापसी करने के लिए जा रहा है.

126
00:07:59,000 --> 00:08:02,000
खैर, malloc रिक्त वापस आ जाएगी.

127
00:08:02,000 --> 00:08:05,000
>> याद रखें, हर बार जब आप कभी malloc कॉल, आप देखने के लिए जाँच किया जाना चाहिए अगर

128
00:08:05,000 --> 00:08:12,000
अशक्त रिटर्न या किसी और कि शुद्धता कटौती है.

129
00:08:12,000 --> 00:08:17,000
चूंकि हम एक असीम ढेर है चाहते हैं,

130
00:08:17,000 --> 00:08:21,000
केवल मामले में हम झूठी लौट जा रहे हैं अगर हम कोशिश

131
00:08:21,000 --> 00:08:26,000
क्षमता और malloc बढ़ाने या जो भी झूठे रिटर्न.

132
00:08:26,000 --> 00:08:30,000
फिर पॉप कोई तर्क लेता है,

133
00:08:30,000 --> 00:08:37,000
और यह स्ट्रिंग है कि ढेर के शीर्ष पर है देता है.

134
00:08:37,000 --> 00:08:41,000
जो भी सबसे हाल ही में ढेर पर धकेल दिया गया था पॉप क्या लौट रहा है,

135
00:08:41,000 --> 00:08:44,000
और यह भी ढेर से हटाता है.

136
00:08:44,000 --> 00:08:50,000
नोटिस और है कि यह शून्य देता है अगर वहाँ ढेर पर कुछ भी नहीं है.

137
00:08:50,000 --> 00:08:53,000
यह हमेशा संभव है कि ढेर खाली है.

138
00:08:53,000 --> 00:08:55,000
जावा में, अगर आप, या अन्य भाषाओं के लिए इस्तेमाल कर रहे हैं,

139
00:08:55,000 --> 00:09:01,000
खाली स्टैक से पॉप करने की कोशिश कर रहा एक अपवाद या कुछ और कारण हो सकता है.

140
00:09:01,000 --> 00:09:09,000
>> लेकिन सी में अशक्त मामलों में हम कैसे इन समस्याओं को संभालने का एक बहुत की तरह है.

141
00:09:09,000 --> 00:09:13,000
अशक्त रिटर्निंग है कि हम कैसे जा रहे हैं को दर्शाता है कि ढेर खाली था.

142
00:09:13,000 --> 00:09:16,000
हम कोड कि अपने ढेर की कार्यक्षमता का परीक्षण करेगा प्रदान की है,

143
00:09:16,000 --> 00:09:19,000
धक्का और पॉप को लागू करने.

144
00:09:19,000 --> 00:09:23,000
इस कोड का एक बहुत नहीं होगा.

145
00:09:23,000 --> 00:09:40,000
मैं वास्तव में होगा, इससे पहले कि हम करते हैं, संकेत, संकेत -

146
00:09:40,000 --> 00:09:44,000
अगर आप इसे नहीं देखा है, malloc केवल समारोह में नहीं है

147
00:09:44,000 --> 00:09:47,000
कि आप के लिए ढेर पर स्मृति का आवंटन.

148
00:09:47,000 --> 00:09:51,000
Alloc कार्यों के एक परिवार के हैं.

149
00:09:51,000 --> 00:09:53,000
1 malloc, जो आप इस्तेमाल कर रहे है.

150
00:09:53,000 --> 00:09:56,000
तो फिर वहाँ calloc, जो malloc के रूप में एक ही बात करता है,

151
00:09:56,000 --> 00:09:59,000
लेकिन यह सब कुछ आप के लिए बाहर शून्य होगा.

152
00:09:59,000 --> 00:10:04,000
यदि आप कभी कुछ mallocing के बाद है करने के लिए सब कुछ सेट अशक्त चाहता

153
00:10:04,000 --> 00:10:06,000
आप सिर्फ लिखने के बजाय पहली जगह में किया जाना calloc प्रयोग किया जाता है

154
00:10:06,000 --> 00:10:09,000
पाश के लिए एक स्मृति से बाहर पूरे ब्लॉक शून्य.

155
00:10:09,000 --> 00:10:15,000
>> Realloc malloc की तरह है और विशेष मामलों की एक बहुत कुछ किया है,

156
00:10:15,000 --> 00:10:19,000
लेकिन मूल रूप से realloc क्या करता है

157
00:10:19,000 --> 00:10:24,000
यह एक सूचक है कि पहले से ही आवंटित किया गया था लेता है.

158
00:10:24,000 --> 00:10:27,000
Realloc समारोह आप यहाँ ध्यान करने के लिए भुगतान किया जा करना चाहते है.

159
00:10:27,000 --> 00:10:31,000
यह एक सूचक है कि पहले से ही malloc से लौटा दिया गया था लेता है.

160
00:10:31,000 --> 00:10:35,000
मान लीजिए कि आप malloc से 10 बाइट्स की एक सूचक का अनुरोध.

161
00:10:35,000 --> 00:10:38,000
फिर बाद में आपको पता है तुम 20 बाइट्स चाहता था,

162
00:10:38,000 --> 00:10:42,000
तो आप 20 बाइट्स के साथ कि सूचक पर realloc कहते हैं,

163
00:10:42,000 --> 00:10:47,000
और realloc स्वचालित रूप से आप के लिए सब कुछ खत्म कॉपी जाएगा.

164
00:10:47,000 --> 00:10:51,000
यदि आप सिर्फ malloc फिर कहा जाता है, जैसे मैं 10 बाइट्स के एक ब्लॉक है.

165
00:10:51,000 --> 00:10:53,000
अब मैं 20 बाइट्स की एक ब्लॉक की जरूरत है,

166
00:10:53,000 --> 00:10:58,000
तो मैं 20 बाइट्स malloc यदि हां, तो मैं स्वयं पर पहली बात से 10 बाइट्स की नकल है

167
00:10:58,000 --> 00:11:01,000
और दूसरी बात में तो पहली बात मुफ्त.

168
00:11:01,000 --> 00:11:04,000
Realloc कि आप के लिए संभाल लेंगे.

169
00:11:04,000 --> 00:11:11,000
>> सूचना हस्ताक्षर करने के लिए शून्य * होने जा रहा है,

170
00:11:11,000 --> 00:11:15,000
जो सिर्फ स्मृति के ब्लॉक करने के लिए एक सूचक लौटने,

171
00:11:15,000 --> 00:11:17,000
तो शून्य * ptr.

172
00:11:17,000 --> 00:11:22,000
आप एक सामान्य सूचक के रूप में शून्य * के बारे में सोच सकते हैं.

173
00:11:22,000 --> 00:11:27,000
आम तौर पर, शून्य * के साथ आप कभी नहीं सौदा,

174
00:11:27,000 --> 00:11:30,000
लेकिन एक शून्य * malloc लौट रहा है, और फिर यह सिर्फ तरह इस्तेमाल किया है

175
00:11:30,000 --> 00:11:34,000
यह वास्तव में एक चार * होने जा रहा है.

176
00:11:34,000 --> 00:11:37,000
पिछले शून्य * कि malloc से वापस आ गया था

177
00:11:37,000 --> 00:11:41,000
अब realloc करने के लिए पारित किया जा जा रहा है, और फिर आकार

178
00:11:41,000 --> 00:11:49,000
बाइट्स के नए नंबर आवंटित करना चाहते है, तो अपने नए क्षमता है.

179
00:11:49,000 --> 00:11:57,000
मैं तुम्हें एक दो मिनट दे देंगे, और यह हमारे अंतरिक्ष में है.

180
00:11:57,000 --> 00:12:02,000
1 संशोधन के साथ शुरू करो.

181
00:12:16,000 --> 00:12:21,000
मैं तुम्हें करने के लिए पर्याप्त धक्का को लागू करने के लिए समय के बाद के बारे में उम्मीद है कि रोक देंगे,

182
00:12:21,000 --> 00:12:24,000
और फिर मैं तुम्हें एक और पॉप तोड़ दे दूँगा.

183
00:12:24,000 --> 00:12:27,000
लेकिन यह सच है कि ज्यादा कोड बिल्कुल नहीं है.

184
00:12:27,000 --> 00:12:35,000
सबसे शायद कोड विस्तार सामान है, क्षमता का विस्तार.

185
00:12:35,000 --> 00:12:39,000
ठीक है, नहीं करने के लिए पूरी तरह से किया जा दबाव,

186
00:12:39,000 --> 00:12:47,000
लेकिन के रूप में लंबे समय के रूप में आपको लगता है कि आप सही रास्ते पर हैं, यह अच्छी बात है.

187
00:12:47,000 --> 00:12:53,000
>> क्या किसी को किसी भी कोड वे मुझे खींच के साथ सहज महसूस करते है?

188
00:12:53,000 --> 00:12:59,000
हाँ, मैं करता है, लेकिन किसी को भी किसी भी कोड मैं खींच सकते हैं होगा?

189
00:12:59,000 --> 00:13:05,000
ठीक है, तुम शुरू करने के लिए, इसे बचाने के लिए कर सकते हैं, जो कुछ भी यह है?

190
00:13:05,000 --> 00:13:09,000
मैं हमेशा उस कदम को भूल जाते हैं.

191
00:13:09,000 --> 00:13:15,000
ठीक है, धक्का पर देख रहे हैं,

192
00:13:15,000 --> 00:13:18,000
क्या आप अपने कोड की व्याख्या करने के लिए करना चाहते हैं?

193
00:13:18,000 --> 00:13:24,000
[छात्र] सबसे पहले, मैं आकार में वृद्धि हुई.

194
00:13:24,000 --> 00:13:28,000
मुझे लगता है कि शायद मुझे लगता है कि वैसे भी होना चाहिए, मैं आकार में वृद्धि हुई है,

195
00:13:28,000 --> 00:13:31,000
और मैं देख रहा हूँ अगर यह क्षमता से कम है.

196
00:13:31,000 --> 00:13:36,000
और अगर यह क्षमता की तुलना में कम है, मैं सरणी है कि हम पहले से ही है.

197
00:13:36,000 --> 00:13:42,000
और अगर ऐसा नहीं है, मैं 2 द्वारा क्षमता गुणा,

198
00:13:42,000 --> 00:13:50,000
और मैं कुछ करने के लिए तार सरणी reallocate अब एक बड़ी क्षमता के आकार के साथ.

199
00:13:50,000 --> 00:13:55,000
और फिर अगर वह विफल रहता है, तो मैं उपयोगकर्ता बता और वापसी झूठी,

200
00:13:55,000 --> 00:14:04,000
और अगर यह ठीक है, तो मैं नई जगह में तार डाल दिया.

201
00:14:04,000 --> 00:14:07,000
>> [रोब बी] यह भी सूचना है कि हम एक अच्छा bitwise ऑपरेटर यहां इस्तेमाल किया

202
00:14:07,000 --> 00:14:09,000
2 से गुणा करने के लिए.

203
00:14:09,000 --> 00:14:11,000
याद रखें, बाएँ बदलाव हमेशा के लिए 2 से गुणा किया जा रहा है.

204
00:14:11,000 --> 00:14:15,000
सही बदलाव 2 द्वारा लंबे समय के रूप में विभाजित किया गया है जैसा कि आपको याद है कि इसका मतलब है

205
00:14:15,000 --> 00:14:18,000
एक पूर्णांक में 2 से विभाजित के रूप में 2 से विभाजित.

206
00:14:18,000 --> 00:14:20,000
यह यहाँ या वहाँ 1 truncate सकता है.

207
00:14:20,000 --> 00:14:26,000
लेकिन 1 द्वारा छोड़ा बदलाव हमेशा के लिए 2 से गुणा किया जा रहा है,

208
00:14:26,000 --> 00:14:32,000
जब तक आप पूर्णांक की सीमा अतिप्रवाह, और फिर यह नहीं होगा.

209
00:14:32,000 --> 00:14:34,000
एक तरफ टिप्पणी.

210
00:14:34,000 --> 00:14:39,000
मैं करने के लिए क्या यह करने के लिए किसी भी तरह से कुछ कोडिंग बदलने नहीं जा रहा है की तरह,

211
00:14:39,000 --> 00:14:48,000
लेकिन मैं इस तरह से कुछ करना पसंद है.

212
00:14:48,000 --> 00:14:51,000
यह वास्तव में यह थोड़ा लंबा बनाने जा रही है.

213
00:15:04,000 --> 00:15:08,000
शायद यह सही करने के लिए इस शो का मामला नहीं है,

214
00:15:08,000 --> 00:15:14,000
लेकिन मैं खंड की तरह के इन ब्लॉकों में

215
00:15:14,000 --> 00:15:17,000
ठीक है, अगर यह होता है अगर है, तो मैं कुछ करने जा रहा हूँ,

216
00:15:17,000 --> 00:15:19,000
और फिर समारोह में किया जाता है.

217
00:15:19,000 --> 00:15:22,000
मैं तो मेरी आँखों समारोह के नीचे सभी तरह स्क्रॉल की जरूरत नहीं है

218
00:15:22,000 --> 00:15:25,000
देखने के लिए किसी और के बाद क्या होता है.

219
00:15:25,000 --> 00:15:27,000
यह है कि अगर यह होता है अगर है, तो मैं बस वापस.

220
00:15:27,000 --> 00:15:30,000
यह भी इस से परे सब कुछ का अच्छा लाभ जोड़ा गया

221
00:15:30,000 --> 00:15:33,000
अब एक बार छोड़ दिया स्थानांतरित कर दिया है.

222
00:15:33,000 --> 00:15:40,000
मैं अब और नहीं करने के लिए यदि आप कभी हास्यास्पद लंबी लाइनों के पास की जरूरत है,

223
00:15:40,000 --> 00:15:45,000
तो उन 4 बाइट्स की मदद कर सकते हैं, और भी कुछ अधिक छोड़ दिया है,

224
00:15:45,000 --> 00:15:48,000
कम अभिभूत आपको लगता है कि अगर आप की तरह ठीक है, मुझे याद है

225
00:15:48,000 --> 00:15:53,000
मैं पाश के लिए एक एक की और अंदर के अंदर एक समय पाश में वर्तमान में हूँ.

226
00:15:53,000 --> 00:15:58,000
कहीं तुम इस वापसी के तुरंत कर सकते हैं, मैं एक तरह की तरह.

227
00:15:58,000 --> 00:16:05,000
यह पूरी तरह से वैकल्पिक है और किसी भी तरह की उम्मीद नहीं है.

228
00:16:05,000 --> 00:16:12,000
>> [छात्र] वहाँ एक आकार असफल हालत में होना चाहिए?

229
00:16:12,000 --> 00:16:19,000
असफल हालत यहाँ हम realloc करने में विफल रहा है, तो हाँ.

230
00:16:19,000 --> 00:16:22,000
असफल हालत में कैसे संभाव्यतः सूचना,

231
00:16:22,000 --> 00:16:26,000
जब तक हम मुक्त सामान बाद, हम हमेशा विफल करने के लिए जा रहे हैं

232
00:16:26,000 --> 00:16:29,000
कोई फर्क नहीं पड़ता कि कितनी बार हम कुछ पुश करने की कोशिश.

233
00:16:29,000 --> 00:16:32,000
यदि हम धक्का रखने के लिए, हम incrementing आकार रखने के लिए,

234
00:16:32,000 --> 00:16:36,000
भले ही हम कुछ ढेर पर नहीं डाल रहे हैं.

235
00:16:36,000 --> 00:16:39,000
आमतौर पर हम जब तक आकार नहीं बढ़ाया

236
00:16:39,000 --> 00:16:43,000
बाद हम सफलतापूर्वक ढेर पर डाल दिया.

237
00:16:43,000 --> 00:16:50,000
हम यह कहना होगा, या तो यहाँ और यहाँ.

238
00:16:50,000 --> 00:16:56,000
और फिर कह ≤ क्षमता s.size के बजाय, यह क्षमता से भी कम समय है,

239
00:16:56,000 --> 00:17:01,000
क्योंकि हम केवल ले जाया गया, जहां सब कुछ था.

240
00:17:01,000 --> 00:17:07,000
>> और याद रखना, केवल जगह है कि हम संभवतः झूठी लौट सकता है

241
00:17:07,000 --> 00:17:14,000
यहाँ है, जहां realloc अशक्त लौटे,

242
00:17:14,000 --> 00:17:19,000
और अगर आप मानक त्रुटि को याद होगा,

243
00:17:19,000 --> 00:17:22,000
शायद आप इस मामले में एक विचार है जहां आप एक मानक त्रुटि मुद्रित करना चाहते हो सकता है,

244
00:17:22,000 --> 00:17:26,000
सिर्फ मानक बाहर करने के लिए सीधे मुद्रण के बजाय ऐसा fprintf stderr.

245
00:17:26,000 --> 00:17:31,000
फिर, कि एक उम्मीद नहीं है, लेकिन अगर यह एक त्रुटि है,

246
00:17:31,000 --> 00:17:41,000
printf टाइप करें, तो आप बनाने के लिए यह मानक बाहर के बजाय मानक त्रुटि मुद्रित करना चाहते हो सकता है.

247
00:17:41,000 --> 00:17:44,000
>> किसी को भी कुछ और ध्यान दें करने के लिए है? हां.

248
00:17:44,000 --> 00:17:47,000
[छात्र] आप [अश्राव्य] पर जा सकते हैं?

249
00:17:47,000 --> 00:17:55,000
[रोब बी] हाँ, यह की वास्तविक binariness या सिर्फ यह है क्या?

250
00:17:55,000 --> 00:17:57,000
[छात्र] तो आप इसे 2 से गुणा?

251
00:17:57,000 --> 00:17:59,000
[रोब बी] हाँ, मूल रूप से.

252
00:17:59,000 --> 00:18:11,000
बाइनरी भूमि में, हम हमेशा अंकों की हमारे सेट है.

253
00:18:11,000 --> 00:18:22,000
1 द्वारा इस बाएं मूल रूप से यह सही पक्ष में यहाँ आवेषण स्थानांतरण.

254
00:18:22,000 --> 00:18:25,000
यह करने के लिए वापस, सिर्फ द्विआधारी में है कि सब कुछ याद

255
00:18:25,000 --> 00:18:28,000
2 की एक शक्ति है, तो इस 0 2 का प्रतिनिधित्व करता है,

256
00:18:28,000 --> 00:18:30,000
1 इस 2, 2 से 2.

257
00:18:30,000 --> 00:18:33,000
अब सही पक्ष के लिए एक 0 डालने से, हम बस सब कुछ शिफ्ट खत्म हो गया.

258
00:18:33,000 --> 00:18:38,000
क्या 0 से 2 इस्तेमाल किया जा अब है 1 2, 2 2 है.

259
00:18:38,000 --> 00:18:41,000
सही पक्ष है कि हम द्वारा सम्मिलित

260
00:18:41,000 --> 00:18:44,000
जरूरी 0 होने जा रहा है,

261
00:18:44,000 --> 00:18:46,000
जो समझ में आता है.

262
00:18:46,000 --> 00:18:49,000
यदि आप कभी भी एक संख्या 2 से गुणा करने के लिए, यह अजीब अंत नहीं हो रहा है,

263
00:18:49,000 --> 00:18:54,000
0 जगह 2 0 होना चाहिए,

264
00:18:54,000 --> 00:18:59,000
और यह है कि मैं क्या आधे से पहले है के बारे में चेतावनी दी है अगर आप बदलाव के लिए ऐसा करते हैं

265
00:18:59,000 --> 00:19:01,000
एक पूर्णांक में बिट्स की संख्या के परे,

266
00:19:01,000 --> 00:19:04,000
तो यह 1 को समाप्त करने से जा रहा जा रहा है.

267
00:19:04,000 --> 00:19:10,000
यह केवल चिंता है अगर आप वास्तव में बड़ी क्षमता के साथ काम किया हो.

268
00:19:10,000 --> 00:19:15,000
लेकिन उस बिंदु पर है, तो आप चीजों के अरबों के एक सरणी के साथ काम कर रहे हैं,

269
00:19:15,000 --> 00:19:25,000
जो स्मृति में वैसे भी फिट नहीं हो सकता है.

270
00:19:25,000 --> 00:19:31,000
>> अब हम पॉप, जो भी आसान करने के लिए मिल सकता है.

271
00:19:31,000 --> 00:19:36,000
तुम यह कर यदि आप एक पूरी गुच्छा पॉप हो सकता है,

272
00:19:36,000 --> 00:19:38,000
और अब आप आधी क्षमता पर फिर से कर रहे हैं.

273
00:19:38,000 --> 00:19:42,000
आप स्मृति की राशि है जो आप हटना realloc सकता है,

274
00:19:42,000 --> 00:19:47,000
लेकिन आप इस बारे में चिंता करने की ज़रूरत नहीं है, तो केवल realloc मामले होने जा रहा है

275
00:19:47,000 --> 00:19:50,000
स्मृति से बढ़ रही है, सिकुड़ते स्मृति कभी नहीं,

276
00:19:50,000 --> 00:19:59,000
है जो पॉप सुपर आसान बनाने जा रही है.

277
00:19:59,000 --> 00:20:02,000
अब कतार, जो ढेर की तरह होने जा रहे हैं,

278
00:20:02,000 --> 00:20:06,000
लेकिन आदेश है कि तुम चीजें लेने के उलट है.

279
00:20:06,000 --> 00:20:10,000
एक कतार के prototypical उदाहरण के लिए एक लाइन है,

280
00:20:10,000 --> 00:20:12,000
इसलिए मुझे लगता है कि अगर आप अंग्रेजी में थे, मैं ने कहा होगा

281
00:20:12,000 --> 00:20:17,000
एक कतार के एक prototypical उदाहरण एक कतार है.

282
00:20:17,000 --> 00:20:22,000
तो एक लाइन की तरह, यदि आप लाइन में पहले व्यक्ति हैं,

283
00:20:22,000 --> 00:20:24,000
आप लाइन से बाहर 1 व्यक्ति होने की उम्मीद है.

284
00:20:24,000 --> 00:20:31,000
यदि आप लाइन में अंतिम व्यक्ति हो, तुम पिछले सेवित व्यक्ति होने जा रहे हैं.

285
00:20:31,000 --> 00:20:35,000
हम जानते हैं कि फीफो पैटर्न कहते हैं, जबकि ढेर LIFO पैटर्न था.

286
00:20:35,000 --> 00:20:40,000
उन शब्दों को सुंदर सार्वभौमिक हैं.

287
00:20:40,000 --> 00:20:46,000
>> ढेर की तरह और arrays के विपरीत, कतार आमतौर पर बीच में तत्वों के लिए उपयोग नहीं की अनुमति नहीं है.

288
00:20:46,000 --> 00:20:50,000
इधर, एक ढेर, हम धक्का और पॉप है.

289
00:20:50,000 --> 00:20:54,000
यहाँ, हम करने के लिए उन्हें बुलाया enqueue और विपंक्ति होता है.

290
00:20:54,000 --> 00:20:58,000
मैंने यह भी सुना है कि उन्हें पारी और unshift बुलाया.

291
00:20:58,000 --> 00:21:02,000
मैंने सुना है लोग कहते धक्का और पॉप भी कतार को लागू करने के लिए.

292
00:21:02,000 --> 00:21:05,000
मैं सम्मिलित करने के लिए, हटाने के बारे में सुना है,

293
00:21:05,000 --> 00:21:11,000
इतना धक्का और पॉप, अगर आप ढेर के बारे में बात कर रहे हैं, तो आप धक्का और popping रहे हैं.

294
00:21:11,000 --> 00:21:16,000
यदि आप कतार के बारे में बात कर रहे हैं, आप शब्दों आप उपयोग करना चाहते ले सकता है

295
00:21:16,000 --> 00:21:23,000
प्रविष्टि और हटाने के लिए, और क्या यह कहा जाना चाहिए पर कोई आम सहमति नहीं है.

296
00:21:23,000 --> 00:21:27,000
लेकिन यहाँ, हम enqueue और विपंक्ति है.

297
00:21:27,000 --> 00:21:37,000
अब, struct लगभग ढेर struct के समान लग रहा है.

298
00:21:37,000 --> 00:21:40,000
लेकिन हम सिर का ट्रैक रखने के लिए है.

299
00:21:40,000 --> 00:21:44,000
मुझे लगता है कि यह यहाँ नीचे कहते हैं, लेकिन हम सिर की आवश्यकता क्यों है?

300
00:21:53,000 --> 00:21:57,000
प्रोटोटाइप मूल रूप से धक्का और पॉप के लिए समान हैं.

301
00:21:57,000 --> 00:21:59,000
आप इसे धक्का और पॉप के रूप में सोच सकते हैं.

302
00:21:59,000 --> 00:22:08,000
फर्क सिर्फ इतना है पॉप लौटने के बजाय पिछले की है, यह है कि 1 लौटने.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, या कुछ और.

304
00:22:12,000 --> 00:22:14,000
और यहाँ शुरुआत है.

305
00:22:14,000 --> 00:22:17,000
हमारी कतार पूरी तरह से भरा हुआ है, तो वहाँ में यह चार तत्वों है.

306
00:22:17,000 --> 00:22:21,000
हमारी कतार के अंत वर्तमान में 2,

307
00:22:21,000 --> 00:22:24,000
और अब हम कुछ डालने के लिए जाना है.

308
00:22:24,000 --> 00:22:29,000
>> जब हम ढेर संस्करण के लिए है कि कुछ और, हम क्या किया सम्मिलित करना चाहते हैं

309
00:22:29,000 --> 00:22:36,000
हम स्मृति के हमारे ब्लॉक बढ़ाया.

310
00:22:36,000 --> 00:22:40,000
इस के साथ समस्या क्या है?

311
00:22:40,000 --> 00:22:45,000
[छात्र] तुम 2 चाल.

312
00:22:45,000 --> 00:22:51,000
क्या मैं कतार के अंत के बारे में पहले कहा था,

313
00:22:51,000 --> 00:22:57,000
1 पर समझ में आता है कि हम शुरू नहीं कर सकता है,

314
00:22:57,000 --> 00:23:01,000
तो हम 1 विपंक्ति करने के लिए करना चाहते हैं, तो विपंक्ति 3, फिर विपंक्ति 4,

315
00:23:01,000 --> 00:23:05,000
तो विपंक्ति 2, तो यह एक विपंक्ति.

316
00:23:05,000 --> 00:23:08,000
हम realloc अब उपयोग नहीं कर सकते,

317
00:23:08,000 --> 00:23:11,000
या बहुत कम से कम, आप एक अलग तरीके से realloc का उपयोग करने के लिए किया है.

318
00:23:11,000 --> 00:23:15,000
लेकिन तुम शायद सिर्फ realloc का उपयोग नहीं करना चाहिए.

319
00:23:15,000 --> 00:23:18,000
आप स्वयं अपनी स्मृति कॉपी करने के लिए जा रहे हैं.

320
00:23:18,000 --> 00:23:21,000
>> वहाँ दो करने के लिए स्मृति की प्रतिलिपि बनाने के लिए कार्य कर रहे हैं.

321
00:23:21,000 --> 00:23:25,000
वहाँ memcopy और memmove है.

322
00:23:25,000 --> 00:23:29,000
मैं वर्तमान में मैन पेज पढ़ रहा हूँ जो एक को देखने के लिए आप करने के लिए उपयोग करना चाहते हैं के लिए जा रहे हैं.

323
00:23:29,000 --> 00:23:35,000
ठीक है, memcopy, अंतर है

324
00:23:35,000 --> 00:23:38,000
कि memcopy और memmove, एक मामले को सही ढंग से संभालती

325
00:23:38,000 --> 00:23:41,000
जहां आप एक क्षेत्र है कि क्षेत्र ओवरलैप होता है में नकल कर रहे हैं

326
00:23:41,000 --> 00:23:46,000
आप में से नकल कर रहे हैं.

327
00:23:46,000 --> 00:23:50,000
Memcopy इसे संभाल नहीं है. Memmove करता है.

328
00:23:50,000 --> 00:23:59,000
आप के रूप में समस्या के बारे में सोच सकते हैं

329
00:23:59,000 --> 00:24:09,000
हम कहते हैं कि मैं इस आदमी की नकल करना चाहते हैं,

330
00:24:09,000 --> 00:24:13,000
इस पर आदमी के लिए इन चार.

331
00:24:13,000 --> 00:24:16,000
अंत में, सरणी की तरह दिखना चाहिए

332
00:24:16,000 --> 00:24:26,000
बाद प्रतिलिपि 2, 1, 2, 1, 3, 4, और फिर अंत में कुछ सामान है.

333
00:24:26,000 --> 00:24:29,000
लेकिन इस क्रम में हम वास्तव में नकल पर निर्भर है,

334
00:24:29,000 --> 00:24:32,000
क्योंकि अगर हम तथ्य यह है कि हम क्षेत्र में नकल कर रहे हैं पर विचार नहीं करते

335
00:24:32,000 --> 00:24:35,000
overlaps एक हम से नकल कर रहे हैं,

336
00:24:35,000 --> 00:24:46,000
तो हम यहाँ शुरुआत की तरह करते हैं, हो सकता है हम जाना चाहते हैं जगह में 2 की नकल,

337
00:24:46,000 --> 00:24:52,000
तो हमारे संकेत आगे बढ़ना है.

338
00:24:52,000 --> 00:24:56,000
>> अब हम यहाँ और यहाँ होने जा रहे हैं, और अब हम प्रतिलिपि बनाना चाहते हैं

339
00:24:56,000 --> 00:25:04,000
इस आदमी पर इस आदमी और हमारे संकेत आगे बढ़ना है.

340
00:25:04,000 --> 00:25:07,000
हम खत्म हो जा रहे हैं क्या 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
बजाय उपयुक्त 2, 1, 2, 1, 3, 4 क्योंकि

342
00:25:10,000 --> 00:25:15,000
1 2, मूल 3, 4 overrode.

343
00:25:15,000 --> 00:25:19,000
Memmove कि सही ढंग से संभालती है.

344
00:25:19,000 --> 00:25:23,000
इस मामले में, मूल रूप से बस हमेशा memmove का उपयोग

345
00:25:23,000 --> 00:25:26,000
क्योंकि यह सही ढंग से संभालती है.

346
00:25:26,000 --> 00:25:29,000
यह आम तौर पर किसी भी बुरा प्रदर्शन नहीं करता.

347
00:25:29,000 --> 00:25:32,000
विचार शुरू से ही शुरू है और इस तरह की नकल के बजाय है

348
00:25:32,000 --> 00:25:35,000
जैसे हम यहाँ सिर्फ किया है, यह अंत से शुरू होता है और प्रतियां,

349
00:25:35,000 --> 00:25:38,000
और उस मामले में, आप एक समस्या कभी नहीं हो सकता है.

350
00:25:38,000 --> 00:25:40,000
वहाँ कोई प्रदर्शन खो दिया है.

351
00:25:40,000 --> 00:25:47,000
हमेशा memmove का उपयोग करें. चिंता करने की ज़रूरत कभी memcopy के बारे में.

352
00:25:47,000 --> 00:25:51,000
और वह है जहाँ आप करने के लिए अलग से memmove जा रहे हैं

353
00:25:51,000 --> 00:26:01,000
लिपटे के आसपास अपनी कतार का हिस्सा.

354
00:26:01,000 --> 00:26:04,000
कोई चिंता नहीं अगर पूरी तरह से नहीं किया.

355
00:26:04,000 --> 00:26:10,000
इस ढेर, पॉप, और धक्का से और अधिक कठिन है.

356
00:26:10,000 --> 00:26:15,000
>> किसी को भी किसी भी कोड में हम साथ काम कर सकता है?

357
00:26:15,000 --> 00:26:21,000
यहां तक ​​कि पूरी तरह से अधूरा है?

358
00:26:21,000 --> 00:26:23,000
[छात्र] हाँ, यह पूरी तरह से अधूरा है, यद्यपि.

359
00:26:23,000 --> 00:26:27,000
लंबे समय के रूप में पूरी तरह से अधूरा ठीक है के रूप में हम कर सकते हैं आप संशोधन बचा?

360
00:26:27,000 --> 00:26:32,000
मुझे लगता है कि हर एक बार भूल जाते हैं.

361
00:26:32,000 --> 00:26:39,000
ठीक है, क्या की अनदेखी होता है जब हम चीजों को आकार की जरूरत है.

362
00:26:39,000 --> 00:26:42,000
पूरी तरह से का आकार परिवर्तन की उपेक्षा.

363
00:26:42,000 --> 00:26:49,000
इस कोड को समझाओ.

364
00:26:49,000 --> 00:26:54,000
मैं सब से पहले की जाँच कर रहा हूँ अगर आकार सब से पहले कॉपी से कम है

365
00:26:54,000 --> 00:27:01,000
और फिर उसके बाद, मैं डालने मैं + सिर के आकार लेने के लिए,

366
00:27:01,000 --> 00:27:05,000
और मुझे यकीन है कि यह सरणी की क्षमता के आसपास wraps,

367
00:27:05,000 --> 00:27:08,000
और मुझे लगता है कि स्थिति पर नए स्ट्रिंग डालने.

368
00:27:08,000 --> 00:27:12,000
तो मैं आकार बढ़ाने के लिए और वापसी सच.

369
00:27:12,000 --> 00:27:22,000
>> [रोब बी] यह निश्चित रूप से एक उन मामलों में जहां आप आधुनिक का उपयोग किया जाना चाहते करने के लिए जा रहे हैं.

370
00:27:22,000 --> 00:27:25,000
मामले की किसी भी तरह है जहां आप चारों ओर लपेटकर है, अगर आपको लगता है कि चारों ओर लपेटकर,

371
00:27:25,000 --> 00:27:29,000
तत्काल सोचा आधुनिक होना चाहिए.

372
00:27:29,000 --> 00:27:36,000
/ एक त्वरित अनुकूलन के रूप में अपने कोड एक लाइन कम करने,

373
00:27:36,000 --> 00:27:42,000
तुम नोटिस कि लाइन तुरंत एक के बाद इस

374
00:27:42,000 --> 00:27:53,000
सिर्फ आकार है + +, तो आप मर्ज है कि इस लाइन में, आकार + +.

375
00:27:53,000 --> 00:27:58,000
अब यहाँ नीचे, हम मामला है

376
00:27:58,000 --> 00:28:01,000
जहाँ हम पर्याप्त स्मृति नहीं है,

377
00:28:01,000 --> 00:28:05,000
इसलिए हम 2 से हमारी क्षमता में वृद्धि कर रहे हैं.

378
00:28:05,000 --> 00:28:09,000
मुझे लगता है कि आप यहाँ एक ही समस्या हो सकता है, लेकिन अब हम इसे अनदेखा कर सकते हैं,

379
00:28:09,000 --> 00:28:13,000
जहां अगर आप अपनी क्षमता में वृद्धि करने में विफल रहा है,

380
00:28:13,000 --> 00:28:18,000
तो आप करने के लिए 2 से अपनी क्षमता को फिर से कम करना चाहते करने के लिए जा रहे हैं.

381
00:28:18,000 --> 00:28:24,000
एक अन्य छोटे नोट है बस आप की तरह कर सकते हैं + =

382
00:28:24,000 --> 00:28:30,000
आप भी कर सकते हैं << =.

383
00:28:30,000 --> 00:28:43,000
लगभग कुछ भी करने से पहले के बराबर होती जा सकते हैं, + = | = & =, << =.

384
00:28:43,000 --> 00:28:52,000
चार * नई हमारी स्मृति के नए ब्लॉक है.

385
00:28:52,000 --> 00:28:55,000
ओह, यहाँ.

386
00:28:55,000 --> 00:29:02,000
>> लोग हमारी स्मृति के नए ब्लॉक के प्रकार के बारे में क्या लगता है?

387
00:29:02,000 --> 00:29:06,000
[छात्र] यह चार ** होना चाहिए.

388
00:29:06,000 --> 00:29:12,000
हमारे struct वापस यहाँ सोच,

389
00:29:12,000 --> 00:29:14,000
तार हम क्या reallocating रहे हैं.

390
00:29:14,000 --> 00:29:21,000
हम कतार में तत्वों के लिए एक पूरी नई गतिशील भंडारण कर रहे हैं.

391
00:29:21,000 --> 00:29:25,000
हम अपने तार को बताए जा रहे हैं कि हम क्या सही अब mallocing रहे हैं,

392
00:29:25,000 --> 00:29:30,000
और इसलिए नए char ** होने जा रहा है.

393
00:29:30,000 --> 00:29:34,000
यह तारों की एक सरणी होने जा रहा है.

394
00:29:34,000 --> 00:29:38,000
फिर मामला है जिसके तहत हम वापसी झूठी जा रहे हैं क्या है?

395
00:29:38,000 --> 00:29:41,000
[छात्र] हम चार * कर किया जाना चाहिए?

396
00:29:41,000 --> 00:29:44,000
[रोब बी] हाँ, अच्छा फोन है.

397
00:29:44,000 --> 00:29:46,000
[छात्र] क्या था?

398
00:29:46,000 --> 00:29:49,000
[रोब बी] हम चार * के आकार करना चाहता था क्योंकि हम नहीं कर रहे हैं अब

399
00:29:49,000 --> 00:29:53,000
यह वास्तव में एक बहुत बड़ी समस्या हो सकता है क्योंकि sizeof (चार) 1 होगा.

400
00:29:53,000 --> 00:29:55,000
Sizeof चार * 4 होने जा रहा है,

401
00:29:55,000 --> 00:29:58,000
तो बार जब आप ints के साथ काम कर रहे हैं की एक बहुत कुछ है,

402
00:29:58,000 --> 00:30:01,000
आप इसे दूर के साथ मिल जाते हैं क्योंकि int और int * के आकार के आकार

403
00:30:01,000 --> 00:30:04,000
एक 32-bit प्रणाली पर एक ही बात हो जा रहे हैं.

404
00:30:04,000 --> 00:30:09,000
लेकिन यहाँ, sizeof (चार) और sizeof (चार *) अब एक ही बात हो जा रहे हैं.

405
00:30:09,000 --> 00:30:15,000
>> परिस्थिति जहाँ हम वापसी झूठी क्या है?

406
00:30:15,000 --> 00:30:17,000
[छात्र] नई रिक्त है.

407
00:30:17,000 --> 00:30:23,000
हाँ, अगर नई अशक्त है, हम वापसी झूठी,

408
00:30:23,000 --> 00:30:34,000
और मैं नीचे फेंक यहाँ जा रहा हूँ

409
00:30:34,000 --> 00:30:37,000
[छात्र] [अश्राव्य]

410
00:30:37,000 --> 00:30:39,000
[रोब बी] हाँ, यह ठीक है.

411
00:30:39,000 --> 00:30:46,000
आप या तो 2 बार क्षमता या क्षमता 1 बदलाव तो और केवल इसे नीचे सेट यहाँ या जो कुछ भी कर सकता है.

412
00:30:46,000 --> 00:30:52,000
हम यह कर के रूप में हम यह था.

413
00:30:52,000 --> 00:30:56,000
>> = 1 क्षमता.

414
00:30:56,000 --> 00:31:08,000
और आप 1 की जगह को खोने के बारे में चिंता करने की ज़रूरत कभी नहीं जा रहे हैं

415
00:31:08,000 --> 00:31:12,000
क्योंकि तुम्हें छोड़ दिया है 1 से स्थानांतरित कर दिया है, तो 1 के स्थान जरूरी 0 है,

416
00:31:12,000 --> 00:31:16,000
तो सही 1 से बदलता है, तो आप अभी भी ठीक हो जा रहे हैं.

417
00:31:16,000 --> 00:31:19,000
[छात्र] क्या आप के लिए लौटने से पहले ऐसा करने की जरूरत है?

418
00:31:19,000 --> 00:31:29,000
[रोब बी] हाँ, यह बिल्कुल नहीं समझ में आता है.

419
00:31:29,000 --> 00:31:36,000
>> अब लगता है हम अंत में समाप्त करने के लिए सच लौटने के लिए जा रहे हैं.

420
00:31:36,000 --> 00:31:39,000
जिस तरह से हम इन memmoves करने जा रहे हैं,

421
00:31:39,000 --> 00:31:45,000
हम हम उन्हें कैसे करना है के साथ सावधान रहने की जरूरत है.

422
00:31:45,000 --> 00:31:50,000
क्या किसी के लिए किसी भी सुझाव है कि हम उन्हें कैसे करना है?

423
00:32:17,000 --> 00:32:21,000
यहाँ हमारी शुरुआत है.

424
00:32:21,000 --> 00:32:28,000
अनिवार्य रूप से, हम शुरुआत में फिर से शुरू करना चाहते हैं

425
00:32:28,000 --> 00:32:35,000
कॉपी और वहाँ से बातें, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
आपको लगता है कि कैसे करते हो?

427
00:32:41,000 --> 00:32:52,000
सबसे पहले, मैं memmove के लिए आदमी पृष्ठ पर फिर से देखने के लिए है.

428
00:32:52,000 --> 00:32:57,000
Memmove, तर्कों के आदेश हमेशा महत्वपूर्ण है.

429
00:32:57,000 --> 00:33:01,000
हम अपने गंतव्य पहले चाहते हैं, स्रोत 2, 3 आकार.

430
00:33:01,000 --> 00:33:06,000
कार्य करता है जो स्रोत और गंतव्य रिवर्स एक बहुत कुछ कर रहे हैं.

431
00:33:06,000 --> 00:33:11,000
गंतव्य स्रोत, करने के लिए लगातार कुछ हो जाता है.

432
00:33:17,000 --> 00:33:21,000
हटो, यह क्या लौट रहा है?

433
00:33:21,000 --> 00:33:27,000
यह गंतव्य के लिए जो भी कारण तुम चाहते हो सकता है कि के लिए एक सूचक देता है.

434
00:33:27,000 --> 00:33:32,000
मैं तस्वीर इसे पढ़ने के कर सकते हैं, लेकिन हम अपने गंतव्य में स्थानांतरित करना चाहते हैं.

435
00:33:32,000 --> 00:33:35,000
>> हमारी मंजिल क्या करने जा रहे हो?

436
00:33:35,000 --> 00:33:37,000
[छात्र] नई.

437
00:33:37,000 --> 00:33:39,000
[रोब बी] हाँ, और जहां हम से नकल कर रहे हैं?

438
00:33:39,000 --> 00:33:43,000
हम नकल कर रहे हैं कि पहली बात यह 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
क्या इस 1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
1 इस का पता क्या है?

441
00:33:55,000 --> 00:33:58,000
कि 1 का पता क्या है?

442
00:33:58,000 --> 00:34:01,000
[छात्र] [अश्राव्य]

443
00:34:01,000 --> 00:34:03,000
[रोब बी] प्रधान + 1 तत्व का पता.

444
00:34:03,000 --> 00:34:05,000
हम सरणी में पहली तत्व कैसे मिलता है?

445
00:34:05,000 --> 00:34:10,000
[छात्र] कतार.

446
00:34:10,000 --> 00:34:15,000
[रोब बी] हाँ q.strings,.

447
00:34:15,000 --> 00:34:20,000
याद रखें, यहाँ, हमारे सिर 1 है.

448
00:34:20,000 --> 00:34:24,000
यह झकना. मैं तो बस लगता है कि यह जादुई

449
00:34:24,000 --> 00:34:29,000
यहाँ हमारे सिर 1 है. मैं मेरे रंग भी बदलने जा रहा हूँ.

450
00:34:29,000 --> 00:34:36,000
और यहाँ तार है.

451
00:34:36,000 --> 00:34:41,000
यह, हम या तो इसे लिखने के रूप में हम यहाँ पर किया जा सकता

452
00:34:41,000 --> 00:34:43,000
+ के साथ सिर q.strings.

453
00:34:43,000 --> 00:34:51,000
लोगों का एक बहुत यह भी लिखने और q.strings [सिर].

454
00:34:51,000 --> 00:34:55,000
यह वास्तव में किसी भी कम कुशल नहीं है.

455
00:34:55,000 --> 00:34:58,000
आप यह सोचने के रूप में आप इसे dereferencing कर रहे हैं तो और पता हो रही हो सकता है,

456
00:34:58,000 --> 00:35:04,000
लेकिन संकलक यह हम पहले क्या था अनुवाद के लिए जा रहा है, वैसे भी, q.strings सिर +.

457
00:35:04,000 --> 00:35:06,000
किसी भी तरह से आप यह सोचने के लिए करना चाहते हैं.

458
00:35:06,000 --> 00:35:11,000
>> और हम कितने बाइट्स की प्रतिलिपि करने के लिए चाहते हो?

459
00:35:11,000 --> 00:35:15,000
[छात्र] क्षमता - सिर.

460
00:35:15,000 --> 00:35:18,000
क्षमता - सिर.

461
00:35:18,000 --> 00:35:21,000
और तो आप हमेशा एक उदाहरण लिख सकता है

462
00:35:21,000 --> 00:35:23,000
पता लगाने की है कि अगर सही है.

463
00:35:23,000 --> 00:35:26,000
[छात्र] यह तो 2 से विभाजित किया जा जरूरत है.

464
00:35:26,000 --> 00:35:30,000
हाँ, तो मुझे लगता है कि हम आकार का उपयोग कर सकते हैं.

465
00:35:30,000 --> 00:35:35,000
हम अभी भी आकार से किया जा रहा है

466
00:35:35,000 --> 00:35:39,000
आकार का उपयोग करते हुए, हम 4 के बराबर आकार है.

467
00:35:39,000 --> 00:35:42,000
हमारे आकार 4 है. हमारे प्रधान 1 है.

468
00:35:42,000 --> 00:35:46,000
हम इन 3 तत्वों की नकल करना चाहते हैं.

469
00:35:46,000 --> 00:35:54,000
यही कारण है कि विवेक कि आकार की जाँच - सिर में सही ढंग से 3 है.

470
00:35:54,000 --> 00:35:58,000
और यहाँ वापस आ रहा है, जैसे कि हम पहले कहा,

471
00:35:58,000 --> 00:36:00,000
अगर हम क्षमता का इस्तेमाल किया है, तो हम 2 से विभाजित करना चाहते हैं

472
00:36:00,000 --> 00:36:04,000
क्योंकि हम पहले से ही हमारी क्षमता हो गई है, तो इसके बजाय, हम आकार का उपयोग करने जा रहे हैं.

473
00:36:11,000 --> 00:36:13,000
यह उस हिस्से प्रतियां.

474
00:36:13,000 --> 00:36:18,000
अब, हम अन्य भाग, भाग है कि शुरू से छोड़ दिया है को कॉपी करने की जरूरत है.

475
00:36:18,000 --> 00:36:28,000
>> कि क्या स्थिति में memmove हो रहा है?

476
00:36:28,000 --> 00:36:32,000
[छात्र] प्लस आकार के सिर.

477
00:36:32,000 --> 00:36:38,000
हाँ, तो हम पहले से ही आकार में नकल की है - सिर बाइट्स,

478
00:36:38,000 --> 00:36:43,000
और इसलिए जहाँ हम शेष बाइट्स की नकल करना चाहते हैं नया है

479
00:36:43,000 --> 00:36:48,000
और फिर आकार ऋण अच्छी तरह से, बाइट्स की संख्या हम पहले से ही अंदर की नकल की है

480
00:36:48,000 --> 00:36:52,000
और फिर हम कहाँ से नकल कर रहे हैं?

481
00:36:52,000 --> 00:36:54,000
[छात्र] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[रोब बी] हाँ q.strings,.

483
00:36:56,000 --> 00:37:02,000
हम भी करते हैं और q.strings [0]

484
00:37:02,000 --> 00:37:05,000
यह काफी कम है इस की तुलना में आम है.

485
00:37:05,000 --> 00:37:14,000
अगर यह सिर्फ 0 होने जा रहा है, तो आप को q.strings देखते हैं.

486
00:37:14,000 --> 00:37:16,000
यही कारण है कि हम कहाँ से नकल कर रहे हैं.

487
00:37:16,000 --> 00:37:18,000
हम कितने बाइट की प्रतिलिपि करने के लिए छोड़ दिया है? >> 10 [छात्र].

488
00:37:18,000 --> 00:37:20,000
सही है.

489
00:37:20,000 --> 00:37:25,000
[छात्र] हम 5 गुणा है - 10 बार के आकार बाइट या कुछ और?

490
00:37:25,000 --> 00:37:30,000
हाँ, तो यह वह जगह है जहाँ क्या वास्तव में हम नकल कर रहे हैं?

491
00:37:30,000 --> 00:37:32,000
[छात्र] [अश्राव्य]

492
00:37:32,000 --> 00:37:34,000
बात हम नकल कर रहे हैं के प्रकार क्या है?

493
00:37:34,000 --> 00:37:36,000
[छात्र] [अश्राव्य]

494
00:37:36,000 --> 00:37:41,000
हाँ, चार * कि हम नकल कर रहे हैं, तो हम उन जहां से आ रहे हैं पता नहीं है.

495
00:37:41,000 --> 00:37:47,000
खैर, जहां वे इशारा कर रहे हैं, तार की तरह, हम अंत में यह कतार पर धक्का

496
00:37:47,000 --> 00:37:49,000
या पंक्ति पर enqueuing.

497
00:37:49,000 --> 00:37:51,000
उन कहाँ से आ रहे हैं, हमें पता नहीं है.

498
00:37:51,000 --> 00:37:56,000
हम सिर्फ चार * खुद का ट्रैक रखने की जरूरत है.

499
00:37:56,000 --> 00:38:00,000
सिर बाइट्स - हम करने के लिए आकार की नकल नहीं करना चाहती.

500
00:38:00,000 --> 00:38:03,000
सिर चार *, हम आकार की प्रतिलिपि बनाना चाहते हैं

501
00:38:03,000 --> 00:38:11,000
तो हम sizeof (चार *) द्वारा इस गुणा करने के लिए जा रहे हैं.

502
00:38:11,000 --> 00:38:17,000
वही यहाँ नीचे, सिर * sizeof (char *).

503
00:38:17,000 --> 00:38:24,000
>> [छात्र] के बारे में क्या [अश्राव्य?]

504
00:38:24,000 --> 00:38:26,000
यहाँ यह सही है?

505
00:38:26,000 --> 00:38:28,000
[छात्र] नहीं, कि नीचे, आकार - सिर.

506
00:38:28,000 --> 00:38:30,000
यहाँ यह सही [रोब बी]?

507
00:38:30,000 --> 00:38:32,000
सूचक गणित.

508
00:38:32,000 --> 00:38:35,000
कैसे सूचक गणित के लिए काम चल रहा है

509
00:38:35,000 --> 00:38:40,000
यह स्वतः ही प्रकार है कि हम साथ काम कर रहे हैं के आकार के आधार पर पलता है.

510
00:38:40,000 --> 00:38:46,000
बस यहाँ पर करना चाहते हैं, नया + (आकार - सिर)

511
00:38:46,000 --> 00:38:56,000
वास्तव में और नए - सिर के आकार] के बराबर है

512
00:38:56,000 --> 00:39:00,000
जब तक हम है कि सही ढंग से काम करने के लिए उम्मीद है,

513
00:39:00,000 --> 00:39:04,000
क्योंकि अगर हम एक int सरणी के साथ काम कर रहे हैं, तो हम int द्वारा सूचकांक नहीं करते

514
00:39:04,000 --> 00:39:07,000
या अगर यह 5 के आकार का है और आप 4 तत्व चाहते हैं, तो हम में सूचकांक

515
00:39:07,000 --> 00:39:10,000
int सरणी [4].

516
00:39:10,000 --> 00:39:14,000
आप नहींं [4] * int के आकार.

517
00:39:14,000 --> 00:39:21,000
कि यह स्वतः ही संभालती है, और इस मामले

518
00:39:21,000 --> 00:39:29,000
सचमुच बराबर है तो, ब्रैकेट वाक्यविन्यास

519
00:39:29,000 --> 00:39:34,000
सिर्फ यह करने के लिए जैसे ही आप संकलन परिवर्तित किया जा जा रहा है.

520
00:39:34,000 --> 00:39:38,000
कि कुछ आप कि के सावधान होने की जरूरत है

521
00:39:38,000 --> 00:39:42,000
जब आप आकार जोड़ रहे हैं - सिर

522
00:39:42,000 --> 00:39:45,000
तुम नहीं एक बाइट जोड़ रहे हैं.

523
00:39:45,000 --> 00:39:53,000
आप एक चार * जोड़ रहे हैं, जो एक बाइट या जो कुछ भी हो सकता है.

524
00:39:53,000 --> 00:39:56,000
>> अन्य प्रश्न?

525
00:39:56,000 --> 00:40:04,000
ठीक है, विपंक्ति के लिए आसान होने जा रहा है.

526
00:40:04,000 --> 00:40:11,000
मैं आप एक मिनट के लागू करने के लिए दे देंगे.

527
00:40:11,000 --> 00:40:18,000
ओह, और मुझे लगता है कि यह एक ही स्थिति है, जहां

528
00:40:18,000 --> 00:40:21,000
क्या enqueue मामले, अगर हम बातिल enqueuing रहे हैं,

529
00:40:21,000 --> 00:40:24,000
शायद हम इसे संभाल करने के लिए करना चाहते हैं, शायद हम नहीं करते.

530
00:40:24,000 --> 00:40:27,000
हम इसे फिर से नहीं करना यहाँ होगा, लेकिन हमारे ढेर मामले के रूप में एक ही है.

531
00:40:27,000 --> 00:40:34,000
यदि हम अशक्त enqueue, हम इसे उपेक्षा करना चाहते हो सकता है.

532
00:40:34,000 --> 00:40:40,000
किसी को कुछ कोड मैं खींच सकते हैं?

533
00:40:40,000 --> 00:40:45,000
[छात्र] मैं सिर्फ विपंक्ति है.

534
00:40:45,000 --> 00:40:56,000
2 संस्करण है कि ठीक है.

535
00:40:56,000 --> 00:40:59,000
आप को समझाना चाहता हूँ?

536
00:40:59,000 --> 00:41:01,000
[छात्र] सबसे पहले, आप सुनिश्चित करें कि वहाँ कतार में कुछ है

537
00:41:01,000 --> 00:41:07,000
और कि आकार 1 से नीचे जा रहा है.

538
00:41:07,000 --> 00:41:11,000
तुम क्या करने की जरूरत है, और फिर आप सिर वापस

539
00:41:11,000 --> 00:41:13,000
और फिर 1 सिर के ऊपर ले जाने के.

540
00:41:13,000 --> 00:41:19,000
ठीक है, तो वहाँ एक कोने मामले में हम पर विचार करने के लिए है. हाँ.

541
00:41:19,000 --> 00:41:24,000
[छात्र] यदि पिछले तत्व अपने सिर पर है,

542
00:41:24,000 --> 00:41:26,000
तो आप सिर सरणी के बाहर बात करने के लिए नहीं करना चाहती.

543
00:41:26,000 --> 00:41:29,000
>> हाँ, तो सिर के रूप में जल्द से जल्द हमारी सरणी के अंत हिट,

544
00:41:29,000 --> 00:41:35,000
जब हम विपंक्ति, हमारे सिर 0 वापस modded चाहिए.

545
00:41:35,000 --> 00:41:40,000
दुर्भाग्य से, हम है कि एक चरण में नहीं कर सकते हैं.

546
00:41:40,000 --> 00:41:44,000
मुझे लगता है कि जिस तरह से मैं शायद यह तय है

547
00:41:44,000 --> 00:41:52,000
यह करने के लिए एक चार * होने जा रहा है, हम क्या लौट रहे हैं,

548
00:41:52,000 --> 00:41:55,000
जो कुछ भी अपने चर नाम होना चाहता है.

549
00:41:55,000 --> 00:42:02,000
तो फिर हम हमारी क्षमता से सिर आधुनिक चाहते

550
00:42:02,000 --> 00:42:10,000
और फिर लौटने के भिगोरना.

551
00:42:10,000 --> 00:42:14,000
लोगों का एक बहुत यहाँ वे कर सकता है

552
00:42:14,000 --> 00:42:19,000
यह you'll के मामले देखने के लिए लोग करते हैं अगर सिर

553
00:42:19,000 --> 00:42:29,000
क्षमता से अधिक है, सिर - क्षमता.

554
00:42:29,000 --> 00:42:36,000
और कहा कि सिर्फ आधुनिक क्या है के आसपास काम कर रहा है.

555
00:42:36,000 --> 00:42:41,000
प्रमुख आधुनिक = क्षमता बहुत क्लीनर है

556
00:42:41,000 --> 00:42:51,000
क्षमता है. अगर सिर क्षमता सिर से अधिक की तुलना में लगभग एक रैपिंग

557
00:42:51,000 --> 00:42:56,000
>> प्रश्न?

558
00:42:56,000 --> 00:43:02,000
ठीक है, आखिरी बात हम छोड़ दिया है हमारे लिंक सूची है.

559
00:43:02,000 --> 00:43:07,000
आप लिंक सूची व्यवहार के कुछ करने के लिए इस्तेमाल किया जा सकता है अगर तुम नहीं किया

560
00:43:07,000 --> 00:43:11,000
अपने हैश तालिका में सूची जुड़ा है, अगर आप एक हैश तालिका किया.

561
00:43:11,000 --> 00:43:15,000
मैं दृढ़ता से एक हैश तालिका करने की सलाह देते हैं.

562
00:43:15,000 --> 00:43:17,000
आप पहले से ही एक trie किया हो सकता है,

563
00:43:17,000 --> 00:43:23,000
लेकिन कोशिश करता है और अधिक कठिन हैं.

564
00:43:23,000 --> 00:43:27,000
सिद्धांत रूप में, वे asymptotically बेहतर कर रहे हैं.

565
00:43:27,000 --> 00:43:30,000
लेकिन सिर्फ बड़े बोर्ड पर देखो,

566
00:43:30,000 --> 00:43:35,000
की कोशिश करता है और बेहतर कभी नहीं, और वे और अधिक स्मृति ले.

567
00:43:35,000 --> 00:43:43,000
सब कुछ के बारे में बदतर और अधिक काम करने के लिए किया जा रहा समाप्त होता है की कोशिश करता है.

568
00:43:43,000 --> 00:43:49,000
यह डेविड Malan समाधान हमेशा क्या है

569
00:43:49,000 --> 00:43:56,000
वह हमेशा अपने trie समाधान पदों, और देखते हैं जहां वह वर्तमान में है.

570
00:43:56,000 --> 00:44:00,000
वह क्या के तहत किया गया था, डेविड जे?

571
00:44:00,000 --> 00:44:06,000
वह # 18 है, इसलिए, कि बहुत बुरा नहीं है,

572
00:44:06,000 --> 00:44:09,000
और कि सर्वश्रेष्ठ में से एक होने जा रहा है आप के बारे में सोच सकते हैं की कोशिश करता है

573
00:44:09,000 --> 00:44:17,000
या एक सर्वश्रेष्ठ में से एक trie की कोशिश करता है.

574
00:44:17,000 --> 00:44:23,000
यह अपने मूल समाधान भी नहीं है?

575
00:44:23,000 --> 00:44:29,000
मुझे लगता है कि trie समाधान करने के लिए राम के उपयोग की इस श्रेणी में अधिक हो जाते हैं.

576
00:44:29,000 --> 00:44:33,000
>> बहुत ऊपर नीचे जाओ, और राम उपयोग एकल अंक में है.

577
00:44:33,000 --> 00:44:36,000
नीचे की ओर नीचे जाओ, और फिर आप देख कोशिश करता है शुरू

578
00:44:36,000 --> 00:44:41,000
, जहाँ आप बिल्कुल विशाल रैम उपयोग हो

579
00:44:41,000 --> 00:44:45,000
और कोशिश करता है और अधिक कठिन हैं.

580
00:44:45,000 --> 00:44:53,000
लेकिन यह एक शैक्षिक अनुभव के लायक पूरी तरह से अगर आप एक किया.

581
00:44:53,000 --> 00:44:56,000
आखिरी बात हमारे लिंक सूची है,

582
00:44:56,000 --> 00:45:04,000
और इन तीन बातें, ढेर, कतार, और लिंक सूचियों,

583
00:45:04,000 --> 00:45:09,000
भविष्य में किसी भी बात आप कभी कंप्यूटर विज्ञान में है

584
00:45:09,000 --> 00:45:12,000
आप इन सब बातों के साथ परिचित है मान जाएगा.

585
00:45:12,000 --> 00:45:19,000
वे सिर्फ इतना सब कुछ करने के लिए मौलिक हैं.

586
00:45:19,000 --> 00:45:25,000
>> सूचियों लिंक, और यहाँ हम एक अकेले लिंक सूची हमारे कार्यान्वयन किया जा रहा है.

587
00:45:25,000 --> 00:45:34,000
क्या अकेले जुड़ा हुआ करता है मतलब है रूप में दोगुना जुड़ा हुआ विरोध? हां.

588
00:45:34,000 --> 00:45:37,000
[छात्र] यह अगले सूचक के बजाय संकेत करने के लिए कहते हैं,

589
00:45:37,000 --> 00:45:39,000
यह पूर्ववर्ती और इसके बाद एक एक की तरह.

590
00:45:39,000 --> 00:45:44,000
हाँ, तो चित्र प्रारूप में, मैं अभी क्या क्या किया?

591
00:45:44,000 --> 00:45:48,000
मैं दो बातें हैं. मैं चित्र और तस्वीर है.

592
00:45:48,000 --> 00:45:51,000
चित्र प्रारूप में, हमारे अकेले जुडी हुई सूचियों,

593
00:45:51,000 --> 00:45:57,000
अनिवार्य रूप से, हम हमारी सूची के सिर के सूचक का किसी तरह का है,

594
00:45:57,000 --> 00:46:02,000
और फिर हमारी सूची के भीतर, हम सिर्फ संकेत है,

595
00:46:02,000 --> 00:46:05,000
और शायद इस अंक को अशक्त करने के लिए.

596
00:46:05,000 --> 00:46:08,000
यह एक अकेले लिंक सूची के अपने ठेठ ड्राइंग होने जा रहा है.

597
00:46:08,000 --> 00:46:14,000
युग्मबंधित सूची, आप पीछे की ओर जा सकते हैं.

598
00:46:14,000 --> 00:46:19,000
अगर मैं तुम्हें सूची में किसी भी नोड दे, तो आप जरूरी प्राप्त कर सकते हैं

599
00:46:19,000 --> 00:46:23,000
किसी भी अन्य नोड सूची में अगर यह एक युग्मबंधित सूची है.

600
00:46:23,000 --> 00:46:27,000
लेकिन अगर मैं आप इस सूची में तीसरे नोड मिलता है और यह एक अकेले लिंक सूची है,

601
00:46:27,000 --> 00:46:30,000
कोई रास्ता नहीं है कि आप कभी भी 1 और 2 नोड्स के लिए ले जा रहे हैं.

602
00:46:30,000 --> 00:46:34,000
और वहाँ लाभ और detriments, और एक स्पष्ट एक है

603
00:46:34,000 --> 00:46:42,000
आप अधिक आकार लेने के लिए, और आप लिए जहां अब इन बातों से इशारा कर रहे हैं का ट्रैक रखने के लिए है.

604
00:46:42,000 --> 00:46:49,000
लेकिन हम केवल परवाह के बारे में अकेले जुड़ा हुआ है.

605
00:46:49,000 --> 00:46:53,000
>> कुछ बातें हम को लागू करने के लिए जा रहे हैं.

606
00:46:53,000 --> 00:47:00,000
आपकी typedef struct नोड, int i: struct नोड * अगले; नोड.

607
00:47:00,000 --> 00:47:09,000
अपने मन में यही typedef जला दिया जाना चाहिए.

608
00:47:09,000 --> 00:47:14,000
प्रश्नोत्तरी 1 एक लिंक सूची नोड के एक typedef दे की तरह होना चाहिए,

609
00:47:14,000 --> 00:47:18,000
और आप तुरंत कि नीचे घसीटना के लिए सक्षम होना चाहिए

610
00:47:18,000 --> 00:47:22,000
बिना भी इसके बारे में सोच रही है.

611
00:47:22,000 --> 00:47:27,000
मैं कुछ सवाल लगता है, हम यहाँ struct आवश्यकता क्यों है?

612
00:47:27,000 --> 00:47:32,000
हम नोड * कहते हैं क्यों नहीं कर सकते?

613
00:47:32,000 --> 00:47:35,000
[छात्र] [अश्राव्य]

614
00:47:35,000 --> 00:47:38,000
हाँ.

615
00:47:38,000 --> 00:47:44,000
केवल एक चीज है कि एक बात एक नोड के रूप में परिभाषित करता है

616
00:47:44,000 --> 00:47:47,000
ही typedef है.

617
00:47:47,000 --> 00:47:55,000
लेकिन इस बिंदु के रूप में, जब हम इस struct नोड परिभाषा के माध्यम से पार्सिंग के तरह कर रहे हैं

618
00:47:55,000 --> 00:48:01,000
हम अभी तक हमारे typedef नहीं समाप्त कर दिया है, के बाद से तो typedef समाप्त नहीं हुआ है,

619
00:48:01,000 --> 00:48:05,000
नोड मौजूद नहीं है.

620
00:48:05,000 --> 00:48:12,000
लेकिन struct नोड करता है, और यहाँ में, इस नोड

621
00:48:12,000 --> 00:48:14,000
यह भी कुछ और कहा जा सकता है.

622
00:48:14,000 --> 00:48:16,000
यह n बुलाया जा सकता है.

623
00:48:16,000 --> 00:48:19,000
यह लिंक्ड सूची नोड कहा जा सकता है.

624
00:48:19,000 --> 00:48:21,000
यह कुछ भी कहा जा सकता है.

625
00:48:21,000 --> 00:48:26,000
लेकिन इस struct नोड इस struct नोड के रूप में एक ही बात कहा जा जरूरत है.

626
00:48:26,000 --> 00:48:29,000
, आप क्या कहते हैं यह भी यहाँ है

627
00:48:29,000 --> 00:48:32,000
और इसलिए भी है कि प्रश्न के दूसरे बिंदु का जवाब

628
00:48:32,000 --> 00:48:37,000
जो कारण है कि एक बार जब आप structs और structs की typedefs देखते हैं बहुत,

629
00:48:37,000 --> 00:48:42,000
आप गुमनाम structs देख जहाँ आप सिर्फ typedef struct देखेंगे,

630
00:48:42,000 --> 00:48:47,000
struct, शब्दकोश, या जो कुछ भी के कार्यान्वयन.

631
00:48:47,000 --> 00:48:51,000
>> यहाँ क्यों हम को नोड कहने की क्या ज़रूरत है?

632
00:48:51,000 --> 00:48:54,000
यह एक गुमनाम struct क्यों नहीं हो सकता?

633
00:48:54,000 --> 00:48:56,000
यह लगभग एक ही जवाब है.

634
00:48:56,000 --> 00:48:58,000
[छात्र] आप struct भीतर यह उल्लेख करने की जरूरत है.

635
00:48:58,000 --> 00:49:04,000
हाँ, संरचना के भीतर, आप struct ही उल्लेख करने की आवश्यकता है.

636
00:49:04,000 --> 00:49:10,000
यदि आप struct एक नाम देना नहीं है, अगर यह एक गुमनाम struct है, आप इसे करने के लिए नहीं उल्लेख कर सकते हैं.

637
00:49:10,000 --> 00:49:17,000
और पिछले लेकिन इन सब किया जाना चाहिए कम से कम कुछ हद तक सरल नहीं है,

638
00:49:17,000 --> 00:49:20,000
और वे तुम्हें एहसास मदद से यदि आप इस नीचे लिख रहे हैं चाहिए

639
00:49:20,000 --> 00:49:24,000
कि आप कुछ गलत कर रहे हैं, अगर इन चीजों की तरह से कोई मतलब नहीं है.

640
00:49:24,000 --> 00:49:28,000
पिछले नहीं बल्कि कम से कम, क्यों इस struct नोड * है?

641
00:49:28,000 --> 00:49:34,000
क्यों यह सिर्फ नोड नहीं struct किया जा सकता है?

642
00:49:34,000 --> 00:49:37,000
[छात्र] अगले struct सूचक.

643
00:49:37,000 --> 00:49:39,000
यह अनिवार्य रूप से है कि हम क्या चाहते हैं.

644
00:49:39,000 --> 00:49:42,000
यह क्यों struct अगले नोड कभी नहीं हो सकता है?

645
00:49:42,000 --> 00:49:50,000
यह struct * अगले नोड क्यों है? हाँ.

646
00:49:50,000 --> 00:49:53,000
[छात्र] यह एक अनंत लूप की तरह है.

647
00:49:53,000 --> 00:49:55,000
हाँ.

648
00:49:55,000 --> 00:49:57,000
[छात्र] यह सब एक में होगा.

649
00:49:57,000 --> 00:50:02,000
हाँ, बस के बारे में सोच कैसे हम आकार या कुछ करना होगा.

650
00:50:02,000 --> 00:50:08,000
एक struct का आकार मूलतः + या - कुछ यहाँ या वहाँ पैटर्न.

651
00:50:08,000 --> 00:50:15,000
यह मूल रूप से struct में चीजों के आकार का योग होने जा रहा है.

652
00:50:15,000 --> 00:50:18,000
यहाँ यह सही है, कुछ भी बदलने के बिना, आकार आसान होने जा रहा है.

653
00:50:18,000 --> 00:50:24,000
Struct नोड के आकार के लिए मैं अगले + आकार के आकार का होने जा रहा है.

654
00:50:24,000 --> 00:50:27,000
मैं का आकार 4 होने जा रहा है. अगले का आकार 4 होने जा रहा है.

655
00:50:27,000 --> 00:50:30,000
Struct नोड का आकार 8 होने जा रहा है.

656
00:50:30,000 --> 00:50:34,000
यदि हम * नहीं है, के बारे में सोच sizeof,

657
00:50:34,000 --> 00:50:37,000
तो sizeof (i) 4 होने जा रहा है.

658
00:50:37,000 --> 00:50:43,000
Struct नोड का आकार अगले मैं के आकार + struct अगले नोड के आकार होने जा रहा है

659
00:50:43,000 --> 00:50:46,000
मैं struct अगले नोड के आकार के आकार.

660
00:50:46,000 --> 00:50:55,000
यह नोड्स के एक अनंत recursion होगा.

661
00:50:55,000 --> 00:51:00,000
यही कारण है कि यह है कि कैसे चीजें होने.

662
00:51:00,000 --> 00:51:03,000
>> फिर, निश्चित रूप से है कि याद है,

663
00:51:03,000 --> 00:51:06,000
या कम से कम यह पर्याप्त समझते हैं कि आप करने में सक्षम हो सकता है

664
00:51:06,000 --> 00:51:12,000
यह कैसा दिखना चाहिए के माध्यम से कारण.

665
00:51:12,000 --> 00:51:14,000
बातें हम करने के लिए लागू करना चाहते हैं के लिए जा रहे हैं.

666
00:51:14,000 --> 00:51:18,000
यदि सूची की लंबाई

667
00:51:18,000 --> 00:51:21,000
आप को धोखा देने और एक के आसपास रख सकता है

668
00:51:21,000 --> 00:51:24,000
वैश्विक लंबाई या कुछ और, लेकिन हम ऐसा करने के लिए नहीं जा रहे हैं.

669
00:51:24,000 --> 00:51:28,000
हम सूची की लंबाई की गणना करने के लिए जा रहे हैं.

670
00:51:28,000 --> 00:51:34,000
हम होता है तो, है कि मूल रूप से एक खोज की तरह है,

671
00:51:34,000 --> 00:51:41,000
तो हम पूर्णांकों की एक लिंक सूची देखने के लिए अगर यह पूर्णांक लिंक सूची में है.

672
00:51:41,000 --> 00:51:44,000
प्रीपेंड सूची के शुरुआत में सम्मिलित करने के लिए जा रहा है.

673
00:51:44,000 --> 00:51:46,000
संलग्न अंत में सम्मिलित करने के लिए जा रहा है.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted सूची में क्रमबद्ध स्थिति में डालने के लिए जा रहा है.

675
00:51:53,000 --> 00:52:01,000
के Insert_sorted तरह मानता है कि आप प्रयोग किया जाता है या कभी नहीं प्रीपेंड बुरे तरीके में परिशिष्ट के रूप में लगाना.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted जब आप insert_sorted लागू कर रहे हैं

677
00:52:09,000 --> 00:52:13,000
हम कहते हैं कि हम हमारे लिंक सूची है.

678
00:52:13,000 --> 00:52:18,000
यह वही है जो वर्तमान की तरह, 2, 4, 5 दिखता.

679
00:52:18,000 --> 00:52:24,000
मैं 3 सम्मिलित करते हैं, तो जब तक सूची के रूप में ही पहले से ही हल करना चाहते हैं,

680
00:52:24,000 --> 00:52:27,000
यह आसान है खोजने के लिए जहां 3 अंतर्गत आता है.

681
00:52:27,000 --> 00:52:29,000
मैं 2 में शुरू करते हैं.

682
00:52:29,000 --> 00:52:32,000
ठीक है, तीन दो से अधिक है, तो मैं जा रहा रखना चाहते हैं.

683
00:52:32,000 --> 00:52:35,000
ओह, 4 बहुत बड़ी है, तो मुझे पता है कि 3 2 और 4 के बीच में जाना जा रहा है,

684
00:52:35,000 --> 00:52:39,000
और मैं संकेत और वह सब सामान ठीक कर दिया है.

685
00:52:39,000 --> 00:52:43,000
लेकिन अगर हम कड़ाई insert_sorted का उपयोग नहीं किया था,

686
00:52:43,000 --> 00:52:50,000
की तरह चलो बस का कहना है कि मैं 6 prepend,

687
00:52:50,000 --> 00:52:55,000
तो मेरे लिंक्ड सूची बनने जा रहा है.

688
00:52:55,000 --> 00:53:01,000
अब यह नहीं समझ में आता है, तो insert_sorted लिए, तुम सिर्फ मान सकते हैं

689
00:53:01,000 --> 00:53:04,000
कि सूची हल है, भले ही आपरेशन मौजूद

690
00:53:04,000 --> 00:53:09,000
जो इसे हल नहीं किया जा करने के लिए पैदा कर सकते हैं, और यह बात है.

691
00:53:09,000 --> 00:53:20,000
एक सहायक डालने तो उन मुख्य बातें आप को लागू करने के लिए जा रहे हैं.

692
00:53:20,000 --> 00:53:24,000
>> अभी के लिए, एक मिनट लेने के लिए लंबाई और होता है,

693
00:53:24,000 --> 00:53:30,000
और उन अपेक्षाकृत जल्दी होना चाहिए.

694
00:53:41,000 --> 00:53:48,000
बंद करने के समय में होने जा रही है, तो किसी को भी लंबाई के लिए कुछ भी है या शामिल हैं?

695
00:53:48,000 --> 00:53:50,000
वे लगभग समान होने के लिए जा रहे हैं.

696
00:53:50,000 --> 00:53:57,000
[छात्र] अवधि.

697
00:53:57,000 --> 00:54:01,000
चलो देखते हैं, संशोधन.

698
00:54:01,000 --> 00:54:04,000
ठीक है.

699
00:54:12,000 --> 00:54:15,000
आप को समझाना चाहता हूँ?

700
00:54:15,000 --> 00:54:21,000
[छात्र] मैं सिर्फ एक सूचक नोड बनाने और यह 1, जो हमारे वैश्विक चर इनिशियलाइज़

701
00:54:21,000 --> 00:54:27,000
और फिर मैं देखने के लिए अगर यह शून्य है तो मैं एक seg गलती नहीं मिलता है और 0 वापसी है कि अगर मामला है.

702
00:54:27,000 --> 00:54:34,000
अन्यथा, मैं के माध्यम से पाश, पूर्णांक भीतर का ट्रैक रखने

703
00:54:34,000 --> 00:54:38,000
कितनी बार मैं सूची के अगले तत्व पहुँचा है

704
00:54:38,000 --> 00:54:43,000
और एक ही वेतन वृद्धि ऑपरेशन में यह भी है कि वास्तविक तत्व का उपयोग करने के लिए,

705
00:54:43,000 --> 00:54:47,000
और फिर मैं लगातार चेक देखने के लिए अगर यह शून्य है,

706
00:54:47,000 --> 00:54:56,000
और अगर यह शून्य है, तो यह aborts और सिर्फ तत्वों मैं पहुँचा है की संख्या देता है.

707
00:54:56,000 --> 00:55:01,000
>> [रोब बी] किसी को कुछ भी पर कोई टिप्पणी है?

708
00:55:01,000 --> 00:55:06,000
यह लग रहा है ठीक शुद्धता बुद्धिमान.

709
00:55:06,000 --> 00:55:10,000
[छात्र] मुझे नहीं लगता कि आप == नोड अशक्त की जरूरत है.

710
00:55:10,000 --> 00:55:13,000
हाँ, तो अगर नोड == अशक्त वापसी 0.

711
00:55:13,000 --> 00:55:18,000
लेकिन अगर नोड == बातिल तो यह ओह, वहाँ एक शुद्धता मुद्दा है.

712
00:55:18,000 --> 00:55:23,000
यह था सिर्फ तुम और मैं लौट रहे हैं, लेकिन यह दायरे में अभी नहीं है.

713
00:55:23,000 --> 00:55:30,000
तुम सिर्फ int i की जरूरत है, तो मैं = 0.

714
00:55:30,000 --> 00:55:34,000
लेकिन अगर नोड अशक्त है, तो मैं अभी भी 0 हो जा रहा है,

715
00:55:34,000 --> 00:55:39,000
और हम 0 वापसी करने जा रहे हैं तो, इस मामले के समान है.

716
00:55:39,000 --> 00:55:48,000
एक अन्य आम बात घोषणा रखने के लिए है

717
00:55:48,000 --> 00:55:51,000
पाश के लिए अंदर के नोड की.

718
00:55:51,000 --> 00:55:54,000
आप कहते हैं कि ओह सकता है, नहीं.

719
00:55:54,000 --> 00:55:56,000
चलो इसे इस रूप में रहते हैं.

720
00:55:56,000 --> 00:55:59,000
मैं शायद int i = 0 यहाँ रखा जाएगा,

721
00:55:59,000 --> 00:56:05,000
तो नोड * नोड = यहाँ 1.

722
00:56:05,000 --> 00:56:11,000
और यह शायद अब इस से छुटकारा कैसे हो रही है.

723
00:56:11,000 --> 00:56:14,000
शायद यह है कि मैं कैसे यह लिखा होता है.

724
00:56:14,000 --> 00:56:21,000
आप इसे इस तरह भी देख सकता है.

725
00:56:21,000 --> 00:56:25,000
पाश संरचना के लिए सही यहाँ यह

726
00:56:25,000 --> 00:56:30,000
लगभग int i = 0 के रूप में आप प्राकृतिक होना चाहिए

727
00:56:30,000 --> 00:56:33,000
मैं सरणी की लंबाई की तुलना में कम है मैं + +.

728
00:56:33,000 --> 00:56:38,000
अगर है कि कैसे आप एक सरणी पर पुनरावृति, यह है कि आप एक लिंक सूची पर पुनरावृति.

729
00:56:38,000 --> 00:56:45,000
>> यह कुछ बिंदु पर 2 प्रकृति का होना चाहिए.

730
00:56:45,000 --> 00:56:50,000
साथ कि दिमाग में, यह लगभग एक ही बात होने जा रहा है.

731
00:56:50,000 --> 00:56:57,000
आप करने के लिए एक लिंक सूची पुनरावृति करना चाहते करने के लिए जा रहे हैं.

732
00:56:57,000 --> 00:57:02,000
नोड मैं पता नहीं क्या मूल्य कहा जाता है.

733
00:57:02,000 --> 00:57:04,000
मैं नोड.

734
00:57:04,000 --> 00:57:15,000
यदि उस नोड पर मूल्य = मैं वापसी सच है, और यह बात है.

735
00:57:15,000 --> 00:57:18,000
सूचना है कि एक ही तरीका हम कभी झूठी वापसी

736
00:57:18,000 --> 00:57:23,000
अगर हम पूरे लिंक की गई सूची से अधिक पुनरावृति और वापस कभी नहीं सच है,

737
00:57:23,000 --> 00:57:29,000
इतना है कि यह क्या करता है.

738
00:57:29,000 --> 00:57:36,000
एक तरफ ध्यान दें हम शायद संलग्न या prepend नहीं मिलेगा.

739
00:57:36,000 --> 00:57:39,000
>> त्वरित अंतिम ध्यान दें.

740
00:57:39,000 --> 00:57:52,000
यदि आप स्थिर कीवर्ड देखते हैं, तो चलो स्थैतिक int गिनती = 0 कहते हैं,

741
00:57:52,000 --> 00:57:56,000
तो हम गिनती नहीं है + +, आप मूल रूप से एक वैश्विक चर के रूप में यह सोचने के लिए कर सकते हैं,

742
00:57:56,000 --> 00:58:00,000
हालांकि मैं सिर्फ यह कहा है कि हम कैसे लंबाई को लागू करने के लिए जा रहे हैं नहीं.

743
00:58:00,000 --> 00:58:06,000
मैं यह कर रहा हूँ यहाँ, और फिर + + गिनती.

744
00:58:06,000 --> 00:58:11,000
किसी भी तरह से हम हम हमारी गिनती incrementing रहे हैं हमारे लिंक्ड सूची में एक नोड में प्रवेश कर सकते हैं.

745
00:58:11,000 --> 00:58:15,000
इस की बात यह है कि स्थिर कीवर्ड का मतलब क्या है.

746
00:58:15,000 --> 00:58:20,000
अगर मैं सिर्फ int गिनती = 0 है कि एक नियमित रूप से पुराने वैश्विक चर होगा.

747
00:58:20,000 --> 00:58:25,000
स्थैतिक int गिनती मतलब क्या यह है कि यह इस फ़ाइल के लिए एक वैश्विक चर है.

748
00:58:25,000 --> 00:58:28,000
यह किसी अन्य फ़ाइल के लिए असंभव है,

749
00:58:28,000 --> 00:58:34,000
5 pset के बारे में सोच की तरह, अगर आप शुरू कर दिया है.

750
00:58:34,000 --> 00:58:39,000
आप दोनों speller.c है, और आप dictionary.c है,

751
00:58:39,000 --> 00:58:42,000
और अगर तुम सिर्फ एक वैश्विक बात की घोषणा तो speller.c में कुछ भी

752
00:58:42,000 --> 00:58:45,000
dictionary.c और इसके विपरीत में पहुँचा जा सकता है.

753
00:58:45,000 --> 00:58:48,000
वैश्विक चर. किसी भी सी फ़ाइल से सुलभ हैं,

754
00:58:48,000 --> 00:58:54,000
लेकिन स्थैतिक चर ही फाइल के भीतर से ही उपलब्ध हैं,

755
00:58:54,000 --> 00:59:01,000
तो जादू चेकर या dictionary.c के अंदर के अंदर,

756
00:59:01,000 --> 00:59:06,000
यह कैसे मैं अपने सरणी के आकार के लिए मेरे चर घोषित होगा की तरह है

757
00:59:06,000 --> 00:59:10,000
या मेरे शब्दकोश में शब्दों की संख्या के आकार.

758
00:59:10,000 --> 00:59:15,000
के बाद से मैं एक वैश्विक चर घोषणा की है कि किसी को भी करने के लिए उपयोग नहीं करना चाहते,

759
00:59:15,000 --> 00:59:18,000
मैं वास्तव में केवल अपने उद्देश्यों के लिए इसके बारे में परवाह है.

760
00:59:18,000 --> 00:59:21,000
>> इस बारे में अच्छी बात यह भी पूरे नाम टक्कर के सामान है.

761
00:59:21,000 --> 00:59:27,000
यदि कुछ अन्य फ़ाइल के लिए एक वैश्विक चर बुलाया गिनती का उपयोग करने की कोशिश करता है, बातें बहुत, बहुत गलत जाना,

762
00:59:27,000 --> 00:59:33,000
तो यह अच्छी तरह से चीजों को सुरक्षित रखता है, और केवल आप इसे उपयोग कर सकते हैं,

763
00:59:33,000 --> 00:59:38,000
और कोई नहीं, और अगर किसी और एक वैश्विक चर बुलाया गिनती की घोषणा कर सकते हैं,

764
00:59:38,000 --> 00:59:43,000
तो यह अपने स्थैतिक चर बुलाया गिनती के साथ हस्तक्षेप नहीं करेगा.

765
00:59:43,000 --> 00:59:47,000
यही कारण है कि स्थिर क्या है. यह एक फ़ाइल वैश्विक चर है.

766
00:59:47,000 --> 00:59:52,000
>> कुछ पर प्रश्न?

767
00:59:52,000 --> 00:59:59,000
सब तैयार है. अलविदा.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]