இந்த தொடர்புடைய செயல்பாடுகள் மிகவும் பயனுள்ளதாக இருக்கும். ஆனால் ஒரு மாறி மற்றொன்றை விட பெரியதா அல்லது சிறியதா என்பதை மட்டுமல்ல, அதன் மதிப்பைப் பெறவும் நாம் தெரிந்து கொள்ள வேண்டிய சந்தர்ப்பங்கள் உள்ளன. இது 'if' அறிக்கைகள் மற்றும் எளிமையான தொடர்புடைய செயல்பாடுகள் மூலம் எளிதாக செய்யப்படுகிறது என்றாலும், C மொழியானது மேக்ரோக்களுக்கு இரண்டு மாறிகளுக்கு இடையே அதிகபட்ச அல்லது குறைந்தபட்ச மதிப்பை வழங்கும் செயல்பாடுகளையும் வழங்குகிறது.
இந்த Linuxhint கட்டுரையில், இரண்டு மாறிகளின் குறைந்தபட்ச மதிப்பைக் கண்டறிய மேக்ரோ MIN() ஐ எவ்வாறு பயன்படுத்துவது என்பதை நீங்கள் கற்றுக் கொள்வீர்கள். தொடரியல், அழைப்பு முறை மற்றும் அது ஏற்றுக்கொள்ளும் தரவு வகை ஆகியவற்றைக் காண்பிப்போம். பின்னர், இது எவ்வாறு செயல்படுகிறது என்பதற்கான விளக்கத்தைப் பார்த்து, இந்த மேக்ரோ பொருந்தும் வெளிப்பாடு மற்றும் சூத்திரத்தை மதிப்பாய்வு செய்வோம்.
மேக்ரோ MIN() இல் உள்ளீடுகளாக வெவ்வேறு தரவு வகைகளுடன் குறைந்தபட்சத்தை எவ்வாறு கண்டுபிடிப்பது என்பதைக் காட்டும் குறியீடு துணுக்குகள் மற்றும் படங்களை உள்ளடக்கிய ஒரு நடைமுறை எடுத்துக்காட்டில் நாங்கள் கற்றுக்கொண்டவற்றைப் பயன்படுத்துகிறோம்.
சி மொழியில் MIN() மேக்ரோவின் தொடரியல்
MIN ( அ , பி )சி மொழியில் MIN() மேக்ரோவின் விளக்கம்
மேக்ரோ MIN() ஆனது 'a' மற்றும் 'b' மாறிகளுக்கு இடையே உள்ள குறைந்தபட்ச மதிப்பை வழங்குகிறது. மேக்ரோ MIN() மூலம் காட்டப்படும் வெளிப்பாடு ஒரு உண்மை/தவறு நிலையாகும், இதில் 'a' மற்றும் 'b' மாறிகளுக்கு இடையே '<' தொடர்புடைய செயல்பாடு பயன்படுத்தப்படுகிறது. 'a' என்பது 'b' ஐ விட குறைவாக இருந்தால், 'a' திரும்பும். 'b' என்பது 'a' ஐ விட குறைவாக இருந்தால், 'b' திரும்பும்.
#வரையறை MIN(a,b) (((a)<(b))?(a):(b))
மேக்ரோ MIN() அதன் உள்ளீடுகள் மற்றும் வெளியீடுகளில் உள்ள அனைத்து தரவு வகைகளிலும் இரண்டு உள்ளீட்டு மாறிகளும் எண் மதிப்புகளாக இருக்க வேண்டும் என்ற ஒரே விதியுடன் செயல்படுகிறது.
இந்த மேக்ரோ 'sys' கோப்புறையில் உள்ள 'param.h' தலைப்பில் வரையறுக்கப்பட்டுள்ளது. அதைப் பயன்படுத்த, அதை எங்கள் குறியீட்டில் பின்வருமாறு செருக வேண்டும்:
#
மேக்ரோ MIN() உடன் இரண்டு முழு எண் மாறிகளுக்கு இடையே உள்ள குறைந்தபட்சத்தை எவ்வாறு கண்டுபிடிப்பது
இந்த எடுத்துக்காட்டில், நாம் ஒரு தன்னிச்சையான மதிப்பை ஒதுக்கும் வகை int இன் 'a' மற்றும் 'b' மாறிகளை உருவாக்குகிறோம், அதில் இருந்து மேக்ரோ MIN() ஐ அழைப்பதன் மூலம் குறைந்தபட்ச மதிப்பைக் காண்கிறோம். நாம் printf() செயல்பாட்டைப் பயன்படுத்தி திரும்பிய மதிப்பை வெளியிடுகிறோம்.
இதைச் செய்ய, “stdio.h” மற்றும் “param.h” தலைப்புகளைச் சேர்த்து, வெற்றிட வகையின் முக்கிய() செயல்பாட்டைத் திறக்கிறோம். அதில், 'a' மற்றும் 'b' முழு எண்களை வரையறுத்து, அவற்றை சீரற்ற மதிப்புடன் ஒதுக்குகிறோம். முடிவைச் சேமிக்க “c” முழு எண்ணையும் நாங்கள் வரையறுக்கிறோம்.
பின்னர், நாம் மேக்ரோ MIN() ஐ அழைக்கிறோம் மற்றும் 'a' மற்றும் 'b' ஐ உள்ளீட்டு வாதங்களாகவும், 'c' ஐ வெளியீடு வாதங்களாகவும் அனுப்புகிறோம். printf() செயல்பாட்டை அழைப்பதன் மூலம் திரும்பிய முடிவைக் காண்பிக்கிறோம். இந்த உதாரணத்திற்கான குறியீடு பின்வருமாறு:
##
வெற்றிடமானது முக்கிய ( ) {
முழு எண்ணாக அ = 32 ;
முழு எண்ணாக பி = 14 ;
முழு எண்ணாக c ;
c = MIN ( அ , பி ) ;
printf ( ' \n குறைந்தபட்சம் %i \n ' , c ) ;
}
அடுத்து, இந்த குறியீட்டின் தொகுப்பு மற்றும் செயல்படுத்தலுடன் ஒரு படத்தைப் பார்க்கிறோம். நாம் பார்க்க முடியும் என, மேக்ரோ MIN() இந்த வழக்கில் 'b' மதிப்பை வழங்குகிறது.
இரட்டை வகையின் மாறிகளைப் பயன்படுத்தினால் அதே நடக்கும்.
##
வெற்றிடமானது முக்கிய ( ) {
இரட்டை அ = 3 ;
இரட்டை பி = 1 ;
இரட்டை c ;
c = MIN ( அ , பி ) ;
printf ( ' \n a மற்றும் b இரண்டின் குறைந்தபட்சம் %f ஆகும் \n ' , c ) ;
}
மிதக்கும் புள்ளி மாறிகள் கொண்ட குறைந்தபட்சம் மற்றும் அதிகபட்சம்
மேக்ரோ MIN() ஒரு பயனுள்ள செயல்பாடாகும், ஆனால் மிதக்கும் புள்ளி மதிப்புகளைப் பயன்படுத்தும் மாறிகளுக்கு அதன் பயன்பாடு பரிந்துரைக்கப்படவில்லை. இந்த வகையான மதிப்புகளின் குறைந்தபட்ச மதிப்பைக் கண்டறிய, கணித நூலகம் 'math.h' தலைப்பில் வரையறுக்கப்பட்ட செயல்பாடுகளின் தொகுப்பை வழங்குகிறது. இந்த தொகுப்பில் fmin(), fminf(), மற்றும் fminl() செயல்பாடுகள் உள்ளன. இந்த செயல்பாடுகள் ஒவ்வொன்றிற்கும் பின்வரும் தொடரியல் பார்ப்போம்:
இரட்டை fmin ( இரட்டை எக்ஸ் , இரட்டை மற்றும் ) ;மிதவை fminf ( மிதவை எக்ஸ் , மிதவை மற்றும் ) ;
நீளமானது இரட்டை fminl ( நீளமானது இரட்டை எக்ஸ் , நீளமானது இரட்டை மற்றும் ) ;
fmin() செயல்பாடு மிதக்கும் புள்ளியுடன் இரட்டை வகை (8 பைட்டுகள்) தரவுகளில் செயல்படுகிறது. fminf() செயல்பாடு வகை மிதவை (4 பைட்டுகள்) தரவுகளுடன் வேலை செய்கிறது, அதே நேரத்தில் fminl() நீண்ட இரட்டை வகை (16 பைட்டுகள்) தரவுகளுடன் வேலை செய்கிறது. மேலும், இந்த செயல்பாடுகள் எண் அல்லாத மதிப்புகளை (NaN) செயலாக்குகின்றன.
முடிவுரை
இந்த Linuxhint கட்டுரையில், இரண்டு மாறிகளுக்கு இடையே உள்ள குறைந்தபட்ச மதிப்பைக் கண்டறிய மேக்ரோ MIN() ஐப் பயன்படுத்த நீங்கள் தெரிந்து கொள்ள வேண்டிய அனைத்தையும் நாங்கள் விளக்கினோம். இந்த மேக்ரோவின் தொடரியல் மற்றும் வரையறை மற்றும் இரண்டு உள்ளீட்டு மாறிகளுக்கு இடையில் 'குறைவான' செயல்பாட்டிற்கு (<) உண்மை/தவறான நிபந்தனையைப் பயன்படுத்தும் சூத்திரத்தைப் பார்த்தோம்.
பல்வேறு வகையான தரவுகளுடன் எவ்வாறு செயல்படுவது என்பதை உங்களுக்குக் காட்ட, குறியீடு துணுக்குகள் மற்றும் படங்களைப் பயன்படுத்தி, நடைமுறை உதாரணத்திற்கு நாங்கள் கற்றுக்கொண்ட கோட்பாட்டைப் பயன்படுத்தினோம். MIN() ஐப் பயன்படுத்த பரிந்துரைக்கப்படாத மிதக்கும் புள்ளி எண்களைக் கையாள்வதற்கான பரிந்துரைக்கப்பட்ட விருப்பங்களையும் நாங்கள் உங்களுக்குக் காட்டினோம்.