Đây là một thực thi vector bit kích thước tĩnh rất đơn giản. Nó yêu cầu C++ 11 hoạt động vì nó dựa trên tiêu đề <cstdint>, nhưng tiêu đề này khá phổ biến vì nó dựa trên tính năng C99. Trong một nhúm, bạn có thể sử dụng tiêu đề C <stdint.h> và chỉ cần sử dụng các loại trong không gian tên chung.
Lưu ý: Điều này đã được nhập khi đang di chuyển và không được thử nghiệm chút nào. Tôi thậm chí không xác minh nó sẽ biên dịch. Vì vậy, có thể có lỗi.
#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.
}
Toàn bộ my_bitvector_base điều là để tạo ra một loại loại tin. Bạn có thể đề cập đến nó trong giao diện hoặc triển khai cho các lớp dẫn xuất bởi vì nó là protected, nhưng bạn không thể đề cập đến các ngữ cảnh khác. Điều này ngăn mọi người lưu trữ bản sao của bitref. Điều này quan trọng bởi vì bitref chỉ thực sự tồn tại để cho phép gán vào kết quả của operator [] vì ủy ban tiêu chuẩn C++, trong tất cả sự khôn ngoan của chúng, đã không triển khai operator []= hoặc một cái gì đó tương tự để gán cho một phần tử mảng.
Như bạn có thể thấy, một bit bit về cơ bản là một mảng bit. Các bit bit Fancier sẽ mô phỏng một mảng 'vô hạn' các bit được khởi tạo thành true hoặc false. Họ làm điều này bằng cách theo dõi bit cuối cùng đã được thiết lập và tất cả các bit trước nó. Và nếu bạn yêu cầu một chút sau đó, họ chỉ trả về giá trị khởi tạo.
Một bit bit tốt cũng sẽ thực hiện operator & và các phần tử khác như vậy để chúng hoạt động giống như một số nguyên không dấu rất lớn có tham chiếu đến thao tác bit thao tác.
Bạn muốn biết gì về vectơ * bit? Trong C++, bạn thường sử dụng 'std :: bitset' hoặc' std :: vector 'cho số này –
jalf
, tôi thậm chí không biết chúng hữu ích cho cái gì, vì vậy mọi thứ cũng sẽ làm) –
Tôi cũng muốn biết cái gì là cơ chế bên trong của bit bit. xin lỗi vì tiếng anh xấu –