C++ நிரலாக்க மொழியில் உள்ள மாறிகள், C++ நிரலுக்குள் மாறிகளைக் கையாள்வதில் இன்றியமையாத பங்கு வகிக்கும் தரவைக் கையாளவும் நிர்வகிக்கவும் அடிப்படைக் கட்டுமானத் தொகுதிகளாகச் செயல்படுகின்றன. C++ நிரலாக்க மொழியானது நிலையான உலகளாவிய மாறிகளைப் பயன்படுத்தி வெவ்வேறு நோக்கங்கள் மற்றும் தொகுப்பு அலகுகளில் மாறித் தெரிவுநிலையை நிர்வகிக்க ஒரு வலுவான வழியை வழங்குகிறது. உலகளாவிய நோக்கத்தில் அறிவிக்கப்படும் ஒரு நிலையான உலகளாவிய மாறியானது 'நிலையான' குறிப்பான் காரணமாக வரையறுக்கப்பட்ட கோப்பில் கட்டுப்படுத்தப்படுகிறது. 'நிலையான' திறவுச்சொல், அந்த கோப்பில் உள்ள செயல்பாடு அழைப்புகள் முழுவதும் மாறி அதன் மதிப்பைத் தக்கவைத்துக்கொள்வதை உறுதிசெய்கிறது, ஆனால் மற்ற கோப்புகளுக்கு அணுக முடியாததாகவும் கண்ணுக்கு தெரியாததாகவும் இருக்கும். நிரலின் நிலையை நிர்வகிப்பதில் C++ இல் நிலையான உலகளாவிய மாறிகள் முக்கியமானவை. இந்தக் கட்டுரை நிலையான உலகளாவிய மாறிகளின் நுணுக்கங்களை ஆராய்கிறது, அவற்றின் பண்புகள், பயன்பாட்டு வழக்குகள் மற்றும் சாத்தியமான சவால்களை எடுத்துக்காட்டுகிறது.
C++ இல் நிலையான மாறிகள்
C++ இல், ஒரு நிலையான மாறி உலகளாவிய, உள்ளூர், பெயர்வெளி அல்லது வகுப்புகளுக்குள் உள்ளிட்ட பல்வேறு நோக்கங்களுக்குள் உடனடியாக உருவாக்கப்படலாம். அதன் இருப்பு முழு நிரல் இயக்க நேரத்தையும் தொடக்கம் முதல் இறுதி வரை பரவுகிறது, அதன் ஒதுக்கீடு முழுவதும் பராமரிக்கப்படுவதை உறுதி செய்கிறது. எளிமையான வார்த்தைகளில், நிரலின் தொடக்கத்தில் நினைவகம் இந்த மாறிகளுக்கு ஒதுக்கப்படுகிறது மற்றும் நிரல் செயல்படுத்தல் முடிவடையும் போது டீல்லோகேட் செய்யப்படுகிறது. நிலையானது மாறியுடன் பயன்படுத்தப்படும்போது, இணைப்பின் அடிப்படையில் மாறியின் தெரிவுநிலையைக் கட்டுப்படுத்துகிறது, மேலும் அது அறிவிக்கப்பட்ட நிரலுக்கு மட்டுமே அணுகக்கூடியது.
C++ இல் நிலையான மாறிகளின் பயன்பாடுகள்
நிலையான உலகளாவிய மாறி, வரையறுக்கும் கோப்பிற்கு மட்டுமே பொருத்தமான நிலை அல்லது உள்ளமைவை பராமரிக்க ஒரு கட்டுப்படுத்தப்பட்ட பொறிமுறையை வழங்குகிறது. நிலையான உலகளாவிய மாறிகளால் விதிக்கப்படும் கோப்பு நோக்கத்தின் கருத்து, வெளிப்புற இணைப்பிலிருந்து தேவையற்ற பக்க விளைவுகளைத் தடுப்பதன் மூலம் தூய்மையான மட்டு நிரலாக்கத்தை எளிதாக்குகிறது. நிலையான மாறி பல்வேறு சூழ்நிலைகளில் பயன்படுத்தப்படலாம் மற்றும் அவை பின்வருவனவற்றில் பட்டியலிடப்பட்டுள்ளன:
காட்சி 1: பல செயல்பாடுகள் முழுவதும் கவுண்டர்
ஒரு செயல்பாட்டிற்குள் நிலையான முக்கிய வார்த்தையுடன் மாறி அறிவிக்கப்படும் போது, அது ஒரே செயல்பாட்டிற்கு பல அழைப்புகளில் அதன் நிலையைப் பாதுகாக்கிறது. ஒரு மாறியின் நிலையை பராமரிக்கும் இந்த திறன் குறிப்பிட்ட சூழ்நிலைகளில் சாதகமாக இருக்கும். C++ நிலையான உலகளாவிய மாறியைப் பயன்படுத்தி பல செயல்பாடுகளில் உள்ள கவுண்டரைப் புரிந்துகொள்ள ஒரு உதாரணத்தைப் பார்ப்போம். எடுத்துக்காட்டு குறியீடு பின்வருமாறு கொடுக்கப்பட்டுள்ளது:
#
வகுப்பு கவுண்டர் {
தனிப்பட்ட:
நிலையான முழு உலகளாவிய கவுண்டர்;
பொது:
வெற்றிட அதிகரிப்பு கவுண்டர் ( ) {
++ குளோபல் கவுண்டர்;
}
int getCounterValue ( ) நிலையான {
திரும்ப உலகளாவிய கவுண்டர்;
}
} ;
int கவுண்டர்::globalCounter = 0 ;
முழு எண்ணாக ( ) {
கவுண்டர் கவுண்டர்;
க்கான ( int i = 0 ; நான் < 5 ; ++i ) {
counter.incrementCounter ( ) ;
}
int counterValue = counter.getCounterValue ( ) ;
std::cout << 'கவுண்டரின் மதிப்பு:' << எதிர்மதிப்பு << std::endl;
திரும்ப 0 ;
}
இந்தக் குறியீடு இரண்டு செயல்பாடுகளைக் கொண்ட எளிய “கவுண்டர்” வகுப்பை வரையறுக்கிறது: “அதிகரிப்பு கவுண்டர்” இது உலகளாவிய கவுண்டரை 1 ஆல் அதிகரிக்கிறது மற்றும் உலகளாவிய கவுண்டரின் தற்போதைய மதிப்பை வழங்கும் “getCounterValue”. குறியீடு 'கவுண்டர்' வகுப்பை எவ்வாறு பயன்படுத்துவது என்பதை விளக்கும் ஒரு முக்கிய செயல்பாட்டையும் கொண்டுள்ளது. இது ஒரு 'கவுண்டர்' பொருளை உருவாக்குகிறது, கவுண்டரை ஐந்து முறை அதிகரிக்கிறது, அதன் மதிப்பை மீட்டெடுக்கிறது மற்றும் கன்சோலில் அச்சிடுகிறது. இந்த செயல்படுத்தல் அனைத்து 'கவுண்டர்' பொருட்களாலும் பகிரப்படும் ஒரு உலகளாவிய கவுண்டரைப் பயன்படுத்துகிறது. இது எளிமையானது மற்றும் புரிந்துகொள்ள எளிதானது, ஆனால் உங்களுக்கு பல சுயாதீன கவுண்டர்கள் தேவைப்படும் சூழ்நிலைகளுக்கு இது பொருந்தாது. நிரலின் பின்வரும் வெளியீட்டைப் பார்க்கவும்:
இந்த எடுத்துக்காட்டில், 'குளோபல்கவுண்டர்' நிலையான மாறியானது 'incrementCounter' மற்றும் 'getCounterValue' போன்ற செயல்பாடுகளுக்கான அழைப்புகளுக்கு இடையில் அதன் நிலையைத் தக்கவைத்துக்கொள்வதை நீங்கள் அவதானிக்கலாம்.
காட்சி 2: பயன்பாடு செயல்பாடு நிகழ்வுகள் முழுவதும் பகிரப்பட்டது
வகுப்பில் உள்ள உறுப்பினர் செயல்பாடு நிலையானது என வரையறுக்கப்படும் போது, அது அனைத்து வகுப்பு நிகழ்வுகளுக்கும் கிடைக்கும். இருப்பினும், அதில் சுட்டிக்காட்டி இல்லாததால், ஒரு நிகழ்வு உறுப்பினரை அணுக முடியாது. இந்த சூழ்நிலையை நன்கு புரிந்துகொள்ள பின்வரும் பொருத்தமான உதாரணத்தை தோண்டி எடுப்போம்:
#வகுப்பு பயன்பாட்டு வகுப்பு {
பொது:
நிலையான வெற்றிட பயன்பாடு செயல்பாடு ( ) {
std::cout << 'பயன்பாட்டு செயல்பாடு அழைக்கப்படுகிறது.' << std::endl;
}
} ;
வகுப்பு MyClass {
பொது:
செல்லாத அழைப்பு யுடிலிட்டி செயல்பாடு ( ) {
UtilityClass::utilityFunction ( ) ;
}
} ;
முழு எண்ணாக ( ) {
MyClass பொருள்;
obj.callUtilityFunction ( ) ;
திரும்ப 0 ;
}
இந்த குறியீடு இரண்டு வகுப்புகளை வரையறுக்கிறது: 'UtilityClass' மற்றும் 'MyClass'. 'UtilityClass' ஆனது 'utilityFunction' எனப்படும் பொது நிலையான செயல்பாட்டைக் கொண்டுள்ளது, இது 'Utility function is called' என்று கன்சோலில் அச்சிடுகிறது. 'MyClass' ஆனது 'callUtilityFunction' என்று அழைக்கப்படும் ஒரு பொது செயல்பாட்டைக் கொண்டுள்ளது, இது 'UtilityClass' இன் 'utilityFunction' செயல்பாட்டை அழைக்கிறது.
முக்கிய செயல்பாடு 'obj' எனப்படும் 'MyClass' இன் ஒரு பொருளை உருவாக்குகிறது. இது 'obj' பொருளின் 'callUtilityFunction' செயல்பாட்டை அழைக்கிறது. இது 'UtilityClass' இன் 'utilityFunction' செயல்பாட்டை கன்சோலில் 'The Utility function is called' என்று அச்சிடுகிறது. குறியீட்டின் பின்வரும் வெளியீட்டைப் பார்க்கவும்:
இந்த அணுகுமுறை தனித்தனி பொருள்களின் தேவையை நீக்குகிறது மற்றும் குறியீட்டு கட்டமைப்பை எளிதாக்குகிறது. 'பயன்பாட்டுச் செயல்பாட்டை' அணுகுவதற்கு வகுப்பு இரண்டு வழிகளை வழங்குகிறது. UtilityClass ::utilityFunction() தொடரியலை நேரடியாகப் பயன்படுத்துவது ஒரு வழி, இது ஒரு பொருளை உருவாக்காமல் அணுகக்கூடியது. மற்ற வழி obj.callUtilityFunction() உறுப்பினர் செயல்பாட்டைப் பயன்படுத்தும் ஒரு பொருளின் மூலம், இது வகுப்பிற்குள் கூடுதல் சூழல் மற்றும் சாத்தியமான கூடுதல் செயல்பாட்டை அனுமதிக்கிறது. பயன்பாட்டுச் செயல்பாட்டிற்கு நீங்கள் விரும்பும் பயன்பாட்டு முறையைப் பொறுத்து, இந்த அணுகுமுறை எளிமை மற்றும் நெகிழ்வுத்தன்மையை சமநிலைப்படுத்துகிறது.
காட்சி 3: நிலையான குளோபல் மாறியில் வகுப்பு நோக்கம்
வகுப்பின் நிகழ்வுகளின் எண்ணிக்கையைப் பொருட்படுத்தாமல், ஒரு வகுப்பிற்குள் நிலையானதாக அறிவிக்கப்பட்ட உறுப்பினர் ஒரு நகலில் மட்டுமே இருக்கிறார். இது தரவு உறுப்பினர்கள் (மாறிகள்) மற்றும் உறுப்பினர் செயல்பாடுகள் ஆகிய இரண்டிற்கும் பொருந்தும். முக்கியமாக, ஒரு நிலையான தரவு உறுப்பினரின் வரையறை வகுப்பு அறிவிப்புக்கு வெளியே, பொதுவாக கோப்பு நோக்கத்தில் நிகழ வேண்டும்.
C++ இல் தரவு உறுப்பினர் மற்றும் உறுப்பினர் செயல்பாடு ஆகிய இரண்டிற்கும் பயன்படுத்தப்படும் நிலையான ஒரு எடுத்துக்காட்டு இங்கே:
#வகுப்பு கவுண்டர் {
பொது:
நிலையான முழு எண்ணாக உலகளாவிய எண்ணிக்கை;
கவுண்டர் ( ) {
++உலகளாவிய எண்ணிக்கை;
}
நிலையான வெற்றிடமான printGlobalCount ( ) {
std::cout << 'உலகளாவிய எண்ணிக்கை:' << உலகளாவிய எண்ணிக்கை << std::endl;
}
} ;
int கவுண்டர்::globalCount = 0 ;
முழு எண்ணாக ( ) {
கவுண்டர் கவுண்டர்1;
கவுண்டர் கவுண்டர்2;
கவுண்டர்::printGlobalCount ( ) ;
திரும்ப 0 ;
}
குறியீடு 'க்ளோபல்கவுண்ட்' எனப்படும் தனியார் நிலையான உறுப்பினர் மாறி மற்றும் இரண்டு பொது உறுப்பினர் செயல்பாடுகளுடன் 'கவுண்டர்' எனப்படும் வகுப்பை வரையறுக்கிறது. ஒன்று Counter() இது 'globalCount' மாறியை அதிகரிக்கும் ஒரு கன்ஸ்ட்ரக்டர் செயல்பாடு ஆகும். மற்றொன்று 'printGlobalCount' ஆகும், இது 'globalCount' மாறியின் தற்போதைய மதிப்பை வழங்குகிறது. குறியீடு ஒரு முக்கிய செயல்பாட்டையும் கொண்டுள்ளது. இந்த செயல்பாடு 'கவுண்டர்1' மற்றும் 'கவுண்டர்2' பெயர்களால் அடையாளம் காணப்பட்ட 'கவுண்டர்' வகுப்பின் இரண்டு பொருட்களை உருவாக்குகிறது. மாறி அறிவிப்புக்குப் பிறகு, இது 'கவுண்டர்::printGlobalCount' செயல்பாட்டை அழைக்கிறது, இது 'globalCount' மாறியின் தற்போதைய மதிப்பை மறைமுகமாக அச்சிடுகிறது. பின்வரும் வெளியீட்டுத் துணுக்கைப் பார்க்கவும்:
இந்த எடுத்துக்காட்டில், ஒரு 'globalCount' மாறியானது 'கவுண்டர்' வகுப்பிற்குள் நிலையான தரவு உறுப்பினராக அறிவிக்கப்படுகிறது. இதன் பொருள், எத்தனை 'எதிர்' பொருள்கள் உருவாக்கப்பட்டாலும், இந்த மாறியின் ஒரே ஒரு நகல் மட்டுமே உள்ளது. கவுண்டர்()கன்ஸ்ட்ரக்டர் ஒவ்வொரு நிகழ்விற்கும் 'குளோபல் கவுண்ட்' ஐ அதிகரிக்கிறது, பொருள்கள் முழுவதும் அதன் பகிரப்பட்ட தன்மையை நிரூபிக்கிறது. 'printGlobalCount' என்பது ஒரு நிலையான உறுப்பினர் செயல்பாடு. நினைவில் கொள்ளுங்கள், இது வகுப்பின் பெயரை நேரடியாகப் பயன்படுத்தி செய்யப்படுகிறது (கவுண்டர்::printGlobalCount). எதிர்பார்த்தபடி 'குளோபல் கவுண்ட்' அதிகரிக்கப்பட்டதை வெளியீடு காட்டுகிறது, இது 'கவுண்டர்' வகுப்பின் அனைத்து நிகழ்வுகளிலும் பகிரப்பட்ட நிலையை பிரதிபலிக்கிறது.
முடிவுரை
முடிவில், C++ இல் நிலையான உலகளாவிய மாறிகள் செயல்பாடுகள் மற்றும் கோப்புகள் முழுவதும் மாநிலத்தை நிர்வகிக்க ஒரு பல்துறை கருவியாக வெளிப்படுகின்றன. அவற்றின் உள் இணைப்பு, நிலையான தன்மை மற்றும் கட்டுப்படுத்தப்பட்ட தகவல் பகிர்வு ஆகியவை சில நிரலாக்க சூழ்நிலைகளில் அவற்றை மதிப்புமிக்க சொத்துகளாக ஆக்குகின்றன. அவற்றின் குணாதிசயங்களைப் புரிந்துகொள்வதன் மூலமும், பல்வேறு பயன்பாட்டு நிகழ்வுகளை ஆராய்வதன் மூலமும், சாத்தியமான ஆபத்துக்களை அங்கீகரிப்பதன் மூலமும், டெவலப்பர்கள் நிலையான உலகளாவிய மாறிகளை திறம்பட பயன்படுத்த முடியும், குறியீடு மாடுலாரிட்டியை மேம்படுத்துகிறது மற்றும் அவர்களின் திட்டங்களின் வெவ்வேறு பகுதிகளுக்கு இடையே தகவல் பரிமாற்றத்தை எளிதாக்குகிறது. சிறந்த நடைமுறைகளை கவனமாக பரிசீலித்து பின்பற்றுவதன் மூலம், நிலையான உலகளாவிய மாறிகள் C++ நிரல்களின் வடிவமைப்பு மற்றும் செயல்பாட்டிற்கு சாதகமாக பங்களிக்க பயன்படுத்தப்படலாம்.