C++ மொழியானது 'pow()' செயல்பாட்டை வழங்குகிறது, இது எந்த எண்ணின் சக்தியையும் கண்டறிய உதவுகிறது. C++ இல் எண்ணின் சக்தியைக் கண்டறிய விரும்பும் போது இந்தச் செயல்பாட்டைப் பயன்படுத்துகிறோம். இந்த செயல்பாடு இரண்டு வாதங்களை எடுக்கும்: முதல் வாதம் 'அடிப்படை' அல்லது அதன் சக்தியை நாம் கண்டுபிடிக்க விரும்பும் எண் மற்றும் அடுத்த வாதம் இந்த செயல்பாட்டில் அடுக்கு ஆகும். இந்த “pow()” செயல்பாடு C++ நிரலாக்கத்தில் “math.h” அல்லது “cmath” தலைப்புக் கோப்பில் வரையறுக்கப்படுகிறது. சில குறியீடுகளைச் செய்து, இந்த முறை C++ இல் உள்ள வெவ்வேறு எண்களின் சக்தியை எவ்வாறு கணக்கிடுகிறது என்பதைப் பார்க்கலாம்.
எடுத்துக்காட்டு 1:
தலைப்பு கோப்புகள் முதலில் சேர்க்கப்பட்டுள்ளன: 'iostream' மற்றும் 'cmath'. 'iostream' உள்ளீடு/வெளியீடு என சேர்க்கப்பட்டுள்ளது மற்றும் பிற செயல்பாடுகள் அதில் வரையறுக்கப்பட்டுள்ளன. இந்த தலைப்புக் கோப்பில் வரையறுக்கப்பட்டுள்ள 'pow()' செயல்பாட்டின் உதவியுடன் எண்ணின் சக்தியைக் கண்டறிய வேண்டியிருப்பதால், 'cmath' சேர்க்கப்பட்டுள்ளது. பின்னர், நாம் 'std' பெயர்வெளியைச் சேர்க்க வேண்டும், எனவே அதை தனித்தனியாக செயல்பாடுகளுடன் சேர்க்க வேண்டியதில்லை.
இதற்குக் கீழே, “முதன்மை()” முறையைப் பயன்படுத்துகிறோம், பின்னர் “cout” ஐப் பயன்படுத்தி சில உரையை அச்சிடுகிறோம், அது C++ இல் அச்சிட உதவுகிறது. பின்னர், 'pow()' செயல்பாட்டைப் பயன்படுத்துகிறோம், அதில் '5' ஐ முதல் அளவுருவாக வைக்கிறோம், இது இங்கே 'அடிப்படை' ஆகும். பின்னர், அந்த எண்ணின் 'அதிவேகம்' என்ற இரண்டாவது அளவுருவாக '3' ஐ வைக்கிறோம். இப்போது, இந்த 'pow()' சார்பு '5' என்ற எண்ணின் சக்தியைக் கண்டறிந்து, '3' இன் சக்தியாக உயர்த்தப்பட்டு, இந்த 'pow()' செயல்பாட்டை 'cout' க்குள் வைக்கும்போது சக்தி முடிவைக் காட்டுகிறது.
குறியீடு 1:
#
#
பெயர்வெளி std ஐப் பயன்படுத்துதல்;
முழு எண்ணாக ( ) {
கூட் << 'இங்கே எண்ணின் சக்தியைக் கணக்கிடுகிறோம்!' << endl;
கூட் << பவ் ( 5 , 3 ) ;
திரும்ப 0 ;
}
வெளியீடு:
'5' இன் பதில் '3' க்கு உயர்த்தப்பட்டது '125' ஆகும், இது பின்வருவனவற்றிலும் வழங்கப்படுகிறது. 'pow()' செயல்பாட்டின் உதவியுடன் இந்த முடிவைப் பெறுகிறோம்.
எடுத்துக்காட்டு 2:
'iostream' மற்றும் 'cmath' தலைப்பு கோப்புகள் இங்கே சேர்க்கப்பட்டுள்ளன. பின்னர், 'நேம்ஸ்பேஸ் std' வைக்கப்படுகிறது. இதன் கீழ், 'முக்கிய()' என்று அழைக்கப்படுகிறது. பின்னர், 'மதிப்பு', 'அதிவேகம்' மற்றும் 'விளைவு' ஆகிய மூன்று மாறிகளை 'int' தரவு வகையாக அறிவிக்கிறோம். இப்போது, 'மதிப்பு' மாறிக்கு '6' மற்றும் 'அடுக்கு' மாறிக்கு '5' ஐ ஒதுக்குகிறோம்.
இதற்குப் பிறகு, 'pow()' செயல்பாட்டைப் பயன்படுத்துகிறோம். பின்னர், இந்த 'pow()' செயல்பாட்டிற்கு இரண்டு மாறிகளையும் கடந்து, அதன் முடிவை 'விளைவு' மாறிக்கு ஒதுக்குகிறோம். இதற்குப் பிறகு, நாங்கள் 'கவுட்' ஐப் பயன்படுத்தி, அறிக்கையை முதலில் இங்கே அச்சிடுகிறோம். பின்னர், அடுத்த 'கவுட்' இல், 'மதிப்பு', 'அதிவேகம்' மற்றும் 'விளைவு' ஆகியவற்றைக் காண்பிக்கிறோம்.
குறியீடு 2:
##
பெயர்வெளி std ஐப் பயன்படுத்துதல்;
முழு எண்ணாக ( ) {
முழு மதிப்பு, அடுக்கு, விளைவு;
மதிப்பு = 6 ;
அடுக்கு = 5 ;
விளைவு = பவ் ( மதிப்பு, அடுக்கு ) ;
கூட் << 'நாங்கள் இங்கே பவ் செயல்பாட்டைப் பயன்படுத்துகிறோம்!' << endl;
கூட் << மதிப்பு << '^' << அடுக்கு << ' = ' << விளைவு;
திரும்ப 0 ;
}
வெளியீடு:
பின்வருவனவற்றில் வழங்கப்பட்டுள்ளபடி “7776” ஆக இருக்கும் “5” இன் சக்திக்கு உயர்த்தப்பட்ட “6” இன் பதிலைப் பெற “pow()” செயல்பாடு உதவுகிறது:
எடுத்துக்காட்டு 3:
இந்தக் குறியீட்டில், மிதவை எண்ணின் சக்தியைக் கண்டுபிடிப்போம், அங்கு அதிவேகமானது மிதவை தரவு வகையாகும். இங்கே, 'iostream' மற்றும் 'cmath' தலைப்பு கோப்புகள் சேர்க்கப்பட்ட பிறகு 'namespace std' செருகப்படுகிறது. “main()” செயல்பாடு பின்னர் அழைக்கப்படுகிறது, மேலும் “n_value”, “e_value” மற்றும் “p_result” என பெயரிடப்பட்ட மூன்று மாறிகள் “float” தரவு வகையாக அறிவிக்கப்படும். இப்போது “n_value” மாறியை “8.2” என்றும் “e_value” மாறியை “3.2” என்றும் அமைக்கிறோம்.
பின்னர், “pow()” செயல்பாட்டைப் பயன்படுத்துகிறோம், அதற்கு இரண்டு மாறிகளையும் அனுப்புகிறோம் மற்றும் செயல்பாட்டின் வெளியீட்டை “p_result” மாறிக்கு ஒதுக்குகிறோம். அடுத்து, அறிக்கையை அச்சிட 'cout' செயல்பாட்டைப் பயன்படுத்துகிறோம். பின்வரும் “cout” இல், “n_value”, “e_value” மற்றும் “p_result” ஆகியவற்றைப் பின்வருமாறு காட்டுவோம்:
குறியீடு 3:
##
பெயர்வெளி std ஐப் பயன்படுத்துதல்;
முழு எண்ணாக ( ) {
மிதவை n_மதிப்பு, e_மதிப்பு, p_result ;
n_மதிப்பு = 8.2 ;
e_value = 3.2 ;
p_result = பவ் ( n_மதிப்பு, ஈ_மதிப்பு ) ;
கூட் << 'நாங்கள் இங்கே பவ் செயல்பாட்டைப் பயன்படுத்துகிறோம்!' << endl;
கூட் << n_மதிப்பு << '^' << ஈ_மதிப்பு << ' = ' << ப_முடிவு;
திரும்ப 0 ;
}
வெளியீடு:
'pow()' செயல்பாட்டின் உதவியுடன் ஃப்ளோட் எண்ணின் அதிவேகமும் மிதவை எண்ணின் சக்தியைக் கண்டறியும் முடிவு இங்கே உள்ளது.
எடுத்துக்காட்டு 4:
இந்தக் குறியீடு இரட்டை எண்ணின் சக்தியை அதிவேகத்துடன் இரட்டை தரவு வகையாகக் கணக்கிடுகிறது. இந்த வழக்கில், 'Iostream' மற்றும் 'cmath' தலைப்பு கோப்புகள் 'namespace std' சேர்க்கப்படுவதற்கு முன் சேர்க்கப்படும். பின்வரும் குறியீடு 'main()' செயல்பாட்டை அழைக்கிறது மற்றும் 'இரட்டை' தரவு வகையுடன் மூன்று மாறிகளை அறிவிக்கிறது மற்றும் இவை 'd_Num', 'd_Expo' மற்றும் 'd_PowRes' ஆகும். “d_num” மற்றும் “d_expo” மாறிகள் இப்போது முறையே “2.25” மற்றும் “5.21” உடன் துவக்கப்பட்டுள்ளன.
அடுத்து, “pow()” செயல்பாட்டின் வெளியீட்டை “d_PowRes” மாறிக்கு ஒதுக்கி, “pow()” செயல்பாட்டைப் பயன்படுத்துகிறோம், இரண்டு மாறிகளையும் அதற்கு அனுப்புகிறோம். அடுத்து, 'cout' செயல்பாட்டைப் பயன்படுத்தி இங்கே வாக்கியத்தை அச்சிடுகிறோம். 'd_Num', 'd_Expo' மற்றும் 'd_PowRes' ஆகியவை அடுத்தடுத்த 'கவுட்' இல் காட்டப்படும்.
குறியீடு 4:
##
பெயர்வெளி std ஐப் பயன்படுத்துதல்;
முழு எண்ணாக ( ) {
இரட்டை d_Num, d_Expo , d_PowRes ;
d_Number = 2.25 ;
d_Expo = 5.21 ;
d_PowRes = பவ் ( d_Num, d_Expo ) ;
கூட் << 'நாங்கள் இங்கே பவ் செயல்பாட்டைப் பயன்படுத்துகிறோம்!' << endl;
கூட் << 'எண்' << டி_எண் << 'அதன் அடுக்கு' << டி_எக்ஸ்போ << endl;
கூட் << டி_எண் << '^' << டி_எக்ஸ்போ << ' = ' << d_PowRes;
திரும்ப 0 ;
}
வெளியீடு:
இரட்டை எண்ணின் சக்தியைப் பெறுவதற்கு, 'pow()' செயல்பாட்டைப் பயன்படுத்துவதன் மூலம், அதிவேகம் இரட்டை எண்ணாக இருக்கும்.
எடுத்துக்காட்டு 5:
இந்த கடைசி குறியீட்டில், எதிர் எண்ணாக இருக்கும் ஒரு எண்ணின் சக்தியைக் கண்டுபிடிப்போம். 'math.h' தலைப்புக் கோப்பில் 'pow()' செயல்பாட்டின் வரையறை இருப்பதால், 'bits/stdc++.h' மற்றும் 'math.h' தலைப்புக் கோப்புகள் இந்தக் குறியீட்டில் உள்ள 'iostream' தலைப்புக் கோப்புடன் இங்கே சேர்க்கப்பட்டுள்ளன.
இதற்குப் பிறகு, 'std' பெயர்வெளியைச் சேர்க்கிறோம். பின்னர், 'முக்கிய()' இப்போது அழைக்கப்படுகிறது. 'b' மாறி இங்கு 'float' தரவு வகையாக துவக்கப்படுகிறது மற்றும் இந்த மாறிக்கு '4.87' மதிப்பு ஒதுக்கப்படுகிறது. இதன் அடியில், “int” மாறி “e” ஆனது “-2” என்ற எதிர்மறை மதிப்புடன் துவக்கப்படுகிறது. பின்னர், 'ஃப்ளோட் ரிசல்ட்' இங்கேயும் அறிவிக்கப்படுகிறது. இதற்குக் கீழே, இந்த “முடிவு” மாறியைத் துவக்கி, “b” மற்றும் “e” ஆகிய மாறிகள் அளவுருக்களாக வைக்கப்பட்டுள்ள இந்த மாறிக்கு “pow()” செயல்பாட்டை ஒதுக்குகிறோம்.
இங்கே, 'ஃப்ளோட்' தரவு வகையின் அடிப்படையைச் செருகுவோம். அடுக்கு என்பது எதிர்மறை முழு எண் மதிப்பு. இப்போது, இந்தச் செயல்பாட்டைப் பயன்படுத்திய பிறகு நாம் பெறும் விளைவு 'முடிவு' மாறியில் சேமிக்கப்படுகிறது, இது கீழே உள்ள 'கவுட்' ஐப் பயன்படுத்தி கீழே காட்டப்படும்.
குறியீடு 5:
##உள்
#include
பெயர்வெளி std ஐப் பயன்படுத்துதல்;
முழு எண்ணாக ( ) {
மிதவை b = 4.87 ;
int e = -2 ;
மிதவை முடிவு;
முடிவு = பவ் ( இரு ) ;
கூட் << 'அடுக்கு இங்கே எதிர்மறையாக உள்ளது' << endl;
கூட் << பி << '^' << இது << ' = ' << விளைவாக;
திரும்ப 0 ;
}
வெளியீடு:
இது நமது குறியீட்டில் உள்ள மிதவை அடிப்படை எண்ணுக்கு எதிர்மறை அடுக்குகளைச் செருகும் முடிவை வழங்குகிறது. 'pow()' செயல்பாட்டின் மூலம் இந்த சக்தி முடிவைப் பெறுகிறோம்.
முடிவுரை
C++ இல் உள்ள “pow()” செயல்பாடு இந்த வழிகாட்டியில் இங்கு ஆராயப்படுகிறது. இந்த 'pow()' செயல்பாட்டைப் பயன்படுத்தும் எந்த எண்ணின் சக்தியையும் கணக்கிடுவதாக நாங்கள் வரையறுத்துள்ளோம். C++ நிரலாக்கத்தில் வெவ்வேறு தரவு வகைகளின் எண்களில் இந்த “pow()” செயல்பாட்டைப் பயன்படுத்துவதற்கான பல உதாரணங்களையும் நாங்கள் விளக்கியுள்ளோம். அதிவேகம் எதிர்மறை மதிப்பாக இருக்கும் எண்ணின் சக்தியையும் கணக்கிட்டு, இந்த வழிகாட்டியில் உள்ள அனைத்து குறியீட்டின் வெளியீடுகளையும் வழங்கினோம்.