यह सवाल गूंगा लग सकता है, लेकिन प्रोग्रामिंग भाषाओं के लिए किसी भी अन्य [पूर्णांक] मूल्य का 0मूल्यांकन क्यों होता है ?falsetrue

स्ट्रिंग तुलना

चूँकि प्रश्न थोड़ा सा सरल लगता है, इसलिए मैं खुद को थोड़ा और समझाऊंगा: सबसे पहले, यह किसी भी प्रोग्रामर को स्पष्ट लग सकता है, लेकिन एक प्रोग्रामिंग भाषा क्यों नहीं होगी - वास्तव में कोई भी हो सकता है, लेकिन नहीं मैंने इस्तेमाल किया - जहां और सभी [पूर्णांक] मूल्यों का 0मूल्यांकन trueकरता है false? यह एक टिप्पणी यादृच्छिक लग सकती है, लेकिन मेरे पास कुछ उदाहरण हैं जहां यह एक अच्छा विचार हो सकता है। सबसे पहले, चलो तीन-तरफा तुलनाओं का strcmpउदाहरण लेते हैं, मैं C का उदाहरण लूंगा: C कोई भी प्रोग्रामर जो C को अपनी पहली भाषा के रूप में आज़मा रहा है, वह निम्नलिखित कोड लिखने के लिए लुभा सकता है:

if (strcmp(str1, str2)) { // Do something... }

चूंकि strcmpरिटर्न 0जो कि मूल्यांकन करता है falseकि तार कब समान हैं, शुरुआत प्रोग्रामर ने जो करने की कोशिश की वह बुरी तरह से विफल हो जाता है और वह आमतौर पर समझ नहीं पाता है कि पहले क्यों। इसके बजाय 0मूल्यांकन किया गया था true, तो इस फ़ंक्शन का उपयोग इसकी सबसे सरल अभिव्यक्ति में किया जा सकता है - ऊपर वाला - जब समानता की तुलना करता है, -1और 1जरूरत पड़ने पर ही उचित जांच करता है और किया जाता था। हमने boolअधिकांश समय वापसी के प्रकार (हमारे दिमाग में मेरा मतलब है) के रूप में माना होगा ।

इसके अलावा, आइए एक नए प्रकार का परिचय दें sign, जो कि केवल मान लेता है -1, 0और 1। यह बहुत आसान हो सकता है। कल्पना कीजिए कि C ++ में एक स्पेसशिप ऑपरेटर है और हम इसे चाहते हैं std::string(ठीक है, पहले से ही compareफंक्शन है, लेकिन स्पेसशिप ऑपरेटर अधिक मजेदार है)। घोषणा वर्तमान में निम्नलिखित एक होगी:

sign operator<=>(const std::string& lhs, const std::string& rhs);

का 0मूल्यांकन किया गया था true, तो अंतरिक्ष यान ऑपरेटर भी मौजूद नहीं होगा, और हम operator==इस तरह से घोषणा कर सकते थे :

sign operator==(const std::string& lhs, const std::string& rhs);

यह एक operator==ही समय में तीन-तरह की तुलना को नियंत्रित करता था, और अभी भी निम्नलिखित जांच करने के लिए इस्तेमाल किया जा सकता है, जबकि यह जांचने में सक्षम है कि कौन सा स्ट्रिंग लेक्सिकोग्राफिक रूप से बेहतर है जब जरूरत हो।

if (str1 == str2) { // Do something... }

पुरानी त्रुटियों को संभालना

अब हमारे पास अपवाद हैं, इसलिए यह हिस्सा केवल उन पुरानी भाषाओं पर लागू होता है जहां ऐसी कोई चीज मौजूद नहीं है (उदाहरण के लिए C)। यदि हम C की मानक लाइब्रेरी (और POSIX एक भी) को देखते हैं, तो हम यह सुनिश्चित कर सकते हैं कि 0सफल होने के बाद maaaaany फ़ंक्शन वापस आए और अन्यथा कोई पूर्णांक। मैंने दुख की बात है कि कुछ लोग इस तरह की चीजें करते हैं:

#define TRUE 0
// ...
if (some_function() == TRUE)
{
    // Here, TRUE would mean success...
    // Do something
}

यदि हम सोचते हैं कि हम प्रोग्रामिंग में कैसे सोचते हैं, तो हमारे पास अक्सर निम्नलिखित तर्क पैटर्न होते हैं:

Do something
Did it work?
Yes ->
    That's ok, one case to handle
No ->
    Why? Many cases to handle

अगर हम इसके बारे में फिर से विचार करते हैं, तो इसका मतलब केवल तटस्थ मूल्य को 0, टू yes(और यही है कि C के कार्य कैसे काम करते हैं) को माना जाता है, जबकि अन्य सभी मानों के कई मामलों को हल करने के लिए हो सकते हैं no। हालाँकि, मुझे पता है कि सभी प्रोग्रामिंग भाषाओं में (शायद कुछ प्रायोगिक esotheric भाषाओं को छोड़कर), जो किसी स्थिति में yesमूल्यांकन करता है , जबकि सभी मामलों का मूल्यांकन करते हैं । कई परिस्थितियां हैं जब "यह काम करता है" एक मामले का प्रतिनिधित्व करता है जबकि "यह काम नहीं करता है" कई संभावित कारणों का प्रतिनिधित्व करता है। अगर हम इसके बारे में इस तरह से सोचते हैं, तो बाकी का मूल्यांकन करने के लिए और अधिक समझ में आता है।falseifnotrue0truefalse

निष्कर्ष

मेरा निष्कर्ष अनिवार्य रूप से मेरा मूल प्रश्न है: हमने भाषाओं को क्यों डिज़ाइन किया 0है falseऔर अन्य मूल्य कहां हैं true, ऊपर मेरे कुछ उदाहरणों को ध्यान में रखते हुए और शायद कुछ और मैंने नहीं सोचा था?

अनुवर्ती: यह देखना अच्छा है कि कई विचारों के साथ कई उत्तर हैं और इसके लिए कई संभावित कारण जैसे हैं। मैं प्यार करता हूँ कि आप इसके बारे में कितना भावुक लग रहे हैं। मैंने मूल रूप से बोरियत से यह सवाल पूछा था, लेकिन जब से आप इतने भावुक लग रहे हैं, मैंने थोड़ा और आगे बढ़ने का फैसला किया और Math.SE पर बूलियन पसंद के लिए 0 और 1 के पीछे तर्क के बारे में पूछा :)

language-design history error-handling

— Morwenn
स्रोत

32

strcmp()सही या गलत के लिए कोई अच्छा उदाहरण नहीं है, क्योंकि यह 3 विभिन्न मूल्यों को लौटाता है। और जब आप एक शेल का उपयोग करना शुरू करेंगे, तो आप आश्चर्यचकित होंगे, जहां 0 का मतलब सच है और कुछ भी गलत का मतलब है।

— ott--

52

@ ott--: यूनिक्स के गोले में, 0 का अर्थ है सफलता और गैर-शून्य का अर्थ है असफलता - बिल्कुल "सत्य" और "असत्य" जैसी बात नहीं है।

— कीथ थॉम्पसन

14

@KeithThompson: बैश (और अन्य गोले) में, "सफलता" और "विफलता" वास्तव में "सच" और "झूठे" के समान हैं। उदाहरण के लिए, कथन पर विचार करें, if true ; then ... ; fiजहां trueएक कमांड है जो शून्य देता है और यह ifचलाने के लिए कहता है ...।

— बरबाद

13

हार्डवेयर में कोई बूलियन नहीं हैं, केवल बाइनरी नंबर, और अधिकांश ऐतिहासिक ISAs में एक गैर-शून्य संख्या को सभी सशर्त शाखाओं के निर्देशों में "सच" माना जाता है (जब तक कि वे इसके बजाय झंडे का उपयोग नहीं कर रहे हों)। इसलिए, निम्न स्तर की भाषाएं अंतर्निहित हार्डवेयर गुणों का पालन करने के लिए बाध्य हैं।

— एसके-तर्क

2

@MasonWheeler एक बूलियन प्रकार होने का मतलब कुछ भी नहीं है। उदाहरण के लिए अजगर करता है एक है boolप्रकार लेकिन तुलना / किसी भी वापसी मान की स्थिति आदि कर सकते हैं।

— बाकुरी

98

0ऐसा falseइसलिए है क्योंकि वे दोनों सामान्य सेमिनारों में शून्य तत्व हैं । भले ही वे अलग-अलग डेटा प्रकार हैं, लेकिन यह उनके बीच परिवर्तित करने के लिए सहज ज्ञान युक्त बनाता है क्योंकि वे आइसोमॉर्फिक बीजीय संरचनाओं से संबंधित हैं।

0गुणन के लिए जोड़ और शून्य की पहचान है। यह पूर्णांकों और परिमेय है, लेकिन के लिए सच है नहीं आईईईई-754 चल बिन्दु संख्या: 0.0 * NaN = NaNऔर 0.0 * Infinity = NaN।
falseबूलियन के लिए पहचान है XOR (⊻) और शून्य बूलियन के लिए और (∧)। यदि बूलियंस को {0, 1} के रूप में दर्शाया जाता है - पूर्णांक मोडुलो 2 का सेट - आप कैरी के बिना carry के अलावा और गुणा के रूप में सोच सकते हैं।
""और []संघनन के लिए पहचान है, लेकिन कई ऑपरेशन हैं जिनके लिए वे शून्य के रूप में समझ में आते हैं। पुनरावृत्ति एक है, लेकिन पुनरावृत्ति और संघनन वितरित नहीं करते हैं, इसलिए ये ऑपरेशन एक संगोष्ठी नहीं बनाते हैं।

इस तरह के निहितार्थ रूपांतरण छोटे कार्यक्रमों में सहायक होते हैं, लेकिन बड़े कार्यक्रमों के बारे में तर्क करना मुश्किल बना सकते हैं। भाषा डिजाइन में कई ट्रेडऑफ्स में से एक।

— जॉन पंडी
स्रोत

1

अच्छा लगा कि आपने सूचियों का उल्लेख किया। (बीटीडब्लू, कॉमन लिस्प में nilखाली सूची []और falseमूल्य दोनों है ; क्या विभिन्न डेटा प्रकारों की पहचान को मर्ज करने की प्रवृत्ति है?) आपको अभी भी यह समझाना होगा कि एक अशिष्ट पहचान के रूप में असत्य पर विचार करना और गुणन पहचान के रूप में सच क्यों है? और दूसरा रास्ता नहीं। के trueलिए पहचान ANDऔर शून्य के रूप में विचार करना संभव नहीं है OR?

— जियोर्जियो

3

समान पहचानों का संदर्भ देने के लिए +1। अंत में एक जवाब जो सिर्फ "सम्मेलन, इसके साथ सौदा करने" के लिए उबाल नहीं करता है।

— l0b0

5

एक ठोस और बहुत पुराने गणित का विवरण देने के लिए +1 जिसमें इस का पालन किया गया है और लंबे समय से समझ में आता है

— जिमी होफा

1

इस जवाब का कोई मतलब नहीं है। trueयह भी पहचान और सेमीरिंग्स (बुलियन और / या) का शून्य है। कोई कारण नहीं है, विचार करने के falseलिए करीब 0 से , सम्मेलन सम्मेलन है true।

— टोनियोएलिग्रिंगो

1

@TonioElGringo: सच्चे और झूठे के बीच अंतर XOR और XNOR के बीच का अंतर है। AND और XOR का उपयोग करके एक आइसोमॉर्फिक रिंग बना सकता है, जहां सही गुणक पहचान है और योजक के साथ गलत है, या OR और XNOR के साथ, जहां असत्य गुणक पहचान है और सत्य योजक है, लेकिन XOROR आमतौर पर एक आम नहीं माना जाता है मौलिक ऑपरेशन जिस तरह से XOR है।

— सुपरकैट

74

क्योंकि गणित काम करता है।

FALSE OR TRUE is TRUE, because 0 | 1 is 1.

... insert many other examples here.

परंपरागत रूप से, C कार्यक्रमों की स्थिति ऐसी होती है

if (someFunctionReturningANumber())

बजाय

if (someFunctionReturningANumber() != 0)

क्योंकि शून्य की अवधारणा झूठी के बराबर है, अच्छी तरह से समझा जाता है।

— रॉबर्ट हार्वे
स्रोत

21

भाषाओं को इस तरह डिज़ाइन किया गया है क्योंकि गणित समझ में आता है। वह पहले आया था।

— रॉबर्ट हार्वे

26

@ मॉर्वेन, यह 19 वीं शताब्दी और जॉर्ज बोले के पास वापस जाता है। लोग अब तक कंप्यूटर के रूप में 0 और सच के रूप में 0 का प्रतिनिधित्व करते रहे हैं।

— चार्ल्स ई। ग्रांट

11

मैं यह नहीं देखता कि गणित दूसरे तरीके से काम क्यों नहीं करता है यदि आप केवल सभी परिभाषाओं को बदलते हैं ताकि AND + और OR हो *।

— नील जी

7

वास्तव में: गणित दोनों तरीकों से काम करता है और इस प्रश्न का उत्तर ऐसा लगता है कि यह विशुद्ध रूप से पारंपरिक है।

— नील जी

6

@Robert यह बहुत अच्छा होगा यदि आप अपनी पोस्ट में "गणितीय कमियों" को निकाल सकते हैं।

— प्रेत ०

38

जैसा कि दूसरों ने कहा है, गणित पहले आया था। इसी कारण 0 है falseऔर 1 है true।

हम किस गणित की बात कर रहे हैं? बूलियन बीजगणित जो 1800 के दशक के मध्य से आता है, बहुत पहले डिजिटल कंप्यूटर के साथ आया था।

आप यह भी कह सकते हैं कि सम्मेलन प्रस्ताववादी तर्क से निकला है , जो बूलियन बीजगणित से भी पुराना है। यह बहुत सारे तार्किक परिणामों की औपचारिकता है जो प्रोग्रामर जानते हैं और प्यार करते हैं ( false || xबराबर x, true && xबराबर xऔर इतने पर)।

मूल रूप से हम दो तत्वों के साथ एक सेट पर अंकगणित के बारे में बात कर रहे हैं। बाइनरी में गिनती के बारे में सोचो। बूलियन बीजगणित इस अवधारणा और इसके सैद्धांतिक आधार के मूल हैं। C जैसी भाषाओं का कन्वेंशन केवल एक सीधा अनुप्रयोग है।

— joshin4colours
स्रोत

2

आप सुनिश्चित कर सकते हैं। लेकिन इसे "मानक" तरीके से रखना सामान्य अंकगणित (0 + 1 = 1 नहीं, 0 + 1 = 0) के साथ अच्छी तरह से फिट बैठता है।

— joshin4colours

2

हां, लेकिन यदि आप परिभाषाओं को उलट देते हैं, तो आप संभवतः और * और + के साथ * लिखेंगे।

— नील जी

3

गणित पहले नहीं आया था। गणित ने माना कि 0 और 1 एक क्षेत्र बनाते हैं, जिसमें AND गुणा की तरह होता है और OR इसके अतिरिक्त होता है।

— कज़

1

@ काज़: लेकिन OR और AND के साथ {0, 1} एक फ़ील्ड नहीं बनाता है।

— जियोर्जियो

2

यह मुझे थोड़ा परेशान करता है कि अधिक उत्तर और टिप्पणियाँ कहती हैं true = 1। यह बिल्कुल सटीक नहीं है, क्योंकि true != 0जो बिल्कुल समान नहीं है। एक कारण (केवल एक ही नहीं) क्यों की तुलना से बचना चाहिए if(something == true) { ... }।

— 20

26

मैंने सोचा कि यह इलेक्ट्रॉनिक्स से "विरासत" के साथ करना था, और बूलियन बीजगणित भी, जहां

0= off, negative, no,false
1= on, positive, yes,true

strcmp रिटर्न 0 जब स्ट्रिंग्स समान होते हैं तो इसके कार्यान्वयन के साथ क्या करना है, क्योंकि यह वास्तव में क्या करता है दो स्ट्रिंग्स के बीच "दूरी" की गणना करना है। उस 0 को भी झूठा माना जाना महज एक संयोग है।

सफलता पर 0 लौटने से समझ में आता है क्योंकि इस मामले में 0 का अर्थ है कि कोई त्रुटि नहीं है और किसी भी अन्य संख्या में त्रुटि कोड होगा। सफलता के लिए किसी अन्य संख्या का उपयोग करना कम समझ में आता है क्योंकि आपके पास केवल एक ही सफलता कोड है, जबकि आपके पास कई त्रुटि कोड हो सकते हैं। आप "यह काम किया?" जैसा कि यदि कथन अभिव्यक्ति है और कहे 0 = हां अधिक अर्थ लगाएगा, लेकिन अभिव्यक्ति अधिक सही ढंग से है "क्या कुछ गलत हुआ?" और फिर आप देखते हैं कि 0 = नहीं बहुत मायने रखता है। false/trueवास्तव में यहाँ सोचने का कोई मतलब नहीं है, क्योंकि यह वास्तव में है no error code/error code।

— Svish
स्रोत

Haha, आप पहले वाले हैं जो रिटर्न एरर क्वेश्चन प्रश्न को स्पष्ट रूप से बताता है। मुझे पहले से ही पता था कि मैंने इसे अपने तरीके से व्याख्या की है और यह दूसरे तरीके से पूछ सकता है, लेकिन आप इसे स्पष्ट रूप से व्यक्त करने वाले हैं (कई उत्तरों और टिप्पणियों में से)। वास्तव में, मैं यह नहीं कहूंगा कि एक या दूसरे तरीके का कोई मतलब नहीं है, लेकिन अधिक यह है कि दोनों अलग-अलग तरीकों से समझ बनाते हैं :)

— Morwenn

1

असल में मैं कहना चाहता हूँ 0के लिए success/no errorकेवल एक चीज है कि समझ में आता है, जब अन्य पूर्णांकों त्रुटि कोड का प्रतिनिधित्व करते है। यह 0भी falseअन्य मामलों में प्रतिनिधित्व करने के लिए होता है, वास्तव में कोई फर्क नहीं पड़ता, क्योंकि हम यहाँ सच या झूठ के बारे में बात नहीं कर रहे हैं;)

— श्वेत

मेरे पास एक ही विचार था इसलिए मैंने

— छीन लिया

1

strcmp()दूरी की गणना के बारे में आपकी बात काफी अच्छी है। अगर इसे बुलाया गया होता strdiff()तो if (!strdiff())बहुत तार्किक होता।

— केविन कॉक्स

"इलेक्ट्रॉनिक्स [...] जहां 0 = [...] गलत, 1 = [...] सच" - यहां तक कि इलेक्ट्रॉनिक्स में, यह केवल एक सम्मेलन है , और केवल एक ही नहीं है। हम इस सकारात्मक तर्क को कहते हैं, लेकिन आप नकारात्मक तर्क का भी उपयोग कर सकते हैं, जहां एक सकारात्मक वोल्टेज गलत इंगित करता है और नकारात्मक सच इंगित करता है। फिर, जिस सर्किट का आप उपयोग करते हैं और वह OR हो जाता है, या वह AND और इसी तरह से चालू हो जाता है। डी मॉर्गन के कानून के कारण, यह सभी समतुल्य है। कभी-कभी, आप सुविधा के लिए नकारात्मक तर्क में लागू एक इलेक्ट्रॉनिक सर्किट का हिस्सा पाएंगे, जिस बिंदु पर उस हिस्से में संकेतों के नाम उनके ऊपर एक पट्टी के साथ नोट किए गए हैं।

— जूल्स

18

के रूप में में विस्तार से बताया इस लेख , मूल्यों falseऔर trueपूर्णांकों 0 और 1 के साथ भ्रमित नहीं किया जाना चाहिए, लेकिन दो तत्वों (देखें के गाल्वा क्षेत्र (परिमित क्षेत्र) के तत्वों के साथ पहचाना जा सकता है यहाँ )।

एक फ़ील्ड दो ऑपरेशन के साथ एक सेट है जो कुछ स्वयंसिद्ध को संतुष्ट करता है।

प्रतीकों 0 और 1 का उपयोग पारंपरिक रूप से किसी क्षेत्र की योगात्मक और गुणात्मक पहचान को दर्शाने के लिए किया जाता है क्योंकि वास्तविक संख्याएं भी एक फ़ील्ड हैं (लेकिन एक परिमित नहीं) जिनकी पहचान संख्या 0 और 1 हैं।

योगात्मक पहचान क्षेत्र का तत्व 0 है, जैसे कि सभी x के लिए:

x + 0 = 0 + x = x

और गुणात्मक पहचान क्षेत्र का तत्व 1 है, जैसे कि सभी x के लिए:

x * 1 = 1 * x = x

दो तत्वों के परिमित क्षेत्र में केवल ये दो तत्व होते हैं, यथा योज्य पहचान 0 (या false) और गुणक पहचान 1 (या true)। इस क्षेत्र के दो संचालन तार्किक XOR (+) और तार्किक AND (*) हैं।

ध्यान दें। यदि आप ऑपरेशन को फ्लिप करते हैं (XOR गुणा है और AND जोड़ है) तो गुणा अधिक जोड़ नहीं है और आपके पास कोई फ़ील्ड नहीं है। ऐसे मामले में आपके पास दो तत्वों 0 और 1 (किसी भी क्रम में) को कॉल करने का कोई कारण नहीं है। यह भी ध्यान दें कि आप ऑपरेशन का चयन नहीं कर सकते हैं या XOR के बजाय: कोई फर्क नहीं पड़ता कि आप कैसे / या इसके अलावा / गुणा के रूप में व्याख्या करते हैं, जिसके परिणामस्वरूप संरचना एक फ़ील्ड नहीं है (सभी व्युत्क्रम तत्व फ़ील्ड एक्सिओम्स द्वारा आवश्यक के रूप में मौजूद नहीं हैं)।

सी कार्यों के बारे में:

कई फ़ंक्शन एक पूर्णांक लौटाते हैं जो एक त्रुटि कोड है। 0 का मतलब NO ERROR है।
वास्तव में, फ़ंक्शन strcmpदो तारों के बीच अंतर की गणना करता है। ० का अर्थ है कि दो तारों में कोई अंतर नहीं है, अर्थात दो तार बराबर हैं।

उपरोक्त सहज ज्ञान युक्त व्याख्याएँ रिटर्न मानों की व्याख्या को याद रखने में मदद कर सकती हैं, लेकिन लाइब्रेरी दस्तावेज़ों की जाँच करना और भी आसान है।

— जियोर्जियो
स्रोत

1

+1 यह दिखाने के लिए कि यदि आप मनमाने ढंग से इन स्वैप करते हैं, तो गणित अब काम नहीं करता है।

— जिमी होफा

2

फ़्लिप: दो तत्वों और संचालन * और + के साथ एक क्षेत्र को देखते हुए, हम 0 के साथ True की पहचान करते हैं और 1. के साथ गलत। हम + के साथ * और XOR की पहचान करते हैं।

— नील जी

1

आप पाएंगे कि ये दोनों पहचान एक ही क्षेत्र में की गई हैं और दोनों बूलियन तर्क के नियमों के अनुरूप हैं। आपका नोट दुर्भाग्य से गलत है :)

— नील जी

1

यदि आप मानते हैं कि True = 0, और XOR + है, तो True को XOR की पहचान होना चाहिए। लेकिन ऐसा नहीं है क्योंकि ट्रू XOR ट्रू = गलत है। जब तक आप ऑपरेशन XOR को True पर फिर से परिभाषित न करें ताकि True XOR True = True हो। फिर निश्चित रूप से आपका निर्माण कार्य करता है क्योंकि आपने केवल चीजों का नाम बदला है (किसी भी गणितीय संरचना में आप हमेशा सफलतापूर्वक एक नाम क्रमचय बना सकते हैं और एक आइसोमोर्फिक संरचना प्राप्त कर सकते हैं)। दूसरी ओर, यदि आप इसे सही मानते हैं, तो गलत और XOR का सामान्य अर्थ है, तो True XOR True = गलत और सत्य Additive नहीं हो सकता है, अर्थात True 0. नहीं हो सकता है

— Giorgio

1

@ जियोर्जियो: मैंने अपनी टिप्पणी के अनुसार अपने निर्माण को अपनी पिछली टिप्पणी में ठीक किया ...

— नील जी

13

आपको यह विचार करना चाहिए कि वैकल्पिक सिस्टम भी डिजाइन के स्वीकार्य निर्णय हो सकते हैं।

गोले: 0 निकास स्थिति सत्य है, गैर-शून्य गलत है

0 से बाहर निकलने की स्थिति को सही मानने वाले गोले का उदाहरण पहले ही उल्लेख किया जा चुका है।

$ ( exit 0 ) && echo "0 is true" || echo "0 is false"
0 is true
$ ( exit 1 ) && echo "1 is true" || echo "1 is false"
1 is false

वहाँ तर्क यह है कि सफल होने का एक तरीका है, लेकिन असफल होने के कई तरीके हैं, इसलिए 0 का उपयोग विशेष मूल्य के रूप में किया जाता है जिसका अर्थ है "कोई त्रुटि नहीं" व्यावहारिक है।

रूबी: 0 किसी भी अन्य संख्या की तरह है

"सामान्य" प्रोग्रामिंग भाषाओं में, रूबी जैसे कुछ आउटलेर हैं, जो 0 को एक सच्चे मूल्य के रूप में मानते हैं।

$ irb
irb(main):001:0> 0 ? '0 is true' : '0 is false'
=> "0 is true"

तर्क है कि केवल है falseऔर nilझूठी होना चाहिए। कई रूबी नौसिखियों के लिए, यह एक गोच है। हालाँकि, कुछ मामलों में, यह अच्छा है कि 0 को किसी अन्य संख्या की तरह ही माना जाता है।

irb(main):002:0> (pos = 'axe' =~ /x/) ? "Found x at position #{pos}" : "x not found"
=> "Found x at position 1"
irb(main):003:0> (pos = 'xyz' =~ /x/) ? "Found x at position #{pos}" : "x not found"
=> "Found x at position 0"
irb(main):004:0> (pos = 'abc' =~ /x/) ? "Found x at position #{pos}" : "x not found"
=> "x not found"

हालांकि, ऐसी प्रणाली केवल एक ऐसी भाषा में काम करती है जो संख्याओं से एक अलग प्रकार के रूप में बूलियन को भेद करने में सक्षम है। कंप्यूटिंग के पहले के दिनों में, असेंबली भाषा या कच्ची मशीन की भाषा के साथ काम करने वाले प्रोग्रामर के पास ऐसी कोई विलासिता नहीं थी। संभवतः "रिक्त" स्थिति के रूप में 0 का इलाज करना स्वाभाविक है, और एक ध्वज के रूप में 1 को थोड़ा सेट करें जब कोड का पता चला कि कुछ हुआ है। विस्तार से, कन्वेंशन ने विकसित किया कि शून्य को झूठा माना गया, और गैर-शून्य मानों को सच माना गया। हालाँकि, यह उस तरह से नहीं है।

जावा: नंबरों को बूलियन के रूप में नहीं माना जा सकता है

जावा में, trueऔर falseकेवल बूलियन मान हैं। संख्याएं बूलियन नहीं हैं, और उन्हें बूलियंस में भी नहीं डाला जा सकता है ( जावा भाषा विनिर्देश, Sec 4.2.2 ):

अभिन्न प्रकार और प्रकार के बीच कोई जाति नहीं हैं boolean।

यह नियम पूरी तरह से प्रश्न से बचता है - सभी बूलियन अभिव्यक्तियों को कोड में स्पष्ट रूप से लिखा जाना है।

— 200_success
स्रोत

1

Rebol और Red दोनों 0-मूल्यवान इंटीजर का इलाज करते हैं! मूल्यों के रूप में सच है, और एक अलग कोई नहीं है! प्रकार (केवल एक मान के साथ, कोई भी) लोगो के अलावा सशर्त असत्य के रूप में माना जाता है! असत्य। मैंने जावास्क्रिप्ट कोड लिखने की कोशिश में महत्वपूर्ण निराशा पाई है जो 0 को झूठा मानता है; यह गतिशील रूप से टाइप की गई भाषा के लिए एक अविश्वसनीय रूप से स्पष्ट निर्णय है। यदि आप कुछ ऐसा परीक्षण करना चाहते हैं जो शून्य हो सकता है या 0 आप लिखना बंद कर सकते हैं if (thing === 0), तो यह सिर्फ शांत नहीं है।

— HostileFork

@HostileFork मुझे नहीं पता। मुझे लगता है कि यह भावना है कि बनाता 0है true(हर दूसरे पूर्णांक के रूप में) एक गतिशील भाषा में। मैं कभी-कभी पायथन में 0पकड़ने की कोशिश करते समय पकड़ने के लिए हुआ None, और कभी-कभी स्पॉट करने के लिए बहुत मुश्किल हो सकता है।

— मॉर्वन

2

रूबी एक बाहरी नहीं है। रूबी इसे लिस्प से लेती है (रूबी को गुप्त रूप से "मैत्ज़लिस्प" भी कहा जाता है)। कंप्यूटर विज्ञान में लिस्प एक मुख्य धारा की भाषा है। शून्य भी POSIX खोल में एक सही मूल्य है, क्योंकि यह पाठ का एक टुकड़ा है if [ 0 ] ; then echo this executes ; fi:। गलत डेटा मान एक रिक्त स्ट्रिंग है, और एक परीक्षण योग्य झूठ एक कमांड की एक असफल समाप्ति स्थिति है, जिसे गैर- मेज़र द्वारा दर्शाया गया है ।

— कज़

8

सामान्य मामले को संबोधित करने से पहले, हम आपके काउंटर उदाहरणों पर चर्चा कर सकते हैं।

स्ट्रिंग तुलना

एक ही तरह की तुलना कई तरह की होती है। इस तरह की तुलना दो वस्तुओं के बीच की दूरी की गणना करती है । जब वस्तुएँ समान होती हैं, तो दूरी कम से कम होती है। तो जब "तुलना सफल होता है", मूल्य 0. है लेकिन वास्तव में, के रिटर्न मान strcmpहै नहीं एक बूलियन, यह एक दूरी है, और क्या फंसा लेती है कि अनजान प्रोग्रामर कर if (strcmp(...)) do_when_equal() else do_when_not_equal()।

C ++ में हम strcmpकिसी Distanceऑब्जेक्ट को वापस करने के लिए रिडिजाइन कर सकते हैं , जो operator bool()0 पर सही होने पर ओवरराइड करता है (लेकिन तब आपको समस्याओं के एक अलग सेट से काट लिया जाएगा)। या सादे सी में सिर्फ एक streqफ़ंक्शन होता है जो स्ट्रिंग्स के बराबर होने पर 1 रिटर्न देता है, और 0 अन्यथा।

एपीआई कॉल / प्रोग्राम एग्जिट कोड

यहाँ आप इस कारण की परवाह करते हैं कि कुछ गलत हो गया है, क्योंकि इससे निर्णय गलत हो जाएंगे। जब चीजें सफल होती हैं, तो आप विशेष रूप से कुछ भी जानना नहीं चाहते हैं - आपकी मंशा का एहसास होता है। इसलिए वापसी का मूल्य इस जानकारी को व्यक्त करना चाहिए। यह एक बूलियन नहीं है, यह एक त्रुटि कोड है। विशेष त्रुटि मान 0 का अर्थ है "कोई त्रुटि नहीं"। शेष सीमा स्थानीय स्तर पर सार्थक त्रुटियों का प्रतिनिधित्व करती है जिनसे आपको निपटना पड़ता है (1 सहित, जिसका अक्सर अर्थ "अनिर्दिष्ट त्रुटि" होता है)।

सामान्य मामला

यह हमें इस सवाल के साथ छोड़ देता है: बूलियन मान Trueऔर Falseक्रमशः 1 और 0 के साथ क्यों दर्शाए जाते हैं?

खैर, व्यक्तिपरक "यह इस तरह से बेहतर लगता है" तर्क के अलावा, यहां कुछ कारण हैं (व्यक्तिपरक भी) मैं इसके बारे में सोच सकता हूं:

विद्युत परिपथ सादृश्य। वर्तमान 1s के लिए चालू है, और 0 के लिए OFF है। मुझे एक साथ (1, हां, सच, चालू) और एक मिश्रण के बजाय (0, नहीं, गलत, बंद) पसंद है
स्मृति आरंभीकरण। जब मैं memset(0)चर का एक गुच्छा (उन्हें ints, तैरता है, बूल हो) मैं चाहता हूं कि उनका मूल्य सबसे रूढ़िवादी मान्यताओं से मेल खाए। उदा। मेरा योग प्रायः 0 है, विधेय मिथ्या है, आदि।

हो सकता है कि ये सभी कारण मेरी शिक्षा से जुड़े हों - अगर मुझे शुरुआत से ही 0 के साथ जुड़ना सिखाया गया था, तो मैं दूसरे रास्ते से जाऊँगा।

— user44761
स्रोत

2

वास्तव में कम से कम एक प्रोग्रामिंग भाषा है जो 0 को सच मानती है। यूनिक्स खोल।

— जान हुदेक

असली मुद्दे को संबोधित करने के लिए +1: मोर्वेन के अधिकांश प्रश्न बिल्कुल नहीं हैं bool।

— dan04

@ dan04 यह है। पूरे पोस्ट डाली की पसंद के पीछे तर्क के बारे में से है intकरने के लिए boolकई प्रोग्रामिंग भाषाओं में। तुलना और त्रुटि इशारों का सामान उन स्थानों के उदाहरण हैं जहां इसे वर्तमान में किए गए एक और तरीके से कास्टिंग करना समझ में आता है।

— मोरवीन

6

उच्च-स्तरीय परिप्रेक्ष्य से, आप तीन अलग-अलग डेटा प्रकारों के बारे में बात कर रहे हैं:

एक बूलियन। बूलियन बीजगणित में गणितीय सम्मेलन का उपयोग करने के लिए 0 falseऔर 1 के लिए है true, इसलिए यह उस सम्मेलन का पालन करने के लिए समझ में आता है। मुझे लगता है कि इस तरह से यह भी समझ में आता है।
तुलना का परिणाम। : यह तीन मूल्य हैं <, =और >(सूचना है कि उनमें से कोई भी है true)। उनके लिए यह क्रमश: -1, 0 और 1 के मूल्यों का उपयोग करने के लिए समझ में आता है (या, आमतौर पर, एक नकारात्मक मूल्य, शून्य और एक सकारात्मक मूल्य)।

यदि आप समानता की जांच करना चाहते हैं और आपके पास केवल एक फ़ंक्शन है जो सामान्य तुलना करता है, तो मुझे लगता है कि आपको कुछ का उपयोग करके इसे स्पष्ट करना चाहिए strcmp(str1, str2) == 0। मैं !इस स्थिति में भ्रमित होने का उपयोग कर पाता हूं , क्योंकि यह एक गैर-बूलियन मान के रूप में मानती है जैसे कि यह एक बूलियन था।

इसके अलावा, ध्यान रखें कि तुलना और समानता एक ही बात नहीं है। उदाहरण के लिए, यदि आप लोगों को उनके जन्म की तारीख से आदेश देते हैं, तो Compare(me, myTwin)उन्हें वापस लौटना चाहिए 0, लेकिन Equals(me, myTwin)वापस लौटना चाहिए false।
किसी कार्य की सफलता या विफलता, संभवतः उस सफलता या असफलता के बारे में विवरण के साथ भी। यदि आप विंडोज के बारे में बात कर रहे हैं, तो यह प्रकार कहा जाता है HRESULTऔर एक गैर-शून्य मान आवश्यक रूप से विफलता का संकेत नहीं देता है। वास्तव में, एक नकारात्मक मूल्य विफलता और गैर-नकारात्मक सफलता को इंगित करता है। सफलता का मूल्य बहुत बार है S_OK = 0, लेकिन यह उदाहरण के लिए S_FALSE = 1, या अन्य मूल्यों के लिए भी हो सकता है ।

भ्रम इस तथ्य से आता है कि तीन तार्किक रूप से भिन्न डेटा प्रकार वास्तव में C और कुछ अन्य भाषाओं में एकल डेटा प्रकार (पूर्णांक) के रूप में दर्शाए जाते हैं और आप किसी शर्त में पूर्णांक का उपयोग कर सकते हैं। लेकिन मुझे नहीं लगता कि शर्तों में कुछ गैर-बूलियन प्रकारों का उपयोग करना सरल बनाने के लिए बूलियन को फिर से परिभाषित करना समझ में आता है।

इसके अलावा, एक अन्य प्रकार पर विचार करें जो अक्सर सी में एक स्थिति में उपयोग किया जाता है: एक सूचक। वहां, एक- NULLपॉइंटर (जिसका प्रतिनिधित्व इस प्रकार है 0) के रूप में व्यवहार करना स्वाभाविक है false। इसलिए आपके सुझाव पर अमल करने से पॉइंटर्स के साथ काम करना भी मुश्किल हो जाएगा। (हालांकि, व्यक्तिगत रूप से, मैं स्पष्ट NULLरूप से बूलियन के रूप में व्यवहार करने के बजाय, बिंदुओं की तुलना करना पसंद करता हूं ।)

— svick
स्रोत

4

शून्य गलत हो सकता है क्योंकि अधिकांश सीपीयू में एक शून्य ध्वज होता है जिसे शाखा में उपयोग किया जा सकता है। यह एक तुलना ऑपरेशन बचाता है।

देखते हैं क्यों।

कुछ psuedocode, दर्शकों के रूप में शायद विधानसभा नहीं पढ़ते हैं

c- सोर्स सिंपल लूप वाइबल 10 बार कॉल करता है

for (int foo =10; foo>0; foo-- ) /* down count loop is shorter */
{  
   wibble();
}

उसके लिए कुछ ढोंग विधानसभा

0x1000 ld a 0x0a      'foo=10
0x1002 call 0x1234    'call wibble()
0x1005 dec a          'foo--
0x1006 jrnz -0x06      'jump back to 0x1000 if not zero
0x1008

c- सोर्स एक और सिंपल लूप वाइबल को 10 बार कॉल करता है

for (int foo =0; foo<10; foo-- ) /* up count loop is longer  */
{  
   wibble();
}

इस मामले के लिए कुछ ढोंग विधानसभा

0x1000 ld a 0x00      'foo=0
0x1002 call 0x1234    'call wibble()
0x1005 dec a          'foo--
0x1006 cmp 0x0a       'compare foo to 10 ( like a subtract but we throw the result away)
0x1008 jrns -0x08      'jump back to 0x1000 if compare was negative
0x100a

कुछ और सी स्रोत

int foo=10;
if ( foo ) wibble()

और विधानसभा

0x1000 ld a 0x10
0x1002 jz 0x3
0x1004 call 0x1234
0x1007

देखो कितना छोटा है?

कुछ और सी स्रोत

int foo=10;
if ( foo==0 ) wibble()

और असेंबली (एक मामूली स्मार्ट कंपाइलर मान सकते हैं जो == 0 को बिना किसी तुलना के बदल सकता है)

0x1000 ld a 0x10
0x1002 jz 0x3
0x1004 call 0x1234
0x1007

अब सत्य = 1 के एक सम्मेलन की कोशिश करते हैं

कुछ और c स्रोत #define TRUE 1 int foo = TRUE; अगर (foo == TRUE) वाइबल ()

और विधानसभा

0x1000 ld a 0x1
0x1002 cmp a 0x01
0x1004 jz 0x3
0x1006 call 0x1234
0x1009

देखते हैं कि नॉनज़रो ट्रू के साथ मामला कितना छोटा है?

वास्तव में शुरुआती सीपीयू में Accumulator से जुड़े झंडे के छोटे सेट थे।

यह जांचने के लिए कि आम तौर पर एक बी या ए = बी एक तुलना निर्देश लेता है।

जब तक बी या तो शून्य नहीं है - जिस स्थिति में शून्य ध्वज को एक साधारण तार्किक NOR के रूप में लागू किया गया है या एक्सीलेटर में सभी बिट्स हैं।
या NEGATIVE जिसमें आप "साइन बिट" का उपयोग करते हैं अर्थात यदि आप दो पूरक अंकगणित का उपयोग कर रहे हैं तो सबसे महत्वपूर्ण बिट है। (ज्यादातर हम करते हैं)

चलो यह आराम करो। कुछ पुराने CPU पर आपको ZERO के बराबर संचायक के लिए तुलना निर्देश का उपयोग करने की आवश्यकता नहीं थी, या संचयकर्ता शून्य से कम नहीं था।

अब आप देखें कि शून्य झूठा क्यों हो सकता है?

कृपया ध्यान दें कि यह पासीडो-कोड है और कोई वास्तविक निर्देश सेट ऐसा नहीं दिखता है। यदि आप असेंबली जानते हैं तो आपको पता है कि मैं यहां चीजों को सरल बना रहा हूं। यदि आप संकलक डिजाइन के बारे में कुछ भी जानते हैं, तो आपको इस उत्तर को पढ़ने की आवश्यकता नहीं है। जो कोई भी लूप अनरोलिंग या ब्रांच प्रीडिक्शन के बारे में कुछ भी जानता है, उन्नत क्लास रूम 203 में हॉल के नीचे है।

— टिम विलिसक्रॉफ्ट
स्रोत

2

आपकी बात यहाँ ठीक नहीं है क्योंकि एक चीज़ के लिए if (foo)और एक if (foo != 0)ही कोड उत्पन्न करना चाहिए, और दूसरी बात, आप यह दिखा रहे हैं कि आप जिस असेंबली भाषा का उपयोग कर रहे हैं, उसमें स्पष्ट बूलियन ऑपरेंड और उनके लिए परीक्षण हैं। उदाहरण के लिए jzसाधन jump if zero। दूसरे शब्दों में if (a == 0) goto target;। और मात्रा का सीधे परीक्षण भी नहीं किया जा रहा है; स्थिति को एक बूलियन ध्वज में परिवर्तित किया जाता है जिसे एक विशेष मशीन शब्द में संग्रहीत किया जाता है। यह वास्तव में अधिक पसंद हैcpu.flags.zero = (a == 0); if (cpu.flags.zero) goto target;

— कज़

कोई काज नहीं, पुराने सीपीयू ने ऐसा काम नहीं किया। Jz / jnz का तुलनात्मक निर्देश किए बिना किया जा सकता है। जो वास्तव में मेरे पूरे पोस्ट की तरह था।

— टिम विलक्रॉफ्ट

2

मैंने तुलनात्मक निर्देश के बारे में कुछ नहीं लिखा।

— कज़

क्या आप एक ऐसे प्रोसेसर का हवाला दे सकते हैं जिसमें एक jzनिर्देश है लेकिन नहीं jnz? (या सशर्त निर्देशों का कोई अन्य असममित सेट)

— टोबी स्पाइट नाइट

3

ऐसे बहुत से उत्तर हैं जो बताते हैं कि कुछ गणितीय संपत्ति द्वारा 1 और सच के बीच पत्राचार आवश्यक है। मुझे ऐसी कोई संपत्ति नहीं मिली और यह सुझाव दिया कि यह पूरी तरह से ऐतिहासिक सम्मेलन है।

दो तत्वों के साथ एक क्षेत्र को देखते हुए, हमारे पास दो ऑपरेशन हैं: जोड़ और गुणा। हम दो तरीकों से इस क्षेत्र पर बूलियन कार्यों को मैप कर सकते हैं:

परंपरागत रूप से, हम 1 के साथ True और 1 के साथ गलत की पहचान करते हैं। हम + के साथ * और XOR की पहचान करते हैं। इस प्रकार या इसके अलावा संतृप्त है।

हालाँकि, हम केवल 0 के साथ True को आसानी से पहचान सकते हैं और 1. के साथ गलत। फिर हम + और XNOR को + से पहचानते हैं। इस प्रकार और संतृप्त जोड़ रहा है।

— नील जी
स्रोत

4

यदि आपने विकिपीडिया पर लिंक का अनुसरण किया था, तो आप पा सकते हैं कि एक बूलियन बीजगणित की अवधारणा दो तत्वों के गैलोज क्षेत्र ( en.wikipedia.org/wiki/GF%282%29 ) के साथ संबंधित है । प्रतीक 0 और 1 का उपयोग पारंपरिक रूप से योज्य और गुणात्मक पहचान को दर्शाने के लिए किया जाता है, क्योंकि वास्तविक संख्याएं भी एक क्षेत्र हैं, जिनकी पहचान संख्या 0 और 1. हैं

— जियोर्जियो

1

@ नील मुझे लगता है कि जियोर्जियो यह कहना चाह रहा है कि यह सिर्फ एक सम्मेलन से अधिक है। बूलियन बीजगणित में 0 और 1 मूल रूप से GF (2) में 0 और 1 के समान हैं, जो कि जोड़ और गुणा के संबंध में वास्तविक संख्याओं में 0 और 1 के समान व्यवहार करता है।

— svick

1

@svick: नहीं, क्योंकि आप केवल गुणन और संतृप्तता का नाम बदलकर OR और AND कर सकते हैं और फिर लेबल को फ्लिप कर सकते हैं ताकि 0 सच हो और 1 गलत हो। जियोर्जियो कह रहा है कि यह बूलियन तर्क का एक सम्मेलन था, जिसे कंप्यूटर विज्ञान के एक सम्मेलन के रूप में अपनाया गया था।

— नील जी

1

@ नील जी: नहीं, आप फ्लिप + और * और 0 नहीं कर सकते हैं और 1 क्योंकि एक फ़ील्ड को इसके अतिरिक्त गुणन की वितरण की आवश्यकता होती है (देखें en.wikipedia.org/wiki/Field_%28mathematics%29 ), लेकिन यदि आप सेट +: = और AND और *: = XOR, आपको T XOR (T AND F) = T XOR F = T मिलता है, जबकि (T XOR T) और (T XOR F) = F AND T = F. इसलिए ऑपरेशन और पहचानों को छोड़कर किसी भी क्षेत्र में नहीं है। तो एक उपयुक्त क्षेत्र की पहचान के रूप में IMO 0 और 1 को परिभाषित करता है, जो झूठे और सच्चे को बहुत विश्वासपूर्वक कैप्चर करता है।

— जियोर्जियो

1

@ जियोर्जियो: मैंने यह स्पष्ट करने के लिए उत्तर संपादित किया है कि क्या चल रहा है।

— नील जी

3

अजीब बात है, शून्य हमेशा झूठ नहीं होता है।

विशेष रूप से, यूनिक्स और पॉज़िक्स सम्मेलन EXIT_SUCCESSको 0 (और EXIT_FAILURE1) के रूप में परिभाषित करना है । वास्तव में यह एक मानक सी सम्मेलन भी है !

तो पॉज़िक्स के गोले और बाहर निकलने के लिए (2) syscalls, 0 का अर्थ "सफल" है जो सहज रूप से झूठ की तुलना में अधिक सच है।

विशेष रूप से, शेल की ifएक "वापसी" EXIT_SUCCESS(जो 0 है) इसकी "तब" शाखा का पालन करना चाहती है !

स्कीम में (लेकिन आम लिस्प में या एमईएलटी में नहीं ) 0 और शून्य (यानि ()स्कीम में) सही हैं, क्योंकि एकमात्र गलत विकल्प है#f

^{मैं सहमत हूं, मैं नाइटपैकिंग हूं!}

— बेसाइल स्टारीनेवविच
स्रोत

3

C का उपयोग हार्डवेयर के करीब निम्न-स्तरीय प्रोग्रामिंग के लिए किया जाता है, एक ऐसा क्षेत्र जिसमें आपको कभी-कभी बिटवाइज़ और लॉजिकल ऑपरेशंस के बीच एक ही डेटा पर शिफ्ट करने की आवश्यकता होती है। एक अंकीय अभिव्यक्ति को बूलियन में बदलने के लिए केवल एक परीक्षण करने के लिए कोड को अव्यवस्थित करना आवश्यक होगा।

आप इस तरह की बातें लिख सकते हैं:

if (modemctrl & MCTRL_CD) {
   /* carrier detect is on */
}

बजाय

if ((modemctrl & MCTRL_CD) != 0) {
    /* carrier detect is on */
}

एक अलग-थलग उदाहरण में यह इतना बुरा नहीं है, लेकिन ऐसा करने से चिढ़ होगी।

इसी तरह, आक्षेप संचालन। यह बूलियन ऑपरेशन के परिणाम के लिए उपयोगी है, एक तुलना की तरह, केवल 0 या 1 का उत्पादन करने के लिए: मान लीजिए कि हम कुछ शब्द के तीसरे बिट को सेट करना चाहते हैं modemctrlजो वाहक का पता लगाता है:

flags |= ((modemctrl & MCTRL_CD) != 0) << 2;

यहां हमें != 0बायवेज़ &एक्सप्रेशन के परिणाम को कम करने के लिए 0या 1, लेकिन परिणाम सिर्फ एक पूर्णांक है, इसलिए हमें बर्नर को पूर्णांक में बदलने के लिए कुछ कष्टप्रद कलाकारों को जोड़ने से रोका जाता है।

भले ही आधुनिक सी अब एक boolप्रकार का है, लेकिन यह अभी भी इस तरह कोड की वैधता को बरकरार रखता है, क्योंकि यह एक अच्छी बात है, और पिछड़े संगतता के साथ बड़े पैमाने पर टूटने के कारण जो अन्यथा होगा।

एक और निर्वासन जहां C चालाक है: चार तरीके से स्विच के रूप में दो बूलियन स्थितियों का परीक्षण:

switch (foo << 1 | bar) {  /* foo and bar booleans are 0 or 1 */
case 0: /* !foo && !bar */
   break;
case 1: /* !foo && bar */
   break;
case 2: /* foo && !bar */
   break;
case 3: /* foo && bar */
   break;
}

आप इसे सी प्रोग्रामर से बिना लड़े दूर नहीं कर सकते थे!

अंत में, C कभी-कभी उच्च स्तरीय असेंबली भाषा के रूप में कार्य करता है। विधानसभा भाषाओं में, हमारे पास बूलियन प्रकार भी नहीं हैं। एक बूलियन मान स्मृति स्थान या रजिस्टर में बस एक बिट या शून्य बनाम नॉनजरो मूल्य है। एक पूर्णांक शून्य, बूलियन शून्य और पता शून्य सभी को विधानसभा भाषा निर्देश सेट (और शायद अस्थायी बिंदु शून्य) में भी उसी तरह से परीक्षण किया जाता है। C और असेंबली भाषा के बीच समानता तब उपयोगी होती है, जब C का उपयोग किसी अन्य भाषा (यहां तक कि दृढ़ता से टाइप किए गए बूलियन!) को संकलित करने के लिए लक्ष्य भाषा के रूप में किया जाता है।

— Kaz
स्रोत

0

एक बूलियन या सत्य मूल्य में केवल 2 मूल्य हैं। सही और गलत।

इन्हें पूर्णांक के रूप में नहीं , बल्कि बिट्स (0 और 1) के रूप में दर्शाया जाना चाहिए ।

किसी भी अन्य पूर्णांक को 0 या 1 के बगल में कहना गलत नहीं है, एक भ्रामक कथन है। सत्य सारणी सत्य मूल्यों से निपटती है, पूर्णांक नहीं।

सत्य मान संभावित से -1 या 2 सभी सत्य तालिकाओं को तोड़ देगा और किसी भी बूलियन तर्क को उनके साथ जोड़ दिया जाएगा।

0 और -1 ==!
0 या 2 ==!

अधिकांश भाषाओं में आमतौर पर एक booleanप्रकार होता है, जब किसी संख्या में टाइप किया जाता है जैसे कि पूर्णांक 0 के पूर्णांक मान के रूप में डाले जाने के लिए गलत पता चलता है।

— जॉन रेन्नोर
स्रोत

1

0 और -1 == आप जो भी बूलियन मूल्य उन्हें देते हैं। यही मेरा सवाल है, क्यों उन्हें कास्टिंग के लिए TRUEया FALSE। मैंने कभी नहीं कहा - शायद मैंने किया था, लेकिन यह इरादा नहीं था - पूर्णांक सही या गलत थे, मैंने इस बारे में पूछा कि वे बूलियन के लिए डाले जाने पर जो भी मूल्यांकन करते हैं।

— मोरवेन

-6

अंततः, आप मूल भाषा को तोड़ने की बात कर रहे हैं क्योंकि कुछ एपीआई भद्दे हैं। क्रेपी एपीआई नए नहीं हैं, और आप उन्हें भाषा को तोड़कर ठीक नहीं कर सकते। यह एक गणितीय तथ्य है कि 0 गलत है और 1 सच है, और कोई भी भाषा जो इस बात का सम्मान नहीं करती है वह मौलिक रूप से टूटी हुई है। तीन-तरफा तुलना आला है और इसका कोई परिणाम नहीं है boolक्योंकि यह तीन संभावित परिणामों को वापस करने के बाद परिणामी रूपांतरित होता है। पुराने सी एपीआई में बस भयानक त्रुटि से निपटने के लिए है, और हैमस्ट्रंग भी हैं क्योंकि सी में भयानक इंटरफेस नहीं होने के लिए आवश्यक भाषा सुविधाएँ नहीं हैं।

ध्यान दें कि मैं यह नहीं कह रहा हूं कि जिन भाषाओं में निहित पूर्णांक नहीं हैं-> बूलियन रूपांतरण।

— DeadMG
स्रोत

11

"यह एक गणितीय तथ्य है कि 0 गलत है और 1 सच है" एर्म।

— आर। मार्टिनो फर्नांडिस

11

क्या आप अपने "गणितीय तथ्य के लिए एक संदर्भ का हवाला देते हैं कि 0 गलत है और 1 सच है"? आपका जवाब एक शेख़ी की तरह खतरनाक लगता है।

— डैन पिचेलमैन

14

यह गणितीय तथ्य नहीं है, बल्कि 19 वीं शताब्दी से गणितीय सम्मेलन है।

— चार्ल्स ई। ग्रांट

1

बूलियन बीजगणित को एक परिमित क्षेत्र द्वारा दर्शाया गया है जिसमें 0 और 1 परिचालनों के लिए पहचान तत्व हैं जो एडिटोन और गुणन के समान हैं। वे ऑपरेशन क्रमशः, OR और AND हैं। वास्तव में, बूलियन बीजगणित को सामान्य बीजगणित की तरह बहुत लिखा जाता है, जहां रस-निक्षेपण AND को इंगित करता है, और +प्रतीक OR को दर्शाता है। के लिए तो उदाहरण abc + a'b'cका मतलब है (a and b and c) or (a and (not b) and (not c))।

— कज़

0 झूठ क्यों है?

स्ट्रिंग तुलना

पुरानी त्रुटियों को संभालना

निष्कर्ष

गोले: 0 निकास स्थिति सत्य है, गैर-शून्य गलत है

रूबी: 0 किसी भी अन्य संख्या की तरह है

जावा: नंबरों को बूलियन के रूप में नहीं माना जा सकता है