C++ Constexpr சரம் எடுத்துக்காட்டுகள்

C++ Constexpr சரத்தின் பயன் என்ன?

constexpr ஐப் பயன்படுத்துவது மிகவும் கச்சிதமான மற்றும் உகந்த இயங்கக்கூடிய கோப்புகளுக்கு வழிவகுக்கும். கம்பைலரால் மதிப்புகள் முன்கூட்டியே தீர்மானிக்கப்படுவதால், அதன் விளைவாக வரும் பைனரிகள் அளவு சிறியதாக இருக்கலாம், இது கணினி வளங்களின் சிக்கனமான பயன்பாட்டை உணர்ந்து, பல்வேறு தளங்களில் மென்பொருளின் செயல்திறனை மேம்படுத்தும். இந்த அம்சத்தின் ஒரு சிறப்பு குறிப்பிடத்தக்க நன்மை, இது இயக்க நேர கணக்கீடுகளில் குறைப்பு ஆகும். சாத்தியமான போதெல்லாம் தொகுத்தல் செயல்பாட்டின் போது மதிப்புகள் கணக்கிடப்படுவதால், இயக்க நேர மதிப்பீடு குறைவாக தேவைப்படுகிறது. இந்த செயல்திறனானது, செயல்பாட்டினை விரைவுபடுத்துவது மட்டுமல்லாமல், ஒட்டுமொத்த நிரல் செயல்பாடுகளையும் நெறிப்படுத்துகிறது.

எடுத்துக்காட்டு 1: Factorial கணக்கீட்டிற்கு C++ இல் Constexpr ஐப் பயன்படுத்துதல்

இந்த எடுத்துக்காட்டில், நாங்கள் constexpr ஐப் பயன்படுத்துவோம், இது கணக்கீடுகளை இயக்க நேரத்தில் அல்லாமல் தொகுக்கும் நேரத்தில் செய்ய அனுமதிக்கிறது. காரணிகளைக் கணக்கிடும் சூழலில், ஒரு பொதுவான கணிதச் செயல்பாடு, இது constexpr ஆகும், இது தொகுக்கப்படும் போது காரணி மதிப்புகளைக் கணக்கிட உதவுகிறது. பின்வரும் குறியீட்டை ஆராய்ந்து மதிப்பாய்வு செய்வோம், பின்னர் குறியீட்டின் விளக்கத்தைப் பார்ப்போம்:

கொடுக்கப்பட்ட குறியீட்டு உதாரணம், ஒரு எண்ணின் காரணியை ஒரு சுழல் வழியில் கணக்கிடுவதற்கு constexpr இன் பயன்பாட்டைக் காட்டுகிறது. இந்த எடுத்துக்காட்டில் தொகுக்கும் நேரத்தில் காரணியான வெளிப்பாட்டை கம்பைலர் மதிப்பீடு செய்ய முடியும், ஏனெனில் காரணிசார் செயல்பாடு அறிவிக்கப்பட்டு constexpr குறிப்பான் மூலம் வரையறுக்கப்படுகிறது. C++ நிரலில் constexpr ஐப் பயன்படுத்தி, தொகுக்கும் நேரத்தில் 5 இன் காரணியான வெளிப்பாட்டை கம்பைலர் மதிப்பிடுகிறது, இது இயக்க நேர கணக்கீட்டின் தேவையை நீக்குகிறது.

இப்போது, ​​குறிப்பிட்ட விவரங்கள் மற்றும் விளக்கங்களுடன் குறியீட்டின் விரிவான முறிவைப் பார்ப்போம்.

முதலில், கன்சோலில் அச்சிடுவதற்கு 'std::cout' போன்ற அத்தியாவசிய உள்ளீடு மற்றும் வெளியீட்டு செயல்பாடுகளை வழங்கும் 'iostream' தலைப்புக் கோப்பை இணைக்க, #include ஐப் பயன்படுத்துகிறோம்.

பின்னர், நாம் காரணியான() செயல்பாட்டிற்கு (சுழற்சி) செல்கிறோம், இது 'constexpr int factorial(int n)' ஆகும். இந்த காரணிசார்() சார்பு ஒரு சுழல்நிலை செயல்பாட்டை வரையறுக்கிறது, இது 'n' முழு எண்ணின் காரணியாலானதைக் கணக்கிடுகிறது. Constexpr, தொகுப்பின் போது செயல்பாட்டை மதிப்பிடுவதன் மூலம் செயல்திறன் மேம்படுத்தல்கள் ஏற்படலாம் என்பதைக் குறிக்கிறது.

திரும்ப n <= 1 ? 1 : (n * factorial(n – 1)) வரியானது மறுநிகழ்வுக்கான நிபந்தனை வெளிப்பாட்டைப் பயன்படுத்துகிறது, அதில் “n” 1ஐ விட குறைவாகவோ அல்லது சமமாகவோ இருந்தால், அது 1ஐ (அடிப்படை வழக்கு) வழங்குகிறது. இல்லையெனில், அது காரணியான கணக்கீட்டை (n! = n * (n-1)!) செய்கிறது, இது காரணியாலானதைக் கணக்கிடுவதற்கான பொதுவான சூத்திரம், 'n - 1' என்று மீண்டும் மீண்டும் அழைப்பதன் மூலம் அதன் முடிவை 'n ஆல் பெருக்குகிறது. ”. இந்த கோடுகள் காரணி கணக்கீட்டிற்கு ஒரு கேட் கீப்பர் போல செயல்படுகின்றன. எண் அடிப்படை மட்டத்தில் உள்ளதா என்பதை இது சரிபார்த்து, அப்படியானால் 1ஐ வழங்கும். இல்லையெனில், இது செயல்பாட்டு அழைப்புகளின் சங்கிலி எதிர்வினையைத் தொடங்குகிறது, ஒவ்வொன்றும் அடிப்படை வழக்கை அடையும் வரை சிறிய எண்களில் செயல்படும். பின்னர், முடிவுகள் தலைகீழ் வரிசையில் ஒன்றாக பெருக்கப்படுகின்றன. உங்கள் குறிப்புக்கான குறியீட்டின் வெளியீடு பின்வருமாறு:

எடுத்துக்காட்டு 2: C++ Constexpr சரத்தை விளக்கும் சிறிய எழுத்துக்களை எண்ணுதல்

Countexpr சரத்தைப் பயன்படுத்தி சிற்றெழுத்துகளின் எண்ணிக்கையை எப்படி எண்ணுவது என்பதை இங்கே கற்றுக்கொள்வோம். இந்த எடுத்துக்காட்டில், இயக்க நேர கணக்கீட்டைக் குறைக்க constexpr அம்சத்தைப் பயன்படுத்தி கொடுக்கப்பட்ட சரத்தில் உள்ள சிறிய எழுத்துக்களின் எண்ணிக்கையை எண்ணுவதே இதன் நோக்கம். CountLowercase() செயல்பாடு, constexpr என அறிவிக்கப்பட்டு, ஒரு “string_view” சரத்தை அதன் அளவுருவாக எடுத்துக்கொண்டு, கொடுக்கப்பட்ட சரத்தின் ஒவ்வொரு எழுத்தையும் உள்ளீடாக மீண்டும் செய்கிறது. நாம் சந்திக்கும் ஒவ்வொரு சிறிய எழுத்துக்கும், எண்ணிக்கை அதிகரிக்கப்படுகிறது. தொகுக்கும் நேர மதிப்பீட்டின் செயல்திறன் மற்றும் செயல்திறன் பலன்களைக் காட்டும், நிலையான வெளிப்பாடுகளில் செயல்பாடு செயல்படுவதால், தொகுக்கும் நேரத்தில் முடிவு பெறப்படுகிறது. முதலில், பின்வரும் குறியீட்டைச் சரிபார்க்கவும். பின்னர், விரிவான விளக்கத்திற்கு செல்லவும்:

ஒவ்வொரு வரியின் விளக்கத்துடன் குறியீட்டின் விரிவான முறிவு இங்கே:

செய்திகளை அச்சிட நிலையான உள்ளீடு/வெளியீட்டு ஸ்ட்ரீம் நூலகத்தைப் பயன்படுத்த #include சேர்க்கப்பட்டுள்ளது. #include ஆனது திறமையான சரம் கையாளுதலுக்கான 'ஸ்ட்ரிங்_வியூ' வகுப்பை உள்ளடக்கியது.

CountLowercase() செயல்பாட்டில், “constexpr size_t countlower(string_view s)” செயல்பாடு, கொடுக்கப்பட்ட சரம் பார்வையில் உள்ள சிறிய எழுத்துக்களைக் கணக்கிடுகிறது. int main() என்பது 'LoWeR CaSe LeTtErS' இல் உள்ள சிறிய எழுத்துக்களின் எண்ணிக்கையைக் குறிக்கும் ஒரு செய்தியை அச்சிட்டு, 'LoWeR CaSe LeTtErS' உடன் கவுண்ட்லோவர்கேஸ்() செயல்பாட்டை உள்ளீடாக அழைத்து, முடிவை அச்சிடும் நிரலின் நுழைவுப் புள்ளியாகும். நிரலின் பின்வரும் வெளியீட்டைப் பார்க்கவும்:

எடுத்துக்காட்டு 3: C++ Constexpr ஐப் பயன்படுத்தி வரிசை விளக்கக்காட்சி

ஒரு நிரலாக்க மொழியில் ஒரே தரவு வகையின் தனிமங்களின் கட்டமைக்கப்பட்ட தொகுப்புகளான வரிசைகள் எவ்வாறு உருவாக்கப்படுகின்றன, அணுகப்படுகின்றன மற்றும் கையாளப்படுகின்றன என்பதை ஒரு வரிசை ஆர்ப்பாட்டம் காட்டுகிறது. பின்வருவனவற்றில், ஒரு குறியீட்டு உதாரணம் மூலம் விளக்குவோம், இதில் நிரல் தொகுக்கும் நேர வரிசை துவக்கம் மற்றும் கையாளுதலுக்கான எளிய உதாரணத்தை வழங்குகிறது.

ஒரு வரிசை விளக்கமானது வரிசைகளின் கருத்தை விளக்குகிறது - ஒரே தரவு வகையைப் பகிர்ந்து கொள்ளும் உறுப்புகளின் கட்டமைக்கப்பட்ட தொகுப்பு - மற்றும் நிரலாக்க மொழியைப் பயன்படுத்தி அவற்றை எவ்வாறு உருவாக்கலாம், அணுகலாம் மற்றும் கையாளலாம். பின்வரும் குறியீட்டு எடுத்துக்காட்டில், தொகுக்கும் நேரத்தில் ஒரு வரிசையை எவ்வாறு துவக்குவது, அதன் அளவைக் கணக்கிடுவது மற்றும் கொடுக்கப்பட்ட வரிசையின் கூறுகளை எவ்வாறு அச்சிடுவது என்பதை விளக்குவோம். கீழே கொடுக்கப்பட்டுள்ள குறியீட்டைப் பார்த்து விளக்கத்திற்குச் செல்லவும்:

இந்த நிரல் ஒரு constexpr வரிசையை துவக்குகிறது, தொகுக்கும் நேரத்தில் அதன் நீளத்தை கணக்கிடுகிறது, பின்னர் வரிசையின் நீளம் மற்றும் உறுப்புகளை கன்சோலில் அச்சிடுகிறது. வரிசை மற்றும் அதன் பண்புகள் தொகுக்கும் நேரத்தில் தீர்மானிக்கப்படுவதை Constexpr உறுதி செய்கிறது. குறியீட்டை உடைத்து குறிப்பிட்ட விவரங்களை ஒவ்வொன்றாக விளக்குவோம்:

நிலையான உள்ளீடு-வெளியீட்டு ஸ்ட்ரீம் நூலகத்தைச் சேர்க்க, வெளியீட்டிற்கு 'cout' போன்ற செயல்பாடுகளைப் பயன்படுத்த அனுமதிக்கிறது, #include என்று அழைக்கப்படுகிறது. நிரல் int main() செயல்பாட்டிலிருந்து செயல்படுத்தலைத் தொடங்குகிறது. மெயின்() செயல்பாட்டிற்குள், “அரேயின்ட்[]” வரிசை வரையறுக்கப்படுகிறது, இது 9 அளவைக் கொண்ட ஒரு constexpr int arrayint[9] அறிக்கையுடன் இருக்கும். வரிசையானது ஐந்து எண்களுடன் துவக்கப்பட்டது, மீதமுள்ள உறுப்புகள் மறைமுகமாக 0 ஆக இருக்கும். முழு எண்ணாக நீளம்_a = வரிசையின் அளவு / அளவு (int); பைட்டுகளில் 'அரேயின்ட்' அளவைக் கணக்கிடுகிறது.

ஒரு 'for' லூப் 'arrayint[]'வரிசையின் உறுப்புகள் வழியாக மீண்டும் செயல்படுகிறது, பின்னர் மதிப்புகள் பணியகத்தில் அச்சிடப்படும். கொடுக்கப்பட்ட குறியீட்டின் பின்வரும் வெளியீட்டைப் பார்ப்போம்:

முடிவுரை

C++ இல் constexpr முக்கிய வார்த்தையின் அறிமுகமும் பரிணாமமும் நிலையான வெளிப்பாடுகள் மற்றும் மதிப்புகள் எவ்வாறு கையாளப்படுகின்றன என்பதில் புரட்சியை ஏற்படுத்தியுள்ளன. இந்த கட்டுரை மூன்று நடைமுறை உதாரணங்களை ஆராய்ந்தது, காரணிகளை கணக்கிடுவதில் constexpr இன் ஆற்றலைக் காட்டுகிறது, சிறிய எழுத்துக்களை எண்ணுகிறது மற்றும் தொகுக்கும் நேரத்தில் வரிசைகளை துவக்குகிறது. மேம்படுத்தப்பட்ட செயல்திறன், குறைக்கப்பட்ட இயக்க நேர கணக்கீடுகள் மற்றும் மேம்படுத்தப்பட்ட நினைவக திறன் ஆகியவை முக்கிய எடுத்துச் செல்லல்களில் அடங்கும். Constexpr என்பது ஒரு குறியீட்டு தளத்தில் நம்பகமான, நிலையான நிறுவனங்களை உருவாக்குவதற்கும், மாறாத தன்மையை உறுதி செய்வதற்கும், மேலும் நெறிப்படுத்தப்பட்ட மற்றும் திறமையான திட்டங்களுக்கு பங்களிப்பதற்கும் ஒரு மதிப்புமிக்க சொத்து.