C++ उदाहरण सहित संकेत

आपको पॉइंटर को मेमोरी एड्रेस के प्रतीकात्मक प्रतिनिधित्व के रूप में देखना चाहिए। पॉइंटर्स के साथ, प्रोग्राम कॉल-बाय-रेफरेंस का अनुकरण कर सकते हैं। वे गतिशील डेटा संरचनाओं को भी बना और उनमें हेरफेर कर सकते हैं। C++पॉइंटर वेरिएबल, किसी अन्य वेरिएबल द्वारा इंगित मेमोरी में एक विशिष्ट पते की ओर इशारा करने वाले वेरिएबल को संदर्भित करता है।

में पते C++

समझ में C++ संकेत: आपको यह समझना होगा कि कंप्यूटर डेटा कैसे संग्रहीत करता है।

जब आप अपने में एक चर बनाते हैं C++ प्रोग्राम को चलाने के लिए, इसे कंप्यूटर मेमोरी में कुछ स्थान दिया जाता है। इस चर का मान निर्दिष्ट स्थान पर संग्रहीत किया जाता है।

कंप्यूटर मेमोरी में डेटा कहाँ संग्रहीत है, यह जानने के लिए, C++ प्रदान करता है & (संदर्भ) ऑपरेटर। ऑपरेटर वह पता लौटाता है जो एक चर रखता है।

उदाहरण के लिए, यदि x एक चर है, तो &x चर का पता लौटाता है।

पॉइंटर घोषणा सिंटैक्स

की घोषणा C++ निम्नलिखित वाक्यविन्यास लेता है:

datatype *variable_name; 

• डेटाटाइप पॉइंटर का आधार प्रकार है जो वैध होना चाहिए C++ डेटा प्रकार।
• variable_name पॉइंटर वेरिएबल का नाम होना चाहिए।
• पॉइंटर घोषणा के लिए ऊपर इस्तेमाल किया गया तारांकन चिह्न गुणन ऑपरेशन करने के लिए इस्तेमाल किए गए तारांकन चिह्न के समान है। यह तारांकन चिह्न है जो चर को पॉइंटर के रूप में चिह्नित करता है।

यहाँ वैध पॉइंटर घोषणाओं का एक उदाहरण दिया गया है C++:

int    *x;    // a pointer to integer
double *x;    // a pointer to double
float  *x;    // a pointer to float
char   *ch     // a pointer to a character

संदर्भ ऑपरेटर (&) और डिफरेंस ऑपरेटर (*)

संदर्भ ऑपरेटर (&) चर का पता लौटाता है।

डिरेफरेंस ऑपरेटर (*) हमें मेमोरी एड्रेस में संग्रहीत मान प्राप्त करने में मदद करता है।

उदाहरण के लिए:

यदि हमारे पास एक चर है जिसका नाम num है, जो 0x234 पते पर संग्रहीत है तथा जिसका मान 28 है।

संदर्भ ऑपरेटर (&) 0x234 लौटाएगा.

डिरेफ़रेंस ऑपरेटर (*) 5 लौटाएगा.

उदाहरण 1:

#include <iostream>
using namespace std;
int main() {
	int  x = 27;  
	int  *ip;        
	ip = &x;       
	cout << "Value of x is : ";
	cout << x << endl;
	cout << "Value of ip is : ";
	cout << ip<< endl;
	cout << "Value of *ip is : ";
	cout << *ip << endl;
	return 0;
}

आउटपुट:

यह कैसे काम करता है:

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

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

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

पॉइंटर्स और एरेज़

ऐरे और पॉइंटर्स एक संबंधित अवधारणा के आधार पर काम करते हैं। पॉइंटर्स वाले ऐरे के साथ काम करते समय ध्यान देने योग्य अलग-अलग बातें हैं। ऐरे का नाम ही ऐरे के बेस एड्रेस को दर्शाता है। इसका मतलब है कि पॉइंटर को ऐरे का पता असाइन करने के लिए, आपको एम्परसेंड (&) का उपयोग नहीं करना चाहिए।

उदाहरण के लिए:

p = arr;

उपरोक्त कथन सही है क्योंकि arr सरणी के पते को दर्शाता है। यहाँ एक और उदाहरण दिया गया है:

p = &arr;

उपरोक्त विवरण ग़लत है.

हम किसी सरणी को अप्रत्यक्ष रूप से पॉइंटर में बदल सकते हैं। उदाहरण के लिए:

int arr [20];
int * ip;

नीचे एक वैध ऑपरेशन है:

ip = arr;

उपरोक्त घोषणा के बाद, ip और arr समतुल्य होंगे, और वे गुण साझा करेंगे। हालाँकि, ip को एक अलग पता सौंपा जा सकता है, लेकिन हम arr को कुछ भी नहीं सौंप सकते।

उदाहरण 2:

यह उदाहरण दिखाता है कि पॉइंटर्स का उपयोग करके किसी सरणी को कैसे पार किया जाए:

#include <iostream>
using namespace std;
int main() {
	int *ip;
	int arr[] = { 10, 34, 13, 76, 5, 46 };
	ip = arr;
	for (int x = 0; x < 6; x++) {
		cout << *ip << endl;
		ip++;
	}
	return 0;
}

आउटपुट:

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

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

1. एक पूर्णांक सूचक चर ip घोषित करें.
2. arr नामक एक सारणी घोषित करें और उसमें 6 पूर्णांक संग्रहित करें।
3. ip को arr असाइन करें। ip और arr समतुल्य हो जाएंगे।
4. एक for loop बनाएँ। loop variable x को index 0 से 5 तक array elements पर पुनरावृति करने के लिए बनाया गया था।
5. पॉइंटर IP के पते पर संग्रहीत मानों को प्रिंट करें। प्रत्येक पुनरावृत्ति में एक मान लौटाया जाएगा, और कुल 6 पुनरावृत्तियाँ की जाएँगी। endl एक है C++ कीवर्ड जिसका मतलब अंतिम पंक्ति है। यह क्रिया आपको प्रत्येक मान के प्रिंट होने के बाद कर्सर को अगली पंक्ति में ले जाने की अनुमति देती है। प्रत्येक मान एक अलग पंक्ति में प्रिंट किया जाएगा।
6. प्रत्येक पुनरावृत्ति के बाद पॉइंटर को अगले int स्थान पर ले जाने के लिए।
7. फॉर लूप का अंत.
8. प्रोग्राम को सफल निष्पादन पर कुछ लौटना चाहिए।
9. main() फ़ंक्शन बॉडी का अंत.

नल पॉइंटर

यदि कोई सटीक पता नहीं है जिसे असाइन किया जाना है, तो पॉइंटर वैरिएबल को NULL असाइन किया जा सकता है। यह घोषणा के दौरान किया जाना चाहिए। ऐसे पॉइंटर को नल पॉइंटर के रूप में जाना जाता है। इसका मान शून्य है और इसे iostream जैसी कई मानक लाइब्रेरी में परिभाषित किया गया है।

उदाहरण 3:

#include <iostream>
using namespace std;
int main() {
	int  *ip = NULL;
	cout << "Value of ip is: " << ip;
	return 0;
}

आउटपुट:

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

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

1. एक पॉइंटर वेरिएबल ip घोषित करें और उसे NULL मान निर्दिष्ट करें।
2. कंसोल पर कुछ पाठ के साथ पॉइंटर वेरिएबल ip का मान प्रिंट करें।
3. प्रोग्राम को सफलतापूर्वक पूरा होने पर मान लौटाना होगा।
4. main() फ़ंक्शन के मुख्य भाग का अंत.

चरों के सूचक

- C++आप कंप्यूटर की मेमोरी से सीधे डेटा में हेरफेर कर सकते हैं।

मेमोरी स्पेस को इच्छानुसार असाइन या री-असाइन किया जा सकता है। यह पॉइंटर वैरिएबल द्वारा संभव बनाया गया है।

पॉइंटर वेरिएबल्स कंप्यूटर की मेमोरी में किसी विशिष्ट पते की ओर संकेत करते हैं, जिसे कोई अन्य वेरिएबल इंगित करता है।

इसे निम्न प्रकार घोषित किया जा सकता है:

int *p;

या,

int* p;

आपके उदाहरण में, हमने पॉइंटर वेरिएबल p घोषित किया है।

यह एक मेमोरी एड्रेस रखेगा.

तारांकन चिह्न एक विसंकेतन ऑपरेटर है जिसका अर्थ है एक सूचक।

पॉइंटर p मेमोरी एड्रेस में एक पूर्णांक मान की ओर इशारा कर रहा है।

उदाहरण 4:

#include <iostream>

using namespace std;
int main() {
	int *p, x = 30;
	p = &x;
	cout << "Value of x is: " << *p;
	return 0;
}

आउटपुट:

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

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

1. एक पॉइंटर चर p और एक चर x को 30 के मान के साथ घोषित करें।
2. चर x का पता p को निर्दिष्ट करें।
3. कंसोल पर कुछ टेक्स्ट के साथ पॉइंटर वेरिएबल p का मान प्रिंट करें।
4. प्रोग्राम को सफलतापूर्वक पूरा होने पर मान लौटाना होगा।
5. main() फ़ंक्शन के मुख्य भाग का अंत.

पॉइंटर्स का अनुप्रयोग

में कार्य करता है C++ केवल एक मान लौटा सकता है। इसके अलावा, फ़ंक्शन में घोषित सभी चर फ़ंक्शन कॉल स्टैक पर आवंटित किए जाते हैं। जैसे ही फ़ंक्शन वापस लौटता है, सभी स्टैक चर नष्ट हो जाते हैं।

फ़ंक्शन के लिए तर्क मान द्वारा पारित किए जाते हैं, और चर पर किए गए किसी भी संशोधन से पारित किए गए वास्तविक चर के मान में कोई परिवर्तन नहीं होता है। निम्न उदाहरण इस अवधारणा को स्पष्ट करने में मदद करता है:-

उदाहरण 5:

#include <iostream>

using namespace std;
void test(int*, int*);
int main() {
	int a = 5, b = 5;
	cout << "Before changing:" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	test(&a, &b);

	cout << "\nAfter changing" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	return 0;
}

void test(int* n1, int* n2) {
	*n1 = 10;
	*n2 = 11;
}

आउटपुट:

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

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

1. टेस्ट नामक फ़ंक्शन का प्रोटोटाइप बनाएं जो दो पूर्णांक पैरामीटर लेगा।
2. main() फ़ंक्शन को कॉल करें। हम इसके बॉडी के अंदर प्रोग्राम लॉजिक जोड़ेंगे।
3. दो पूर्णांक चर a और b घोषित करें, जिनमें से प्रत्येक का मान 5 है।
4. कंसोल पर कुछ टेक्स्ट प्रिंट करें। endl (अंतिम पंक्ति) कर्सर को अगली पंक्ति में प्रिंट करना शुरू करने के लिए ले जाएगा।
5. कंसोल पर अन्य टेक्स्ट के साथ वेरिएबल a का मान प्रिंट करें। endl (अंतिम पंक्ति) कर्सर को अगली पंक्ति में प्रिंट करना शुरू करने के लिए ले जाएगा।
6. कंसोल पर अन्य टेक्स्ट के साथ वेरिएबल b का मान प्रिंट करें। endl (अंतिम पंक्ति) कर्सर को अगली पंक्ति में प्रिंट करना शुरू करने के लिए ले जाएगा।
7. test() नामक एक फ़ंक्शन बनाएँ जो चर a और b के पते को पैरामीटर के रूप में लेता है।
8. कंसोल पर कुछ टेक्स्ट प्रिंट करें। टेक्स्ट प्रिंट होने से पहले \n एक नई खाली लाइन बनाएगा। endl (अंतिम पंक्ति) टेक्स्ट प्रिंट होने के बाद अगली लाइन में प्रिंटिंग शुरू करने के लिए कर्सर को ले जाएगा।
9. कंसोल पर अन्य टेक्स्ट के साथ वेरिएबल a का मान प्रिंट करें। endl (अंतिम पंक्ति) कर्सर को अगली पंक्ति में प्रिंट करना शुरू करने के लिए ले जाएगा।
10. कंसोल पर अन्य टेक्स्ट के साथ वेरिएबल b का मान प्रिंट करें। endl (अंतिम पंक्ति) कर्सर को अगली पंक्ति में प्रिंट करना शुरू करने के लिए ले जाएगा।
11. प्रोग्राम को सफलतापूर्वक पूरा होने पर मान लौटाना होगा।
12. main() फ़ंक्शन के मुख्य भाग का अंत.
13. फ़ंक्शन test() को परिभाषित करना। फ़ंक्शन को दो पूर्णांक पॉइंटर चर *n1 और *n2 लेना चाहिए।
14. पॉइंटर चर *n1 को 10 का मान निर्दिष्ट करना.
15. पॉइंटर चर *n2 को 11 का मान निर्दिष्ट करना.
16. फ़ंक्शन test() के मुख्य भाग का अंत.

यद्यपि, फ़ंक्शन परीक्षण के अंदर चर a और b को नए मान निर्दिष्ट किए जाते हैं, लेकिन फ़ंक्शन कॉल पूरा होने के बाद, वे बाहरी फ़ंक्शन main में प्रतिबिंबित नहीं होते हैं।

फ़ंक्शन तर्कों के रूप में पॉइंटर्स का उपयोग करने से फ़ंक्शन में वेरिएबल का वास्तविक पता पास करने में मदद मिलती है, और वेरिएबल पर किए गए सभी परिवर्तन बाहरी फ़ंक्शन में दिखाई देंगे।

उपरोक्त मामले में, फ़ंक्शन 'test' में चर 'a' और 'b' का पता होता है। ये दोनों चर फ़ंक्शन 'test' से सीधे पहुँच योग्य होते हैं, और इसलिए इन चरों में किया गया कोई भी परिवर्तन कॉलर फ़ंक्शन 'main' में दिखाई देता है।

पॉइंटर्स का उपयोग करने के लाभ

पॉइंटर्स के उपयोग के लाभ/सुविधाएँ इस प्रकार हैं

• पॉइंटर्स वे चर हैं जो अन्य डेटा का पता संग्रहीत करते हैं। चर में C++.
• पॉइंटर्स का उपयोग करके फ़ंक्शन द्वारा एक से अधिक चर को संशोधित और लौटाया जा सकता है।
• पॉइंटर्स का उपयोग करके मेमोरी को गतिशील रूप से आवंटित और डी-आबंटित किया जा सकता है।
• पॉइंटर्स प्रोग्राम की जटिलता को सरल बनाने में मदद करते हैं।
• पॉइंटर्स के उपयोग से प्रोग्राम की निष्पादन गति में सुधार होता है।

सारांश

• पॉइंटर एक चर को संदर्भित करता है जो किसी अन्य चर का पता रखता है।
• प्रत्येक पॉइंटर का एक वैध डेटा प्रकार होता है।
• पॉइंटर मेमोरी एड्रेस का प्रतीकात्मक प्रतिनिधित्व है।
• पॉइंटर्स प्रोग्राम को कॉल-बाय-रेफरेंस का अनुकरण करने और गतिशील डेटा संरचनाओं को बनाने और उनमें हेरफेर करने की अनुमति देते हैं।
• Arrays और पॉइंटर्स एक संबंधित अवधारणा का उपयोग करते हैं।
• सरणी नाम सरणी के आधार को दर्शाता है।
• यदि आप किसी ऐरे का पता किसी पॉइंटर को निर्दिष्ट करना चाहते हैं, तो एम्परसेंड (&) का उपयोग न करें।
• यदि पॉइंटर वैरिएबल को निर्दिष्ट करने के लिए कोई विशिष्ट पता नहीं है, तो उसे NULL निर्दिष्ट करें।