C++ उदाहरण के साथ सारणी का गतिशील आवंटन

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

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

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

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

नया कीवर्ड

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

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

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

pointer_variable = new data_type;

पॉइंटर_वैरिएबल का नाम है सूचक चर.

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

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

उदाहरण 1:

#include<iostream>
using 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;
}

आउटपुट:

कोड का स्क्रीनशॉट यहां दिया गया है:

Code स्पष्टीकरण:

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

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

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

किसी गतिशील सारणी को 0 पर आरंभीकृत करना आसान है।

सिंटेक्स:

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

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

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

उदाहरण 2:

#include <iostream>
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;
}

आउटपुट:

कोड का स्क्रीनशॉट यहां दिया गया है:

Code स्पष्टीकरण:

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

सारणियों का आकार बदलना

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

हालांकि, C++ एक बार सरणी आवंटित हो जाने के बाद उसका आकार बदलने की कोई अंतर्निहित प्रणाली नहीं होती।

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

ध्यान दें: इस तकनीक में त्रुटियाँ होने की संभावना है, इसलिए इससे बचने का प्रयास करें।

गतिशील रूप से सारणी हटाना

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

नोट:

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

उदाहरण 3:

#include<iostream>
using 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;
}

आउटपुट:

कोड का स्क्रीनशॉट यहां दिया गया है:

Code स्पष्टीकरण:

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

अक्सर पूछे जाने वाले प्रश्न