C++ భాష ఏదైనా సంఖ్య యొక్క శక్తిని కనుగొనడంలో సహాయపడే “pow()” ఫంక్షన్‌ను అందిస్తుంది. మేము C++లో సంఖ్య యొక్క శక్తిని కనుగొనాలనుకున్నప్పుడు మేము ఈ ఫంక్షన్‌ను ఉపయోగిస్తాము. ఈ ఫంక్షన్ రెండు ఆర్గ్యుమెంట్‌లను తీసుకుంటుంది: మొదటి ఆర్గ్యుమెంట్ “బేస్” లేదా దాని శక్తిని మనం కనుగొనాలనుకుంటున్న సంఖ్య మరియు తదుపరి ఆర్గ్యుమెంట్ ఈ ఫంక్షన్‌లో ఘాతాంకం. ఈ “pow()” ఫంక్షన్ C++ ప్రోగ్రామింగ్‌లోని “math.h” లేదా “cmath” హెడర్ ఫైల్‌లో నిర్వచించబడింది. కొన్ని కోడ్‌లను చేద్దాం మరియు ఈ పద్ధతి C++లో వివిధ సంఖ్యల శక్తిని ఎలా గణించాలో తనిఖీ చేద్దాం.
ఉదాహరణ 1:
హెడర్ ఫైల్‌లు ముందుగా చేర్చబడ్డాయి: 'iostream' మరియు 'cmath'. 'iostream' ఇన్‌పుట్/అవుట్‌పుట్‌గా చేర్చబడింది మరియు ఇతర విధులు దానిలో నిర్వచించబడ్డాయి. ఈ హెడర్ ఫైల్‌లో నిర్వచించబడిన “pow()” ఫంక్షన్ సహాయంతో మనం సంఖ్య యొక్క శక్తిని కనుగొనవలసి ఉన్నందున “cmath” చేర్చబడింది. అప్పుడు, మనం తప్పనిసరిగా “std” నేమ్‌స్పేస్‌ని జోడించాలి కాబట్టి మనం దానిని ఫంక్షన్‌లతో విడిగా జోడించాల్సిన అవసరం లేదు.
దీని కింద, మేము “ప్రధాన()” పద్ధతిని అమలు చేస్తాము మరియు C++లో ప్రింటింగ్‌లో సహాయపడే విధంగా “cout”ని ఉపయోగించి కొంత వచనాన్ని ప్రింట్ చేస్తాము. అప్పుడు, మేము ఇక్కడ 'బేస్' అయిన మొదటి పరామితిగా '5'ని ఉంచే 'pow()' ఫంక్షన్‌ని ఉపయోగిస్తాము. అప్పుడు, మేము '3' ను రెండవ పరామితిగా ఉంచుతాము, అది ఆ సంఖ్య యొక్క 'ఘాతాంకం'. ఇప్పుడు, ఈ “pow()” ఫంక్షన్ “3” యొక్క శక్తికి పెంచబడిన “5” సంఖ్య యొక్క శక్తిని కనుగొంటుంది మరియు మేము ఈ “pow()” ఫంక్షన్‌ను “cout” లోపల ఉంచినప్పుడు శక్తి ఫలితాన్ని ప్రదర్శిస్తుంది.
కోడ్ 1:
#
#
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
కోట్ << 'మేము ఇక్కడ సంఖ్య యొక్క శక్తిని గణిస్తున్నాము!' << endl;
కోట్ << పావు ( 5 , 3 ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
“5” యొక్క సమాధానం “3”కి పెంచబడింది “125” ఇది క్రింది వాటిలో కూడా ఇవ్వబడింది. 'pow()' ఫంక్షన్ సహాయంతో మేము ఈ ఫలితాన్ని పొందుతాము.
ఉదాహరణ 2:
“iostream” అలాగే “cmath” హెడర్ ఫైల్‌లు ఇక్కడ చేర్చబడ్డాయి. అప్పుడు, 'నేమ్‌స్పేస్ std' ఉంచబడుతుంది. దీని కింద, 'ప్రధాన()' అంటారు. అప్పుడు, మేము 'విలువ', 'ఘాతం' మరియు 'ఫలితం' అనే మూడు వేరియబుల్‌లను 'పూర్ణాంక' డేటా రకంగా ప్రకటిస్తాము. ఇప్పుడు, మనం “విలువ” వేరియబుల్‌కు “6” మరియు “ఘాతాంకం” వేరియబుల్‌కు “5” ని కేటాయిస్తాము.
దీని తరువాత, మేము 'pow()' ఫంక్షన్‌ని ఉపయోగిస్తాము. అప్పుడు, మేము ఈ “పౌ()” ఫంక్షన్‌కు రెండు వేరియబుల్‌లను పాస్ చేస్తాము మరియు దాని ఫలితాన్ని “ఫలితం” వేరియబుల్‌కు కేటాయిస్తాము. దీని తర్వాత, మేము 'కౌట్'ని ఉపయోగించుకుంటాము మరియు స్టేట్‌మెంట్‌ను ముందుగా ఇక్కడ ప్రింట్ చేస్తాము. తరువాత, తదుపరి 'కౌట్' లో, మేము 'విలువ', 'ఘాతం', అలాగే 'ఫలితం' ప్రదర్శిస్తాము.
కోడ్ 2:
##
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
పూర్ణాంక విలువ, ఘాతాంకం, ఫలితం;
విలువ = 6 ;
ఘాతాంకం = 5 ;
outcome = పౌ ( విలువ, ఘాతాంకం ) ;
కోట్ << 'మేము ఇక్కడ పౌ ఫంక్షన్‌ని ఉపయోగిస్తాము!' << endl;
కోట్ << విలువ << '^' << ఘాతాంకం << ' = ' << ఫలితం;
తిరిగి 0 ;
}
అవుట్‌పుట్:
కింది వాటిలో అందించిన విధంగా “7776” అయిన “5” శక్తికి పెంచబడిన “6” సమాధానాన్ని చేరుకోవడానికి “పౌ()” ఫంక్షన్ మాకు సహాయపడుతుంది:
ఉదాహరణ 3:
ఈ కోడ్‌లో, ఫ్లోట్ నంబర్ యొక్క శక్తిని మేము కనుగొంటాము, ఇక్కడ ఘాతాంకం కూడా ఫ్లోట్ డేటా రకం. ఇక్కడ, “iostream” మరియు “cmath” హెడర్ ఫైల్‌లు చేర్చబడిన తర్వాత “namespace std” చొప్పించబడుతుంది. అప్పుడు “main()” ఫంక్షన్ అంటారు మరియు “n_value”, “e_value” మరియు “p_result” అనే మూడు వేరియబుల్స్ “float” డేటా రకంగా ప్రకటించబడతాయి. మేము ఇప్పుడు “n_value” వేరియబుల్‌ను “8.2”కి మరియు “e_value” వేరియబుల్‌ని “3.2”కి సెట్ చేసాము.
అప్పుడు, మేము “pow()” ఫంక్షన్‌ని ఉపయోగిస్తాము, దానికి రెండు వేరియబుల్స్‌ను పాస్ చేసి, ఫంక్షన్ యొక్క అవుట్‌పుట్‌ను “p_result” వేరియబుల్‌కి కేటాయిస్తాము. తరువాత, మేము స్టేట్‌మెంట్‌ను ప్రింట్ చేయడానికి “కౌట్” ఫంక్షన్‌ను ఉపయోగిస్తాము. కింది “కౌట్”లో, మేము ఈ క్రింది విధంగా “n_value”, “e_value” మరియు “p_result”ని చూపుతాము:
కోడ్ 3:
##
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
ఫ్లోట్ n_value, e_value, p_result ;
n_value = 8.2 ;
e_value = 3.2 ;
p_result = పౌ ( n_value, e_value ) ;
కోట్ << 'మేము ఇక్కడ పౌ ఫంక్షన్‌ని ఉపయోగిస్తాము!' << endl;
కోట్ << n_value << '^' << e_value << ' = ' << p_ఫలితం;
తిరిగి 0 ;
}
అవుట్‌పుట్:
'pow()' ఫంక్షన్ సహాయంతో ఫ్లోట్ సంఖ్య యొక్క ఘాతాంకం కూడా ఫ్లోట్ సంఖ్య యొక్క శక్తిని కనుగొనే ఫలితం ఇక్కడ ఉంది.
ఉదాహరణ 4:
ఈ కోడ్ డబుల్ డేటా రకంగా ఘాతాంకంతో డబుల్ సంఖ్య యొక్క శక్తిని గణిస్తుంది. ఈ సందర్భంలో, “namespace std” చేర్చబడటానికి ముందు “iostream” మరియు “cmath” హెడర్ ఫైల్‌లు చేర్చబడతాయి. కింది కోడ్ “మెయిన్()” ఫంక్షన్‌ని పిలుస్తుంది మరియు “డబుల్” డేటా రకంతో మూడు వేరియబుల్స్‌ను ప్రకటిస్తుంది మరియు అవి “d_Num”, “d_Expo” మరియు “d_PowRes”. “d_num” మరియు “d_expo” వేరియబుల్స్ ఇప్పుడు వరుసగా “2.25” మరియు “5.21”తో ప్రారంభించబడ్డాయి.
తరువాత, మేము 'pow()' ఫంక్షన్ యొక్క అవుట్‌పుట్‌ను 'd_PowRes' వేరియబుల్‌కి కేటాయిస్తాము మరియు 'pow()' ఫంక్షన్‌ని ఉపయోగిస్తాము, దానికి రెండు వేరియబుల్స్‌ను పంపుతాము. తరువాత, మేము 'కౌట్' ఫంక్షన్ ఉపయోగించి ఇక్కడ వాక్యాన్ని ప్రింట్ చేస్తాము. '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;
కోట్ << 'సంఖ్య ఇది' << d_Num << 'దాని ఘాతాంకం' << d_Expo << endl;
కోట్ << d_Num << '^' << d_Expo << ' = ' << d_PowRes;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఘాతాంకం అదే విధంగా డబుల్ సంఖ్య అయిన డబుల్ సంఖ్య యొక్క శక్తిని పొందడానికి “pow()” ఫంక్షన్‌ని ఉపయోగించడం వలన ఇది వస్తుంది.
ఉదాహరణ 5:
ఈ చివరి కోడ్‌లో, ప్రతికూల సంఖ్య ఘాతాంకం ఉన్న సంఖ్య యొక్క శక్తిని మనం కనుగొంటాము. “math.h” హెడర్ ఫైల్ “pow()” ఫంక్షన్ యొక్క నిర్వచనాన్ని కలిగి ఉన్నందున ఈ కోడ్‌లోని “iostream” హెడర్ ఫైల్‌తో పాటు “bits/stdc++.h” మరియు “math.h” హెడర్ ఫైల్‌లు ఇక్కడ చేర్చబడ్డాయి.
దీని తరువాత, మేము 'std' నేమ్‌స్పేస్‌ని జోడిస్తాము. అప్పుడు, 'ప్రధాన ()' ఇప్పుడు అంటారు. “b” వేరియబుల్ ఇక్కడ “ఫ్లోట్” డేటా రకంగా ప్రారంభించబడింది మరియు ఈ వేరియబుల్‌కు “4.87” విలువ కేటాయించబడింది. దీని కింద, “int” వేరియబుల్ “e” ప్రతికూల విలువతో ప్రారంభించబడింది, ఇది “-2”. అప్పుడు, 'ఫ్లోట్ ఫలితం' కూడా ఇక్కడ ప్రకటించబడింది. దీని క్రింద, మేము ఈ “ఫలితం” వేరియబుల్‌ని ప్రారంభిస్తాము మరియు ఈ వేరియబుల్‌కు “pow()” ఫంక్షన్‌ను కేటాయిస్తాము, దీనిలో రెండు వేరియబుల్స్ “b” మరియు “e” పారామీటర్‌లుగా ఉంచబడతాయి.
ఇక్కడ, మేము 'ఫ్లోట్' డేటా రకం యొక్క ఆధారాన్ని ఇన్సర్ట్ చేస్తాము. ఘాతాంకం ప్రతికూల పూర్ణాంకం విలువ. ఇప్పుడు, ఈ ఫంక్షన్‌ని వర్తింపజేసిన తర్వాత మనకు లభించే ఫలితం “ఫలితం” వేరియబుల్‌లో సేవ్ చేయబడుతుంది, ఇది కింద ఉన్న “కౌట్” ఉపయోగించి కింది వాటిలో ప్రదర్శించబడుతుంది.
కోడ్ 5:
##include
#include
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
పూర్ణాంక ప్రధాన ( ) {
ఫ్లోట్ బి = 4.87 ;
int e = -2 ;
ఫ్లోట్ ఫలితం;
result = పావు ( బి, ఇ ) ;
కోట్ << 'ఘాతం ఇక్కడ ప్రతికూలంగా ఉంది' << endl;
కోట్ << బి << '^' << అది << ' = ' << ఫలితం;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇది మన కోడ్‌లోని ఫ్లోట్ బేస్ నంబర్‌కు ప్రతికూల ఘాతాంకాన్ని చొప్పించిన ఫలితాన్ని అందిస్తుంది. మేము ఈ శక్తి ఫలితాన్ని 'pow()' ఫంక్షన్‌తో పొందుతాము.
ముగింపు
C++లోని “pow()” ఫంక్షన్ ఈ గైడ్‌లో ఇక్కడ అన్వేషించబడింది. మేము ఈ “pow()” ఫంక్షన్‌ని ఉపయోగించే ఏదైనా సంఖ్య యొక్క శక్తిని కంప్యూటింగ్‌గా నిర్వచించాము. మేము C++ ప్రోగ్రామింగ్‌లోని విభిన్న డేటా రకాల సంఖ్యలపై ఈ “pow()” ఫంక్షన్‌ని వర్తింపజేయడానికి అనేక ఉదాహరణలను కూడా వివరించాము. మేము ఘాతాంకం ప్రతికూల విలువ అయిన సంఖ్య యొక్క శక్తిని కూడా గణించాము మరియు ఈ గైడ్‌లోని అన్ని కోడ్‌ల అవుట్‌పుట్‌లను రెండర్ చేసాము.