C++లో నిర్మాణాలకు పరిచయం
స్ట్రక్చర్ అనేది వినియోగదారు సృష్టించిన డేటా రకం, ఇది వివిధ డేటా రకాల్లోని బహుళ వేరియబుల్స్‌ను ఒకే పేరుతో గుర్తించిన ఒకే ఎంటిటీగా మిళితం చేస్తుంది. నిర్మాణం అనేది పూర్ణాంకాలు, ఫ్లోట్‌లు మరియు అక్షరాలు వంటి వివిధ డేటా రకాలను ఒకే యూనిట్‌లో ఉంచే కంటైనర్ లాంటిది.
C++లో పాయింటర్‌లకు పరిచయం
C++లోని పాయింటర్ అనేది మరొక వేరియబుల్ యొక్క మెమరీ చిరునామాను నిల్వ చేసే వేరియబుల్. అవి మెమరీలో డేటాను మార్చడానికి మరియు యాక్సెస్ చేయడానికి ఉపయోగపడతాయి మరియు సాధారణంగా డైనమిక్ మెమరీ కేటాయింపు మరియు సూచన ద్వారా ఫంక్షన్‌లకు పారామితులను పంపడంలో ఉపయోగిస్తారు.
C++లో స్ట్రక్చర్‌కు పాయింటర్‌ని ప్రకటిస్తోంది
మనం స్ట్రక్చర్ మరియు పాయింటర్‌లను ఉపయోగించే ముందు, ముందుగా వాటిని డిక్లేర్ చేయాలి. ది 'నిర్మాణం' C++లో నిర్మాణం యొక్క ప్రకటన కోసం కీవర్డ్ ఉపయోగించబడుతుంది మరియు దాని తర్వాత నిర్మాణాన్ని గుర్తించే పేరు ఉంటుంది.
C++లో పాయింటర్ టు స్ట్రక్చర్ యొక్క సింటాక్స్ క్రింది విధంగా ఉంది.
నిర్మాణం పేరు_నిర్మాణం * ptr ;
ptr = & నిర్మాణం_వేరియబుల్ ;
సింటాక్స్ పాయింటర్ వేరియబుల్‌ని ప్రకటించింది ptr రకం నిర్మాణం పేరు_నిర్మాణం . ది (*) అని సూచిస్తుంది ptr అనేది ఒక పాయింటర్.
రెండవ పంక్తి రకం యొక్క స్ట్రక్చర్ వేరియబుల్ యొక్క మెమరీ చిరునామాను కేటాయిస్తుంది పేరు_నిర్మాణం పాయింటర్‌కి ptr ఉపయోగించి & (చిరునామా) ఆపరేటర్.
C++లో స్ట్రక్చర్ చేయడానికి పాయింటర్‌ను ఎలా సృష్టించాలి
C++లో స్ట్రక్చర్‌కు పాయింటర్‌ని సృష్టించడానికి క్రింది దశలు ఉన్నాయి:
దశ 1: ముందుగా కావలసిన సభ్యులతో నిర్మాణాన్ని ప్రకటించండి.
నిర్మాణం ఉద్యోగి {స్ట్రింగ్ పేరు ;
int వయస్సు ;
తేలుతుంది జీతం ;
} ;
దశ 2: ఇప్పుడు మనం స్ట్రక్చర్‌తో సమానమైన పాయింటర్ వేరియబుల్‌ని ప్రకటిస్తాము. ఉపయోగించడానికి (*) ఇది పాయింటర్ వేరియబుల్ అని సూచించడానికి ఆపరేటర్.
ఉద్యోగి * ఉద్యోగిPtr ;దశ 3: తదుపరి ఉపయోగించండి చిరునామా-యొక్క ఆపరేటర్ (&) స్ట్రక్చర్ వేరియబుల్ యొక్క మెమరీ చిరునామాకు పాయింటర్‌ను కేటాయించడానికి.
ఉద్యోగి పి = { 'ఉద్యోగి' , 24 , 10000 } ;ఉద్యోగిPtr = & p ;
నిర్మాణం యొక్క సభ్యుడిని యాక్సెస్ చేయడానికి మేము ఉపయోగిస్తాము బాణం ఆపరేటర్ (->) పాయింటర్ వేరియబుల్‌తో.
కోట్ << 'పేరు:' << ఉద్యోగిPtr -> పేరు << endl ;కోట్ << 'వయస్సు:' << ఉద్యోగిPtr -> వయస్సు << endl ;
కోట్ << 'జీతం:' << ఉద్యోగిPtr -> జీతం << endl ;
C++లో స్ట్రక్చర్‌కు పాయింటర్‌ను ఎలా సృష్టించాలో వివరించే పూర్తి ప్రోగ్రామ్ క్రింద ఉంది:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
నిర్మాణం ఉద్యోగి {
స్ట్రింగ్ పేరు ;
int వయస్సు ;
తేలుతుంది జీతం ;
} ;
int ప్రధాన ( ) {
ఉద్యోగి పి = { 'ఉద్యోగి' , 24 , 10000 } ;
ఉద్యోగి * ఉద్యోగిPtr = & p ;
కోట్ << 'పేరు:' << ఉద్యోగిPtr -> పేరు << endl ;
కోట్ << 'వయస్సు:' << ఉద్యోగిPtr -> వయస్సు << endl ;
కోట్ << 'జీతం:' << ఉద్యోగిPtr -> జీతం << endl ;
తిరిగి 0 ;
}
పై ప్రోగ్రామ్ నిర్మాణాత్మకతను సృష్టిస్తుంది ఉద్యోగి ముగ్గురు సభ్యులతో; పేరు , వయస్సు , మరియు జీతం . అది ఒక వేరియబుల్ సృష్టిస్తుంది p ఉద్యోగి రకం మరియు దాని సభ్యులను ప్రారంభిస్తుంది.
తరువాత, ఇది పాయింటర్ వేరియబుల్‌ను సృష్టిస్తుంది ఉద్యోగిPtr ఉద్యోగి రకం మరియు దానికి మెమరీ చిరునామాను కేటాయిస్తుంది p . తర్వాత ఇది ఉద్యోగి సభ్యులను యాక్సెస్ చేయడానికి పాయింటర్‌ని ఉపయోగిస్తుంది నిర్మాణం మరియు వాటిని కన్సోల్‌కు ప్రింట్ చేస్తుంది.
ముగింపు
C++లోని నిర్మాణాలకు పాయింటర్లు సంక్లిష్ట డేటా రకాలను సులభంగా మార్చడానికి అనుమతిస్తాయి. స్ట్రక్చర్‌లకు పాయింటర్‌లను ఉపయోగించడం ద్వారా, మీరు స్ట్రక్చర్‌లో ఉన్న డేటాను యాక్సెస్ చేయవచ్చు మరియు సవరించవచ్చు మరియు ఫంక్షన్‌లకు ఆర్గ్యుమెంట్‌గా పాస్ చేయవచ్చు. నిర్మాణం కోసం C++ పాయింటర్‌ల వివరాల కోసం, డాక్యుమెంటేషన్‌ని చూడండి.