[Powered by Google Translate] [समीक्षा] प्रश्नोत्तरी [0]
>> [Lexi रॉस, टॉमी MacWilliam, लुकास Freitas, यूसुफ Ong] [हार्वर्ड विश्वविद्यालय]
>> [यह CS50 है.] [CS50.TV]
>> अरे, सब लोग.
0 प्रश्नोत्तरी, जो इस जगह बुधवार ले जा रहा है के लिए समीक्षा सत्र के लिए आपका स्वागत है.
आज रात हम क्या करने जा रहे हैं, मैं 3 अन्य TFS के साथ हूँ,
और हम एक साथ हम पाठ्यक्रम में क्या किया है अब तक की एक समीक्षा के माध्यम से जाने के लिए जा रहे हैं.
यह 100% व्यापक होने नहीं जा रहा है, लेकिन इसे आप एक बेहतर विचार देना चाहिए
क्या आप पहले से ही नीचे है और क्या आप अभी भी अध्ययन करने के लिए बुधवार से पहले की जरूरत है.
और सवालों के साथ अपने हाथ उठाने के लिए स्वतंत्र महसूस हो रहा है जैसा कि हम साथ जा रहे हैं,
लेकिन ध्यान में रखना है कि हम भी समय का एक छोटा सा होगा अंत
अगर हम कुछ मिनट के साथ के माध्यम से मिलता है स्पेयर करने के लिए सामान्य प्रश्नों करते हैं,
तो मन में रखने के लिए, और इसलिए हम 0 सप्ताह के शुरुआत में शुरू करने जा रहे हैं.
>> प्रश्नोत्तरी [0 समीक्षा!] भाग [0] [Lexi रॉस] लेकिन इससे पहले कि हम करते हैं कि चलो के बारे में बात करते हैं
प्रश्नोत्तरी के रसद.
>> [रसद] [क्विज़ / 10 10 बुधवार पर व्याख्यान के एवज में जगह लेता है]
>> [(विवरण के लिए http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf देखें)] यह बुधवार, 10 अक्तूबर है.
>> कि इस बुधवार है, और अगर आप इस URL यहाँ जाने के लिए,
जो भी CS50.net - वहाँ से सुलभ के लिए एक कड़ी यह
आप देख सकते हैं जहां के आधार पर जाने के बारे में जानकारी
अपने अंतिम नाम या स्कूल की मान्यता के रूप में के रूप में अच्छी तरह से
यह प्रश्नोत्तरी के बारे में वास्तव में क्या कवर और प्रश्नों के प्रकार है कि आप को मिल जा रहे हैं बताता है.
ध्यान में रखें कि आप भी एक अनुभाग में प्रश्नोत्तरी के लिए समीक्षा करने का मौका होगा,
तो अपने TFS कुछ अभ्यास समस्याओं पर चल रहा होना चाहिए,
और कहा कि एक और अच्छा मौका देखने के लिए जहां आप अभी भी प्रश्नोत्तरी के लिए अध्ययन की जरूरत है.
बिट्स 'n बाइट्स के साथ शुरुआत में चलो शुरू करो.
याद है एक सा ही एक 0 या 1 एक है,
और एक बाइट 8 उन बिट्स के एक संग्रह है.
बिट्स के इस संग्रह में सही यहाँ देखो.
हम कितने बिट्स के लिए बाहर आंकड़ा करने में सक्षम होना चाहिए.
हम कहाँ गिनती वहाँ सिर्फ 8 उनमें से आठ 0 या 1 यूनिट.
और के बाद से वहाँ 8 बिट, कि 1 बाइट है,
और यह हेक्साडेसिमल में बदलने.
हेक्साडेसिमल 16 आधार है, और यह बहुत आसान है कन्वर्ट करने के लिए
बाइनरी में एक नंबर है, जो कि क्या है हेक्साडेसिमल में एक संख्या है.
हम सभी कर हम 4 के समूहों को देखो,
और हम उन्हें उचित षोडश आधारी अंकों के साथ परिवर्तित.
हम 4 के अधिकार सबसे समूह के साथ शुरू करते हैं, इतना 0011.
यह एक 1 और 2 एक हो सकता है, तो एक साथ कि 3 बनाता जा रहा है.
और फिर हम 4 के अन्य ब्लॉक में देखने.
1101. कि एक 1, एक 4, 8 और एक होने जा रहा है.
कि एक साथ 13 हो सकता है, जो डी. बनाता जा रहा है
और हम याद करेंगे हेक्ज़ाडेसिमल में हम सिर्फ 9 के माध्यम से 0 नहीं जाना है.
हम 0 एफ के माध्यम से जाना, 9 इतना होने के बाद, एक को 10 से मेल खाती है,
11 बी, वगैरह जहां एफ 15 है.
13 यहाँ एक डी है,
तो यह दशमलव कन्वर्ट करने के लिए हम क्या हम वास्तव में है
2 की एक शक्ति के रूप में प्रत्येक स्थिति का इलाज.
यह एक 1, 2, एक शून्य 4s, 8s शून्य, एक 16, वगैरह है,
और यह एक छोटे से अपने सिर में गणना करने के लिए मुश्किल है, लेकिन अगर हम अगली स्लाइड पर जाना
हम देख सकते हैं कि जवाब.
>> मूलतः हम सही से भर में वापस छोड़ दिया करने के लिए जा रहे हैं,
और हम 2 की इसी शक्ति के द्वारा प्रत्येक अंक बढ़ रहे हैं.
और याद है, हेक्सादशमलव के लिए हम 0x के साथ शुरुआत में इन नंबरों को निरूपित करने के लिए
इसलिए हम इसे एक दशमलव संख्या के साथ भ्रमित नहीं है.
पर, यह एक ASCII तालिका है,
और क्या हम के लिए ASCII का उपयोग करने के लिए अक्षर से संख्यात्मक मूल्यों मैप है.
क्रिप्टोग्राफी pset में याद है हम ASCII तालिका का व्यापक उपयोग किया
आदेश में क्रिप्टोग्राफी के विभिन्न तरीकों का उपयोग करने के लिए,
कैसर और Vigenère बीजलेख, अलग पत्र में परिवर्तित
उपयोगकर्ता द्वारा दिए गए कुंजी के अनुसार एक स्ट्रिंग में.
चलो ASCII गणित का एक छोटा सा पर देखने के.
पर 'पी' में चरित्र फार्म का है कि क्यू होगा 1 + खोज रहे हैं,
याद और '5 '≠ 5 कि.
और वास्तव में हम कैसे उन 2 रूपों के बीच परिवर्तित होता है?
यह वास्तव में बहुत मुश्किल नहीं है.
5 क्रम में पाने के लिए हम घटाना '0 '
क्योंकि वहाँ '0 के बीच 5 स्थानों रहे हैं और '5.
आदेश में अन्य जिस तरह से हम सिर्फ 0 जोड़ने जाने के लिए,
तो यह नियमित रूप से गणित की तरह तरह की है.
बस याद है कि जब यह चारों ओर कुछ उद्धरण है यह एक चरित्र है
और इस प्रकार ASCII तालिका में एक मूल्य के लिए मेल खाती है.
अधिक सामान्य कंप्यूटर विज्ञान विषयों में चल रहा है.
हमने सीखा है कि एक एल्गोरिथ्म है क्या और कैसे हम प्रोग्रामिंग का उपयोग
एल्गोरिदम को लागू.
एल्गोरिदम के कुछ उदाहरणों में सच की तरह कुछ सरल कर रहे हैं
जाँच कर रहा है कि क्या एक भी या विषम संख्या है.
के लिए याद है कि हम 2 द्वारा संख्या आधुनिक और जांच यदि परिणाम 0 है.
यदि हां, तो यह भी है. यदि नहीं, तो यह अजीब है.
और कहा कि वास्तव में एक बुनियादी एल्गोरिथ्म का एक उदाहरण है.
>> एक और अधिक शामिल एक का एक छोटा सा द्विआधारी खोज है,
जो हम पर समीक्षा सत्र में बाद में जाना होगा.
और प्रोग्रामिंग अवधि हम एक एल्गोरिथ्म लेने के लिए उपयोग
और यह कंप्यूटर कोड परिवर्तित पढ़ सकते हैं.
प्रोग्रामिंग के 2 उदाहरण स्क्रैच है,
जो है हम क्या 0 सप्ताह में किया.
हालांकि हम वास्तव में बाहर नहीं कोड लिखें कि इसे लागू करने के लिए एक रास्ता है
इस एल्गोरिथ्म, जो संख्या 1-10 मुद्रण है,
और यहाँ हम सी प्रोग्रामिंग भाषा में ही करते हैं.
ये कार्यात्मक समकक्ष, सिर्फ अलग अलग भाषाओं या वाक्य रचना में लिखा हैं.
हम तो बूलीय अभिव्यक्ति के बारे में सीखा है,
और एक बूलीयन एक मूल्य है कि या तो सही है या गलत है,
और यहाँ बार बार बूलियन अभिव्यक्ति
शर्तों के अंदर जाने के लिए, यदि ऐसा है तो (x ≤ 5),
ठीक है, हम पहले से ही निर्धारित x = 5 तो, उस हालत को सच करने के लिए मूल्यांकन के लिए जा रहा है.
और अगर यह सच है, जो कुछ भी कोड हालत नीचे है
कंप्यूटर द्वारा मूल्यांकन किया जा रहा है, इतना है कि स्ट्रिंग मुद्रित किया जा रहा है
मानक उत्पादन, और शब्द हालत
बयान अगर कोष्ठक के अंदर जो कुछ भी करने के लिए संदर्भित करता है.
सभी ऑपरेटर्स को याद रखें.
| | गठबंधन जब हम कोशिश कर रहे हैं के लिए 2 या अधिक की स्थिति, यह && और याद रखें
== नहीं = जाँच करें कि क्या 2 बातों के समान हैं.
याद रखें कि = काम के लिए है जबकि == एक बूलियन ऑपरेटर है.
≤, ≥ और फिर अंतिम 2 आत्म व्याख्यात्मक हैं.
बूलीयन तर्क का एक सामान्य समीक्षा यहाँ.
और बूलियन अभिव्यक्ति भी loops में महत्वपूर्ण हैं,
जो हम अब खत्म हो जाना होगा.
हम loops के 3 प्रकार के बारे में अब तक CS50 में सीखा के लिए है, जबकि, और करते हैं, जबकि.
और यह जानना महत्वपूर्ण है कि जबकि सबसे प्रयोजनों के लिए
हम वास्तव में पाश के किसी भी प्रकार के आम तौर पर उपयोग कर सकते हैं
वहाँ आम पैटर्न या उद्देश्यों के कुछ प्रकार के होते हैं
प्रोग्रामिंग है कि विशेष रूप से इन loops के लिए कॉल में
कि इसे बनाने के लिए सबसे कुशल या यह है कि रास्ते में कोड सुरुचिपूर्ण.
चलो खत्म हो जाना क्या इन loops के प्रत्येक के लिए सबसे अधिक बार इस्तेमाल किया जा जाता है.
>> एक पाश के लिए हम आम तौर पर पहले से ही पता है कि कितनी बार हम पुनरावृति करने के लिए करना चाहते हैं.
यही कारण है कि हम क्या हालत में डाल दिया.
के लिए, मैं = 0, मैं <10, उदाहरण के लिए.
हम पहले से ही जानते हैं कि हम करने के लिए 10 बार कुछ करना चाहते हैं.
अब, एक समय पाश के लिए, आम तौर पर हम जरूरी नहीं करते
पता है कि कितनी बार हम पाश को चलाने के लिए करना चाहते हैं.
लेकिन हम हालत के कुछ प्रकार जानते हैं कि हम यह चाहते हैं
हमेशा सच हो या हमेशा गलत हो सकता है.
उदाहरण के लिए, जबकि सेट कर दिया जाता है.
चलो का कहना है कि एक बूलीयन चर है.
हालांकि यह सच है कि हम कोड का मूल्यांकन करने के लिए करना चाहते हैं,
तो एक छोटा सा अधिक एक्स्टेंसिबल पाश के लिए एक छोटे से अधिक एक सामान्य की तुलना में थोड़ा,
लेकिन पाश के लिए किसी भी एक समय पाश में बदला जा सकता है.
अंत में करते हैं, जबकि loops, जो trickiest सही दूर समझ सकता है,
अक्सर इस्तेमाल किया जाता है जब हम कोड पहले से मूल्यांकन करना चाहते हैं
पहली बार इससे पहले कि हम स्थिति की जाँच करें.
एक के लिए एक आम उपयोग के मामले जबकि पाश
जब आप उपयोगकर्ता इनपुट प्राप्त करना चाहते है, और आप जानते हैं कि आप उपयोगकर्ता पूछना चाहता हूँ
इनपुट के लिए एक ही बार में कम से कम है, लेकिन अगर वे तुम्हें अच्छा इनपुट देना नहीं है सही दूर
आप उन्हें पूछ जब तक वे तुम्हें अच्छा इनपुट दे रखना चाहते हैं.
यह एक के सबसे आम उपयोग जबकि पाश है,
और इन छोरों के वास्तविक संरचना में देखो.
वे आम तौर पर हमेशा के लिए इन पैटर्न का पालन करते हैं.
>> अंदर के लिए पाश में आप 3 घटक है:
initialization तरह आम तौर पर कुछ int i = 0 जहाँ मैं काउंटर है,
हालत है, जहां हम कहने के लिए पाश के लिए इस दौड़ इस हालत अभी भी धारण के रूप में लंबे समय के रूप में करना चाहते हैं,
मैं 10 <, और फिर अंत में, अद्यतन, जो है हम कैसे वेतन वृद्धि की तरह
पाश में प्रत्येक बिंदु पर काउंटर चर.
वहाँ देखने के के लिए एक आम बात सिर्फ मैं + +,
जो मैं 1 द्वारा हर बार वेतन वृद्धि का मतलब है.
आप भी मैं + = 2 की तरह कुछ कर सकता है,
जिसका मतलब है कि मैं 2 हर बार जब आप पाश के माध्यम से जाना जोड़ने.
और फिर यह सिर्फ किसी भी कोड है कि वास्तव में पाश के भाग के रूप में चलाता है को संदर्भित करता है.
और एक समय पाश के लिए, इस समय हम वास्तव में लूप के बाहर initialization है,
तो उदाहरण के लिए, चलो कहना है कि हम पाश के एक ही प्रकार के रूप में मैं सिर्फ वर्णित करने की कोशिश कर रहे हैं.
हम कहेंगे int i = 0 पहले पाश शुरू होता है.
तो हम जब मैं 10 <यह क्या कह सकते हैं,
तो इससे पहले के रूप में कोड की एक ही ब्लॉक,
और इस बार कोड की अद्यतन उदाहरण के लिए, भाग, मैं + +,
वास्तव में पाश के अंदर चला जाता है.
और अंत में, के लिए करते हैं, जबकि यह जबकि पाश के लिए इसी तरह की है,
लेकिन हमें याद है कि एक बार कोड का मूल्यांकन करेंगे
हालत से पहले जाँच की है, तो यह एक बहुत अधिक समझ में आता है
अगर आप ऊपर से नीचे के क्रम में इसे देखो.
में एक जबकि पाश कोड का मूल्यांकन से पहले आप भी जबकि हालत में देखने के,
जबकि एक समय पाश, यह पहले की जाँच करता है.
विवरण और चर.
जब हम एक नया चर बनाने चाहते हैं हम पहली बार यह इनिशियलाइज़ चाहते हैं.
>> उदाहरण के लिए, int बार चर बार initializes,
लेकिन यह एक मूल्य नहीं दे करता है, तो क्या अब बार मूल्य है?
हम नहीं जानते.
यह कुछ कचरा मूल्य है कि पहले स्मृति में किया गया था वहाँ जमा हो सकता है,
और हम उस चर का उपयोग नहीं करना चाहते
जब तक हम वास्तव में यह एक मूल्य दे,
इसलिए हम इसे यहाँ की घोषणा.
तो फिर हम यह नीचे 42 इनिशियलाइज़.
अब, बेशक, हम जानते हैं कि इस लाइन पर एक, int = 42 बार किया जा सकता है.
लेकिन सिर्फ कई कदम है कि पर जा रहे हैं स्पष्ट करने के लिए,
घोषणा और आरंभीकरण अलग यहाँ हो रही हैं.
यह एक कदम पर होता है, और अगले एक, int baz बार = 1 +,
नीचे इस बयान है, तो इस कोड ब्लॉक के अंत में कि वेतन वृद्धि baz,
अगर हम baz के मूल्य मुद्रित थे यह 44 होगा
क्योंकि हम घोषणा और इसे प्रारंभ करने के लिए 1> बार,
और फिर हम इसके साथ एक बार और अधिक वेतन वृद्धि + +.
हम इस सुंदर संक्षेप में खत्म हो गया था, लेकिन यह अच्छा है करने के लिए एक सामान्य
धागे और घटनाओं क्या कर रहे हैं की समझ है.
हम मुख्य रूप से खरोंच में यह किया है,
ताकि आप कोड के कई दृश्यों के रूप में धागे के बारे में सोच सकते हैं
एक ही समय में चल रहा है.
वास्तविकता में, यह शायद एक ही समय में नहीं चल रहा है,
लेकिन सॉर्ट के सिद्धांत के रूप में हम यह है कि रास्ते में बारे में सोच सकते हैं.
>> स्क्रैच में, उदाहरण के लिए, हम कई sprites था.
यह एक ही समय में अलग कोड को क्रियान्वित करने जा सकता है.
एक, जबकि अन्य कुछ कह रहा है चलने जा सकता है
स्क्रीन के एक अलग हिस्से में.
घटनाक्रम बाहर तर्क को अलग करने का एक और तरीका है
अपने कोड के विभिन्न तत्वों के बीच,
और खरोंच में हम घटनाओं अनुकरण प्रसारण का उपयोग करने में सक्षम थे,
और कहा कि वास्तव में जब मैं प्राप्त मैं नहीं सुन जब,
लेकिन अनिवार्य रूप से यह जानकारी संचारित करने के के लिए एक तरीका है
एक प्रेत से दूसरे करने के लिए.
उदाहरण के लिए, आप इस खेल को संचारित करना चाहते हो सकता है,
और जब एक और प्रेत खेल खत्म प्राप्त करता है,
यह एक निश्चित तरीके से प्रतिक्रिया करता है.
यह प्रोग्रामिंग के लिए समझने के लिए एक महत्वपूर्ण मॉडल है.
बस बुनियादी 0 सप्ताह पर जाने के लिए, क्या हम पर चला गया है अब तक,
चलो इस साधारण सी कार्यक्रम में देखो.
पाठ यहाँ से एक छोटे से छोटा सा हो सकता है, लेकिन मैं इसे खत्म हो जाना बहुत जल्दी होगा.
हम 2 शीर्ष cs50.h, और stdio.h में हेडर फाइल सहित रहे हैं.
हम तो एक निरंतर बुलाया सीमा को परिभाषित कर रहे हैं 100 साल.
हम तो अपने मुख्य समारोह में लागू कर रहे हैं.
चूंकि हम कमांड लाइन तर्क यहाँ का उपयोग नहीं करते हम शून्य डाल की जरूरत है
मुख्य लिए तर्क के रूप में.
हम मुख्य ऊपर int देखते हैं. यह वापसी प्रकार है, इसलिए नीचे में 0 वापसी.
और हम CS50 पुस्तकालय समारोह का उपयोग कर रहे हैं int पाने के
इनपुट के लिए उपयोगकर्ता पूछने के लिए, और हम इसे इस चर x में स्टोर,
तो हम एक्स ऊपर घोषित, और हम इसे x = GetInt के साथ इनिशियलाइज़.
>> हम तो देखने के लिए अगर उपयोगकर्ता हमें अच्छा इनपुट दिया की जाँच करें.
यदि यह ≥ सीमा है हम 1 के एक त्रुटि कोड लौटने और एक त्रुटि संदेश प्रिंट चाहते हैं.
और अंत में, अगर उपयोगकर्ता हमें दिया है अच्छा निवेश
हम संख्या वर्ग और बाहर है कि परिणाम मुद्रित करने के लिए जा रहे हैं.
बस सुनिश्चित करने के लिए कि उन सभी घर मारा
आप यहाँ कोड के विभिन्न भागों के लेबल देख सकते हैं.
मैं निरंतर, हेडर फाइल में उल्लेख किया है.
ओह, int x. को याद है कि एक स्थानीय चर के लिए सुनिश्चित करें कि.
कि यह एक वैश्विक चर से विरोधाभासों, जो हम के बारे में बात करेंगे
बाद में एक छोटा सा समीक्षा सत्र में,
और हम पुस्तकालय समारोह printf बुला रहे हैं,
यदि ऐसा है तो हम stdio.h हैडर फ़ाइल शामिल नहीं था
हम printf कॉल करने में सक्षम नहीं होगा.
और मेरा मानना ​​है कि तीर है कि कट गया यहाँ% d इशारा कर रहा है,
जो printf में स्वरूपण स्ट्रिंग है.
इसे कहते हैं, बाहर संख्या,% d के रूप में इस चर मुद्रित.
और कहा कि यह 0 सप्ताह के लिए है.
अब लुकास के लिए जारी रखने के लिए जा रहा है.
हे, दोस्तों. मेरा नाम लुकास है.
मैं परिसर, माथर पर सबसे अच्छा घर में एक sophomore हूँ,
और मैं 1 सप्ताह और 2.1 के बारे में थोड़ा बहुत बात करने के लिए जा रहा हूँ.
[1 सप्ताह और 2.1] [लुकास Freitas]
के रूप में Lexi कह रहा था, जब हम खरोंच से सी के लिए अपने कोड का अनुवाद शुरू
एक चीजों की है कि हम देखा है कि आप बस नहीं कर सकते हैं
अपने कोड लिखने और इसे चलाने के लिए अब एक हरा झंडा का उपयोग कर.
असल में, आप के लिए कुछ कदम का उपयोग करने के लिए अपनी सी कार्यक्रम बनाना है
एक निष्पादन योग्य फ़ाइल बन जाते हैं.
असल में आप जब आप एक प्रोग्राम लिख रहे हैं क्या है कि
आप एक भाषा कि एक संकलक समझ सकता में अपने विचार अनुवाद
इसलिए जब आप सी में एक प्रोग्राम लिख रहे हैं
आप क्या कर रहे हैं वास्तव में कुछ लिख रहा है कि अपने संकलक समझने जा रहा है,
और तो संकलक कि कोड अनुवाद करने के लिए जा रहा है
कुछ है कि आपके कंप्यूटर को समझने में.
>> और बात है, अपने कंप्यूटर वास्तव में बहुत गूंगा है.
आपका कंप्यूटर केवल 0s और 1s समझ सकते हैं,
तो वास्तव में 1 कंप्यूटर में लोगों को आम तौर पर क्रमादेशित
0s और 1s, लेकिन अब और नहीं का उपयोग करते हुए, भगवान का शुक्र है.
हम 0s और 1s के लिए दृश्यों को याद नहीं है
पाश के लिए या एक जबकि पाश और इतने के लिए एक के लिए.
यही कारण है कि हम एक संकलक है.
एक संकलक क्या करता है, यह मूल रूप से सी कोड अनुवाद,
हमारे मामले में, एक भाषा है कि आपके कंप्यूटर को समझने के लिए,
जो वस्तु कोड, और संकलक है कि हम प्रयोग कर रहे है
है बजना कहा जाता है, तो यह वास्तव में बजना के लिए प्रतीक है.
जब आप अपने कार्यक्रम है, तो आप 2 बातें करने के लिए है.
सबसे पहले, आप अपने कार्यक्रम संकलन है, और फिर आप अपने कार्यक्रम को चलाने के लिए जा रहे हैं.
आप विकल्पों में से एक बहुत कुछ ऐसा करने के लिए अपने कार्यक्रम संकलन.
1 एक बजना इल्ली
जिसमें कार्यक्रम अपने कार्यक्रम का नाम है.
इस मामले में आप वे सिर्फ इतना कह रहे हैं देख सकते हैं "अरे, मेरे प्रोग्राम संकलन."
आप यह नहीं कह या कुछ भी "मैं अपने कार्यक्रम के लिए इस नाम करना चाहते हैं" कर रहे हैं.
>> दूसरा विकल्प अपने कार्यक्रम के लिए एक नाम दे रही है.
आप बजना - ओ और फिर नाम कह सकते हैं कि आप चाहते हैं
निष्पादन योग्य फ़ाइल के रूप में और फिर इल्ली का नाम दिया जाएगा.
और तुम भी कार्यक्रम बनाने के लिए करते हैं, कर सकते हैं और देखने के लिए पहले 2 मामलों में कैसे
मैं डाला. ग, और 3 एक में मैं ही कार्यक्रम है?
हाँ, तुम वास्तव में नहीं है. ग डाल दिया जब आप बनाने के लिए उपयोग करना चाहिए.
अन्यथा संकलक वास्तव में आप पर चिल्लाना जा रहा है.
और यह भी, मैं अगर तुम लोगों को याद नहीं पता नहीं है,
लेकिन कई बार हम भी या lm इस्तेमाल lcs50 का एक बहुत.
कि जोड़ने कहा जाता है.
यह सिर्फ संकलक बताता है कि आप उन पुस्तकालयों का उपयोग करेगा,
इसलिए यदि आप cs50.h का उपयोग करना चाहते हैं आप वास्तव में टाइप करने के लिए है
इल्ली - lcs50 बजना.
यदि आप ऐसा नहीं करते, संकलक पता करने के लिए नहीं जा रहा है
कि आप cs50.h. में उन कार्यों का उपयोग कर रहे हैं
और जब आप अपने कार्यक्रम चलाने के लिए आपके पास 2 विकल्प चाहते हैं.
यदि आप बजना इल्ली किया आप अपने कार्यक्रम के लिए एक नाम नहीं दिया.
आप इसे चलाने के a.out / का उपयोग है.
A.out एक मानक नाम है कि बजना अपने कार्यक्रम देता है अगर आप इसे एक नाम देना नहीं है.
अन्यथा आप / कार्यक्रम करने जा रहे हैं यदि आप अपने कार्यक्रम के लिए एक नाम दिया है,
और अगर आप भी कार्यक्रम नाम बनाने के लिए किया है कि एक कार्यक्रम के लिए पाने के लिए जा रहा है
पहले से ही ग फ़ाइल के रूप में एक ही नाम के प्रोग्राम किया जा रहा है.
तब हम डेटा प्रकार और डेटा के बारे में बात की थी.
>> मूल रूप से डेटा प्रकार छोटे बक्से वे उपयोग के रूप में एक ही बात कर रहे हैं
मूल्यों की दुकान है, तो डेटा प्रकार Pokémons तरह वास्तव में कर रहे हैं.
वे सभी आकार और प्रकार में आते हैं.
मैं अगर है कि सादृश्य समझ में आता है पता नहीं है.
डेटा आकार वास्तव में मशीन वास्तुकला पर निर्भर करता है.
सभी डेटा आकार है कि मैं यहाँ दिखाने के लिए जा रहा हूँ
एक 32-bit मशीन है, जो हमारे उपकरण के मामले के लिए वास्तव में कर रहे हैं,
लेकिन अगर आप वास्तव में अपने मैक या Windows में भी कोडिंग कर रहे हैं
शायद आप एक 64-bit मशीन के लिए जा रहे हैं,
इतना याद है कि डेटा आकार कि मैं जा रहा हूँ यहाँ दिखाने के लिए
32-bit मशीन के लिए कर रहे हैं.
पहली एक है कि हमने देखा कि एक int था,
जो बहुत सीधा है.
आप एक पूर्णांक की दुकान int का उपयोग करें.
हम भी चरित्र, चार देखा.
यदि आप एक पत्र या एक छोटे से प्रतीक का उपयोग करना चाहते हैं तो आप शायद एक चार का उपयोग करने के लिए जा रहे हैं.
चार 1 बाइट, जो 8 बिट जैसे Lexi कहा, का मतलब है.
असल में हम एक ASCII टेबल है कि 256 है
0s और 1s के संभव संयोजनों,
और फिर जब आप एक चार प्रकार अनुवाद करने के लिए जा रहा है
चरित्र है कि आप एक संख्या है कि आप ASCII तालिका में Lexi की तरह है, आदानों कहा.
हम भी नाव है, जो हम दशमलव नंबर स्टोर करने के लिए उपयोग किया है.
यदि आप 3.14 का चयन करना चाहते हैं, उदाहरण के लिए, आप एक नाव का उपयोग करने जा रहे हैं
या एक डबल है कि अधिक सटीक है.
एक नाव 4 बाइट्स है.
एक डबल 8 बाइट्स है, तो फर्क सिर्फ इतना सटीक है.
हम यह भी है कि एक लंबे integers के लिए प्रयोग किया जाता है,
और आप एक 32-bit मशीन को देखने के लिए एक int और एक लंबे समय के एक ही आकार के हो सकता है,
तो यह वास्तव में समझ में नहीं पड़ता है एक 32-bit मशीन में एक लंबे समय का उपयोग करें.
>> लेकिन अगर आप एक मैक और 64-bit मशीन का उपयोग कर रहे हैं, वास्तव में एक लंबा 8 आकार की है,
तो यह वास्तव में वास्तुकला पर निर्भर करता है.
32-bit मशीन के लिए यह समझ में नहीं करने के लिए वास्तव में एक लंबे समय का उपयोग करता है.
और फिर एक लंबे, दूसरे हाथ पर, 8 बाइट्स है,
तो यह बहुत अच्छा है अगर आप एक लंबी पूर्णांक चाहते.
और अंत में, हम स्ट्रिंग है, जो वास्तव में एक चार * है,
जो एक चार के लिए एक सूचक है.
यह बहुत आसान लगता है कि स्ट्रिंग के आकार की तरह होने जा रहा है
वर्णों की संख्या है कि तुम वहाँ है,
लेकिन वास्तव में ही चार *
एक चार, जो 4 बाइट्स के लिए एक सूचक का आकार है.
एक चार * के आकार 4 बाइट्स है.
यह बात अगर आप एक छोटे से शब्द या एक पत्र या कुछ भी कोई फर्क नहीं पड़ता है.
यह 4 बाइट्स होने जा रहा है.
हम भी कास्टिंग के बारे में एक छोटा सा सीखा है,
तो जैसा कि आप देख सकते हैं, अगर आप हैं, उदाहरण के लिए, एक प्रोग्राम है कि कहते हैं
int x = 3 और फिर printf ("% d", x / 2)
क्या तुम लोगों को पता है कि यह क्या स्क्रीन पर मुद्रित करने के लिए जा रहा है?
>> किसी >> [छात्र] 2.
1. 1 >>, हाँ.
जब आप 2/3 करने के लिए यह 1.5 हो रहा है,
लेकिन जब से हम एक पूर्णांक का उपयोग कर रहे हैं यह दशमलव भाग की उपेक्षा की जा रही है,
और आप 1 के लिए जा रहे हैं.
यदि आपको लगता है कि ऐसा करने के लिए आप क्या कर सकते हैं, उदाहरण के लिए नहीं करना चाहते,
है एक नाव की घोषणा y = x.
तो एक्स है कि 3 इस्तेमाल किया जा अब y में 3.000 होने जा रहा है.
और फिर आप y / 2 मुद्रित कर सकते हैं.
असल में, मैं 2 होना चाहिए. वहाँ पर.
यह 3.00/2.00 करने जा रहा है,
और आप 1.5 पाने के लिए जा रहे हैं.
और हम इस .2 च सिर्फ दशमलव भाग में 2 दशमलव इकाइयों के लिए पूछने के लिए.
यदि आप .3 च है यह वास्तव में 1.500 किया जा रहा है.
यदि यह 2 से 1.50 होने जा रहा है.
हम भी इस मामले यहाँ है.
यदि आप नाव x = 3.14 और तब आप printf x
आप 3.14 पाने के लिए जा रहे हैं.
और अगर आप ऐसा x = x, int
जो एक int के रूप में एक्स के इलाज का मतलब है और आप एक्स अभी मुद्रित
आप 3.00 के लिए जा रहे हैं.
क्या इसका यह मतलब है?
क्योंकि आप पहले एक पूर्णांक के रूप में एक्स के इलाज कर रहे हैं, तो आप दशमलव भाग की अनदेखी कर रहे हैं,
और फिर आप x मुद्रण कर रहे हैं.
और अंत में, तुम भी यह कर सकते हैं,
int x 65 =, और फिर आप एक चार ग = x की घोषणा,
और फिर अगर आप ग को मुद्रित आप वास्तव में पाने के लिए जा रहे हैं
ए, तो बुनियादी तौर पर आप यहाँ क्या कर रहे हैं
चरित्र में पूर्णांक अनुवाद,
बस जैसे ASCII तालिका करता है.
हम भी गणित ऑपरेटरों के बारे में बात की थी.
उनमें से ज्यादातर बहुत सीधा कर रहे हैं, तो +, -, *, /
और हम भी आधुनिक है, जो 2 नंबर का एक प्रभाग के शेष के बारे में बात की थी.
यदि आप 10 3%, उदाहरण के लिए है,
इसका मतलब है 3 द्वारा 10 विभाजित है, और शेष क्या है?
यह एक होने जा रहा है, तो यह वास्तव में कार्यक्रमों की एक बहुत कुछ करने के लिए बहुत ही उपयोगी है.
Vigenère और सीज़र के लिए मुझे पूरा यकीन है कि तुम लोगों के सभी आधुनिक का इस्तेमाल कर रहा हूँ.
गणित ऑपरेटरों के बारे में बहुत सावधान रहना जब * और / के संयोजन.
>> उदाहरण के लिए, यदि आप करते हैं (3/2) 2 * आप क्या करने के लिए जा रहे हैं?
2 [छात्र].
हाँ, 2, 2 3 / क्योंकि 1.5 हो जा रहा है,
लेकिन जब से तुम 2 integers के बीच कार्य कर रहे हैं
आप वास्तव में सिर्फ 1 पर विचार करने जा रहे हैं,
और फिर 1 2 * 2 होने जा रहा है, तो बहुत, बहुत सावधान रहना
जब integers के साथ गणित कर रहे हैं क्योंकि
उस मामले में आप 2 कि = 3, मिल सकता है.
और भी वरीयता के बारे में बहुत सावधान रहना.
आप आमतौर पर लघुकोष्ठकों का उपयोग करने के लिए सुनिश्चित करें कि आप जानते हैं कि आप क्या कर रहे हैं होना चाहिए.
कुछ उपयोगी शॉर्टकट, ज़ाहिर है, एक मैं + + या मैं + = 1
का उपयोग कर या + =.
कि मैं मैं = 1 + कर के रूप में एक ही बात है.
तुम भी मैं क्या कर सकते हैं या मैं - = 1,
जो मैं मैं = -1 के रूप में एक ही बात है,
कुछ आप लोग loops के लिए में एक बहुत का उपयोग करें, कम से कम.
* इसके अलावा, अगर आप का उपयोग * = और यदि आप करते हैं, उदाहरण के लिए,
मैं * = 2 मैं मैं = 2 * कह के रूप में एक ही बात है,
और विभाजन के लिए एक ही बात है.
यदि आप / मैं 2 = मैं = मैं / 2 के रूप में एक ही बात है.
>> अब कार्यों के बारे में.
तुम लोग सीखा है कि कार्य करता है कोड को बचाने के लिए एक बहुत अच्छा करने के लिए रणनीति है
जब आप प्रोग्रामिंग कर रहे हैं, इसलिए यदि आप एक ही कार्य करने के लिए करना चाहते हैं
कोड में फिर से और फिर, शायद आप के लिए एक समारोह का उपयोग करना चाहते हैं
बस इतना तुम पर और फिर से कोड को कॉपी और पेस्ट नहीं है.
दरअसल, मुख्य एक समारोह है, और जब मैं तुम्हें एक समारोह का स्वरूप दिखाने
आप देख सकते हैं कि यह बहुत स्पष्ट है के लिए जा रहे हैं.
हम भी कुछ पुस्तकालयों से कार्यों का उपयोग,
उदाहरण के लिए, printf, Getin, जो CS50 पुस्तकालय से है,
और toupper जैसे अन्य कार्य.
उन कार्यों के सभी वास्तव में अन्य पुस्तकालयों में लागू कर रहे हैं,
और जब आप अपने कार्यक्रम की शुरुआत में उन पगहा फ़ाइलें डाल दिया
आप कह रहे हैं आप कृपया मुझे उन कार्यों के लिए कोड दे सकते हैं
तो मैं उन्हें खुद के द्वारा लागू नहीं है?
और तुम भी अपने खुद के कार्यों लिखते हैं, कर सकते हैं ताकि जब आप प्रोग्रामिंग शुरू
आपको पता है कि पुस्तकालयों सभी कार्य करता है कि आप की जरूरत नहीं है.
पिछले pset के लिए, उदाहरण के लिए, हम आकर्षित, हाथापाई, और लुकअप लिखा था,
और यह बहुत, बहुत महत्वपूर्ण है करने के कार्यों को लिखने में सक्षम होना
क्योंकि वे उपयोगी हैं, और हम उन्हें प्रोग्रामिंग में हर समय का उपयोग,
और यह कोड का एक बहुत बचाता है.
एक समारोह के प्रारूप में यह एक है.
हम शुरुआत में वापस प्रकार है. वापसी प्रकार क्या है?
यह बस जब अपने कार्य करने के लिए वापस जा रहा है.
यदि आप उदाहरण के लिए एक समारोह है, भाज्य है,
कि एक पूर्णांक के भाज्य की गणना करने के लिए जा रहा है,
शायद यह एक पूर्णांक भी वापस जा रहा है.
तो वापस प्रकार int होने जा रहा है,.
Printf वास्तव में एक वापसी प्रकार शून्य है
क्योंकि आप कुछ भी नहीं लौट रहे हैं.
तुम सिर्फ स्क्रीन करने के लिए कर रहे हैं बातें मुद्रण
और समारोह के बाद छोड़ने.
तो फिर तुम समारोह का नाम है कि आप चुन सकते है.
तुम एक छोटे से उचित हो सकता है, जैसे xyz की तरह एक नाम का चयन नहीं करते
या x2f तरह.
एक नाम है कि समझ में आता है बनाने की कोशिश करें.
>> उदाहरण के लिए, अगर यह भाज्य है, भाज्य का कहना है.
यदि यह एक समारोह में कहा कि कुछ आकर्षित करने के लिए जा रहा है, नाम है, यह आकर्षित.
और फिर हम पैरामीटर, जो भी तर्क कहा जाता है,
जो संसाधनों है कि अपने कार्य की जरूरत है की तरह कर रहे हैं
अपने कोड से अपने कार्य करने के लिए.
यदि आप एक संख्या का क्रमगुणित की गणना करना चाहते हैं
शायद आप एक नंबर एक क्रमगुणित की गणना करने की जरूरत है.
एक तर्क है कि आप के पास जा रहे हैं की संख्या ही है.
और फिर यह करने के लिए कुछ करते हैं और अंत में मूल्य वापस करने के लिए जा रहा है
जब तक यह एक शून्य समारोह है.
चलो एक उदाहरण देखते हैं.
अगर मैं एक समारोह में कहा कि पूर्णांकों की सरणी में सभी नंबरों को रकम लिखना चाहते हैं,
सब से पहले, वापस प्रकार int होने जा रहा है,
क्योंकि मैं पूर्णांकों की सरणी है.
और फिर मैं sumArray तरह समारोह के नाम किया जा रहा हूँ,
और फिर यह सरणी ही ले जा रहा है int nums,
और तब सरणी तो मुझे पता है कि कितनी संख्या मैं करने के लिए राशि की लंबाई.
तो मैं उदाहरण के लिए कहा जाता है एक चर राशि, 0 से आरंभ करने की है,
और हर बार मैं सरणी में एक तत्व देखते मैं यह योग करने के लिए जोड़ है, तो मैं एक पाश के लिए किया.
वैसे ही जैसे Lexi कहा, आप int i = 0, मैं <लंबाई और मैं + +.
और सरणी में प्रत्येक तत्व के लिए मैं योग + = nums [i] किया था,
और फिर मैं योग लौटे, तो यह बहुत आसान है, और यह कोड का एक बहुत बचाता है
अगर आप इस समारोह में समय की एक बहुत का उपयोग कर रहे हैं.
फिर हम स्थितियों पर एक नज़र लिया.
हम अगर, बाकी है, और कुछ तो.
चलो देखते हैं क्या उन लोगों के बीच अंतर है.
इन 2 कोड पर एक नज़र रखना. उन दोनों के बीच क्या अंतर है?
पहले एक - मूल रूप से किया गया है कोड आपको बताने के लिए करना चाहते हैं
, या 0 - अगर एक संख्या + है.
1 एक का कहना है कि अगर यह> 0 है तो यह सकारात्मक है.
यदि यह = 0 से तो यह 0 है, और अगर यह <0 है, तो यह नकारात्मक है.
>> और अगर, वरना, और अन्य एक कर रही है.
दोनों के बीच अंतर यह है कि वास्तव में इस एक के लिए जा रहा है
अगर> 0 <0 या = 0 तीन बार,
यदि ऐसा है तो आप 2 नंबर है, उदाहरण के लिए, यह करने के लिए यहाँ आते हैं और कहते जा रहा है
(x> 0), और अगर यह के लिए हाँ कह रहा है, तो मैं सकारात्मक मुद्रित करें.
लेकिन फिर भी मैं पता है कि यह> 0 और 0 0 या <होने वाला नहीं है
मैं अभी भी करने जा रहा हूँ यह 0 है, यह है <0,
इसलिए मैं वास्तव में ifs हैं के अंदर जा रहा हूँ कि मैं नहीं था
क्योंकि मैं पहले से ही पता है कि यह इन शर्तों के किसी को संतुष्ट करने के लिए नहीं जा रहा है.
मैं अगर उपयोग कर सकते हैं, और अगर कुछ बयान.
यह मूल रूप से कहते हैं कि अगर x = 0 मैं सकारात्मक मुद्रित करने के लिए.
यदि ऐसा नहीं है, मैं भी इस परीक्षण के लिए जा रहा हूँ.
यदि यह 2 है यह करने के लिए नहीं कर रहा हूँ मैं जा रहा है.
वैसे, अगर मैं x = 2 था आप कहेंगे
अगर (x> 0), हाँ, तो इस प्रिंट.
अब जब कि मुझे पता है कि यह> 0 है और यह है कि अगर पहले संतुष्ट
मैं भी करने के लिए इस कोड को चलाने के लिए नहीं जा रहा हूँ.
कोड तेजी से चलाता है, वास्तव में, 3 गुना तेजी से यदि आप इस का उपयोग करें.
हम यह भी के बारे में और या सीखा है.
मैं इस के माध्यम से जाना है क्योंकि Lexi पहले से ही उनके बारे में बात करने के लिए नहीं जा रहा हूँ.
यह सिर्फ && और | | ऑपरेटर.
>> केवल एक चीज मैं कहता हूँ सावधान हो सकता है जब आप 3 की स्थिति है.
लघुकोष्ठकों का उपयोग क्योंकि यह बहुत भ्रामक है जब आप एक शर्त है
और एक और एक या एक दूसरे के.
लघुकोष्ठकों का उपयोग सुनिश्चित करें कि अपनी शर्तों समझ बनाने के
क्योंकि उस मामले में, उदाहरण के लिए, आप कल्पना कर सकते हैं कि
यह पहली शर्त है और एक या एक से दूसरे हो सकता है
या 2 एक में संयुक्त शर्तों और
या 3 एक है, तो बस सावधान रहना.
और अंत में, हम स्विच के बारे में बात की थी.
एक स्विच बहुत उपयोगी है जब आप एक चर है.
हम कहते हैं कि तुम n की तरह एक चर
0, 1, 2 या हो सकता है, और उन मामलों में से प्रत्येक
आप एक काम करने के लिए जा रहे हैं.
आप चर स्विच करने के लिए कह सकते हैं, और यह इंगित करता है कि
मूल्य value1 की तरह है तो मैं यह करने के लिए जा रहा हूँ,
और फिर मैं तोड़ने, जिसका मतलब है मैं अन्य मामलों में से किसी में देखने के लिए नहीं जा रहा हूँ
क्योंकि हम पहले से ही उस मामले संतुष्ट
और फिर value2 और इतने पर है, और मैं भी एक डिफ़ॉल्ट स्विच कर सकते हैं.
इसका मतलब है कि अगर यह मामलों था कि मैं किसी को संतुष्ट नहीं करता
कि मैं कुछ और करने के लिए जा रहा हूँ, लेकिन यह है कि वैकल्पिक है.
यह सब मेरे लिए है. अब चलो टॉमी है.
ठीक है, यह 3 ish सप्ताह होने जा रहा है.
इन विषयों हम को कवर किया जाएगा क्रिप्टो, गुंजाइश, arrays वगैरह की कुछ कर रहे हैं.
क्रिप्टो पर बस एक त्वरित शब्द. हम इस घर हथौड़ा करने के लिए नहीं जा रहे हैं.
>> हम 2 pset में इस किया था, लेकिन प्रश्नोत्तरी के लिए सुनिश्चित करें कि आपको फर्क पता
सीज़र बीजलेख और Vigenère बीजलेख के बीच,
कैसे उन सिफर काम के दोनों और क्या यह एन्क्रिप्ट करने के लिए की तरह है
और डिक्रिप्ट पाठ उन 2 सिफर का उपयोग कर.
याद रखें, कैसर बीजलेख बस एक ही राशि के द्वारा प्रत्येक चरित्र घूमता है,
सुनिश्चित करें कि आप आधुनिक वर्णमाला में पत्रों की संख्या से बना रही है.
और Vigenère बीजलेख, दूसरे हाथ पर, प्रत्येक वर्ण rotates
एक अलग राशि के द्वारा, इसलिए बजाय कह से
3 Vigenère द्वारा हर चरित्र घुमाया प्रत्येक वर्ण बारी बारी से होगा
कुछ कीवर्ड के आधार पर एक अलग राशि से
जहां कीवर्ड में प्रत्येक पत्र कुछ अलग राशि का प्रतिनिधित्व करता है
स्पष्ट पाठ घुमाएगी.
चर गुंजाइश के बारे में पहले बात करते हैं.
वहाँ चर के 2 अलग अलग प्रकार के होते हैं.
हम स्थानीय चर है, और इन में परिभाषित किया जा जा रहे हैं
बाहर की मुख्य या किसी भी समारोह या ब्लॉक के बाहर,
और इन सुलभ अपने कार्यक्रम में कहीं भी हो जाएगा.
यदि आप एक समारोह है और उस समारोह में एक समय पाश है
बड़ा वैश्विक चर हर जगह सुलभ है.
एक स्थानीय चर, दूसरे हाथ पर, जगह है जहाँ यह परिभाषित किया गया है scoped है.
>> यदि आप एक समारोह यहाँ है, उदाहरण के लिए, हम इस समारोह छ है,
और जी के अंदर एक चर y बुलाया है,
और इसका मतलब है कि यह एक स्थानीय चर है.
हालांकि इस चर y कहा जाता है
और इस चर इन 2 कार्यों y कहा जाता है
कोई विचार नहीं है क्या कर रहे हैं एक दूसरे के स्थानीय चर है.
दूसरी ओर, यहाँ हम int x = 5 कहते हैं,
और यह किसी भी समारोह के दायरे से बाहर है.
यह मुख्य के दायरे से बाहर है, तो यह एक वैश्विक चर है.
यह है कि इन 2 कार्यों के अंदर का मतलब है जब मैं एक्स कहते हैं - या x + +
मैं एक ही एक्स जिससे इस y और इस y विभिन्न चर तक पहुँचने हूँ.
यह एक वैश्विक चर और एक स्थानीय चर के बीच अंतर है.
जहाँ तक के रूप में डिजाइन का संबंध है, कभी कभी यह शायद एक अच्छा विचार है
स्थानीय चर रखने के लिए जब भी आप संभवतः कर सकते हैं
होने के बाद से वैश्विक चर का एक गुच्छा वास्तव में भ्रमित हो सकता है.
यदि आप कार्यों का एक गुच्छा है सब एक ही बात को संशोधित
क्या तुम अगर इस समारोह में गलती से इस वैश्विक modifies भूल सकता है,
और यह अन्य समारोह में इसके बारे में पता नहीं है,
और यह बहुत भ्रमित करता है के रूप में आप और अधिक कोड मिलता है.
चर स्थानीय रखते हुए जब भी आप संभवतः कर सकते हैं
सिर्फ अच्छे डिजाइन है.
Arrays, याद है, बस एक ही प्रकार के तत्वों की सूची.
सीआई के अंदर 2.0 1, जैसे एक सूची नहीं है, नमस्ते कर सकते हैं.
हम सिर्फ ऐसा नहीं कर सकते.
>> जब हम सी में एक सरणी की घोषणा तत्वों के सभी एक ही प्रकार के हैं.
यहाँ मैं 3 integers के एक सरणी है.
यहाँ मैं सरणी की लंबाई है, लेकिन अगर मैं सिर्फ इस वाक्यविन्यास में यह की घोषणा कर रहा हूँ
जहाँ मैं निर्दिष्ट तत्वों के सभी क्या कर रहे हैं मैं तकनीकी रूप से इस 3 की जरूरत नहीं है.
संकलक काफी समझदार के लिए बाहर आंकड़ा कितना बड़ा सरणी होना चाहिए है.
अब जब मैं करने के लिए या एक सरणी के मूल्य निर्धारित करना चाहते हैं
यह करने के लिए कि क्या वाक्यविन्यास है.
यह वास्तव में सरणी के दूसरे तत्व को संशोधित क्योंकि याद करेंगे,
नंबर 0 में शुरू होता है, 1 पर नहीं.
अगर मैं उस मूल्य को पढ़ने के लिए चाहते हैं मैं कुछ कहने की तरह कर सकते हैं int x = सरणी [1].
या अगर मैं कि मूल्य निर्धारित करना चाहते हैं, जैसे मैं यहाँ क्या कर रहा हूँ,
मैं सरणी [1] कह सकते हैं = 4.
उस समय उनके सूचकांक तत्वों तक पहुँचने
या उनकी स्थिति या जहां वे सरणी में कर रहे हैं,
और है कि लिस्टिंग 0 में शुरू होता है.
हम भी arrays के arrays हो सकता है,
और यह एक बहु - आयामी सरणी कहा जाता है.
जब हम एक बहु - आयामी सरणी
इसका मतलब है कि हम कुछ पंक्तियों और स्तंभों की तरह हो सकता है,
और यह सिर्फ visualizing या इसके बारे में सोच का एक तरीका है.
जब मैं एक बहु - आयामी सरणी है इसका मतलब है कि मैं करने की जरूरत शुरू करने के लिए जा रहा हूँ
1 से अधिक सूचकांक क्योंकि अगर मैं एक ग्रिड
कह रही है क्या आप पंक्ति में रहे हैं बस हमें एक संख्या देना नहीं है.
यह वास्तव में सिर्फ हमें संख्याओं की एक सूची देने के लिए जा रहा है.
चलो कहते हैं कि मैं इस सरणी यहाँ है.
मैं एक ग्रिड सरणी कहा जाता है, और मैं यह 2 पंक्तियों और 3 कॉलम कह रहा हूँ,
और तो यह यह visualizing की एक तरीका है.
जब मैं कहता हूँ मैं [1] पर तत्व प्राप्त करना चाहते हैं [2]
इसका मतलब है कि क्योंकि इन पंक्तियों के पहले और फिर स्तंभों
मैं करने के लिए 1 पंक्ति के बाद से मैं 1 कहा कूदने के लिए जा रहा हूँ.
>> तो मैं 2 स्तंभ यहाँ आने के लिए जा रहा हूँ, और मैं मान 6 पाने के लिए जा रहा हूँ.
मतलब होता है?
बहु - आयामी arrays, याद है, तकनीकी रूप से सिर्फ सरणियों की एक सरणी हैं.
हम arrays के arrays के arrays हो सकता है.
हम जा रखने के लिए कर सकते हैं, लेकिन के बारे में वास्तव में एक तरह लगता है
यह कैसे बाहर रखा जा रहा है और क्या हो रहा है यह कल्पना है
इस तरह एक ग्रिड में.
जब हम कार्य करने के लिए arrays गुजरती हैं, वे व्यवहार करने जा रहे हैं
जब हम कार्य करने के लिए नियमित रूप से चर के पास से एक छोटे से अलग बिट
एक int या एक नाव पारित की तरह.
जब हम एक int या चार या इन अन्य डेटा के किसी भी प्रकार के पास
हम सिर्फ अगर समारोह modifies पर एक नज़र लिया
कि परिवर्तन करने के लिए प्रचार करने के लिए नहीं जा रहा है कि चर के मूल्य
बुला कार्य करने के लिए.
एक सरणी के साथ, दूसरे हाथ पर, कि क्या होगा.
अगर मैं कुछ कार्य करने के लिए एक सरणी में पास और उस समारोह तत्वों में से कुछ परिवर्तन,
जब मैं समारोह में कहा कि यह कहा जाता है करने के लिए वापस आ
मेरे सरणी अब अलग हो जा रहा है, और उस के लिए शब्दावली
है arrays संदर्भ द्वारा पारित कर दिया जाता है, के रूप में हम बाद में देखेंगे.
यह संकेत है, कैसे काम इन बुनियादी जहां डेटा प्रकार से संबंधित है,
दूसरे हाथ पर, मान द्वारा पारित कर रहे हैं.
>> हम जानते हैं कि कुछ चर की एक प्रतिलिपि बनाने और फिर नकल में गुजर रहा है के रूप में सोच सकते हैं.
इससे कोई फर्क नहीं पड़ता है कि क्या हम उस चर के साथ करते हैं.
बुला समारोह पता है कि यह बदल गया था नहीं होगा.
Arrays सिर्फ एक छोटे से उस संबंध में थोड़ा अलग हैं.
उदाहरण के लिए, के रूप में हम सिर्फ देखा, मुख्य बस एक समारोह है
कि 2 बहस में ले जा सकते हैं.
मुख्य समारोह के लिए 1 तर्क argc, या तर्कों की संख्या है,
और दूसरा तर्क argv कहा जाता है,
और उन उन तर्कों की वास्तविक मान रहे हैं.
चलो कहते हैं कि मैं एक this.c कार्यक्रम बुलाया है,
और मैं यह कहना है, और मैं कमांड लाइन पर चला जा रहा हूँ.
अब कुछ बहस में अपने कार्यक्रम के लिए पारित यह कहा जाता है,
मैं कुछ ऐसा कहना है / इस सीएस 50 है.
यह है कि हम क्या दाऊद करने के लिए हर दिन की कल्पना टर्मिनल पर.
लेकिन अब है कि कार्यक्रम के मुख्य समारोह के अंदर
इन मूल्यों है, तो 4 argc है.
यह थोड़ा भ्रमित हो सकता है क्योंकि वास्तव में हम केवल 50 सीएस में गुजर रहे हैं हो सकता है.
यह केवल 3.
लेकिन याद रखना कि argv के पहले तत्व या 1 तर्क
समारोह ही नाम है.
तो इसका मतलब है कि हम 4 बातें यहाँ है,
और 1 तत्व / यह होने जा रहा है.
और यह एक स्ट्रिंग के रूप में प्रतिनिधित्व किया जाएगा.
तो शेष तत्वों रहे हैं जो हम इस कार्यक्रम के नाम के बाद में टाइप.
तो बस के रूप में एक अलग रूप में हम शायद 2 pset में देखा था,
याद है कि 50 स्ट्रिंग पूर्णांक 50 ≠ है.
तो हम जैसे कुछ नहीं कह सकते हैं 'int = x 3 argv.'
>> वह सिर्फ जा रहा है, समझ बनाने के लिए नहीं है क्योंकि यह एक स्ट्रिंग है, और यह एक पूर्णांक है.
तो अगर आप 2 के बीच परिवर्तित करना चाहते हैं, याद है, हम जा रहे हैं
इस जादू atoi समारोह बुलाया है.
यह एक स्ट्रिंग लेता है और कि स्ट्रिंग के अंदर प्रतिनिधित्व पूर्णांक देता है.
तो है कि एक आसान गलती प्रश्नोत्तरी बनाने,
बस सोच रहा है कि यह स्वचालित रूप से सही प्रकार होगा.
लेकिन सिर्फ इतना पता है कि ये हमेशा तार हो जाएगा
यहां तक ​​कि अगर स्ट्रिंग केवल एक पूर्णांक या एक चरित्र या एक नाव शामिल हैं.
तो अब समय चल रहा है के बारे में बात करते हैं.
जब हम इन सभी एल्गोरिदम कि इन सब पागल बातें करते हैं
यह वास्तव में उपयोगी हो जाता है के लिए सवाल पूछते हैं, "वे कैसे समय लेते हैं?"
हम कुछ उपगामी संकेतन बुलाया के साथ कि प्रतिनिधित्व करते हैं.
तो इसका मतलब है कि - ठीक है, चलो का कहना है कि हम हमारे एल्गोरिथ्म दे
कुछ सच में, सच, सच में बड़ा इनपुट है.
हम सवाल पूछना चाहता हूँ, "कब तक यह करने के लिए ले जा रहा है?
कितने कदम यह हमारे एल्गोरिथ्म लेने के लिए चलेंगे
इनपुट के आकार के एक समारोह के रूप में? "
तो 1 जिस तरह से हम चलाने के लिए समय का वर्णन कर सकते हैं बड़ा ओ के साथ है
और यह हमारे चलने सबसे ज्यादा मामले समय है.
तो अगर हम एक सरणी सॉर्ट करना चाहते हैं, और हम हमारे एल्गोरिथ्म एक सरणी दे
अवरोही क्रम में जब यह आरोही क्रम में होना चाहिए,
कि सबसे खराब मामला होने जा रहा है.
यह हमारे समय हमारे एल्गोरिथ्म ले जाएगा की अधिकतम लंबाई में ऊपरी बाध्य है.
दूसरी ओर, इस Ω समय चल रहा है सबसे अच्छा मामले का वर्णन करने के लिए जा रहा है.
तो अगर हम एक छँटाई एल्गोरिथ्म के लिए एक पहले से ही क्रमबद्ध सरणी देते हैं,
कितनी देर तक यह इसे सुलझा ले जाएगा?
और यह, फिर, एक कम समय चल रहा है पर बाध्य का वर्णन करता है.
तो यहाँ सिर्फ कुछ शब्दों है कि कुछ सामान्य चल बार का वर्णन कर रहे हैं.
ये आरोही क्रम में हैं.
सबसे तेजी से चल रहा है समय हमारे पास लगातार कहा जाता है.
>> यह कोई फर्क नहीं पड़ता कि कितने तत्वों हम हमारे एल्गोरिथ्म दे मतलब है,
कोई फर्क नहीं पड़ता कि कैसे हमारे सरणी बड़ा है, यह छँटाई
या जो कुछ भी कर हम सरणी के लिए कर रहे हैं हमेशा समय की एक ही राशि ले जाएगा.
तो हम एक 1 है, जो एक स्थिर है कि बस के साथ प्रतिनिधित्व कर सकते हैं.
हम लघुगणक चलाने के समय में भी देखा.
तो द्विआधारी खोज की तरह कुछ logarithmic है,
जहां हम हर आधे समय में समस्या में कटौती
और फिर बातें बस वहाँ से अधिक मिलता है.
और अगर तुम कभी किसी भाज्य एल्गोरिथ्म के एक हे लेखन,
आप शायद यह अपने दिन नौकरी के रूप में विचार नहीं करना चाहिए.
जब हम चल रहे बार की तुलना में यह महत्वपूर्ण है कि इन बातों को ध्यान में रखने के.
तो अगर मैं एक एल्गोरिथ्म कि हे (एन), और किसी
हे के एक एल्गोरिथ्म (2n) वास्तव में ये हैं asymptotically बराबर.
तो अगर हम eleventy अरब की तरह एक बड़ी संख्या हो n कल्पना कीजिए:
इसलिए जब हम eleventy अरब eleventy अरब की तरह कुछ + 3 की तुलना कर रहे हैं,
अचानक कि वास्तव में तीन एक बड़ा अंतर अब और नहीं कर सकता है.
यही कारण है कि हम इन बातों के बराबर होने के लिए विचार शुरू करने के लिए जा रहे हैं.
इन अचरों की तरह यहाँ बातें तो इस 2 x है, या एक 3 जोड़ने,
ये सिर्फ स्थिरांक, और इन करने के लिए छोड़ने जा रहे हैं.
तो यही कारण है कि इन चलाने बार के सभी 3 कह रही है वे O (n) के रूप में एक ही कर रहे हैं.
इसी तरह, अगर हम 2 अन्य चलाने बार है, चलो कहते हैं कि हे (एन + ² 2n ³), हम जोड़ सकते हैं
+ N 7 +, और फिर हम एक और चलाने के लिए समय है कि सिर्फ हे (n ³) है.
फिर, ये एक ही बात कर रहे हैं क्योंकि इन - ये एक ही नहीं कर रहे हैं.
ये वही बातें कर रहे हैं, माफ करना. तो ये वही कर रहे हैं, क्योंकि
इस n ³ इस 2n ² हावी हो रहा है.
>> क्या है अगर हम (n ³) हे और हे की तरह बार चलाने के लिए है ही बात नहीं है (² n)
क्योंकि इस n ³ ज्यादा इस n ² से भी बड़ा है.
तो अगर हम exponents है, अचानक यह बात करने के लिए शुरू होता है,
लेकिन जब हम बस कारकों के साथ काम कर रहे हैं के रूप में हम यहाँ हैं,
तो यह बात है क्योंकि वे सिर्फ बाहर छोड़ने के लिए जा रहे हैं नहीं जा रहा है.
चलो एल्गोरिदम के कुछ हम अब तक देखा है पर एक नज़र रखना
और उनके चलाने के समय के बारे में बात करते हैं.
एक सूची में एक नंबर के लिए देखने का पहला तरीका है, कि हमने देखा, रैखिक खोज थी.
और रैखिक खोज के कार्यान्वयन सुपर सीधा है.
हम सिर्फ एक सूची है, और हम सूची में हर एक तत्व पर देखने के लिए जा रहे हैं
जब तक हम इस संख्या को खोजने के लिए हम देख रहे हैं.
तो इसका मतलब है कि सबसे खराब स्थिति में, यह O (n).
और सबसे बुरा मामले में अगर तत्व हो सकता है
पिछले तत्व, तो रैखिक खोज का उपयोग हम हर एक तत्व को देखने के लिए है
जब तक हम पिछले एक क्रम में पता है कि यह वास्तव में सूची में था.
हम सिर्फ आधे रास्ते नहीं दे और सकते हैं और कहते हैं, "यह शायद वहाँ नहीं है."
रैखिक खोज के साथ हम पूरी बात को देखने के लिए है.
सबसे अच्छा मामले चल रहे है, दूसरे हाथ पर, निरंतर है
क्योंकि सबसे अच्छा मामले में हम देख रहे हैं तत्व सिर्फ सूची में पहले से एक है.
तो यह हमें वास्तव में एक कदम है, कोई फर्क नहीं पड़ता कि कितना बड़ा सूची है ले जा रहा है
अगर हम पहले तत्व के लिए हर बार देख रहे हैं.
>> तो जब आप खोज, याद है, यह नहीं की आवश्यकता नहीं है कि हमारी सूची हल हो.
क्योंकि हम तो बस हर एक तत्व पर देखने जा रहे हैं, और यह वास्तव में कोई फर्क नहीं पड़ता
किस क्रम में उन तत्वों के अंदर कर रहे हैं
एक और अधिक बुद्धिमान खोज एल्गोरिथ्म द्विआधारी खोज की तरह कुछ है.
याद रखें, द्विआधारी खोज के कार्यान्वयन है जब आप करने के लिए जा रहे हैं
सूची के बीच में तलाश में रहते हैं.
और क्योंकि हम बीच में देख रहे हैं, हम चाहते हैं कि सूची हल है
या हम जहां मध्यम है नहीं पता है, करते हैं और हम पर देखो
पूरी सूची में इसे खोजने के लिए, और फिर उस बिंदु पर हम सिर्फ समय बर्बाद कर रहे हैं.
तो अगर हम एक क्रमबद्ध सूची है और हम बीच में मिल जाए, हम करने के लिए बीच की तुलना करने के लिए जा रहे हैं
तत्व के लिए हम देख रहे हैं.
अगर यह बहुत अधिक है, तो हम सही आधा भूल कर सकते हैं
क्योंकि हम जानते हैं कि अगर हमारे तत्व पहले से ही बहुत अधिक है
और इस तत्व की सही करने के लिए सब कुछ भी अधिक है,
तो हम वहाँ अब देखने की जरूरत नहीं है.
कहाँ दूसरे हाथ पर, यदि हमारे तत्व बहुत कम है,
हम जानते हैं कि उस तत्व की बाईं करने के लिए सब कुछ भी बहुत कम है,
तो यह वास्तव में वहाँ देखो समझ में नहीं पड़ता है, या तो.
इस तरह, हर कदम के साथ और सूची के मध्य में हर समय हम देख,
हम में आधा हमारी समस्या में कटौती करने के लिए जा रहे हैं क्योंकि अचानक हम जानते हैं
नंबर है कि एक के लिए हम देख रहे हैं नहीं किया जा सकता है की एक पूरी गुच्छा.
>> Pseudocode में यह कुछ इस तरह देखना होगा,
और क्योंकि हम हर आधे ही समय में सूची में कटौती कर रहे हैं,
हमारे सबसे ज्यादा मामले रन रैखिक से logarithmic समय कूदता है.
तो अचानक हम लॉग में कदम क्रम में एक सूची में एक तत्व को खोजने के लिए.
सबसे अच्छा मामले चल रहे है, हालांकि, अभी भी लगातार
क्योंकि अब, चलो बस का कहना है कि तत्व के लिए हम देख रहे हैं
हमेशा मूल सूची के सटीक बीच.
तो हम बड़ा के रूप में हम चाहते हैं के रूप में हमारी सूची विकसित कर सकते हैं, लेकिन अगर तत्व के लिए हम देख रहे हैं के बीच में है,
तो यह केवल करने के लिए हमें एक कदम उठाने जा रहा है.
तो यही कारण है कि हम हे (लॉग एन) और (1) Ω या लगातार कर रहे हैं.
चलो वास्तव में इस सूची पर द्विआधारी खोज चलाने.
तो हम कहते हैं कि हम 164 तत्व के लिए देख रहे हैं.
पहली बात हम क्या करने जा रहे हैं यह है कि इस सूची के मध्य पाते हैं.
यह सिर्फ इतना होता है कि midpoint इन दो संख्याओं के बीच में गिर रहा है,
तो चलो बस मनमाने ढंग से कहते हैं, हर बार midpoint 2 संख्याओं के बीच गिर जाता है,
चलो बस ऊपर दौर.
हम सिर्फ यकीन है कि हम इस तरह के हर कदम बनाने की जरूरत है.
तो हम दौर के लिए जा रहे हैं, और हम कहते हैं कि 161 हमारी सूची के बीच जा रहे हैं.
161 तो <164, और 161 के बाईं ओर हर तत्व
भी <164 में से एक है, इसलिए हम जानते हैं कि यह करने के लिए हम सभी को मदद करने के लिए नहीं जा रहा है
यहाँ देख शुरू तत्व है क्योंकि हम के लिए देख रहे हैं हो सकता है वहाँ नहीं कर सकते.
तो हम क्या कर सकते है हम सिर्फ सूची की है कि पूरे बाईं आधा के बारे में भूल सकता है,
और अब केवल 161 आगे की सही से विचार करें.
>> तो फिर, यह midpoint की है, चलो बस ऊपर दौर.
अब 175 बहुत बड़ी है.
तो हम जानते हैं कि यह हमें यहाँ या यहाँ की तलाश में मदद करने के लिए नहीं जा रहा है,
तो हम सिर्फ इतना है कि दूर फेंक कर सकते हैं, और अंततः हम 164 मारा जाएगा.
द्विआधारी खोज पर कोई सवाल?
चलो एक सूची के माध्यम से पहले से ही हल खोज से आगे बढ़ना
वास्तव में किसी भी क्रम में संख्याओं की एक सूची ले
और आरोही क्रम में है कि सूची बना रही है.
पहली एल्गोरिथ्म हम पर देखा बुलबुला तरह बुलाया गया था.
और इस एल्गोरिदम हमने देखा की आसान हो जाएगा.
बुलबुला तरह का कहना है कि जब सूची के अंदर किसी भी 2 तत्वों जगह से बाहर हैं,
जिसका अर्थ है वहाँ एक कम संख्या के बाईं ओर के लिए एक उच्च संख्या है,
तो हम उन्हें स्वैप के लिए जा रहे हैं, क्योंकि इसका मतलब है कि सूची होगा
"हल अधिक से पहले था.
और हम बस के लिए इस प्रक्रिया को फिर से जारी करने जा रहे हैं और फिर
अंततः जब तक उनके सही स्थान पर बुलबुला तत्वों तरह है और हम एक क्रमबद्ध सूची है.
>> इस चलाने के समय हे होने जा रहा है (एन ²). क्यों?
ठीक है, क्योंकि सबसे ज्यादा मामले में, हम हर तत्व ले जा रहे हैं, और
हम अंत में यह सूची में हर दूसरे तत्व की तुलना करने के लिए जा रहे हैं.
लेकिन सबसे अच्छा मामले में, हम पहले से ही एक क्रमबद्ध सूची है, बुलबुला तरह
सिर्फ एक बार के माध्यम से जाना जा रहा है, कहते हैं, "नहीं, मैं किसी भी स्वैप नहीं बना था, इसलिए मैं काम कर रहा हूँ."
तो हम एक सबसे अच्छा मामले Ω (एन) के समय चल रहा है.
चलो एक सूची पर बुलबुला तरह चला.
या 1, चलो बस कुछ pseudocode सच में जल्दी से देखो.
हम कहते हैं कि हम ट्रैक के पाश के हर यात्रा में रखना चाहते हैं, चाहते हैं,
या नहीं, हम किसी भी तत्व बदल का ट्रैक रखने के लिए.
तो यह है कि के लिए कारण, हम बंद करने जा रहे हैं जब हम किसी भी तत्व नहीं बदली है.
इसलिए हमारे पाश की शुरुआत में हम कुछ भी नहीं बदली है, तो हम कहेंगे कि गलत है.
अब, हम सूची के माध्यम से जाने के लिए जा रहे हैं और तत्व की तुलना मैं तत्व मैं 1 +
और यदि यह मामला है कि वहाँ एक छोटी संख्या के बाईं ओर के लिए एक बड़ी संख्या है,
तो हम सिर्फ उन्हें स्वैप करने के लिए जा रहे हैं.
>> और फिर हम याद है कि हम एक तत्व बदली जा रहे हैं.
इसका मतलब है कि हम सूची के माध्यम से कम से कम 1 बार जाने की जरूरत है
क्योंकि हालत में हम बंद कर दिया है जब पूरी सूची पहले से ही सॉर्ट किया जाता है,
जिसका अर्थ है कि हम किसी भी स्वैप नहीं बनाया है.
तो यही कारण है कि हमारी हालत यहाँ नीचे है जबकि कुछ तत्वों बदली किया गया है. '
तो अब हम सिर्फ यह एक सूची पर चल रहा है पर देखो.
मैं 5,0,1,6,4 सूची है.
बुलबुला तरह छोड़ दिया पर सभी तरह से शुरू करने जा रहा है, और यह तुलना करने के लिए जा रहा है
मैं तत्वों, तो 0 मैं + 1, जो 1 तत्व है.
यह कहना है, अच्छी तरह से 5> 0 जा रहा है, लेकिन अभी 5 बाईं करने के लिए है,
इसलिए मैं 5 और 0 स्वैप करने की जरूरत है.
जब मैं उन्हें स्वैप, अचानक मैं यह अलग सूची मिलता है.
5 अब> 1, तो हम उन्हें स्वैप के लिए जा रहे हैं.
5 6> नहीं है, तो हम यहाँ कुछ भी करने की जरूरत नहीं है.
लेकिन 6 4>, तो हम स्वैप करने की जरूरत है.
फिर, हम पूरा करने के लिए अंत में पता चलता सूची के माध्यम से चलाने की जरूरत है
कि इन क्रम से बाहर हैं, हम उन्हें स्वैप,
और इस बिंदु पर हम सूची के माध्यम से 1 अधिक समय चलाने की जरूरत है
यकीन है कि सब कुछ अपने आदेश में है, और इस बिंदु बुलबुला तरह समाप्त हो गया है.
कुछ तत्वों को लेने और उन्हें छँटाई करने के लिए एक अलग एल्गोरिथ्म चयन छंटाई है.
चयन छंटाई के पीछे विचार यह है कि हम करने के लिए सूची का एक क्रमबद्ध भाग बनाने जा रहे हैं
एक समय में 1 तत्व.
>> और जिस तरह से हम ऐसा करने जा रहे हैं सूची के बाईं ओर खंड के निर्माण से है.
और मूल रूप से, हर - हर कदम पर, हम छोटी तत्व हम छोड़ दिया है ले जा रहे हैं
है कि अभी तक हल नहीं किया गया है, और हम यह कि हल खंड में स्थानांतरित करने के लिए जा रहे हैं.
इसका मतलब है कि हम लगातार न्यूनतम unsorted तत्व को खोजने की जरूरत है
और फिर कि न्यूनतम तत्व ले और यह साथ जो कुछ भी स्वैप
बाएँ सबसे तत्व है कि हल नहीं है.
इस के चलाने के लिए समय हे होने जा रहा है (² n), क्योंकि मामले में सबसे खराब
हम हर दूसरे तत्व हर एक तत्व की तुलना की जरूरत है.
क्योंकि हम कह रहे हैं कि अगर हम सूची के बाईं छमाही में शुरू करते हैं, हम की जरूरत है
पूरे सही खंड के माध्यम से जाने के लिए छोटी से छोटी तत्व मिल.
और फिर, फिर से, हम पूरे सही खंड जाने के लिए और की जरूरत है
और अधिक से अधिक और अधिक से अधिक जा रहा है कि फिर से रखने के लिए.
N ² होने जा रहा है. हम पाश अंदर पाश के लिए किसी अन्य के लिए एक आवश्यकता के लिए जा रहे हैं
जो n ² पता चलता है.
सबसे अच्छा मामले सोचा, चलो कहते हैं कि हम यह एक पहले से ही क्रमबद्ध सूची दे;
हम वास्तव में n ² की तुलना में किसी भी बेहतर नहीं करते.
क्योंकि चयन तरह जानते हुए भी कि कोई रास्ता नहीं है
न्यूनतम तत्व बस एक मैं हो रही हो.
यह अभी भी यकीन है कि यह वास्तव में कम से कम करने की जरूरत है.
>> और यकीन है कि यह न्यूनतम है, इस एल्गोरिथ्म का उपयोग केवल तरह,
हर एक तत्व पर फिर से देखने के लिए है.
तो सच में, अगर आप इसे देना - अगर आप चयन छंटाई पहले से ही एक क्रमबद्ध सूची दे,
यह करने के लिए यह एक सूची है कि अभी तक हल नहीं है देने की तुलना में किसी भी बेहतर करने के लिए नहीं जा रहा है.
वैसे, अगर यह मामला होता है कि कुछ हे (कुछ)
और कुछ के ओमेगा, हम सिर्फ अधिक succinctly कि यह कुछ के θ कह सकते हैं.
तो अगर आप देखते हैं कि कहीं भी आते हैं, कि है कि क्या सिर्फ मतलब है.
>> यदि कुछ n के थीटा ², यह दोनों बड़े (² n) हे और Ω (² n) है.
सबसे अच्छा मामले में और सबसे ज्यादा मामले तो, इससे कोई फर्क नहीं पड़ता है,
एल्गोरिथ्म हर बार एक ही बात करने के लिए जा रहा है.
तो यह है कि क्या चयन छंटाई के लिए pseudocode की तरह लग सकता है.
हम मूल रूप से कहना है कि मैं सूची पुनरावृति करना चाहते करने के लिए जा रहे हैं
से सही करने के लिए, और लूप के प्रत्येक चलना छोड़ दिया है, मैं को स्थानांतरित करने के लिए जा रहा हूँ
सूची के इस हल भाग में न्यूनतम तत्व.
और एक बार मैं वहाँ कुछ ले जाने के लिए, मैं कभी उस तत्व पर फिर से देखने की जरूरत है.
क्योंकि जैसे ही मैं में सूची के बाईं ओर खंड के लिए एक तत्व स्वैप, यह हल है
क्योंकि हम minimums उपयोग करके आरोही क्रम में सब कुछ कर रहे हैं.
तो हम ने कहा, ठीक है, हम स्थिति में मैं कर रहे हैं, और हम तत्वों के सभी को देखने की जरूरत है
मैं के सही क्रम में करने के लिए कम से कम मिल.
तो इसका मतलब है कि हम i + 1 से सूची के अंत में देखना चाहता हूँ.
और अब, अगर तत्व है कि हम वर्तमान में देख रहे हैं हमारे न्यूनतम से कम इतनी दूर है,
जो, याद है, हम कम से कम बंद शुरू कर रहे हैं हो सकता है सिर्फ
जो भी तत्व हम वर्तमान में कर रहे हैं, मुझे लगता है कि कम से कम है.
अगर मैं एक तत्व है कि तुलना में छोटी है, तो मैं कहने जा रहा हूँ, ठीक है,
ठीक है, मैं कम से कम एक नया मिल गया है.
मुझे याद है, जहां था कि कम से कम करने के लिए जा रहा हूँ.
>> तो अब, एक बार में मैं कि सही unsorted खंड के माध्यम से चला गया है,
मैं कह सकता हूँ मैं तत्व है कि मैं इस स्थिति में है के साथ न्यूनतम तत्व स्वैप करने के लिए जा रहा हूँ.
यह मेरी सूची का निर्माण करने के लिए जा रहा है, मेरे बाएं से दाएं की सूची के अनुसार क्रमबद्ध भाग,
और हम कभी एक तत्व पर फिर से देखने की जरूरत नहीं है एक बार यह उस हिस्से में है.
एक बार जब हम यह बदली है.
तो चलो इस सूची में चयन तरह से चलाने के लिए.
नीले तत्व के लिए यहाँ मैं जा रहा है, और लाल तत्व न्यूनतम तत्व होने जा रहा है.
तो मैं सूची की बाईं पर सभी तरह से शुरू होता है, तो 5 बजे.
अब हम न्यूनतम unsorted तत्व को खोजने की जरूरत है.
तो हम कह 0 <5, 0 मेरी नई न्यूनतम है.
>> लेकिन मैं वहाँ रोक नहीं है, क्योंकि भले ही हम पहचान सकते हैं कि 0 छोटी कर सकते हैं,
हम सुनिश्चित करने के लिए सूची के हर दूसरे तत्व के माध्यम से चलाने की जरूरत है.
1 तो बड़ा है, 6 बड़ा है, 4 बड़ा है.
इसका मतलब है कि इन तत्वों के सभी को देखने के बाद, मैं निर्धारित किया है 0 सबसे छोटी है.
तो मैं 5 और 0 स्वैप करने के लिए जा रहा हूँ.
एक बार मुझे लगता है कि स्वैप, मैं एक नई सूची हासिल करने जा रहा हूँ, और मुझे पता है कि मैं जरूरत 0 कि फिर से देखने के लिए कभी नहीं
क्योंकि एक बार मैं यह बदली है, मैं इसे हल किया है और हम कर रहे हैं.
अब यह सिर्फ इतना होता है कि नीले तत्व फिर से 5,
और हम 1 में देखने की जरूरत है, तो 6 और 4 के लिए है कि 1 निर्धारित
छोटी न्यूनतम तत्व है, इसलिए हम 1 और 5 स्वैप करेंगे.
फिर, हम को देखने की जरूरत है - 6 और 4 से 5 की तुलना,
और हम 4 और 5 स्वैप करने के लिए जा रहे हैं, और अंत में की तुलना
उन 2 नंबर और उन्हें स्वैप जब तक हम अपने क्रमबद्ध सूची मिलता है.
चयन प्रकार पर कोई सवाल?
ठीक है. चलो यहाँ पिछले विषय ले जाने के लिए, और कहा कि recursion है.
>> Recursion, याद है, यह वास्तव में मेटा बात है, जहां एक समारोह
बार - बार खुद को कहता है.
तो कुछ बिंदु पर, जबकि हमारे fuction को बार - बार खुद को बुला रहा है,
वहाँ कुछ बिंदु है जिस पर हम अपने आप को फोन बंद होने की जरूरत है.
क्योंकि अगर हम ऐसा नहीं करते, तो हम सिर्फ करने के लिए हमेशा के लिए करने के लिए जारी करने जा रहे हैं,
और हमारे कार्यक्रम समाप्त करने के लिए नहीं जा रहा है.
हम इस हालत के आधार मामले कहते हैं.
और आधार के मामले फिर से एक समारोह बुला के बजाय कहते हैं,
मैं बस कुछ मूल्य वापस करने के लिए जा रहा हूँ.
तो एक बार हम एक मूल्य लौटा दिया है, हम खुद को बुला बंद कर दिया है,
और हम इतनी दूर कर दिया है कि कॉल के बाकी भी लौट सकते हैं.
आधार के मामले के विपरीत पुनरावर्ती मामला है.
और यह तब होता है जब हम समारोह में कहा कि हम अंदर वर्तमान में कर रहे हैं एक और फोन बनाना चाहते हैं
और हम शायद, हालांकि हमेशा नहीं, अलग तर्क का उपयोग करना चाहते हैं.
>> तो अगर हम च बुलाया समारोह है, और च सिर्फ 1 तर्क ले बुलाया,
और हम बस (1) च, च (1), च (1) बुला रखने के लिए, और यह सिर्फ इतना है कि होता है
1 तर्क पुनरावर्ती के मामले में गिर जाता है, हम अभी भी जा रहे हैं कभी नहीं करने के लिए बंद है.
यहां तक ​​कि अगर हम एक आधार मामला है, हमें यकीन है कि अंततः हम उस आधार मामले मारा जा रहे हैं बनाने की जरूरत है.
हम सिर्फ इस पुनरावर्ती मामले में रहने नहीं रखते.
आम तौर पर, जब हम खुद को कहते हैं, तो हम शायद एक अलग तर्क हर बार जा रहे हैं.
यहाँ एक बहुत आसान पुनरावर्ती समारोह है.
तो यह एक संख्या का क्रमगुणित की गणना करेगी.
यहाँ शीर्ष हम हमारे आधार मामला है.
मामले में है कि n ≤ 1, हम फिर से फोन भाज्य नहीं जा रहे हैं.
हम को रोकने के लिए जा रहे हैं, हम सिर्फ कुछ मूल्य वापस करने के लिए जा रहे हैं.
अगर यह सच नहीं है, तो हम हमारे पुनरावर्ती मामले हिट करने के लिए जा रहे हैं.
यहाँ सूचना है कि हम सिर्फ भाज्य (n) नहीं बुला रहे हैं, क्योंकि वह बहुत मददगार नहीं होगा.
हम कुछ और के भाज्य कॉल करने के लिए जा रहे हैं.
>> और इसलिए आप देखते हैं, अंत में अगर हम एक भाज्य (5) या कुछ पारित कर सकते हैं,
हम (4) भाज्य और इतने पर कॉल करने के लिए जा रहे हैं, और अंततः हम इस आधार के मामले में मारा जा रहे हैं.
तो यह अच्छा लग रहा है. देखते हैं क्या होता है जब हम वास्तव में इस चलाने के लिए करते हैं.
यह हो चुकी है, और हम कहते हैं कि मुख्य एक तर्क (4) के साथ इस समारोह में कॉल करने के लिए जा रहा है.
तो एक बार भाज्य देखता है और = 4, भाज्य ही कॉल करेगा.
अब, अचानक, हम भाज्य (3) है.
तो इन कार्यों बढ़ती रखने अंततः जब तक हम अपने बेस मामले मारा जा रहे हैं.
इस बिंदु पर, इस की वापसी मूल्य वापसी (nx इस का वापसी मान) है,
इस की वापसी मूल्य nx की वापसी मूल्य है.
अंततः हम कुछ संख्या हिट की जरूरत है.
यहाँ शीर्ष पर, हम 1 वापसी का कहना है.
इसका मतलब है कि एक बार हम उस संख्या में वापसी, हम ढेर बंद इस पॉप कर सकते हैं.
तो इस भाज्य (1) किया जाता है.
जब 1 रिटर्न, इस भाज्य (1) रिटर्न, 1 इस वापसी.
इस का वापसी मान, याद है, nx की वापसी मूल्य था.
तो अचानक, इस आदमी जानता है कि मैं 2 वापस करना चाहते हैं.
>> तो याद है, इस के मूल्य वापसी सिर्फ nx वापसी मूल्य है यहाँ.
तो अब हम 3 x 2 कहते हैं, कर सकते हैं और अंत में, यहाँ हम कह सकते हैं
यह सिर्फ 4 x 3 x 2 होने जा रहा है.
और एक बार इस रिटर्न, हम मुख्य के एक पूर्णांक के अंदर करने के लिए नीचे उतरो.
Recursion पर कोई सवाल?
सही सभी. तो अंत में प्रश्नों के लिए और अधिक समय है,
लेकिन अब यूसुफ शेष विषयों को कवर किया जाएगा.
>> सभी सही [यूसुफ Ong]. तो अब है कि हम recursions के बारे में बात की है,
चलो क्या मर्ज करते तरह है के बारे में थोड़ा सा बात.
मर्ज तरह मूल रूप से संख्या की एक सूची छँटाई का एक और तरीका है.
और यह कैसे काम करता है मर्ज प्रकार के साथ है, आप एक सूची है, और हम क्या है
हम कहते हैं, चलो 2 हिस्सों में विभाजित है.
हम पहले तरह बाईं आधे पर फिर से मर्ज चलने देंगे,
तो हम सही आधा पर तरह मर्ज चलने देंगे,
और कहा कि हमें अब 2 हिस्सों क्रमबद्ध हैं देता है, और अब हम उन halves एक साथ गठबंधन करने के लिए जा रहे हैं.
यह थोड़ा मुश्किल है के लिए एक उदाहरण के बिना देखते हैं, तो हम गतियों से चलते हैं और देखेंगे कि क्या होता है.
तो आप इस सूची के साथ शुरू करते हैं, हम इसे दो हिस्सों में विभाजित है.
हम बाईं आधे पर तरह 1 मर्ज चलाने.
तो यह है कि बाईं आधा है, और अब हम उन्हें इस सूची के माध्यम से फिर से चलाने के
जो मर्ज प्रकार में पारित हो जाता है, और फिर हम देखते हैं, फिर से,
इस सूची के बाईं ओर पर है और हम उस पर छंटाई संविलय चलाते हैं.
अब, हम 2 नंबर की एक सूची के लिए नीचे उतरो,
अब बाईं आधा केवल 1 तत्व लंबा है, और हम नहीं कर सकते
एक सूची है कि आधे में केवल 1 तत्व है विभाजित, तो हम सिर्फ कहते हैं, एक बार हम 50 है,
जो सिर्फ 1 तत्व है, यह पहले से ही हल है.
>> एक बार जब हम उस के साथ कर रहे हैं, हम देख सकते हैं कि हम कर सकते हैं
इस सूची के ठीक आधे पर चलते हैं,
और 3 में भी हल किया है और तो अब है कि इस सूची के दोनों हिस्सों को हल कर रहे हैं
हम इन नंबरों वापस एक साथ शामिल हो सकते हैं.
इसलिए हम 50 और 3 पर देखो, 3 50 की तुलना में छोटे है, तो यह पहली बार में चला जाता है और फिर 50 अंदर आता है
अब, जो कुछ किया है, हम वापस जाओ कि सूची और तरह यह सही आधा.
42 यह स्वयं की संख्या है, तो यह पहले से ही हल है.
तो अब हम इन तुलना 2 और 3 42 की तुलना में छोटी है, तो है कि पहली बार में डाल दिया जाता है,
अब 42 में डाल दिया जाता है, और 50 के अंदर डाल दिया जाता है
अब, कि हल है, हम सभी तरह से वापस जाने के लिए शीर्ष पर, 1337 और 15.
ठीक है, हम अब इस सूची के बाईं आधा में देखो, 1337 के द्वारा ही है तो इसे हल है और 15 के साथ एक ही है.
तो अब हम इन संख्या 2 गठबंधन करने के लिए कि मूल सूची, 15 <1337 सॉर्ट करने के लिए,
तो यह पहली बार में चला जाता है, तो 1337 के अंदर चला जाता है
और अब हम ऊपर शीर्ष मूल सूची के दोनों हिस्सों का हल.
और हम सभी को करना है इन गठबंधन है.
हम इस सूची की पहली संख्या 2, 3 <15 को देखो, तो यह सॉर्ट सरणी में पहली बार चला जाता है.
<15 42, तो यह अब अंदर चला जाता है, 42 <1337, कि अंदर चला जाता है
<50 1337, तो यह अंदर चला जाता है और लगता है कि हम सिर्फ 2 नंबर इस सूची से दूर ले गया.
तो हम सिर्फ 2 सूचियों के बीच बारी नहीं कर रहे हैं.
हम सिर्फ शुरुआत में देख रहे हैं, और हम तत्व ले जा रहे हैं
और फिर यह हमारे सरणी में डाल छोटे है.
अब हम सब halves विलय कर दिया है और हम कर रहे हैं.
>> बारे में कोई सवाल तरह मर्ज? हाँ?
[छात्र] यदि यह अलग समूहों में विभाजित है, वे अभी क्यों नहीं है, यह एक बार विभाजित
और आप एक समूह में 3 और 2 है? [प्रश्न दुर्बोध के बाकी]
कारण, तो सवाल यह है, हम सिर्फ उस दिशा में पहला कदम नहीं क्यों उन्हें मर्ज कर सकते हैं के बाद हम उन्हें दिया है?
कारण है कि हम यह कर सकते हैं, दोनों पक्षों के बाएँ सबसे तत्वों को शुरू करने के लिए,
और फिर छोटे से एक ले और इसे में डाल दिया है, यह है कि हम जानते हैं कि इन
व्यक्तिगत सूची हल आदेश में हैं.
तो अगर मैं दोनों हिस्सों के बाएँ सबसे तत्वों को देख रहा हूँ,
मुझे पता है कि वे उन लोगों की सूची की सबसे छोटी तत्व हो जा रहे हैं.
इसलिए मैं उन्हें इस बड़ी सूची की सबसे छोटी तत्व स्थानों में डाल सकते हैं.
दूसरी ओर, अगर मैं वहाँ पर दूसरे स्तर में उन 2 सूची में देखो,
50, 3, 42, +१,३३७, और 15, उन हल नहीं कर रहे हैं.
तो अगर मैं 50 और 1337 में देखो, मैं मेरी सूची में 50 1 डाला जा रहा हूँ.
लेकिन वह वास्तव में समझ में नहीं पड़ता है, क्योंकि उन सभी से बाहर 3 छोटी तत्व है.
तो एक ही कारण है कि हम इस संयोजन कदम कर सकते हैं क्योंकि हमारी सूची में पहले से ही हल कर रहे हैं.
यही वजह है कि हम करने के लिए नीचे नीचे करने के लिए सभी तरह से है
क्योंकि जब हम सिर्फ एक ही नंबर है, तो आप यह है कि एक ही नंबर पता
में और खुद की पहले से ही एक क्रमबद्ध सूची है.
>> कोई सवाल? नहीं?
जटिलता? खैर, आप देख सकते हैं कि हर कदम पर वहाँ अंत संख्या है,
और हम आधा लॉग n बार में एक सूची में विभाजित कर सकते हैं,
जो है जहाँ हम इस n x लॉग n जटिलता मिलता.
और आप मर्ज प्रकार के लिए सबसे अच्छा मामले n लॉग एन देखते हैं, और यह सिर्फ इतना होता है
कि सबसे खराब स्थिति है, या वहाँ पर Ω भी है n n लॉग.
कुछ को ध्यान में रखना.
पर चल रहा है, चलो कुछ सुपर बुनियादी मैं / ओ फ़ाइल पर जाने
यदि आप हाथापाई पर देखा, तो आप देखेंगे कि हम प्रणाली के कुछ प्रकार था
जहाँ आप एक लॉग फ़ाइल पर लिखने के लिए अगर आप कोड के माध्यम से पढ़ सकता है.
चलो देखते हैं आप कैसे कर सकता है.
खैर, हम fprintf है, जो बस के रूप में printf के बारे में सोच सकते हैं,
लेकिन बस के बजाय एक फाइल करने के लिए मुद्रण, और इसलिए शुरुआत में च.
कोड के इस यहाँ तरह है, यह क्या करता है, के रूप में आप हाथापाई में देखा हो सकता है,
यह पंक्ति संख्या क्या कर रहे हैं द्वारा पंक्ति अपने सरणी 2 आयामी मुद्रण के माध्यम से बाहर चला जाता है.
इस मामले में, printf अपने टर्मिनल के लिए बाहर प्रिंट या हम क्या कॉल अनुभाग के मानक उत्पादन.
>> और अब, इस मामले में, हम सभी को करना है fprintf साथ printf की जगह है,
यह बताओ कि क्या आप फ़ाइल मुद्रित करने के लिए करना चाहते हैं, और इस मामले में यह सिर्फ यह प्रिंट कि फाइल करने के लिए बाहर
के बजाय यह मुद्रण अपने टर्मिनल.
ठीक है, तो सवाल begs: हम कहाँ से फ़ाइल के इस प्रकार मिलता है, है ना?
हम इस fprintf fuction में लॉग इन करने के लिए पारित किया है लेकिन हमें पता नहीं कहाँ से आया था.
खैर, जल्दी कोड में हम क्या यहाँ पर इस कोड का हिस्सा था,
जो मूल रूप से कहते हैं कि खुले फ़ाइल log.txt कॉल.
हम के बाद क्या वह यह है कि हम यह सुनिश्चित करें कि फ़ाइल वास्तव में सफलतापूर्वक खोला है.
तो यह कई कारणों के लिए असफल हो सकता है, आप अपने कंप्यूटर पर पर्याप्त जगह नहीं है, उदाहरण के लिए,.
तो यह हमेशा महत्वपूर्ण है इससे पहले कि आप फ़ाइल के साथ कोई कार्रवाई
कि हम जाँच करें कि क्या कि फ़ाइल सफलतापूर्वक खोला गया.
तो क्या है कि एक, कि fopen के लिए एक तर्क है, ठीक है, हम कई मायनों में एक फ़ाइल को खोल सकते हैं.
हम क्या कर सकते हैं, हम यह w गुजरती हैं, कर सकते हैं जो फ़ाइल को अधिलेखित का मतलब है पहले से ही अगर यह बाहर निकलता है,
हम एक एक के पास है, जो वे फाइल के अंत करने के बजाय यह अधिभावी संलग्न कर सकते हैं,
या हम r निर्दिष्ट करने के लिए, जो मतलब कर सकते हैं, के रूप में केवल पढ़ने के लिए फ़ाइल को खोलने के.
तो अगर कार्यक्रम फ़ाइल में किसी भी परिवर्तन करने की कोशिश करता है,
उन पर चिल्लाओ और उन्हें यह करना नहीं है.
अंत में, एक बार हम फाइल के साथ कर रहे हैं, किया इस पर कार्रवाई कर रही है,
हमें यकीन है कि हम फ़ाइल बंद करने की जरूरत है.
और इसलिए अपने कार्यक्रम के अंत में, आप उन्हें फिर से पारित करने जा रहे हैं
इस फाइल कि आप खोला है, और बस इसे बंद.
तो यह कुछ महत्वपूर्ण है कि आप यकीन है कि तुम क्या करना है.
तो याद है आप एक फ़ाइल खोल सकते हैं, तो आप फ़ाइल के लिए लिख सकते हैं,
फ़ाइल में संचालन करते हैं, लेकिन फिर तुम अंत में फ़ाइल को बंद करना होगा.
>> बुनियादी फ़ाइल पर कोई प्रश्न मैं / हे? हाँ?
[छात्र सवाल है, unintelligible]
यहाँ ठीक है. सवाल है, जहां इस log.txt फ़ाइल प्रकट नहीं होता है?
वैसे, अगर आप सिर्फ यह log.txt दे, यह निष्पादन योग्य के रूप में एक ही निर्देशिका में बनाता है.
तो अगर you're - >> [छात्र सवाल है, unintelligible]
हां. उसी फ़ोल्डर में, या एक ही निर्देशिका में है, के रूप में आप यह कहते हैं.
अब स्मृति, ढेर, और ढेर.
तो कैसे स्मृति कंप्यूटर में बाहर रखी है?
खैर, आप यहाँ इस ब्लॉक की तरह के रूप में स्मृति की कल्पना कर सकते हैं.
और हम स्मृति में क्या वहाँ पर अटक ढेर और ढेर कहा जाता है कि वहाँ नीचे है.
और ढेर नीचे की ओर बढ़ता है और ढेर ऊपर की ओर बढ़ता है.
के रूप में तो टॉमी उल्लेख किया है - ओह, ठीक है, और हम इन अन्य 4 वर्ग जो मैं एक दूसरे में मिल जाएगा -
के रूप में टॉमी पहले कहा, आप जानते हैं कि कैसे अपने कार्यों खुद कहते हैं और एक दूसरे को फोन?
वे स्टैक फ्रेम का इस तरह का निर्माण.
वैसे, अगर मुख्य foo कॉल, foo ढेर पर डाल दिया जाता है.
फू कॉल बार, बार पाने के ढेर पर डाल दिया, और कहा कि के बाद ढेर पर डाल दिया जाता है.
और के रूप में वे वापस, वे एक बंद ढेर ले लिया हो.
इन स्थानों में से प्रत्येक स्मृति और क्या करना है?
खैर, ऊपर, जो पाठ खंड कार्यक्रम में ही शामिल हैं.
तो मशीन कोड, कि वहाँ है, एक बार आप अपने कार्यक्रम संकलन.
अगला, किसी भी वैश्विक चर initialized.
>> तो आप अपने प्रोग्राम में वैश्विक चर है, और आप की तरह, एक = 5 कहते हैं,
उस खंड में डाल दिया जाता है, और सही है कि के तहत,
आप किसी भी uninitialized वैश्विक डेटा है, जो सिर्फ एक int है,
लेकिन आप यह नहीं कह कि यह कुछ भी करने के लिए बराबर है.
पता है इन वैश्विक चर रहे हैं, तो वे मुख्य के बाहर हो.
तो यह किसी भी वैश्विक चर है कि घोषित कर रहे हैं लेकिन initialized नहीं कर रहे हैं मतलब है.
तो ढेर में क्या है? मेमोरी आवंटित malloc, जो हम करने के लिए एक छोटा सा में मिलेगा का उपयोग.
और अंत में, ढेर के साथ आप किसी भी स्थानीय चर
और किसी भी कार्य आप अपने मापदंडों में से किसी में कॉल कर सकते हैं.
आखिरी बात, तुम सच में पता करने के लिए वातावरण चर क्या करना नहीं है,
लेकिन जब भी आप प्रोग्राम चलाते हैं, वहाँ जुड़े कुछ की तरह है,
यह व्यक्ति जो कार्यक्रम दौड़ा उपयोक्तानाम है.
और उस के तल पर तरह की होने जा रहा है.
स्मृति पते, जो हेक्साडेसिमल मान रहे हैं के संदर्भ में,
0 में शीर्ष शुरू में मूल्यों, और वे सभी रास्ते जाने के नीचे करने के लिए नीचे.
इस मामले में, अगर आप 32-bit प्रणाली पर हैं,
नीचे में पता करने के लिए 0x होने जा रहा है, वायुसेना द्वारा पीछा किया, कि क्योंकि 32 बिट है,
जो 8 बाइट्स है, और इस मामले में 8 बाइट्स 8 हेक्साडेसिमल अंक से मेल खाती है.
तो यहाँ नीचे आप के लिए है, जैसे, 0xffffff जा रहे हैं, और वहाँ आप 0 के लिए जा रहे हैं.
तो क्या संकेत हैं? आप में से कुछ इस खंड में नहीं है इससे पहले कि कवर किया जा सकता है.
लेकिन हम इस पर व्याख्यान में जाना था, तो एक सूचक सिर्फ एक डेटा प्रकार है
भंडार है जो, 50 की तरह मूल्य के कुछ प्रकार के बजाय, यह स्मृति में कुछ स्थान के पते भंडार.
कि स्मृति की तरह [unintelligible].
तो इस मामले में, हम क्या है, हम एक पूर्णांक या एक int * एक सूचक है,
और यह 0xdeadbeef का इस हेक्साडेसिमल पता होता है.
>> तो हम क्या है, अब, स्मृति में कुछ स्थान पर इस सूचक अंक,
और वह सिर्फ एक, 50 मूल्य इस स्मृति स्थान पर है.
कुछ 32 बिट सिस्टम पर, सभी 32 बिट सिस्टम पर, संकेत 32 बिट या 4 बाइट्स ले.
लेकिन, उदाहरण के लिए, एक 64-bit प्रणाली पर, संकेत 64 बिट कर रहे हैं.
तो यह है कि कुछ आप को ध्यान में रखना चाहता हूँ.
तो एक अंत बिट प्रणाली पर एक सूचक अंत बिट लंबा है.
सूचक की तरह अतिरिक्त चीजों के बिना को पचाने में मुश्किल कर रहे हैं,
तो चलो गतिशील स्मृति आवंटन के एक उदाहरण के माध्यम से जाना.
क्या आप के लिए गतिशील स्मृति आवंटन करता है, या हम क्या malloc कहते हैं,
यह आपको सेट के बाहर डेटा के कुछ प्रकार आवंटित.
तो इस डेटा की तरह है और कार्यक्रम की अवधि के लिए स्थायी.
क्योंकि जैसा कि आप जानते हैं, यदि आप एक समारोह के अंदर एक्स, और उस समारोह रिटर्न घोषित,
अब आप कोई डेटा कि x में संग्रहीत किया गया था, के लिए उपयोग है.
संकेत हमें करना क्या है वे हमें स्मृति या दुकान मूल्यों की दुकान
स्मृति का एक अलग खंड, अर्थात् ढेर में.
अब एक बार हम समारोह के लौटने के लिए, के रूप में लंबे समय के रूप में हम एक सूचक है
स्मृति में उस स्थान पर है, तो हम क्या कर सकते हैं हम सिर्फ वहाँ मूल्यों पर देख सकते हैं.
चलो एक उदाहरण में देखें: यह हमारी स्मृति लेआउट फिर से है.
और हम इस समारोह है, मुख्य है.
यह क्या करता है - ठीक है, इतना आसान है, सही? Int x = 5, कि बस मुख्य ढेर पर एक चर है.
>> दूसरी ओर, अब हम एक सूचक है जो समारोह giveMeThreeInts कॉल की घोषणा.
और इसलिए अब हम इस समारोह में जाने के लिए और हम इसके लिए एक नया ढेर फ्रेम बनाने.
हालांकि, इस ढेर फ्रेम में, हम int अस्थायी * घोषित,
जो हमारे लिए mallocs 3 integers में.
तो int के आकार हमें दे कितने बाइट्स int है,
और malloc हमें देता है कि ढेर पर अंतरिक्ष के कई बाइट्स.
तो इस मामले में, हम 3 integers के लिए पर्याप्त स्थान बनाया है,
ढेर और जिस तरह से वहाँ है, जो कारण है कि मैं इसे उच्च ऊपर खींचा है.
एक बार जब हम कर रहे हैं, हम वापस यहाँ आते हैं, आप केवल जरूरत 3 ints लौटा,
और यह पता देता है, इस मामले में जहां कि स्मृति है.
और हम सूचक स्विच = सेट, और वहाँ हम सिर्फ एक सूचक है.
लेकिन क्या है कि समारोह रिटर्न यहाँ खड़ी है और गायब हो जाता है.
तो अस्थायी गायब हो जाता है, लेकिन हम अभी भी जहां के पते को बनाए रखने
उन 3 integers साधन के अंदर हैं.
इस सेट में, संकेत scoped स्थानीय स्तर पर कर रहे हैं stacked फ्रेम के लिए,
लेकिन स्मृति जो वे उल्लेख के ढेर में है.
>> क्या इसका यह मतलब है?
[छात्र] क्या आप इसे फिर से कह सकते हैं? >> [जोसेफ] हाँ.
तो अगर मैं सिर्फ एक छोटा सा वापस जाना है, तो आप देखते हैं कि अस्थायी आवंटित
वहाँ ढेर पर कुछ स्मृति.
इसलिए जब इस समारोह रिटर्न giveMeThreeInts, यहाँ इस ढेर के लिए गायब हो जा रहा है.
और यह चर के किसी भी, इस मामले में, यह सूचक कि stacked फ्रेम में आवंटित किया गया था.
यह करने के लिए गायब हो जा रहा है, लेकिन जब से हम अस्थायी लौटे
और हम सूचक सेट = अस्थायी, सूचक अब एक ही स्थान की स्मृति के रूप में अस्थायी था बिंदु जा रहा है.
तो अब, भले ही हम अस्थायी, कि स्थानीय सूचक खो देते हैं,
हम अभी भी यह क्या कि चर सूचक के अंदर करने के लिए इशारा कर रहा था की स्मृति पते बनाए रखने के लिए.
प्रश्न? यह एक भ्रामक विषय की तरह हो सकता है अगर आप इस पर खंड में नहीं चले गए हैं कर सकते हैं.
हम निश्चित रूप से, अपने TF करेंगे कर सकते हैं इसे खत्म हो जाना और हम निश्चित रूप से सवाल जवाब कर सकते
इस के लिए समीक्षा सत्र के अंत में.
लेकिन यह एक जटिल विषय की तरह है, और मैं अधिक उदाहरण है कि को दिखाने के लिए जा रहे हैं
में मदद करेगा कि स्पष्ट संकेत वास्तव में क्या कर रहे हैं.
>> इस मामले में, संकेत arrays के लिए बराबर हैं,
इसलिए मैं सिर्फ एक int सरणी के रूप में एक ही बात के रूप में इस सूचक का उपयोग कर सकते हैं.
तो मैं 0 में अनुक्रमण कर रहा हूँ, और 1 1 पूर्णांक बदलने,
2 2 पूर्णांक बदल रहा है, और 3 के लिए 3 पूर्णांक.
तो संकेत पर अधिक है. खैर, Binky याद करते हैं.
इस मामले में हम एक सूचक आवंटित है, या हम एक सूचक की घोषणा की है,
लेकिन शुरू में, जब मैं सिर्फ एक सूचक की घोषणा की है, यह स्मृति में कहीं भी नहीं इशारा कर रहा है.
यह बस के अंदर कचरा मूल्यों है.
तो मुझे पता नहीं है जहां यह सूचक की ओर इशारा करते है.
यह एक पता है जो सिर्फ 0 और 1 जहां यह शुरू में घोषित किया गया था के साथ भरा है.
मैं इस के साथ कुछ भी नहीं है जब तक मैं उस पर malloc कॉल कर सकते हैं
और तब यह मुझे ढेर पर एक छोटी सी जगह है जहां मैं मान अंदर डाल सकते हैं देता है.
तो फिर, मैं नहीं जानता कि क्या इस स्मृति के अंदर है.
पहली बात तो मुझे क्या करना है यह है कि जाँच करें कि क्या प्रणाली पर्याप्त स्मृति था
मुझे वापस दे पहली जगह है, जो कारण है कि मैं कर रहा हूँ कि इस जांच में 1 पूर्णांक.
यदि सूचक अशक्त है, इसका मतलब है कि यह करने के लिए पर्याप्त जगह है या कुछ अन्य त्रुटि हुआ नहीं था,
इसलिए मैं अपने कार्यक्रम के बाहर से बाहर निकलना चाहिए.
लेकिन अगर यह सफल था, अब मुझे लगता है कि सूचक का उपयोग कर सकते हैं
और * सूचक क्या करता है यह इस प्रकार है, जहां पता है
कि मूल्य है, जहां है और यह 1 के बराबर सेट.
तो यहाँ पर, हम अगर अस्तित्व में है कि स्मृति की जाँच कर रहे हैं.
>> एक बार जब आप जानते हैं कि यह मौजूद है, तो आप इसे में डाल सकते हैं
इस मामले में 1, क्या मूल्य तुम इसे में लाना चाहते हैं.
एक बार जब हम इसके साथ कर रहे हैं, तो आप कि सूचक मुक्त करने की जरूरत है
क्योंकि हम प्रणाली है कि आप पहली जगह में कहा है कि स्मृति को वापस लाने की जरूरत है.
क्योंकि कंप्यूटर नहीं पता है जब हम इसके साथ कर रहे हैं.
इस मामले में हम स्पष्ट रूप से यह कह रहे हैं, ठीक है, हम उस स्मृति के साथ कर रहे हैं.
यदि कुछ अन्य प्रक्रिया की जरूरत है, कुछ अन्य कार्यक्रम की जरूरत है, आगे जाने के लिए और इसे लेने के लिए स्वतंत्र महसूस हो रहा है.
हम भी क्या कर सकते हैं हम सिर्फ सेट पर स्थानीय चर का पता प्राप्त कर सकते है.
तो int x मुख्य की खड़ी फ्रेम के अंदर है.
और जब हम इस एम्परसेंड का उपयोग करते हैं, तो यह और ऑपरेटर, यह क्या करता है
यह एक्स लेता है, और x सिर्फ स्मृति में कुछ डेटा है, लेकिन यह एक पता है.
यह कहीं स्थित है. तो बुला और एक्स, यह क्या करता है यह हमारे x का पता देता है.
ऐसा करके, हम जहाँ x स्मृति में सूचक बात कर रहे हैं.
अब हम सिर्फ पसंद करते है * कुछ x करते हैं, हम कर रहे हैं 5 वापस पाने के लिए जा रहा है.
सितारा इसे अपसंदर्भन बुलाया है.
आप पते का पालन करें और आप के मूल्य में संग्रहीत.
>> कोई सवाल? हाँ?
[छात्र] यदि आप 3 उठाई बात नहीं करते हैं, यह अभी भी संकलन?
हां. यदि आप 3-सूचक बात नहीं करते हैं, यह अभी भी संकलन करने के लिए जा रहा है,
लेकिन मैं तुम्हें दिखाने के लिए, एक दूसरे में क्या होता है और कर रही है कि बिना,
है कि हम क्या एक स्मृति रिसाव कहते हैं. तुम प्रणाली नहीं दे रहे हैं
अपनी स्मृति वापस करने के लिए, तो एक के बाद जबकि कार्यक्रम जमा करने के लिए जा रहा है
स्मृति कि यह नहीं है और यह और कुछ नहीं का उपयोग कर सकते हैं.
यदि आप कभी भी अपने कंप्यूटर पर 1.5 लाख किलोबाइट के साथ देखा है फ़ायरफ़ॉक्स,
कार्य प्रबंधक में, यह है कि क्या हो रहा है.
आप प्रोग्राम है कि वे नहीं संभाल रहे हैं में एक स्मृति रिसाव है.
तो कैसे सूचक गणित काम करता है?
खैर, सूचक गणित एक सरणी में तरह अनुक्रमण की तरह है.
इस मामले में, मैं एक सूचक है, और मुझे क्या करना है मैं पहले तत्व के लिए सूचक बिंदु बना
3 integers कि मैं आवंटित है की इस सरणी की.
तो अब मैं क्या करूँ, सितारा सूचक सूची में पहला तत्व परिवर्तन.
स्टार सूचक यहाँ पर एक अंक.
एक सूचक है, तो यहाँ पर संकेतक है यहाँ पर है, दो सूचक यहाँ पर है.
>> तो बस 1 जोड़ने के इस सरणी के साथ आगे बढ़ के रूप में एक ही बात है.
हमें क्या करना है, जब हम एक सूचक आप यहाँ पर पता मिलता है,
और यहाँ में मूल्य प्राप्त करने के क्रम में, आप पूरे अभिव्यक्ति से में एक सितारा
यह भिन्नता.
तो, इस मामले में, मैं 1 के लिए इस सरणी में पहला स्थान स्थापित कर रहा हूँ,
2 दूसरा स्थान, और 3 के लिए 3 स्थान.
तो क्या मैं कर रहा हूँ यहाँ मैं अपने एक सूचक मुद्रण कर रहा हूँ,
जो सिर्फ मुझे 2 देता है.
अब मैं सूचक incrementing रहा हूँ, तो सूचक एक सूचक बराबर होती है,
जो आगे बढ़ता रहता है.
और इसलिए अब अगर मैं एक सूचक मुद्रित करने के लिए, सूचक एक अब 3,
जो इस मामले में 3 बाहर प्रिंट.
और आदेश में मुफ्त कुछ, सूचक है कि मैं इसे देना
सरणी जो मैं malloc से वापस मिल गया की शुरुआत में इशारा किया जाना चाहिए.
तो, इस मामले में, अगर मैं 3 सही यहाँ कॉल करने के लिए गए थे, यह सही नहीं होगा,
क्योंकि यह सरणी के बीच में है.
मैं मूल स्थान को पाने घटाना है
प्रारंभिक पहले स्थान से पहले मैं इसे मुक्त कर सकते हैं.
तो, यहाँ एक और अधिक शामिल उदाहरण है.
इस मामले में, हम एक चरित्र सरणी में 7 अक्षर का आवंटन कर रहे हैं.
>> और इस मामले में हम क्या कर रहे हैं हम उनमें से पहले 6 पर पाशन कर रहे हैं,
और हम उन्हें जेड के लिए स्थापित कर रहे हैं
तो, int के लिए i = 0, मैं 6>, मैं + +,
तो, सूचक + मैं सिर्फ हमें इस मामले में दे देंगे,
सूचक, एक सूचक, सूचक 2, 3 सूचक, और इतने पर और आगे पाश में.
यह करने के लिए क्या हो रहा है यह है कि पता हो जाता है, यह dereferences मूल्य पाने के लिए,
और बदलाव है कि एक जेड के लिए मूल्य
फिर अंत में याद है कि यह एक स्ट्रिंग है, है ना?
सभी तार अशक्त समाप्त चरित्र के साथ समाप्त करने के लिए है.
तो, मुझे क्या करना है सूचक 6 में मैं अंदर अशक्त टर्मिनेटर चरित्र डाला
और अब मैं क्या मूल रूप से यहाँ क्या कर रहा हूँ printf एक स्ट्रिंग के लिए लागू कर रहा है?
>> तो, अब printf जब जब यह एक स्ट्रिंग के अंत तक पहुँच?
अशक्त समाप्त चरित्र हिट.
तो, इस मामले में, मेरे इस सरणी की शुरुआत करने के लिए मूल सूचक अंक.
मैं 1 चरित्र प्रिंट बाहर. मैं इसे एक से अधिक चलते हैं.
मुझे लगता है कि चरित्र प्रिंट बाहर. मैं इसे स्थानांतरित.
और मैं यह कर जब तक मैं अंत तक पहुँचने रखना.
और अब अंत * संकेतक भिन्नता और अशक्त समाप्त चरित्र वापस मिल जाएगा.
और इसलिए मेरे जबकि पाश चलाता है केवल जब कि मूल्य अशक्त समाप्त चरित्र नहीं है.
तो, अब मैं इस पाश से बाहर निकलें.
और यदि ऐसा है तो मैं इस सूचक से 6 घटाना,
मैं वापस शुरू करने के लिए सभी रास्ते जाओ.
याद है, मैं यह कर रहा हूँ क्योंकि मैं शुरू करने के लिए जाने के क्रम में यह मुक्त है.
>> तो, मुझे पता है कि एक बहुत कुछ था. वहाँ किसी भी सवाल?
कृपया, हाँ?
[छात्र प्रश्न unintelligible]
आप कह सकते हैं कि जोर से? माफ़ कीजिए.
[छात्र] पिछली स्लाइड सही से पहले आप सूचक मुक्त कर दिया,
आप वास्तव में जहां सूचक के मूल्य बदल रहा है?
[यूसुफ] तो, ठीक है यहाँ. >> [छात्र] ओह, ठीक है.
[यूसुफ] तो, मैं एक सूचक ऋण ऋण है, सही है,
जो बात वापस एक चलता है, और फिर मैं इसे मुक्त,
क्योंकि यह सूचक सरणी की शुरुआत की ओर इशारा किया है.
[छात्र] लेकिन यह है कि आपको लगता है कि लाइन के बाद बंद कर दिया था की जरूरत नहीं होगा.
तो [यूसुफ], अगर मैं इस के बाद बंद कर दिया था, यह एक स्मृति रिसाव माना किया जाएगा,
क्योंकि मैं मुक्त नहीं चला था.
[छात्र] मैं [unintelligible] पहली तीन पंक्तियों के बाद जहां आप एक सूचक [unintelligible] था.
[यूसुफ] उह. तो, वहाँ सवाल क्या है?
माफ़ कीजिए. नहीं, नहीं. जाओ, जाओ, कृपया.
तो [छात्र], आप संकेत के मूल्य नहीं बदल रहे हैं.
आप सूचक ऋण ऋण नहीं होता था.
[यूसुफ] हाँ, बिल्कुल.
तो, जब मैं एक सूचक और सूचक दो
मैं सूचक नहीं कर रहा हूँ एक सूचक के बराबर होती है.
तो, सूचक सरणी की शुरुआत में सिर्फ इशारा रहता है.
यह केवल जब मैं प्लस प्लस कि यह सूचक के अंदर मूल्य वापस सेट,
कि यह वास्तव में साथ यह बढ़ता रहता है.
सही सभी.
और सवाल?
>> फिर, अगर यह भारी की तरह है, इस सत्र में कवर किया जाएगा.
इसके बारे में अपने अध्यापन साथी से पूछो, और हम अंत में सवाल जवाब कर सकते हैं.
और आम तौर पर हम इस शून्य से बात करना पसंद नहीं है.
यह मुझे कितना मैं सरणी में ऑफसेट है का ट्रैक रखने की आवश्यकता है.
तो, सामान्य रूप में, यह सिर्फ कैसे काम करता है सूचक गणित समझाने.
लेकिन हम आम तौर पर क्या करना पसंद है हम सूचक की एक प्रतिलिपि बनाने के लिए करना है,
और फिर हम उस प्रतिलिपि का उपयोग जब हम चारों ओर स्ट्रिंग में आगे बढ़ रहे हैं.
तो, इन मामले में आप प्रति पूरे स्ट्रिंग मुद्रित करने के लिए उपयोग करते हैं,
लेकिन हम सूचक शून्य से 6 की तरह नहीं है या कितना हम इस में चले गए ट्रैक रखने के लिए,
सिर्फ इसलिए कि हम जानते हैं कि हमारे मूल बिंदु अभी भी सूची की शुरुआत करने के लिए कहा जाता है
और सभी कि हम इस प्रतिलिपि का बदल दिया था.
तो, सामान्य रूप में, अपने मूल सूचक की प्रतियां बदल.
की कोशिश मत करो की तरह की तरह मूल प्रतियों को बदलने नहींं.
अपने मूल के केवल प्रतियां को बदलने की कोशिश कर रहा है.
तो, तुम नोटिस जब हम printf में स्ट्रिंग पारित
आप इसे के सामने में एक सितारा डाल जैसे हम अन्य सभी dereferences के साथ किया था नहीं है, है ना?
तो, अगर तुम बाहर प्रिंट पूरे स्ट्रिंग% s की उम्मीद है एक पता है,
और इस मामले में एक सूचक या वर्णों की एक सरणी की तरह इस मामले में.
>> वर्ण, चार * arrays और एक ही बात कर रहे हैं.
सूचक वर्ण के लिए है, और चरित्र arrays एक ही बात कर रहे हैं.
और हां, तो हम सभी को करना है सूचक में पास है.
हम * सूचक या ऐसा कुछ की तरह पास नहीं है.
तो, arrays और संकेत एक ही बात कर रहे हैं.
जब आप एक्स की तरह कुछ कर रहे हैं यहाँ पर एक सरणी के लिए [y]
यह हुड के नीचे क्या कर रहा है यह कह रहा है, ठीक है, यह एक चरित्र सरणी है,
तो यह एक संकेत है.
और इसलिए x एक ही बात कर रहे हैं,
और इसलिए यह क्या करता है यह एक्स के लिए y कहते हैं,
जो स्मृति में आगे है कि ज्यादा से आगे बढ़ के रूप में एक ही बात है.
और अब x + y हमें पते के कुछ प्रकार देता है,
और हम पता भिन्नता या तीर का पालन करें
स्मृति में है कि जहां स्थान है और हम स्मृति में उस स्थान का मूल्य बाहर निकलना.
ऐसा है, तो इन दोनों वास्तव में एक ही बात कर रहे हैं.
यह सिर्फ एक वाक्यात्मक चीनी है.
वे एक ही बात करते हैं. वे एक दूसरे के लिए सिर्फ अलग syntactics हो.
>> तो, क्या संकेत के साथ गलत जा सकते हैं? की तरह, एक बहुत. ठीक है. तो, बुरी बातें.
कुछ बुरी चीजें आप कर सकते हैं अगर आपके malloc कॉल अशक्त सही रिटर्न नहीं की जाँच कर रहे हैं?
इस मामले में, मैं प्रणाली पूछ रहा हूँ मुझे दे कि संख्या क्या है?
2 4 अरब बार की तरह है, क्योंकि एक पूर्णांक के आकार 4 बाइट्स है.
मैं इसके लिए 8 अरब बाइट्स की तरह पूछ रहा हूँ.
बेशक मेरे कंप्यूटर मुझे इतना याददाश्त वापस देने के लिए सक्षम होने के लिए नहीं जा रहा है.
और अगर हम यह शून्य है की जाँच नहीं था, इसलिए जब हम यह वहाँ पर भिन्नता की कोशिश -
जहां यह जा रहा है के लिए तीर का पालन - हम कि स्मृति नहीं है.
यह है कि क्या हम एक शून्य सूचक dereferencing कॉल.
और यह अनिवार्य रूप से आप segfault का कारण बनता है.
यह तरीके आप segfault कर सकते हैं में से एक है.
अन्य बुरी बातें आप कर सकते हैं - ओह अच्छी तरह से.
यह एक शून्य सूचक dereferencing किया गया था. ठीक है.
अन्य बुरी बातें अच्छी तरह से ठीक करने के लिए, कि तुम सिर्फ वहाँ में एक जांच डाल
कि जाँच करता है कि सूचक अशक्त है
और इस कार्यक्रम से बाहर निकलें अगर ऐसा होता है कि malloc एक शून्य सूचक देता है.
Xkcd हास्य है. लोग अब यह समझ में. के आधार पर छाँटें.
>> तो स्मृति. और मैं इस पर चला गया.
हम एक पाश में malloc बुला रहे हैं, लेकिन हर बार हम malloc कॉल
हम जहां यह सूचक की ओर इशारा करते है का ट्रैक खो रहे हैं,
क्योंकि हम यह clobbering रहे हैं.
तो, malloc आरंभिक कॉल मुझे देता स्मृति यहाँ.
इस पर मेरी सूचक संकेत.
अब, मैं इसे मुक्त नहीं है, तो अब मैं malloc फिर से फोन किया.
अब यह खत्म अंक यहाँ. अब मेरी स्मृति यहाँ पर इशारा कर रहा है.
यहाँ ओर इशारा करते हुए. यहाँ ओर इशारा करते हुए.
लेकिन मैं यहाँ कि मैं आवंटित सभी स्मृति के पते का ट्रैक खो दिया.
और इसलिए अब मैं उन्हें किसी भी संदर्भ अब और नहीं है.
तो, मैं उन्हें इस लूप के बाहर मुक्त नहीं कर सकते हैं.
और इतने में आदेश कुछ इस तरह तय करने के लिए,
अगर आप स्मृति मुक्त करने के लिए भूल जाते हैं और आप इस स्मृति रिसाव हो,
आप इस लूप के अंदर स्मृति मुक्त एक बार आप इसके साथ कर रहे है.
खैर, यह क्या होता है. मैं जानता हूँ कि आप में से बहुत से इस से नफरत है.
लेकिन अब याय! आप 44,000 किलोबाइट की तरह मिलता है.
इसलिए, आप यह लूप के अंत में मुक्त
और कहा कि सिर्फ स्मृति हर समय मुक्त करने के लिए जा रहा है.
मूलतः, अपने कार्यक्रम स्मृति रिसाव अब और नहीं है.
>> और अब आप कर सकते हैं और कुछ के कुछ स्मृति मुक्त कि आप दो बार के लिए कहा है.
इस मामले में, आप malloc कुछ है, तो आप अपने मूल्य बदल जाते हैं.
आप इसे मुफ्त क्योंकि एक बार आप ने कहा कि आप इसके साथ किया गया.
लेकिन तब हम इसे फिर से मुक्त कर दिया.
यह कुछ है कि बहुत बुरा है.
यह शुरू में segfault नहीं जा रहा है,
लेकिन एक के बाद जबकि इस डबल क्या है इस भ्रष्ट अपने ढेर संरचना मुक्त
और आप एक छोटा सा इस बारे में और अधिक जानने के लिए अगर आप CS61 तरह एक क्लास लेने का चयन करेंगे.
लेकिन अनिवार्य रूप से एक के बाद जब आपके कंप्यूटर को उलझन में मिल जा रहा है
स्मृति स्थानों क्या कर रहे हैं और जहां जहां यह संग्रहीत किया जाता है के बारे में -
जहां डेटा स्मृति में संग्रहीत किया जाता है.
और इसलिए एक सूचक मुक्त दो बार एक बुरी बात यह है कि आप नहीं करना चाहती है.
>> अन्य चीजें हैं जो गलत जा सकते हैं sizeof का उपयोग नहीं कर रहा है.
तो, इस मामले में आप 8 बाइट्स malloc,
और कहा कि दो integers के रूप में एक ही बात है, है ना?
तो, कि पूरी तरह से सुरक्षित है, लेकिन यह क्या है?
ठीक है, के रूप में लुकास अलग architectures पर के बारे में बात की थी,
integers अलग लंबाई की हैं.
तो, उपकरण है कि आप का उपयोग कर रहे हैं पर, पूर्णांकों के बारे में 4 बाइट्स हैं,
लेकिन वे कुछ अन्य प्रणाली पर 8 बाइट्स हो सकता है या वे 16 बाइट्स हो सकता है हो सकता है.
तो, अगर मैं सिर्फ यहाँ पर इस नंबर का उपयोग करने के लिए,
इस कार्यक्रम के उपकरण पर काम कर सकते हैं,
लेकिन यह कुछ अन्य प्रणाली पर पर्याप्त स्मृति आवंटित करने के लिए नहीं जा रहा है.
इस मामले में, यह है कि क्या sizeof ऑपरेटर के लिए प्रयोग किया जाता है.
जब हम कहते हैं sizeof (int), यह क्या करता है
यह हमें प्रणाली है कि प्रोग्राम चल रहा है पर एक पूर्णांक के आकार देता है.
तो, इस मामले में, sizeof (int) उपकरण की तरह कुछ पर 4 वापस आ जाएगी,
और अब इस वसीयत 4 2 * है, जो 8 है,
जो सिर्फ दो integers के लिए आवश्यक स्थान की राशि है.
एक अलग सिस्टम पर, अगर एक int 16 बाइट्स या 8 बाइट की तरह है,
यह सिर्फ पर्याप्त बाइट्स वापस करने के लिए है कि राशि की दुकान के लिए जा रहा है.
>> और अंत में, structs.
तो, अगर आप स्मृति में एक sudoku बोर्ड की दुकान चाहता था, कैसे हम इस कर सकता है?
आप पहली बात के लिए एक चर की तरह लगता है कि हो सकता है,
दूसरी बात, तीसरी बात के लिए एक चर के लिए एक चर,
बुरा, सही - चौथी बात के लिए एक चर?
तो, एक सुधार आप इस के शीर्ष पर एक 9 एक्स 9 सरणी बनाने के लिए कर सकते हैं.
यह ठीक है, लेकिन क्या अगर आप sudoku बोर्ड के साथ अन्य बातों सहयोगी चाहता था
जैसे बोर्ड की कठिनाई क्या है,
या, उदाहरण के लिए, अपने स्कोर क्या है, या कितना समय यह आप इस बोर्ड को हल करने के लिए ले लिया है?
ठीक है, तुम क्या कर सकते है आप एक struct बना सकते हैं.
मैं मूल रूप से कह रहा हूँ क्या मैं यहाँ पर इस संरचना को परिभाषित कर रहा हूँ,
और मैं एक sudoku बोर्ड है जो एक बोर्ड है कि 9 एक्स 9 के होते हैं परिभाषित कर रहा हूँ.
>> और यह क्या है यह स्तर के नाम करने के लिए संकेत है.
यह भी एक्स और वाई, जो जहां मैं सही हूँ अब निर्देशांक हैं.
यह भी समय [unintelligible] खर्च किया गया है, और यह कदम मैं इतनी दूर inputted है की कुल संख्या है.
और इसलिए इस मामले में, मैं सिर्फ एक संरचना में डेटा की एक पूरी गुच्छा समूहीकृत कर सकते हैं
यह अलग चर की तरह चारों ओर उड़ान की तरह होने के बजाय
कि मैं वास्तव में ट्रैक नहीं रखने के लिए कर सकते हैं.
और यह देता है हमें सिर्फ इस struct के अंदर विभिन्न बातें संदर्भित की तरह के लिए अच्छा वाक्यविन्यास है.
मैं सिर्फ board.board करते हैं, और मैं sudoku बोर्ड वापस मिल सकता है.
Board.level, मैं यह कितना कठिन है.
Board.x और board.y मुझे जहाँ मैं बोर्ड में हो सकता है के निर्देशांक दे.
और इसलिए मैं तक पहुँचने हूँ हम क्या struct में क्षेत्र कहते हैं.
यह sudokuBoard को परिभाषित करता है, जो मुझे लगता है कि एक प्रकार है.
और अब हम यहाँ हैं. मैं एक प्रकार sudokuBoard "बोर्ड" चर बुलाया है.
और तो अब मैं सभी क्षेत्रों है कि यहाँ पर इस संरचना का उपयोग कर सकते हैं.
>> Structs बारे में कोई सवाल है? हाँ?
Int एक्स, वाई के लिए [छात्र], आप एक लाइन पर दोनों घोषित? >> [यूसुफ] उह.
[छात्र] तो, तुम सिर्फ है कि उन सभी के साथ कर सकता है?
एक्स की तरह, y अल्पविराम बार कुल कि?
[यूसुफ] हाँ, आप निश्चित रूप से है कि कर सकता है, लेकिन कारण है कि मैं एक ही लाइन पर एक्स और वाई डाल -
और सवाल यह है कि हम सिर्फ एक ही लाइन पर यह कर सकते हैं?
हम सिर्फ एक ही लाइन पर क्यों नहीं है कि इन सभी के डाल दिया है
एक्स और वाई में एक दूसरे से जुड़े हुए हैं,
और यह सिर्फ stylistically अधिक सही है, एक अर्थ में,
क्योंकि यह एक ही लाइन पर दो बातें समूहीकरण है
जैसे कि तरह एक ही बात करने के लिए संबंधित हैं.
और मैं तो बस इन अलग अलग. यह सिर्फ एक शैली बात है.
यह कार्यात्मक जो भी कोई फर्क नहीं पड़ता.
Structs पर कोई अन्य प्रश्न?
आप एक struct के साथ एक Pokédex को परिभाषित कर सकते हैं.
एक Pokemon एक संख्या है और यह एक पत्र, एक मालिक, एक प्रकार है.
और फिर अगर आप पोकीमॉन की एक सरणी है, आप एक Pokédex बनाने, सही हो सकता है?
ठीक है, शांत,. तो, structs पर सवाल. उन structs से संबंधित हैं.
>> अंत में, GDB. GDB क्या है तुम करते हो? यह आपको अपने कार्यक्रम डिबग.
और अगर आप GDB नहीं किया है, मैं कम देख सिफारिश की जाएगी
और सिर्फ GDB क्या है ऊपर जा रहा है, तो आप यह कैसे के साथ काम करते हैं, कैसे आप इसे उपयोग कर सकते हैं,
और यह एक कार्यक्रम पर परीक्षण.
और इसलिए GDB क्या आपको करना है कि यह [unintelligible] अपने कार्यक्रम को थामने की मदद
और एक व्यावहारिक लाइन.
उदाहरण के लिए, मैं अपने कार्यक्रम के 3 लाइन की तरह थामने के निष्पादन के लिए चाहते हैं,
और जब मैं 3 लाइन पर हूँ मैं सभी मूल्यों है कि वहाँ रहे हैं मुद्रित कर सकते हैं.
और इसलिए हम क्या कॉल की तरह एक पंक्ति में pausing
हम इस कि लाइन पर एक breakpoint डाल कॉल
और फिर हम उस समय कार्यक्रम के राज्य में चर मुद्रित कर सकते हैं.
>> हम फिर से लाइन से लाइन कार्यक्रम के माध्यम से कदम कर सकते हैं.
और फिर हम ढेर के राज्य में समय पर देख सकते हैं.
और इतने में आदेश GDB, हम क्या है हम सी फाइल पर बजना कॉल का उपयोग करने के लिए,
लेकिन हम इसे - ggdb ध्वज पारित किया है.
और एक बार हम कर रहे हैं कि हम सिर्फ परिणामस्वरूप आउटपुट फाइल पर gdb चलाने.
और इसलिए आप इस तरह पाठ की तरह कुछ जन मिलता है,
लेकिन वास्तव में सब तुम्हें क्या करना है आदेश में शुरुआत में टाइप है.
तोड़ मुख्य मुख्य में एक breakpoint डालता है.
400 सूची 400 लाइन के आसपास कोड की लाइनों की सूची है.
और इसलिए इस मामले में आप सिर्फ चारों ओर देखने के लिए और कर सकते हैं कहते हैं, ओह,
मैं 397 लाइन है, जो इस लाइन में एक breakpoint सेट करना चाहते हैं,
और तब अपने प्रोग्राम के उस कदम में चलाता है और इसे तोड़ने के लिए जा रहा है.
यह वहाँ थामने के लिए जा रहा है, और तुम बाहर प्रिंट, उदाहरण के लिए कर सकते हैं, कम या अधिक के मूल्य.
और तो वहाँ आप को पता है की जरूरत है आदेशों की एक गुच्छा रहे हैं,
और इस स्लाइड शो वेबसाइट पर जाना होगा,
यदि ऐसा है तो आप बस इन संदर्भित करना चाहते हैं या उन्हें अपने धोखा चादरें पर डाल की तरह है, स्वतंत्र महसूस हो रहा है.
>> कूल. क्विज समीक्षा 0 था, और हम चारों ओर छड़ी अगर आप किसी भी सवाल है.
सही सभी.
>> [वाहवाही]
>> [CS50.TV]