C++ भाषा काम करने के लिए कई डेटा प्रकार प्रदान करती है जैसे 'int', 'फ्लोट', 'चार', 'डबल', 'लॉन्ग डबल', आदि। 'डबल' डेटा प्रकार का उपयोग उन संख्याओं के लिए किया जाता है जिनमें दशमलव बिंदु ऊपर होते हैं '15' तक या घातीय मानों के लिए। यह एक फ़्लोट की तुलना में दोगुनी जानकारी और डेटा ले जा सकता है जिसे डबल डेटा प्रकार कहा जाता है। इसका आकार लगभग '8 बाइट्स' है, जो फ़्लोट डेटा प्रकार को दोगुना करता है।
'डबल' डेटा प्रकार के साथ काम करते समय हमें चुनौतियों का सामना करना पड़ सकता है। हम डबल डेटा प्रकार को सीधे प्रिंट नहीं कर सकते हैं, इसलिए हम 'डबल' डेटा प्रकार का पूरा मान प्रिंट करने के लिए कुछ तकनीकों का उपयोग कर सकते हैं। हम दशमलव बिंदुओं वाले दोहरे डेटा प्रकार के साथ काम करते समय 'सेटपरसिजन ()' विधि का उपयोग कर सकते हैं। दोहरे डेटा प्रकार के दूसरे मामले में जिसमें घातीय मान हैं, हम 'निश्चित' या 'वैज्ञानिक' प्रारूपों का उपयोग कर सकते हैं। यहां, हम इस गाइड में किसी भी तकनीक का उपयोग किए बिना और सभी तीन तरीकों का उपयोग करके दोहरे डेटा प्रकारों की छपाई पर चर्चा करेंगे।
उदाहरण 1:
C++ कोड यहां है जिसमें 'iostream' हेडर फ़ाइल शामिल है क्योंकि हमें इस हेडर फ़ाइल में घोषित फ़ंक्शंस के साथ काम करना है। फिर, हम 'नेमस्पेस एसटीडी' डालते हैं ताकि हमें अपने कार्यों के साथ 'एसटीडी' कीवर्ड को अलग से जोड़ने की आवश्यकता न हो। फिर, हम यहां फ़ंक्शन को लागू करते हैं जो 'मुख्य()' फ़ंक्शन है। निम्नलिखित में, हम 'var_a' नाम के साथ एक 'डबल' वेरिएबल घोषित करते हैं और इस वेरिएबल को दशमलव बिंदु मान निर्दिष्ट करते हैं। अब, हम इस दोहरे मान को प्रदर्शित करना चाहते हैं, इसलिए हम इस वेरिएबल को रखने के लिए 'काउट' का उपयोग करते हैं जहां हम दोहरे मान को संग्रहीत करते हैं। फिर, हम 'रिटर्न 0' जोड़ते हैं।
कोड 1:
#शामिल करेंका उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( खालीपन ) {
दोहरा var_a = 7.9765455419016 ;
अदालत << 'दोगुना मूल्य जो हमने यहां रखा है = ' << var_a ;
वापस करना 0 ;
}
आउटपुट:
अब, इस परिणाम में ध्यान दें कि यह हमारे कोड में डाले गए पूर्ण दोहरे मान को प्रिंट नहीं करता है। तो, यह वह समस्या है जिसका सामना हमें C++ प्रोग्रामिंग में डबल डेटा प्रकार के साथ काम करते समय करना पड़ता है।
उदाहरण 2:
इस उदाहरण में, हम अंकगणितीय ऑपरेशन को दशमलव बिंदु मानों पर लागू करेंगे और फिर परिणाम को दोहरे डेटा प्रकार मान के रूप में प्रदर्शित करेंगे। हम सबसे पहले 'bits/stdc++.h' हेडर फ़ाइल जोड़ते हैं जिसमें सभी मानक लाइब्रेरी शामिल हैं। फिर, हम 'नेमस्पेस एसटीडी' का उपयोग करने के बाद 'मुख्य()' को लागू करते हैं। यहां 'ए' वेरिएबल को 'डबल' डेटा प्रकार के साथ घोषित किया गया है और फिर इस वेरिएबल को '1.0/5000' असाइन किया गया है। अब, यह इस विभाजन ऑपरेशन को डेटा पर लागू करता है और परिणाम को 'डबल' डेटा प्रकार के 'ए' वेरिएबल में संग्रहीत करता है। फिर, हम 'काउट' का उपयोग करके 'ए' में संग्रहीत परिणाम प्रदर्शित करते हैं।
कोड 2:
#शामिल<बिट्स/stdc++.h>का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( खालीपन ) {
दोहरा ए = 1.0 / 5000 ;
अदालत << 'मेरा दोगुना मूल्य है' << ए ;
वापस करना 0 ;
}
आउटपुट:
यहां दिए गए दोहरे डेटा प्रकार मान का परिणाम है। हम उन मानों पर गणितीय संक्रियाओं को आसानी से लागू कर सकते हैं जो दोहरे डेटा प्रकार के परिणाम लौटाते हैं और उन्हें हमारे C++ कोड में प्रदर्शित करते हैं।
उदाहरण 3: सेटप्रिसिजन() विधि का उपयोग करना
यहां, हम 'सेटप्रिसिजन' विधि लागू करेंगे। हम दो हेडर फ़ाइलें शामिल करते हैं: 'iosteam' और 'bits/stdc++.h'। फिर 'नेमस्पेस एसटीडी' जोड़ा जाता है जो हमें हमारे प्रत्येक फ़ंक्शन के साथ व्यक्तिगत रूप से 'एसटीडी' कीवर्ड शामिल करने से बचाता है। फिर इसके नीचे 'मुख्य()' फ़ंक्शन को कॉल किया जाता है। 'var_a' वेरिएबल को अब 'डबल' डेटा प्रकार के साथ घोषित किया गया है जिसमें दशमलव बिंदु वाला मान होता है।
चूँकि हम पूर्ण संख्या प्रदर्शित करना चाहते हैं, इसलिए हम 'काउट' स्टेटमेंट में 'सेटप्रिसिजन ()' फ़ंक्शन का उपयोग करते हैं। हम इस फ़ंक्शन के पैरामीटर के रूप में '15' पास करते हैं। यह विधि इस दोहरे डेटा प्रकार मान में दशमलव बिंदु के मानों की संख्या निर्धारित करने में सहायता करती है। हमने यहां जो परिशुद्धता निर्धारित की है वह '15' है। तो, यह दशमलव बिंदु मान की '15' संख्याएँ प्रदर्शित करता है। फिर, हम इस 'डबल' डेटा प्रकार मान को प्रिंट करने के लिए 'सेटप्रिसिजन ()' विधि का उपयोग करने के बाद इस 'काउट' में 'var_a' डालते हैं।
कोड 3:
#शामिल करें#शामिल<बिट्स/stdc++.h>
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( खालीपन ) {
दोहरा var_a = 7.9765455419016 ;
अदालत << setprecision ( पंद्रह ) << 'दोगुना मूल्य जो हमने यहां रखा है = ' << var_a ;
वापस करना 0 ;
}
आउटपुट:
यहां, हम देख सकते हैं कि हमने कोड में जो पूरा मूल्य दर्ज किया है वह प्रदर्शित होता है। ऐसा इसलिए है क्योंकि हमने अपने कोड में 'सेटप्रिसिजन()' फ़ंक्शन का उपयोग किया है और सटीक संख्या को '15' पर सेट किया है।
उदाहरण 4:
'iomanip' और 'iostream' दो हेडर फ़ाइलें हैं। 'iomanip' का उपयोग किया जाता है क्योंकि इस हेडर फ़ाइल में 'setprecision()' फ़ंक्शन घोषित किया गया है। फिर, 'std' नेमस्पेस डाला जाता है और 'main()' को इनवॉइस करता है। यहां घोषित 'डबल' डेटा प्रकार का पहला वेरिएबल 'dbl_1' है और दूसरे वेरिएबल का नाम 'dbl_2' है। हम दशमलव बिंदुओं वाले दोनों चरों को अलग-अलग मान निर्दिष्ट करते हैं। अब, हम 'सेटपरसिजन ()' फ़ंक्शन का उपयोग करके और यहां '12' पास करके दोनों मानों के लिए समान सटीक संख्या लागू करते हैं।
अब, दोनों मानों के लिए सटीक संख्या '12' पर सेट है, जिसका अर्थ है कि ये मान '12' मान प्रदर्शित करते हैं। हम 'काउट' फ़ंक्शन को रखने के बाद इस 'सेटप्रिसिजन ()' फ़ंक्शन का उपयोग करते हैं। इसके नीचे, हम 'डबल' डेटा प्रकार के दोनों मानों को 'काउट' के साथ प्रिंट करते हैं।
कोड 4:
#शामिल#शामिल करें
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
दोहरा dbl_1 = 9.92362738239293 ;
दोहरा dbl_2 = 6.68986442623803 ;
अदालत << setprecision ( 12 ) ;
अदालत << 'डबल टाइप नंबर 1 = ' << dbl_1 << अंतः ;
अदालत << 'डबल टाइप नंबर 2 = ' << dbl_2 << अंतः ;
वापस करना 0 ;
}
आउटपुट:
हम देख सकते हैं कि यह 12 मान दिखाता है और इस 'डबल' डेटा प्रकार मान के अन्य सभी मानों को अनदेखा करता है क्योंकि हम अपने कोड में सटीक मान सेट करते हैं।
उदाहरण 5:
यहां, हम तीन वेरिएबल घोषित करते हैं: 'new_d1', 'new_d2', और 'new_d3'। तीनों मानों का डेटा प्रकार 'डबल' है। हम इन सभी वेरिएबल्स को मान भी निर्दिष्ट करते हैं। अब, हम तीनों वेरिएबल्स के लिए अलग-अलग सटीक मान सेट करना चाहते हैं। हम 'काउट' के अंदर 'सेटप्रिसिजन ()' फ़ंक्शन के पैरामीटर के रूप में '15' पास करके पहले वैरिएबल मान के लिए '15' सेट करते हैं। इसके बाद, हम दूसरे वेरिएबल के मान के सटीक मान के रूप में '10' सेट करते हैं और इस तीसरे मान के लिए सटीक संख्या के रूप में '6' सेट करते हैं।
कोड 5:
#शामिल#शामिल करें
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
दोहरा new_d1 = 16.6393469106198566 ;
दोहरा new_d2 = 4.01640810861469 ;
दोहरा new_d3 = 9.95340810645660 ;
अदालत << 'सटीक 15 के साथ डबल टाइप नंबर = ' << setprecision ( पंद्रह ) << new_d1 << अंतः ;
अदालत << 'सटीकता 10 के साथ डबल टाइप नंबर = ' << setprecision ( 10 ) << new_d2 << अंतः ;
अदालत << 'सटीक 6 के साथ डबल टाइप नंबर = ' << setprecision ( 6 ) << new_d3 << अंतः ;
वापस करना 0 ;
}
आउटपुट:
यहां सभी तीन मान अलग-अलग हैं क्योंकि हम उन सभी के लिए अलग-अलग सटीक मान समायोजित करते हैं। पहले मान में '15' संख्याएँ हैं क्योंकि हमने सटीक मान को '15' पर सेट किया है। दूसरे मान में '10' के सटीक मान के कारण '10' संख्याएँ हैं, और तीसरे मान में '6' संख्याएँ प्रदर्शित होती हैं क्योंकि इसका सटीक मान कोड में '6' पर समायोजित किया गया है।
उदाहरण 6:
हम यहां चार वेरिएबल आरंभ करते हैं: दो को दशमलव बिंदु मानों के साथ आरंभ किया जाता है और अन्य दो को घातीय मानों के साथ आरंभ किया जाता है। इसके बाद, हम सभी चार वेरिएबल्स को 'काउट' के अंदर रखकर 'फिक्स्ड' फॉर्मेट लागू करते हैं। इसके नीचे, हम 'वैज्ञानिक' कीवर्ड का उपयोग करने के बाद उन्हें 'काउट' के अंदर रखकर इन चर पर अलग से 'वैज्ञानिक' प्रारूप का उपयोग करते हैं।
कोड 6:
#शामिल#शामिल करें
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
दोहरा my_dbl_1 = 7.7637208968554 ;
दोहरा my_ex_1 = 776ई+2 ;
दोहरा my_dbl_2 = 4.6422657897086 ;
दोहरा my_ex_2 = 464ई+2 ;
अदालत << 'निश्चित कीवर्ड का उपयोग करके' << अंतः ;
अदालत << 'पहला डबल टाइप नंबर =' << तय << my_dbl_1 << अंतः ;
अदालत << 'दूसरा डबल टाइप नंबर = ' << तय << my_ex_1 << अंतः ;
अदालत << 'तीसरा दोहरा प्रकार संख्या =' << तय << my_dbl_2 << अंतः ;
अदालत << 'चौथा डबल प्रकार संख्या =' << तय << my_ex_2 << अंतः ;
अदालत << अंतः ;
अदालत << 'वैज्ञानिक कीवर्ड का उपयोग करके:' << अंतः ;
अदालत << 'पहला डबल टाइप नंबर = ' << वैज्ञानिक << my_dbl_1 << अंतः ;
अदालत << 'दूसरा डबल टाइप नंबर = ' << वैज्ञानिक << my_ex_1 << अंतः ;
अदालत << 'तीसरा दोहरा प्रकार संख्या =' << वैज्ञानिक << my_dbl_2 << अंतः ;
अदालत << 'चौथा डबल प्रकार संख्या =' << वैज्ञानिक << my_ex_2 << अंतः ;
वापस करना 0 ;
}
आउटपुट:
यह परिणाम 'डबल' डेटा प्रकार मानों पर 'निश्चित' और 'वैज्ञानिक' प्रारूप लागू करने के बाद आउटपुट दिखाता है। 'निश्चित' प्रारूप पहले चार मानों पर लागू होता है। अंतिम चार मानों पर, 'वैज्ञानिक' प्रारूप लागू किया जाता है और परिणाम यहां प्रदर्शित होता है।
निष्कर्ष
'प्रिंटिंग डबल' डेटा प्रकार की अवधारणा पर यहां विस्तार से चर्चा की गई है। हमने C++ प्रोग्रामिंग में 'डबल' डेटा प्रकार को प्रिंट करने की विभिन्न तकनीकों का पता लगाया। हमने तीन अलग-अलग तकनीकों का प्रदर्शन किया जो हमें 'डबल' डेटा प्रकार मानों को प्रिंट करने में सहायता करती हैं; ये 'सेटप्रिसिजन()', 'फिक्स्ड' और 'वैज्ञानिक' हैं। हमने इस गाइड में सभी तकनीकों का गहन अध्ययन किया।