[Powered by Google Translate] [धारा 6] [अधिक आरामदायक]
[रोब Bowden] [हार्वर्ड विश्वविद्यालय]
[यह CS50 है.] [CS50.TV]
>> हम सवालों के हमारे अनुभाग के लिए सिर कर सकते हैं.
मैं पहले अंतरिक्ष के लिए URL को भेजा.
सवालों के अनुभाग की शुरुआत का कहना है -
जाहिरा तौर पर मैं पूरी तरह से एक बहुत ही आसान सवाल unsick है नहीं कर रहा हूँ
बस क्या valgrind है?
वेलग्रिंड क्या करता है?
किसी कहना है वेलग्रिंड क्या करता करना चाहते हैं?
[छात्र] चेक स्मृति लीक.
हाँ, वेलग्रिंड एक सामान्य स्मृति चेकर है.
यह अंत में, आपको बताता है कि अगर आप किसी भी स्मृति लीक है,
जिनमें से ज्यादातर है कि हम क्या ऐसा इसलिए है क्योंकि के लिए उपयोग कर रहे हैं यदि आप चाहते हैं
समस्या सेट में या आप चाहते हैं, तो अच्छी तरह से करने के
बड़े बोर्ड पर मिलता है, तुम जो भी कोई स्मृति लीक की जरूरत है,
और मामले में आप एक स्मृति रिसाव है कि तुम नहीं मिल सकता है,
यह भी ध्यान में रखना है कि जब भी आप एक फ़ाइल खोलने
और अगर आप इसे नहीं बंद करते हैं, कि एक स्मृति रिसाव है.
>> लोगों का एक बहुत कुछ नोड के लिए देख रहे हैं कि वे मुक्त कराने के नहीं रहे हैं
जब वास्तव में, वे बहुत पहले कदम में शब्दकोश नहीं बंद नहीं किया.
यह आपको यह भी बताता है कि अगर आप किसी भी अवैध है पढ़ता है या लिखते हैं,
जिसका मतलब है कि अगर आप कोशिश करते हैं और एक मूल्य निर्धारित
कि ढेर के अंत से परे है और यह seg गलती के लिए नहीं होता है
लेकिन वेलग्रिंड यह पकड़ता है, के रूप में आप वास्तव में नहीं वहाँ लेखन चाहिए,
और इसलिए आप निश्चित रूप से उन दोनों में से किसी भी नहीं होना चाहिए.
कैसे आप प्रयोग करते valgrind?
>> यह एक सामान्य सवाल है
की तरह इसे चलाते हैं और उत्पादन को देखो.
उत्पादन समय की एक बहुत भारी है.
वहाँ भी मज़ा त्रुटियों जहां अगर आप कुछ बहुत गलत बात है
एक पाश में हो रहा है, तो यह अंततः कहते हैं, "रास्ता भी कई त्रुटियों.
मैं अब गिनती को रोकने के लिए जा रहा हूँ. "
यह मूल रूप से है कि आप को पार्स शाब्दिक उत्पादन है.
अंत में, यह है कि आप किसी भी स्मृति लीक बताना होगा,
कितने ब्लॉक, जो उपयोगी हो सकता है क्योंकि
अगर यह एक ब्लॉक unfreed है, तो यह आमतौर पर है खोजने के लिए आसान
1,000 से अधिक ब्लॉकों unfreed.
1000 unfreed ब्लॉकों शायद मतलब है कि आप को मुक्त कराने नहीं कर रहे हैं
अपने लिंक उचित या कुछ सूचियों.
कि valgrind है.
>> अब हम हमारे सवालों के अनुभाग है,
जो आप डाउनलोड की जरूरत नहीं है.
आप मेरे नाम पर क्लिक करें और उन्हें अंतरिक्ष में खींच सकते हैं.
अब मुझ पर क्लिक करें.
1 अवतरण ढेर, जिसे हम पहली बार कर रहे हैं होगा.
2 संशोधन कतार हो जाएगा, और 3 संशोधन अकेले लिंक सूची होगा.
हमारे ढेर के साथ बंद शुरू.
के रूप में यह यहाँ का कहना है, एक ढेर एक सबसे बुनियादी है,
कंप्यूटर विज्ञान की मूलभूत डेटा संरचनाओं.
बहुत prototypical उदाहरण है
डायनिंग हॉल में ट्रे के ढेर.
यह मूल रूप से जब भी आप एक ढेर करने के लिए शुरू की जा रही है,
किसी को कहते हैं, जा रहा है "ओह ट्रे के एक ढेर की तरह."
आप ट्रे धुआँरा.
फिर जब आप एक ट्रे खींचने के लिए जाना,
1 ट्रे खींच लिया हो रही है कि पिछले एक है कि ढेर पर डाल दिया गया है.
यहाँ यह भी तरह ढेर कहते हैं
हम स्मृति के खंड ढेर कहा जाता है.
और यह ढेर क्यों कहा जाता है?
>> क्योंकि एक ढेर डेटा संरचना की तरह,
यह धक्का और चबूतरे ढेर पर ढेर फ्रेम,
जहां ढेर फ्रेम एक समारोह के एक विशिष्ट कॉल की तरह कर रहे हैं.
और एक ढेर की तरह, आप हमेशा के लिए वापसी करना होगा
एक समारोह फोन से पहले आप नीचे कम ढेर फ्रेम में फिर से प्राप्त कर सकते हैं.
आप मुख्य कॉल foo कॉल बार और बार मुख्य सीधे वापस नहीं हो सकता.
यह हमेशा के लिए सही धक्का और popping ढेर का पालन करने के लिए मिल गया है.
दो ऑपरेशन जैसा मैंने कहा था, धक्का और पॉप हैं.
उन सार्वभौमिक शर्तों रहे हैं.
आप धक्का और कोई बात नहीं क्या ढेर के मामले में पॉप पता होना चाहिए.
हम देखेंगे पंक्तिज को संचित करना अलग की तरह कर रहे हैं.
यह वास्तव में एक सार्वभौमिक शब्द नहीं है, लेकिन धक्का और पॉप के ढेर के लिए सार्वभौमिक हैं.
पुश बस ढेर पर डाल दिया है.
पॉप बंद ले चुकी है.
और हम देखते हैं कि हम हमारे typedef struct ढेर,
इसलिए हम char ** तार है.
किसी भी ** से डर नहीं है.
यह अंत में तार का एक सरणी होने जा रहा है
या वर्ण के लिए संकेत की एक सरणी, जहां
वर्ण के लिए संकेत करने के लिए तार हो जाते हैं.
यह तार नहीं है, लेकिन यहाँ वे तार होने जा रहे हैं.
>> हम तारों की एक सरणी है.
हम एक आकार है, जो प्रतिनिधित्व करता है कि कितने तत्वों ढेर पर वर्तमान में कर रहे हैं,
और फिर हम क्षमता है, जो है कि कितने तत्वों ढेर पर हो सकता है.
क्षमता 1 से अधिक कुछ के रूप में शुरू कर देना चाहिए,
लेकिन आकार 0 के रूप में शुरू करने जा रहा है.
अब, वहाँ मूल रूप से कर रहे हैं तीन अलग अलग तरीकों से आप एक ढेर के बारे में सोच सकते हैं.
खैर, वहाँ शायद अधिक है, लेकिन दो मुख्य तरीके हैं
आप इसे लागू एक सरणी का उपयोग कर सकते हैं, या आप इसे लागू करने के लिए एक लिंक सूची का उपयोग कर सकते हैं.
लिंक सूचियों तरह से ढेर बनाने के लिए तुच्छ है.
यह बहुत आसान है के लिए एक लिंक सूचियों का उपयोग ढेर,
तो यहाँ, हम एक ढेर arrays का उपयोग करने के लिए जा रहे हैं,
और फिर arrays का उपयोग, वहाँ भी दो तरीकों से आप इसके बारे में सोच सकते हैं.
इससे पहले, जब मैंने कहा कि हम ढेर के लिए एक क्षमता है,
तो हम ढेर पर एक तत्व फिट कर सकते हैं.
>> एक तरीका यह हो सकता है के रूप में के रूप में आप 10 तत्वों मारा, तो आप कर रहे हैं जल्द ही है.
तुम जानते हो सकता है कि वहाँ एक ऊपरी दुनिया में 10 चीजों में से एक ही है
कि आप 10 से अधिक बातें अपने ढेर पर कभी नहीं होगा,
जो मामले में आप अपने ढेर के आकार पर ऊपरी बाध्य हो सकता है.
या तुम हो सकता है अपने ढेर असीम हो,
लेकिन अगर आप एक सरणी कर रहे हैं, इसका मतलब है कि हर बार जब आप 10 तत्वों मारा,
तो आप करने के लिए 20 तत्वों को विकसित करने के लिए जा रहे हैं, और जब आप 20 तत्वों मारा,
आप करने के लिए 30 तत्वों या 40 तत्वों को अपने सरणी बढ़ने जा रहे हैं.
आप करने के लिए क्षमता है, जो हम यहाँ क्या करने जा रहे हैं बढ़ाने की आवश्यकता के लिए जा रहे हैं.
हर बार जब हम हमारे ढेर के अधिकतम आकार तक पहुँचने,
जब हम पर कुछ धक्का, हम करने के लिए क्षमता बढ़ाने की आवश्यकता के लिए जा रहे हैं.
यहाँ, हम धक्का bool धक्का (चार * str) के रूप में घोषित किया है.
चार * str स्ट्रिंग है कि हम ढेर पर जोर दे रहे हैं,
और bool बस का कहना है कि हम सफल हो या असफल.
>> हम कैसे विफल कर सकते हैं?
केवल परिस्थिति है कि आप सोच सकते हैं क्या है
जहाँ हम झूठी वापसी की आवश्यकता होगी?
हाँ.
[छात्र] यदि यह भरा हुआ है और हम एक घिरा कार्यान्वयन का उपयोग कर रहे हैं.
हाँ, तो कैसे हम को परिभाषित वह जवाब दिए
अगर यह भरा हुआ है और हम घिरा कार्यान्वयन का उपयोग कर रहे हैं.
तो हम निश्चित रूप से झूठी वापस आ जाएगी.
जैसे ही हम सरणी में 10 चीजें हिट, हम 11 फिट नहीं कर सकते, तो हम वापसी झूठी.
अगर यह असीमित है तो क्या होगा? हाँ.
यदि आप किसी कारण के लिए सरणी का विस्तार नहीं कर सकते हैं.
हाँ, तो स्मृति एक सीमित संसाधन है,
और अंत में, अगर हम ढेर पर पर और फिर से धक्का चीजें रखने के लिए,
हम कोशिश करते हैं और एक बड़ा सरणी आवंटित करने के लिए फिट करने के लिए जा रहे हैं
बड़ी क्षमता, और malloc या जो कुछ भी हम प्रयोग कर रहे हैं झूठी वापसी करने के लिए जा रहा है.
खैर, malloc रिक्त वापस आ जाएगी.
>> याद रखें, हर बार जब आप कभी malloc कॉल, आप देखने के लिए जाँच किया जाना चाहिए अगर
अशक्त रिटर्न या किसी और कि शुद्धता कटौती है.
चूंकि हम एक असीम ढेर है चाहते हैं,
केवल मामले में हम झूठी लौट जा रहे हैं अगर हम कोशिश
क्षमता और malloc बढ़ाने या जो भी झूठे रिटर्न.
फिर पॉप कोई तर्क लेता है,
और यह स्ट्रिंग है कि ढेर के शीर्ष पर है देता है.
जो भी सबसे हाल ही में ढेर पर धकेल दिया गया था पॉप क्या लौट रहा है,
और यह भी ढेर से हटाता है.
नोटिस और है कि यह शून्य देता है अगर वहाँ ढेर पर कुछ भी नहीं है.
यह हमेशा संभव है कि ढेर खाली है.
जावा में, अगर आप, या अन्य भाषाओं के लिए इस्तेमाल कर रहे हैं,
खाली स्टैक से पॉप करने की कोशिश कर रहा एक अपवाद या कुछ और कारण हो सकता है.
>> लेकिन सी में अशक्त मामलों में हम कैसे इन समस्याओं को संभालने का एक बहुत की तरह है.
अशक्त रिटर्निंग है कि हम कैसे जा रहे हैं को दर्शाता है कि ढेर खाली था.
हम कोड कि अपने ढेर की कार्यक्षमता का परीक्षण करेगा प्रदान की है,
धक्का और पॉप को लागू करने.
इस कोड का एक बहुत नहीं होगा.
मैं वास्तव में होगा, इससे पहले कि हम करते हैं, संकेत, संकेत -
अगर आप इसे नहीं देखा है, malloc केवल समारोह में नहीं है
कि आप के लिए ढेर पर स्मृति का आवंटन.
Alloc कार्यों के एक परिवार के हैं.
1 malloc, जो आप इस्तेमाल कर रहे है.
तो फिर वहाँ calloc, जो malloc के रूप में एक ही बात करता है,
लेकिन यह सब कुछ आप के लिए बाहर शून्य होगा.
यदि आप कभी कुछ mallocing के बाद है करने के लिए सब कुछ सेट अशक्त चाहता
आप सिर्फ लिखने के बजाय पहली जगह में किया जाना calloc प्रयोग किया जाता है
पाश के लिए एक स्मृति से बाहर पूरे ब्लॉक शून्य.
>> Realloc malloc की तरह है और विशेष मामलों की एक बहुत कुछ किया है,
लेकिन मूल रूप से realloc क्या करता है
यह एक सूचक है कि पहले से ही आवंटित किया गया था लेता है.
Realloc समारोह आप यहाँ ध्यान करने के लिए भुगतान किया जा करना चाहते है.
यह एक सूचक है कि पहले से ही malloc से लौटा दिया गया था लेता है.
मान लीजिए कि आप malloc से 10 बाइट्स की एक सूचक का अनुरोध.
फिर बाद में आपको पता है तुम 20 बाइट्स चाहता था,
तो आप 20 बाइट्स के साथ कि सूचक पर realloc कहते हैं,
और realloc स्वचालित रूप से आप के लिए सब कुछ खत्म कॉपी जाएगा.
यदि आप सिर्फ malloc फिर कहा जाता है, जैसे मैं 10 बाइट्स के एक ब्लॉक है.
अब मैं 20 बाइट्स की एक ब्लॉक की जरूरत है,
तो मैं 20 बाइट्स malloc यदि हां, तो मैं स्वयं पर पहली बात से 10 बाइट्स की नकल है
और दूसरी बात में तो पहली बात मुफ्त.
Realloc कि आप के लिए संभाल लेंगे.
>> सूचना हस्ताक्षर करने के लिए शून्य * होने जा रहा है,
जो सिर्फ स्मृति के ब्लॉक करने के लिए एक सूचक लौटने,
तो शून्य * ptr.
आप एक सामान्य सूचक के रूप में शून्य * के बारे में सोच सकते हैं.
आम तौर पर, शून्य * के साथ आप कभी नहीं सौदा,
लेकिन एक शून्य * malloc लौट रहा है, और फिर यह सिर्फ तरह इस्तेमाल किया है
यह वास्तव में एक चार * होने जा रहा है.
पिछले शून्य * कि malloc से वापस आ गया था
अब realloc करने के लिए पारित किया जा जा रहा है, और फिर आकार
बाइट्स के नए नंबर आवंटित करना चाहते है, तो अपने नए क्षमता है.
मैं तुम्हें एक दो मिनट दे देंगे, और यह हमारे अंतरिक्ष में है.
1 संशोधन के साथ शुरू करो.
मैं तुम्हें करने के लिए पर्याप्त धक्का को लागू करने के लिए समय के बाद के बारे में उम्मीद है कि रोक देंगे,
और फिर मैं तुम्हें एक और पॉप तोड़ दे दूँगा.
लेकिन यह सच है कि ज्यादा कोड बिल्कुल नहीं है.
सबसे शायद कोड विस्तार सामान है, क्षमता का विस्तार.
ठीक है, नहीं करने के लिए पूरी तरह से किया जा दबाव,
लेकिन के रूप में लंबे समय के रूप में आपको लगता है कि आप सही रास्ते पर हैं, यह अच्छी बात है.
>> क्या किसी को किसी भी कोड वे मुझे खींच के साथ सहज महसूस करते है?
हाँ, मैं करता है, लेकिन किसी को भी किसी भी कोड मैं खींच सकते हैं होगा?
ठीक है, तुम शुरू करने के लिए, इसे बचाने के लिए कर सकते हैं, जो कुछ भी यह है?
मैं हमेशा उस कदम को भूल जाते हैं.
ठीक है, धक्का पर देख रहे हैं,
क्या आप अपने कोड की व्याख्या करने के लिए करना चाहते हैं?
[छात्र] सबसे पहले, मैं आकार में वृद्धि हुई.
मुझे लगता है कि शायद मुझे लगता है कि वैसे भी होना चाहिए, मैं आकार में वृद्धि हुई है,
और मैं देख रहा हूँ अगर यह क्षमता से कम है.
और अगर यह क्षमता की तुलना में कम है, मैं सरणी है कि हम पहले से ही है.
और अगर ऐसा नहीं है, मैं 2 द्वारा क्षमता गुणा,
और मैं कुछ करने के लिए तार सरणी reallocate अब एक बड़ी क्षमता के आकार के साथ.
और फिर अगर वह विफल रहता है, तो मैं उपयोगकर्ता बता और वापसी झूठी,
और अगर यह ठीक है, तो मैं नई जगह में तार डाल दिया.
>> [रोब बी] यह भी सूचना है कि हम एक अच्छा bitwise ऑपरेटर यहां इस्तेमाल किया
2 से गुणा करने के लिए.
याद रखें, बाएँ बदलाव हमेशा के लिए 2 से गुणा किया जा रहा है.
सही बदलाव 2 द्वारा लंबे समय के रूप में विभाजित किया गया है जैसा कि आपको याद है कि इसका मतलब है
एक पूर्णांक में 2 से विभाजित के रूप में 2 से विभाजित.
यह यहाँ या वहाँ 1 truncate सकता है.
लेकिन 1 द्वारा छोड़ा बदलाव हमेशा के लिए 2 से गुणा किया जा रहा है,
जब तक आप पूर्णांक की सीमा अतिप्रवाह, और फिर यह नहीं होगा.
एक तरफ टिप्पणी.
मैं करने के लिए क्या यह करने के लिए किसी भी तरह से कुछ कोडिंग बदलने नहीं जा रहा है की तरह,
लेकिन मैं इस तरह से कुछ करना पसंद है.
यह वास्तव में यह थोड़ा लंबा बनाने जा रही है.
शायद यह सही करने के लिए इस शो का मामला नहीं है,
लेकिन मैं खंड की तरह के इन ब्लॉकों में
ठीक है, अगर यह होता है अगर है, तो मैं कुछ करने जा रहा हूँ,
और फिर समारोह में किया जाता है.
मैं तो मेरी आँखों समारोह के नीचे सभी तरह स्क्रॉल की जरूरत नहीं है
देखने के लिए किसी और के बाद क्या होता है.
यह है कि अगर यह होता है अगर है, तो मैं बस वापस.
यह भी इस से परे सब कुछ का अच्छा लाभ जोड़ा गया
अब एक बार छोड़ दिया स्थानांतरित कर दिया है.
मैं अब और नहीं करने के लिए यदि आप कभी हास्यास्पद लंबी लाइनों के पास की जरूरत है,
तो उन 4 बाइट्स की मदद कर सकते हैं, और भी कुछ अधिक छोड़ दिया है,
कम अभिभूत आपको लगता है कि अगर आप की तरह ठीक है, मुझे याद है
मैं पाश के लिए एक एक की और अंदर के अंदर एक समय पाश में वर्तमान में हूँ.
कहीं तुम इस वापसी के तुरंत कर सकते हैं, मैं एक तरह की तरह.
यह पूरी तरह से वैकल्पिक है और किसी भी तरह की उम्मीद नहीं है.
>> [छात्र] वहाँ एक आकार असफल हालत में होना चाहिए?
असफल हालत यहाँ हम realloc करने में विफल रहा है, तो हाँ.
असफल हालत में कैसे संभाव्यतः सूचना,
जब तक हम मुक्त सामान बाद, हम हमेशा विफल करने के लिए जा रहे हैं
कोई फर्क नहीं पड़ता कि कितनी बार हम कुछ पुश करने की कोशिश.
यदि हम धक्का रखने के लिए, हम incrementing आकार रखने के लिए,
भले ही हम कुछ ढेर पर नहीं डाल रहे हैं.
आमतौर पर हम जब तक आकार नहीं बढ़ाया
बाद हम सफलतापूर्वक ढेर पर डाल दिया.
हम यह कहना होगा, या तो यहाँ और यहाँ.
और फिर कह ≤ क्षमता s.size के बजाय, यह क्षमता से भी कम समय है,
क्योंकि हम केवल ले जाया गया, जहां सब कुछ था.
>> और याद रखना, केवल जगह है कि हम संभवतः झूठी लौट सकता है
यहाँ है, जहां realloc अशक्त लौटे,
और अगर आप मानक त्रुटि को याद होगा,
शायद आप इस मामले में एक विचार है जहां आप एक मानक त्रुटि मुद्रित करना चाहते हो सकता है,
सिर्फ मानक बाहर करने के लिए सीधे मुद्रण के बजाय ऐसा fprintf stderr.
फिर, कि एक उम्मीद नहीं है, लेकिन अगर यह एक त्रुटि है,
printf टाइप करें, तो आप बनाने के लिए यह मानक बाहर के बजाय मानक त्रुटि मुद्रित करना चाहते हो सकता है.
>> किसी को भी कुछ और ध्यान दें करने के लिए है? हां.
[छात्र] आप [अश्राव्य] पर जा सकते हैं?
[रोब बी] हाँ, यह की वास्तविक binariness या सिर्फ यह है क्या?
[छात्र] तो आप इसे 2 से गुणा?
[रोब बी] हाँ, मूल रूप से.
बाइनरी भूमि में, हम हमेशा अंकों की हमारे सेट है.
1 द्वारा इस बाएं मूल रूप से यह सही पक्ष में यहाँ आवेषण स्थानांतरण.
यह करने के लिए वापस, सिर्फ द्विआधारी में है कि सब कुछ याद
2 की एक शक्ति है, तो इस 0 2 का प्रतिनिधित्व करता है,
1 इस 2, 2 से 2.
अब सही पक्ष के लिए एक 0 डालने से, हम बस सब कुछ शिफ्ट खत्म हो गया.
क्या 0 से 2 इस्तेमाल किया जा अब है 1 2, 2 2 है.
सही पक्ष है कि हम द्वारा सम्मिलित
जरूरी 0 होने जा रहा है,
जो समझ में आता है.
यदि आप कभी भी एक संख्या 2 से गुणा करने के लिए, यह अजीब अंत नहीं हो रहा है,
0 जगह 2 0 होना चाहिए,
और यह है कि मैं क्या आधे से पहले है के बारे में चेतावनी दी है अगर आप बदलाव के लिए ऐसा करते हैं
एक पूर्णांक में बिट्स की संख्या के परे,
तो यह 1 को समाप्त करने से जा रहा जा रहा है.
यह केवल चिंता है अगर आप वास्तव में बड़ी क्षमता के साथ काम किया हो.
लेकिन उस बिंदु पर है, तो आप चीजों के अरबों के एक सरणी के साथ काम कर रहे हैं,
जो स्मृति में वैसे भी फिट नहीं हो सकता है.
>> अब हम पॉप, जो भी आसान करने के लिए मिल सकता है.
तुम यह कर यदि आप एक पूरी गुच्छा पॉप हो सकता है,
और अब आप आधी क्षमता पर फिर से कर रहे हैं.
आप स्मृति की राशि है जो आप हटना realloc सकता है,
लेकिन आप इस बारे में चिंता करने की ज़रूरत नहीं है, तो केवल realloc मामले होने जा रहा है
स्मृति से बढ़ रही है, सिकुड़ते स्मृति कभी नहीं,
है जो पॉप सुपर आसान बनाने जा रही है.
अब कतार, जो ढेर की तरह होने जा रहे हैं,
लेकिन आदेश है कि तुम चीजें लेने के उलट है.
एक कतार के prototypical उदाहरण के लिए एक लाइन है,
इसलिए मुझे लगता है कि अगर आप अंग्रेजी में थे, मैं ने कहा होगा
एक कतार के एक prototypical उदाहरण एक कतार है.
तो एक लाइन की तरह, यदि आप लाइन में पहले व्यक्ति हैं,
आप लाइन से बाहर 1 व्यक्ति होने की उम्मीद है.
यदि आप लाइन में अंतिम व्यक्ति हो, तुम पिछले सेवित व्यक्ति होने जा रहे हैं.
हम जानते हैं कि फीफो पैटर्न कहते हैं, जबकि ढेर LIFO पैटर्न था.
उन शब्दों को सुंदर सार्वभौमिक हैं.
>> ढेर की तरह और arrays के विपरीत, कतार आमतौर पर बीच में तत्वों के लिए उपयोग नहीं की अनुमति नहीं है.
इधर, एक ढेर, हम धक्का और पॉप है.
यहाँ, हम करने के लिए उन्हें बुलाया enqueue और विपंक्ति होता है.
मैंने यह भी सुना है कि उन्हें पारी और unshift बुलाया.
मैंने सुना है लोग कहते धक्का और पॉप भी कतार को लागू करने के लिए.
मैं सम्मिलित करने के लिए, हटाने के बारे में सुना है,
इतना धक्का और पॉप, अगर आप ढेर के बारे में बात कर रहे हैं, तो आप धक्का और popping रहे हैं.
यदि आप कतार के बारे में बात कर रहे हैं, आप शब्दों आप उपयोग करना चाहते ले सकता है
प्रविष्टि और हटाने के लिए, और क्या यह कहा जाना चाहिए पर कोई आम सहमति नहीं है.
लेकिन यहाँ, हम enqueue और विपंक्ति है.
अब, struct लगभग ढेर struct के समान लग रहा है.
लेकिन हम सिर का ट्रैक रखने के लिए है.
मुझे लगता है कि यह यहाँ नीचे कहते हैं, लेकिन हम सिर की आवश्यकता क्यों है?
प्रोटोटाइप मूल रूप से धक्का और पॉप के लिए समान हैं.
आप इसे धक्का और पॉप के रूप में सोच सकते हैं.
फर्क सिर्फ इतना है पॉप लौटने के बजाय पिछले की है, यह है कि 1 लौटने.
2, 1, 3, 4, या कुछ और.
और यहाँ शुरुआत है.
हमारी कतार पूरी तरह से भरा हुआ है, तो वहाँ में यह चार तत्वों है.
हमारी कतार के अंत वर्तमान में 2,
और अब हम कुछ डालने के लिए जाना है.
>> जब हम ढेर संस्करण के लिए है कि कुछ और, हम क्या किया सम्मिलित करना चाहते हैं
हम स्मृति के हमारे ब्लॉक बढ़ाया.
इस के साथ समस्या क्या है?
[छात्र] तुम 2 चाल.
क्या मैं कतार के अंत के बारे में पहले कहा था,
1 पर समझ में आता है कि हम शुरू नहीं कर सकता है,
तो हम 1 विपंक्ति करने के लिए करना चाहते हैं, तो विपंक्ति 3, फिर विपंक्ति 4,
तो विपंक्ति 2, तो यह एक विपंक्ति.
हम realloc अब उपयोग नहीं कर सकते,
या बहुत कम से कम, आप एक अलग तरीके से realloc का उपयोग करने के लिए किया है.
लेकिन तुम शायद सिर्फ realloc का उपयोग नहीं करना चाहिए.
आप स्वयं अपनी स्मृति कॉपी करने के लिए जा रहे हैं.
>> वहाँ दो करने के लिए स्मृति की प्रतिलिपि बनाने के लिए कार्य कर रहे हैं.
वहाँ memcopy और memmove है.
मैं वर्तमान में मैन पेज पढ़ रहा हूँ जो एक को देखने के लिए आप करने के लिए उपयोग करना चाहते हैं के लिए जा रहे हैं.
ठीक है, memcopy, अंतर है
कि memcopy और memmove, एक मामले को सही ढंग से संभालती
जहां आप एक क्षेत्र है कि क्षेत्र ओवरलैप होता है में नकल कर रहे हैं
आप में से नकल कर रहे हैं.
Memcopy इसे संभाल नहीं है. Memmove करता है.
आप के रूप में समस्या के बारे में सोच सकते हैं
हम कहते हैं कि मैं इस आदमी की नकल करना चाहते हैं,
इस पर आदमी के लिए इन चार.
अंत में, सरणी की तरह दिखना चाहिए
बाद प्रतिलिपि 2, 1, 2, 1, 3, 4, और फिर अंत में कुछ सामान है.
लेकिन इस क्रम में हम वास्तव में नकल पर निर्भर है,
क्योंकि अगर हम तथ्य यह है कि हम क्षेत्र में नकल कर रहे हैं पर विचार नहीं करते
overlaps एक हम से नकल कर रहे हैं,
तो हम यहाँ शुरुआत की तरह करते हैं, हो सकता है हम जाना चाहते हैं जगह में 2 की नकल,
तो हमारे संकेत आगे बढ़ना है.
>> अब हम यहाँ और यहाँ होने जा रहे हैं, और अब हम प्रतिलिपि बनाना चाहते हैं
इस आदमी पर इस आदमी और हमारे संकेत आगे बढ़ना है.
हम खत्म हो जा रहे हैं क्या 2, 1, 2, 1, 2, 1
बजाय उपयुक्त 2, 1, 2, 1, 3, 4 क्योंकि
1 2, मूल 3, 4 overrode.
Memmove कि सही ढंग से संभालती है.
इस मामले में, मूल रूप से बस हमेशा memmove का उपयोग
क्योंकि यह सही ढंग से संभालती है.
यह आम तौर पर किसी भी बुरा प्रदर्शन नहीं करता.
विचार शुरू से ही शुरू है और इस तरह की नकल के बजाय है
जैसे हम यहाँ सिर्फ किया है, यह अंत से शुरू होता है और प्रतियां,
और उस मामले में, आप एक समस्या कभी नहीं हो सकता है.
वहाँ कोई प्रदर्शन खो दिया है.
हमेशा memmove का उपयोग करें. चिंता करने की ज़रूरत कभी memcopy के बारे में.
और वह है जहाँ आप करने के लिए अलग से memmove जा रहे हैं
लिपटे के आसपास अपनी कतार का हिस्सा.
कोई चिंता नहीं अगर पूरी तरह से नहीं किया.
इस ढेर, पॉप, और धक्का से और अधिक कठिन है.
>> किसी को भी किसी भी कोड में हम साथ काम कर सकता है?
यहां तक ​​कि पूरी तरह से अधूरा है?
[छात्र] हाँ, यह पूरी तरह से अधूरा है, यद्यपि.
लंबे समय के रूप में पूरी तरह से अधूरा ठीक है के रूप में हम कर सकते हैं आप संशोधन बचा?
मुझे लगता है कि हर एक बार भूल जाते हैं.
ठीक है, क्या की अनदेखी होता है जब हम चीजों को आकार की जरूरत है.
पूरी तरह से का आकार परिवर्तन की उपेक्षा.
इस कोड को समझाओ.
मैं सब से पहले की जाँच कर रहा हूँ अगर आकार सब से पहले कॉपी से कम है
और फिर उसके बाद, मैं डालने मैं + सिर के आकार लेने के लिए,
और मुझे यकीन है कि यह सरणी की क्षमता के आसपास wraps,
और मुझे लगता है कि स्थिति पर नए स्ट्रिंग डालने.
तो मैं आकार बढ़ाने के लिए और वापसी सच.
>> [रोब बी] यह निश्चित रूप से एक उन मामलों में जहां आप आधुनिक का उपयोग किया जाना चाहते करने के लिए जा रहे हैं.
मामले की किसी भी तरह है जहां आप चारों ओर लपेटकर है, अगर आपको लगता है कि चारों ओर लपेटकर,
तत्काल सोचा आधुनिक होना चाहिए.
/ एक त्वरित अनुकूलन के रूप में अपने कोड एक लाइन कम करने,
तुम नोटिस कि लाइन तुरंत एक के बाद इस
सिर्फ आकार है + +, तो आप मर्ज है कि इस लाइन में, आकार + +.
अब यहाँ नीचे, हम मामला है
जहाँ हम पर्याप्त स्मृति नहीं है,
इसलिए हम 2 से हमारी क्षमता में वृद्धि कर रहे हैं.
मुझे लगता है कि आप यहाँ एक ही समस्या हो सकता है, लेकिन अब हम इसे अनदेखा कर सकते हैं,
जहां अगर आप अपनी क्षमता में वृद्धि करने में विफल रहा है,
तो आप करने के लिए 2 से अपनी क्षमता को फिर से कम करना चाहते करने के लिए जा रहे हैं.
एक अन्य छोटे नोट है बस आप की तरह कर सकते हैं + =
आप भी कर सकते हैं << =.
लगभग कुछ भी करने से पहले के बराबर होती जा सकते हैं, + = | = & =, << =.
चार * नई हमारी स्मृति के नए ब्लॉक है.
ओह, यहाँ.
>> लोग हमारी स्मृति के नए ब्लॉक के प्रकार के बारे में क्या लगता है?
[छात्र] यह चार ** होना चाहिए.
हमारे struct वापस यहाँ सोच,
तार हम क्या reallocating रहे हैं.
हम कतार में तत्वों के लिए एक पूरी नई गतिशील भंडारण कर रहे हैं.
हम अपने तार को बताए जा रहे हैं कि हम क्या सही अब mallocing रहे हैं,
और इसलिए नए char ** होने जा रहा है.
यह तारों की एक सरणी होने जा रहा है.
फिर मामला है जिसके तहत हम वापसी झूठी जा रहे हैं क्या है?
[छात्र] हम चार * कर किया जाना चाहिए?
[रोब बी] हाँ, अच्छा फोन है.
[छात्र] क्या था?
[रोब बी] हम चार * के आकार करना चाहता था क्योंकि हम नहीं कर रहे हैं अब
यह वास्तव में एक बहुत बड़ी समस्या हो सकता है क्योंकि sizeof (चार) 1 होगा.
Sizeof चार * 4 होने जा रहा है,
तो बार जब आप ints के साथ काम कर रहे हैं की एक बहुत कुछ है,
आप इसे दूर के साथ मिल जाते हैं क्योंकि int और int * के आकार के आकार
एक 32-bit प्रणाली पर एक ही बात हो जा रहे हैं.
लेकिन यहाँ, sizeof (चार) और sizeof (चार *) अब एक ही बात हो जा रहे हैं.
>> परिस्थिति जहाँ हम वापसी झूठी क्या है?
[छात्र] नई रिक्त है.
हाँ, अगर नई अशक्त है, हम वापसी झूठी,
और मैं नीचे फेंक यहाँ जा रहा हूँ
[छात्र] [अश्राव्य]
[रोब बी] हाँ, यह ठीक है.
आप या तो 2 बार क्षमता या क्षमता 1 बदलाव तो और केवल इसे नीचे सेट यहाँ या जो कुछ भी कर सकता है.
हम यह कर के रूप में हम यह था.
>> = 1 क्षमता.
और आप 1 की जगह को खोने के बारे में चिंता करने की ज़रूरत कभी नहीं जा रहे हैं
क्योंकि तुम्हें छोड़ दिया है 1 से स्थानांतरित कर दिया है, तो 1 के स्थान जरूरी 0 है,
तो सही 1 से बदलता है, तो आप अभी भी ठीक हो जा रहे हैं.
[छात्र] क्या आप के लिए लौटने से पहले ऐसा करने की जरूरत है?
[रोब बी] हाँ, यह बिल्कुल नहीं समझ में आता है.
>> अब लगता है हम अंत में समाप्त करने के लिए सच लौटने के लिए जा रहे हैं.
जिस तरह से हम इन memmoves करने जा रहे हैं,
हम हम उन्हें कैसे करना है के साथ सावधान रहने की जरूरत है.
क्या किसी के लिए किसी भी सुझाव है कि हम उन्हें कैसे करना है?
यहाँ हमारी शुरुआत है.
अनिवार्य रूप से, हम शुरुआत में फिर से शुरू करना चाहते हैं
कॉपी और वहाँ से बातें, 1, 3, 4, 2.
आपको लगता है कि कैसे करते हो?
सबसे पहले, मैं memmove के लिए आदमी पृष्ठ पर फिर से देखने के लिए है.
Memmove, तर्कों के आदेश हमेशा महत्वपूर्ण है.
हम अपने गंतव्य पहले चाहते हैं, स्रोत 2, 3 आकार.
कार्य करता है जो स्रोत और गंतव्य रिवर्स एक बहुत कुछ कर रहे हैं.
गंतव्य स्रोत, करने के लिए लगातार कुछ हो जाता है.
हटो, यह क्या लौट रहा है?
यह गंतव्य के लिए जो भी कारण तुम चाहते हो सकता है कि के लिए एक सूचक देता है.
मैं तस्वीर इसे पढ़ने के कर सकते हैं, लेकिन हम अपने गंतव्य में स्थानांतरित करना चाहते हैं.
>> हमारी मंजिल क्या करने जा रहे हो?
[छात्र] नई.
[रोब बी] हाँ, और जहां हम से नकल कर रहे हैं?
हम नकल कर रहे हैं कि पहली बात यह 1, 3, 4.
क्या इस 1, 3, 4.
1 इस का पता क्या है?
कि 1 का पता क्या है?
[छात्र] [अश्राव्य]
[रोब बी] प्रधान + 1 तत्व का पता.
हम सरणी में पहली तत्व कैसे मिलता है?
[छात्र] कतार.
[रोब बी] हाँ q.strings,.
याद रखें, यहाँ, हमारे सिर 1 है.
यह झकना. मैं तो बस लगता है कि यह जादुई
यहाँ हमारे सिर 1 है. मैं मेरे रंग भी बदलने जा रहा हूँ.
और यहाँ तार है.
यह, हम या तो इसे लिखने के रूप में हम यहाँ पर किया जा सकता
+ के साथ सिर q.strings.
लोगों का एक बहुत यह भी लिखने और q.strings [सिर].
यह वास्तव में किसी भी कम कुशल नहीं है.
आप यह सोचने के रूप में आप इसे dereferencing कर रहे हैं तो और पता हो रही हो सकता है,
लेकिन संकलक यह हम पहले क्या था अनुवाद के लिए जा रहा है, वैसे भी, q.strings सिर +.
किसी भी तरह से आप यह सोचने के लिए करना चाहते हैं.
>> और हम कितने बाइट्स की प्रतिलिपि करने के लिए चाहते हो?
[छात्र] क्षमता - सिर.
क्षमता - सिर.
और तो आप हमेशा एक उदाहरण लिख सकता है
पता लगाने की है कि अगर सही है.
[छात्र] यह तो 2 से विभाजित किया जा जरूरत है.
हाँ, तो मुझे लगता है कि हम आकार का उपयोग कर सकते हैं.
हम अभी भी आकार से किया जा रहा है
आकार का उपयोग करते हुए, हम 4 के बराबर आकार है.
हमारे आकार 4 है. हमारे प्रधान 1 है.
हम इन 3 तत्वों की नकल करना चाहते हैं.
यही कारण है कि विवेक कि आकार की जाँच - सिर में सही ढंग से 3 है.
और यहाँ वापस आ रहा है, जैसे कि हम पहले कहा,
अगर हम क्षमता का इस्तेमाल किया है, तो हम 2 से विभाजित करना चाहते हैं
क्योंकि हम पहले से ही हमारी क्षमता हो गई है, तो इसके बजाय, हम आकार का उपयोग करने जा रहे हैं.
यह उस हिस्से प्रतियां.
अब, हम अन्य भाग, भाग है कि शुरू से छोड़ दिया है को कॉपी करने की जरूरत है.
>> कि क्या स्थिति में memmove हो रहा है?
[छात्र] प्लस आकार के सिर.
हाँ, तो हम पहले से ही आकार में नकल की है - सिर बाइट्स,
और इसलिए जहाँ हम शेष बाइट्स की नकल करना चाहते हैं नया है
और फिर आकार ऋण अच्छी तरह से, बाइट्स की संख्या हम पहले से ही अंदर की नकल की है
और फिर हम कहाँ से नकल कर रहे हैं?
[छात्र] Q.strings [0].
[रोब बी] हाँ q.strings,.
हम भी करते हैं और q.strings [0]
यह काफी कम है इस की तुलना में आम है.
अगर यह सिर्फ 0 होने जा रहा है, तो आप को q.strings देखते हैं.
यही कारण है कि हम कहाँ से नकल कर रहे हैं.
हम कितने बाइट की प्रतिलिपि करने के लिए छोड़ दिया है? >> 10 [छात्र].
सही है.
[छात्र] हम 5 गुणा है - 10 बार के आकार बाइट या कुछ और?
हाँ, तो यह वह जगह है जहाँ क्या वास्तव में हम नकल कर रहे हैं?
[छात्र] [अश्राव्य]
बात हम नकल कर रहे हैं के प्रकार क्या है?
[छात्र] [अश्राव्य]
हाँ, चार * कि हम नकल कर रहे हैं, तो हम उन जहां से आ रहे हैं पता नहीं है.
खैर, जहां वे इशारा कर रहे हैं, तार की तरह, हम अंत में यह कतार पर धक्का
या पंक्ति पर enqueuing.
उन कहाँ से आ रहे हैं, हमें पता नहीं है.
हम सिर्फ चार * खुद का ट्रैक रखने की जरूरत है.
सिर बाइट्स - हम करने के लिए आकार की नकल नहीं करना चाहती.
सिर चार *, हम आकार की प्रतिलिपि बनाना चाहते हैं
तो हम sizeof (चार *) द्वारा इस गुणा करने के लिए जा रहे हैं.
वही यहाँ नीचे, सिर * sizeof (char *).
>> [छात्र] के बारे में क्या [अश्राव्य?]
यहाँ यह सही है?
[छात्र] नहीं, कि नीचे, आकार - सिर.
यहाँ यह सही [रोब बी]?
सूचक गणित.
कैसे सूचक गणित के लिए काम चल रहा है
यह स्वतः ही प्रकार है कि हम साथ काम कर रहे हैं के आकार के आधार पर पलता है.
बस यहाँ पर करना चाहते हैं, नया + (आकार - सिर)
वास्तव में और नए - सिर के आकार] के बराबर है
जब तक हम है कि सही ढंग से काम करने के लिए उम्मीद है,
क्योंकि अगर हम एक int सरणी के साथ काम कर रहे हैं, तो हम int द्वारा सूचकांक नहीं करते
या अगर यह 5 के आकार का है और आप 4 तत्व चाहते हैं, तो हम में सूचकांक
int सरणी [4].
आप नहींं [4] * int के आकार.
कि यह स्वतः ही संभालती है, और इस मामले
सचमुच बराबर है तो, ब्रैकेट वाक्यविन्यास
सिर्फ यह करने के लिए जैसे ही आप संकलन परिवर्तित किया जा जा रहा है.
कि कुछ आप कि के सावधान होने की जरूरत है
जब आप आकार जोड़ रहे हैं - सिर
तुम नहीं एक बाइट जोड़ रहे हैं.
आप एक चार * जोड़ रहे हैं, जो एक बाइट या जो कुछ भी हो सकता है.
>> अन्य प्रश्न?
ठीक है, विपंक्ति के लिए आसान होने जा रहा है.
मैं आप एक मिनट के लागू करने के लिए दे देंगे.
ओह, और मुझे लगता है कि यह एक ही स्थिति है, जहां
क्या enqueue मामले, अगर हम बातिल enqueuing रहे हैं,
शायद हम इसे संभाल करने के लिए करना चाहते हैं, शायद हम नहीं करते.
हम इसे फिर से नहीं करना यहाँ होगा, लेकिन हमारे ढेर मामले के रूप में एक ही है.
यदि हम अशक्त enqueue, हम इसे उपेक्षा करना चाहते हो सकता है.
किसी को कुछ कोड मैं खींच सकते हैं?
[छात्र] मैं सिर्फ विपंक्ति है.
2 संस्करण है कि ठीक है.
आप को समझाना चाहता हूँ?
[छात्र] सबसे पहले, आप सुनिश्चित करें कि वहाँ कतार में कुछ है
और कि आकार 1 से नीचे जा रहा है.
तुम क्या करने की जरूरत है, और फिर आप सिर वापस
और फिर 1 सिर के ऊपर ले जाने के.
ठीक है, तो वहाँ एक कोने मामले में हम पर विचार करने के लिए है. हाँ.
[छात्र] यदि पिछले तत्व अपने सिर पर है,
तो आप सिर सरणी के बाहर बात करने के लिए नहीं करना चाहती.
>> हाँ, तो सिर के रूप में जल्द से जल्द हमारी सरणी के अंत हिट,
जब हम विपंक्ति, हमारे सिर 0 वापस modded चाहिए.
दुर्भाग्य से, हम है कि एक चरण में नहीं कर सकते हैं.
मुझे लगता है कि जिस तरह से मैं शायद यह तय है
यह करने के लिए एक चार * होने जा रहा है, हम क्या लौट रहे हैं,
जो कुछ भी अपने चर नाम होना चाहता है.
तो फिर हम हमारी क्षमता से सिर आधुनिक चाहते
और फिर लौटने के भिगोरना.
लोगों का एक बहुत यहाँ वे कर सकता है
यह you'll के मामले देखने के लिए लोग करते हैं अगर सिर
क्षमता से अधिक है, सिर - क्षमता.
और कहा कि सिर्फ आधुनिक क्या है के आसपास काम कर रहा है.
प्रमुख आधुनिक = क्षमता बहुत क्लीनर है
क्षमता है. अगर सिर क्षमता सिर से अधिक की तुलना में लगभग एक रैपिंग
>> प्रश्न?
ठीक है, आखिरी बात हम छोड़ दिया है हमारे लिंक सूची है.
आप लिंक सूची व्यवहार के कुछ करने के लिए इस्तेमाल किया जा सकता है अगर तुम नहीं किया
अपने हैश तालिका में सूची जुड़ा है, अगर आप एक हैश तालिका किया.
मैं दृढ़ता से एक हैश तालिका करने की सलाह देते हैं.
आप पहले से ही एक trie किया हो सकता है,
लेकिन कोशिश करता है और अधिक कठिन हैं.
सिद्धांत रूप में, वे asymptotically बेहतर कर रहे हैं.
लेकिन सिर्फ बड़े बोर्ड पर देखो,
की कोशिश करता है और बेहतर कभी नहीं, और वे और अधिक स्मृति ले.
सब कुछ के बारे में बदतर और अधिक काम करने के लिए किया जा रहा समाप्त होता है की कोशिश करता है.
यह डेविड Malan समाधान हमेशा क्या है
वह हमेशा अपने trie समाधान पदों, और देखते हैं जहां वह वर्तमान में है.
वह क्या के तहत किया गया था, डेविड जे?
वह # 18 है, इसलिए, कि बहुत बुरा नहीं है,
और कि सर्वश्रेष्ठ में से एक होने जा रहा है आप के बारे में सोच सकते हैं की कोशिश करता है
या एक सर्वश्रेष्ठ में से एक trie की कोशिश करता है.
यह अपने मूल समाधान भी नहीं है?
मुझे लगता है कि trie समाधान करने के लिए राम के उपयोग की इस श्रेणी में अधिक हो जाते हैं.
>> बहुत ऊपर नीचे जाओ, और राम उपयोग एकल अंक में है.
नीचे की ओर नीचे जाओ, और फिर आप देख कोशिश करता है शुरू
, जहाँ आप बिल्कुल विशाल रैम उपयोग हो
और कोशिश करता है और अधिक कठिन हैं.
लेकिन यह एक शैक्षिक अनुभव के लायक पूरी तरह से अगर आप एक किया.
आखिरी बात हमारे लिंक सूची है,
और इन तीन बातें, ढेर, कतार, और लिंक सूचियों,
भविष्य में किसी भी बात आप कभी कंप्यूटर विज्ञान में है
आप इन सब बातों के साथ परिचित है मान जाएगा.
वे सिर्फ इतना सब कुछ करने के लिए मौलिक हैं.
>> सूचियों लिंक, और यहाँ हम एक अकेले लिंक सूची हमारे कार्यान्वयन किया जा रहा है.
क्या अकेले जुड़ा हुआ करता है मतलब है रूप में दोगुना जुड़ा हुआ विरोध? हां.
[छात्र] यह अगले सूचक के बजाय संकेत करने के लिए कहते हैं,
यह पूर्ववर्ती और इसके बाद एक एक की तरह.
हाँ, तो चित्र प्रारूप में, मैं अभी क्या क्या किया?
मैं दो बातें हैं. मैं चित्र और तस्वीर है.
चित्र प्रारूप में, हमारे अकेले जुडी हुई सूचियों,
अनिवार्य रूप से, हम हमारी सूची के सिर के सूचक का किसी तरह का है,
और फिर हमारी सूची के भीतर, हम सिर्फ संकेत है,
और शायद इस अंक को अशक्त करने के लिए.
यह एक अकेले लिंक सूची के अपने ठेठ ड्राइंग होने जा रहा है.
युग्मबंधित सूची, आप पीछे की ओर जा सकते हैं.
अगर मैं तुम्हें सूची में किसी भी नोड दे, तो आप जरूरी प्राप्त कर सकते हैं
किसी भी अन्य नोड सूची में अगर यह एक युग्मबंधित सूची है.
लेकिन अगर मैं आप इस सूची में तीसरे नोड मिलता है और यह एक अकेले लिंक सूची है,
कोई रास्ता नहीं है कि आप कभी भी 1 और 2 नोड्स के लिए ले जा रहे हैं.
और वहाँ लाभ और detriments, और एक स्पष्ट एक है
आप अधिक आकार लेने के लिए, और आप लिए जहां अब इन बातों से इशारा कर रहे हैं का ट्रैक रखने के लिए है.
लेकिन हम केवल परवाह के बारे में अकेले जुड़ा हुआ है.
>> कुछ बातें हम को लागू करने के लिए जा रहे हैं.
आपकी typedef struct नोड, int i: struct नोड * अगले; नोड.
अपने मन में यही typedef जला दिया जाना चाहिए.
प्रश्नोत्तरी 1 एक लिंक सूची नोड के एक typedef दे की तरह होना चाहिए,
और आप तुरंत कि नीचे घसीटना के लिए सक्षम होना चाहिए
बिना भी इसके बारे में सोच रही है.
मैं कुछ सवाल लगता है, हम यहाँ struct आवश्यकता क्यों है?
हम नोड * कहते हैं क्यों नहीं कर सकते?
[छात्र] [अश्राव्य]
हाँ.
केवल एक चीज है कि एक बात एक नोड के रूप में परिभाषित करता है
ही typedef है.
लेकिन इस बिंदु के रूप में, जब हम इस struct नोड परिभाषा के माध्यम से पार्सिंग के तरह कर रहे हैं
हम अभी तक हमारे typedef नहीं समाप्त कर दिया है, के बाद से तो typedef समाप्त नहीं हुआ है,
नोड मौजूद नहीं है.
लेकिन struct नोड करता है, और यहाँ में, इस नोड
यह भी कुछ और कहा जा सकता है.
यह n बुलाया जा सकता है.
यह लिंक्ड सूची नोड कहा जा सकता है.
यह कुछ भी कहा जा सकता है.
लेकिन इस struct नोड इस struct नोड के रूप में एक ही बात कहा जा जरूरत है.
, आप क्या कहते हैं यह भी यहाँ है
और इसलिए भी है कि प्रश्न के दूसरे बिंदु का जवाब
जो कारण है कि एक बार जब आप structs और structs की typedefs देखते हैं बहुत,
आप गुमनाम structs देख जहाँ आप सिर्फ typedef struct देखेंगे,
struct, शब्दकोश, या जो कुछ भी के कार्यान्वयन.
>> यहाँ क्यों हम को नोड कहने की क्या ज़रूरत है?
यह एक गुमनाम struct क्यों नहीं हो सकता?
यह लगभग एक ही जवाब है.
[छात्र] आप struct भीतर यह उल्लेख करने की जरूरत है.
हाँ, संरचना के भीतर, आप struct ही उल्लेख करने की आवश्यकता है.
यदि आप struct एक नाम देना नहीं है, अगर यह एक गुमनाम struct है, आप इसे करने के लिए नहीं उल्लेख कर सकते हैं.
और पिछले लेकिन इन सब किया जाना चाहिए कम से कम कुछ हद तक सरल नहीं है,
और वे तुम्हें एहसास मदद से यदि आप इस नीचे लिख रहे हैं चाहिए
कि आप कुछ गलत कर रहे हैं, अगर इन चीजों की तरह से कोई मतलब नहीं है.
पिछले नहीं बल्कि कम से कम, क्यों इस struct नोड * है?
क्यों यह सिर्फ नोड नहीं struct किया जा सकता है?
[छात्र] अगले struct सूचक.
यह अनिवार्य रूप से है कि हम क्या चाहते हैं.
यह क्यों struct अगले नोड कभी नहीं हो सकता है?
यह struct * अगले नोड क्यों है? हाँ.
[छात्र] यह एक अनंत लूप की तरह है.
हाँ.
[छात्र] यह सब एक में होगा.
हाँ, बस के बारे में सोच कैसे हम आकार या कुछ करना होगा.
एक struct का आकार मूलतः + या - कुछ यहाँ या वहाँ पैटर्न.
यह मूल रूप से struct में चीजों के आकार का योग होने जा रहा है.
यहाँ यह सही है, कुछ भी बदलने के बिना, आकार आसान होने जा रहा है.
Struct नोड के आकार के लिए मैं अगले + आकार के आकार का होने जा रहा है.
मैं का आकार 4 होने जा रहा है. अगले का आकार 4 होने जा रहा है.
Struct नोड का आकार 8 होने जा रहा है.
यदि हम * नहीं है, के बारे में सोच sizeof,
तो sizeof (i) 4 होने जा रहा है.
Struct नोड का आकार अगले मैं के आकार + struct अगले नोड के आकार होने जा रहा है
मैं struct अगले नोड के आकार के आकार.
यह नोड्स के एक अनंत recursion होगा.
यही कारण है कि यह है कि कैसे चीजें होने.
>> फिर, निश्चित रूप से है कि याद है,
या कम से कम यह पर्याप्त समझते हैं कि आप करने में सक्षम हो सकता है
यह कैसा दिखना चाहिए के माध्यम से कारण.
बातें हम करने के लिए लागू करना चाहते हैं के लिए जा रहे हैं.
यदि सूची की लंबाई
आप को धोखा देने और एक के आसपास रख सकता है
वैश्विक लंबाई या कुछ और, लेकिन हम ऐसा करने के लिए नहीं जा रहे हैं.
हम सूची की लंबाई की गणना करने के लिए जा रहे हैं.
हम होता है तो, है कि मूल रूप से एक खोज की तरह है,
तो हम पूर्णांकों की एक लिंक सूची देखने के लिए अगर यह पूर्णांक लिंक सूची में है.
प्रीपेंड सूची के शुरुआत में सम्मिलित करने के लिए जा रहा है.
संलग्न अंत में सम्मिलित करने के लिए जा रहा है.
Insert_sorted सूची में क्रमबद्ध स्थिति में डालने के लिए जा रहा है.
के Insert_sorted तरह मानता है कि आप प्रयोग किया जाता है या कभी नहीं प्रीपेंड बुरे तरीके में परिशिष्ट के रूप में लगाना.
>> Insert_sorted जब आप insert_sorted लागू कर रहे हैं
हम कहते हैं कि हम हमारे लिंक सूची है.
यह वही है जो वर्तमान की तरह, 2, 4, 5 दिखता.
मैं 3 सम्मिलित करते हैं, तो जब तक सूची के रूप में ही पहले से ही हल करना चाहते हैं,
यह आसान है खोजने के लिए जहां 3 अंतर्गत आता है.
मैं 2 में शुरू करते हैं.
ठीक है, तीन दो से अधिक है, तो मैं जा रहा रखना चाहते हैं.
ओह, 4 बहुत बड़ी है, तो मुझे पता है कि 3 2 और 4 के बीच में जाना जा रहा है,
और मैं संकेत और वह सब सामान ठीक कर दिया है.
लेकिन अगर हम कड़ाई insert_sorted का उपयोग नहीं किया था,
की तरह चलो बस का कहना है कि मैं 6 prepend,
तो मेरे लिंक्ड सूची बनने जा रहा है.
अब यह नहीं समझ में आता है, तो insert_sorted लिए, तुम सिर्फ मान सकते हैं
कि सूची हल है, भले ही आपरेशन मौजूद
जो इसे हल नहीं किया जा करने के लिए पैदा कर सकते हैं, और यह बात है.
एक सहायक डालने तो उन मुख्य बातें आप को लागू करने के लिए जा रहे हैं.
>> अभी के लिए, एक मिनट लेने के लिए लंबाई और होता है,
और उन अपेक्षाकृत जल्दी होना चाहिए.
बंद करने के समय में होने जा रही है, तो किसी को भी लंबाई के लिए कुछ भी है या शामिल हैं?
वे लगभग समान होने के लिए जा रहे हैं.
[छात्र] अवधि.
चलो देखते हैं, संशोधन.
ठीक है.
आप को समझाना चाहता हूँ?
[छात्र] मैं सिर्फ एक सूचक नोड बनाने और यह 1, जो हमारे वैश्विक चर इनिशियलाइज़
और फिर मैं देखने के लिए अगर यह शून्य है तो मैं एक seg गलती नहीं मिलता है और 0 वापसी है कि अगर मामला है.
अन्यथा, मैं के माध्यम से पाश, पूर्णांक भीतर का ट्रैक रखने
कितनी बार मैं सूची के अगले तत्व पहुँचा है
और एक ही वेतन वृद्धि ऑपरेशन में यह भी है कि वास्तविक तत्व का उपयोग करने के लिए,
और फिर मैं लगातार चेक देखने के लिए अगर यह शून्य है,
और अगर यह शून्य है, तो यह aborts और सिर्फ तत्वों मैं पहुँचा है की संख्या देता है.
>> [रोब बी] किसी को कुछ भी पर कोई टिप्पणी है?
यह लग रहा है ठीक शुद्धता बुद्धिमान.
[छात्र] मुझे नहीं लगता कि आप == नोड अशक्त की जरूरत है.
हाँ, तो अगर नोड == अशक्त वापसी 0.
लेकिन अगर नोड == बातिल तो यह ओह, वहाँ एक शुद्धता मुद्दा है.
यह था सिर्फ तुम और मैं लौट रहे हैं, लेकिन यह दायरे में अभी नहीं है.
तुम सिर्फ int i की जरूरत है, तो मैं = 0.
लेकिन अगर नोड अशक्त है, तो मैं अभी भी 0 हो जा रहा है,
और हम 0 वापसी करने जा रहे हैं तो, इस मामले के समान है.
एक अन्य आम बात घोषणा रखने के लिए है
पाश के लिए अंदर के नोड की.
आप कहते हैं कि ओह सकता है, नहीं.
चलो इसे इस रूप में रहते हैं.
मैं शायद int i = 0 यहाँ रखा जाएगा,
तो नोड * नोड = यहाँ 1.
और यह शायद अब इस से छुटकारा कैसे हो रही है.
शायद यह है कि मैं कैसे यह लिखा होता है.
आप इसे इस तरह भी देख सकता है.
पाश संरचना के लिए सही यहाँ यह
लगभग int i = 0 के रूप में आप प्राकृतिक होना चाहिए
मैं सरणी की लंबाई की तुलना में कम है मैं + +.
अगर है कि कैसे आप एक सरणी पर पुनरावृति, यह है कि आप एक लिंक सूची पर पुनरावृति.
>> यह कुछ बिंदु पर 2 प्रकृति का होना चाहिए.
साथ कि दिमाग में, यह लगभग एक ही बात होने जा रहा है.
आप करने के लिए एक लिंक सूची पुनरावृति करना चाहते करने के लिए जा रहे हैं.
नोड मैं पता नहीं क्या मूल्य कहा जाता है.
मैं नोड.
यदि उस नोड पर मूल्य = मैं वापसी सच है, और यह बात है.
सूचना है कि एक ही तरीका हम कभी झूठी वापसी
अगर हम पूरे लिंक की गई सूची से अधिक पुनरावृति और वापस कभी नहीं सच है,
इतना है कि यह क्या करता है.
एक तरफ ध्यान दें हम शायद संलग्न या prepend नहीं मिलेगा.
>> त्वरित अंतिम ध्यान दें.
यदि आप स्थिर कीवर्ड देखते हैं, तो चलो स्थैतिक int गिनती = 0 कहते हैं,
तो हम गिनती नहीं है + +, आप मूल रूप से एक वैश्विक चर के रूप में यह सोचने के लिए कर सकते हैं,
हालांकि मैं सिर्फ यह कहा है कि हम कैसे लंबाई को लागू करने के लिए जा रहे हैं नहीं.
मैं यह कर रहा हूँ यहाँ, और फिर + + गिनती.
किसी भी तरह से हम हम हमारी गिनती incrementing रहे हैं हमारे लिंक्ड सूची में एक नोड में प्रवेश कर सकते हैं.
इस की बात यह है कि स्थिर कीवर्ड का मतलब क्या है.
अगर मैं सिर्फ int गिनती = 0 है कि एक नियमित रूप से पुराने वैश्विक चर होगा.
स्थैतिक int गिनती मतलब क्या यह है कि यह इस फ़ाइल के लिए एक वैश्विक चर है.
यह किसी अन्य फ़ाइल के लिए असंभव है,
5 pset के बारे में सोच की तरह, अगर आप शुरू कर दिया है.
आप दोनों speller.c है, और आप dictionary.c है,
और अगर तुम सिर्फ एक वैश्विक बात की घोषणा तो speller.c में कुछ भी
dictionary.c और इसके विपरीत में पहुँचा जा सकता है.
वैश्विक चर. किसी भी सी फ़ाइल से सुलभ हैं,
लेकिन स्थैतिक चर ही फाइल के भीतर से ही उपलब्ध हैं,
तो जादू चेकर या dictionary.c के अंदर के अंदर,
यह कैसे मैं अपने सरणी के आकार के लिए मेरे चर घोषित होगा की तरह है
या मेरे शब्दकोश में शब्दों की संख्या के आकार.
के बाद से मैं एक वैश्विक चर घोषणा की है कि किसी को भी करने के लिए उपयोग नहीं करना चाहते,
मैं वास्तव में केवल अपने उद्देश्यों के लिए इसके बारे में परवाह है.
>> इस बारे में अच्छी बात यह भी पूरे नाम टक्कर के सामान है.
यदि कुछ अन्य फ़ाइल के लिए एक वैश्विक चर बुलाया गिनती का उपयोग करने की कोशिश करता है, बातें बहुत, बहुत गलत जाना,
तो यह अच्छी तरह से चीजों को सुरक्षित रखता है, और केवल आप इसे उपयोग कर सकते हैं,
और कोई नहीं, और अगर किसी और एक वैश्विक चर बुलाया गिनती की घोषणा कर सकते हैं,
तो यह अपने स्थैतिक चर बुलाया गिनती के साथ हस्तक्षेप नहीं करेगा.
यही कारण है कि स्थिर क्या है. यह एक फ़ाइल वैश्विक चर है.
>> कुछ पर प्रश्न?
सब तैयार है. अलविदा.
[CS50.TV]