उदाहरण 1:
इस कोड में 'वैकल्पिक' और 'iostream' हेडर फ़ाइलें आयात की जाती हैं। हमें इन हेडर फ़ाइलों को आयात करना होगा ताकि हम उनमें परिभाषित कार्यों तक आसानी से पहुंच सकें। इसके बाद, हम 'नेमस्पेस एसटीडी' शामिल करते हैं ताकि हमें इसे 'एसटीडी::ऑप्शनल' और 'एसटीडी::काउट' जैसे कार्यों के साथ अलग से टाइप न करना पड़े। हम यहां 'नेमस्पेस एसटीडी' का उपयोग करते हैं। तो, अब, हम उनके साथ 'std' टाइप किए बिना 'वैकल्पिक' या 'काउट' डालते हैं।
फिर, हम मुख्य() को लागू करते हैं और 'वैकल्पिक' डालते हैं और इसे 'int' पर सेट करते हैं और 'myNum' घोषित करते हैं। यह 'std:: option' वेरिएबल घोषित करने के लिए सिंटैक्स है। फिर, हम 'वैल्यू' नामक एक अन्य वेरिएबल को इनिशियलाइज़ करते हैं और वैल्यू_ऑर() फ़ंक्शन का उपयोग करके 'myNum' वेरिएबल को एक मान निर्दिष्ट करते हैं। हम इस फ़ंक्शन में '99' पास करते हैं, इसलिए यदि कोई मान मौजूद नहीं है तो यह इस '99' को 'muNum' वेरिएबल को निर्दिष्ट करता है और इसे 'वैल्यू' वेरिएबल में संग्रहीत करता है। फिर, हम इसके नीचे 'काउट' रखते हैं जो उस मान को प्रदर्शित करने में सहायता करता है जो हमने इसके ऊपर वाले वेरिएबल को सौंपा है।
कोड 1:
#शामिल <वैकल्पिक>#शामिल करें
नेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( ) {
वैकल्पिक < int यहाँ > myNum ;
int यहाँ कीमत = myNum. मूल्य_या ( 99 ) ;
अदालत << 'myNum का मान है:' << कीमत << अंतः ;
वापस करना 0 ;
}
आउटपुट:
यहां, हम देख सकते हैं कि '99' प्रदर्शित होता है जिसका अर्थ है कि मान ऊपर मौजूद नहीं था और जो मान हमने जोड़ा है वह उस चर को सौंपा गया है।
उदाहरण 2:
हम पहले हेडर फ़ाइलें शामिल करते हैं और 'नेमस्पेस एसटीडी' डालते हैं। अब, इसके नीचे, हम 'std::Optional' फ़ंक्शन घोषित करते हैं जो कि 'divideFunc()' है। 'लाभांश' और 'भाजक' इस फ़ंक्शन के दो पैरामीटर हैं। फिर हम इसके नीचे 'if' का उपयोग करते हैं जहां हम एक शर्त जोड़ते हैं जो कहती है 'विभाजक != 0'। यदि यह संतुष्ट है, तो यह इस विभाजन का उत्तर लौटाता है क्योंकि हम इसके अंदर 'रिटर्न' जोड़ते हैं। अन्यथा, यह 'nullopt' लौटाता है जिसका अर्थ है कोई सुरक्षित-प्रकार का मान नहीं। अब, हम मुख्य() का आह्वान करते हैं। 'std::optional' का अनुमान लगाने के लिए, हम 'divideFunc()' डालते हैं और इसमें '27, 3' जोड़ते हैं और परिणाम को 'quotient' वेरिएबल पर निर्दिष्ट करते हैं।
यहां, हम 'ऑटो' कीवर्ड का उपयोग करते हैं ताकि यह स्वचालित रूप से अपने डेटा प्रकार को समायोजित कर सके। इसके बाद, हम 'if' जोड़ते हैं जहां हम 'has-value' का उपयोग करते हैं जो यह निर्धारित करता है कि एक प्रकार-मान प्राप्त हुआ है या नहीं। फिर, हम 'काउट' डालते हैं जो 'भागफल' चर में संग्रहीत परिणाम प्रस्तुत करता है, और 'अन्य' भाग में एक कथन होता है जो यह प्रस्तुत करता है कि भाजक शून्य है।
कोड 2:
#शामिल करें#शामिल <वैकल्पिक>
नेमस्पेस एसटीडी का उपयोग करना ;
वैकल्पिक < int यहाँ > डिवाइडफ़ंक ( int यहाँ लाभांश , int यहाँ डिवाइडर ) {
अगर ( डिवाइडर != 0 ) {
वापस करना लाभांश / डिवाइडर ;
}
वापस करना nullopt ;
}
int यहाँ मुख्य ( ) {
ऑटो भागफल = डिवाइडफ़ंक ( 27 , 3 ) ;
अगर ( भागफल। has_value ( ) ) {
अदालत << 'भागफल है:' << भागफल। कीमत ( ) << अंतः ;
} अन्य {
अदालत << 'यहां भाजक शून्य है' << अंतः ;
}
वापस करना 0 ;
}
आउटपुट:
आउटपुट विभाजन के बाद परिणाम प्रस्तुत करता है जिसका अर्थ है कि भाजक शून्य नहीं है। इस उदाहरण में, 'std:: option' का उपयोग यह निर्धारित करने के लिए किया जाता है कि कोई मान मौजूद है या टाइप-सुरक्षित रूप से नहीं है।
उदाहरण 3:
यहां, हम 'std:: वैकल्पिक' वेरिएबल घोषित कर रहे हैं जो मुख्य() के अंदर 'संख्या' है। फिर, हम 'if' का उपयोग करते हैं जिसमें हम has_value() फ़ंक्शन को इस 'संख्या' वेरिएबल के साथ रखते हैं। यह जाँचता है कि इस 'संख्या' वेरिएबल में कोई मान है या नहीं। यदि 'संख्या' वेरिएबल में कोई मान है, तो यह उस कथन को प्रस्तुत करता है जिसे हमने 'यदि' के बाद जोड़ा है। अन्यथा, यह उस कथन को प्रस्तुत करता है जिसे हमने 'अन्य' के बाद रखा है।
अब, हम 'संख्या' को '92' से आरंभ करते हैं और इसके नीचे फिर से 'if' का उपयोग करते हैं, जहां has_value() फ़ंक्शन को 'if as the शर्त' में 'संख्या' वेरिएबल के साथ जोड़ा जाता है। यह निर्धारित करता है कि 'संख्या' चर का कोई मान है या नहीं। 'यदि' के बाद हम जो वाक्य जोड़ते हैं, वह तब प्रस्तुत किया जाता है जब 'संख्या' चर का कोई मान होता है। यदि नहीं, तो वह कथन जिसे हम 'अन्य' के बाद रखते हैं, प्रस्तुत किया जाता है।
कोड 3:
#शामिल करें#शामिल <वैकल्पिक>
int यहाँ मुख्य ( ) {
कक्षा :: वैकल्पिक < int यहाँ > संख्या ;
अगर ( संख्या। has_value ( ) ) {
कक्षा :: अदालत << 'नंबर मौजूद है:' << संख्या। कीमत ( ) << कक्षा :: अंतः ;
} अन्य {
कक्षा :: अदालत << 'नंबर मौजूद नहीं है।' << कक्षा :: अंतः ;
}
संख्या = 92 ;
अगर ( संख्या। has_value ( ) ) {
कक्षा :: अदालत << 'नंबर मौजूद है:' << संख्या। कीमत ( ) << कक्षा :: अंतः ;
} अन्य {
कक्षा :: अदालत << 'नंबर मौजूद नहीं है।' << कक्षा :: अंतः ;
}
वापस करना 0 ;
}
आउटपुट:
यह पहले 'अन्य' भाग को प्रस्तुत करता है क्योंकि हम 'std:: वैकल्पिक' वेरिएबल को कोई मान निर्दिष्ट नहीं करते हैं। फिर, हम उस मान को अगली पंक्ति में प्रदर्शित करने के लिए इस वेरिएबल को एक मान निर्दिष्ट करते हैं।
उदाहरण 4:
अब, हम तीन 'std:: वैकल्पिक' वेरिएबल घोषित करते हैं जो 'n1', 'n2' और 'n3' हैं। हम 'n2' और 'n3' वेरिएबल्स को भी मान निर्दिष्ट करते हैं जो क्रमशः '29' और '45' हैं। 'std::optional' वर्ग का 'n1' वेरिएबल यहां खाली है। अब, हम 'बूलल्फा' का उपयोग करते हैं जो रिटर्न को '1' और '0' के बजाय 'सही' या 'गलत' रूप में लौटाने में सहायता करता है।
इसके बाद, हम इन 'एसटीडी::वैकल्पिक' वेरिएबल्स के बीच संबंधपरक ऑपरेटरों का उपयोग करते हैं और प्रत्येक कथन को 'काउट' के अंदर रखते हैं ताकि यह हमारे द्वारा जोड़े गए तुलना के परिणाम को भी प्रस्तुत कर सके। सबसे पहले, यह जांचता है कि 'n3 > n2', फिर 'n3 < n2', 'n1 < n2', 'n1 == std::nullopt'। यहां, 'nullopt' का उपयोग नो सेफ-टाइप मान या null की तुलना करने के लिए किया जाता है। फिर, हम 'cout' स्टेटमेंट के अंदर 'n2 == 49' और 'n3 == 88' को अलग से चेक करते हैं।
कोड 4:
#शामिल <वैकल्पिक>#शामिल करें
int यहाँ मुख्य ( )
{
कक्षा :: वैकल्पिक < int यहाँ > एन 1 ;
कक्षा :: वैकल्पिक < int यहाँ > एन 2 ( 29 ) ;
कक्षा :: वैकल्पिक < int यहाँ > n3 ( चार पांच ) ;
कक्षा :: अदालत << कक्षा :: अक्षरांकीय ;
कक्षा :: अदालत << 'एन3 > एन2' << ( n3 > एन 2 ) << कक्षा :: अंतः ;
कक्षा :: अदालत << 'एन3 <एन2' << ( n3 < एन 2 ) << कक्षा :: अंतः ;
कक्षा :: अदालत << 'द एन1 <एन2' << ( एन 1 < एन 2 ) << कक्षा :: अंतः ;
कक्षा :: अदालत << 'एन1==शून्य' << ( एन 1 == कक्षा :: nullopt ) << कक्षा :: अंतः ;
कक्षा :: अदालत << 'एन2==49' << ( एन 2 == 29 ) << कक्षा :: अंतः ;
कक्षा :: अदालत << 'एन3 == 88' << ( n3 == 88 ) << कक्षा :: अंतः ;
}
आउटपुट:
C++ प्रोग्राम जिसका हमने पहले उल्लेख किया था वह आउटपुट पर परिणाम को समवर्ती रूप से प्रिंट करते समय 'std:: वैकल्पिक' प्रकार के विभिन्न चर मानों की तुलना करता है।
उदाहरण 5:
इस कोड में शामिल हेडर फ़ाइलें 'iostream', 'fstream', 'वैकल्पिक' और 'स्ट्रिंग' हैं। 'एफस्ट्रीम' में दोनों कार्यों की परिभाषा शामिल है जो 'ऑफस्ट्रीम' और 'इफस्ट्रीम' हैं जिनकी हमें इस कोड में आवश्यकता है। अब, हम 'नेमस्पेस एसटीडी' शामिल करते हैं, इसलिए हम इसे प्रत्येक फ़ंक्शन के साथ अलग से नहीं रखते हैं। फिर, हम 'std: वैकल्पिक' का उपयोग करते हैं और 'ReadFileFunc' नाम के साथ एक फ़ंक्शन घोषित करते हैं जिसमें हम तर्क के रूप में 'const string& f_Name' पास करते हैं।
फिर, हमारे पास 'ifstream' है जो उस फ़ाइल को पढ़ने में मदद करता है जिसका नाम 'f_name' वेरिएबल में जोड़ा जाएगा। फिर, हम 'if' का उपयोग करते हैं जिसमें हम वह शर्त शामिल करते हैं जो कहती है कि यदि फ़ाइल नहीं खोली गई है, तो यह 'nullopt' लौटाती है क्योंकि हमने इसे 'if' स्टेटमेंट के नीचे जोड़ा है। फिर, हम एक और फ़ंक्शन बनाते हैं जो 'फ़ाइलकंटेंट' है जो फ़ाइल खोले जाने पर फ़ाइल में सामग्री लिखने में सहायता करता है। यहां, हम 'रिटर्न फ़ाइलकंटेंट' को फिर से रखते हैं जो वह सामग्री भी लौटाता है जिसे हमने खोलने के बाद फ़ाइल में जोड़ा था।
अब, हम यहां 'मुख्य()' को कॉल करते हैं जिसमें हम 'f_Name' वेरिएबल को 'Sample.txt' फ़ाइल नाम के साथ प्रारंभ करते हैं जिसे हम खोलना चाहते हैं। फिर, हम यहां 'ReadFileFunc()' को कॉल करते हैं और इस फ़ंक्शन में 'f_Name' वेरिएबल पास करते हैं जो फ़ाइल को पढ़ने की कोशिश करता है और इसकी सामग्री को 'f_content' वेरिएबल में संग्रहीत करता है। इसके नीचे, हम 'if' में 'f_content' वेरिएबल के साथ 'has_value()' का उपयोग करते हैं। यदि इस वेरिएबल में कोई मान है, तो यह इसे भी प्रस्तुत करता है क्योंकि हमने 'if' के नीचे 'cout' जोड़ा है जिसमें हमने 'f_content' भी रखा है। अन्यथा, यह वह त्रुटि दिखाता है जिसे हमने 'अन्य' के बाद जोड़ा है।
कोड 5:
#शामिल करें#शामिल
#शामिल <वैकल्पिक>
#शामिल <स्ट्रिंग>
नेमस्पेस एसटीडी का उपयोग करना ;
वैकल्पिक < डोरी > ReadFileFunc ( कॉन्स्ट डोरी & f_नाम ) {
ifstream myFile ( f_नाम ) ;
अगर ( ! मेरी फाइल। खुला है ( ) ) {
वापस करना nullopt ;
}
स्ट्रिंग फ़ाइल सामग्री ( ( isstreambuf_iterator < चार > ( मेरी फाइल ) ) , isstreambuf_iterator < चार > ( ) ) ;
वापस करना फ़ाइलसामग्री ;
}
int यहाँ मुख्य ( ) {
कॉन्स्ट स्ट्रिंग f_Name = 'नमूना.txt' ;
ऑटो f_सामग्री = ReadFileFunc ( f_नाम ) ;
अगर ( f_सामग्री. has_value ( ) ) {
अदालत << 'फ़ाइल की सामग्री है: \एन ' << f_सामग्री. कीमत ( ) << अंतः ;
} अन्य {
सेर << 'त्रुटि: फ़ाइल यहां नहीं खोली गई' << f_नाम << अंतः ;
}
वापस करना 0 ;
}
आउटपुट:
यहां, यह त्रुटि विवरण दिखाता है जिसे हमने दिए गए कोड के परिणाम के रूप में 'अन्य' भाग में जोड़ा है।
निष्कर्ष
इस ट्यूटोरियल में, हमने मजबूत C++ सुविधा की खोज की, जो 'std::वैकल्पिक' है और समझाया कि यह वैकल्पिक मूल्यों का प्रतिनिधित्व करने का एक मानकीकृत तरीका प्रदान करता है, शून्य संदर्भों की आवश्यकता को दूर करता है और स्पष्टता और कोड सुरक्षा को बढ़ाता है। हमने सीखा कि यह जटिल मुद्दों को समझाने और गलतियों से शालीनता से निपटने की क्षमता में भी सुधार करता है।