C++ என்பது ஒரு நிரலாக்க மொழியாகும், இது உயர் செயல்திறன் மற்றும் தரமான பயன்பாடுகளை உருவாக்க பயன்படுகிறது. C++ வழங்கும் அம்சங்களில் ஒன்று சரம் கையாளுதல் ஆகும், இதில் சரங்களை ஒப்பிட்டுப் பார்க்கும் திறன் உள்ளது. இருப்பினும், சரங்களை ஒப்பிடுவதற்கு C++ இரண்டு முறைகளை வழங்குகிறது: ' == 'ஆபரேட்டர் மற்றும்' ஒப்பிடு() ”முறை. அவற்றின் ஒற்றுமை இருந்தபோதிலும், உங்கள் குறியீடு எவ்வாறு செயல்படுகிறது என்பதைப் பாதிக்கக்கூடிய தனித்துவமான வேறுபாடுகள் உள்ளன.
இந்த டுடோரியல் இந்த இரண்டு முறைகளுக்கு இடையேயான வித்தியாசத்தை உள்ளடக்கும், == மற்றும் C++ இல் ஒப்பீடு().
== C++ இல் ஆபரேட்டர்
C++ இல், இரண்டு மதிப்புகள் சமமாக உள்ளதா இல்லையா என்பதைச் சரிபார்க்க இரட்டைச் சம == ஆபரேட்டர் பயன்படுத்தப்படுகிறது. == ஆபரேட்டரைப் பயன்படுத்துவதற்கான பொதுவான வடிவம் பின்வருமாறு:
பயன்படுத்த ' == சரங்களை ஒப்பிடுவதற்கான ஆபரேட்டர், பொதுவான வடிவம் பின்வருமாறு:
- முதலில், நீங்கள் ஒப்பிடுவதற்கு இரண்டு சரம் மாறிகளை அறிவிக்க வேண்டும்.
- பின்னர் பயன்படுத்தவும் ' == ” இரண்டு சரங்களையும் ஒப்பிட்டுப் பார்க்கவும்.
- ஆபரேட்டர் '' இன் பூலியன் மதிப்பை வழங்குவார் சரியா தவறா ', இரண்டு சரங்களும் ஒரே மாதிரியானதா என்பதைப் பொறுத்து.
இங்கே ஒரு உதாரணம்:
#
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( ) {
சரம் str1 = 'வணக்கம்' ;
சரம் str2 = 'லினக்ஸ்' ;
சரம் str3 = 'வணக்கம்' ;
என்றால் ( str1 == str2 ) {
கூட் << 'சரம் 1 மற்றும் சரம் 2 சமம்' << endl ;
} வேறு {
கூட் << 'சரம் 1 மற்றும் சரம் 2 சமமாக இல்லை' << endl ;
}
என்றால் ( str1 == str3 ) {
கூட் << 'சரம் 1 மற்றும் சரம் 3 சமம்' << endl ;
} வேறு {
கூட் << 'சரம் 1 மற்றும் சரம் 3 சமமாக இல்லை' << endl ;
}
திரும்ப 0 ;
}
ஒப்பிடு() முறை C++ இல்
C++ இல், ஒப்பீடு() முறையானது, இரண்டு சரங்களின் எழுத்துகளை அவற்றின் ASCII மதிப்புகளின் அடிப்படையில், மற்றும் அவற்றின் உறவைக் குறிக்கும் முழு எண்ணை வழங்கும். முதல் சரம் இரண்டாவது சரத்தை விட சொற்களஞ்சியத்தில் குறைவாக இருந்தால், இந்த முறையால் வழங்கப்படும் முழு எண் எதிர்மறையாகவும், இரண்டு ஒப்பிடப்பட்ட சரங்களும் ஒரே மாதிரியாக இருந்தால் பூஜ்ஜியமாகவும் இருக்கும், மேலும் முதல் சரம் மற்றதை விட அதிகமாக இருந்தால், இந்த முறை நேர்மறை எண்ணை வழங்கும்.
ஒப்பீடு() முறையைப் பயன்படுத்துவதற்கான வடிவம் கீழே உள்ளது:
முழு எண்ணாக மாறி_பெயர் = str1. ஒப்பிடு ( str2 ) ;ஒப்பிடு() முறையைப் பயன்படுத்தி இரண்டு சரங்களை ஒப்பிடுவதற்கான எடுத்துக்காட்டு குறியீடு கீழே உள்ளது:
##
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
முழு எண்ணாக முக்கிய ( ) {
சரம் str1 = 'LinuxHint' ;
சரம் str2 = 'இணையதளம்' ;
முழு எண்ணாக விளைவாக = str1. ஒப்பிடு ( str2 ) ;
என்றால் ( விளைவாக < 0 )
{
கூட் << 'சரம் 1 என்பது சரம் 2 ஐ விட சொற்களஞ்சியம் குறைவாக உள்ளது.' << endl ;
}
திரும்ப 0 ;
}
C++ சரம் == மற்றும் ஒப்பிடு() முறைக்கு இடையே உள்ள வேறுபாடு என்ன?
ஒப்பீடு() முறைக்கும் == ஆபரேட்டருக்கும் இடையே உள்ள முக்கிய வேறுபாடுகள் கீழே பட்டியலிடப்பட்டுள்ளன:
| ஒப்பிடு() | == ஆபரேட்டர் |
|---|---|
| இது முழு எண் மதிப்பை வழங்குகிறது | இது பூலியன் மதிப்பை வழங்குகிறது |
| துல்லியமான முடிவுகளைப் பெற, ஒப்பிடப்பட்ட சரங்களின் அதே நீளம் தேவை | முழு சரங்களையும் பாத்திரத்தின் அடிப்படையில் ஒப்பிடுகிறது |
| இது வாதங்களைப் பொறுத்து பல செயல்பாடுகளைச் செய்ய முடியும் | ஒரு அறுவை சிகிச்சையை மட்டுமே செய்ய முடியும் |
| சரங்களை எழுத்துமுறையின் அடிப்படையில் ஒரு அகராதி ஒப்பீடு செய்கிறது | முழு சரங்களின் எளிய ஒப்பீட்டைச் செய்கிறது |
| வார்த்தைக்கு வார்த்தை சரம் பிரித்தெடுத்தல் செய்கிறது | எழுத்துக்கு எழுத்து சரம் ஒப்பீடு செய்கிறது |
முடிவுரை
C++ என்பது ஒரு சக்திவாய்ந்த நிரலாக்க மொழியாகும், இது சரம் கையாளுதல் திறன்களை வழங்குகிறது, இதில் சரங்களை ஒப்பிடும் திறன் உள்ளது == 'ஆபரேட்டர் அல்லது' ஒப்பிடு() ”முறை. இரண்டு முறைகளும் குறியீட்டின் செயல்திறனை பாதிக்கும் தனித்துவமான வேறுபாடுகளைக் கொண்டுள்ளன, மேலும் ஒவ்வொன்றையும் எப்போது பயன்படுத்த வேண்டும் என்பதைப் புரிந்துகொள்வது டெவலப்பர்கள் மிகவும் திறமையான குறியீட்டை எழுத உதவும்.