శూన్య పాయింటర్ అంటే ఏమిటి (శూన్యత*)?
శూన్య పాయింటర్, జెనరిక్ పాయింటర్ అని కూడా పిలుస్తారు, ఇది ఏదైనా నిర్దిష్ట డేటా రకంతో అనుబంధించబడని పాయింటర్, ఇది ఏ రకమైన డేటాను సూచించడానికి అనుకూలంగా ఉంటుంది. మరో మాటలో చెప్పాలంటే, ఎ శూన్యమైన పాయింటర్ పూర్ణాంకం, అక్షరం, స్ట్రింగ్ లేదా ఏదైనా ఇతర డేటా రకాన్ని సూచించవచ్చు. ఈ వశ్యత C మరియు C++ ప్రోగ్రామింగ్‌లో శూన్యమైన పాయింటర్‌లను శక్తివంతమైన సాధనంగా చేస్తుంది.
C మరియు C++లో శూన్య పాయింటర్ యొక్క ప్రకటన
C మరియు C++లో, ది శూన్యమైన పాయింటర్ కింది వాక్యనిర్మాణం ద్వారా ప్రకటించబడింది:
శూన్యం * ptr ;
C మరియు C++లో శూన్య పాయింటర్‌ల వినియోగం
శూన్యమైన పాయింటర్లు వేరియబుల్ యొక్క డేటా రకం తెలియనప్పుడు లేదా రన్‌టైమ్‌లో మారుతున్నప్పుడు C లో ఎక్కువగా ఉపయోగించబడుతుంది. నిర్దిష్ట డేటా రకాన్ని తెలుసుకోవాల్సిన అవసరం లేకుండా డేటాను నిల్వ చేయడానికి మరియు మార్చడానికి సాధారణ మార్గాన్ని అవి అనుమతిస్తాయి. వివిధ రకాల డేటాను నిర్వహించగల ఫంక్షన్‌లు లేదా డేటా స్ట్రక్చర్‌లతో వ్యవహరించేటప్పుడు ఇది ప్రత్యేకంగా సహాయపడుతుంది.
ఒక సాధారణ ఉపయోగం శూన్యమైన పాయింటర్లు వంటి మెమరీ కేటాయింపు ఫంక్షన్లలో ఉంది malloc() ఇది ఏదైనా డేటా రకాన్ని నిల్వ చేయడానికి ఉపయోగించే మెమరీ బ్లాక్‌కి శూన్యమైన పాయింటర్ పాయింట్‌ను అందిస్తుంది. ప్రోగ్రామర్ అప్పుడు కేటాయించిన మెమరీ బ్లాక్‌లో నిల్వ చేయబడిన డేటాను యాక్సెస్ చేయడానికి మరియు మార్చడానికి తగిన డేటా రకానికి శూన్యమైన పాయింటర్‌ను ప్రసారం చేయవచ్చు.
C లో శూన్య పాయింటర్‌ల మరొక ఉపయోగం ఉంది ఫంక్షన్ పాయింటర్లు , ఇవి ఫంక్షన్ యొక్క మెమరీ చిరునామాను నిల్వ చేసే వేరియబుల్స్. ఫంక్షన్ పాయింటర్ వినియోగంలో మరింత సౌలభ్యాన్ని అనుమతించడం ద్వారా, దాని రిటర్న్ రకం లేదా పరామితి జాబితాతో సంబంధం లేకుండా, ఏదైనా ఫంక్షన్ యొక్క మెమరీ చిరునామాను నిల్వ చేయడానికి శూన్య పాయింటర్‌లను ఉపయోగించవచ్చు.
దాని యొక్క ఉపయోగం శూన్యమైన పాయింటర్లు C++లో దాదాపు సారూప్యంగా ఉంటుంది, అయినప్పటికీ, వివిధ తరగతుల వస్తువుల కోసం సాధారణ ఇంటర్‌ఫేస్‌ను రూపొందించడానికి కూడా వాటిని ఉపయోగించవచ్చు. వర్చువల్ ఫంక్షన్ల వాడకం ద్వారా ఇది తరచుగా సాధించబడుతుంది, ఇది వివిధ తరగతుల వస్తువులను ఏకరీతిగా పరిగణించడానికి అనుమతిస్తుంది. ఇంకా, C++ C కంటే మరింత కఠినమైన రకం తనిఖీని అందిస్తుంది, అంటే ఉపయోగించడం శూన్యమైన పాయింటర్లు తప్పుగా ఉంటే మరిన్ని లోపాలు మరియు బగ్‌లు ఏర్పడవచ్చు.
C మరియు C++లో శూన్య పాయింటర్‌లను ఉపయోగిస్తున్నప్పుడు పరిగణించవలసిన అంశాలు
ఉపయోగిస్తున్నప్పుడు మీరు పరిగణించవలసిన కొన్ని పాయింట్లు ఇక్కడ ఉన్నాయి శూన్యమైన పాయింటర్లు C మరియు C++లో.
1: సి లో, శూన్యం* రిటర్న్ విలువ మరియు ఫంక్షన్ పారామీటర్‌గా ఉపయోగించవచ్చు కానీ C++లో మీరు తప్పనిసరిగా నిర్దిష్ట డేటా రకం పాయింటర్‌ని కలిగి ఉండాలి.
ఉదాహరణకి:
C లో, కోడ్ క్రింద ఇవ్వబడింది:
##
శూన్యం * యాడ్_సంఖ్యలు ( int a , int బి ) {
int * ఫలితం = malloc ( పరిమాణం ( int ) ) ;
* ఫలితం = a + బి ;
తిరిగి ( శూన్యం * ) ఫలితం ;
}
శూన్యం ప్రింట్_ఫలితం ( శూన్యం * ఫలితం ) {
int * ptr = ( int * ) ఫలితం ;
printf ( 'ఫలితం: %d \n ' , * ptr ) ;
ఉచిత ( ptr ) ;
}
int ప్రధాన ( ) {
int సంఖ్య1 = 5 , సంఖ్య2 = 7 ;
శూన్యం * ఫలితం = యాడ్_సంఖ్యలు ( సంఖ్య1 , సంఖ్య2 ) ;
ప్రింట్_ఫలితం ( ఫలితం ) ;
తిరిగి 0 ;
}
పై కోడ్ ఫంక్షన్‌ను నిర్వచిస్తుంది add_numbers() అది తిరిగి ఇస్తుంది a శూన్యం* ఆర్గ్యుమెంట్‌లుగా ఆమోదించబడిన రెండు పూర్ణాంకాలను జోడించడం ద్వారా ఫలితానికి పాయింటర్. ఫంక్షన్ ప్రింట్_ఫలితం() a పడుతుంది void * పాయింటర్ మరియు ఫలితాన్ని ముద్రిస్తుంది. ప్రధాన() ఫంక్షన్‌లో, మేము కాల్ చేస్తాము add_numbers() మరియు ఫలితంగా పాస్ void * పాయింటర్ కు ప్రింట్_ఫలితం() ప్రింటింగ్ కోసం.
C++లో, నిర్దిష్ట డేటా రకం అవసరం.
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
శూన్యం printInt ( int * ఒకదానిపై ) {
కోట్ << 'పూర్ణాంకం:' << * ఒకదానిపై << endl ;
}
int ప్రధాన ( ) {
int x = 10 ;
int * ptr = & x ;
printInt ( ptr ) ;
తిరిగి 0 ;
}
2: C లో, మీరు శూన్యమైన పాయింటర్‌ను మరొక పాయింటర్ రకానికి మార్చవచ్చు అవ్యక్త మార్పిడి. కానీ C++ లో మీరు ఉపయోగించాలి స్పష్టమైన మార్పిడి మార్చడానికి శూన్యమైన పాయింటర్ ఏదైనా ఇతర పాయింటర్ రకానికి.
C మరియు C++ రెండింటి మధ్య వ్యత్యాసాన్ని వివరించడానికి ఇక్కడ ఒక సాధారణ కోడ్ ఉదాహరణ ఉంది అవ్యక్తమైన మరియు స్పష్టమైన మార్పిడి యొక్క శూన్యమైన పాయింటర్లు ఇతర పాయింటర్ రకాలకు:
C లో, కింది కోడ్ ఉపయోగించబడుతుంది:
#శూన్యం ప్రింట్‌చార్ ( శూన్యం * చ ) {
చార్ సి = * ( చార్ * ) చ ;
printf ( '%c \n ' , సి ) ;
}
int ప్రధాన ( ) {
చార్ సి = 'a' ;
శూన్యం * ptr = & సి ;
ప్రింట్‌చార్ ( ptr ) ;
తిరిగి 0 ;
}
పై కోడ్ ఫంక్షన్‌ను నిర్వచిస్తుంది ప్రింట్‌చార్ అది శూన్యమైన పాయింటర్‌ను పారామీటర్‌గా తీసుకుంటుంది మరియు ఆ మెమరీ స్థానంలో నిల్వ చేయబడిన అక్షరాన్ని ప్రింట్ చేస్తుంది. ప్రధాన ఫంక్షన్‌లో, చార్ వేరియబుల్ సి నిర్వచించబడింది మరియు దాని చిరునామా శూన్యమైన పాయింటర్‌లో నిల్వ చేయబడుతుంది ptr ది ప్రింట్‌చార్ ఫంక్షన్ అప్పుడు తో అంటారు శూన్యమైన పాయింటర్ 'ptr' వాదనగా. శూన్యమైన పాయింటర్ స్పష్టంగా చార్ పాయింటర్‌గా మార్చబడుతుంది 'ప్రింట్‌చార్' నిల్వ చేయబడిన విలువను యాక్సెస్ చేయడానికి మరియు ప్రింట్ చేయడానికి ఫంక్షన్ 'సి' .
C++లో, కోడ్ క్రింద ఇవ్వబడింది:
#శూన్యం printInt ( శూన్యం * ఒకదానిపై ) {
int * ptr = స్టాటిక్_కాస్ట్ < int *> ( ఒకదానిపై ) ;
std :: కోట్ << * ptr << std :: endl ;
}
int ప్రధాన ( ) {
int x = 10 ;
శూన్యం * ptr = & x ;
printInt ( ptr ) ;
తిరిగి 0 ;
}
పై కోడ్ ఫంక్షన్‌ను నిర్వచిస్తుంది printInt అది శూన్యమైన పాయింటర్ సంఖ్యను పారామీటర్‌గా తీసుకుంటుంది మరియు దానిని ఉపయోగించి పూర్ణాంక పాయింటర్‌కి ప్రసారం చేస్తుంది స్టాటిక్_కాస్ట్ ఆపరేటర్ . అప్పుడు ఫంక్షన్ క్యాస్ట్ చేసిన పాయింటర్ ద్వారా సూచించబడిన పూర్ణాంకం యొక్క విలువను ముద్రిస్తుంది. ప్రధాన విధిలో, పూర్ణాంకం వేరియబుల్ x నిర్వచించబడింది మరియు దాని చిరునామా aలో నిల్వ చేయబడుతుంది శూన్యమైన పాయింటర్ ptr, ఇది తరువాత పంపబడుతుంది printInt ఫంక్షన్. ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ x విలువ, ఇది 10.
తుది ఆలోచనలు
ది శూన్యం C మరియు C++లోని పాయింటర్లు దాని నిర్దిష్ట డేటా రకాన్ని తెలుసుకోవాల్సిన అవసరం లేకుండా డేటాను మార్చటానికి శక్తివంతమైన మార్గాన్ని అందిస్తాయి. అవి మెమరీ కేటాయింపు మరియు ఫంక్షన్ పాయింటర్‌లకు, అలాగే C++లోని వివిధ తరగతుల వస్తువుల కోసం సాధారణ ఇంటర్‌ఫేస్‌ను రూపొందించడానికి ఉపయోగపడతాయి. అయినప్పటికీ, వాటి వినియోగంలో C మరియు C++ మధ్య తేడాలను పరిగణనలోకి తీసుకోవడం చాలా ముఖ్యం శూన్యమైన పాయింటర్లు , C++లో నిర్దిష్ట డేటా రకాల అవసరం మరియు ఇతర పాయింటర్ రకాలకు శూన్యమైన పాయింటర్‌లను ప్రసారం చేసేటప్పుడు స్పష్టమైన మార్పిడి అవసరం వంటివి. ఈ పాయింట్లను జాగ్రత్తగా పరిశీలించడం వలన మరింత సమర్థవంతమైన మరియు ప్రభావవంతమైన ఉపయోగం పొందవచ్చు శూన్యమైన పాయింటర్లు ప్రోగ్రామింగ్ లో.