एक बढ़ावा के माध्यम से बार-बार दोहराना :: dynamic_bitset

Question

मैं एक boost dynamic_bitset है कि मैं से सेट बिट्स निकालने के लिए कोशिश कर रहा हूँ है:

boost::dynamic_bitset<unsigned long> myBitset(1000); 

मेरी पहली सोचा एक सरल प्रत्येक सूचकांक के माध्यम से लूप 'डंप' और अगर पूछना करने के लिए था यह स्थापित किया गया था:

for(size_t index = 0 ; index < 1000 ; ++index) 
{ 
    if(myBitset.test(index)) 
    { 
     /* do something */ 
    } 
} 

लेकिन फिर मैंने देखा कि दो दिलचस्प तरीकों, find_first() और find_next() कि मुझे यकीन है कि के लिए सोचा था कि इस उद्देश्य के लिए बने थे:

size_t index = myBitset.find_first(); 
while(index != boost::dynamic_bitset::npos) 
{ 
     /* do something */ 
     index = myBitset.find_next(index); 
} 

मैंने कुछ परीक्षण चलाए और ऐसा लगता है कि दूसरी विधि अधिक कुशल है, लेकिन इससे मुझे चिंता है कि इस पुनरावृत्ति को करने के लिए एक और 'सही' तरीका हो सकता है। मैं दस्तावेज़ बिट्स में पुनरावृत्त करने के सही तरीके को इंगित करने वाले दस्तावेज में कोई उदाहरण या नोट नहीं ढूंढ पाया।

तो, find_first() और find_next() का उपयोग dynamic_bitset पर फिर से शुरू करने का सबसे अच्छा तरीका है, या कोई और तरीका है?

Answer 1

find_first और find_next सबसे तेज़ तरीका है। इसका कारण यह है कि यदि उनमें से कोई भी सेट नहीं है तो ये पूरे ब्लॉक (dynamic_bitset::bits_per_block बिट्स, शायद 32 या 64) पर जा सकते हैं।

ध्यान दें कि dynamic_bitsetdoes not have iterators, तो यह थोड़ा सा सी-सी ++ 'ईश व्यवहार करेगा, इससे कोई फर्क नहीं पड़ता।

Answer 2

की आपकी परिभाषा पर निर्भर करता है। एक सही विधि को सभी वैध इनपुट पर सही परिणाम मिलना चाहिए और पर्याप्त तेज़ होना चाहिए।

find_first और find_next वहां हैं ताकि उन्हें एक तुलना में बिट्स के पूरे ब्लॉक स्कैन करने के लिए अनुकूलित किया जा सके। यदि कोई ब्लॉक है, तो 64 बिट्स के एक हस्ताक्षरित लंबे समय तक, एक ब्लॉक तुलना 64 बिट्स का विश्लेषण करती है, जहां आपके द्वारा पोस्ट की गई एक सीधी लूप उस के लिए 64 पुनरावृत्तियों का उपयोग करेगी।