सी मध्ये पॉईंटर अंकगणित

आम्ही जोडणे, वजाबाकी इत्यादी पॉईंटर्सवर अंकगणित ऑपरेशन्स करू शकतो. तथापि, आम्हाला माहित आहे की पॉईंटरमध्ये पत्ता आहे, पॉईंटरवर केलेल्या अंकगणित ऑपरेशनचा परिणाम देखील पॉईंटर असेल जर इतर ऑपरेंड टाइप इंटिजर असेल तर. पॉईंटर-पॉईंटर वजाबाकीमध्ये, परिणाम एक पूर्णांक मूल्य असेल. सी भाषेतील पॉईंटरवर अंकगणित ऑपरेशन्स खालीलप्रमाणे आहेत: वाढ घट जोड वजाबाकी तुलना

सी मध्ये वाढीव पॉईंटर

जर आपण पॉईंटर 1 ने वाढविला तर पॉईंटर त्वरित पुढील स्थानाकडे निर्देशित करेल. हे सामान्य अंकगणितापेक्षा काहीसे वेगळे आहे कारण पॉईंटरचे मूल्य पॉईंटर निर्देशित करीत असलेल्या डेटा प्रकाराच्या आकाराने वाढेल. आम्ही पॉईंटरवर वाढीच्या ऑपरेशनचा वापर करून अ‍ॅरेला ओलांडू शकतो जे अ‍ॅरेच्या प्रत्येक घटकाकडे लक्ष वेधून घेईल, त्यावर काही ऑपरेशन करेल आणि लूपमध्ये स्वतःला अद्यतनित करेल. पॉईंटर वाढविण्याचा नियम खाली दिला आहे:

DmauRMkktamaee= krMTRdesa + mai * AakarRApaf(deTa pzakar)

जिथे मी पॉईंटर वाढतो त्या संख्येने.

32-बिट

32-बिट इंट व्हेरिएबलसाठी, त्यास 2 बाइटद्वारे वाढविले जाईल.

64-बिट

64-बिट इंट व्हेरिएबलसाठी, त्यास 4 बाइट्सने वाढविले जाईल. चला 64-बिट आर्किटेक्चरवर पॉईंटर व्हेरिएबलची वाढ करण्याचे उदाहरण पाहूया.

उदाहरण

#vaapara<PsaTidiAayaAae.Pca>
paunaZ mauqya(){
paunaZ kzmaaMk=50;
paunaZ *pai;//paEZMTr Tu paunaZ
pai=&kzmaaMk;//sTaeAr D paaa cyaa kzmaaMk cala
laiha("paaa cyaa p cala Aahe %u \n",pai);
pai=pai+1;
laiha("naMtar vaaW: paaa cyaa p cala Aahe %u \n",pai); // maoyae Aamacai sYaitai, pai vaila maiQvaa vaaWiva vDara 4 baaET.
vaapasakra 0;
}

आउटपुट

paaa cyaa pai cala Aahe 3214864300
naMtar vaaW: paaa cyaa pai cala Aahe 3214864304

पॉईंटर वापरुन अ‍ॅरेचा मागोवा घेत आहे

उदाहरण

#vaapara<PsaTidiAayaAae.Pca>
qaalai mauqya ()
{
paunaZ PAar[5] = {1, 2, 3, 4, 5};
paunaZ *pai = PAar;
paunaZ mai;
laiha("mauna AWre oaTk...\n");
jaeMvh(mai = 0; mai< 5; mai++)
{
laiha("%paunaZ ",*(pai+mai));
}
}

आउटपुट

mauna AWre oaTk...
1 2 3 4 5

सी मध्ये कमी करणे पॉईंटर

वाढीप्रमाणे, आम्ही पॉईंटर व्हेरिएबल कमी करू शकतो. जर आपण पॉईंटर कमी केले तर ते मागील स्थानाकडे निर्देशित करण्यास प्रारंभ करेल. पॉईंटर कमी करण्याचे सूत्र खाली दिले आहे:

DmauRMkktamaee= krMTRdesa - mai * AakarRApaf(deTa pzakar)

32-बिट

32-बिट इंट व्हेरिएबलसाठी, ते 2 बाइट्सने कमी केले जाईल.

64-बिट

64-बिट इंट व्हेरिएबलसाठी, ते 4 बाइट्सने कमी केले जाईल. 64-बिट ओएस वर पॉईंटर व्हेरिएबल कमी करण्याचे उदाहरण पाहूया.

उदाहरण

#vaapara <PsaTidiAayaAae.Pca>
qaalai mauqya(){
paunaZ kzmaaMk=50;
paunaZ *pai;//paEZMTr Tu paunaZ
pai=&kzmaaMk;//sTaeAr D paaa cyaa kzmaaMk cala
laiha("paaa cyaa p cala Aahe %u \n",pai);
pai=pai-1;
laiha("naMtar oaT: paaa cyaa p cala Aahe %u \n",pai); // pai vaila Aataa paEZMT Tu D EmaidiPT maagaila sYaana.
}

आउटपुट

पी व्हेरिएबलचा पत्ता 3214864300 आहे कमी झाल्यानंतर: पी व्हेरिएबलचा पत्ता 3214864296 आहे

आम्ही पॉईंटर व्हेरिएबलमध्ये मूल्य जोडू शकतो. पॉईंटरमध्ये मूल्य जोडण्याचे सूत्र खाली दिले आहे:

DmauRMkktamaee= krMTRdesa + (kzmaaMk * AakarRApaf(deTa pzakar))

32-बिट

32-बिट इंट व्हेरिएबलसाठी, ते 2 * क्रमांक जोडेल.

64-बिट

64-बिट इंट व्हेरिएबलसाठी, ते 4 * क्रमांक जोडेल. 64-बिट आर्किटेक्चरवर पॉईंटर व्हेरिएबलमध्ये मूल्य जोडण्याचे उदाहरण पाहूया.

उदाहरण

#vaapara<PsaTidiAayaAae.Pca>
paunaZ mauqya(){
paunaZ kzmaaMk=50;
paunaZ *pai;//paEZMTr Tu paunaZ
pai=&kzmaaMk;//sTaeAr D paaa cyaa kzmaaMk cala
laiha("paaa cyaa p cala Aahe %u \n",pai);
pai=pai+3; //jaaedtaRAahe 3 Tu paEZMTr cala
laiha("naMtar jaaedta Aahe 3: paaa cyaa p cala Aahe %u \n",pai);
vaapasakra 0;
}

आउटपुट

paaa cyaa pai cala Aahe 3214864300
naMtar jaaedtaRAahe 3: paaa cyaa pai cala Aahe 3214864312

जसे आपण पाहू शकता, पीचा पत्ता 3214864300 आहे. परंतु पी व्हेरिएबलसह 3 जोडल्यानंतर ते 3214864312 आहे, म्हणजेच 4*3 = 12 वाढ. आम्ही 64-बिट आर्किटेक्चर वापरत असल्याने ते 12 वाढते. परंतु जर आपण 32-बिट आर्किटेक्चर वापरत असाल तर ते केवळ 6 पर्यंत वाढत होते, म्हणजेच 2*3 = 6. 32-बिट ओएसमध्ये पूर्णांक मूल्य 2-बाइट मेमरी व्यापते म्हणून.

सी पॉईंटर वजाबाकी

पॉईंटर व्यतिरिक्त, आम्ही पॉईंटर व्हेरिएबलमधून मूल्य वजा करू शकतो. पॉईंटरकडून कोणतीही संख्या वजा केल्यास पत्ता मिळेल. पॉईंटर व्हेरिएबलमधून वजाबाकीचे मूल्य खाली दिले आहे:

DmauRMkktamaee= krMTRdesa - (kzmaaMk * AakarRApaf(deTa pzakar))

32-बिट

32-बिट इंट व्हेरिएबलसाठी, ते 2 * क्रमांक वजा करेल.

64-बिट

64-बिट इंट व्हेरिएबलसाठी, ते 4 * क्रमांक वजा करेल. चला 64-बिट आर्किटेक्चरवरील पॉईंटर व्हेरिएबलमधून मूल्य वजा करण्याचे उदाहरण पाहूया.

उदाहरण

#vaapara<PsaTidiAayaAae.Pca>
paunaZ mauqya(){
paunaZ kzmaaMk=50;
paunaZ *pai;//paEZMTr Tu paunaZ
pai=&kzmaaMk;//sTaeAr D paaa cyaa kzmaaMk cala
laiha("paaa cyaa p cala Aahe %u \n",pai);
pai=pai-3; //vajaaRkrnae 3 paasauna paEZMTr cala
laiha("naMtar vajaa krnae 3: paaa cyaa p cala Aahe %u \n",pai);
vaapasakra 0;
}

आउटपुट

paaa cyaa pai cala Aahe 3214864300
naMtar vajaaRkrnae 3: paaa cyaa pai cala Aahe 3214864288

पॉईंटर व्हेरिएबलमधून 3 वजा केल्यानंतर आपण पाहू शकता, ते मागील पत्त्याच्या मूल्यापेक्षा 12 (4*3) कमी आहे. तथापि, नंबर वजा करण्याऐवजी आम्ही दुसर्‍या पत्त्यावरून (पॉईंटर) पत्ता वजा करू शकतो. याचा परिणाम एक नंबर होईल. हे एक साधे अंकगणित ऑपरेशन होणार नाही, परंतु ते खालील नियमांचे पालन करेल. जर दोन पॉईंटर्स एकाच प्रकारचे असतील तर,

paaaR2 - paaaR1 = (vajaabaaki cyaa Daena paae)/Aakar cyaa deTa pzakar kaya paEZMTr gauna

एका पॉईंटरला दुसर्‍यापासून वजा करण्यासाठी खालील उदाहरणाचा विचार करा.

उदाहरण

#vaapara<PsaTidiAayaAae.Pca>
qaalai mauqya ()
{
paunaZ mai = 100;
paunaZ *pai = &mai;
paunaZ *Tempa;
Tempa = pai;
pai = pai + 3;
laiha("paEZMTr vajaabaaki: %paunaZ - %paunaZ = %paunaZ",pai, Tempa, pai-Tempa);
}

आउटपुट

paEZMTr vajaabaaki: 1030585080 - 1030585068 = 3

पॉईंटर्ससह बेकायदेशीर अंकगणित

अशी अनेक ऑपरेशन्स आहेत जी पॉईंटर्सवर केली जाऊ शकत नाहीत. कारण, पॉईंटर स्टोअर्स संबोधित करतात म्हणूनच आपण ऑपरेशन्सकडे दुर्लक्ष केले पाहिजे ज्यामुळे बेकायदेशीर पत्ता होऊ शकेल, उदाहरणार्थ, व्यतिरिक्त आणि गुणाकार. अशा ऑपरेशन्सची यादी खाली दिली आहे. पत्ता + पत्ता = बेकायदेशीर पत्ता * पत्ता = बेकायदेशीर पत्ता % पत्ता = बेकायदेशीर पत्ता / पत्ता = बेकायदेशीर पत्ता आणि पत्ता = बेकायदेशीर पत्ता ^ पत्ता = बेकायदेशीर पत्ता | पत्ता = बेकायदेशीर ~ पत्ता = बेकायदेशीर

सी मध्ये कार्य करण्यासाठी पॉईंटर

आम्ही मागील अध्यायात चर्चा केल्याप्रमाणे, पॉईंटर सी मधील फंक्शनकडे निर्देशित करू शकतो तथापि, पॉईंटर व्हेरिएबलची घोषणा फंक्शन प्रमाणेच असणे आवश्यक आहे. फंक्शनकडे निर्देशित करण्यासाठी पॉईंटर करण्यासाठी खालील उदाहरणाचा विचार करा.

उदाहरण

#vaapara<PsaTidiAayaAae.Pca>
paunaZ jaaed ();
paunaZ mauqya ()
{
paunaZ parinaama;
paunaZ (*paiTiAar)();
paiTiAar = &jaaed;
parinaama = (*paiTiAar)();
laiha("D baerija Aahe %paunaZ",parinaama);
}
paunaZ jaaed()
{
paunaZ A, bai;
laiha("pzavaiST kra Daena saMqyaa?");
vacaa("%paunaZ %paunaZ",&A,&bai);
vaapasakra A+bai;
}

आउटपुट

pzavaiSTRkra Daena saMqyaa?10 15
D baerija Aahe 25

सी मध्ये फंक्शन्सच्या अ‍ॅरेचे पॉईंटर

फंक्शन्सच्या अ‍ॅरेची संकल्पना समजण्यासाठी, आपल्याला फंक्शनचा अ‍ॅरे समजला पाहिजे. मूलभूतपणे, फंक्शनचा अ‍ॅरे एक अ‍ॅरे आहे ज्यामध्ये फंक्शन्सचे पत्ते असतात. दुस words ्या शब्दांत, फंक्शन्सच्या अ‍ॅरेचे पॉईंटर एक अ‍ॅरेकडे निर्देशित करणारा पॉईंटर आहे ज्यामध्ये फंक्शन्समध्ये पॉईंटर्स असतात. खालील उदाहरणाचा विचार करा.

उदाहरण

#vaapara<PsaTidiAayaAae.Pca>
paunaZ DSaZvaa();
paunaZ pzaDSaZna(paunaZ);
paunaZ (*PAar[3])();
paunaZ (*(*paiTiAar)[3])();

paunaZ mauqya ()
{
paunaZ parinaamaR1;
PAar[0] = DSaZvaa;
PAar[1] = pzaDSaZna;
paiTiAar = &PAar;
parinaamaR1 = (**paiTiAar)();
laiha("mauna D maulya parta Aalae vDara DSaZvaa : %paunaZ",parinaamaR1);
(*(*paiTiAar+1))(parinaamaR1);
}
paunaZ DSaZvaa()
{
paunaZ A = 65;
vaapasakra A++;
}
paunaZ pzaDSaZna(paunaZ bai)
{
laiha("\DMkkpaDh 90 Tu D maulya parta Aalae vDara DSaZvaa: %paunaZ",bai+90);
}

आउटपुट

mauna D maulya partaRAalae vDara DSaZvaa : 65
jaaedtaRAahe 90 Tu D maulya partaRAalae vDara DSaZvaa: 155

bcaMMmaz kimataa laayataarhuAa AkMtaM KpauMMMMMMMma : 65<baiAar>jaaPd.AjaaZrhrhi 90 aMma kimataa laayataarhuAa AkMtaM KpauMMMMMMMma: 155<baiAar>