उदाहरण के साथ ए ++ का डायनेमिक आवंटन

एक गतिशील सरणी क्या है?

एक गतिशील सरणी एक नियमित सरणी के समान है, लेकिन प्रोग्राम रनटाइम के दौरान इसका आकार परिवर्तनीय है। डायनामेर्रे तत्व स्मृति के एक सन्निहित ब्लॉक पर कब्जा कर लेते हैं।

एक बार एक सरणी बना लेने के बाद, इसका आकार नहीं बदला जा सकता है। हालांकि, एक गतिशील सरणी अलग है। एक गतिशील सरणी भरे जाने के बाद भी अपने आकार का विस्तार कर सकती है।

एक सरणी के निर्माण के दौरान, इसे स्मृति की पूर्व निर्धारित राशि आवंटित की जाती है। डायनामिक ऐरे के साथ ऐसा नहीं है क्योंकि जरूरत पड़ने पर यह एक निश्चित कारक द्वारा अपने मेमोरी साइज को बढ़ाता है।

इस C ++ ट्यूटोरियल में, आप सीखेंगे

• एक गतिशील सरणी क्या है?
• डायनामिक एरेज़ के प्रदर्शन को प्रभावित करने वाले कारक
• नया कीवर्ड
• गतिशील रूप से आवंटित सरणियों को प्रारंभ करना
• Arrays का आकार बदलना
• डायनामिकली एरर्स को हटाना

डायनामिक एरेज़ के प्रदर्शन को प्रभावित करने वाले कारक

सरणी का प्रारंभिक आकार और इसका विकास कारक इसके प्रदर्शन को निर्धारित करता है। निम्नलिखित बातों पर ध्यान दें:

1. यदि किसी सरणी में एक छोटा आकार और एक छोटा विकास कारक है, तो यह अधिक बार मेमोरी को पुनः व्यवस्थित करता रहेगा। यह सरणी के प्रदर्शन को कम करेगा।
2. यदि किसी सरणी में एक बड़ा आकार और एक बड़ा विकास कारक है, तो इसमें अप्रयुक्त मेमोरी का एक बड़ा हिस्सा होगा। इसके कारण, आकार परिवर्तन को अधिक समय लग सकता है। यह सरणी के प्रदर्शन को कम करेगा।

नया कीवर्ड

C ++ में, हम नए कीवर्ड का उपयोग करके एक डायनामिक ऐरे बना सकते हैं। आवंटित की जाने वाली वस्तुओं की संख्या वर्ग कोष्ठक की एक जोड़ी के भीतर निर्दिष्ट की गई है। प्रकार का नाम इससे पहले होना चाहिए। अनुरोधित मदों की संख्या आवंटित की जाएगी।

वाक्य - विन्यास:

नया कीवर्ड निम्न सिंटैक्स लेता है:

pointer_variable = new data_type;

Pointer_variable सूचक चर का नाम है।

Data_type एक मान्य C ++ डेटा प्रकार होना चाहिए।

तब कीवर्ड पहले आइटम पर एक पॉइंटर लौटाता है। डायनामिक ऐरे बनाने के बाद, हम डिलीट कीवर्ड का उपयोग करके इसे हटा सकते हैं।

उदाहरण 1:

#includeusing namespace std;int main() {int x, n;cout << "Enter the number of items: << "\n";cin >>n;int *arr = new int(n);cout << "Enter " << n << " items" << endl;for (x = 0; x < n; x++) {cin >> arr[x];}cout << "You entered: ";for (x = 0; x < n; x++) {cout << arr[x] << " ";}return 0;}

आउटपुट:

यहाँ कोड का एक स्क्रीनशॉट है:

कोड स्पष्टीकरण:

1. अपने कार्यों का उपयोग करने के लिए हमारे कार्यक्रम में iostream हेडर फ़ाइल शामिल करें।
2. बिना बुलाए अपनी कक्षाओं का उपयोग करने के लिए हमारे प्रोग्राम में std नाम स्थान शामिल करें।
3. मुख्य () फ़ंक्शन को कॉल करें। फ़ंक्शन के शरीर के भीतर प्रोग्राम लॉजिक जोड़ा जाना चाहिए।
4. दो पूर्णांक चर x और n घोषित करें।
5. वेरिएबल n के मान को दर्ज करने के लिए उपयोगकर्ता को संकेत देने वाले कंसोल पर कुछ टेक्स्ट प्रिंट करें।
6. कीबोर्ड से उपयोगकर्ता इनपुट पढ़ें और इसे वेरिएबल n पर असाइन करें।
7. कुल एन पूर्णांक रखने के लिए एक सरणी घोषित करें और इसे पॉइंटर चर * गिरफ्तार करने के लिए असाइन करें।
8. उपयोगकर्ता को एन नंबर दर्ज करने के लिए संकेत देने वाला संदेश प्रिंट करें।
9. उपयोगकर्ता द्वारा दर्ज की गई वस्तुओं पर पुनरावृति करने के लिए एक लूप वेरिएबल x बनाने के लिए लूप के लिए उपयोग करें।
10. उपयोगकर्ता द्वारा दर्ज किए गए तत्वों को पढ़ें और उन्हें सरणी में गिरफ्तार करें।
11. लूप के लिए शरीर का अंत।
12. कंसोल पर कुछ टेक्स्ट प्रिंट करें।
13. सरणी के आइटम पर पुनरावृति करने के लिए एक लूप चर x बनाने के लिए लूप के लिए उपयोग करें।
14. कंसोल पर गिरफ्तार नाम के सरणी में निहित मानों को प्रिंट करें।
15. लूप के लिए शरीर का अंत।
16. कार्यक्रम सफल होने पर मूल्य वापस करना चाहिए।
17. मुख्य () फ़ंक्शन के शरीर का अंत।

नोट: उपर्युक्त उदाहरण में, उपयोगकर्ता को रन समय के दौरान सरणी के लिए किसी भी आकार को निर्दिष्ट करने की अनुमति है। इसका मतलब है कि रनटाइम के दौरान सरणी का आकार निर्धारित किया जाता है ।

गतिशील रूप से आवंटित सरणियों को प्रारंभ करना

डायनेमिक ऐरे को 0 से इनिशियलाइज़ करना आसान है।

वाक्य - विन्यास:

int *array{ new int[length]{} };

उपरोक्त सिंटैक्स में, लंबाई सरणी में जोड़े जाने वाले तत्वों की संख्या को दर्शाती है। चूंकि हमें सरणी को 0 से आरंभ करने की आवश्यकता है, इसलिए इसे खाली छोड़ दिया जाना चाहिए।

हम एक शुरुआती सूची का उपयोग करके एक गतिशील सरणी को इनिशियलाइज़ कर सकते हैं। आइए एक उदाहरण बनाएं जो इसे प्रदर्शित करता है।

उदाहरण 2:

#include using namespace std;int main(void) {int x;int *array{ new int[5]{ 10, 7, 15, 3, 11 } };cout << "Array elements: " << endl;for (x = 0; x < 5; x++) {cout << array[x] << endl;}return 0;}

आउटपुट:

यहाँ कोड का एक स्क्रीनशॉट है:

कोड स्पष्टीकरण:

1. अपने कार्यों का उपयोग करने के लिए हमारे कार्यक्रम में iostream हेडर फ़ाइल शामिल करें।
2. हमारे प्रोग्राम में std नेमस्पेस को शामिल करें, बिना कॉल किए उसकी कक्षाओं का उपयोग करने के लिए।
3. मुख्य () फ़ंक्शन को कॉल करें। फ़ंक्शन के शरीर के भीतर प्रोग्राम लॉजिक जोड़ा जाना चाहिए।
4. X नाम के एक पूर्णांक चर की घोषणा करें।
5. एक प्रारंभिक सूची का उपयोग करके सरणी नामक एक गतिशील सरणी घोषित करें। सरणी में 5 पूर्णांक तत्व होंगे। ध्यान दें कि हमने सरणी लंबाई और आरम्भिक सूची के बीच ऑपरेटर का उपयोग नहीं किया है।
6. कंसोल पर कुछ टेक्स्ट प्रिंट करें। एंडल एक C ++ कीवर्ड है जिसका मतलब है एंड लाइन। यह कर्सर को अगले वाक्य पर ले जाता है।
7. सरणी तत्वों पर पुनरावृति करने के लिए लूप के लिए उपयोग करें।
8. कंसोल पर सरणी नाम की सामग्री मुद्रित करें।
9. लूप के लिए शरीर का अंत।
10. कार्यक्रम सफल होने पर मूल्य वापस करना चाहिए।
11. मुख्य () फ़ंक्शन के शरीर का अंत।

Arrays का आकार बदलना

आवंटन समय के दौरान एक गतिशील सरणी की लंबाई निर्धारित की जाती है।

हालाँकि, C ++ में एक बार आबंटित होने के बाद किसी सरणी को आकार देने का एक अंतर्निहित तंत्र नहीं है।

हालाँकि, आप इस चुनौती को गतिशील रूप से तत्वों को कॉपी करते हुए, फिर पुराने सरणी को मिटाकर, एक नई सरणी आवंटित करके इस चुनौती को पार कर सकते हैं।

नोट: कि यह तकनीक त्रुटियों से ग्रस्त है, इसलिए, इससे बचने का प्रयास करें।

डायनामिकली एरर्स को हटाना

इसका उद्देश्य पूरा होने पर एक गतिशील सरणी को कंप्यूटर मेमोरी से हटा दिया जाना चाहिए। डिलीट स्टेटमेंट आपको इसे पूरा करने में मदद कर सकता है। जारी की गई मेमोरी स्पेस का उपयोग डेटा के दूसरे सेट को रखने के लिए किया जा सकता है। हालाँकि, भले ही आप कंप्यूटर मेमोरी से डायनेमिक ऐरे को डिलीट न करें, लेकिन प्रोग्राम समाप्त होने के बाद यह अपने आप डिलीट हो जाएगा।

ध्यान दें:

कंप्यूटर मेमोरी से डायनामिक ऐरे को हटाने के लिए, आपको डिलीट के बजाय, [] का उपयोग करना चाहिए। [] सीपीयू को निर्देश देता है कि वह एक चर के बजाय कई चर हटाए। डायनामिक एरे से काम करते समय डिलीट [] के बजाय डिलीट के उपयोग से समस्याएँ हो सकती हैं। ऐसी समस्याओं के उदाहरणों में मेमोरी लीक, डेटा भ्रष्टाचार, क्रैश आदि शामिल हैं।

उदाहरण 3:

#includeusing namespace std;int main() {int x, n;cout << "How many numbers will you type?" << "\n";cin >>n;int *arr = new int(n);cout << "Enter " << n << " numbers" << endl;for (x = 0; x < n; x++) {cin >> arr[x];}cout << "You typed: ";for (x = 0; x < n; x++) {cout << arr[x] << " ";}cout << endl;delete [] arr;return 0;}

आउटपुट:

यहाँ कोड का एक स्क्रीनशॉट है:

कोड स्पष्टीकरण:

1. अपने कार्यों का उपयोग करने के लिए हमारे कार्यक्रम में iostream हेडर फ़ाइल शामिल करें।
2. बिना बुलाए अपनी कक्षाओं का उपयोग करने के लिए हमारे प्रोग्राम में std नाम स्थान शामिल करें।
3. मुख्य () फ़ंक्शन को कॉल करें। फ़ंक्शन के शरीर के भीतर प्रोग्राम लॉजिक जोड़ा जाना चाहिए।
4. पूर्णांक डेटा प्रकार के दो चर x और n घोषित करें।
5. कंसोल पर कुछ टेक्स्ट प्रिंट करें। पाठ उपयोगकर्ता को उन संख्याओं के बारे में बताने के लिए कहेगा जो वे दर्ज करेंगे।
6. कीबोर्ड से उपयोगकर्ता इनपुट पढ़ें। इनपुट मान चर n को सौंपा जाएगा।
7. एक सूचक चर * गिरफ्तारी की घोषणा करें। सरणी अर कुल एनजीरों को संग्रहीत करने के लिए कुछ मेमोरी आरक्षित करेगा।
8. कंसोल पर एक संदेश प्रिंट करें जो उपयोगकर्ता को एन नंबर दर्ज करने के लिए प्रेरित करता है।
9. उपयोगकर्ता के द्वारा दर्ज किए गए नंबरों पर पुनरावृति करने के लिए लूप और लूप वेरिएबल x बनाएं।
10. उपयोगकर्ता द्वारा दर्ज की गई संख्या को पढ़ें और उन्हें गिरफ्तार सरणी में संग्रहीत करें।
11. लूप के लिए शरीर का अंत।
12. कंसोल पर कुछ टेक्स्ट प्रिंट करें।
13. सरणी गिरफ्तारी की सामग्री पर पुनरावृत्ति करने के लिए लूप और लूप चर x का उपयोग करें।
14. कंसोल पर गिरफ्तार सरणी के मूल्यों का प्रिंट आउट लें।
15. लूप के लिए शरीर का अंत।
16. कंसोल पर एक खाली लाइन प्रिंट करें।
17. अरै अरेस्ट की मेमोरी को फ्री करें।
18. कार्यक्रम सफलतापूर्वक पूरा होने पर मान लौटाएगा।
19. मुख्य () फ़ंक्शन के शरीर का अंत।

सारांश:

• नियमित सरणियों का एक निश्चित आकार होता है। आप एक बार घोषित होने के बाद उनका आकार संशोधित नहीं कर सकते।
• इस प्रकार के सरणियों के साथ, संकलन समय के दौरान मेमोरी का आकार निर्धारित किया जाता है।
• डायनेमिक ऐरे अलग हैं। उनके आकार को रनटाइम के दौरान बदला जा सकता है।
• गतिशील सरणियों में, आकार रनटाइम के दौरान निर्धारित किया जाता है।
• C ++ में डायनामिक सरणियों को नए कीवर्ड का उपयोग करके घोषित किया गया है।
• डायनामिक एरे में संग्रहित होने वाली वस्तुओं की संख्या को निर्दिष्ट करने के लिए हम वर्गाकार कोष्ठक का उपयोग करते हैं।
• एक बार सरणी के साथ, हम डिलीट ऑपरेटर का उपयोग करके मेमोरी को मुक्त कर सकते हैं।
• सभी सरणी तत्वों की मेमोरी को मुक्त करने के लिए [] के साथ डिलीट ऑपरेटर का उपयोग करें।
• बिना डिलीट [] केवल एक ही तत्व की मेमोरी को मुक्त करता है।
• C ++ सरणियों का आकार बदलने के लिए कोई अंतर्निहित तंत्र नहीं है।
• किसी सूची आरंभीकरण का उपयोग करके किसी सरणी को आरंभीकृत करने के लिए, हम ऑपरेटर का उपयोग नहीं करते हैं।