C++లో పౌకు నిర్వచించబడని సూచనను పరిష్కరించడం
ఈ దోష సందేశాన్ని పరిష్కరించేటప్పుడు, మేము మా కోడ్‌లో “pow()” ఫంక్షన్ ప్రకటించబడిన హెడర్ ఫైల్‌ను జోడిస్తాము. ఇది మా కోడ్ నుండి లోపాన్ని తొలగిస్తుంది. “pow()” ఫంక్షన్ కోసం ఉపయోగించబడే హెడర్ ఫైల్‌లు:
- #
హెడర్ ఫైల్‌ను చేర్చండి - #include
హెడర్ ఫైల్ - #include
హెడర్ ఫైల్
ఈ లోపం ఎలా సంభవిస్తుందో మరియు C++ ప్రోగ్రామింగ్‌లో ఈ లోపాన్ని ఎలా పరిష్కరించాలో చూపే కొన్ని కోడ్‌లు ఇక్కడ ఉన్నాయి.
ఉదాహరణ 1:
మా మొదటి ఉదాహరణలో, ఇన్‌పుట్ మరియు అవుట్‌పుట్ టాస్క్‌లను చేయడంలో సహాయపడే “#include
దీని తరువాత, మన C++ కోడ్ యొక్క ప్రారంభాన్ని నిర్వచించడానికి ఉపయోగించబడే “int main()” ఫంక్షన్‌ని ఇక్కడ పిలుస్తాము. ఇప్పుడు, ఈ ఫంక్షన్‌లో, డిస్‌ప్లే స్క్రీన్‌పై ఇచ్చిన సమాచారాన్ని ప్రింట్ చేయడంలో సహాయపడే “కౌట్<<” స్టేట్‌మెంట్‌ను మేము ఉపయోగిస్తాము. మా పాయింటర్‌ని కొత్త లైన్‌కి మార్చడానికి “<< endl” స్టేట్‌మెంట్ ఉపయోగించబడుతుంది.
దీని తరువాత, 'pow()' ఫంక్షన్ ఉపయోగించబడుతుంది, దీనిలో మనం రెండు పారామితులను పాస్ చేయాలి: బేస్ మరియు ఎక్స్పోనెంట్. ఇక్కడ, మేము '10, 4'ని జోడిస్తాము, దీనిలో '10' మూల సంఖ్య మరియు '4' ఘాతాంకం. ఈ కోడ్ చివరిలో, మేము 'రిటర్న్ 0' అనే మరో స్టేట్‌మెంట్‌ను ఇన్సర్ట్ చేస్తాము.
కోడ్ 1:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
కోట్ << 'పవర్ ఫంక్షన్ ఇక్కడ ఉపయోగించబడుతుంది' ;
కోట్ << endl << endl ;
కోట్ << పావు ( 10 , 4 ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
కోడ్‌ను పూర్తి చేసిన తర్వాత, మేము దానిని కంపైల్ చేసి రన్ చేయాలి. మేము మునుపటి కోడ్‌ను కంపైల్ చేసినప్పుడు, “ఈ స్కోప్‌లో పౌ ప్రకటించబడలేదు” అని పేర్కొన్న దోష సందేశం కనిపిస్తుంది. ఈ 'pow()' ఫంక్షన్ డిక్లేర్ చేయబడిన హెడర్ ఫైల్‌ను మేము జోడించనందున ఈ లోపం కనిపిస్తుంది. ఈ లోపాన్ని పరిష్కరించడానికి, మనం ముందుగా పేర్కొన్న ఏదైనా హెడర్ ఫైల్‌లను చొప్పించాలి.
ఇప్పుడు, ఫలితాన్ని పొందడానికి మనం ఈ లోపాన్ని పరిష్కరించాలి. దీని కోసం, మేము కోడ్‌లో కొద్దిగా మార్పులు చేసాము. అదే కోడ్‌లో, మేము '' హెడర్ ఫైల్ తర్వాత '#include' హెడర్ ఫైల్‌ను జోడిస్తాము. ఈ హెడర్ ఫైల్‌లో “pow()” ఫంక్షన్ ప్రకటించబడినందున ఇది మునుపటి కోడ్ యొక్క లోపాన్ని తీసివేయడంలో సహాయపడుతుంది.
నవీకరించబడిన కోడ్ 1:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
కోట్ << 'పవర్ ఫంక్షన్ ఇక్కడ ఉపయోగించబడుతుంది' ;
కోట్ << endl << endl ;
కోట్ << పావు ( 10 , 4 ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్ :
ఈ నవీకరించబడిన కోడ్ ఇప్పుడు కంపైల్ చేయబడింది మరియు విజయవంతంగా అమలవుతోంది మరియు మేము కోడ్ అవుట్‌పుట్‌ను పొందుతాము. మునుపటి కోడ్ యొక్క లోపం ఇప్పుడు తీసివేయబడింది మరియు సంకలనం తర్వాత క్రింది ఫలితం కనిపిస్తుంది:
ఉదాహరణ 2:
ఇక్కడ, మనకు C++లో మరొక ఉదాహరణ ఉంది. “
కోడ్ 2:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
కోట్ << 'మేము ఇక్కడ C++ ప్రోగ్రామింగ్‌లో సంఖ్య యొక్క శక్తిని కనుగొంటాము.' << endl << endl ;
int ఒకదానిపై, ఎక్స్ , ఫలితం ;
ఒకదానిపై = 25 ;
ఎక్స్ = 2 ;
ఫలితం = పావు ( ఒకదానిపై, ఎక్స్ ) ;
కోట్ << 'సంఖ్య యొక్క శక్తి =' << ఫలితం ;
కోట్ << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్ :
ఇప్పుడు, ఈ కొత్త కోడ్ మునుపటి ఉదాహరణ వలె అదే దోష సందేశాన్ని చూపుతుంది. కారణం ఏమిటంటే, మేము ఈ “pow()” ఫంక్షన్‌ని పొందగలిగే హెడర్ ఫైల్‌ను ఇన్సర్ట్ చేయనందున ఇది కూడా అదే.
ఇప్పుడు, మనము 'cmath' హెడర్ ఫైల్ అయిన మా కోడ్‌కి హెడర్ ఫైల్‌ని జోడిస్తాము. ఈ హెడర్ ఫైల్ మన కోడ్ యొక్క “pow()” ఫంక్షన్‌ని పొందడానికి C++ ప్రోగ్రామింగ్‌లో ఉపయోగించబడుతుంది. “#include” హెడర్ ఫైల్‌ను జోడించిన తర్వాత, మన కోడ్ యొక్క అవసరమైన అవుట్‌పుట్‌ను పొందుతాము.
ఉదాహరణ 3:
ఇప్పుడు, మనకు మరో ఉదాహరణ ఉంది. ఇక్కడ, “main()” ఫంక్షన్ తర్వాత, మేము “4.5”తో “లాంగ్ డబుల్” డేటా రకం యొక్క “base_num”ని డిక్లేర్ చేస్తాము మరియు ప్రారంభించాము. అప్పుడు, మేము “పూర్ణాంకం” డేటా రకం యొక్క “expo_num”ని “-2”తో కూడా ప్రకటిస్తాము మరియు ప్రారంభిస్తాము. మేము 'పొడవైన డబుల్' డేటాటైప్‌లో ఉన్న 'ఫలితం_1' పేరు యొక్క మరొక వేరియబుల్‌ను కూడా ప్రకటిస్తాము.
ఇప్పుడు, “ఫలితం_1” వేరియబుల్‌ని ప్రారంభించేందుకు “pow()” ఫంక్షన్‌ని ఉపయోగిస్తాము మరియు ఈ ఫంక్షన్‌కి “base_num” మరియు “expo_num”ని పాస్ చేస్తాము. దీని తరువాత, మేము 'కౌట్' ఆదేశాన్ని ఉపయోగించి ఫలితాన్ని ప్రింట్ చేస్తాము. ఇప్పుడు, మేము “ఫ్లోట్” డేటా రకంతో “f_baseNum” మరియు “f_expoNum” అనే మరో రెండు వేరియబుల్స్ డిక్లేర్ చేస్తాము మరియు ప్రారంభించాము. మేము వాటిని వరుసగా '-9.2' మరియు '5'తో ప్రారంభిస్తాము. అప్పుడు, మేము “ఫలితం_2”ని “డబుల్” డేటా రకంగా ప్రకటిస్తాము. మేము ఇప్పుడు “f_baseNum” మరియు “f_expoNum”లో పాస్ చేస్తూ “pow()” పద్ధతిని ఉపయోగించి “result_22” వేరియబుల్‌ని ప్రారంభిస్తాము. తరువాత, ఫలితాన్ని ముద్రించడానికి మేము 'కౌట్' ఆదేశాన్ని ఉపయోగిస్తాము.
కోడ్ 3:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
పొడవు రెట్టింపు ఆధార_సంఖ్య = 4.5 ;
int ఎక్స్పో_నమ్ = - 2 ;
పొడవు రెట్టింపు ఫలితం_1 ;
ఫలితం_1 = పావు ( బేస్_నమ్, ఎక్స్పో_నమ్ ) ;
కోట్ << 'ఇక్కడ బేస్_నమ్ దీర్ఘ డబుల్‌లో ఉంది మరియు ఎక్స్పో_నమ్ పూర్ణాంకం రకంలో ఉంది' << endl << endl ;
కోట్ << ఆధార_సంఖ్య << '^' << ఎక్స్పో_నమ్ << ' = ' << ఫలితం_1 << endl << endl ;
తేలుతుంది f_baseNum = - 9.2 , f_expoNum = 5 ;
రెట్టింపు ఫలితం_2 ;
ఫలితం_2 = పావు ( f_baseNum, f_expoNum ) ;
కోట్ << 'ఇక్కడ f_baseNum ఫ్లోట్‌లో ఉంది మరియు f_expoNum డబుల్ టైప్‌లో ఉంది' << endl << endl ;
కోట్ << f_baseNum << '^' << f_expoNum << ' = ' << ఫలితం_2 ;
తిరిగి 0 ;
}
అవుట్‌పుట్ :
ఈ కోడ్‌ను కంపైల్ చేసిన తర్వాత, పవర్ ఫంక్షన్ ఈ స్కోప్‌లో ప్రకటించబడలేదని చెప్పే దోష సందేశం మాకు వస్తుంది. ఈ ఫంక్షన్ డిక్లేర్ చేయబడిన హెడర్ ఫైల్‌ను మనం కోల్పోయామని దీని అర్థం.
లోపం ఇప్పుడు “
దీన్ని ఉంచిన తర్వాత, కోడ్ విజయవంతంగా పాటించబడుతుంది మరియు ఇక్కడ కూడా చూపబడిన మా కోడ్ అవుట్‌పుట్‌ను మేము పొందుతాము.
మేము '
“
ముగింపు
ఈ కథనంలో, C++ ప్రోగ్రామింగ్‌లో “పౌకు నిర్వచించబడని సూచన” లేదా “ఈ స్కోప్‌లో పౌ ప్రకటించబడలేదు” లోపం కూడా వివరంగా చర్చించబడింది. విజయవంతమైన కోడ్ సంకలనం కోసం లోపాన్ని తొలగించడంలో సహాయపడే మార్గాలు లేదా హెడర్ ఫైల్‌లను కూడా మేము అన్వేషించాము. మేము దోష సందేశాన్ని మరియు ఆ దోష సందేశాన్ని తీసివేసిన తర్వాత కోడ్ యొక్క ఫలితాన్ని చూపిన ఉదాహరణలను మేము ప్రదర్శించాము.