उदाहरण 1:
पहला कोड यहां है जहां हमें उपयोगकर्ता से पूर्णांक मान मिलता है। पहली पंक्ति में, हम 'iostream' हेडर फ़ाइल शामिल करते हैं क्योंकि हमें यहां इनपुट प्राप्त करने और आउटपुट प्रदर्शित करने की आवश्यकता है। इस हेडर फ़ाइल में 'सिन' और 'काउट' फ़ंक्शन की घोषणा की जाती है। फिर, 'std' नेमस्पेस जोड़ा जाता है क्योंकि यह 'cin' और 'cout' जैसे कार्यों को परिभाषित करता है। इसलिए, यदि हम अपने कोड की शुरुआत में 'नेमस्पेस एसटीडी' डालते हैं, तो हमें प्रत्येक फ़ंक्शन के साथ 'एसटीडी' टाइप करने की आवश्यकता नहीं है।
फिर, हम 'मुख्य()' फ़ंक्शन को कॉल करते हैं और बाद में पूर्णांक डेटा प्रकार का एक चर घोषित करते हैं। 'int_value' वेरिएबल का नाम है जिसे हमने यहां घोषित किया है। इसके बाद, हम 'काउट' का उपयोग करते हैं जो स्क्रीन पर दिए गए डेटा को प्रिंट करने में सहायता करता है। यहां, हम उपयोगकर्ता को एक संदेश प्रदर्शित करते हैं जिसमें हम कहते हैं, 'एक पूर्णांक संख्या दर्ज करें'। इसके नीचे, हम निष्कर्षण प्रतीकों '>>' के साथ 'cin' रखते हैं और 'int_num' वेरिएबल रखते हैं।
अब, हम उपयोगकर्ता का इनपुट लेते हैं और इसे यहां सहेजते हैं। हम उस पूर्णांक संख्या को भी प्रदर्शित करना चाहते हैं जिसे उपयोगकर्ता यहां स्क्रीन पर दर्ज करता है। इसलिए, हम इसके नीचे 'cout' का उपयोग करते हैं और वहां 'int_value' डालते हैं।
कोड 1:
#शामिल करना
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
int यहाँ int_value ;
अदालत <> int_value ;
अदालत << 'पूर्णांक संख्या है:' << int_value ;
वापस करना 0 ;
}
आउटपुट:
जब दिया गया कोड निष्पादित होता है, तो हम '89' दर्ज करते हैं और यह उपयोगकर्ता के इनपुट के रूप में '89' लेता है। फिर, हम 'एंटर' दबाते हैं, इसलिए यह अगली पंक्ति प्रदर्शित करता है।
उदाहरण 2:
हमें यहां इनपुट प्राप्त करने और आउटपुट प्रदर्शित करने की आवश्यकता है। इसलिए, हम पहली पंक्ति में 'iostream' हेडर फ़ाइल शामिल करते हैं। इस हेडर फ़ाइल में 'cin' और 'cout' फ़ंक्शंस के लिए घोषणाएँ शामिल हैं। इसके बाद, “std” नेमस्पेस जोड़ा जाता है। यदि हम अपने कोड की शुरुआत में 'नेमस्पेस एसटीडी' जोड़ते हैं तो हमें प्रत्येक फ़ंक्शन के साथ 'एसटीडी' टाइप करने की आवश्यकता नहीं है।
'मुख्य()' फ़ंक्शन पर कॉल के बाद, एक 'फ्लोट' डेटा प्रकार चर घोषित किया जाता है। जिस वेरिएबल को हम यहां घोषित करते हैं उसे 'फ्लोट_वैल्यू' कहा जाता है। इसके बाद, हम टर्मिनल पर उपलब्ध कराए गए डेटा को प्रस्तुत करने में सहायता के लिए 'काउट' फ़ंक्शन का उपयोग करते हैं। यहां, हम उपयोगकर्ता को एक संदेश प्रदर्शित करके एक फ्लोट नंबर दर्ज करने के लिए कहते हैं। 'फ्लोट_नम' वेरिएबल और निष्कर्षण प्रतीक '>>' को 'सिन' के साथ इसके नीचे स्थित किया गया है।
उपयोगकर्ता का इनपुट एकत्र किया जाता है और 'फ्लोट_नम' में सहेजा जाता है। हम इसके नीचे एक बार फिर 'काउट' फ़ंक्शन का उपयोग करते हैं और 'फ्लोट_वैल्यू' डालते हैं क्योंकि हम उस फ्लोट नंबर को भी देखना चाहते हैं जिसे उपयोगकर्ता स्क्रीन पर दर्ज करता है।
कोड 2:
#शामिल करेंका उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
तैरना फ्लोट_वैल्यू ;
अदालत <> फ्लोट_वैल्यू ;
अदालत << 'फ्लोट संख्या है:' << फ्लोट_वैल्यू ;
वापस करना 0 ;
}
उत्पादन :
जब पहले उल्लिखित कोड चलता है, तो हम उपयोगकर्ता के इनपुट के रूप में कीबोर्ड से '87.5' टाइप करते हैं। जब हम 'एंटर' पर क्लिक करते हैं तो अगली पंक्ति फ़्लोट मान प्रदर्शित करती है।
उदाहरण 3:
अब, आइए उपयोगकर्ता से 'डबल' डेटा प्रकार मान प्राप्त करें। यहां, हम 'डबल' डेटा प्रकार के 'डबल_वैल्यू' को प्रारंभ करते हैं और फिर वह संदेश डालते हैं जो हम उपयोगकर्ता को दिखाना चाहते हैं। इसके बाद, हम “cin>>” का उपयोग करते हैं और “double_value” वेरिएबल को यहां रखते हैं। उपयोगकर्ता का इनपुट इस 'डबल_वैल्यू' वेरिएबल में सहेजा जाता है। हम 'काउट' का फिर से उपयोग करते हैं जहां हम उपयोगकर्ता द्वारा आउटपुट के रूप में दर्ज किए गए इनपुट को प्रदर्शित करने के लिए 'डबल_वैल्यू' वेरिएबल डालते हैं।
कोड 3:
#शामिल करनाका उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
दोहरा दोहरा_मूल्य ;
अदालत <> दोहरा_मूल्य ;
अदालत << 'दोहरी संख्या है:' << दोहरा_मूल्य ;
वापस करना 0 ;
}
उत्पादन :
यहां, हम डबल डेटा टाइप नंबर दर्ज करते हैं और 'एंटर' दबाते हैं। लेकिन यहां, हम ध्यान दें कि यह पूरी संख्या प्रदर्शित नहीं करता है। संपूर्ण 'डबल' डेटा प्रकार संख्या प्रदर्शित करने के लिए, हमें बस C++ में कुछ तकनीकों की आवश्यकता है।
उदाहरण 4:
यहां, हम एक और हेडर फ़ाइल शामिल करते हैं जो 'बिट्स/stdc++.h' है क्योंकि इसमें सभी वांछित फ़ंक्शन घोषणाएं शामिल हैं। यहां, हम 'डबल' डेटा प्रकार के 'डबल_डी' को प्रारंभ करने के बाद देखने के लिए उपयोगकर्ता के लिए वांछित संदेश सेट करते हैं। इसके बाद, हम 'cin>>' फ़ंक्शन का उपयोग करते हैं और यहां 'double_d' वेरिएबल असाइन करते हैं। इनपुट 'डबल_डी' में सहेजा गया है। उपयोगकर्ता द्वारा यहां दर्ज किए गए इनपुट को आउटपुट के रूप में प्रदर्शित करने के लिए, हम 'डबल_डी' वेरिएबल को फिर से 'काउट' फ़ील्ड में दर्ज करते हैं। हम 'सेटप्रिसिजन ()' फ़ंक्शन भी शामिल करते हैं जिसमें हम '10' जोड़ते हैं ताकि यह डबल डेटा प्रकार मान की सटीकता को समायोजित कर सके और तदनुसार प्रिंट कर सके। हमने यहां जो परिशुद्धता निर्धारित की है वह '10' है।
कोड 4:
#शामिल करना#शामिल करना
का उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
दोहरा d_value2 ;
अदालत <> d_value2 ;
अदालत << setprecision ( 10 ) << 'दोहरी संख्या है:' << d_value2 ;
वापस करना 0 ;
}
उत्पादन :
यहां, यह इनपुट इकट्ठा करता है और फिर उसी सटीकता के अनुसार 'डबल' मान प्रदर्शित करता है जिसे हमने दिए गए कोड में समायोजित किया है।
उदाहरण 5:
इस कोड में हमें यूजर से कैरेक्टर का इनपुट मिलता है। हम यहां एक 'char' वेरिएबल 'char1' प्रारंभ करते हैं और फिर संदेश प्रदर्शित करने के लिए 'cout' का उपयोग करते हैं। फिर, हम 'cin>>' रखते हैं और इस 'char1' को वहां रखते हैं। तो, उपयोगकर्ता द्वारा दर्ज किया गया अक्षर यहां संग्रहीत किया जाता है। फिर, हम 'char1' वेरिएबल में संग्रहीत चरित्र को दिखाने के लिए फिर से 'काउट' का उपयोग करते हैं।
कोड 5:
#शामिल करेंका उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
चार char1 ;
अदालत <> char1 ;
अदालत << 'चरित्र है:' << char1 ;
वापस करना 0 ;
}
उत्पादन :
निष्पादन के बाद, यह संदेश प्रदर्शित होता है. हम कैरेक्टर इनपुट के रूप में 'z' टाइप करते हैं। फिर, अगली पंक्ति में, दर्ज किया गया वर्ण प्रदर्शित होता है।
उदाहरण 6:
हमें इस कोड में उपयोगकर्ता से स्ट्रिंग इनपुट प्राप्त होता है। यहां, हम 'स्ट्रिंग' वेरिएबल 'myName' को प्रारंभ करते हैं और संदेश को आउटपुट करने के लिए 'cout' का उपयोग करते हैं। इसके बाद, हम उस स्थान पर 'myName' और 'cin>>' डालते हैं। इस प्रकार, उपयोगकर्ता द्वारा दर्ज की गई स्ट्रिंग यहां सहेजी गई है। इसके बाद, हम 'myName' वेरिएबल में सेव की गई स्ट्रिंग को प्रदर्शित करने के लिए फिर से 'cout' कमांड का उपयोग करते हैं।
कोड 6:
#शामिल करेंका उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
मेरा नाम स्ट्रिंग करें ;
अदालत <> मेरा नाम ;
अदालत << 'मेरा नाम है: ' << मेरा नाम ;
वापस करना 0 ;
}
आउटपुट:
निम्न संदेश प्रकट होता है. हम इनपुट फ़ील्ड में 'पीटर' स्ट्रिंग दर्ज करते हैं। फिर दर्ज की गई स्ट्रिंग को निम्नलिखित पंक्ति में दिखाया गया है:
उदाहरण 7:
जब हम इनपुट के रूप में कई स्ट्रिंग्स या एक लाइन लेना चाहते हैं, तो हमें 'गेटलाइन ()' फ़ंक्शन का उपयोग करना चाहिए। हम यहां 'स्ट्रिंग नाम' घोषित करते हैं। फिर, जो संदेश हम दर्ज करते हैं वह 'काउट' का उपयोग करके मुद्रित होता है। फिर हम 'नाम' और 'सिन' को 'गेटलाइन ()' फ़ंक्शन में डालते हैं जो उपयोगकर्ता से कई स्ट्रिंग इनपुट प्राप्त करता है और उन्हें 'नाम' चर में संग्रहीत करता है। यह उपयोगकर्ता द्वारा दर्ज की गई स्ट्रिंग्स को सहेजता है। इसके बाद, हम 'काउट' कमांड का उपयोग करके 'नाम' वेरिएबल में सहेजे गए स्ट्रिंग्स को प्रदर्शित करते हैं।
कोड 7:
#शामिल करेंका उपयोग करते हुए नाम स्थान कक्षा ;
int यहाँ मुख्य ( ) {
स्ट्रिंग नाम ;
अदालत << 'कृपया अपना पूरा नाम यहां दर्ज करें:' ;
लाइन में आओ ( खाना , नाम ) ;
अदालत << 'आपका पूरा नाम है:' << नाम ;
वापस करना 0 ;
}
आउटपुट:
यहां, इस परिणाम में, हम 'जेम्स सैमुअल' को स्ट्रिंग डेटा के रूप में दर्ज करते हैं। जब हम 'एंटर' दबाते हैं, तो यह यहां पूरा नाम प्रदर्शित करता है क्योंकि हमने 'गेटलाइन ()' फ़ंक्शन का उपयोग किया है।
निष्कर्ष
हमने इस गाइड में 'C++ उपयोगकर्ता इनपुट' के बारे में चर्चा की। हमने इस अवधारणा की खोज की और सीखा कि 'सिन' कमांड, निष्कर्षण प्रतीकों '>>' के साथ, उपयोगकर्ता का इनपुट प्राप्त करने के लिए उपयोग किया जाता है। हमने 'cin>>' कमांड की मदद से उपयोगकर्ता से पूर्णांक, फ्लोट, डबल, चार और स्ट्रिंग डेटा प्रकार मानों का इनपुट लिया और C++ उदाहरणों का प्रदर्शन किया जिसमें 'उपयोगकर्ता इनपुट' अवधारणा को विस्तार से समझाया गया है .