सी में शून्य सूचक

शून्य सूचक का वाक्य

riKta *saucak naama;

शून्य सूचक की घोषणा नीचे दी गई है:

riKta *paiTiAar;

उपरोक्त घोषणा में, शून्य सूचक का प्रकार है, और 'पीटीआर' सूचक का नाम है।

आइए कुछ उदाहरणों पर विचार करें: paunaZ i = 9; // पूर्णांक चर आरंभीकरण। paunaZ *p; // पूर्णांक सूचक घोषणा। फ्लोट *fp; // फ्लोटिंग पॉइंटर घोषणा। शून्य *ptr; // शून्य सूचक घोषणा। पी = एफपी; // गलत। fp = & i; // गलत ptr = p; // सही ptr = fp; // सही ptr = & i; // सही

सी में शून्य सूचक का आकार

C में शून्य सूचक का आकार वर्ण प्रकार के सूचक के आकार के समान है। सी परसेप्शन के अनुसार, एक पॉइंटर टू शून्य का प्रतिनिधित्व चरित्र प्रकार के सूचक के समान है। पॉइंटर का आकार उस प्लेटफ़ॉर्म के आधार पर अलग -अलग होगा जो आप उपयोग कर रहे हैं।

आइए नीचे दिए गए उदाहरण को देखें:

#samaahitaF <PsaTidiAayaAae.Pca>
paunaZ mauqyaF()
{
riKta *paiTiAar = vyaYaZ; //riKta saucak
paunaZ *pai = vyaYaZ;// paunaZaMk saucak
AxarF *saipai = vyaYaZ;//cariOa saucak
ApaunaZ *Ppafpai = vyaYaZ;//ApaunaZ saucak
//Aakar ka riKta saucak
mauDznama("Aakar ka qaalaipana saucak = %paunaZ\n\n",Aakar(paiTiAar));
//Aakar ka paunaZaMk saucak
mauDznama("Aakar ka paunaZaMk saucak = %paunaZ\n\n",Aakar(pai));
//Aakar ka cariOa saucak
mauDznama("Aakar ka cariOa saucak = %paunaZ\n\n",Aakar(saipai));
//Aakar ka ApaunaZ saucak
mauDznama("Aakar ka taIrnaa saucak = %paunaZ\n\n",Aakar(Ppafpai));
naivaZtanama 0;
}

शून्य सूचक के लाभ

निम्नलिखित एक शून्य सूचक के फायदे हैं: Malloc () और Calloc () फ़ंक्शन शून्य पॉइंटर को लौटाता है, इसलिए इन कार्यों का उपयोग किसी भी डेटा प्रकार की मेमोरी को आवंटित करने के लिए किया जा सकता है।

#samaahitaF <PsaTidiAayaAae.Pca>
#samaahitaF<smautai_AavaMTna_1.Pca>
paunaZ mauqyaF()
{
paunaZ P=90;

paunaZ *PKsa = (paunaZ*)smautai_AavaMTna_1(Aakar(paunaZ)) ;
PKsa=&P;
mauDznama("kimata kaIna hI naukilaa vDara x saucak : %paunaZ",*PKsa);
naivaZtanama 0;
}

शून्य सूचक से संबंधित कुछ महत्वपूर्ण बिंदु हैं:

#samaahitaF <PsaTidiAayaAae.Pca>
paunaZ mauqyaF()
{
paunaZ P=90;
riKta *paiTiAar;
paiTiAar=&P;
mauDznama("kimata kaIna hI naukilaa vDara paiTiAar saucak : %paunaZ",*paiTiAar);
naivaZtanama 0;
}

उपरोक्त कोड में, *पीटीआर एक शून्य सूचक है जो पूर्णांक चर 'ए' की ओर इशारा कर रहा है। जैसा कि हम पहले से ही जानते हैं कि शून्य पॉइंटर को समाप्त नहीं किया जा सकता है, इसलिए उपरोक्त कोड संकलन-समय त्रुटि देगा क्योंकि हम पॉइंटर 'पीटीआर' द्वारा बताए गए चर के मूल्य को सीधे प्रिंट कर रहे हैं।

अब, हम त्रुटि को दूर करने के लिए उपरोक्त कोड को फिर से लिखते हैं।

#samaahitaF <PsaTidiAayaAae.Pca>
paunaZ mauqyaF()
{
paunaZ P=90;
riKta *paiTiAar;
paiTiAar=&P;
mauDznama("kimata kaIna hI naukilaa vDara paiTiAar saucak : %paunaZ",*(paunaZ*)paiTiAar);
naivaZtanama 0;
}

उपरोक्त कोड में, हम नीचे दिए गए कथन का उपयोग करके पूर्णांक सूचक को शून्य सूचक टाइप करते हैं: (paunaZ*) ptr; फिर, हम उस चर के मान को प्रिंट करते हैं जो नीचे दिए गए कथन का उपयोग करके शून्य सूचक 'पीटीआर' द्वारा इंगित किया गया है: *(paunaZ*) ptr;

शून्य पॉइंटर्स पर अंकगणितीय संचालन

हम सीधे C में शून्य पॉइंटर्स पर अंकगणितीय संचालन लागू नहीं कर सकते हैं। हमें उचित टाइपकास्टिंग को लागू करने की आवश्यकता है ताकि हम शून्य पॉइंटर्स पर अंकगणितीय संचालन कर सकें।

आइए नीचे दिए गए उदाहरण देखें:

#samaahitaF<PsaTidiAayaAae.Pca>
paunaZ mauqyaF()
{
ApaunaZ P[4]={6.1,2.3,7.8,9.0};
riKta *paiTiAar;
paiTiAar=P;
kurftae(paunaZ maIM=0;maIM<4;maIM++)
{
mauDznama("%ApaunaZ,",*paiTiAar);
paiTiAar=paiTiAar+1; // galata.

}}

उपरोक्त कोड संकलन-समय त्रुटि को दर्शाता है कि "शून्य अभिव्यक्ति का अमान्य उपयोग" के रूप में हम सीधे शून्य सूचक पर अंकगणितीय संचालन को लागू नहीं कर सकते हैं, अर्थात, पीटीआर = पीटीआर+1।

आइए त्रुटि को हटाने के लिए उपरोक्त कोड को फिर से लिखें।

#samaahitaF<PsaTidiAayaAae.Pca>
paunaZ mauqyaF()
{
ApaunaZ P[4]={6.1,2.3,7.8,9.0};
riKta *paiTiAar;
paiTiAar=P;
kurftae(paunaZ maIM=0;maIM<4;maIM++)
{
mauDznama("%ApaunaZ,",*((ApaunaZ*)paiTiAar+maIM));
}}

उपरोक्त कोड सफलतापूर्वक चलता है क्योंकि हमने शून्य पॉइंटर पर उचित कास्टिंग लागू की, अर्थात्, (फ्लोट*) पीटीआर और फिर हम अंकगणित ऑपरेशन, अर्थात्,*((फ्लोट*) पीटीआर+i) को लागू करते हैं।

हम शून्य पॉइंटर्स का उपयोग क्यों करते हैं?

हम इसके पुन: प्रयोज्य के कारण शून्य संकेत का उपयोग करते हैं। शून्य पॉइंटर्स किसी भी प्रकार की वस्तु को संग्रहीत कर सकते हैं, और हम उचित टाइपकास्टिंग के साथ अप्रत्यक्ष ऑपरेटर का उपयोग करके किसी भी प्रकार की वस्तु को पुनः प्राप्त कर सकते हैं।

आइए एक उदाहरण के माध्यम से समझें।

#samaahitaF<PsaTidiAayaAae.Pca>
paunaZ mauqyaF()
{
paunaZ P=56; // pzaarMBa ka P paunaZaMk car 'P'.
ApaunaZ bai=4.5; // pzaarMBa ka P ApaunaZ car 'bai'.
AxarF sai='a'; // pzaarMBa ka P AxarF car 'sai'.
riKta *paiTiAar; // oaaeSanaa ka riKta saucak.
// naiyata pataa ka car 'P'.
paiTiAar=&P;
mauDznama("kimata ka 'a' hI : %paunaZ",*((paunaZ*)paiTiAar));
// naiyata pataa ka car 'bai'.
paiTiAar=&bai;
mauDznama("\Pk pzakar ka haenaa ka 'b' hI : %ApaunaZ",*((ApaunaZ*)paiTiAar));
// naiyata pataa ka car 'sai'.
paiTiAar=&sai;
mauDznama("\Pk pzakar ka haenaa ka 'c' hI : %AxarF",*((AxarF*)paiTiAar));
naivaZtanama 0;
}