ఈ కథనం C++లో పాయింటర్ అర్థమెటిక్ గురించి. పాయింటర్లు డేటా యొక్క మెమరీ చిరునామాను నిల్వ చేసే వేరియబుల్స్. పాయింటర్ అంకగణితం అనేది C++ ప్రోగ్రామింగ్ లాంగ్వేజ్ ప్రపంచంలో ఒక శక్తివంతమైన లక్షణం, ఇది మన మెమరీ బఫర్‌లలో కొత్త మెమరీ చిరునామాను అభివృద్ధి చేయడానికి కూడిక, గుణకారం, భాగహారం, ఇంక్రిమెంట్, తగ్గింపు మరియు తీసివేతలో పాయింటర్‌ను కలిగి ఉండే వివిధ అంకగణిత కార్యకలాపాలతో వ్యవహరించడానికి అనుమతిస్తుంది. . పాయింటర్ అంకగణితం డైనమిక్ మెమరీ కేటాయింపును సులభంగా సృష్టిస్తుంది. ఈ C++ కథనంలో, పాయింటర్ల సహాయంతో వివిధ మార్గాల్లో మెమరీ చిరునామాను ఎలా మార్చాలో మరియు సరైన మార్గదర్శకాలు మరియు ఉదాహరణలను అందించడం ఎలాగో నేర్చుకుందాం.
దృష్టాంతం 1: పాయింటర్ ఇంక్రిమెంట్ మరియు డిక్రిమెంట్ ఆపరేషన్‌లను నిర్వహిస్తుంది
ఇక్కడ, మేము విభిన్న ప్రయోజనాలను కలిగి ఉన్న విభిన్న మెమరీ చిరునామాలను ఉత్పత్తి చేయడానికి పాయింటర్ మానిప్యులేషన్ గురించి నేర్చుకుంటాము. ఇంక్రిమెంటింగ్ మరియు డిక్రీమెంటింగ్ పాయింటర్లు కూడా పరపతి పాయింటర్ల అంకగణితం, ఇవి అడ్రస్‌ను ఒక కారకం ద్వారా పెంచడం లేదా తగ్గించడం ద్వారా అవి సూచించే డేటా రకం పరిమాణంతో గుణించబడతాయి. ఈ దృష్టాంతానికి సంబంధించిన కోడ్ స్నిప్పెట్ కింది వాటిలో జోడించబడింది:
#include
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
const int Arr_Max = 5 ;
పూర్ణాంక ప్రధాన ( ) {
int ఎక్కడ [ Arr_Max ] = { ఇరవై , 150 , 270 } ;
int * ptr; // ప్రకటించండి పాయింటర్
ptr = var;
కోసం ( int i = 0 ; i < Arr_Max; i++ ) {
std::cout << 'మూలకం యొక్క మెమరీ చిరునామా : [' << i << '] = ' ;
std::cout << ptr << endl;
కోట్ << 'చిరునామాకు వ్యతిరేకంగా విలువ [' << i << '] = ' ;
కోట్ << * ptr << endl;
std::cout << 'పాయింటర్ విజయవంతంగా పెరిగింది' << endl;
ptr++;
}
std::cout << 'తగ్గింపు ముందు పాయింటర్ చిరునామా' << ptr << endl;
ptr--;
std::cout << 'తగ్గిన తర్వాత పాయింటర్ చిరునామా' << ptr << endl;
తిరిగి 0 ;
}
ఇక్కడ, మేము చాలా ప్రారంభంలో కోడ్‌లో అవసరమైన లైబ్రరీని నిర్వచించాము: “
మేము చిరునామాను యాక్సెస్ చేయడానికి పాయింటర్‌కు శ్రేణిని పాస్ చేస్తాము. మనందరికీ తెలిసినట్లుగా, శ్రేణులు ఎల్లప్పుడూ వేర్వేరు స్థానాల్లో బహుళ అంశాలను కలిగి ఉంటాయి. కాబట్టి, శ్రేణిలోని ప్రతి మూలకాన్ని యాక్సెస్ చేయడానికి మాకు “సహాయం” పాయింటర్‌తో లూప్ అవసరం. లూప్ ఎగ్జిక్యూట్ అయిన ప్రతిసారీ, మెమరీ అడ్రస్‌ను మెమొరీ అడ్రస్‌ను తదుపరి చిరునామాకు మార్చే పాయింటర్ అంకగణితం “ptr++” ఇంక్రిమెంట్ ఆపరేటర్ సహాయంతో మేము ఈ చిరునామాకు వ్యతిరేకంగా మెమరీ చిరునామా మరియు విలువలను పొందుతాము. లూప్ ఎగ్జిక్యూషన్ సైకిల్ శ్రేణి పరిమాణంపై ఆధారపడి ఉంటుంది. లూప్ వెలుపల, “ptr- -” తగ్గింపు పాయింటర్‌ని ఉపయోగించడం ద్వారా మేము పాయింటర్‌ను మునుపటి మెమరీ చిరునామాకు తిరిగి పొందాలనుకుంటున్నాము.
ఎగ్జిక్యూట్>కంపైల్ & రన్ ఎంపికను క్లిక్ చేయడం ద్వారా ఈ కోడ్‌ని అమలు చేయండి మరియు మీరు ఈ క్రింది అవుట్‌పుట్‌ను పొందుతారు:
ఆశాజనక, ఈ అవుట్‌పుట్ అర్థం చేసుకోవడం సులభం. మెమరీ చిరునామా మరియు విలువ మార్చబడ్డాయి. పాయింటర్‌ను ఒక స్థానం నుండి మార్చడం C++లోని ఇంక్రిమెంట్ పాయింటర్ అంకగణితం నుండి మాత్రమే సాధ్యమవుతుంది.
దృశ్యం 2: C++లో రెండు పాయింటర్లను తీసివేయడం
ఈ దృష్టాంతంలో, మేము C++లో రెండు లేదా అంతకంటే ఎక్కువ పాయింటర్లను ఎలా తీసివేయాలో నేర్చుకుంటాము. వ్యవకలనం వచ్చే అన్ని అంకగణిత కార్యకలాపాలు ముఖ్యమైన ప్రక్రియలు, ఎందుకంటే అవి ఒకే రకమైన డేటాను కలిగి ఉంటే మరియు మాత్రమే మేము ఒకేసారి రెండు పాయింటర్లను తీసివేయగలము.
అదనంగా, గుణకారం మరియు భాగహారం వంటి ఇతర కార్యకలాపాలు పాయింటర్‌లో సాధ్యం కాదు ఎందుకంటే అవి మెమరీ అడ్రసింగ్‌లో అర్ధవంతం కావు. కోడ్ స్నిప్పెట్ కింది వాటిలో జోడించబడింది:
#పూర్ణాంక ప్రధాన ( ) {
అతను పిలుస్తాడు [ ] = { 23 , 36 , 42 , 51 , 62 , 77 , 89 , 96 , 100 } ;
int * ptrr1 = & దానికి [ 3 ] ; // మూడవ మూలకానికి పాయింటర్ ( 42 )
int * ptrr2 = & దానికి [ 6 ] ; // ఆరవ మూలకానికి పాయింటర్ ( 89 )
ptrdiff_t ptrs వ్యవకలనం = ptrr2 - ptrr1;
std::cout << 'ఈ చిరునామాల మధ్య వ్యత్యాసం:' << ptrs వ్యవకలనం << 'మూలకాలు' << std::endl;
తిరిగి 0 ;
}
వ్యవకలన చర్య C++లో మెమరీ చిరునామా మధ్య వ్యత్యాసాన్ని కనుగొనడం. ప్రధాన ఫంక్షన్‌లో, మేము వేర్వేరు సూచికలలో వేర్వేరు విలువలను కలిగి ఉన్న శ్రేణిని తీసుకుంటాము. శ్రేణిలో, ప్రతి సూచిక వేరే మెమరీ స్థానాన్ని కలిగి ఉంటుంది. పాయింటర్ అంకగణితం సహాయంతో మనం రెండు పాయింటర్ల మధ్య వ్యత్యాసాన్ని మాత్రమే కనుగొనగలం. ఇక్కడ, మేము ప్రత్యేక పాయింటర్ రకాన్ని “ptrdiff_t” ఉపయోగిస్తాము, అది C++లో రెండు లేదా అంతకంటే ఎక్కువ పాయింటర్ల మధ్య తేడాలను కనుగొనడానికి తప్పనిసరిగా ఉపయోగించాలి.
ఈ కోడ్ యొక్క అవుట్‌పుట్ కింది వాటిలో జోడించబడింది:
ఈ చిరునామాల మధ్య వ్యత్యాసం మూలకం వైస్ ద్వారా ఉంటుంది, ఇది 3.
దృశ్యం 3: C++లో రెండు లేదా అంతకంటే ఎక్కువ పాయింటర్లను సరిపోల్చండి
ఈ దృష్టాంతంలో, “==”, “<=”, “>=”, “<”, ”>” వంటి విభిన్న రిలేషనల్ ఆపరేటర్‌లను ఉపయోగించి C++లోని విభిన్న పాయింటర్లను ఎలా పోల్చాలో నేర్చుకుంటాము. పాయింటర్లు ఒకే శ్రేణిలోని మూలకాల చిరునామాను సూచించినట్లయితే మాత్రమే మనం వాటిని పోల్చగలము. రెండు పాయింటర్లను వివిధ రకాలతో పోల్చడం నిర్వచించబడని ప్రవర్తనకు కారణమవుతుందని గుర్తుంచుకోండి. పాయింటర్ పోలికకు సంబంధించిన కోడ్ స్నిప్పెట్ కింది వాటిలో పేర్కొనబడింది:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
int arr1 [ 10 ] = { 4 , 7 , 9 , పదకొండు , 14 , 16 , 18 , ఇరవై , 22 , 25 } ;
int * ptr1 = & arr1 [ 3 ] ;
int * ptr2 = & arr1 [ 6 ] ;
int * ptr3 = & arr1 [ 8 ] ;
int * ptr4 = & arr1 [ 9 ] ;
ఉంటే ( ptr1 ==ptr2 )
{
std::cout << 'సూచనలు సమానం' << endl;
}
లేకపోతే ఉంటే ( ptr3 < =ptr4 )
{
std::cout << 'ptr3 ptr4 కంటే తక్కువ లేదా సమానం' << endl ;;
}
లేకపోతే
{
std::cout << 'సూచనలు ఏ దశలోనూ పోల్చబడవు' << endl;
}
తిరిగి 0 ;
}
ఇక్కడ, మేము 10 మూలకాలతో శ్రేణిని తీసుకుంటాము. మేము శ్రేణి యొక్క విభిన్న సూచికను సూచించే నాలుగు పాయింటర్లను ప్రకటిస్తాము. ఆ తర్వాత, ఇచ్చిన కోడ్‌లో కనిపించే విధంగా మేము ఈ నాలుగు పాయింటర్లను వేర్వేరు పరిస్థితులలో పోల్చాము. “if” కండిషన్‌లో, “ptr1” పాయింటర్, “ptr2” పాయింటర్‌కి సమానంగా ఉందో లేదో తనిఖీ చేసి, ఆపై “పాయింటర్లు ఈక్వల్” అని ప్రింట్ చేయండి. మనకు అనేక షరతులు ఉన్నప్పుడు, “ptr3” పాయింటర్ “ptr4” పాయింటర్ కంటే తక్కువగా ఉందో లేదో తనిఖీ చేయడానికి “else if” షరతును ఉపయోగిస్తాము. అన్ని తరువాత, క్లిక్ చేయండి ఎగ్జిక్యూట్ > కంపైల్ & రన్ ఎంపిక.
ఈ కోడ్ యొక్క అవుట్‌పుట్ కింది వాటిలో జోడించబడింది:
ఇది కన్సోల్ స్క్రీన్‌పై చెల్లుబాటు అయ్యే పరిస్థితిని ప్రదర్శిస్తుంది మరియు సంకలనం నుండి నిష్క్రమిస్తుంది. “ptr3” పాయింటర్ “ptr4” పాయింటర్ పాయింటింగ్ విలువ కంటే తక్కువ లేదా సమానమైన విలువను కలిగి ఉంది.
దృష్టాంతం 4: పాయింటర్ అర్థమెటిక్‌తో బేసి సంఖ్యను ప్రదర్శించండి
ఇక్కడ, పూర్ణాంకం యొక్క శ్రేణికి మెమరీని ఎలా డైనమిక్‌గా కేటాయించవచ్చో చూద్దాం. ఈ కేసుకు సంబంధించిన కోడ్ స్నిప్పెట్ కింది వాటిలో ఇవ్వబడింది:
#పూర్ణాంక ప్రధాన ( ) {
పూర్ణాంక సంఖ్యలు [ ] = { 1 , 12 , 33 , 24 , పదిహేను , 776 , 71 , 18 , 29 , యాభై } ;
int * ptrr = సంఖ్యలు;
std::cout << 'శ్రేణులలో బేసి సంఖ్యలు:' ;
కోసం ( int i = 0 ; i < 10 ; ++i ) {
ఉంటే ( * ptrr % 2 ! = 0 ) {
std::cout << * ptrr << '' ;
}
ptrr++;
}
std::cout << std::endl;
తిరిగి 0 ;
}
ప్రధాన విధిలో, మేము 10 మూలకాలను కలిగి ఉన్న శ్రేణిని తీసుకుంటాము. శ్రేణిలోని బేసి సంఖ్యను తనిఖీ చేయడానికి శ్రేణిలోని అన్ని మూలకాలను సూచించే పాయింటర్ మనకు అవసరం. 'ఫర్' లూప్‌లో, శ్రేణి యొక్క ప్రస్తుత మూలకాన్ని విభజించడం ద్వారా బేసి సంఖ్యను తనిఖీ చేయండి. శ్రేణిలోని ఒక మూలకాన్ని తనిఖీ చేసిన తర్వాత పాయింటర్ కౌంటర్ పెంచబడుతుంది.
కోడ్‌ని అమలు చేసిన తర్వాత, అవుట్‌పుట్ కన్సోల్ స్క్రీన్‌పై ప్రదర్శించబడుతుంది, అది కింది వాటిలో ఇవ్వబడింది:
ఈ విధంగా, మేము కన్సోల్ స్క్రీన్‌పై పాయింటర్ అంకగణితాన్ని ఉపయోగించి బేసి సంఖ్యలను ప్రదర్శించవచ్చు.
ముగింపు
పాయింటర్ అంకగణితం అనేది C++లో వివిధ కార్యకలాపాలను చేసే అత్యంత ప్రభావవంతమైన సాధనం అని మేము ఇక్కడ నిర్ధారించాము. పాయింటర్ అదే డేటా రకాన్ని కలిగి ఉన్న శ్రేణి విలువను పెంచుతుందని లేదా తగ్గుతుందని నిర్ధారించుకోండి. C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లోని పాయింటర్ అర్థమెటిక్ సహాయంతో మేము శ్రేణి విలువలను వాటి మెమరీ చిరునామాల ద్వారా పోల్చవచ్చు. పాయింటర్ అర్థమెటిక్ సహాయంతో మనం శ్రేణిని దాటవచ్చు మరియు మెమరీని సులభంగా నిర్వహించవచ్చు.