ఈ గైడ్‌లో, మేము పరిశీలిస్తాము డబుల్ కోలన్ (::) ఆపరేటర్ C++లో మరియు విభిన్న దృశ్యాలలో ఇది ఎలా పని చేస్తుంది.
:: C++లో ఏమి చేస్తుంది?
C++లో, ది పరిధి స్పష్టత ఆపరేటర్ (::) వివిధ స్కోప్ స్థాయిలలో ఉన్న వేరియబుల్ పేర్లను తిరిగి పొందడానికి ఉపయోగించబడుతుంది. ప్రోగ్రామింగ్‌లోని స్కోప్ అనేది వేరియబుల్స్ మరియు ఫంక్షన్‌లను యాక్సెస్ చేయగల సందర్భాన్ని సూచిస్తుంది.
C++లో వివిధ సందర్భాలలో :: యొక్క ఉపయోగాలు
C++లో, ది స్కోప్ రిజల్యూషన్ ఆపరేటర్ (::) ఇది ఉపయోగించబడే సందర్భాన్ని బట్టి వివిధ ఉపయోగాలను కలిగి ఉంటుంది. ఈ ఆపరేటర్ యొక్క కొన్ని ముఖ్యమైన ఉపయోగాలు క్రిందివి:
1: వేరియబుల్ లేదా ఫంక్షన్‌ని వేరే నేమ్‌స్పేస్‌లో యాక్సెస్ చేయండి
ఎ నేమ్‌స్పేస్ పేరు పెట్టే వైరుధ్యాలను నివారించడానికి C++లో గ్రూప్ సంబంధిత ఫంక్షన్‌లు, తరగతులు మరియు వేరియబుల్స్‌కు ఉపయోగించబడుతుంది. మీరు a లోపల వేరియబుల్ లేదా ఫంక్షన్‌ని నిర్వచించినప్పుడు నేమ్‌స్పేస్ , వేరియబుల్ లేదా ఫంక్షన్ పేరు దానిలో మాత్రమే కనిపిస్తుంది నేమ్‌స్పేస్ .
C++లో, మీరు ఉపయోగించవచ్చు స్కోప్ రిజల్యూషన్ ఆపరేటర్ (::) తో పాటు నేమ్‌స్పేస్ వేరే నేమ్‌స్పేస్‌లో నిర్వచించబడిన వేరియబుల్ లేదా ఫంక్షన్‌ను యాక్సెస్ చేయడానికి పేరు మరియు వేరియబుల్ లేదా ఫంక్షన్ పేరు. ఇది a నుండి వేరియబుల్ లేదా ఫంక్షన్‌ని యాక్సెస్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది నేమ్‌స్పేస్ ఇది సృష్టించబడినది కాకుండా.
పై సందర్భాన్ని అర్థం చేసుకోవడానికి, కింది కోడ్‌ను ఉదాహరణగా పరిగణించండి:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
నేమ్‌స్పేస్ గణితం {
స్థిరంగా రెట్టింపు PI = 3.14159 ;
రెట్టింపు చతురస్రం ( రెట్టింపు x ) {
తిరిగి x * x ;
}
}
int ప్రధాన ( ) {
కోట్ << 'PI విలువ:' << గణితం :: PI << endl ;
కోట్ << '5 యొక్క వర్గము:' << గణితం :: చతురస్రం ( 5 ) << endl ;
తిరిగి 0 ;
}
పై కోడ్ ఉపయోగిస్తుంది గణిత నేమ్‌స్పేస్ యాక్సెస్ చేయడానికి 'PI' స్థిరమైన మరియు 'చదరపు' ఉపయోగించి ఫంక్షన్ స్కోప్ రిజల్యూషన్ ఆపరేటర్ '::' . ఇది కన్సోల్‌కు విలువలను ముద్రిస్తుంది.
అవుట్‌పుట్
2: ప్రోగ్రామ్‌లో గ్లోబల్ వేరియబుల్‌ని యాక్సెస్ చేయండి
ప్రోగ్రామ్‌లో లోకల్ మరియు గ్లోబల్ వేరియబుల్స్ యొక్క ఒకే పేరు ఉన్నప్పుడు, లోకల్ వేరియబుల్ గ్లోబల్ దాన్ని దాచవచ్చు. అటువంటి పరిస్థితులలో, మీరు ఉపయోగించవచ్చు స్కోప్ రిజల్యూషన్ ఆపరేటర్ (::) గ్లోబల్ వేరియబుల్ యాక్సెస్ కోసం. ఈ ఆపరేటర్ దాని పరిధిని బట్టి గ్లోబల్ వేరియబుల్‌ను స్పష్టంగా సూచించడానికి అనుమతిస్తుంది.
ఉదాహరణకు, క్రింద ఇవ్వబడిన కోడ్‌లో, మేము గ్లోబల్ వేరియబుల్‌ని సూచించాము ‘ఎ ' ద్వారా స్కోప్ రిజల్యూషన్ ఆపరేటర్(::) , అదే పేరుతో స్థానిక వేరియబుల్ నిర్వచించబడిన ఫంక్షన్ లోపల నుండి:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int a = పదిహేను ;
int ప్రధాన ( )
{
int a = 35 ;
కోట్ << 'గ్లోబల్ వేరియబుల్ a విలువ' << :: a << endl ;
కోట్ << 'స్థానిక వేరియబుల్ a విలువ' << a << endl ;
తిరిగి 0 ;
}
పై కోడ్‌లో, ప్రధాన విధికి వెలుపల ఉన్న వేరియబుల్ a గ్లోబల్ వేరియబుల్ మరియు ప్రధాన ఫంక్షన్‌లోని వేరియబుల్ a స్థానిక వేరియబుల్ గ్లోబల్ వేరియబుల్ అదే పేరుతో. కౌట్ స్టేట్‌మెంట్‌లో, మేము గ్లోబల్ వేరియబుల్‌ను ప్రింట్ చేయడానికి స్కోప్ రిజల్యూషన్ ఆపరేటర్‌ని ఉపయోగించాము a .
అవుట్‌పుట్
3: తరగతి వెలుపల ఒక ఫంక్షన్‌ను నిర్వచించండి
C++లో, మీరు క్లాస్ డెఫినిషన్ వెలుపల క్లాస్ ఫంక్షన్‌ని నిర్వచించవచ్చు మరియు దీన్ని ఉపయోగించి చేయవచ్చు స్కోప్ రిజల్యూషన్ ఆపరేటర్ (::) ఫంక్షన్ ఏ తరగతికి చెందినదో పేర్కొనడానికి. ఫంక్షన్ తరగతి పరిధి వెలుపల నిర్వచించబడినందున ఇది అవసరం.
యొక్క ఈ ఉపయోగాన్ని ప్రదర్శించే ఉదాహరణ కోడ్ ఇక్కడ ఉంది స్కోప్ రిజల్యూషన్ ఆపరేటర్ :
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
తరగతి myClass {
ప్రజా :
శూన్యం నా పనితీరు ( ) ;
} ;
శూన్యం నా తరగతి :: నా పనితీరు ( ) {
కోట్ << 'myfunction() కాల్డ్ !' ;
}
int ప్రధాన ( )
{
myClass classObj ;
classObj. నా పనితీరు ( ) ;
తిరిగి 0 ;
}
పై కోడ్‌లో, మెంబర్ ఫంక్షన్ myfunction() ఉపయోగించి తరగతి వెలుపల నిర్వచించబడింది స్కోప్ రిజల్యూషన్ ఆపరేటర్ :: అని పేర్కొనడానికి myfunction() myClass తరగతికి చెందినది.
అవుట్‌పుట్
4: క్లాస్ స్టాటిక్ మెంబర్‌లను యాక్సెస్ చేయండి
C++లో, క్లాస్‌లో స్టాటిక్ సభ్యుడు మరియు అదే పేరుతో స్థానిక వేరియబుల్ ఉన్నప్పుడు, ది స్కోప్ రిజల్యూషన్ ఆపరేటర్ (::) తరగతి స్టాటిక్ సభ్యులను యాక్సెస్ చేయడానికి ఉపయోగించవచ్చు. ఇది ప్రోగ్రామ్ స్థానిక వేరియబుల్ మరియు స్టాటిక్ మెంబర్ మధ్య తేడాను గుర్తించడానికి అనుమతిస్తుంది.
వినియోగానికి సంబంధించిన ఉదాహరణ కోడ్ ఇక్కడ ఉంది స్కోప్ రిజల్యూషన్ ఆపరేటర్ అటువంటి సందర్భంలో:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
తరగతి myClass {
ప్రజా :
స్థిరమైన int myStatVar ;
} ;
int నా తరగతి :: myStatVar = 5 ;
int ప్రధాన ( ) {
int myStatVar = 10 ;
కోట్ << 'లోకల్ వేరియబుల్ myStatVar:' << myStatVar << endl ;
కోట్ << 'క్లాస్ వేరియబుల్ myStatVar:' << నా తరగతి :: myStatVar << endl ;
తిరిగి 0 ;
}
పై ప్రోగ్రామ్ మొదట తరగతిని నిర్వచిస్తుంది నా తరగతి స్టాటిక్ మెంబర్ వేరియబుల్‌తో myStatVar . ఇది ప్రోగ్రామ్ యొక్క ప్రధాన ఫంక్షన్ లోపల అదే పేరుతో స్థానిక వేరియబుల్‌ను నిర్వచిస్తుంది. క్లాస్ వేరియబుల్‌ని యాక్సెస్ చేయడానికి, ది స్కోప్ రిజల్యూషన్ ఆపరేటర్ (::) తరగతి పేరుతో ఉపయోగించబడుతుంది నా తరగతి . ప్రోగ్రామ్ రెండు వేరియబుల్స్ యొక్క విలువను కన్సోల్‌కు అవుట్‌పుట్ చేస్తుంది.
అవుట్‌పుట్
5: బహుళ వారసత్వాలతో ఉపయోగించండి
ది స్కోప్ రిజల్యూషన్ ఆపరేటర్ (::) సభ్యుని వేరియబుల్స్ లేదా ఫంక్షన్‌లను ఒకే పేరుతో కలిగి ఉన్న బహుళ పేరెంట్ క్లాస్‌ల నుండి C++ క్లాస్ ఉత్పన్నమైనప్పుడు సభ్యుని యొక్క ఏ వెర్షన్ ఉపయోగించాలో సూచించడానికి కూడా ఉపయోగించబడుతుంది. మేము ఉపయోగించి ఒకే సభ్యుని యొక్క వివిధ సంస్కరణల మధ్య తేడాను గుర్తించవచ్చు స్కోప్ రిజల్యూషన్ ఆపరేటర్ పేరెంట్ క్లాస్ పేరు మరియు సభ్యుని పేరు తర్వాత.
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
తరగతి పేరెంట్ 1 {
ప్రజా :
శూన్యం ముద్రణ ( ) {
కోట్ << 'ఇది క్లాస్ పేరెంట్1 ప్రింట్ ఫంక్షన్.' << endl ;
}
} ;
తరగతి పేరెంట్2 {
ప్రజా :
శూన్యం ముద్రణ ( ) {
కోట్ << 'ఇది క్లాస్ పేరెంట్2 ప్రింట్ ఫంక్షన్.' << endl ;
}
} ;
తరగతి myClass : పబ్లిక్ పేరెంట్1 , పబ్లిక్ పేరెంట్2 {
ప్రైవేట్ :
int ఒకదానిపై ;
ప్రజా :
నా తరగతి ( int n ) {
ఒకదానిపై = n ;
}
శూన్యం ముద్రణ ( ) {
తల్లిదండ్రులు 1 :: ముద్రణ ( ) ; // పేరెంట్1 యొక్క ప్రింట్ ఫంక్షన్‌కు కాల్ చేయండి
తల్లిదండ్రులు2 :: ముద్రణ ( ) ; // పేరెంట్2 యొక్క ప్రింట్ ఫంక్షన్‌కు కాల్ చేయండి
కోట్ << 'సంఖ్య యొక్క విలువ:' << ఒకదానిపై << endl ; // సంఖ్య విలువను ముద్రించండి
}
} ;
int ప్రధాన ( ) {
myClass obj ( 42 ) ; // 42కి ప్రారంభించబడిన సంఖ్యతో MyClass యొక్క వస్తువును సృష్టించండి
obj ముద్రణ ( ) ; // వస్తువు యొక్క ప్రింట్() ఫంక్షన్‌కు కాల్ చేయండి
తిరిగి 0 ;
}
పై ప్రోగ్రామ్ యొక్క ఉపయోగాన్ని ప్రదర్శిస్తుంది స్కోప్ రిజల్యూషన్ ఆపరేటర్ (::) యొక్క ప్రింట్ ఫంక్షన్ల మధ్య తేడాను గుర్తించడానికి తల్లిదండ్రులు 1 మరియు తల్లిదండ్రులు2 రెండు తరగతులు వారసత్వంగా వచ్చినప్పుడు నా తరగతి. తో విధులు కాల్ చేయడం ద్వారా మాతృ తరగతి ఫంక్షన్ పేరుకు ముందు ఉన్న పేరు, ఫంక్షన్ యొక్క ఏ వెర్షన్‌ని ఉపయోగించాలో మనం పేర్కొనవచ్చు.
అవుట్‌పుట్
క్రింది గీత
ది స్కోప్ రిజల్యూషన్ ఆపరేటర్ (::) వివిధ స్కోప్ స్థాయిలలో వేరియబుల్ పేర్లను యాక్సెస్ చేయడానికి ఉపయోగించే C++లో కీలకమైన అంశం. వేరే నేమ్‌స్పేస్‌లో వేరియబుల్ లేదా ఫంక్షన్‌ను యాక్సెస్ చేయడం, గ్లోబల్ వేరియబుల్‌ను యాక్సెస్ చేయడం, క్లాస్ వెలుపల ఫంక్షన్‌ను నిర్వచించడం, క్లాస్‌లోని స్టాటిక్ మెంబర్‌లను యాక్సెస్ చేయడం మరియు బహుళ వారసత్వాలను ఉపయోగించడం వంటి వివిధ ఉపయోగాలు ఆపరేటర్‌కు ఉన్నాయి. కొత్త డెవలపర్‌లకు ఇది గందరగోళంగా ఉన్నప్పటికీ, అర్థం చేసుకోవడం స్కోప్ రిజల్యూషన్ ఆపరేటర్ (::) మంచి ప్రోగ్రామింగ్ అభ్యాసానికి అవసరం.