கேம்கள், கிராபிக்ஸ், வெப் சர்வர்கள் மற்றும் பலவற்றை உள்ளடக்கிய பல்வேறு நிரல்களை C++ நிரலாக்க மொழியைப் பயன்படுத்தி உருவாக்கலாம். இருப்பினும், சில நேரங்களில், எங்கள் நிரல்களில் உள்ள தரவுகளில் சில செயல்பாடுகளைச் செய்ய வேண்டியிருக்கும், அதாவது தேடுதல், வரிசைப்படுத்துதல் அல்லது உறுப்புகளின் வரம்பில் அதிகபட்ச அல்லது குறைந்தபட்ச மதிப்பைக் கண்டறிதல் போன்றவை. வரிசைப்படுத்தப்பட்ட உறுப்புகளின் வரம்பில் மதிப்பின் மேல் வரம்பைக் கண்டறியப் பயன்படும் செயல்பாடுகளில் ஒன்று top_bound().
C++ இல் top_bound() செயல்பாடு என்றால் என்ன
C++ இல் உள்ள மேல்_பவுண்ட்() சார்பு என்பது வரிசைப்படுத்தப்பட்ட தனிமங்கள் மற்றும் மதிப்பை வாதங்களாக எடுத்துக் கொள்ளும் ஒரு செயல்பாடாகும், மேலும் மதிப்பை விட அதிகமாக இருக்கும் வரம்பில் உள்ள முதல் உறுப்பைச் சுட்டிக்காட்டி மீண்டும் மீண்டும் வழங்கும்.
இது இரண்டு வெவ்வேறு வகையான வாதங்களைக் கொண்டுள்ளது:
மேல்_பவுண்டு ( ஒன்றில். முதலில் , ஒன்றில். கடந்த , மதிப்பு )
ஆய்வு செய்ய வேண்டிய உறுப்புகளின் வரம்பைக் குறிப்பிடும் மறு செய்கைகள் முதல் மற்றும் கடைசி. பயன்படுத்தப்பட்ட இடைவெளியில் முதல் உறுப்பு முதல் இறுதி வரை உள்ள அனைத்து கூறுகளும் உள்ளன, ஆனால் கடைசியாகக் குறிப்பிடப்பட்ட உறுப்பு இல்லை. மதிப்பு என்பது உறுப்புகளை ஒப்பிடுவதற்கான மதிப்பு.
மேல்_பவுண்டு ( ஒன்றில். முதலில் , ஒன்றில். கடந்த , மதிப்பு, ஒப்பீடு தொகுப்பு )
இந்த வழக்கில், பைனரி செயல்பாடு தொகுப்பானது பூலாக மாற்றக்கூடிய மதிப்பை உருவாக்குகிறது மற்றும் வரம்பின் உருப்படிகளாக அதே வகையின் இரண்டு அளவுருக்களை ஏற்றுக்கொள்கிறது. ஒரு குறிப்பிட்ட நிபந்தனையானது முதல் வாதம் இரண்டாவது வாதத்தை விட அதிகமாக இல்லை என்று கட்டளையிட்டால், செயல்பாடு உண்மையான முடிவை வழங்க வேண்டும், இல்லையெனில் அது தவறானதாக இருக்கும்.
C++ இல் top_bound() செயல்பாட்டை எவ்வாறு பயன்படுத்துவது
பல்வேறு சூழ்நிலைகளில் வரிசைப்படுத்தப்பட்ட உறுப்புகளின் வரம்பில் மதிப்பின் மேல் வரம்பைக் கண்டறிய மேல்_பவுண்ட்() செயல்பாடு பயன்படுத்தப்படலாம். எடுத்துக்காட்டாக, வரிசைப்படுத்தப்பட்ட அணி அல்லது வெக்டரில் ஒரு தனிமத்தின் நிலையைக் கண்டறிய அல்லது ஒரு தொகுப்பு அல்லது வரைபடத்தில் அடுத்த பெரிய உறுப்பைக் கண்டறிய இதைப் பயன்படுத்தலாம். C++ இல் top_bound() செயல்பாட்டை எவ்வாறு பயன்படுத்துவது என்பதற்கான சில எடுத்துக்காட்டுகள் இங்கே:
எடுத்துக்காட்டு 1: வரிசைப்படுத்தப்பட்ட அணிவரிசையில் ஒரு தனிமத்தின் நிலையைக் கண்டறிய top_bound() செயல்பாட்டைப் பயன்படுத்துதல்
வரிசைப்படுத்தப்பட்ட முழு எண்களின் வரிசையில் ஒரு உறுப்பின் நிலையைக் கண்டறிந்து அதைத் திரையில் காண்பிக்க மேல்_பவுண்ட்() செயல்பாட்டைப் பயன்படுத்தும் ஒரு எடுத்துக்காட்டு இங்கே:
#
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக வரிசை [ ] = { பதினைந்து , 35 , நான்கு. ஐந்து , 55 , 65 } ;
முழு எண்ணாக அ = அளவு ( வரிசை ) / அளவு ( வரிசை [ 0 ] ) ;
கூட் << 'வரிசை கொண்டுள்ளது:' ;
க்கான ( முழு எண்ணாக நான் = 0 ; நான் < அ ; நான் ++ )
கூட் << வரிசை [ நான் ] << '' ;
கூட் << ' \n ' ;
முழு எண்ணாக பி = நான்கு. ஐந்து ; // ஒரு மதிப்பை அறிவித்து துவக்கவும்
முழு எண்ணாக * ப = மேல்_வரம்பு ( வரிசை, வரிசை + a, b ) ;
கூட் << 'மேல் எல்லை' << பி << 'நிலையில் உள்ளது:' << ( ப - வரிசை ) << ' \n ' ; // சுட்டிக்காட்டி எண்கணிதத்தைப் பயன்படுத்தி நிலையைக் காட்டு
திரும்ப 0 ;
}
முதலில் நிரல் தேவையான தலைப்பு கோப்புகள் மற்றும் எண்களைக் கொண்ட வரிசையை வரையறுக்கிறது, பின்னர் வரிசையின் அளவைப் பெற sizeof() செயல்பாட்டைப் பயன்படுத்துகிறது. அடுத்து a for loop ஆனது வரிசையின் கூறுகளைக் காட்டப் பயன்படுகிறது, பின்னர் ஒரு முழு எண் அறிவிக்கப்படும், அதன் வரிசையில் அதன் நிலை சுட்டிக்காட்டியைப் பயன்படுத்தி தீர்மானிக்கப்படுகிறது மற்றும் அது வெளியீட்டில் காட்டப்படும்:
எடுத்துக்காட்டு 2: ஒரு தொகுப்பில் அடுத்த பெரிய உறுப்பைக் கண்டறிய top_bound() செயல்பாட்டைப் பயன்படுத்துதல்
முழு எண்களின் தொகுப்பில் கொடுக்கப்பட்ட மதிப்பை விட அடுத்த பெரிய உறுப்பைக் கண்டறிந்து அதைத் திரையில் காண்பிக்க மேல்_பவுண்ட்() செயல்பாட்டைப் பயன்படுத்தும் எடுத்துக்காட்டு குறியீடு இங்கே:
##
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( )
{
அமைக்கப்பட்டது < முழு எண்ணாக > ஒன்றில் = { பதினைந்து , 25 , 35 , நான்கு. ஐந்து , 55 } ; // முழு எண்களின் தொகுப்பை அறிவித்து துவக்கவும்
கூட் << 'கொடுக்கப்பட்ட எண்கள்:' ;
க்கான ( ஆட்டோ அ : ஒன்றில் ) // லூப்பிற்கான வரம்பு அடிப்படையிலான செட் உறுப்புகளைக் காட்டவும்
கூட் << அ << '' ;
கூட் << ' \n ' ;
முழு எண்ணாக அ = நான்கு. ஐந்து ; // ஒரு மதிப்பை அறிவித்து துவக்கவும்
ஆட்டோ அது = மேல்_வரம்பு ( ஒன்றில். தொடங்கும் ( ) , ஒன்றில். முடிவு ( ) , ஏ ) ; // top_bound() ஐப் பயன்படுத்தி தொகுப்பில் x இன் மேல் வரம்பைக் கண்டறியவும்
என்றால் ( அது ! = ஒன்றில். முடிவு ( ) ) // இட்ரேட்டர் செல்லுபடியாகுமா என சரிபார்க்கவும்
கூட் << 'அடுத்த அதிக எண்ணிக்கையை விட' << அ << ' இருக்கிறது ' << * அது << ' \n ' ; // dereference operator ஐப் பயன்படுத்தி உறுப்பைக் காட்டவும்
வேறு
கூட் << 'உயர்ந்த எண் எதுவும் இல்லை' << அ << ' \n ' ; // அத்தகைய உறுப்பு காணப்படவில்லை எனில் ஒரு செய்தியைக் காட்டவும்
திரும்ப 0 ;
}
முதலில் குறியீடு தேவையான தலைப்பு கோப்புகளை வரையறுக்கிறது, பின்னர் ஐந்து உறுப்புகளின் திசையன் வரையறுக்கப்படுகிறது, அடுத்து திசையன் தானாக முக்கிய சொல்லைப் பயன்படுத்தி காட்டப்படும், ஏனெனில் இது உறுப்புகளின் தரவு வகையை தானாகவே அமைக்கும். அடுத்து 45 மதிப்பைக் கொண்ட ஒரு மாறி அறிவிக்கப்படுகிறது, இது மேல்_பவுண்ட்() செயல்பாட்டைப் பயன்படுத்தி வரையறுக்கப்பட்ட திசையனுடன் ஒப்பிடப்படுகிறது, பின்னர் அது ஒப்பீட்டு முடிவைக் காட்டுகிறது:
முடிவுரை
மேல்_பவுண்ட்() சார்பு என்பது, கொடுக்கப்பட்ட மதிப்பை விட அதிகமாக இருக்கும் வரிசைப்படுத்தப்பட்ட வரம்பில் உள்ள முதல் உறுப்பைச் சுட்டிக்காட்டி மீண்டும் மீண்டும் வழங்கும் ஒரு செயல்பாடாகும். குறிப்பிட்ட எண்ணை விட அதிகமாகவோ அல்லது சமமாகவோ இருக்கும் இடைவெளியில் முதல் எண்ணைக் கண்டறிய, C++ இல் top_bound() செயல்பாட்டைப் பயன்படுத்தவும். பட்டியலில் அடுத்த அதிக எண்ணைக் கண்டறிவது அல்லது கொடுக்கப்பட்ட வரம்பை விட அதிகமாக இருக்கும் வரிசைப்படுத்தப்பட்ட வரிசையில் முதல் உறுப்பைக் கண்டறிவது போன்ற பணிகளுக்கு இது பயனுள்ளதாக இருக்கும்.