शामिल
यहां एक बहुत ही सरल स्थिर आकार के बिट वेक्टर कार्यान्वयन है। इसे C12+ 11 को फ़ंक्शन करने की आवश्यकता है क्योंकि यह <cstdint> शीर्षलेख पर निर्भर करता है, लेकिन यह हेडर काफी सामान्यतः पाया जाता है क्योंकि यह C99 सुविधा पर आधारित है। चुटकी में आप सी <stdint.h> शीर्षलेख का उपयोग कर सकते हैं और इसके बजाय वैश्विक नामस्थान में बस प्रकारों का उपयोग कर सकते हैं।
नोट: यह ऑन-द-फ्लाई टाइप किया गया था और बिल्कुल परीक्षण नहीं किया गया है। मैंने यह भी सत्यापित नहीं किया कि यह संकलित होगा। तो, त्रुटियां हो सकती हैं।
#include <cstdint> // ::std::uint64_t type
#include <cstddef> // ::std::size_t type
#include <algorithm>
class my_bitvector_base {
protected:
class bitref { // Prevent this class from being used anywhere else.
public:
bitref(::std::uint64_t &an_int, ::std::uint64_t mask)
: an_int_(an_int), mask_(mask)
{
}
const bitref &operator =(bool val) {
if (val) {
an_int_ |= mask_;
} else {
an_int_ &= ~mask_;
}
return *this;
}
const bitref &operator =(const bitref &br) {
return this->operator =(bool(br));
}
operator bool() const {
return ((an_int_ & mask_) != 0) ? true : false;
}
private:
::std::uint64_t &an_int_;
::std::uint64_t mask_;
};
};
template < ::std::size_t Size >
class my_bitvector : public my_bitvector_base {
private:
static constexpr ::std::size_t numints = ((Size + 63)/64);
public:
my_bitvector() { ::std::fill(array, array + numints, 0); }
bool operator [](::std::size_t bitnum) const {
const ::std::size_t bytenum = bit/64;
bitnum = bitnum % 64;
return ((ints_[bytenum] & (::std::uint64_t(1) << bitnum)) != 0) ? true : false;
}
bitref operator[](::std::size_t bitnum) {
const ::std::size_t bytenum = bit/64;
bitnum = bitnum % 64;
::std::uint64_t mask = ::std::uint64_t(1) << bitnum;
return bitref(ints_[bytenum], mask);
}
private:
::std::uint64_t ints_[numints];
};
// Example uses
void test()
{
my_bitvector<70> bits; // A 70 bit long bit vector initialized to all false
bits[1] = true; // Set bit 1 to true
bool abit = bits[1]; // abit should be true.
abit = bits[69]; // abit should be false.
}
पूरे my_bitvector_base बात निजी प्रकार का एक तरह तैयार करना है। आप व्युत्पन्न कक्षाओं के लिए इंटरफेस या कार्यान्वयन में इसका उल्लेख कर सकते हैं क्योंकि यह protected है, लेकिन आप इसे अन्य संदर्भों का उल्लेख नहीं कर सकते हैं। यह लोगों को bitref की एक प्रति संग्रह करने से रोकता है। यह महत्वपूर्ण है क्योंकि bitref केवल operator [] के परिणाम के लिए असाइनमेंट की अनुमति देने के लिए वास्तव में मौजूद है क्योंकि सी ++ मानकों की समिति ने अपने सभी ज्ञान में operator []= या किसी सरणी तत्व को असाइन करने के लिए समान कुछ लागू नहीं किया है।
जैसा कि आप देख सकते हैं, थोड़ा वेक्टर मूल रूप से बिट्स की एक सरणी है। फैनसीर बिट वेक्टर सच्चे या झूठे शुरू किए गए बिट्स की 'अनंत' सरणी अनुकरण करेंगे। वे इसे सेट किए गए आखिरी बिट को ट्रैक करके और इससे पहले सभी बिट्स को ट्रैक करके ऐसा करते हैं। और यदि आप इसके बाद थोड़ा सा पूछते हैं, तो वे केवल प्रारंभिक मान वापस कर देते हैं।
एक अच्छा बिट वेक्टर भी operator & और अन्य ऐसी नब्बे के दशक को लागू करेगा ताकि वे बिट मैनिपुलेशन ऑपरेशंस के संदर्भ में एक बहुत बड़े हस्ताक्षरित पूर्णांक की तरह व्यवहार कर सकें।
* * बिट वैक्टर के बारे में आप क्या जानना चाहते हैं? सी ++ में, आप आमतौर पर इस – jalf
के लिए 'std :: bitset' या' std :: vector 'का उपयोग करेंगे, मैं यह भी नहीं जानता कि वे क्या उपयोगी हैं, इसलिए कुछ भी करेगा) –
भी मैं जानना चाहता हूं कि क्या बिट वेक्टर के आंतरिक यांत्रिकी है। खराब अंग्रेजी के लिए खेद है –