సి ++ లో పాయింటర్లను ఎలా అమలు చేయాలి?

పాయింటర్లు C ++ లో c ++ లో మరొక వేరియబుల్ యొక్క చిరునామాను కలిగి ఉన్న వేరియబుల్. చిరునామా పాయింటర్ వేరియబుల్‌లో నిల్వ చేయబడుతుంది మరియు కాల్-బై-రిఫరెన్స్ అమలులో సహాయపడుతుంది.

ఈ వ్యాసంలో క్రింది గమనికలు కవర్ చేయబడతాయి,

• పాయింటర్లు
• పాయింటర్లు మరియు శ్రేణులు
• శూన్య పాయింటర్లు
• శూన్య పాయింటర్లు
• పాయింటర్ అంకగణిత ఆపరేషన్
• పాయింటర్ టు పాయింటర్
• ఫంక్షన్లకు పాయింటర్

C ++ లోని పాయింటర్లలో ఈ కథనంతో ప్రారంభమవుతుంది

సింటాక్స్:

జావాలో ఒక ప్రోగ్రామ్‌ను ముగించండి

డేటాటైప్ * పాయింటర్‌నేమ్ ఉదాహరణ: int * ptr

• పాయింటర్ వేరియబుల్ దాని పేరుకు ముందు * గుర్తును కలిగి ఉంటుంది.
• పాయింటర్‌ను లొకేటర్ లేదా ఇండికేటర్ అని కూడా అంటారు.

పాయింటర్ యొక్క ఉపయోగాలు:

• డైనమిక్ మెమరీ కేటాయింపు
• శ్రేణులు, నిర్మాణం మరియు విధుల యొక్క వివిధ కార్యక్రమాలలో

ఇక్కడ ఒక ఉదాహరణ కోడ్:

# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std int main () {int num = 17 int * ptr ptr = & num cout<< 'Value at ptr = ' << ptr << 'n' cout << 'Value at var = ' << num << 'n' cout << 'Value at *ptr = ' << *ptr << 'n' } 

అవుట్పుట్:

వివరణ:

పై ప్రోగ్రామ్‌లో, మేము పాయింటర్ యొక్క ప్రాథమిక పనిని చూపుతాము. మనకు విలువ 17 తో పూర్ణాంక వేరియబుల్ సంఖ్య ఉంది. మనకు పూర్ణాంక రకం యొక్క పాయింటర్ వేరియబుల్ ptr ఉంది. మేము పాయింటర్ ptr కు సంఖ్య యొక్క చిరునామాను కేటాయిస్తాము.

మేము మొదట ptr విలువను ప్రింట్ చేస్తాము, అది చిరునామా. తరువాత, మేము సంఖ్యా విలువను ప్రింట్ చేస్తాము మరియు చివరికి, పాయింటర్ ptr చేత ఉంచబడిన ప్రదేశంలో విలువను ప్రింట్ చేస్తాము.

C ++ పై పాయింటర్లపై ఈ కథనంతో కదులుతోంది

పాయింటర్లు మరియు శ్రేణులు:

శ్రేణి పేరు మొదటి మూలకం యొక్క చిరునామాను కలిగి ఉన్నందున, మేము శ్రేణి యొక్క మొదటి మూలకాన్ని పాయింటర్‌గా పరిగణించవచ్చు. మేము ఈ క్రింది పద్ధతిలో పాయింటర్‌ను ఉపయోగించవచ్చు.

ఉదాహరణ కోడ్ ఇక్కడ ఉంది:

# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std int main () {int arr [3] = {5, 10, 20} int * ptr ptr = arr cout<< 'Elements of the array are: ' cout << ptr[0] << ' ' << ptr[1] << ' ' << ptr[2] } 

 అవుట్పుట్: 

వివరణ:

పై ప్రోగ్రామ్‌లో, శ్రేణితో పాయింటర్ యొక్క ప్రాథమిక పనిని మేము చూపిస్తాము. మాకు 5,10,20 విలువలతో శ్రేణి అర్రే ఉంది. మనకు టైప్ Int యొక్క పాయింటర్ వేరియబుల్ ptr ఉంది. మేము అర్ర్ యొక్క చిరునామాను పాయింటర్ ptr కు కేటాయిస్తాము.

మేము మొదట ptr [0] యొక్క విలువను ప్రింట్ చేస్తాము, అది శ్రేణి యొక్క మొదటి మూలకం. తరువాత, మేము వరుసగా రెండవ మరియు మూడవ అంశాలను ప్రింట్ చేస్తాము. శ్రేణి మూలకాలు వరుసగా నిల్వ చేయబడినందున, పాయింటర్ పెరుగుదల ద్వారా శ్రేణి యొక్క ఇతర స్థానాన్ని యాక్సెస్ చేయవచ్చు.

C ++ పై పాయింటర్లపై ఈ కథనంతో కదులుతోంది

శూన్య గమనికలు:

విలువలు లేని మరియు శూన్య విలువను కలిగి ఉన్న పాయింటర్ల రకం ఉన్నాయి

ఉదాహరణ :

int * ptr = NULL

లింక్డ్ లిస్ట్ వంటి డేటా స్ట్రక్చర్లలో ఇవి చాలా ఉపయోగపడతాయి.

C ++ పై పాయింటర్లపై ఈ కథనంతో కదులుతోంది

శూన్య గమనికలు:

రిటర్న్ రకం లేని పాయింటర్ల రకం ఇవి.

C ++ పై పాయింటర్లపై ఈ కథనంతో కదులుతోంది

పాయింటర్ అంకగణిత ఆపరేషన్:

పాయింటర్లలో వేర్వేరు ఆపరేషన్లు చేయవచ్చు. ఇక్కడ కొన్ని ముఖ్యమైన రకాలు ఉన్నాయి.

• పెంచిన (++)
• తగ్గింది (-)
• రెండు పాయింటర్ల మధ్య వ్యత్యాసం (p1-p2)
• పాయింటర్‌కు పూర్ణాంకం అదనంగా (+ లేదా + =)
• పాయింటర్ నుండి పూర్ణాంకం యొక్క వ్యవకలనం (- లేదా - =)

ఈ ఆపరేషన్లలో కొన్నింటిని డెమో చేయడానికి ఇక్కడ కోడ్ ఉంది:

# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std int main () {int arr [3] = {10, 100, 200} int * ptr ptr = arr (int i = 0 i<3 i++) { cout << 'Value at different locations of array using *ptr = ' << *ptr << 'n' ptr++ } } 

అవుట్పుట్:

వివరణ:

పై ప్రోగ్రామ్‌లో పాయింటర్ వేరియబుల్ యొక్క పెరుగుదల యొక్క సాధారణ అంకగణిత ఆపరేషన్ చూపబడింది.

C ++ పై పాయింటర్లపై ఈ కథనంతో కదులుతోంది

పాయింటర్ టు పాయింటర్:

ఈ రకమైన వ్యవస్థలో, రెండు పాయింటర్లు ఉన్నాయి. మొదటి పాయింటర్ రెండవ పాయింటర్‌కు మరియు రెండవ పాయింటర్ విలువను కలిగి ఉన్న వేరియబుల్‌కు సూచిస్తుంది.

print_r నుండి స్ట్రింగ్

ఉదాహరణ కోడ్ ఇక్కడ ఉంది:

అవుట్పుట్:

C ++ పై పాయింటర్లపై ఈ కథనంతో కదులుతోంది

విధులకు పాయింటర్:

ఇది ఫంక్షన్లకు పాయింటర్లను పంపే మార్గం. ఫంక్షన్ పరామితిని పాయింటర్ రకంగా ప్రకటించాలి. ఇది క్రింది కోడ్‌లో చూపబడింది,

# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std float getAverage (int * arr, int size) int main () {int balance [5] = {1432, 232, 3232, 17, 502} float avg avg = getAverage (balance, 5) cout<< 'Average value is: ' << avg << endl return 0 } float getAverage(int *arr, int size) { int i, sum = 0 double avg for (i = 0 i < size ++i) { sum += arr[i] } avg = double(sum) / size return avg } 

అవుట్పుట్

ఈ విధంగా మనం ఒక ఫంక్షన్‌కు పాయింటర్‌ను పాస్ చేస్తాము.

ఈ విధంగా ‘సి ++ లోని పాయింటర్స్’ పై ఈ వ్యాసం ముగిసింది. మీరు మరింత తెలుసుకోవాలనుకుంటే, చూడండి విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.