எடுத்துக்காட்டு 1: டூப்பிள்ஸ்/ஜோடிகளைப் பயன்படுத்துதல்
C++ இல் பல மதிப்புகளை வழங்க சில நடைமுறை விளக்கங்களைச் செய்வோம். இங்கே, எங்கள் குறியீட்டில் பல மதிப்புகளை வழங்க உதவும் டூப்பிள்ஸ்/ஜோடி நுட்பங்களைப் பயன்படுத்துகிறோம். C++ பல்வேறு தலைப்புக் கோப்புகளை வழங்குகிறது, அதை நாம் நமது குறியீட்டில் சேர்க்க வேண்டும். C++ நிரலாக்கத்தின் அனைத்து லைப்ரரிகளையும் கொண்டிருப்பதால், 'bits/stdc++.h' ஐ இங்கே சேர்க்கிறோம். பின்னர், 'std' என்ற பெயர்வெளி இங்கு சேர்க்கப்படுகிறது. இதற்குப் பிறகு, நாங்கள் மூன்று தரவு வகைகள், இரண்டு மிதவை தரவு வகைகள் மற்றும் மீதமுள்ள ஒரு 'சார்' தரவு வகையை வைக்கும் 'tuple' முக்கிய சொல்லைப் பயன்படுத்துகிறோம். அதற்குக் கீழே, ஒரு டூப்பிளைத் திரும்பப் பெறுவதற்கு மதிப்புகளைக் கட்ட, 'திரும்ப' முக்கிய சொல்லைப் பயன்படுத்துகிறோம்.
இப்போது, பல மதிப்புகளை வழங்க 'ஜோடி' முறையைப் பயன்படுத்துகிறோம். இந்த 'ஜோடி' முறையில், இரண்டு மாறிகளின் தரவு வகைகளை வைக்கிறோம், இரண்டும் இங்கே 'ஃப்ளோட்' ஆகும். மாறிகள் 'float_1' மற்றும் 'float_2' என்று பெயரிடப்பட்டுள்ளன. பின்னர், 'ஜோடிகளுக்கு' திரும்ப இரண்டு மதிப்புகளை பேக் செய்கிறோம். இதற்குப் பிறகு, நாங்கள் இங்கே “முதன்மை()” ஐ அழைக்கிறோம், பின்னர் “f_1, f_2” பெயருடன் இரண்டு “float” மாறிகளை அறிவிக்கிறோம். 'char' மாறி இங்கு 'myChar' என்றும் அறிவிக்கப்பட்டுள்ளது. பின்னர், “My_Tuple()” செயல்பாட்டின் மூலம் வழங்கப்படும் மதிப்புகளைத் திறக்கிறோம்.
இதற்கு கீழே, திரும்பிய மதிப்புகளை ஜோடிகளாக சேமிக்கிறோம். 'My_Tuple' செயல்பாட்டில் '4.99, 8.98' மற்றும் 'My_Pair' செயல்பாட்டில் '6.86, 3.22' ஆகியவற்றைச் சேமிக்கிறோம். பின்னர், அதில் எழுதப்பட்ட அனைத்து தகவல்களையும் அச்சிடும் 'cout' ஐப் பயன்படுத்துகிறோம்.
குறியீடு 1:
#
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
tuple < மிதவை , மிதவை , கரி > My_Tuple ( மிதவை f_1, மிதவை f_2 ) {
திரும்ப செய்ய_டூப்பிள் ( f_2, f_1, '$' ) ;
}
ஜோடி < மிதவை , மிதவை > என்_ஜோடி ( மிதவை f_a, மிதவை f_b ) {
திரும்ப செய்_ஜோடி ( f_b, f_a ) ;
}
முழு எண்ணாக முக்கிய ( ) {
மிதவை f_1,f_2 ;
கரி myChar ;
கட்டு ( f_1, f_2, myChar ) = My_Tuple ( 4.99 , 8.98 ) ;
ஜோடி new_p = என்_ஜோடி ( 6.86 , 3.22 ) ;
கூட் << 'டூபிள்ஸ் மூலம் நாம் பெறும் மதிப்புகள்:' ;
கூட் << f_1 << '' << f_2 << '' << myChar << endl ;
கூட் << 'ஜோடி மூலம் நாம் பெறும் மதிப்புகள்:' ;
கூட் << புதிய_ப. முதலில் << '' << புதிய_ப. இரண்டாவது ;
திரும்ப 0 ;
}
வெளியீடு :
'டூப்பிள்ஸ்' மற்றும் 'ஜோடி' முறையைப் பயன்படுத்துவதன் மூலம் நாம் இங்கு பெறும் மதிப்புகள் பின்வருவனவற்றில் காட்டப்படும். இங்கே பல மதிப்புகளை வழங்குகிறது என்பதை நினைவில் கொள்க.
எடுத்துக்காட்டு 2: சுட்டிகளைப் பயன்படுத்துதல்
இங்கே 'ஒப்பிடு' செயல்பாட்டில் அளவுருக்களை அவற்றின் முகவரிகளுடன் அனுப்புகிறோம். 'int' வகையின் 'value_1' மற்றும் 'value_2' மற்றும் 'int* g_Address, int* s_Address' ஆகியவற்றைச் சேர்க்கிறோம். இதற்குப் பிறகு, 'மதிப்பு_2' ஐ விட 'மதிப்பு_1' அதிகமாக இருக்கும் என்ற நிபந்தனையைச் சேர்க்கும் 'if' நிபந்தனையைப் பயன்படுத்துகிறோம். இது திருப்தி அடைந்தால், பின்வரும் அறிக்கை செயல்படுத்தப்படும். அது இல்லையென்றால், இது கீழே சேர்க்கப்பட்டுள்ள அறிக்கையை புறக்கணித்து, 'வேறு' பகுதியை நோக்கி நகரும். இப்போது, “main()” ஐப் பயன்படுத்திய பிறகு, “g_value”, “s_value”, “newValue1” மற்றும் “newValue2” என்ற பெயர்களுடன் நான்கு புதிய மாறிகளை அறிவிக்கிறோம்.
இதற்குப் பிறகு, எண்களை உள்ளிட ஒரு செய்தியை அச்சிட்டு, பயனரிடமிருந்து இரண்டு மதிப்புகளைப் பெறும் 'சின்' ஐ வைக்கிறோம். பயனர் உள்ளிடும் மதிப்புகள் முறையே 'newValue1' மற்றும் 'newValue2' மாறிகளில் சேமிக்கப்படும். இதற்குப் பிறகு, நாம் முன்பு உருவாக்கிய 'ஒப்பிடு ()' செயல்பாட்டை அழைக்கிறோம் மற்றும் அதில் நான்கு அளவுருக்களை அனுப்புகிறோம். பின்னர், 'ஒப்பிடு' செயல்பாட்டைச் செய்த பிறகு முடிவைக் காண்பிப்போம், மேலும் அது பயனர் உள்ளிடும் அந்த எண்களிலிருந்து அதிக எண்ணிக்கையையும் சிறிய எண்ணையும் காட்டுகிறது.
குறியீடு 2:
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
வெற்றிடமானது ஒப்பிடு ( முழு எண்ணாக மதிப்பு_1, முழு எண்ணாக மதிப்பு_2, முழு எண்ணாக * g_முகவரி, முழு எண்ணாக * s_முகவரி )
{
என்றால் ( மதிப்பு_1 > மதிப்பு_2 ) {
* g_முகவரி = மதிப்பு_1 ;
* s_முகவரி = மதிப்பு_2 ;
}
வேறு {
* g_முகவரி = மதிப்பு_2 ;
* s_முகவரி = மதிப்பு_1 ;
}
}
முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக g_value, s_value, newValue_1, newValue_2 ;
கூட் << 'தயவுசெய்து இரண்டு எண்களை உள்ளிடவும்:' <> புதிய மதிப்பு_1 >> புதிய மதிப்பு_2 ;
ஒப்பிடு ( புதிய மதிப்பு_1, புதிய மதிப்பு_2, & g_மதிப்பு, & s_மதிப்பு ) ;
கூட் << ' \n அதிக எண்ணிக்கை ' << g_value << 'மற்றும் சிறிய எண்'
<< s_மதிப்பு ;
திரும்ப 0 ;
}
வெளியீடு :
பயனர் இங்கே '86' மற்றும் '23' ஐ உள்ளிடுகிறார். 'Enter' ஐ அழுத்திய பிறகு, அது முடிவைக் காட்டுகிறது. இந்த வழியில், நாம் பல மதிப்புகளைப் பெறுகிறோம்.
எடுத்துக்காட்டு 3: வரிசையைப் பயன்படுத்துதல்
இங்கே “ComputeComparison()” செயல்பாட்டை உருவாக்குகிறோம், அதில் “num_1” மற்றும் “num_2” ஆகிய இரண்டு மாறிகளை “int” வகையாகவும், “my_arr[]” என்ற பெயரில் ஒரு வரிசையையும் செருகுவோம். இதற்குப் பிறகு, எங்களிடம் “if” நிபந்தனை உள்ளது, இது “num_1” “num_2” ஐ விட அதிகமாக உள்ளதா இல்லையா என்பதைச் சரிபார்க்கும். இது உண்மையாக இருந்தால், “my_arr[0]”க்கு “num_1” ஒதுக்கப்படும் மற்றும் “num_2” என்பது “my_arr[1]”க்கு ஒதுக்கப்படும். ஆனால் நிபந்தனை உண்மையாக இல்லாவிட்டால், “else” க்குப் பிறகு வரும் அறிக்கைகள் செயல்படுத்தப்படும், அதில் “num_2” ஐ “my_arr[0]” மற்றும் “num_1” ஐ “my_arr[1]”க்கு ஒதுக்குவோம்.
இதற்குப் பிறகு, நாம் இங்கே “main()” என்று அழைக்கிறோம், பின்னர் மேலும் இரண்டு int மாறிகளை அறிவிக்கிறோம்: “newNum_1” மற்றும் “newNum_2”. இதற்குப் பிறகு, அளவு '2' வரிசை அறிவிக்கப்படுகிறது. இதற்குப் பிறகு, “சின்” உதவியுடன் பயனரிடமிருந்து இரண்டு எண்களைப் பெறுகிறோம், பின்னர் “கம்ப்யூட் கம்பரிசன்()” செயல்பாட்டை அழைத்து பின்வரும் முடிவைக் காண்பிக்கிறோம். எனவே, அது இங்கே பல மதிப்புகளை வழங்குகிறது.
குறியீடு 3:
#பயன்படுத்தி பெயர்வெளி வகுப்பு ;
வெற்றிடமானது கணக்கீடு ஒப்பீடு ( முழு எண்ணாக எண்_1, முழு எண்ணாக எண்_2, முழு எண்ணாக my_arr [ ] )
{
என்றால் ( எண்_1 > எண்_2 ) {
my_arr [ 0 ] = எண்_1 ;
my_arr [ 1 ] = எண்_2 ;
}
வேறு {
my_arr [ 0 ] = எண்_2 ;
my_arr [ 1 ] = எண்_1 ;
}
}
முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக newNum_1, newNum_2 ;
முழு எண்ணாக my_arr [ 2 ] ;
கூட் << 'ஒப்பிடுவதற்கு இரண்டு எண்களை உள்ளிடவும்' <> புதிய எண்_1 >> புதிய எண்_2 ;
கணக்கீடு ஒப்பீடு ( newNum_1, newNum_2, my_arr ) ;
கூட் << ' \n அதிக எண்ணிக்கை ' << my_arr [ 0 ] << ' மற்றும் இந்த '
'சிறிய எண்' << my_arr [ 1 ] ;
திரும்ப 0 ;
}
வெளியீடு :
'54' மற்றும் '98' இரண்டையும் இங்கே தட்டச்சு செய்து, முடிவைக் காட்ட 'Enter' ஐ அழுத்தவும். இது நாம் உள்ளிட்ட எண்களில் இருந்து பெரிய மற்றும் சிறிய எண்களைக் காட்டுகிறது.
எடுத்துக்காட்டு 4: டூபிள்ஸைப் பயன்படுத்துதல்
இரண்டு தலைப்பு கோப்புகள் இங்கே சேர்க்கப்பட்டுள்ளன: 'tuple' மற்றும் 'iostream'. அடுத்து, 'std' பெயர்வெளி இங்கு வைக்கப்பட்டுள்ளது. அடுத்து, நாம் 'tuple' முக்கிய சொல்லைப் பயன்படுத்துகிறோம் மற்றும் 'int' என்ற இரண்டு தரவு வகைகளைச் செருகுவோம். இதற்குப் பிறகு, “findingValues()”பெயருடன் ஒரு செயல்பாட்டை உருவாக்கி, அதன் அளவுருக்களாக “intValue_1” மற்றும் “intValue2” ஐ அனுப்புவோம்.
பின்னர், 'intValue_1 < intValue_2' நிபந்தனையை நாம் தட்டச்சு செய்யும் இடத்தில் 'if' வைக்கப்படும். அதன் கீழே, 'திரும்ப' முக்கிய சொல்லைப் பயன்படுத்துகிறோம் மற்றும் 'make_tuple()' செயல்பாட்டை வைக்கிறோம், இதில் இரண்டு மாறிகளும் 'intValue_1, intValue2_' அளவுருவாக சேர்க்கப்படும். பின்னர், 'make_tuple()' செயல்பாட்டுடன் 'return' ஐ மீண்டும் வைக்கும் 'else' பகுதி உள்ளது. ஆனால் இங்கே, முதலில் 'intValue_2' ஐ வைக்கிறோம், பின்னர் 'intValue1' ஐ வைக்கிறோம். இப்போது, நாம் 'main()' என்று அழைக்கிறோம் மற்றும் 'new_value1' ஐ '5' மற்றும் 'new_value2' ஐ '28' உடன் துவக்குகிறோம்.
பின்வருவனவற்றில், 'int' வகையின் மேலும் இரண்டு மாறிகளை 'பெரிய' மற்றும் 'சிறிய' பெயர்களுடன் அறிவிக்கிறோம். பின்னர், 'டை()' செயல்பாட்டை வைத்து, 'சிறிய, பெரிய' மாறிகளை அளவுருவாக அனுப்புகிறோம், மேலும் இங்கே 'findingValues()' செயல்பாட்டை அழைக்கிறோம். இதற்குப் பிறகு, இரண்டு மதிப்புகளையும் அச்சிடுகிறோம்: பெரிய மற்றும் சிறிய எண்கள்.
குறியீடு 4:
# அடங்கும்# அடங்கும்
பயன்படுத்தி பெயர்வெளி வகுப்பு ;
tuple findingValues ( முழு எண்ணாக intValue_1, முழு எண்ணாக intValue_2 )
{
என்றால் ( intValue_1 < intValue_2 ) {
திரும்ப செய்ய_டூப்பிள் ( intValue_1 , intValue_2 ) ;
}
வேறு {
திரும்ப செய்ய_துப்பிள் ( intValue_2 , intValue_1 ) ;
}
}
முழு எண்ணாக முக்கிய ( )
{
முழு எண்ணாக புதிய_மதிப்பு1 = 5 , new_value2 = 28 ;
முழு எண்ணாக பெரிய, சிறிய ;
கட்டு ( சிறிய, பெரிய ) = மதிப்புகளைக் கண்டறிதல் ( புதிய_மதிப்பு1, புதிய_மதிப்பு2 ) ;
printf ( 'அதிக எண் %d மற்றும் '
'சிறிய எண் %d' ,
பெரிய, சிறிய ) ;
திரும்ப 0 ;
}
வெளியீடு :
எங்கள் குறியீட்டில் நாம் சேர்க்கும் எண்கள் ஒரே நேரத்தில் பெரிய மற்றும் சிறிய மதிப்புகளைக் காட்டுகின்றன. இந்த வழியில், நம் குறியீட்டில் பல மதிப்புகளை எளிதாக திரும்பப் பெறலாம்.
முடிவுரை
இந்த வழிகாட்டி C++ குறியீடுகளில் 'பல மதிப்புகளை திரும்பப் பெறுதல்' பற்றியது. இந்த வழிகாட்டியில் இந்த கருத்தை நாங்கள் முழுமையாக ஆராய்ந்தோம் மற்றும் C++ நிரலாக்கத்தில் பல மதிப்புகளை திரும்பப் பெற உதவும் மூன்று நுட்பங்களைப் பற்றி விவாதித்தோம். டூப்பிள்கள், ஜோடிகள், சுட்டிகள் மற்றும் வரிசை நுட்பங்களைப் பயன்படுத்துவதன் மூலம் பல மதிப்புகள் வழங்கப்படுகின்றன என்பதை நாங்கள் விளக்கினோம். இந்த நுட்பங்கள் அனைத்தும் இங்கே விரிவாக விவரிக்கப்பட்டுள்ளன.