सी डबल पॉइंटर (पॉइंटर टू पॉइंटर)

जैसा कि हम जानते हैं कि, सी। पॉइंटर में एक चर के पते को संग्रहीत करने के लिए एक पॉइंटर का उपयोग किया जाता है, एक चर के एक्सेस समय को कम करता है। हालांकि, सी में, हम एक और सूचक के पते को संग्रहीत करने के लिए एक सूचक को भी परिभाषित कर सकते हैं। इस तरह के पॉइंटर को डबल पॉइंटर (पॉइंटर टू पॉइंटर) के रूप में जाना जाता है। पहले पॉइंटर का उपयोग एक चर के पते को संग्रहीत करने के लिए किया जाता है जबकि दूसरे पॉइंटर का उपयोग पहले पॉइंटर के पते को संग्रहीत करने के लिए किया जाता है। आइए इसे नीचे दिए गए आरेख द्वारा समझें।

एक डबल पॉइंटर घोषित करने का वाक्यविन्यास नीचे दिया गया है।

paunaZ **pai; // saucak kae P saucak kaIna hI ESaara kae Pk paunaZaMk.

निम्नलिखित उदाहरण पर विचार करें।

उदाहरण

#samaahitaF<PsaTidiAayaAae.Pca>
riKta mauqyaF ()
{
paunaZ P = 10;
paunaZ *pai;
paunaZ **paipai;
pai = &P; // saucak pai hI ESaara kae pataa ka P
paipai = &pai; // saucak paipai hI P AMk saucak ESaara kae pataa ka saucak pai
mauDznama("pataa ka a: %\n",pai); // pataa ka P EcCa haenaa mauita
mauDznama("pataa ka p: %\n",paipai); // pataa ka pai EcCa haenaa mauita
mauDznama("kimata saMgazhita par p: %paunaZ\n",*pai); // kimata oautaZ par pataa naihita vDara pai maIM.EZTi. 10 EcCa haenaa mauita
mauDznama("kimata saMgazhita par paipai: %paunaZ\n",**paipai); // kimata saMgazhita par pataa naihita vDara saucak kd.a par paipai
}

आउटपुट

pataa ka P: K26.8734
pataa ka pai: K26.8738
kimata saMgazhita par pai: 10
kimata saMgazhita par paipai: 10

C डबल पॉइंटर उदाहरण

आइए एक उदाहरण देखें जहां एक पॉइंटर दूसरे पॉइंटर के पते की ओर इशारा करता है।

जैसा कि आप उपरोक्त आंकड़े में देख सकते हैं, P2 में P (FFF2) का पता है, और P में संख्या चर (FFF4) का पता होता है।

उदाहरण

#samaahitaF<PsaTidiAayaAae.Pca>
paunaZ mauqyaF(){
paunaZ saMqyaa=50;
paunaZ *pai;//saucak kae paunaZ
paunaZ **paiR2;//saucak kae saucak
pai=&saMqyaa;//BaMdar pataa ka saMqyaa car
paiR2=&pai;
mauDznama("pataa ka saMqyaa car hI % \n",&saMqyaa);
mauDznama("pataa ka p car hI % \n",pai);
mauDznama("kimata ka *p car hI %paunaZ \n",*pai);
mauDznama("pataa ka pai 2 car hI % \n",paiR2);
mauDznama("kimata ka **pai 2 car hI %paunaZ \n",*pai);
naivaZtanama 0;
}

आउटपुट

pataa ka saMqyaa car hI ii i4
pataa ka pai car hI ii i4
kimata ka *pai car hI 50
pataa ka paiR2 car hI ii i2
kimata ka **pai car hI 50

Q. निम्नलिखित कार्यक्रम का आउटपुट क्या होगा?

उदाहरण

#samaahitaF<PsaTidiAayaAae.Pca>
riKta mauqyaF ()
{
paunaZ P[10] = {100, 206, 300, 409, 509, 601}; //reqaa 1
paunaZ *pai[] = {P, P+1, P+2, P+3, P+4, P+5}; //reqaa 2
paunaZ **paipai = pai; //reqaa 3
paipai++; // reqaa 4
mauDznama("%paunaZ %paunaZ %paunaZ\n",paipai-pai,*paipai - P,**paipai); // reqaa 5
*paipai++; // reqaa 6
mauDznama("%paunaZ %paunaZ %paunaZ\n",paipai-pai,*paipai - P,**paipai); // reqaa 7
++*paipai; // reqaa 8
mauDznama("%paunaZ %paunaZ %paunaZ\n",paipai-pai,*paipai - P,**paipai); // reqaa 9
++**paipai; // reqaa 10
mauDznama("%paunaZ %paunaZ %paunaZ\n",paipai-pai,*paipai - P,**paipai); // reqaa 11
}

आउटपुट

1 1 206
2 2 300
2 3 409
2 3 410

उपरोक्त प्रश्न में, पॉइंटर अंकगणित का उपयोग डबल पॉइंटर के साथ किया जाता है। 6 तत्वों की एक सरणी को परिभाषित किया गया है जिसे पॉइंटर पी के एक सरणी द्वारा इंगित किया गया है। पॉइंटर एरे पी को एक डबल पॉइंटर पीपी द्वारा इंगित किया गया है। हालांकि, उपरोक्त छवि आपको एक संक्षिप्त विचार देती है कि मेमोरी को सरणी ए और पॉइंटर एरे पी को कैसे आवंटित किया जा रहा है। पी के तत्व पॉइंटर्स हैं जो सरणी के हर तत्व की ओर इशारा कर रहे हैं। चूंकि हम जानते हैं कि सरणी नाम में सरणी का आधार पता होता है, इसलिए यह एक सूचक के रूप में काम करेगा और क्या मूल्य *(ए), *(ए+1), आदि का उपयोग करके किया जा सकता है, जैसा कि छवि में दिखाया गया है, एक [0] को निम्नलिखित तरीकों से एक्सेस किया जा सकता है। A [0]: यह सरणी के पहले तत्व तक पहुंचने का सबसे सरल तरीका है *(ए): एक स्टोर के बाद से सरणी के पहले तत्व का पता, हम उस पर अप्रत्यक्ष सूचक का उपयोग करके इसके मूल्य का उपयोग कर सकते हैं। *P [0]: यदि A [0] को एक पॉइंटर P का उपयोग करके एक्सेस किया जाना है, तो हम पॉइंटर सरणी P के पहले तत्व पर अप्रत्यक्ष ऑपरेटर ( *) का उपयोग कर सकते हैं, अर्थात, *p [0]। ** (पीपी): जैसा कि पीपी पॉइंटर सरणी के आधार पते को संग्रहीत करता है, *पीपी पॉइंटर सरणी के पहले तत्व का मूल्य देगा जो कि पूर्णांक सरणी के पहले तत्व का पता है। ** P पूर्णांक सरणी के पहले तत्व का वास्तविक मूल्य देगा। कार्यक्रम में आ रहा है, लाइन 1 और 2 पूर्णांक और सूचक सरणी को अपेक्षाकृत घोषित करते हैं। लाइन 3 पॉइंटर सरणी पी को डबल पॉइंटर को इनिशियलाइज़ करता है। जैसा कि छवि में दिखाया गया है, यदि सरणी का पता 200 से शुरू होता है और पूर्णांक का आकार 2 है, तो पॉइंटर सरणी में 200, 202, 204, 206, 208, 210 के रूप में मान होंगे। आइए विचार करें कि पॉइंटर सरणी का आधार पता 300 है; डबल पॉइंटर पीपी में पॉइंटर सरणी का पता होता है, अर्थात, 300। लाइन नंबर 4 1 से पीपी का मान बढ़ाता है, यानी, पीपी अब 302 को संबोधित करने की ओर इशारा करेगा। लाइन नंबर 5 में एक अभिव्यक्ति होती है जो तीन मानों को प्रिंट करती है, अर्थात्, पीपी - पी, *पीपी - ए, ** पीपी। आइए उनमें से हर एक की गणना करें। पीपी = 302, पी = 300 => पीपी-पी = (302-300)/2 => पीपी-पी = 1, यानी, 1 मुद्रित किया जाएगा। पीपी = 302, *पीपी = 202, ए = 200 => *पीपी - ए = 202 - 200 = 2/2 = 1, यानी, 1 मुद्रित किया जाएगा। पीपी = 302, *पीपी = 202, *( *पीपी) = 206, यानी, 206 मुद्रित किया जाएगा। इसलिए लाइन 5 के परिणाम के रूप में, आउटपुट 1, 1, 206 कंसोल पर मुद्रित किया जाएगा। लाइन 6 पर, *पीपी ++ लिखा गया है। यहां, हमें यह ध्यान देना चाहिए कि दो Unary ऑपरेटर * और ++ में एक ही पूर्वता होगी। इसलिए, संबद्धता के नियम से, इसका मूल्यांकन दाएं से बाएं से किया जाएगा। इसलिए अभिव्यक्ति *पीपी ++ को ( *(पीपी ++)) के रूप में फिर से लिखा जा सकता है। चूंकि, पीपी = 302 जो अब बन जाएगा, 304। *पीपी 204 देगा। लाइन 7 पर, फिर से अभिव्यक्ति लिखी गई है जो तीन मानों को प्रिंट करती है, अर्थात्, पीपी-पी, *पीपी-ए, *पीपी। आइए उनमें से प्रत्येक की गणना करें। पीपी = 304, पी = 300 => पीपी - पी = (304 - 300)/2 => पीपी -पी = 2, यानी, 2 मुद्रित किया जाएगा। पीपी = 304, *पीपी = 204, ए = 200 => *पीपी -ए = (204 - 200)/2 = 2, यानी, 2 मुद्रित किया जाएगा। पीपी = 304, *पीपी = 204, *( *पीपी) = 300, यानी, 300 मुद्रित किया जाएगा। इसलिए, लाइन 7 के परिणाम के रूप में, आउटपुट 2, 2, 300 कंसोल पर मुद्रित किया जाएगा। लाइन 8 पर, ++*पीपी लिखा गया है। एसोसिएटिविटी के नियम के अनुसार, इसे (++ (*(पीपी))) के रूप में फिर से लिखा जा सकता है। चूंकि, पीपी = 304, *पीपी = 204, *पीपी = *(पी [2]) = 206 का मान जो अब एक [3] की ओर इशारा करेगा। लाइन 9 पर, फिर से अभिव्यक्ति लिखी गई है जो तीन मानों को प्रिंट करती है, अर्थात्, पीपी-पी, *पीपी-ए, *पीपी। आइए उनमें से प्रत्येक की गणना करें। पीपी = 304, पी = 300 => पीपी - पी = (304 - 300)/2 => पीपी -पी = 2, यानी, 2 मुद्रित किया जाएगा। पीपी = 304, *पीपी = 206, ए = 200 => *पीपी -ए = (206 - 200)/2 = 3, यानी, 3 मुद्रित किया जाएगा। पीपी = 304, *पीपी = 206, *( *पीपी) = 409, यानी, 409 मुद्रित किया जाएगा। इसलिए, लाइन 9 के परिणाम के रूप में, आउटपुट 2, 3, 409 कंसोल पर मुद्रित किया जाएगा। लाइन 10 पर, ++ ** पीपी रिटेन है। संबद्धता के नियम के अनुसार, इसे (++ (*(*(पीपी)))) के रूप में फिर से लिखा जा सकता है। पीपी = 304, *पीपी = 206, ** पीपी = 409, ++ ** पीपी => *पीपी = *पीपी +1 = 410। दूसरे शब्दों में, ए [3] = 410। लाइन 11 पर, फिर से अभिव्यक्ति लिखी गई है जो तीन मानों को प्रिंट करती है, अर्थात्, पीपी-पी, *पीपी-ए, *पीपी। आइए उनमें से प्रत्येक की गणना करें। पीपी = 304, पी = 300 => पीपी - पी = (304 - 300)/2 => पीपी -पी = 2, यानी, 2 मुद्रित किया जाएगा। पीपी = 304, *पीपी = 206, ए = 200 => *पीपी -ए = (206 - 200)/2 = 3, यानी, 3 मुद्रित किया जाएगा। लाइन 8 पर, ** पीपी = 410। इसलिए लाइन 9 के परिणाम के रूप में, आउटपुट 2, 3, 410 कंसोल पर मुद्रित किया जाएगा। अंत में, पूर्ण कार्यक्रम का आउटपुट के रूप में दिया जाएगा: