இந்த வழிகாட்டியில், நாம் பார்ப்போம் இரட்டை பெருங்குடல் (::) ஆபரேட்டர் C++ இல் மற்றும் வெவ்வேறு சூழ்நிலைகளில் இது எவ்வாறு செயல்படுகிறது.
:: C++ இல் என்ன செய்கிறது?
C++ இல், தி நோக்கம் தீர்மானம் ஆபரேட்டர் (::) பல்வேறு ஸ்கோப் நிலைகளில் இருக்கும் மாறியின் பெயர்களை மீட்டெடுக்கப் பயன்படுகிறது. நிரலாக்கத்தின் நோக்கம் மாறிகள் மற்றும் செயல்பாடுகளை அணுகக்கூடிய சூழலைக் குறிக்கிறது.
C++ இல் வெவ்வேறு நிகழ்வுகளில் :: இன் பயன்பாடுகள்
C++ இல், தி ஸ்கோப் ரெசல்யூஷன் ஆபரேட்டர் (::) அது பயன்படுத்தப்படும் சூழலைப் பொறுத்து பல்வேறு பயன்பாடுகளைக் கொண்டுள்ளது. இந்த ஆபரேட்டரின் சில குறிப்பிடத்தக்க பயன்பாடுகள் பின்வருமாறு:
1: ஒரு மாறி அல்லது செயல்பாட்டை வெவ்வேறு பெயர்வெளியில் அணுகவும்
ஏ பெயர்வெளி பெயரிடும் முரண்பாடுகளைத் தவிர்க்க, C++ இல் குழு தொடர்பான செயல்பாடுகள், வகுப்புகள் மற்றும் மாறிகளுக்குப் பயன்படுத்தப்படுகிறது. a க்குள் ஒரு மாறி அல்லது செயல்பாட்டை நீங்கள் வரையறுக்கும்போது பெயர்வெளி , மாறி அல்லது செயல்பாட்டின் பெயர் அதற்குள் மட்டுமே தெரியும் பெயர்வெளி .
C++ இல், நீங்கள் பயன்படுத்தலாம் ஸ்கோப் ரெசல்யூஷன் ஆபரேட்டர் (::) இணைந்து பெயர்வெளி வேறு பெயர்வெளியில் வரையறுக்கப்பட்ட ஒரு மாறி அல்லது செயல்பாட்டை அணுகுவதற்கான பெயர் மற்றும் மாறி அல்லது செயல்பாட்டு பெயர். இது a இலிருந்து மாறி அல்லது செயல்பாட்டை அணுக உங்களை அனுமதிக்கிறது பெயர்வெளி அது உருவாக்கப்பட்ட ஒன்றைத் தவிர.
மேலே உள்ள வழக்கைப் புரிந்து கொள்ள, பின்வரும் குறியீட்டை உதாரணமாகக் கவனியுங்கள்:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
பெயர்வெளி கணிதம் {
நிலையான இரட்டை PI = 3.14159 ;
இரட்டை சதுரம் ( இரட்டை எக்ஸ் ) {
திரும்ப எக்ஸ் * எக்ஸ் ;
}
}
முழு எண்ணாக முக்கிய ( ) {
கூட் << 'PI இன் மதிப்பு:' << கணிதம் :: PI << endl ;
கூட் << '5 இன் சதுரம்:' << கணிதம் :: சதுரம் ( 5 ) << endl ;
திரும்ப 0 ;
}
மேலே உள்ள குறியீடு பயன்படுத்துகிறது கணித பெயர்வெளி அணுகுவதற்கு 'PI' நிலையான மற்றும் 'சதுரம்' பயன்படுத்தி செயல்பாடு ஸ்கோப் ரெசல்யூஷன் ஆபரேட்டர் '::' . இது மதிப்புகளை கன்சோலில் அச்சிடுகிறது.
வெளியீடு
2: திட்டத்தில் குளோபல் மாறியை அணுகவும்
உள்ளூர் மற்றும் உலகளாவிய மாறிகளின் ஒரே பெயர் நிரலில் இருக்கும்போது, உள்ளூர் மாறி உலகளாவிய ஒன்றை மறைக்கக்கூடும். அத்தகைய சூழ்நிலைகளில், நீங்கள் பயன்படுத்தலாம் ஸ்கோப் ரெசல்யூஷன் ஆபரேட்டர் (::) உலகளாவிய மாறியை அணுகுவதற்கு. இந்த ஆபரேட்டர் உலகளாவிய மாறியை அதன் நோக்கத்தின் அடிப்படையில் வெளிப்படையாகக் குறிப்பிட அனுமதிக்கிறது.
எடுத்துக்காட்டாக, கீழே கொடுக்கப்பட்டுள்ள குறியீட்டில், உலகளாவிய மாறியைக் குறிப்பிடுகிறோம் ‘அ ‘ வழியாக ஸ்கோப் ரெசல்யூஷன் ஆபரேட்டர்(::) , ஒரு செயல்பாட்டின் உள்ளே இருந்து அதே பெயரைக் கொண்ட உள்ளூர் மாறி வரையறுக்கப்பட்டுள்ளது:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக அ = பதினைந்து ;
முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக அ = 35 ;
கூட் << 'உலகளாவிய மாறி a இன் மதிப்பு' << :: அ << endl ;
கூட் << 'உள்ளூர் மாறி a இன் மதிப்பு' << அ << endl ;
திரும்ப 0 ;
}
மேலே உள்ள குறியீட்டில், முக்கிய செயல்பாட்டிற்கு வெளியே இருக்கும் மாறி a present ஆகும் உலகளாவிய மாறி மற்றும் முக்கிய செயல்பாட்டிற்குள் உள்ள மாறி a ஆகும் உள்ளூர் மாறி உலகளாவிய மாறியின் அதே பெயருடன். கவுட் அறிக்கையில், உலகளாவிய மாறியை அச்சிட, ஸ்கோப் ரெசல்யூஷன் ஆபரேட்டரைப் பயன்படுத்தியுள்ளோம் அ .
வெளியீடு
3: வகுப்பிற்கு வெளியே ஒரு செயல்பாட்டை வரையறுக்கவும்
C++ இல், நீங்கள் வர்க்க வரையறைக்கு வெளியே ஒரு வர்க்க செயல்பாட்டை வரையறுக்கலாம் மற்றும் அதை பயன்படுத்தி செய்யலாம் ஸ்கோப் ரெசல்யூஷன் ஆபரேட்டர் (::) செயல்பாடு எந்த வகுப்பைச் சேர்ந்தது என்பதைக் குறிப்பிட. செயல்பாடு வர்க்க நோக்கத்திற்கு வெளியே வரையறுக்கப்பட்டிருப்பதால் இது அவசியம்.
இந்த பயன்பாட்டை நிரூபிக்கும் ஒரு எடுத்துக்காட்டு குறியீடு இங்கே உள்ளது நோக்கம் தீர்மானம் ஆபரேட்டர் :
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
வர்க்கம் myClass {
பொது :
வெற்றிடமானது என் செயல்பாடு ( ) ;
} ;
வெற்றிடமானது என் வகுப்பு :: என் செயல்பாடு ( ) {
கூட் << 'myfunction() Called !' ;
}
முழு எண்ணாக முக்கிய ( )
{
myClass classObj ;
classObj. என் செயல்பாடு ( ) ;
திரும்ப 0 ;
}
மேலே உள்ள குறியீட்டில், உறுப்பினர் செயல்பாடு myfunction() பயன்படுத்தி வகுப்பிற்கு வெளியே வரையறுக்கப்படுகிறது ஸ்கோப் ரெசல்யூஷன் ஆபரேட்டர் :: என்று குறிப்பிட வேண்டும் myfunction() myClass வகுப்பைச் சேர்ந்தது.
வெளியீடு
4: வகுப்பின் நிலையான உறுப்பினர்களை அணுகவும்
C++ இல், ஒரு நிலையான உறுப்பினர் மற்றும் அதே பெயரில் ஒரு உள்ளூர் மாறி இருக்கும் போது, வகுப்பிற்குள், ஸ்கோப் ரெசல்யூஷன் ஆபரேட்டர் (::) ஒரு வகுப்பின் நிலையான உறுப்பினர்களை அணுக பயன்படுத்தலாம். இது நிரலை உள்ளூர் மாறி மற்றும் நிலையான உறுப்பினரை வேறுபடுத்த அனுமதிக்கிறது.
பயன்பாடு தொடர்பான ஒரு எடுத்துக்காட்டு குறியீடு இங்கே உள்ளது நோக்கம் தீர்மானம் ஆபரேட்டர் அத்தகைய சந்தர்ப்பத்திற்கு:
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
வர்க்கம் myClass {
பொது :
நிலையான முழு எண்ணாக myStatVar ;
} ;
முழு எண்ணாக என் வகுப்பு :: myStatVar = 5 ;
முழு எண்ணாக முக்கிய ( ) {
முழு எண்ணாக myStatVar = 10 ;
கூட் << 'உள்ளூர் மாறி myStatVar:' << myStatVar << endl ;
கூட் << 'கிளாஸ் மாறி myStatVar:' << என் வகுப்பு :: myStatVar << endl ;
திரும்ப 0 ;
}
மேலே உள்ள நிரல் முதலில் ஒரு வகுப்பை வரையறுக்கிறது என் வகுப்பு நிலையான உறுப்பினர் மாறியுடன் myStatVar . இது நிரலின் முக்கிய செயல்பாட்டிற்குள் அதே பெயரில் உள்ள ஒரு உள்ளூர் மாறியை வரையறுக்கிறது. வகுப்பு மாறியை அணுக, தி ஸ்கோப் ரெசல்யூஷன் ஆபரேட்டர் (::) வர்க்கப் பெயருடன் பயன்படுத்தப்படுகிறது என் வகுப்பு . நிரல் இரண்டு மாறிகளின் மதிப்பை கன்சோலுக்கு வெளியிடுகிறது.
வெளியீடு
5: பல மரபுரிமைகளுடன் பயன்படுத்தவும்
தி ஸ்கோப் ரெசல்யூஷன் ஆபரேட்டர் (::) ஒரே பெயரில் உறுப்பினர் மாறிகள் அல்லது செயல்பாடுகளைக் கொண்ட பல பெற்றோர் வகுப்புகளிலிருந்து C++ கிளாஸ் பெறப்பட்டால், எந்த உறுப்பினரின் எந்தப் பதிப்பைப் பயன்படுத்த வேண்டும் என்பதைக் குறிப்பிடவும் பயன்படுகிறது. ஐப் பயன்படுத்தி ஒரே உறுப்பினரின் பல்வேறு பதிப்புகளை நாம் வேறுபடுத்தி அறியலாம் நோக்கம் தீர்மானம் ஆபரேட்டர் பெற்றோரின் வகுப்பின் பெயர் மற்றும் உறுப்பினரின் பெயர்.
#பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
வகுப்பு பெற்றோர் 1 {
பொது :
வெற்றிடமானது அச்சு ( ) {
கூட் << 'இது கிளாஸ் பெற்றோர்1 பிரிண்ட் செயல்பாடு.' << endl ;
}
} ;
வகுப்பு பெற்றோர்2 {
பொது :
வெற்றிடமானது அச்சு ( ) {
கூட் << 'இது வகுப்பு பெற்றோர்2 அச்சு செயல்பாடு.' << endl ;
}
} ;
வர்க்கம் myClass : பொது பெற்றோர்1 , பொது பெற்றோர்2 {
தனிப்பட்ட :
முழு எண்ணாக ஒன்றில் ;
பொது :
என் வகுப்பு ( முழு எண்ணாக n ) {
ஒன்றில் = n ;
}
வெற்றிடமானது அச்சு ( ) {
பெற்றோர்1 :: அச்சு ( ) ; // Parent1 இன் அச்சு செயல்பாட்டை அழைக்கவும்
பெற்றோர்2 :: அச்சு ( ) ; // Parent2 இன் அச்சு செயல்பாட்டை அழைக்கவும்
கூட் << 'எண்ணின் மதிப்பு:' << ஒன்றில் << endl ; // எண்ணின் மதிப்பை அச்சிடவும்
}
} ;
முழு எண்ணாக முக்கிய ( ) {
myClass obj ( 42 ) ; // MyClass இன் ஒரு பொருளை உருவாக்கவும், எண்ணை 42 ஆக துவக்கவும்
obj. அச்சு ( ) ; // பொருளின் அச்சு() செயல்பாட்டை அழைக்கவும்
திரும்ப 0 ;
}
மேலே உள்ள நிரல் அதன் பயன்பாட்டை நிரூபிக்கிறது ஸ்கோப் ரெசல்யூஷன் ஆபரேட்டர் (::) இன் அச்சு செயல்பாடுகளை வேறுபடுத்த பெற்றோர்1 மற்றும் பெற்றோர்2 இரண்டு வகுப்புகளும் மரபுரிமையாக இருக்கும்போது என் வகுப்பு. உடன் செயல்பாடுகளை அழைப்பதன் மூலம் பெற்றோர் வகுப்பு செயல்பாட்டின் பெயருக்கு முந்தைய பெயர், செயல்பாட்டின் எந்த பதிப்பைப் பயன்படுத்த வேண்டும் என்பதைக் குறிப்பிடலாம்.
வெளியீடு
பாட்டம் லைன்
தி ஸ்கோப் ரெசல்யூஷன் ஆபரேட்டர் (::) வெவ்வேறு ஸ்கோப் நிலைகளில் மாறி பெயர்களை அணுகுவதற்கு C++ இல் ஒரு முக்கிய அங்கமாகும். வெவ்வேறு பெயர்வெளியில் மாறி அல்லது செயல்பாட்டை அணுகுதல், உலகளாவிய மாறியை அணுகுதல், வகுப்பிற்கு வெளியே ஒரு செயல்பாட்டை வரையறுத்தல், ஒரு வகுப்பின் நிலையான உறுப்பினர்களை அணுகுதல் மற்றும் பல பரம்பரைகளைப் பயன்படுத்துதல் உள்ளிட்ட பல்வேறு பயன்பாடுகளை ஆபரேட்டர் கொண்டுள்ளது. புதிய டெவலப்பர்களுக்கு இது குழப்பமாக இருந்தாலும், புரிந்துகொள்வது ஸ்கோப் ரெசல்யூஷன் ஆபரேட்டர் (::) நல்ல நிரலாக்க நடைமுறைக்கு அவசியம்.