703

C में कोई अंतर्निहित बूलियन प्रकार नहीं है। सी में उनका उपयोग करने का सबसे अच्छा तरीका क्या है?

c boolean

— न्यूरोमैन्सर
स्रोत

73

C में बूलियन प्रकार होता है। कम से कम हाल के मानकों में एक है।

— आरा १

10

stackoverflow.com/questions/1608318/is-bool-a-native-c-type/…

— AnT

1050

सबसे अच्छे से बदतर:

विकल्प 1 (C99)

#include <stdbool.h>

विकल्प 2

typedef enum { false, true } bool;

विकल्प 3

typedef int bool;
enum { false, true };

विकल्प 4

typedef int bool;
#define true 1
#define false 0

व्याख्या

विकल्प 1 केवल तभी काम करेगा जब आप C99 का उपयोग करेंगे और इसे करने के लिए "मानक तरीका" होगा। यदि संभव हो तो इसे चुनें।
विकल्प 2, 3 और 4 समान व्यवहार वाले व्यवहार में होंगे। # 2 और # 3 हालांकि #defines का उपयोग नहीं करते हैं, जो मेरी राय में बेहतर है।

यदि आप अनिर्णीत हैं, तो # 1 के साथ जाएं!

— थॉमस बोनी
स्रोत

1

क्या आप इस बात पर विस्तार से बता सकते हैं कि वे सबसे अच्छे विकल्प क्यों हैं?

— ९

1

@endolith <stdbool.h> boolसंकलक , अनुकूलन और संकलक चुनने का तरीका एक बूलियन मूल्य के इच्छित उद्देश्य के लिए अधिक उपयुक्त हो सकता है, जिसका उपयोग करने की तुलना में बूलियन मूल्य int(यानी संकलक एक से boolअलग लागू करने के लिए चुन सकता है int)। यदि आप भाग्यशाली हैं, तो यह संकलित समय पर कठोर प्रकार की जाँच का परिणाम भी हो सकता है।

— ब्लबरडाइब्लूब

1

क्यों उपयोग intके लिए bool? वह बेकार है। का उपयोग करें unsigned char। या सी के बिलिन का उपयोग करें _Bool।

— user12211554

@ नोबोडी एक छोटे प्रकार का उपयोग करके मेमोरी को बचा सकता है, लेकिन यह इसे और तेज नहीं बना सकता है। अक्सर, यह छोटे आकार के बजाय प्रोसेसर के मूल शब्द के आकार का उपयोग करने के लिए तेज़ होता है क्योंकि इसे संरेखित करने के लिए इसे ठीक से संरेखित करने के लिए संकलक की आवश्यकता हो सकती है

— टेड क्लेन बर्गमैन

241

सी में बुलियन पर कुछ विचार:

मैं इतना बूढ़ा हो intचुका हूं कि मैं अपने बूलियन टाइप के बिना किसी भी टाइपिडेफ या विशेष डिफाइन या एनम को सही या झूठे मूल्यों के लिए इस्तेमाल कर रहा हूं । यदि आप बूलियन स्थिरांक के खिलाफ तुलना नहीं करने के बारे में मेरे सुझाव का पालन करते हैं, तो आपको केवल झंडे को आरम्भ करने के लिए 0/1 का उपयोग करना होगा। हालाँकि, इस तरह के दृष्टिकोण को इन आधुनिक समयों में बहुत प्रतिक्रियावादी माना जा सकता है। उस मामले में, किसी को निश्चित रूप <stdbool.h>से इसका उपयोग करना चाहिए क्योंकि इसका कम से कम मानकीकृत होने का लाभ है।

बूलियन स्थिरांक को जो भी कहा जाता है, उन्हें केवल आरंभीकरण के लिए उपयोग करें। कभी ऐसा कुछ लिखो

if (ready == TRUE) ...
while (empty == FALSE) ...

इन्हें हमेशा क्लीयर द्वारा बदला जा सकता है

if (ready) ...
while (!empty) ...

ध्यान दें कि ये वास्तव में यथोचित और काफी जोर से पढ़ा जा सकता है।

अपने बूलियन चर को सकारात्मक नाम दें, अर्थात fullइसके बजाय notfull। उत्तरार्द्ध कोड की ओर जाता है जो आसानी से पढ़ना मुश्किल है। तुलना

if (full) ...
if (!full) ...

साथ में

if (!notfull) ...
if (notfull) ...

पूर्व जोड़ी के दोनों स्वाभाविक रूप से पढ़ते हैं, जबकि !notfullयह पढ़ने के लिए अजीब है, और अधिक जटिल बूलियन अभिव्यक्तियों में बहुत खराब हो जाता है।

आम तौर पर बूलियन तर्कों से बचा जाना चाहिए। इस तरह परिभाषित एक फ़ंक्शन पर विचार करें

void foo(bool option) { ... }

फ़ंक्शन के शरीर के भीतर, यह बहुत स्पष्ट है कि तर्क का क्या मतलब है क्योंकि इसमें एक सुविधाजनक और उम्मीद है कि सार्थक, नाम। लेकिन, कॉल साइट्स जैसी दिखती हैं

foo(TRUE);
foo(FALSE):

यहां, यह बताना असंभव है कि फंक्शन की परिभाषा या घोषणा को देखे बिना पैरामीटर का क्या मतलब है, और यदि आप और भी अधिक बूलियन पैरामीटर जोड़ते हैं तो यह बहुत जल्दी खराब हो जाता है। मैं या तो सुझाव देता हूं

typedef enum { OPT_ON, OPT_OFF } foo_option;
void foo(foo_option option);

या

#define OPT_ON true
#define OPT_OFF false
void foo(bool option) { ... }

किसी भी स्थिति में, कॉल साइट अब दिखती है

foo(OPT_ON);
foo(OPT_OFF);

पाठक की परिभाषा को कम से कम समझने के बिना कम से कम समझने का मौका है foo।

— डेल हाग्लगंड
स्रोत

1

और आप समानता के लिए दो चर की तुलना कैसे करते हैं? बूलियन स्थिरांक का उपयोग कभी भी महान काम नहीं करता है, लेकिन यह समस्या का समाधान नहीं करता है जब एक गैर-स्थिरांक के खिलाफ तुलना की जाती है।

— बरूच

मुझे माफ़ कर दो, लेकिन मैं इस सवाल को नहीं समझता। क्या आप पूछ रहे हैं कि मैं समानता के लिए दो बूलियन चर की तुलना कैसे करूं? यदि हां, काम नहीं a == bकरता है?

— डेल हाग्लगंड

5

@Kenji आप जो कहते हैं वह सच है, हालांकि मेरा मानना है कि एक के अलावा अन्य मूल्यों को सच के बराबर उपयोग करना लगभग हमेशा एक बुरा विचार है। अपने उदाहरण में तो, यह सोचते हैं कि aऔर bशून्य से ऊपर गिनती तक, मैं a > 0 == b > 0बजाय। यदि आप मनमाने ढंग से गैर-शून्य मानों की सत्यता का लाभ उठाने पर जोर देते हैं, !!varतो बूलियन 0/1 मूल्य के बराबर होता है var, इसलिए आप लिख सकते हैं !!a == !!b, हालांकि काफी पाठक इसे भ्रमित पाएंगे।

— डेल Hagglund

3

!a == !bसमानता के परीक्षण के लिए भी पर्याप्त है, गैर शून्य शून्य हो जाते हैं, और शून्य एक हो जाते हैं।

— राणापट्टिसन

5

@rpattiso आप निश्चित रूप से काफी सही हैं, लेकिन मुझे लगता है कि मैं !!a"गैर-बूलियन को अपने समतुल्य सत्य मूल्य में परिवर्तित करता हूं " के रूप में पढ़ूंगा , जबकि मैं !a"तार्किक रूप से बूलियन चर को उल्टा" के रूप में पढ़ूंगा। विशेष रूप से, मैं कुछ विशेष कारण की तलाश करूंगा जो तार्किक उलटा वांछित था।

— डेल हाग्लगंड

88

सी में एक बूलियन एक पूर्णांक है: झूठे के लिए शून्य और सत्य के लिए गैर-शून्य।

यह भी देखें बूलियन डेटा प्रकार , खंड सी, सी ++, ऑब्जेक्टिव-सी, AWK ।

— Fortega
स्रोत

यह तार्किक ऑपरेटरों के साथ भी अच्छा काम करता है (&& और ||)।

— वल्तराव जू

74

यहाँ संस्करण है कि मैं इस्तेमाल किया है:

typedef enum { false = 0, true = !false } bool;

क्योंकि झूठे का केवल एक मूल्य होता है, लेकिन एक तार्किक सत्य के कई मूल्य हो सकते हैं, लेकिन तकनीक यह निर्धारित करने के लिए सही है कि संकलक झूठ के विपरीत के लिए क्या उपयोग करेगा।

यह किसी की कोडिंग की समस्या का ध्यान रखता है जो इस पर उतरता है:

if (true == !false)

मुझे लगता है कि हम सभी सहमत होंगे कि यह एक अच्छा अभ्यास नहीं है, लेकिन एक समय के लिए "सही = गलत" करने की लागत से हम उस समस्या को खत्म कर देते हैं।

[संपादित] अंत में मैं इस्तेमाल किया:

typedef enum { myfalse = 0, mytrue = !myfalse } mybool;

अन्य योजनाओं के साथ नाम टकराने से बचने के लिए जो परिभाषित कर रहे थे trueऔरfalse । लेकिन अवधारणा वही है।

[संपादित करें] पूर्णांक के बूलियन में रूपांतरण दिखाने के लिए:

mybool somebool;
int someint = 5;
somebool = !!someint;

पहला (सबसे सही)! गैर-शून्य पूर्णांक को 0 में परिवर्तित करता है, फिर दूसरा (सबसे बाएं)! 0 को एक myfalseमान में परिवर्तित करता है । मैं इसे शून्य पूर्णांक में परिवर्तित करने के लिए पाठक के लिए एक अभ्यास के रूप में छोड़ दूंगा।

[संपादित करें] यह मेरी शैली है कि किसी एनम में मूल्य की स्पष्ट सेटिंग का उपयोग करें जब विशिष्ट मूल्य की आवश्यकता होती है, भले ही डिफ़ॉल्ट मान समान हो। उदाहरण: क्योंकि शून्य की आवश्यकता है कि मैं false = 0,इसके बजाय शून्य का उपयोग करता हूंfalse,

— माइकल पॉटर
स्रोत

5

इसके अलावा enums का उपयोग करने के एक और फायदा आईडीई एकीकरण है - true, falseऔर boolमें हाइलाइट किया जाता सबसे आईडीई के, क्योंकि वे enum मूल्यों और एक typedef, के रूप में करने का विरोध किया हैं #defines, जो बहुत कम ही ऐसा वाक्य रचना हाइलाइट किए गए हैं।

जिज्ञासु: यह वास्तव में काम करता है या नहीं, इस बात की अनदेखी करना कि क्या एक समान गणना में पूर्व मान का संदर्भ देने के लिए एक सीम (99+) की अनुमति है ?

@ tgm1024 gcc -ansi -pedantic -Wallकोई चेतावनी नहीं देता है, इसलिए मुझे भरोसा है gcc; यदि यह इसके लिए भी काम करता है, तो c89उसे भी काम करना चाहिए c99।

— यानि

1

"क्योंकि झूठ का केवल एक ही मूल्य होता है, लेकिन एक तार्किक सत्य के कई मूल्य हो सकते हैं, लेकिन तकनीक सच साबित होती है कि संकलक झूठ के विपरीत के लिए क्या उपयोग करेगा।" नकारात्मक संचालक !केवल मान लौटा सकता है 0और 1इसलिए true = !falseहमेशा मान प्रदान करेगा 1. यह विधि कोई अतिरिक्त सुरक्षा नहीं देती है typedef enum { false, true } bool;।

— user694733

1

सबसे पहले मैंने पाया कि C90 (6.3.3.3 Unary अंकगणित ऑपरेटरों) से है: "तार्किक निषेध ऑपरेटर का परिणाम! 0 है यदि इसके ऑपरेंड का मान असमान से 0. 1 की तुलना करता है यदि इसके ऑपरेंड का मान 0. के बराबर है। परिणाम का प्रकार int है। अभिव्यक्ति! E (O == E) के बराबर है। " किसी भी कंपाइलर को कवर करना चाहिए जो कभी भी मानक सी का समर्थन करने का दावा करता है। कंपाइलर्स उन मामलों में कानूनी रूप से इस नियम की अनदेखी कर सकते हैं जहां यह देखने योग्य व्यवहार (जैसे if(!value)) के लिए मायने नहीं रखता है , लेकिन यह अपवाद इस विशिष्ट मामले में लागू नहीं है।

— user694733

48

यदि आप C99 कंपाइलर का उपयोग कर रहे हैं तो इसमें बूल प्रकारों के लिए अंतर्निहित समर्थन है:

#include <stdbool.h>
int main()
{
  bool b = false;
  b = true;
}

http://en.wikipedia.org/wiki/Boolean_data_type

— गैरी विलोबी
स्रोत

30

पहली चीजें पहले। C, यानी ISO / IEC 9899 में 19 वर्षों से बुलियन प्रकार है । इस सवाल पर जाकर संयुक्त रूप से शौकिया / शैक्षणिक / व्यावसायिक भागों के साथ सी प्रोग्रामिंग करियर की अपेक्षित लंबाई से अधिक लंबा समय है । मेरा है कि शायद 1-2 साल से अधिक है। इसका अर्थ है कि उस समय के दौरान जब एक औसत पाठक ने C के बारे में कुछ भी सीखा है, C का वास्तव में बूलियन डेटा प्रकार है ।

डेटाटाइप के लिए #include <stdbool.h>, और उपयोग करें true, falseऔर bool। या इसे शामिल न करें _Bool, 1और उपयोग करें , और 0इसके बजाय।

इस धागे के अन्य उत्तरों में कई खतरनाक प्रथाओं को बढ़ावा दिया गया है। मैं उन्हें संबोधित करूंगा:

typedef int bool;
#define true 1
#define false 0

यह कोई नहीं-नहीं है, क्योंकि एक आकस्मिक पाठक - जिन्होंने उन 19 वर्षों के भीतर सी सीखा था - उम्मीद करेंगे कि वास्तविक डेटा प्रकार boolको संदर्भित करता है और इसी तरह का व्यवहार करेगा, लेकिन यह नहीं करता है! उदाहरण के लिए bool

double a = ...;
bool b = a;

C99 bool/ के साथ _Bool, iff परb सेट किया गया था शून्य, और अन्यथा। C11 6.3.1.2p1false atrue

जब कोई स्केलर मान परिवर्तित किया जाता है _Bool, तो परिणाम 0 होता है यदि मान 0 के बराबर होता है; अन्यथा, परिणाम 1. 59)

फुटनोट

59) NaNs 0 के बराबर तुलना नहीं करते हैं और इस प्रकार 1 में बदल जाते हैं।

साथ typedefजगह में, doubleएक करने के लिए मजबूर किया जाएगा int- अगर डबल का मूल्य रेंज में के लिए नहीं है int, व्यवहार अपरिभाषित है ।

स्वाभाविक रूप से एक ही है, तो पर लागू होता है trueऔर falseएक में घोषित किया गया enum।

क्या और भी खतरनाक है घोषित करना

typedef enum bool {
    false, true
} bool;

क्योंकि अब 1 और 0 के अलावा सभी मान अमान्य हैं, और क्या इस तरह का मान उस प्रकार के एक चर को सौंपा जाना चाहिए , व्यवहार पूरी तरह से अपरिभाषित होगा ।

इसलिए अगर आप C99 का इस्तेमाल किसी अक्षम्य कारण के लिए नहीं कर सकते हैं, तो आपके द्वारा उपयोग किए जाने वाले बूलियन चर के लिए:

प्रकार intऔर मान 0और 1 जैसा है ; और ध्यान से डबल नकारात्मक के साथ किसी भी अन्य मूल्यों से डोमेन रूपांतरण करते हैं!!
या आप अगर जोर देते हैं आपको याद नहीं है कि 0, falsy और गैर शून्य truish है कम से कम उपयोग में अपर केस इतना है कि वे C99 अवधारणाओं के साथ भ्रमित नहीं मिलता है: BOOL, TRUEऔर FALSE!

— एंटटी हापला
स्रोत

1

C मानक का कौन सा हिस्सा स्पष्ट रूप से सूचीबद्ध मानों को रखने के लिए गणना प्रकारों की वस्तुओं को सीमित करेगा? यदि एक प्रगणित निरंतर के लिए सबसे बड़ा मूल्य UCHAR_MAX या USHRT_MAX से कम है, एक कार्यान्वयन एक प्रकार से छोटे इस्तेमाल कर सकते हैं intया unsigned intएक गणन धारण करने के लिए है, लेकिन मैं मानक में कुछ भी नहीं है कि एक गणना एक पूर्णांक के अलावा और कुछ के रूप में व्यवहार करने के लिए कारण होगा के बारे में पता प्रकार।

— 20

18

typedef enum {
    false = 0,
    true
} t_bool;

— mouviciel
स्रोत

2

MAX_INT के माध्यम से 2 को भी सच का मूल्यांकन करना चाहिए

— टेक्नोसॉरस

2

@technosaurus इस दृष्टिकोण को लेना गारंटी नहीं देता है! गलत == सच के बाद से! झूठ कोई भी गैर-शून्य संख्या नहीं हो सकती है। एक साधारण काम-आस-पास स्पष्ट रूप से झूठे को सच करने के लिए होगा।

— एंड्रयू

3

@ और यह सच नहीं है। !0 = 1C मानक द्वारा, और !a = 0किसी भी गैर-शून्य मान के लिए a। समस्या यह है कि किसी भी गैर-शून्य को सच माना जाता है। यदि ऐसा है aऔर bदोनों "सच" हैं, तो जरूरी नहीं कि यह मामला 'ए == बी' ही हो।

— जेरेमी वेस्ट

14

सी में एक बूलियन प्रकार है: बूल (कम से कम पिछले 10 (!) वर्षों के लिए)

Stdbool.h को शामिल करें और सही / गलत उम्मीद के मुताबिक काम करेगा।

— dmeister
स्रोत

12

मानक में 10 साल, लेकिन संकलक में 10 साल नहीं! MSVC ++ का C संकलन // टिप्पणियों की अनुमति देने के अलावा अन्य सभी पर C99 का समर्थन नहीं करता है, और कभी भी ऐसा करने की संभावना नहीं है। इसके अलावा _Bool C99 में एक अंतर्निहित प्रकार के रूप में परिभाषित किया गया है, जबकि बूल <stdbool.h> हैडर में एक टाइपराइफ है।

— क्लिफोर्ड 20

5

@ क्लिफर्ड 4 साल आपकी टिप्पणी के बाद ... कुछ भी नहीं बदला है। MSVC एक C ++ कंपाइलर है और मेरा मानना है कि MS ने कहा है कि वे वास्तव में सभी नए C फीचर्स (C99 & C11) का समर्थन करने के इच्छुक नहीं हैं। लेकिन मैं यह नहीं कह सकता कि MSVC एक कारण के रूप में नई सी सुविधाओं का समर्थन नहीं करता है (विशेषकर जब आप इसे उत्तर पर 10 साल के खिलाफ कहते हैं )। प्रोग्रामिंग दुनिया में 10 साल वास्तव में एक लंबा समय है। किसी भी सभ्य संकलक के पास 10 वर्ष से कम समय में इसके लिए समर्थन होना चाहिए, अगर विक्रेता को इसका समर्थन करने का इरादा है।

— पीपी

2

@ किंग्सइंडियन: मुझे यकीन नहीं है कि आपने अपनी टिप्पणी मुझे क्यों निर्देशित की या मुझे टिप्पणी करने की आवश्यकता महसूस हुई। मैं केवल स्थिति बता रहा था क्योंकि यह लेखन के समय खड़ा था। मैं उस स्थिति का समर्थन नहीं कर रहा था, केवल इंगित कर रहा था कि "उत्तर" सभी परिस्थितियों में लागू नहीं हो सकता है।

— क्लिफर्ड

@ क्लिफोर्ड: सख्ती से, मानक को boolएक मैक्रो होने की आवश्यकता होती है जो फैलता है _Bool। यह अंतर इसलिए मायने रखता है क्योंकि आप #undefएक मैक्रो (और इसकी अनुमति हो सकती है, कम से कम एक संक्रमणकालीन उपाय के रूप में), लेकिन आप untypedefटाइप नहीं कर सकते । हालांकि यह आपकी पहली टिप्पणी के मुख्य जोर को बदल नहीं सकता है।

— जोनाथन लेफ्लर

2

VS2015 और बाद में (और संभवतः पहले, एक बिंदु तक) सी संकलन के boolमाध्यम से कोई समस्या नहीं है <stdbool.h>। इसका समाधान होता है _Bool।

11

कुछ भी नॉनजरो का मूल्यांकन बूलियन ऑपरेशन में सच है, तो आप बस कर सकते हैं

#define TRUE 1
#define FALSE 0

और स्थिरांक का उपयोग करें।

— ggambett
स्रोत

10

लेकिन उन्हें सावधानी के साथ उपयोग करें: क्योंकि एक सच्चा परिणाम किसी भी गैर-शून्य मान हो सकता है, परीक्षण यदि (t == TRUE) {...} और यदि (t), जो अन्य भाषाओं में समतुल्य हैं, C के समतुल्य नहीं हैं। ।

— 12 डिग में

1

आप सही हैं, लेकिन यह C ++ में भी सही है, जिसमें एक बूल टाइप है, है ना? डिबगिंग के दौरान मैंने 5837834939 के मूल्यों के साथ बूल वेरिएबल देखा है ...

— ggambett

1

C ++ में, if (t == true) परीक्षण if (t) परीक्षण के बराबर होता है, क्योंकि C ++ कुछ रूपांतरण करता है (वह सब कुछ जो 0 या शून्य सूचक मान को सही में परिवर्तित नहीं किया गया है)

— Fortega

6

आपको बस एक बूलियन सही मूल्य के बारे में मान लेना चाहिए कि यह गैर-शून्य है। तो कोड जैसे अगर (b) सुरक्षित है जबकि अगर (b == TRUE) नहीं है; उत्तरार्द्ध बुरा अभ्यास है (और व्यर्थ)।

— क्लिफर्ड

5

यदि आप C99 का उपयोग करने की अनुमति देते हैं, तो अन्य उत्तरों और कुछ स्पष्टीकरण के पूरक हैं।

+-------+----------------+-------------------------+--------------------+
|  Name | Characteristic | Dependence in stdbool.h |        Value       |
+-------+----------------+-------------------------+--------------------+
| _Bool |   Native type  |    Don't need header    |                    |
+-------+----------------+-------------------------+--------------------+
|  bool |      Macro     |           Yes           | Translate to _Bool |
+-------+----------------+-------------------------+--------------------+
|  true |      Macro     |           Yes           |   Translate to 1   |
+-------+----------------+-------------------------+--------------------+
| false |      Macro     |           Yes           |   Translate to 0   |
+-------+----------------+-------------------------+--------------------+

मेरी कुछ प्राथमिकताएँ:

_Boolया bool? दोनों ठीक हैं, लेकिनbool कीवर्ड से बेहतर है_Bool ।
के लिए स्वीकृत मान हैं boolऔर _Boolहैं: falseया true। नियत 0या 1के बजाय falseयाtrue मान्य है, लेकिन पढ़ने के लिए और तर्क प्रवाह को समझने के लिए कठिन है।

मानक से कुछ जानकारी:

_Boolनहीं है unsigned int, लेकिन अहस्ताक्षरित पूर्णांक प्रकार के समूह का हिस्सा है । यह मूल्यों को धारण करने के लिए काफी बड़ा है0 या1 ।
नहीं, लेकिन हाँ, आप को फिर से परिभाषित करने में सक्षम हैं bool true औरfalse निश्चित रूप से एक अच्छा विचार नहीं है। इस क्षमता को अश्लील माना जाता है और भविष्य में इसे हटा दिया जाएगा।
स्केलर प्रकार (अंकगणित प्रकार और सूचक प्रकार) को निर्दिष्ट करना _Boolया bool, यदि स्केलर का मूल्य बराबर है 0या इसकी तुलना 0होगी 0, अन्यथा परिणाम है 1:_Bool x = 9; 9 को 1असाइन किए जाने पर परिवर्तित किया जाता है x।
_Bool1 बाइट (8 बिट) है, आमतौर पर प्रोग्रामर को अन्य बिट्स का उपयोग करने की कोशिश करने के लिए लुभाया जाता है, लेकिन इसकी सिफारिश नहीं की जाती है, क्योंकि केवल जो गारंटी दी जाती है वह यह है कि डेटा को स्टोर करने के लिए केवल एक बिट का उपयोग किया जाता है, न charकि उस प्रकार का जैसे 8 उपलब्ध बिट्स।

— अपरिभाषित व्यवहार
स्रोत

2

यह यह है:

#define TRUE 1
#define FALSE 0

— RngTng
स्रोत

7

Id #define TRUE! FALSE

— Tom

2

आप इसके लिए एक चार, या एक और छोटी संख्या के कंटेनर का उपयोग कर सकते हैं।

छद्म कोड

#define TRUE  1
#define FALSE 0

char bValue = TRUE;

— फिलिप एकबर्ग
स्रोत

C में भी यह आमतौर पर एक int है, और यह int का उपयोग करने वाले अन्य कोड द्वारा सटीक चेतावनियों के नुकसान का कारण बन सकता है ..

— थॉमस बॉनिनी

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

— किंग्सले

2

आप _Bool का उपयोग कर सकते हैं, लेकिन रिटर्न मान एक पूर्णांक होना चाहिए (1 सत्य के लिए, 0 झूठे के लिए)। हालाँकि, यह C ++ की तरह बूल को शामिल करने और उपयोग करने के लिए अनुशंसित है, जैसा कि इस उत्तर में daniweb मंच से कहा गया है , साथ ही साथ यह उत्तर , इस अन्य स्टैकओवरफ़्लो प्रश्न से:

_बूल: C99 का बूलियन प्रकार। _Bool का उपयोग सीधे केवल तभी किया जाता है यदि आप विरासत कोड बनाए रख रहे हैं जो पहले से ही मैक्रोज़ को बूल, ट्रू या गलत के लिए परिभाषित करता है। अन्यथा, उन मैक्रो को हेडर में मानकीकृत किया जाता है। उस शीर्ष लेख को शामिल करें और आप C ++ में उसी तरह बूल का उपयोग कर सकते हैं।

— Lokian
स्रोत

2

सशर्त अभिव्यक्तियों को सत्य माना जाता है यदि वे गैर-शून्य हैं, लेकिन सी मानक के लिए आवश्यक है कि तार्किक ऑपरेटर स्वयं या तो 0 या 1 पर लौटें।

@Tom: #define TRUE! FALSE खराब है और पूरी तरह से बेकार है। यदि हेडर फ़ाइल संकलित C ++ कोड में अपना रास्ता बनाती है, तो यह समस्याओं का कारण बन सकता है:

void foo(bool flag);

...

int flag = TRUE;
foo(flag);

कुछ कंपाइलर int => बूल रूपांतरण के बारे में एक चेतावनी उत्पन्न करेंगे। कभी-कभी लोग ऐसा करने से बचते हैं:

foo(flag == TRUE);

C ++ बूल होने के लिए अभिव्यक्ति को मजबूर करने के लिए। लेकिन अगर आप # ट्राय करते हैं! FALSE, तो आप खत्म हो जाते हैं:

foo(flag == !0);

जो अंत-से-बूल तुलना करना समाप्त करता है जो किसी भी तरह चेतावनी को ट्रिगर कर सकता है।

— jamesdlin
स्रोत

1

यदि आप C99 का उपयोग कर रहे हैं तो आप _Boolप्रकार का उपयोग कर सकते हैं । कोई #includeएस आवश्यक नहीं हैं। हालांकि, जहां आप एक पूर्णांक है जैसे कि यह इलाज करने की आवश्यकता है 1है trueऔर 0हैfalse ।

फिर आप को परिभाषित कर सकते TRUEहैं और FALSE।

_Bool this_is_a_Boolean_var = 1;


//or using it with true and false
#define TRUE 1
#define FALSE 0
_Bool var = TRUE;

— That_Linux_Guy
स्रोत

या आप कर सकते हैं #include <stdbool.h>और उपयोग bool, trueऔर falseमानक आप के लिए करना चाहता है।

— एसएस ऐनी

1

आजकल C99 बूलियन प्रकारों का समर्थन करता है, लेकिन आपको इसकी आवश्यकता है #include <stdbool.h>।

उदाहरण:

#include <stdbool.h>

int main() 
{ 
    bool arr[2] = {true, false}; 

    printf("%d\n", arr[0] && arr[1]);
    printf("%d\n", arr[0] || arr[1]);

    return 0; 
}

आउटपुट:

0
1

— Kalana
स्रोत

0

यही है वह जो मेरे द्वारा उपयोग किया जाता है:

enum {false, true};
typedef _Bool bool;

_Bool सी में निर्मित प्रकार है। यह बूलियन मूल्यों के लिए अभिप्रेत है।

— user12211554
स्रोत

-2

आप बस #defineनिर्देश का उपयोग इस प्रकार कर सकते हैं:

#define TRUE 1
#define FALSE 0
#define NOT(arg) (arg == TRUE)? FALSE : TRUE
typedef int bool;

और निम्नानुसार उपयोग करें:

bool isVisible = FALSE;
bool isWorking = TRUE;
isVisible = NOT(isVisible);

और इसी तरह

— प्रकाश भट्टराई
स्रोत

5

नहीं मैक्रो argको एक पूरे के रूप में और अभिव्यक्ति के आसपास कोष्ठक द्वारा संरक्षित किया जाना चाहिए #define NOT(arg) (((arg) == TRUE) ? FALSE : TRUE):। हालांकि, यह झूठ के लिए परीक्षण करने के लिए बेहतर होगा (यह सही जवाब दे देंगे, भले ही arg23 के बजाय 0 या 1 था: #define NOT(arg) (((arg) == FALSE) ? TRUE : FALSE)लेकिन पूरे अभिव्यक्ति को कम किया जा सकता है। #define NOT(arg) (!(arg))ज़ाहिर है, है, जो एक ही परिणाम पैदा करता है।

— जोनाथन Leffler

सी में बूलियन मूल्यों का उपयोग करना

व्याख्या