सारांश
यह पाठ पाठ्यक्रम की छठी इकाई खोलता है, जो संयुक्त डेटा को समर्पित है। यह बताता है कि इकाई किसलिए है: डेटा के संग्रहों (स्थिर और परिवर्ती आकार के अनुक्रम, तालिकाएँ और रिकॉर्ड) को निरूपित करना और उन्हें बुनियादी एल्गोरिदमों से संसाधित करना सिखाना, चाहे वे हाथ से लिखे गए हों या लाइब्रेरी से लिए गए हों, और यह अनुमान लगाना कि उनकी लागत कितनी है; इसके छह पाठों और उन्हें जोड़ने वाले सूत्र को प्रस्तुत करता है; उसे याद दिलाता है जिसे इकाई ज्ञात मानती है, ख़ासकर निश्चर वाले लूप और कॉन्स्ट रेफ़रेंस द्वारा पास करना; वह समस्या सामने रखता है जिसे इकाई हल करती है, यानी ऐसे प्रोग्राम की समस्या जिसे ऐसा डेटा सहेजना है जिसकी मात्रा वह नहीं जानता और जो अलग-अलग चरों से लिखे जाने पर अतिरिक्त डेटा को चुपचाप छोड़ देता है; लागत का पूर्वाभास एल्गोरिदम के दूसरे माप के रूप में कराता है, उसकी शुद्धता के साथ; और दिखाता है कि यह इकाई आगे की इकाइयों में और C++ में प्रोग्रामिंग II पाठ्यक्रम में कहाँ ले जाती है।
अधिगम उद्देश्य
- इकाई की विषय-वस्तु के क्रम का वर्णन करना और समझाना कि हर पाठ अपने बाद वाले पाठ को क्या देता है।
- लूप, उनके निश्चर और पैरामीटर पास करने के तरीक़ों (मान द्वारा, रेफ़रेंस द्वारा और कॉन्स्ट रेफ़रेंस द्वारा) को याद करना और ज़रूरत हो तो उन्हें दोहराना।
- एक उदाहरण के सहारे एल्गोरिदम की लागत का पूर्वाभास पाना, उसकी गुणवत्ता के दूसरे माप के रूप में, उसकी शुद्धता के साथ।
- पहचानना कि इकाई पूरी करने पर क्या कर पाना अपेक्षित है, और उसे उससे अलग करना जो आगे की इकाइयों में सीखा जाएगा।
प्रवेश मूल्यांकन
इकाई शुरू करने से पहले आरंभ-बिंदु को माप लेना उपयोगी है। यह मूल्यांकन एक स्व-मूल्यांकन है: इसमें अंक नहीं दिए जाते, और इसका एकमात्र उद्देश्य अध्ययन को दिशा देना है। पहले चार प्रश्न उसे जाँचते हैं जिसे इकाई ज्ञात मानती है: अधिकतम मान खोजने वाले लूप का निश्चर, किसी बड़े पैरामीटर को पास करने का तरीक़ा, दो नेस्टेड लूपों के चक्करों की संख्या और अचिह्नित अंकगणित। उसके बाद के छह प्रश्न, पाठों के क्रम से, इकाई के केंद्रीय विचारों को छूते हैं: किसी अनुक्रम के मान्य इंडेक्स, वेक्टर का निर्माण, किसी आकार को कितनी बार आधा किया जा सकता है, क्रमबद्ध डेटा में खोज, तालिका का दोहरा इंडेक्स, और एक ही सत्ता के डेटा को अलग-अलग संग्रहों में सहेजने का ख़तरा। अभी इनके सही उत्तर देने के लिए कोई बाध्य नहीं है, और इनमें से कुछ में “मुझे अभी नहीं पता” एक ईमानदार उत्तर है: हर उत्तर, सही हो या ग़लत, बात को समझाता है और उस पाठ का नाम बताता है जिसमें वह बात आती है। यही कौशल अंत में, सारांश वाले पाठ में, फिर से मापे जाते हैं।
इकाई शुरू करने से पहले अपना आरंभ बिंदु मापें। यह एक छोटा स्व-मूल्यांकन है: इस पर अंक नहीं दिए जाते और इसका परिणाम केवल आपके ब्राउज़र में रहता है।
प्रश्न 1पिछली इकाइयों सेकोड का अंश
int largest{0}; int t{}; while (std::cin >> t) { if (t > largest) { largest = t; } }कोlargestमें पढ़े गए तापमानों में से सबसे बड़ा छोड़ना चाहिए। यह किस इनपुट पर विफल होता है?पहला चक्कर उस डेटा की तुलना 0 से करता है और धनात्मक होने पर उसे सहेज लेता है: एक ही धनात्मक डेटा के साथ परिणाम सही है। उत्तर देने से पहले ट्रेस चलाकर देखना अच्छा है।>के साथ अधिकतम के बराबर डेटा उसकी जगह नहीं लेता, पर अधिकतम वही संख्या है: दोहराव परिणाम नहीं बदलता।यह दिखाता है कि इनिशियलाइज़ेशन को निश्चर से नहीं जाँचा गया: सही लूप यह माँगता है कि निश्चर पहले चक्कर से पहले ही सत्य हो।वांछित निश्चर, “largestअब तक पढ़े गए मानों का अधिकतम है”, आरंभ में सत्य नहीं होता, क्योंकि कुछ भी पढ़ने से पहले कोई अधिकतम नहीं होता, और आरंभिक 0 हर ऋणात्मक डेटा से बड़ा निकलता है। इसका सुधार पहले डेटा से इनिशियलाइज़ करना है, यह जाँचने के बाद कि वह मौजूद है। पाठ वेक्टर यही काम एक सहेजे गए अनुक्रम पर करता है, और लाइब्रेरी इसेstd::ranges::maxसे व्यक्त करती है, जिसकी पूर्व-शर्त यह है कि अनुक्रम ख़ाली न हो।दोहराएँ: सही लूप की रचना
प्रश्न 2पिछली इकाइयों सेएक फ़ंक्शन गिनता है कि दस लाख कैरेक्टरों वाले किसी टेक्स्ट में, जो एक
std::stringमें सहेजा गया है, कितने स्वर हैं, और उसे बदलता नहीं। उसके पैरामीटर को कैसे घोषित करना उचित है?मान द्वारा पास करना हर कॉल में दस लाख कैरेक्टरों की प्रति बनाता है: यह सही है, पर ऐसी लागत चुकाता है जिससे कुछ नहीं मिलता।यह प्रति नहीं बनाता, पर बिना ज़रूरत टेक्स्ट बदलने देता है और न लिटरल स्वीकार करता है न अस्थायी ऑब्जेक्ट: यह “प्रति न बनाना” और “बदलने देना” को एक मान लेता है।पास करने का तरीक़ा इंटरफ़ेस का हिस्सा है: मान द्वारा पास करना फ़ंक्शन से उसकी अपनी प्रति का वादा करता है, और प्रोग्राम को वह प्रति बनानी पड़ती है।कॉन्स्ट रेफ़रेंस टेक्स्ट को उसकी प्रति बनाए बिना और उसे बदलने की अनुमति के बिना पढ़ता है, और साथ ही अस्थायी ऑब्जेक्ट भी स्वीकार करता है। इकाई 6 में यह चुनाव नियम बन जाता है: जो फ़ंक्शन दस लाख डेटा वाले वेक्टर को पढ़ता है, वह उसेconst std::vector<int>&के रूप में लेता है, और अनावश्यक प्रति लागत की सबसे आम त्रुटि बन जाती है।दोहराएँ: पैरामीटर और स्कोप
प्रश्न 3पिछली इकाइयों से
++countकितनी बार निष्पादित होता है,for (int i{0}; i < 6; ++i) { for (int j{0}; j < i; ++j) { ++count; } }में?सही उत्तर:
भीतरी लूप होने पर 0 चक्कर लगाता है, होने पर एक, और इसी तरह होने पर 5: कुल , जो है। पाठ एल्गोरिदम की लागत इस गिनती का सामान्यीकरण करता है: डेटा के सभी युग्मों पर चलने वाले दो लूप चक्कर लगाते हैं, और यही संख्या तय करती है कि कोई एल्गोरिदम दस लाख डेटा के लिए काम का है या नहीं।दोहराएँ: लूप
प्रश्न 4पिछली इकाइयों से
std::println("{}", 0u - 1);ऐसे सिस्टम पर क्या लिखता है जिसमेंunsigned int32 बिट का हो?यह मानता है कि अचिह्नित प्रकार ऋणात्मक मान स्वीकार करता है।यह मानता है कि घटाव प्रकार के सबसे छोटे मान पर रुक जाता है; अचिह्नित अंकगणित घूम जाता है, संतृप्त नहीं होता।यह संभावित चेतावनी को त्रुटि समझ लेता है: व्यंजक मान्य है और उसका मान परिभाषित है।अचिह्नित अंकगणित मॉड्यूलर है: 0 में से 1 घटाने पर मान घूमकर प्रकार के सबसे बड़े मान पर, पर, पहुँच जाता है। इकाई 6 आकारों कोstd::size_tसे मापती है, जो भी अचिह्नित है, इसलिए ख़ाली वेक्टर के साथv.size() - 1का मान नहीं, बल्कि एक विशाल संख्या होता है; पाठ ऐरे इस घटाव के प्रति सावधान करता है, और पाठ वेक्टर वह लूप दिखाता है जो इसके कारण सीमाओं के बाहर चला जाता है।दोहराएँ: पूर्णांक और उनका निरूपण
प्रश्न 5 अवयवों वाले किसी अनुक्रम में, जिसे C++ की तरह क्रमांकित किया गया है, कौन-से इंडेक्स किसी अवयव को इंगित करते हैं?
यह आम बोलचाल की तरह एक से क्रमांकन करता है; C++ मेंa[n]पहले ही अनुक्रम के बाहर है।यह एक के अंतर की सबसे आम त्रुटि है: यह इंडेक्स गिनता है, जबकि अवयव हैं।यह एक ईमानदार उत्तर है: पाठ 6.1 इसे समझाता है, उस कारण के साथ जिसकी वजह से गिनती शून्य से होती है।प्रश्न 6
vमें क्या होता है,std::vector<int> v(3, 7);के बाद?यह कोष्ठकों को ऐसे पढ़ता है मानो वे धनु कोष्ठक हों।यह दोनों संख्याओं की भूमिकाएँ उलट देता है।यह एक ईमानदार उत्तर है: पाठ 6.2 वेक्टर और उसे बनाने के तरीक़े प्रस्तुत करता है।प्रश्न 7
for (int m{1024}; m > 1; m /= 2) { ... }कितने चक्कर लगाता है?सही उत्तर:
हर चक्कर की शुरुआत मेंmके मान 1024, 512, 256, 128, 64, 32, 16, 8, 4 और 2 हैं: दस चक्कर, क्योंकि , और दस है। जो एल्गोरिदम हर चरण में अपनी समस्या को आधा कर देता है, वह लगभग चरण लेता है, और पाठ एल्गोरिदम की लागत उसे लघुगणकीय कहता है: एक अरब डेटा के लिए उसे लगभग तीस चरण काफ़ी हैं।दोहराएँ: एल्गोरिदम की लागत
प्रश्न 8एक टेलीफ़ोन निर्देशिका में दस लाख नाम वर्णानुक्रम में हैं। किसी एक को खोजने के लिए उसे बीच से खोला जाता है, वह आधा हिस्सा छोड़ दिया जाता है जिसमें नाम हो ही नहीं सकता, और दूसरे आधे के साथ यही दोहराया जाता है। उसे अधिक से अधिक कितनी बार खोलना पड़ता है?
यह उस खोज की गिनती है जो नामों को एक-एक करके जाँचती है: क्रम का लाभ उठाए बिना औसतन आधी निर्देशिका देखनी पड़ती है।यह दस लाख का वर्गमूल है: यह हिस्से को आधा करने और उसे खंडों में बाँटने को एक मान लेता है।यह दस आधार वाला लघुगणक इस्तेमाल करता है: हर बार खोलने पर आधा हिस्सा छूटता है, नौ दसवाँ नहीं।हर बार खोलने पर वह हिस्सा आधा हो जाता है जिसमें नाम हो सकता है, और दस लाख से अधिक है: बीस बार आधा करने के बाद एक ही नाम बचता है। यह पाठ खोजना और क्रमबद्ध करना की द्विआधारी खोज है, जो तभी काम करती है जब डेटा क्रमबद्ध हो, और जिसका औचित्य एक निश्चर से दिया जाता है।दोहराएँ: खोजना और क्रमबद्ध करना
प्रश्न 9
std::vector<std::vector<int>> t{{1, 2, 3}, {4, 5, 6}};के साथt[1][0]औरt.size()के मान क्या हैं?यह पहले इंडेक्स को स्तंभ के रूप में पढ़ता है और पंक्तियों की जगह स्तंभ गिनता है।यह मानता है किsize()तालिका के सभी खाने गिनता है।यह एक ईमानदार उत्तर है: पाठ 6.5 तालिकाओं को वेक्टरों के वेक्टर के रूप में प्रस्तुत करता है।प्रश्न 10एक प्रोग्राम किसी समूह के नाम एक वेक्टर में और उनके ग्रेड दूसरे में सहेजता है, इस तरह कि ग्रेड
grades[i]उसी का है जिसका नामnames[i]है। अगर वह केवल ग्रेडों वाले वेक्टर को क्रमबद्ध करे, तो क्या होता है?कंपाइलर के लिए दोनों वेक्टर स्वतंत्र हैं: संबंध केवल उसके मन में है जिसने प्रोग्राम लिखा।एल्गोरिदम को एक ही वेक्टर मिलता है और वह दूसरे के अस्तित्व को नहीं जानता।हर पहुँच मान्य है और हर परिणाम परिभाषित है: दोष लॉजिक का है, और इसीलिए पाठ्यक्रम के दोनों डिटेक्टरों में से कोई भी इसे नहीं पकड़ता (मेमोरी त्रुटियों का डिटेक्टर, AddressSanitizer, और अपरिभाषित व्यवहार का डिटेक्टर, UndefinedBehaviorSanitizer)।
सामग्री लोड हो रही है…