उदाहरण 1:
अब, आइए कुछ उदाहरण देखें जहां हम इस 'बूलियन डेटा प्रकार' का उपयोग करते हैं और दिखाते हैं कि यह C++ में काम कर रहा है। हम अपना कोड उन हेडर फ़ाइलों को जोड़कर शुरू करते हैं जिनकी हमें आवश्यकता होती है। पहली हेडर फ़ाइल जो हम यहां जोड़ते हैं वह '
इसके बाद, हमारे पास एक ड्राइवर कोड है जिसका अर्थ है कि हम यहां 'मुख्य()' फ़ंक्शन जोड़ते हैं। अब, हम बूलियन डेटाटाइप 'बूल' के साथ 'isBulbOn' वेरिएबल घोषित करते हैं और यहां 'सही' समायोजित करते हैं। इसके नीचे, हमारे पास 'isBulbOff' नाम का एक और बूलियन वैरिएबल है जिसमें हम 'गलत' जोड़ते हैं। यह सही और गलत परिणाम क्रमशः '1' और '0' हैं।
इन बूलियन मानों के आउटपुट की जांच करने के लिए, हम बस उन्हें 'काउट' स्टेटमेंट का उपयोग करके प्रिंट करते हैं। इस 'काउट' कथन में, हम पहले 'isBulbOn' परिणाम प्रिंट करते हैं। फिर, अगली पंक्ति में, हम 'isBulbOff' वेरिएबल का परिणाम प्रिंट करते हैं। यहां 'एंडल' का उपयोग किया गया है इसलिए यह हमारे पॉइंटर को अगली पंक्ति में ले जाता है।
कोड 1:
#शामिल करें
नेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( )
{
बूल isBulbOn = सत्य ;
बूल isBulbOff = असत्य ;
अदालत << 'बल्ब यहाँ जल रहा है' << isBulbOn << अंतः ;
अदालत << 'बल्ब यहाँ नहीं जल रहा है' << बल्ब बंद है ;
}
आउटपुट:
इस कोड का आउटपुट परिणाम को '0' और '1' रूपों में दर्शाता है जैसा कि निम्नलिखित में दिखाया गया है। यहां, '1' 'सही' परिणाम को इंगित करता है जबकि '0' 'गलत' परिणाम को इंगित करता है। हमें यह परिणाम केवल 'बूल' डेटा प्रकार के कारण प्राप्त होता है।
उदाहरण 2:
अब, हम इस कोड की शुरुआत में हेडर फ़ाइल को शामिल करने के बाद मुख्य के अंदर 'बूल' डेटाटाइप के दो वेरिएबल, 'पास' और 'फेल' घोषित करते हैं। यहां 'पास' वेरिएबल को 'सही' के रूप में असाइन किया गया है, और 'असफल' वेरिएबल को 'गलत' के रूप में असाइन किया गया है। अब, 'पास' परिणाम के रूप में '1' लौटाता है और 'असफल' परिणाम के रूप में '0' लौटाता है।
अब, हम '1' और '0' के रूप में सही या गलत परिणाम प्राप्त करने के लिए अपने 'काउट' स्टेटमेंट में इन बूल वेरिएबल्स का उपयोग करते हैं। 'काउट' जहां हम 'पास' डालते हैं वह '1' लौटाता है। जहां हम 'विफल' का उपयोग करते हैं वहां '0' रिटर्न मिलता है। यहां, हम पांच 'काउट' कथन जोड़ते हैं, प्रत्येक में बूलियन वैरिएबल होता है।
कोड 2:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( )
{
बूल पास = सत्य ;
बूल विफल = असत्य ;
अदालत << 'प्रतिशत 60 है' << उत्तीर्ण << अंतः ;
अदालत << 'प्रतिशत 45 है' << असफल << अंतः ;
अदालत << 'प्रतिशत 90 है' << उत्तीर्ण << अंतः ;
अदालत << 'प्रतिशत 85 है' << उत्तीर्ण << अंतः ;
अदालत << 'प्रतिशत 33 है' << असफल << अंतः ;
}
आउटपुट:
इस आउटपुट में, '1' 'सही' परिणाम का प्रतिनिधित्व करता है जो कि 'पास' है और '0' 'गलत' परिणाम का प्रतिनिधित्व करता है जो इस मामले में 'असफल' है।
उदाहरण 3:
इस कोड में, हम तीन पूर्णांक चर प्रारंभ करते हैं जो क्रमशः '45', '62', और '3' के मान के साथ 'num_01', 'num_02', और 'a' हैं। इसके बाद, हम तीन और वेरिएबल घोषित करते हैं - 'b_01', 'b_02', और 'b_03' - और ये बूलियन डेटाटाइप 'बूल' हैं। अब, हम 'b_01' को 'num_01 == num_01' शर्त के साथ प्रारंभ करते हैं। फिर, हम 'b_02' और 'b_03' को 'b_01' की तरह ही आरंभ करते हैं।
सभी वेरिएबल्स को आरंभ करने के बाद, हम इन बूलियन वेरिएबल्स के परिणाम की जांच करने के लिए 'काउट' का उपयोग करके उन्हें अलग से प्रिंट करते हैं। इसके बाद, हम 'बूल' डेटा प्रकार के 'बी_ए' वेरिएबल को 'ट्रू' से इनिशियलाइज़ करते हैं। फिर, हम यहां 'if' कथन का उपयोग करते हैं जहां हम 'b_a' को एक शर्त के रूप में रखते हैं। अब, यदि यह 'b_a' स्थिति सत्य है, तो 'if' के बाद का कथन निष्पादित किया जाता है। अन्यथा, 'अन्य' भाग यहां निष्पादित होगा। इसके बाद, हम आगे बढ़ते हैं और 'संख्या' पूर्णांक चर को आरंभ करते हैं जिसमें हम कुछ गणितीय संचालन लागू करते हैं और 'संख्या' परिणाम प्रदर्शित करते हैं।
कोड 3:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( )
{
int यहाँ num_01 = चार पांच , num_02 = 62 , ए = 3 ;
बूल b_01 , b_02 , b_03 ;
b_01 = num_01 == num_01 ;
b_02 = num_01 == num_02 ;
b_03 = num_02 > num_01 ;
अदालत << 'प्रथम बूल b_01 का उत्तर है = ' <<
b_01 << अंतः ;
अदालत << 'दूसरे बूल b_02 का उत्तर है = ' <<
b_02 << अंतः ;
अदालत << 'तीसरे बूल b_03 का उत्तर है = ' <<
b_03 << अंतः ;
बूल बी_ए = सत्य ;
अगर ( बी ० ए )
अदालत << 'हाँ' << अंतः ;
अन्य
अदालत << 'नहीं' << अंतः ;
int यहाँ एक पर = असत्य + 7 * ए - बी ० ए + सत्य ;
अदालत << एक पर ;
वापस करना 0 ;
}
आउटपुट:
यह परिणाम उन ऑपरेशनों के परिणाम दिखाता है जिन्हें हमने अपने कोड में निष्पादित किया था। तो, इस तरह, हम अपने C++ कोड में इस 'बूलियन डेटा प्रकार' का उपयोग करते हैं।
उदाहरण 4:
यहां, हम 'isHotDay' को 'बूल' वेरिएबल के रूप में टाइप करते हैं और इसे 'गलत' से आरंभ करते हैं। अब, हम 'if' स्टेटमेंट का उपयोग करते हैं और 'isHotDay' को शर्त के रूप में पास करते हैं। यदि 'isHotDay' शर्त पूरी हो जाती है तो 'if' के बाद आने वाला स्टेटमेंट अब निष्पादित हो जाता है। अन्यथा, 'अन्य' भाग इस बिंदु पर चलेगा।
अब, हमारे पास 'DoTask' बूलियन वैरिएबल है और इसे 'सही' पर सेट करें। इसके अलावा, हम 'टास्क_काउंट' नाम के 'इंट' वेरिएबल को भी इनिशियलाइज़ करते हैं। इसके बाद, हम 'while()' लूप डालते हैं। इस 'जबकि ()' लूप में, हम 'DoTask' को शर्त के रूप में रखते हैं। while लूप के अंदर, हम “Task_count++” लिखते हैं जिससे “Task_count” का मान 1 बढ़ जाता है।
जब यह कथन निष्पादित होता है, तो 'टास्क_काउंट' का मान 1 बढ़ जाता है। फिर, अगला 'काउट' कथन निष्पादित होता है। इसके बाद, हम फिर से एक शर्त रखते हैं जो कि “Task_count <9” है और इस शर्त को “DoTask” वेरिएबल को असाइन करते हैं। यह लूप तब तक काम करता है जब तक 'टास्क_काउंट' '9' से कम न हो जाए।
कोड 4:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( ) {
बूल हॉटडे है = असत्य ;
अगर ( हॉटडे है ) {
अदालत << 'आज गर्मी अधिक है!' << अंतः ;
} अन्य {
अदालत << 'यह गर्म दिन नहीं है' << अंतः ;
}
बूल डूटास्क = सत्य ;
int यहाँ कार्य_गणना = 0 ;
जबकि ( कार्य करें ) {
कार्य_गणना ++;
अदालत << 'यहाँ कार्य जारी है' << कार्य_गणना << अंतः ;
कार्य करें = ( कार्य_गणना < 9 ) ;
}
वापस करना 0 ;
}
आउटपुट:
यह आउटपुट हमारे द्वारा अपने कोड के माध्यम से की गई प्रत्येक क्रिया का परिणाम प्रदर्शित करता है। इस प्रकार, हम इस 'बूलियन डेटा प्रकार' को अपने C++ कोड में भी इस तरीके से नियोजित करते हैं।
उदाहरण 5:
अब, हम इस ट्यूटोरियल के अंतिम उदाहरण की ओर बढ़ते हैं। यहां, हम तीन अद्वितीय बूलियन वैरिएबल लेते हैं और दोनों को प्रिंट करते हैं। इसके बाद, हम इन बूलियन वेरिएबल्स पर 'AND', 'OR', और 'NOT' ऑपरेटर्स लागू करते हैं। साथ ही, सभी ऑपरेशनों का परिणाम बूलियन रूप में संग्रहीत किया जाता है क्योंकि हमने उन सभी वेरिएबल्स के साथ 'बूल' जोड़ा है जिनमें इन ऑपरेशनों का परिणाम संग्रहीत है। इसके बाद, हम इन ऑपरेशनों के नतीजे को फिर से बूलियन में प्रिंट करते हैं।
कोड 5:
#शामिलनेमस्पेस एसटीडी का उपयोग करना ;
int यहाँ मुख्य ( )
{
बूल वैल्यू_1 = सत्य ;
बूल वैल्यू_2 = असत्य ;
बूल वैल्यू_3 = सत्य ;
अदालत << 'मान_1 है' << मान_1 << अंतः ;
अदालत << 'मान_2 है' << मान_2 << अंतः ;
अदालत << 'मान_3 है' << मूल्य_3 << अंतः << अंतः ;
बूल परिणाम_1 = ( मान_1 || मूल्य_3 ) && मान_1 ;
बूल परिणाम_2 = मान_1 && मान_2 ;
बूल परिणाम_3 = मान_2 || मूल्य_3 ;
बूल परिणाम_4 = ! मूल्य_3 ;
बूल परिणाम_5 = ! मान_2 ;
बूल परिणाम_6 = ! मान_1 ;
अदालत << 'परिणाम 1 है = ' << परिणाम_1 << अंतः ;
अदालत << 'परिणाम 2 है = ' << परिणाम_2 << अंतः ;
अदालत << 'परिणाम 3 है = ' << परिणाम_3 << अंतः ;
अदालत << 'परिणाम 4 है = ' << परिणाम_4 << अंतः ;
अदालत << 'परिणाम 5 है = ' << परिणाम_5 << अंतः ;
अदालत << 'परिणाम 6 है = ' << परिणाम_6 << अंतः ;
}
आउटपुट:
यहाँ परिणाम है. हम देख सकते हैं कि प्रत्येक ऑपरेशन का परिणाम '0' और '1' के रूप में प्रदर्शित होता है क्योंकि 'बूल' डेटा प्रकार का उपयोग किया जाता है।
निष्कर्ष
इस ट्यूटोरियल में, हमने दिखाया कि C++ में बूलियन डेटा प्रकार का उपयोग कैसे किया जाता है और बूलियन डेटा प्रकार का परिणाम क्या होता है। हमने उन उदाहरणों का पता लगाया जिनमें हमने इस बूलियन डेटा प्रकार का उपयोग किया था। हमने देखा है कि यह बूलियन डेटा प्रकार प्रभावी और सीधा है, लेकिन गलतियों को रोकने के लिए इसका सावधानीपूर्वक उपयोग करना आवश्यक है।