c++ - क्या मैं एक बार में एक छोटे से बूल की जांच कर सकता हूं?




arrays casting (4)

... और अनिवार्य "अपना खुद का रोल रोल करें" उत्तर के लिए, हम किसी भी सरणी bool[N] लिए एक सरल "या" जैसे फ़ंक्शन प्रदान कर सकते हैं, जैसे:

template<size_t N>
constexpr bool or_all(const bool (&bs)[N]) {
    for (bool b : bs) {
        if (b) { return b; }
    }

    return false;
}

या अधिक संक्षेप में,

template<size_t N>
constexpr bool or_all(const bool (&bs)[N]) {
    for (bool b : bs) { if (b) { return b; } }
    return false;
}

यह भी जैसे शॉर्ट-सर्कुलेटिंग दोनों का लाभ है || , और संकलन समय पर गणना योग्य होने पर पूरी तरह से अनुकूलित किया जा रहा है।

इसके अलावा, यदि आप अवलोकन को आसान बनाने के लिए कुछ अन्य प्रकार के टाइप-पिंगल bool[N] के मूल विचार की जांच करना चाहते हैं, तो मैं बहुत सलाह दूंगा कि आप इसे char[N2] न देखें, बजाय N2 == (sizeof(bool) * N) । यह आपको एक सरल प्रतिनिधित्व दर्शक प्रदान करने की अनुमति देगा जो स्वचालित रूप से देखी गई वस्तु के वास्तविक आकार को माप सकता है, इसके अलग-अलग बाइट्स पर पुनरावृत्ति की अनुमति दे सकता है, और आपको यह आसानी से निर्धारित करने की अनुमति देगा कि क्या प्रतिनिधित्व विशिष्ट मूल्यों से मेल खाता है (जैसे, जैसे, शून्य या गैर शून्य)। मुझे अपने सिर के ऊपर से पूरी तरह से यकीन नहीं है कि क्या इस तरह की परीक्षा किसी भी यूबी को लागू करेगी, लेकिन मैं यह निश्चित रूप से कह सकता हूं कि किसी भी प्रकार के निर्माण को एक व्यवहार्य स्थिर अभिव्यक्ति नहीं कहा जा सकता है, इसके लिए char* लिए एक पुन: व्याख्यात्मक कलाकारों की आवश्यकता होती है। unsigned char* या समान (या तो स्पष्ट रूप से, या std::memcpy() ) में, और इस तरह आसानी से अनुकूलित नहीं किया जा सकता है।

यहाँ एक समान प्रश्न here , लेकिन उस प्रश्न में उपयोगकर्ता को एक बहुत बड़ा सरणी, या वेक्टर लगता था। अगर मेरे पास:

bool boolArray[4];

और मैं जांच करना चाहता हूं कि क्या सभी तत्व झूठे हैं, मैं [0], [1], [2] और [3] या तो अलग से जांच कर सकता हूं, या मैं इसके माध्यम से लूप कर सकता हूं। चूँकि (जहाँ तक मुझे पता है) झूठ का मान 0 होना चाहिए और 0 के अलावा कुछ भी सत्य है, तो मैंने बस करने के बारे में सोचा:

if ( *(int*) boolArray) { }

यह काम करता है, लेकिन मुझे एहसास है कि यह एक बाइट होने पर निर्भर करता है और चार बाइट्स होने पर निर्भर करता है। अगर मैं (std :: uint32_t) को कास्ट करता हूं, तो क्या यह ठीक होगा, या यह अभी भी एक बुरा विचार है? मैं सिर्फ एक सरणी में 3 या 4 बूल रखता हूं और सोच रहा था कि क्या यह सुरक्षित है, और यदि नहीं तो इसे करने का एक बेहतर तरीका है।

इसके अलावा, मामले में मैं 4 से अधिक बूलों के साथ समाप्त होता हूं, लेकिन 8 से कम मैं एक एसटीडी के साथ एक ही काम कर सकता हूं: uint64_t या अहस्ताक्षरित लंबे समय तक या कुछ और?


आप std::bitset<N>::any उपयोग कर सकते हैं:

बिट्स में से कोई भी true , अन्यथा false हैं तो कोई भी रिटर्न true

#include <iostream>      
#include <bitset>        

int main ()
{
  std::bitset<4> foo;
  // modify foo here


  if (foo.any())
    std::cout << foo << " has " << foo.count() << " bits set.\n";
  else
    std::cout << foo << " has no bits set.\n";

  return 0;
}

Live

यदि आप true लौटना चाहते हैं तो सभी या बिट में से कोई भी सेट नहीं है, तो आप क्रमशः std::bitset<N>::all या std::bitset<N>::none उपयोग कर सकते हैं।


जैसा कि stνdα τ टिप्पणियों में देखा गया है, std::bitset शायद यूबी-मुक्त तरीके से उस से निपटने का सबसे अच्छा तरीका है।

std::bitset<4> boolArray {};
if(boolArray.any()) {
    //do the thing
}

यदि आप एरेज़ से std::any_of चाहते हैं, तो आप std::any_of उपयोग कर सकते हैं, लेकिन इसके लिए std::any_of उपयोग (संभवतः पाठकों के लिए अजीबोगरीब) की आवश्यकता होती है, जो इसके तर्क को लौटाता है:

bool boolArray[4];
if(std::any_of(std::begin(boolArray), std::end(boolArray), [](bool b){return b;}) {
    //do the thing
}

टाइप-पाइंटिंग 4 bool एस टू int एक बुरा विचार हो सकता है - आप प्रत्येक प्रकार के आकार के बारे में सुनिश्चित नहीं हो सकते। यह संभवतः अधिकांश आर्किटेक्चर पर काम करेगा, लेकिन std::bitset को किसी भी परिस्थिति में हर जगह काम करने की गारंटी है।







boolean