ప్రధాన భాగాలు:
ఏకైక_పిటిఆర్ ఆబ్జెక్ట్ యొక్క రెండు ప్రధాన భాగాలు క్రింద ఇవ్వబడ్డాయి:
A. నిల్వ చేసిన పాయింటర్:
ప్రత్యేకమైన పాయింటర్ ద్వారా సృష్టించబడిన వస్తువులను నిర్వహించడానికి ఇది ఉపయోగించబడుతుంది. ఇది పాయింటర్ సృష్టి సమయంలో సృష్టించబడింది మరియు దీనిని వివిధ మార్గాల్లో మార్చవచ్చు.
B. నిల్వ చేసిన డిలీటర్:
ఇది నిర్వహించే వస్తువును తొలగించడానికి ఉపయోగించే నిల్వ చేసిన పాయింటర్ రకం వాదనను తీసుకుంటుంది. ఇది పాయింటర్ సృష్టి సమయంలో కూడా సృష్టించబడింది మరియు దీనిని వివిధ మార్గాల్లో మార్చవచ్చు.
ఉదాహరణ 1: కన్స్ట్రక్టర్‌తో క్లాస్ యొక్క పాయింటర్ ఆబ్జెక్ట్‌ను సృష్టించండి
కింది ఉదాహరణలో చూపిన విధంగా వస్తువులను ఉపయోగించడం ద్వారా క్లాస్ యొక్క ప్రత్యేకమైన పాయింటర్ ఆబ్జెక్ట్‌లను ప్రకటించడం మరియు క్లాస్ పద్ధతిని యాక్సెస్ చేయడం. కన్స్ట్రక్టర్ మరియు పబ్లిక్ మెథడ్ ఉన్న క్లాస్ కోడ్‌లో ప్రకటించబడింది. నిర్మాతకు మూడు వాదనలు ఉన్నాయి. మూడు ఆర్గ్యుమెంట్ విలువలతో కన్స్ట్రక్టర్‌కు కాల్ చేయడం ద్వారా మొదటి ప్రత్యేకమైన పాయింటర్ సృష్టించబడింది. ది ఫలితం () పద్దతిని పాయింటర్ ఆబ్జెక్ట్ అంటారు, ఇది కన్స్ట్రక్టర్ యొక్క మూడు ఆర్గ్యుమెంట్ విలువల మొత్తాన్ని లెక్కిస్తుంది. తరువాత, కన్స్ట్రక్టర్‌కు కాల్ చేయకుండానే రెండవ ప్రత్యేకమైన పాయింటర్ ఆబ్జెక్ట్ సృష్టించబడుతుంది మరియు మొదటి పాయింటర్ రెండవ పాయింటర్‌కు తరలించబడుతుంది. ది ఫలితం () పద్ధతి రెండవ పాయింటర్ ఆబ్జెక్ట్ ద్వారా పిలువబడుతుంది.
//అవసరమైన లైబ్రరీలను చేర్చండి#చేర్చండి
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
//తరగతిని నిర్వచించండి
తరగతి అదనంగా{
int సంఖ్య 1, సంఖ్య 2, సంఖ్య 3;
ప్రజా:
//నిర్మాతను ప్రకటించండి
అదనంగా(int a, int b, int c)
{
సంఖ్య 1 = a;
సంఖ్య 2 = బి;
సంఖ్య 3 = సి;
}
//లెక్కించడానికి పద్ధతిని ప్రకటించండిమొత్తం
int ఫలితం()
{
తిరిగిసంఖ్య 1 + సంఖ్య 2 + సంఖ్య 3;
}
};
int ప్రధాన()
{
//మొదటి పాయింటర్‌ని ప్రకటించండి
ఏకైక_పిటిఆర్ పాయింటర్ 1(కొత్త చేరిక(నాలుగు ఐదు,55,30));
ఖరీదు<<'మొదటి పాయింటర్‌ని ఉపయోగించి మొత్తం ఫలితం:'<ఫలితం() <<' n';
//రెండవ పాయింటర్‌ని ప్రకటించండి
ఏకైక_పిటిఆర్ పాయింటర్ 2;
//మొదటి పాయింటర్‌ను రెండవ పాయింటర్‌కు తరలించండి
పాయింటర్ 2 = తరలించు(పాయింటర్ 1);
ఖరీదు<<'రెండవ పాయింటర్‌ని ఉపయోగించి మొత్తం ఫలితం:'<ఫలితం() <<' n';
రిటర్న్ 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. 45, 55, మరియు 30 మొత్తాలు రెండు పాయింటర్ల కోసం ముద్రించబడ్డాయి.
ఉదాహరణ 2: కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్‌తో క్లాస్ యొక్క పాయింటర్ ఆబ్జెక్ట్‌ను సృష్టించండి
కన్స్ట్రక్టర్ మరియు డిస్ట్రక్టర్‌తో క్లాస్ యొక్క ప్రత్యేకమైన పాయింటర్ ఆబ్జెక్ట్‌ను ప్రకటించే మార్గం క్రింది ఉదాహరణలో చూపబడింది. క్లాస్‌లో ఒక ఆర్గ్యుమెంట్‌తో కన్స్ట్రక్టర్, క్లాస్ వేరియబుల్ విలువకు డిస్‌ప్లే () అనే పబ్లిక్ మెథడ్ మరియు క్లాస్ వస్తువును నాశనం చేసే ముందు డిస్ట్రక్షన్ మెసేజ్‌ను ప్రింట్ చేసే డిస్ట్రక్టర్ ఉన్నాయి. కోడ్‌లో ప్రత్యేకమైన పాయింటర్ ఆబ్జెక్ట్‌ను సృష్టించిన తర్వాత డిస్‌ప్లే () పద్ధతిని పిలుస్తారు.
//అవసరమైన లైబ్రరీలను చేర్చండి#చేర్చండి
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
//తరగతిని నిర్వచించండి
తరగతి కస్టమర్
{
స్ట్రింగ్ పేరు;
ప్రజా:
//నిర్మాతను ప్రకటించండి
కస్టమర్(స్ట్రింగ్ n)
{
పేరు = n;
ఖరీదు<<'వనరు కేటాయించబడింది. n';
}
//కస్టమర్ పేరును ముద్రించడానికి పద్ధతిని ప్రకటించండి
శూన్యమైన ప్రదర్శన()
{
ఖరీదు<<'కస్టమర్ పేరు:'<<పేరు<<' n';
}
//విధ్వంసకుడిని ప్రకటించండి
కస్టమర్()
{
ఖరీదు<<'వనరు ధ్వంసం చేయబడింది. n';
}
};
int ప్రధాన()
{
//ఏకైక_పిటిఆర్ యాజమాన్యంలోని వనరుల వస్తువును కేటాయించండి
unique_ptruPointer{కొత్త కస్టమర్('మీర్ అబ్బాస్') };
uPointer->ప్రదర్శన();
రిటర్న్ 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది:
ఉదాహరణ 3: యాజమాన్యాన్ని బదిలీ చేసిన తర్వాత పాయింటర్‌ని తనిఖీ చేయండి
ప్రత్యేకమైన పాయింటర్ యొక్క యాజమాన్యాన్ని తనిఖీ చేసే మార్గం ఒక క్లాస్ యొక్క రెండు ప్రత్యేకమైన పాయింటర్లను సృష్టించడం ద్వారా కింది ఉదాహరణలో చూపబడింది. కోడ్‌లో రెండు స్ట్రింగ్ వేరియబుల్స్ మరియు పబ్లిక్ మెథడ్ ఉన్న క్లాస్ ప్రకటించబడింది. తరగతి యొక్క మొదటి ప్రత్యేకమైన పాయింటర్ వస్తువును సృష్టించిన తర్వాత తరగతి యొక్క Book_details () పద్ధతిని పిలుస్తారు. తరువాత, రెండవ ప్రత్యేకమైన పాయింటర్ ఆబ్జెక్ట్ సృష్టించబడింది మరియు మొదటి పాయింటర్‌ను మొదటి పాయింటర్‌ను నాశనం చేసే రెండవ పాయింటర్‌కు తరలించబడింది. రెండు పాయింటర్ల యాజమాన్యం తర్వాత తనిఖీ చేయాలి.
//అవసరమైన లైబ్రరీలను చేర్చండి#చేర్చండి
#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
//తరగతిని నిర్వచించండి
తరగతి పుస్తకం{
స్ట్రింగ్ శీర్షిక ='ది సి ++ ప్రోగ్రామింగ్ లాంగ్వేజ్';
స్ట్రింగ్ రచయిత ='జార్నే స్ట్రోస్ట్రప్';
ప్రజా:
//పుస్తక వివరాలను ముద్రించడానికి పద్ధతిని ప్రకటించండి
voidBook_details()
{
ఖరీదు<<'పుస్తకం పేరు:'<<శీర్షిక<<' n';
ఖరీదు<<'రచయిత పేరు:'<<రచయిత<<' n';
}
};
int ప్రధాన()
{
//మొదటి పాయింటర్‌ని ప్రకటించండి
ఏకైక_పిటిఆర్ పాయింటర్ 1(కొత్త పుస్తకం());
పాయింటర్ 1->పుస్తకం_వివరాలు();
//రెండవ పాయింటర్‌ని ప్రకటించండి
ఏకైక_పిటిఆర్ పాయింటర్ 2;
//మొదటి పాయింటర్‌ను రెండవ పాయింటర్‌కు తరలించండి
పాయింటర్ 2 = తరలించు(పాయింటర్ 1);
//మొదటి పాయింటర్‌ని తనిఖీ చేయండి
ఉంటే (స్టాటిక్_కాస్ట్(పాయింటర్ 1))ఖరీదు<<'మొదటి పాయినర్ శూన్యమైనది కాదు n';
elsecout<<'మొదటి పాయినర్ శూన్యమైనది n';
//రెండవ పాయింటర్‌ని తనిఖీ చేయండి
ఉంటే (స్టాటిక్_కాస్ట్(పాయింటర్ 2))ఖరీదు<<'రెండవ పాయినర్ శూన్యమైనది కాదు n';
elsecout<<'రెండవ పాయినర్ శూన్యమైనది n';
రిటర్న్ 0;
}
అవుట్‌పుట్:
పై కోడ్‌ను అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. అవుట్‌పుట్ ప్రకారం, మొదటి పాయింటర్ యాజమాన్యం తీసివేయబడింది మరియు సందేశం, మొదటి పాయింటర్ శూన్యమైనది మొదటి పాయింటర్ కోసం ముద్రించబడింది. రెండవ పాయింటర్ యాజమాన్యం ఉంది, మరియు సందేశం, మొదటి పాయింటర్ శూన్యమైనది కాదు రెండవ పాయింటర్ కోసం ముద్రించబడింది:
ముగింపు:
C ++ ప్రోగ్రామింగ్‌లో ప్రత్యేకమైన పాయింటర్‌ను ఉపయోగించే ప్రయోజనాలు ఈ ట్యుటోరియల్‌లో బహుళ ఉదాహరణలను ఉపయోగించి వివరించబడ్డాయి. విశిష్ట పాయింటర్‌ని సరిగ్గా ఉపయోగించడాన్ని పాఠకులు తెలుసుకోవడంలో సహాయపడటానికి ప్రత్యేకమైన పాయింటర్‌ను సృష్టించడం, పాయింటర్ యాజమాన్యాన్ని బదిలీ చేయడం మరియు పాయింటర్ యొక్క ప్రస్తుత యాజమాన్యాన్ని తనిఖీ చేసే మార్గాలు ఇక్కడ వివరించబడ్డాయి.