ఈ కథనం C++లో పాయింటర్ టు పాయింటర్ కాన్సెప్ట్ గురించి. పాయింటర్ నుండి పాయింటర్ పాయింట్లు లేదా మరొక పాయింటర్ యొక్క చిరునామాను నిల్వ చేస్తుంది మరియు పాయింటర్‌ల యొక్క తారుమారుని అనుమతిస్తుంది. ఈ కాన్సెప్ట్‌ని ఉపయోగించి, మనం మెమరీలోని మరొక స్థానం నుండి పాయింటర్‌ని సులభంగా సవరించవచ్చు. డైనమిక్‌గా కేటాయించబడిన మెమరీ లేదా శ్రేణి యొక్క మూలకాలను మార్చటానికి బహుళ-డైమెన్షనల్ శ్రేణులలో డబుల్ పాయింటర్‌లు ప్రయోజనకరంగా ఉంటాయి. మేము ఈ పాయింటర్ టు పాయింటర్ వర్కింగ్ మరియు సి++లో సరైన ఉదాహరణలతో వినియోగాన్ని చర్చిస్తాము.
దృశ్యం 1: పాయింటర్ టు పాయింటర్ యొక్క మెమరీ ప్రాతినిధ్యం
ఈ దృష్టాంతంలో, డబుల్ పాయింటర్‌ను ప్రకటించడం అనేది పాయింటర్ పేరుకు ముందు అదనపు నక్షత్రం (*) ఉన్న పాయింటర్ డిక్లరేషన్‌ను పోలి ఉంటుంది. మేము C++లో డబుల్ పాయింటర్ యొక్క మెమరీ స్థానాన్ని సులభంగా సూచించగలము. పాయింటర్ నుండి పాయింటర్ యొక్క కోడ్ స్నిప్పెట్ క్రింది వాటిలో ఇవ్వబడింది:
#
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( )
{
పూర్ణాంక అంకె = యాభై ;
int * ptrr;
ptrr = & అంకె;
int ** ptrr1;
ptrr1 = & ptrr;
కోట్ << 'పాయింటర్ మెమరీ చిరునామా: \n ' ;
కోట్ << 'ptrr (పాయింటర్): ' << ptrr << ' \n ' ;
కోట్ << '*ptrr1 (డబుల్ పాయింటర్): ' <<* ptrr1 << ' \n ' ;
కోట్ << 'పాయింటర్‌లోని విలువ నిల్వలు: \n ' ;
కోట్ << '*ptrr =' <<* ptrr << endl;
కోట్ << '**ptrr1 (పాయింటర్ నుండి పాయింటర్) = ' <<** ptrr1 << endl;
తిరిగి 0 ;
}
ప్రధాన ఫంక్షన్‌లో, మేము ఒక వేరియబుల్ తీసుకుంటాము, దీని మెమరీ చిరునామా పాయింటర్‌లో నిల్వ చేయబడాలి. ఇప్పుడు, మేము 'అంకె' వేరియబుల్‌ను ప్రారంభించాము. ఆ తరువాత, మేము 'అంకె' మెమరీ చిరునామాను నిల్వ చేసే 'ptrr' పాయింటర్‌ను ప్రకటిస్తాము. ఇప్పుడు, '*ptrr' పాయింటర్ చిరునామాను నిల్వ చేసే '** ptrr1' అనే డబుల్ పాయింటర్‌ని మేము ప్రకటిస్తాము. కోడ్ చివరిలో, మేము కన్సోల్ స్క్రీన్‌పై పాయింటర్ మరియు డబుల్ పాయింటర్ యొక్క మెమరీ మరియు విలువను ప్రదర్శిస్తాము. ఈ కోడ్ యొక్క అవుట్‌పుట్ క్రింది వాటిలో పేర్కొనబడింది:
“ptrr” పాయింటర్ యొక్క మెమరీ చిరునామా “0x6ffe04”, మరియు “*ptrr1” పాయింటర్ “ptrr” పాయింటర్ యొక్క మెమరీ చిరునామాను కూడా నిల్వ చేస్తుంది. పాయింటర్ లోపల నిల్వ చేయబడిన విలువ '50'. ప్రాథమికంగా, డబుల్ పాయింటర్ యొక్క చిరునామా ఎల్లప్పుడూ పాయింటర్ యొక్క మెమరీ చిరునామా వలె ఉంటుంది.
దృష్టాంతం 2: పాయింటర్ టు పాయింటర్‌ని ఫంక్షన్ పారామీటర్‌గా
ఈ దృష్టాంతంలో, ఏదైనా వేరియబుల్‌లో తాత్కాలిక మెమరీ కేటాయింపును నిర్వహించడానికి ఏదైనా ఫంక్షన్‌లో డబుల్ పాయింటర్‌ను పారామీటర్‌గా ఎలా పాస్ చేయాలో నేర్చుకుంటాము. డబుల్ పాయింటర్‌తో ఫంక్షన్ పరామితి యొక్క కోడ్ స్నిప్పెట్ కింది వాటిలో పేర్కొనబడింది:
#include
getMemoryAddress శూన్యం ( int ** డబుల్_ptr ) {
మీరు వాతావరణం = 200 ;
* double_ptr = & ఉష్ణోగ్రత;
}
పూర్ణాంక ప్రధాన ( ) {
int * ptr_1;
int ** డబుల్_ptr;
double_ptr = & ptr_1;
మెమరీ చిరునామా పొందండి ( డబుల్_ptr ) ;
std::cout << '**డబుల్_ptr విలువ : ' << ** డబుల్_ptr << std::endl;
తిరిగి 0 ;
}
ఇక్కడ, C++లో పాయింటర్ టు పాయింటర్ కాన్సెప్ట్ ఎలా పనిచేస్తుందో తెలుసుకుందాం. డబుల్ పాయింటర్‌తో పనిచేయడానికి ప్రోగ్రామ్‌లో ఒక పాయింటర్ ప్రకటించబడిందని గుర్తుంచుకోండి. కాబట్టి, మేము 'getMemoryAddress' ఫంక్షన్‌ను నిర్మిస్తాము. మేము ఈ ఫంక్షన్‌ను డిజైన్ చేస్తాము, తద్వారా మేము పరామితిని పాస్ చేసినప్పుడు, అది స్వయంచాలకంగా డబుల్ పాయింటర్ యొక్క మెమరీ చిరునామాను పొందుతుంది.
ఫంక్షన్‌లో, మేము “tempp” వేరియబుల్ మరియు “**double_ptr” డబుల్ పాయింటర్‌ని తీసుకుంటాము. మేము పేర్కొన్న వేరియబుల్ యొక్క చిరునామాను డబుల్ పాయింటర్కు “టెంప్” మరియు డబుల్ పాయింటర్ విలువలను ఫంక్షన్ యొక్క ఆర్గ్యుమెంట్‌గా పాస్ చేస్తాము. ప్రోగ్రామ్ కన్సోల్ స్క్రీన్‌పై ప్రధాన ఫంక్షన్ కోడ్ ఫలితాన్ని ప్రదర్శిస్తుంది, కాబట్టి ప్రధాన ఫంక్షన్‌లో ఉన్న అన్ని విషయాలు ఎక్జిక్యూటబుల్. మేము ప్రధాన ఫంక్షన్‌లో “ptr_1” పాయింటర్ మరియు డబుల్ పాయింటర్‌ని “double_ptr”గా తీసుకుంటాము. మేము పాయింటర్ యొక్క చిరునామాను డబుల్ పాయింటర్కు పాస్ చేస్తాము.
ఇప్పుడు, మేము ఓవర్‌రైడ్ ఫంక్షన్‌లో డబుల్ పాయింటర్ వేరియబుల్‌ను పాస్ చేస్తాము మరియు డబుల్ పాయింటర్ ఫలితాన్ని చూపించడానికి “కౌట్” అవుట్‌పుట్ స్ట్రీమ్ స్టేట్‌మెంట్‌లోని పాయింటర్ వేరియబుల్‌కు పాయింటర్‌ను పాస్ చేస్తాము.
కంపైలర్ ఓవర్‌రైడ్ ఫంక్షన్‌కు చేరుకున్నప్పుడు, ఈ ఫంక్షన్ నిర్వచించబడిన కంపైలర్ చెకర్ ఫంక్షన్‌లోని కోడ్‌ను అమలు చేస్తుంది మరియు ఫలితాన్ని ప్రధాన ఫంక్షన్‌కి అందిస్తుంది.
ఈ కోడ్ యొక్క అవుట్‌పుట్ కింది వాటిలో జోడించబడింది:
ఫలితం: డబుల్ పాయింటర్ విలువ 200.
దృశ్యం 3: పాయింటర్ టు పాయింటర్‌తో 2D అర్రేని ఉపయోగించడం
ఈ ఉదాహరణలో, మేము డబుల్ పాయింటర్‌ని కలిగి ఉన్న 2D శ్రేణితో వ్యవహరిస్తాము. మేము శ్రేణిని తీసుకుంటాము మరియు పాయింటర్‌లో శ్రేణి చిరునామాను పాస్ చేస్తాము. ఈ దృశ్యం యొక్క పూర్తి కోడ్ క్రింది విధంగా అందించబడింది:
పూర్ణాంక ప్రధాన ( ) {const int వరుసలు = 3 ;
const int cols = 2 ;
int ** matrix = కొత్త int * [ వరుసలు ] ;
కోసం ( int i = 0 ; i < వరుసలు; ++i ) {
మాతృక [ i ] = కొత్త int [ cols ] ;
}
కోసం ( int i = 0 ; i < వరుసలు; ++i ) {
కోసం ( int j = 0 ; జె < cols; ++j ) {
మాతృక [ i ] [ జె ] = నేను * cols + j;
}
}
కోసం ( int i = 0 ; i < వరుసలు; ++i ) {
కోసం ( int j = 0 ; జె < cols; ++j ) {
కోట్ << మాతృక [ i ] [ జె ] << '' ;
}
కోట్ << endl;
}
కోసం ( int i = 0 ; i < వరుసలు; ++i ) {
తొలగించు [ ] మాతృక [ i ] ;
}
తొలగించు [ ] మాతృక;
తిరిగి 0 ;
}
మనందరికీ తెలిసినట్లుగా, మనకు 2D శ్రేణిలో అనేక వరుసలు మరియు అనేక నిలువు వరుసలు ఉన్నాయి. ప్రధాన ఫంక్షన్‌లో, 'const int' ఉన్న అడ్డు వరుసలు మరియు నిలువు వరుసలను మేము ప్రారంభిస్తాము. ఆ తర్వాత, మేము ప్రతి అడ్డు వరుసలో ఉన్న నిలువు వరుసల కోసం మెమరీ స్థలాన్ని మరియు నిలువు వరుసల కోసం మెమరీ స్థలాన్ని కేటాయిస్తాము. మేము మాతృక డబుల్ పాయింటర్‌లో వరుసల విలువను పాయింటర్‌గా '** మ్యాట్రిక్స్'గా పాస్ చేస్తాము. ఈ డబుల్ పాయింటర్‌లో, అడ్డు వరుసల సంఖ్య యొక్క లూప్ అమలు చేయబడుతుంది లేదా నిజం. అప్పుడు, పరిస్థితి తప్పుగా మారే వరకు మరొక అంతర్గత లూప్ అమలు చేయబడుతుంది.
మెమరీ కేటాయింపు తర్వాత, మేము మళ్లీ శ్రేణిలో విలువను కేటాయిస్తాము: అడ్డు వరుసల కోసం ఒక బాహ్య లూప్ మరియు 2D శ్రేణి యొక్క నిలువు వరుసల కోసం ఒక అంతర్గత లూప్. లోపలి లూప్‌లో, అడ్డు వరుసలు మరియు నిలువు వరుసల విలువ డబుల్ పాయింటర్కు కేటాయించబడుతుంది మరియు అవసరమైన అంకగణిత ఆపరేషన్‌ను నిర్వహిస్తుంది. మేము మెమరీలో కేటాయించిన అడ్డు వరుసలు మరియు నిలువు వరుసల సంఖ్య వంటి 2D శ్రేణి యొక్క విలువలను ప్రదర్శిస్తాము. అడ్డు వరుసలు మరియు నిలువు వరుసల సంఖ్య ఎల్లప్పుడూ అడ్డు వరుసలు మరియు నిలువు వరుసల విలువలను నిల్వ చేసే డబుల్ పాయింటర్‌ను సూచిస్తుంది. చివరికి, మేము మెమరీని క్లియర్ చేస్తాము మరియు C++లోని మెమరీ నుండి ఈ శ్రేణిని డీలాకేట్ చేస్తాము.
డబుల్ పాయింటర్‌తో 2D శ్రేణి యొక్క అవుట్‌పుట్ కింది వాటిలో జోడించబడింది:
దృష్టాంతం 4: పాయింటర్ నుండి పాయింటర్‌ని ఉపయోగించి పాయింటర్‌లను మార్చుకోవడం
ఇక్కడ, డబుల్ పాయింటర్‌ను ప్రకటించడం ద్వారా C++లో పాయింటర్‌లను ఎలా మార్చుకోవాలో నేర్చుకుంటాము. ఈ దృశ్యం యొక్క కోడ్ స్నిప్పెట్ కింది వాటిలో జోడించబడింది:
#శూన్య మార్పిడి ( int ** ptrr_1, మీరు ** ptrr_2 ) {
int * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
పూర్ణాంక ప్రధాన ( ) {
int x = పదిహేను , y = 25 ;
int * ptrrA = & x, * ptrrB = & మరియు;
std::cout << 'స్వాప్ చేయడానికి ముందు: *ptrrA =' << * ptrrA << ', *ptrrB =' << * ptrrB << std::endl;
మార్పిడి ( & ptrrA, & ptrrB ) ;
std::cout << 'స్వాప్ తర్వాత: *ptrrA అంటే =' << * ptrrA << ', *ptrrB అంటే= ' << * ptrrB << std::endl;
తిరిగి 0 ;
}
మొదట, మేము స్వాప్ ఫంక్షన్‌ను నిర్మిస్తాము, రెండు పాయింటర్‌లను ఫంక్షన్ ఆర్గ్యుమెంట్‌గా పాస్ చేస్తాము. స్వాప్ ఫంక్షన్‌లో, మేము “టెంప్” పాయింటర్‌ని తీసుకుంటాము మరియు కొంత సమయం వరకు “టెంప్”లో “పాయింటర్1” విలువను పాస్ చేస్తాము. అప్పుడు, మేము 'పాయింటర్ 2' విలువను 'పాయింటర్ 1'కి పాస్ చేస్తాము. చివరికి, మేము 'టెంప్' పాయింటర్ యొక్క విలువను 'పాయింటర్ 2'కి పాస్ చేస్తాము.
ప్రధాన ఫంక్షన్‌లో, “స్వాప్” ఫంక్షన్‌లో మనం పాస్ చేసే లేదా ఓవర్‌రైడ్ చేసే రెండు పాయింటర్‌లు మనకు అవసరం. మేము ఇచ్చిన పాయింటర్‌లకు వేరియబుల్స్ చిరునామాలను పాస్ చేస్తాము. అప్పుడు, పాయింటర్ మార్పిడికి ముందు మరియు తర్వాత పాయింటర్ విలువ ప్రదర్శించబడుతుంది.
ఈ కోడ్ యొక్క అవుట్‌పుట్ కింది వాటిలో జోడించబడింది:
మనం చూడగలిగినట్లుగా, పాయింటర్ యొక్క విలువలు C++లో డబుల్ పాయింటర్‌ని ఉపయోగించి విజయవంతంగా మార్చబడతాయి.
ముగింపు
పాయింటర్ నుండి పాయింటర్ ఎల్లప్పుడూ C++లో ఏదైనా పాయింటర్ యొక్క మెమరీ చిరునామాను నిల్వ చేస్తుందని మేము నిర్ధారించాము. ఏ క్షణంలోనైనా ఏదైనా పాయింటర్ యొక్క మెమరీ స్థానాన్ని తాత్కాలికంగా ఉపయోగించడానికి మనం డబుల్ పాయింటర్‌ని ఉపయోగించవచ్చు. మెమరీ చిరునామాను పరోక్షంగా మార్చడానికి మరియు డేటాను చేరుకోవడానికి ఇది చాలా ప్రభావవంతమైన మార్గం.