C++ भाषा एक 'pow()' फ़ंक्शन प्रदान करती है जो किसी भी संख्या की शक्ति ज्ञात करने में सहायता करती है। जब हम C++ में संख्या की शक्ति ज्ञात करना चाहते हैं तो हम इस फ़ंक्शन का उपयोग करते हैं। यह फ़ंक्शन दो तर्क लेता है: पहला तर्क 'आधार' या वह संख्या है जिसकी शक्ति हम खोजना चाहते हैं और अगला तर्क इस फ़ंक्शन में घातांक है। यह 'pow()' फ़ंक्शन C++ प्रोग्रामिंग में 'math.h' या 'cmath' हेडर फ़ाइल के अंदर परिभाषित किया गया है। आइए कुछ कोड बनाएं और जांचें कि यह विधि C++ में विभिन्न संख्याओं की शक्ति की गणना कैसे करती है।
उदाहरण 1:
हेडर फ़ाइलें पहले शामिल हैं: 'iostream' और 'cmath'। 'आईओस्ट्रीम' को इनपुट/आउटपुट के रूप में शामिल किया गया है और अन्य कार्यों को इसमें परिभाषित किया गया है। 'सीमैथ' को शामिल किया गया है क्योंकि हमें 'पाउ()' फ़ंक्शन की सहायता से किसी संख्या की शक्ति का पता लगाना है जो इस हेडर फ़ाइल में परिभाषित है। फिर, हमें 'std' नेमस्पेस जोड़ना होगा ताकि हमें इसे अलग से फ़ंक्शन के साथ जोड़ने की आवश्यकता न पड़े।
इसके नीचे, हम 'मेन()' विधि को लागू करते हैं और फिर 'काउट' का उपयोग करके कुछ टेक्स्ट प्रिंट करते हैं क्योंकि यह C++ में प्रिंटिंग में सहायता करता है। फिर, हम 'पाउ()' फ़ंक्शन का उपयोग करते हैं जिसमें हम '5' को पहले पैरामीटर के रूप में रखते हैं जो यहां 'आधार' है। फिर, हम '3' को दूसरे पैरामीटर के रूप में रखते हैं जो उस संख्या का 'प्रतिपादक' है। अब, यह 'pow()' फ़ंक्शन संख्या '5' की शक्ति का पता लगाता है जिसे '3' की शक्ति तक बढ़ाया जाता है और जैसे ही हम इस 'pow()' फ़ंक्शन को 'cout' के अंदर डालते हैं, शक्ति परिणाम प्रदर्शित करता है।
कोड 1:
#शामिल करें
#शामिल करें <सीमैथ>
नेमस्पेस एसटीडी का उपयोग करना;
मुख्य प्रवेश बिंदु ( ) {
अदालत << 'हम यहां संख्या की शक्ति की गणना कर रहे हैं!' << एंडल;
अदालत << पाउ ( 5 , 3 ) ;
वापस करना 0 ;
}
आउटपुट:
'5' का घात '3' तक बढ़ाने पर उत्तर '125' आता है जिसे निम्नलिखित में भी प्रस्तुत किया गया है। हमें यह परिणाम 'pow()' फ़ंक्शन की सहायता से मिलता है।
उदाहरण 2:
'iostream' के साथ-साथ 'cmath' हेडर फ़ाइलें यहां शामिल हैं। फिर, 'नेमस्पेस एसटीडी' रखा गया है। इसके नीचे, “main()” कहा जाता है। फिर, हम तीन चर घोषित करते हैं जो 'मूल्य', 'प्रतिपादक' और 'परिणाम' को 'int' डेटा प्रकार के रूप में घोषित करते हैं। अब, हम 'मान' वेरिएबल को '6' और 'एक्सपोनेंट' वेरिएबल को '5' असाइन करते हैं।
इसके बाद, हम 'pow()' फ़ंक्शन का उपयोग करते हैं। फिर, हम दोनों वेरिएबल्स को इस 'pow()' फ़ंक्शन में पास करते हैं और इसका परिणाम 'परिणाम' वेरिएबल को निर्दिष्ट करते हैं। इसके बाद, हम 'काउट' का उपयोग करते हैं और पहले यहां स्टेटमेंट प्रिंट करते हैं। फिर, अगले 'काउट' में, हम 'मूल्य', 'प्रतिपादक', साथ ही 'परिणाम' प्रदर्शित करते हैं।
कोड 2:
#शामिल करें#शामिल करें <सीमैथ>
नेमस्पेस एसटीडी का उपयोग करना;
मुख्य प्रवेश बिंदु ( ) {
पूर्णांक मूल्य, प्रतिपादक, परिणाम;
मूल्य = 6 ;
प्रतिपादक = 5 ;
परिणाम = पाउ ( मूल्य, घातांक ) ;
अदालत << 'हम यहां पाउ फ़ंक्शन का उपयोग करते हैं!' << एंडल;
अदालत << कीमत << '^' << प्रतिपादक << ' = ' << नतीजा;
वापस करना 0 ;
}
आउटपुट:
'पाउ()' फ़ंक्शन हमें '6' के उत्तर तक पहुंचने में मदद करता है जिसे '5' की शक्ति तक बढ़ाया जाता है जो कि '7776' है जैसा कि निम्नलिखित में प्रस्तुत किया गया है:
उदाहरण 3:
इस कोड में, हम फ्लोट नंबर की शक्ति पाएंगे जहां घातांक भी फ्लोट डेटा प्रकार है। यहां, 'iostream' और 'cmath' हेडर फ़ाइलों को शामिल करने के बाद 'नेमस्पेस std' डाला गया है। फिर 'मुख्य()' फ़ंक्शन को कॉल किया जाता है, और 'n_value', 'e_value', और 'p_result' नामक तीन चर को 'फ्लोट' डेटा प्रकार के रूप में घोषित किया जाता है। अब हम 'n_value' वेरिएबल को '8.2' पर और 'e_value' वेरिएबल को '3.2' पर सेट करते हैं।
फिर, हम 'pow()' फ़ंक्शन का उपयोग करते हैं, इसमें दोनों वेरिएबल पास करते हैं और फ़ंक्शन के आउटपुट को 'p_result' वेरिएबल पर असाइन करते हैं। इसके बाद, हम स्टेटमेंट को प्रिंट करने के लिए 'काउट' फ़ंक्शन का उपयोग करते हैं। निम्नलिखित 'cout' में, हम 'n_value', 'e_value', और 'p_result' को इस प्रकार दिखाएंगे:
कोड 3:
#शामिल करें#शामिल करें <सीमैथ>
नेमस्पेस एसटीडी का उपयोग करना;
मुख्य प्रवेश बिंदु ( ) {
फ़्लोट n_value, e_value, p_result ;
n_मान = 8.2 ;
ई_वैल्यू = 3.2 ;
p_परिणाम = पाउ ( n_मान, e_मान ) ;
अदालत << 'हम यहां पाउ फ़ंक्शन का उपयोग करते हैं!' << एंडल;
अदालत << n_मूल्य << '^' << ई_वैल्यू << ' = ' << p_परिणाम;
वापस करना 0 ;
}
आउटपुट:
यहां वह परिणाम है जिसमें हम 'पाउ()' फ़ंक्शन की सहायता से फ्लोट नंबर की शक्ति पाते हैं जिसका घातांक भी फ्लोट नंबर है।
उदाहरण 4:
यह कोड दोहरे डेटा प्रकार के रूप में घातांक के साथ दोहरे नंबर की शक्ति की गणना करता है। इस मामले में, 'iostream' और 'cmath' हेडर फ़ाइलें 'नेमस्पेस std' शामिल करने से पहले शामिल की जाती हैं। निम्नलिखित कोड 'मुख्य()' फ़ंक्शन को कॉल करता है और 'डबल' डेटा प्रकार के साथ तीन चर घोषित करता है और ये 'd_Num', 'd_Expo' और 'd_PowRes' हैं। 'd_num' और 'd_expo' वेरिएबल्स को अब क्रमशः '2.25' और '5.21' के साथ प्रारंभ किया गया है।
इसके बाद, हम 'pow()' फ़ंक्शन के आउटपुट को 'd_PowRes' वेरिएबल पर असाइन करते हैं और दोनों वेरिएबल्स को इसमें पास करते हुए, 'pow()' फ़ंक्शन का उपयोग करते हैं। इसके बाद, हम 'काउट' फ़ंक्शन का उपयोग करके वाक्य को यहां प्रिंट करते हैं। 'd_Num', 'd_Expo', और 'd_PowRes' आगामी 'cout' में प्रदर्शित होते हैं।
कोड 4:
#शामिल करें#शामिल करें <सीमैथ>
नेमस्पेस एसटीडी का उपयोग करना;
मुख्य प्रवेश बिंदु ( ) {
डबल d_Num, d_Expo, d_PowRes;
d_संख्या = 2.25 ;
d_एक्सपो = 5.21 ;
d_PowRes = पाउ ( d_Num, d_Expo ) ;
अदालत << 'हम यहां पाउ फ़ंक्शन का उपयोग करते हैं!' << एंडल;
अदालत << 'संख्या है ' << d_Num << ' इसका प्रतिपादक है ' << d_एक्सपो << एंडल;
अदालत << d_Num << '^' << d_एक्सपो << ' = ' << d_PowRes;
वापस करना 0 ;
}
आउटपुट:
यह एक दोहरी संख्या की शक्ति प्राप्त करने के लिए 'pow()' फ़ंक्शन का उपयोग करने के परिणामस्वरूप होता है जिसका घातांक भी एक दोहरी संख्या है।
उदाहरण 5:
इस अंतिम कोड में, हम उस संख्या की घात ज्ञात करेंगे जिसका घातांक ऋणात्मक संख्या है। इस कोड में 'बिट्स/stdc++.h' और 'math.h' हेडर फ़ाइलें 'iostream' हेडर फ़ाइल के साथ शामिल हैं क्योंकि 'math.h' हेडर फ़ाइल में 'pow()' फ़ंक्शन की परिभाषा शामिल है।
इसके बाद, हम “std” नेमस्पेस जोड़ते हैं। फिर, अब 'मुख्य()' कहा जाता है। यहां 'बी' वेरिएबल को 'फ्लोट' डेटा प्रकार के रूप में प्रारंभ किया गया है और इस वेरिएबल को '4.87' मान निर्दिष्ट किया गया है। इसके नीचे, 'int' वेरिएबल 'e' को नकारात्मक मान के साथ प्रारंभ किया गया है जो कि '-2' है। फिर, 'फ्लोट परिणाम' भी यहां घोषित किया जाता है। इसके नीचे, हम इस 'परिणाम' वेरिएबल को प्रारंभ करते हैं और इस वेरिएबल को 'pow()' फ़ंक्शन असाइन करते हैं जिसमें दोनों वेरिएबल 'बी' और 'ई' को पैरामीटर के रूप में रखा जाता है।
यहां, हम 'फ्लोट' डेटा प्रकार का आधार सम्मिलित करते हैं। घातांक ऋणात्मक पूर्णांक मान है। अब, इस फ़ंक्शन को लागू करने के बाद हमें जो परिणाम मिलता है वह 'परिणाम' वेरिएबल में सहेजा जाता है जिसे इसके नीचे 'काउट' का उपयोग करके प्रदर्शित किया जाता है।
कोड 5:
#शामिल करें#शामिल<बिट्स/stdc++.h>
#शामिल<गणित.h>
नेमस्पेस एसटीडी का उपयोग करना;
मुख्य प्रवेश बिंदु ( ) {
फ्लोट बी = 4.87 ;
पूर्णांक ई = -2 ;
फ़्लोट परिणाम;
परिणाम = पाउ ( होना ) ;
अदालत << 'यहाँ प्रतिपादक नकारात्मक है' << एंडल;
अदालत << बी << '^' << यह है << ' = ' << परिणाम;
वापस करना 0 ;
}
आउटपुट:
यह उस परिणाम को प्रस्तुत करता है जहां हम अपने कोड में फ्लोट बेस नंबर पर नकारात्मक घातांक डालते हैं। हमें यह शक्ति परिणाम 'pow()' फ़ंक्शन से मिलता है।
निष्कर्ष
इस गाइड में C++ में 'pow()' फ़ंक्शन का पता लगाया गया है। हमने इसे किसी भी संख्या की शक्ति की गणना के रूप में परिभाषित किया है जहां हम इस 'पाउ()' फ़ंक्शन का उपयोग करते हैं। हमने C++ प्रोग्रामिंग में विभिन्न डेटा प्रकारों की संख्या पर इस 'pow()' फ़ंक्शन को लागू करने के कई उदाहरण भी दिए हैं। हमने उस संख्या की शक्ति की भी गणना की जहां घातांक नकारात्मक मान है और इस गाइड में सभी कोड के आउटपुट प्रस्तुत किए हैं।