boost.png (6897 bytes)


dynamic_bitset<Block, Allocator>

目錄

Description(描述)
Synopsis(概要)
Definitions(定義)
Examples(示例)
Rationale(基本原理)
Header Files(頭文件)
Template Parameters(模板參數)
Concepts modeled(概念原型)
Type requirements(類型需求)
Public base classes(公有基類)
Nested type names(嵌套類型名)
Public data members(公有數據成員)
Constructors(構造函數)
Destructor(析構函數)
Member functions(成員函數)
Non-member functions(非成員函數)
Exception guarantees(異常保證)
Changes from previous version(s)(版本變化)
See also(參見)
Acknowledgements(感謝)

Description(描述)

dynamic_bitset 類表示一組二進制位。它通過 operator[] 提供對單獨二進制位的值的訪問,並提供了可以應用於內建整數類型的全部位操作符,比如 operator&operator<<。組內的二進制位數目在運行期通過 dynamic_bitset 的構造函數的一個參數指定。

dynamic_bitset 類和 std::bitset 類幾乎相同。區別在於 dynamic_bitset 的大小(二進制位的數目)是在運行期 dynamic_bitset 對象的構造過程中指定的,而 std::bitset 的大小是在編譯期由一個整型模板參數指定。

dynamic_bitset 的設計要解決的主要問題是表示一個有限集合的子集。每一個二進制位表示有限集合中的一個元素是否在子集中。這樣一來,dynamic_bitset 的位操作,比如 operator&operator|,就對應於相應的集合操作,比如交集和並集。

Synopsis(概要)

namespace boost {

template <typename Block, typename Allocator>
class dynamic_bitset
{
public:
typedef Block block_type;
typedef Allocator allocator_type;
typedef implementation-defined size_type;

static const int bits_per_block = implementation-defined;
static const size_type npos = implementation-defined;

class reference { void operator&(); // not defined public: // An automatically generated copy constructor. reference& operator=(bool value); reference& operator=(const reference& rhs); reference& operator|=(bool value); reference& operator&=(bool value); reference& operator^=(bool value); reference& operator-=(bool value); bool operator~() const; operator bool() const; reference& flip(); }; typedef bool const_reference;

explicit dynamic_bitset(const Allocator& alloc = Allocator());

explicit dynamic_bitset(size_type num_bits, unsigned long value = 0,
const Allocator& alloc = Allocator());

template <typename CharT, typename Traits, typename Alloc>
explicit dynamic_bitset(const std::basic_string<CharT, Traits, Alloc>& s,
typename std::basic_string<CharT, Traits, Alloc>::size_type pos = 0,
typename std::basic_string<CharT, Traits, Alloc>::size_type n = std::basic_string<CharT, Traits, Alloc>::npos,
const Allocator& alloc = Allocator());

template <typename BlockInputIterator>
dynamic_bitset(BlockInputIterator first, BlockInputIterator last,
const Allocator& alloc = Allocator());

dynamic_bitset(const dynamic_bitset& b);

void swap(dynamic_bitset& b);

dynamic_bitset& operator=(const dynamic_bitset& b);

allocator_type get_allocator() const;

void resize(size_type num_bits, bool value = false);
void clear();
void push_back(bool bit);
void append(Block block);
template <typename BlockInputIterator>
void append(BlockInputIterator first, BlockInputIterator last);

dynamic_bitset& operator&=(const dynamic_bitset& b);
dynamic_bitset& operator|=(const dynamic_bitset& b);
dynamic_bitset& operator^=(const dynamic_bitset& b);
dynamic_bitset& operator-=(const dynamic_bitset& b);
dynamic_bitset& operator<<=(size_type n);
dynamic_bitset& operator>>=(size_type n);
dynamic_bitset operator<<(size_type n) const;
dynamic_bitset operator>>(size_type n) const;

dynamic_bitset& set(size_type n, bool val = true);
dynamic_bitset& set();
dynamic_bitset& reset(size_type n);
dynamic_bitset& reset();
dynamic_bitset& flip(size_type n);
dynamic_bitset& flip();
bool test(size_type n) const;
bool any() const;
bool none() const;
dynamic_bitset operator~() const;
size_type count() const;

reference operator[](size_type pos);
bool operator[](size_type pos) const;

unsigned long to_ulong() const;

size_type size() const;
size_type num_blocks() const;
size_type max_size() const;
bool empty() const;

bool is_subset_of(const dynamic_bitset& a) const;
bool is_proper_subset_of(const dynamic_bitset& a) const;

size_type find_first() const;
size_type find_next(size_type pos) const;



};

template <typename B, typename A>
bool operator==(const dynamic_bitset<B, A>& a, const dynamic_bitset<B, A>& b);

template <typename Block, typename Allocator>
bool operator!=(const dynamic_bitset<Block, Allocator>& a, const dynamic_bitset<Block, Allocator>& b);

template <typename B, typename A>
bool operator<(const dynamic_bitset<B, A>& a, const dynamic_bitset<B, A>& b);

template <typename Block, typename Allocator>
bool operator<=(const dynamic_bitset<Block, Allocator>& a, const dynamic_bitset<Block, Allocator>& b);

template <typename Block, typename Allocator>
bool operator>(const dynamic_bitset<Block, Allocator>& a, const dynamic_bitset<Block, Allocator>& b);

template <typename Block, typename Allocator>
bool operator>=(const dynamic_bitset<Block, Allocator>& a, const dynamic_bitset<Block, Allocator>& b);

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
operator&(const dynamic_bitset<Block, Allocator>& b1, const dynamic_bitset<Block, Allocator>& b2);

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
operator|(const dynamic_bitset<Block, Allocator>& b1, const dynamic_bitset<Block, Allocator>& b2);

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
operator^(const dynamic_bitset<Block, Allocator>& b1, const dynamic_bitset<Block, Allocator>& b2);

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
operator-(const dynamic_bitset<Block, Allocator>& b1, const dynamic_bitset<Block, Allocator>& b2);

template <typename Block, typename Allocator, typename CharT, typename Alloc>
void to_string(const dynamic_bitset<Block, Allocator>& b,
std::basic_string<CharT, Alloc>& s);

template <typename Block, typename Allocator, typename BlockOutputIterator>
void to_block_range(const dynamic_bitset<Block, Allocator>& b,
BlockOutputIterator result);

template <typename CharT, typename Traits, typename Block, typename Allocator>
std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& os, const dynamic_bitset<Block, Allocator>& b);

template <typename CharT, typename Traits, typename Block, typename Allocator>
std::basic_istream<CharT, Traits>&
operator>>(std::basic_istream<CharT, Traits>& is, dynamic_bitset<Block, Allocator>& b);

} // namespace boost

Definitions(定義)

每一個二進制位代表布爾值 true 或者 false(1 或者 0)。set 一個二進制位就是將它賦值為 1。clear 或者 reset 一個二進制位就是將它賦值為 0。flip 一個二進制位就是如果它的值為 0 就變為 1,如果為 1 就變為 0。每一個二進制位有一個非負的 position。一個 bitset x 包含 x.size() 個二進制位,每一個二進制位被分配在區間 [0,x.size()) 中一個唯一的 position。position 0 的那個二進制位被稱為 least significant bit,而 position size() - 1 的是 most significant bit。當將一個 dynamic_bitset 實例變換為 unsigned long n,或從 unsigned long n 變換為一個 dynamic_bitset 實例時,bitset 中 position i 的二進制位的值與 (n >> i) & 1 相同。

Examples(示例)

Example 1 (設置並讀出一些二進制位)

Example 2 (從整數創建 bitsets)

Example 3 (執行輸入/輸出和一些位操作)。

Rationale(基本原理)

dynamic_bitset 不是容器,不提供迭代器,是因為以下原因:

    有些人更喜歡用名字 "toggle" 而不是 "flip"。選擇名字 "flip" 是因為它是 std::bitset 中使用的名字。實際上,dynamic_bitset 中大多數函數名字的選擇都是因為這個原因。

    當一個前提條件被違反的時候,dynamic_bitset 不拋出異常(就像 std::bitset 所做的)。代之以使用 assert。關於這一點的解釋參見 Error and Exception Handling 的指導方針。

    Header Files(頭文件)

    dynamic_bitset 被定義在頭文件 boost/dynamic_bitset.hpp 中。而且,頭文件 boost/dynamic_bitset_fwd.hpp 中有一個 dynamic_bitset 的前向聲明。

    Template parameters(模板參數)

    參數 說明 缺省
    Block 存儲在二進制位中的整數類型。 unsigned long
    Allocator 用於所有內部內存管理的分配器類型。 std::allocator<Block>

    Concepts Modeled(概念原型)

    Assignable, Default Constructible, Equality Comparable, LessThan Comparable.

    Type requirements(類型需求)

    Block 是一個無符號整數類型。Allocator 滿足一個分配器的標準需求。

    Public base classes(公有基類)

    無。

    Nested type names(嵌套類型名)


    dynamic_bitset::reference
    

    一個行為類似引向一個單獨二進制位的引用的代理類。它包含一個賦值操作符,一個到 bool 的轉換,一個 operator~,和一個成員函數 flip。它僅僅作為 dynamic_bitsetoperator[] 的一個輔助類而存在。下表描述了對 reference 類型的合法的操作。假設 b 是一個 dynamic_bitset 的實例,i, jsize_type 而且在區間 [0,b.size()) 中。還有,注意,當我們寫 b[i] 時,我們的意思是一個由 b[i] 初始化的類型 reference 的對象。變量 x 是一個 bool

    表達式 語義
    x = b[i] b 的第 i 個二進制位賦給 x
    (bool)b[i] 返回 b 的第 i 個二進制位。
    b[i] = x b 的第 i 個二進制位設置為 x,並返回 b[i]
    b[i] |= x b 的第 i 個二進制位和 x 的值做或操作,並返回 b[i]
    b[i] &= x b 的第 i 個二進制位和 x 的值做與操作,並返回 b[i]
    b[i] ^= x b 的第 i 個二進制位和 x 的值做異或操作,並返回 b[i]
    b[i] -= x 如果 x==true,清空 b 的第 i 個二進制位。返回 b[i]
    b[i] = b[j] b 的第 i 個二進制位設置為 b 的第 j 個二進制位的值,並返回 b[i]
    b[i] |= b[j] b 的第 i 個二進制位和 b 的第 j 個二進制位做或操作,並返回 b[i]
    b[i] &= b[j] b 的第 i 個二進制位和 b 的第 j 個二進制位做與操作,並返回 b[i]
    b[i] ^= b[j] b 的第 i 個二進制位和 b 的第 j 個二進制位做異或操作,並返回 b[i]
    b[i] -= b[j] 如果 b 的第 j 個二進制位被設置,清空 b 的第 i 個二進制位。並返回 b[i]
    x = ~b[i] b 的第 i 個二進制位的反賦給 x
    (bool)~b[i] 返回 b 的第 i 個二進制位的反。
    b[i].flip() b 的第 i 個二進制位取反,並返回 b[i]

    dynamic_bitset::const_reference
    
    類型 bool
    dynamic_bitset::size_type
    
    無符號整數類型,代表 bit set 的大小。
    dynamic_bitset::block_type
    
    Block 類型相同。
    dynamic_bitset::allocator_type;
    
    Allocator 類型相同。

    Public data members(公有數據成員)


    dynamic_bitset::bits_per_block
    
    用來表示值的類型 Block 的,排除任何冗余二進制位後的二進制位的數目。在數字上等於 std::numeric_limits<Block>::digits
    dynamic_bitset::npos
    
    size_type 的最大值。[gps]

    Constructors(構造函數)


    dynamic_bitset(const Allocator& alloc = Allocator())
    作用:構造一個大小為 0 的 bitset。alloc 對象的一個拷貝將被用於隨後的 bitset 操作(比如 resize)中分配內存。
    後置條件:this->size() == 0
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。
    (需求來自於 Default Constructible(可缺省構造)。)
    dynamic_bitset(size_type num_bits,
    unsigned long value = 0,
    const Allocator& alloc = Allocator())
    作用:從一個整數構造一個 bitset。前 M 個二進制位被初始化為 val 中的相應的二進制位,其他(如果有的話)全部被初始化為 0(這裡的 M = min(num_bits, std::numeric_limits<unsigned long>::digits))。alloc 對象的一個拷貝將被用於隨後的 bitset 操作(比如 resize)中分配內存。例如,如下:

    dynamic_bitset b<>( 16, 7 );

    將匹配 由一個迭代器區間進行構造的構造函數 (不是這一個),不過底層的實現還是會"做正確的事"並構造從值 7 構造一個 16 位的 bitset。

    後置條件: 拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。

    dynamic_bitset(const dynamic_bitset& x)
    作用:構造一個是 bitset x 的拷貝的 bitset。this bitset 的分配器是 x 中的分配器的一個拷貝。
    後置條件:對於區間 [0,x.size()) 中的所有 i(*this)[i] == x[i]
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。
    (需求來自於 Assignable(可賦值)。)
    template <typename BlockInputIterator>
    explicit
    dynamic_bitset(BlockInputIterator first, BlockInputIterator last,
    const Allocator& alloc = Allocator());
    作用:基於一個 blocks 的區間構造一個 bitset。讓 *first 為 block number 0,*++first 為 block number 1,等等。block number b 被用於初始化 dynamic_bitset 的位置區間 [b*bits_per_block, (b+1)*bits_per_block) 中的二進制位。對於每一個值為 bval 的 block number b,二進制位 (bval >> i) & 1 相當於在 bitset 中位置 (b * bits_per_block + i) 上的二進制位(這裡的 i 在區間 [0, bits_per_block) 中)。
    dynamic_bitset(BlockInputIterator first, BlockInputIterator last,
    const Allocator& alloc = Allocator());
    作用:
    要求:類型 BlockInputIterator 必須是一個 Input Iterator 的原型,而它的 value_type 必須和 Block 是同一個類型。
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。

    template<typename Char, typename Traits, typename Alloc>
    explicit
    dynamic_bitset(const std::basic_string<Char,Traits,Alloc>& s,
    typename std::basic_string<CharT, Traits, Alloc>::size_type pos = 0,
    typename std::basic_string<CharT, Traits, Alloc>::size_type n = std::basic_string<Char,Traits,Alloc>::npos,
    const Allocator& alloc = Allocator())
    前提條件:pos <= s.size() 而且用於初始化二進制位的字符必須是 0 或者 1
    作用:從一個 0 的或者 1 的 string 構造一個 bitset。前 M 個二進制位被初始化為 s 中相應的字符,這裡的 M = min(s.size() - pos, n)。注意 s 中的最高的字符位置,不是最低的,對應於 least significant bit。也就是說,字符位置 pos + M - 1 - i 對應於二進制位 i。所以,例如,dynamic_bitset(string("1101"))dynamic_bitset(13ul) 相同。
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。

    Destructor(析構函數)


    ~dynamic_bitset()
    作用:釋放與 this bitset 有關的內存並銷毀這個 bitset 對像自身。
    拋出:不拋出異常。

    Member Functions(成員函數)


    void swap(dynamic_bitset& b);
    作用:this bitset 的內容與 bitset b 的內容被互相交換。
    後置條件:this bitset 與原來的 b 相等,而 b 也等於 this bitset 的先前版本。
    拋出:不拋出異常。
    dynamic_bitset& operator=(const dynamic_bitset& x)
    作用:this bitset 成為 bitset x 的一個拷貝。
    後置條件:對於區間 [0,x.size()) 中的所有 i(*this)[i] == x[i]
    返回:*this
    拋出:不拋出異常。
    (需求來自於 Assignable(可賦值)。)
    allocator_type get_allocator() const;
    返回:用於構造 *this 的分配器對象的一個拷貝。
    void resize(size_type num_bits, bool value = false);
    作用:將此 bitset 的二進制位數目變為 num_bits。如果 num_bits > size(),那麼區間 [0,size()) 中的二進制位保持不變,[size(),num_bits) 中的二進制位全部被設置為 value。如果 num_bits < size(),那麼區間 [0,num_bits) 中的二進制位保持不變(而剩餘的二進制位被拋棄)。
    後置條件:this->size() == num_bits
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。

    void clear()
    作用:bitset 的大小變為 0。
    拋出:不拋出異常。
    void push_back(bool value);
    作用:將 bitset 的大小增加 1,並設置新的 most-significant bit 的值為 value
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。

    void append(Block value);
    作用:value 中的二進制位附加到 bitset 中(加在最後)。這將 bitset 的大小增大 bits_per_block。如果 s 是 bitset 的原大小,那麼對於區間 [0,bits_per_block) 中的 i,位置 (s + i) 上的二進制位被設置為 ((value >> i) & 1)
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。

    template <typename BlockInputIterator>
    void append(BlockInputIterator first, BlockInputIterator last);
    作用:這個函數提供和下面的代碼相同的最終結果,但是一般更有效率。[gps]
    for (; first != last; ++first)
    append(*first);
    要求:BlockInputIterator 類型必須是一個 Input Iterator 的原型,而它的 value_type 必須和 Block 是同一個類型。
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。

    dynamic_bitset& operator&=(const dynamic_bitset& rhs)
    要求:this->size() == rhs.size()
    作用:rhs 中的所有二進制位與 this bitset 中的二進制位做按位與。這等價於:
    for (size_type i = 0; i != this->size(); ++i)
    (*this)[i] = (*this)[i] & rhs[i];
    返回:*this
    拋出:不拋出異常。
    dynamic_bitset& operator|=(const dynamic_bitset& rhs)
    要求:this->size() == rhs.size()
    作用:rhs 中的所有二進制位與 this bitset 中的二進制位做按位與。這等價於:
    for (size_type i = 0; i != this->size(); ++i)
    (*this)[i] = (*this)[i] | rhs[i];
    返回:*this
    拋出:不拋出異常。
    dynamic_bitset& operator^=(const dynamic_bitset& rhs)
    要求:this->size() == rhs.size().
    作用:rhs 中的所有二進制位與 this bitset 中的二進制位做按位異或。這等價於:
    for (size_type i = 0; i != this->size(); ++i)
    (*this)[i] = (*this)[i] ^ rhs[i];
    返回:*this
    拋出:不拋出異常。
    dynamic_bitset& operator-=(const dynamic_bitset& rhs)
    要求:this->size() == rhs.size()
    作用:求出 this bitset 和 rhs bitset 的差集。這等價於:
    for (size_type i = 0; i != this->size(); ++i)
    (*this)[i] = (*this)[i] && !rhs[i];
    返回:*this
    拋出:不拋出異常。
    dynamic_bitset& operator<<=(size_type n)
    作用:將 this bitset 中的二進制位向左移動 n 個二進制位。對於 bitset 中的每一個二進制位,位置 pos 上的二進制位持有位置 pos - n 上的二進制位原來的值,或者如果沒有這樣的二進制位存在,則為 0。
    返回:*this
    拋出:不拋出異常。
    dynamic_bitset& operator>>=(size_type n)
    作用:將 this bitset 中的二進制位向右移動 n 個二進制位。對於 bitset 中的每一個二進制位,位置 pos 上的二進制位持有位置 pos + n 上的二進制位原來的值,或者如果沒有這樣的二進制位存在,則為 0。
    返回:*this
    拋出:不拋出異常。
    dynamic_bitset operator<<(size_type n) const
    返回:*this 的一個拷貝並向左移動 n 個二進制位。對於返回的 bitset 中的每一個二進制位,位置 pos 上的二進制位持有 this bitset 的位置 pos - n 上的二進制位的值,或者如果這樣的二進制位不存在,則為 0。注意,表達式 b << n 等價於構造一個 b 的臨時拷貝,然後使用 operator<<=
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。
    dynamic_bitset operator>>(size_type n) const
    返回:*this 的一個拷貝並向右移動 n 個二進制位。對於返回的 bitset 中的每一個二進制位,位置 pos 上的二進制位持有 this bitset 的位置 pos + n 上的二進制位的值,或者如果這樣的二進制位不存在,則為 0。注意,表達式 b >> n 等價於構造一個 b 的臨時拷貝,然後使用 operator>>=
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。
    dynamic_bitset& set()
    作用:設置 this bitset 中的每一個二進制位為 1。
    返回:*this
    拋出:不拋出異常。
    dynamic_bitset& flip()
    作用:翻轉 this bitset 中的每一個二進制位的值。
    返回:*this
    拋出:不拋出異常。
    dynamic_bitset operator~() const
    返回:*this 的一個拷貝,並翻轉它的所有二進制位。
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。
    dynamic_bitset& reset()
    作用:清空 this bitset 中的每一個二進制位。
    返回:*this
    拋出:不拋出異常。
    dynamic_bitset& set(size_type n, bool val = true)
    前提條件:n < this->size()
    作用:如果 valtrue,則設置二進制位 n,如果 valfalse,則清空二進制位 n
    返回:*this
    dynamic_bitset& reset(size_type n)
    前提條件:n < this->size()
    作用:清空二進制位 n
    返回:*this
    dynamic_bitset& flip(size_type n)
    前提條件:n < this->size()
    作用:翻轉二進制位 n
    返回:*this
    size_type size() const
    返回:this bitset 中的二進制位的數目。
    拋出:不拋出異常。
    size_type num_blocks() const
    返回:this bitset 中的 blocks 的數目。
    拋出:不拋出異常。
    size_type max_size() const;
    返回:擁有和 *this 相同類型的一個 dynamic_bitset 對象的最大大小。注意,如果有任何 dynamic_bitset 操作導致 size() 超過了 max_size(),則行為是未定義的

    【在 lib issue 197 關閉之後,這個函數的語義可能會有輕微的改變 - G.P.S.】

    bool empty() const;
    返回:如果 this->size() == 0,則為 true,否則,為 false注意:不要和 none() 混淆,那具有不同的語義。
    size_type count() const
    返回:this bitset 中被設置的二進制位的數目。
    拋出:不拋出異常。
    bool any() const
    返回:如果 this bitset 中有任何二進制位被設置,則為 true,否則,為 false
    拋出:不拋出異常。
    bool none() const
    返回:如果沒有二進制位被設置,則為 true,否則,為 false
    拋出:不拋出異常。
    bool test(size_type n) const
    前提條件:n < this->size()
    返回:如果二進制位 n 被設置,則為 true,如果二進制位 n 為 0,則為 false
    reference operator[](size_type n)
    前提條件:n < this->size()
    返回:一個引向二進制位 nreference。注意,這個 reference 是一個帶有一個賦值操作符和一個到 bool 的轉換的 proxy(代理)類,它允許你在賦值時使用 operator[]。也就是說,你既可以寫 x = b[n],也可以寫 b[n] = x。然而,在其它很多方面,proxy(代理)和真正的引用類型 bool& 不一樣。
    bool operator[](size_type n) const
    前提條件:n < this->size()
    返回:test(n) 相同。
    unsigned long to_ulong() const
    返回:*this 中的二進制位的相應的數字值。
    拋出:如果那個值太大以致不能用一個 unsigned long 表示(也就是說,如果 *this 的任何一個 >= std::numeric_limits<unsigned long>::digits 的位置有非 0 的二進制位),則拋出 std::overflow_error
    bool is_subset_of(const dynamic_bitset& a) const
    要求:this->size() == a.size()
    返回:如果 this bitset 是 bitset a 的一個子集,則為 true。也就是說,如果對於 this bitset 中的每一個被設置的二進制位,bitset a 中相對應的二進制位也被設置,則返回 true。否則,這個函數返回 false。
    拋出:不拋出異常。
    bool is_proper_subset_of(const dynamic_bitset& a) const
    要求:this->size() == a.size()
    返回:如果 this bitset 是 bitset a 的一個真子集,則為 true。也就是說,如果對於 this set 中每一個被設置的二進制位,bitset a 中相對應二進制位也被設置,而且 this->count() < a.count(),則返回 true。否則,這個函數返回 false。
    拋出:不拋出異常。
    size_type find_first() const;
    返回:被設置的二進制位的最小的索引 i,或者如果 *this 中沒有被設置的二進制位,則為 npos
    size_type find_next(size_type pos) const;
    返回:pos 大的被設置的二進制位的最小的索引 i,或者如果這樣的索引不存在,則為 npos
    bool operator==(const dynamic_bitset& rhs) const
    返回:如果 this->size() == rhs.size(),而且對於所有的在區間 [0,rhs.size()) 中的 i,都有 (*this)[i] == rhs[i],則為 true。否則,返回 false
    拋出:不拋出異常。
    (需求來自於 Equality Comparable(可等值比較)。)
    bool operator!=(const dynamic_bitset& rhs) const
    返回:!((*this) == rhs)
    拋出:不拋出異常。
    (需求來自於 Equality Comparable(可等值比較)。)
    bool operator<(const dynamic_bitset& rhs) const
    返回:如果按照字典順序 this bitset 比 rhs 小,則為 true,否則,返回 false。(關於字典順序的定義,參見 lexicographical_compare(字典式比較)的描述)。
    拋出:不拋出異常。
    (需求來自於 Less Than Comparable(可小於比較)。)
    bool operator>(const dynamic_bitset& rhs) const
    返回:!((*this) < rhs || (*this) == rhs)
    拋出:不拋出異常。
    (需求來自於 Less Than Comparable(可小於比較)。)
    bool operator<=(const dynamic_bitset& rhs) const
    返回:(*this) < rhs || (*this) == rhs
    拋出:不拋出異常。
    (需求來自於 Less Than Comparable(可小於比較)。)
    bool operator>=(const dynamic_bitset& rhs) const
    返回:(*this) > rhs || (*this) == rhs
    拋出:不拋出異常。
    (需求來自於 Less Than Comparable(可小於比較)。)

    Non-Member Functions(非成員函數)


    dynamic_bitset operator&(const dynamic_bitset& a, const dynamic_bitset& b)
    要求:a.size() == b.size()
    返回:bitsets ab 按位與形成的新的 bitset。注意,表達式 b1 & b2 等價於創建一個臨時的 b1 的拷貝,使用 operator&=,並返回臨時拷貝。
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。
    dynamic_bitset operator|(const dynamic_bitset& a, const dynamic_bitset& b)
    要求:a.size() == b.size()
    返回:bitsets ab 按位或形成的新的 bitset。注意,表達式 b1 | b2 等價於創建一個臨時的 b1 的拷貝,使用 operator|=,並返回臨時拷貝。
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。
    dynamic_bitset operator^(const dynamic_bitset& a, const dynamic_bitset& b)
    要求:a.size() == b.size()
    返回:bitsets ab 按位異或形成的新的 bitset。注意,表達式 b1 ^ b2 等價於創建一個臨時的 b1 的拷貝,使用 operator^=,並返回臨時拷貝。
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。
    dynamic_bitset operator-(const dynamic_bitset& a, const dynamic_bitset& b)
    要求:a.size() == b.size()
    返回:bitsets ab 的差集形成的新的 bitset。注意,表達式 b1 – b2 等價於創建一個臨時的 b1 的拷貝,使用 operator-=,並返回臨時拷貝。
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。
    template <typename CharT, typename Alloc>
    void to_string(const dynamic_bitset<Block, Allocator>& b,
    std::basic_string<Char,Traits,Alloc>& s)
    作用:拷貝 b 的一個表示到 string s 中。如果一個二進制位被設置,則 string 中相應的字符為 '1',如果沒有設置,則為 '0'。string 的字符位置 i 對應於二進制位位置 b.size() - 1 – i
    拋出:如果內存被耗盡,string 會拋出一個分配錯誤。
    基本原理:這個函數不是一個持有 0 個參數並返回一個 string 的成員函數是由於兩個原因。首先,因為 string 不用拷貝(由於以傳值方式傳遞),這個版本的性能稍微高一些。第二,作為一個成員函數,為了允許與 basic_string 的模板參數相關的彈性,成員函數需要顯式模板參數。沒有幾個 C++ 程序員熟悉顯式模板參數,而且一些 C++ 編譯器也不能很好地處理它們。
    template <typename Block, typename Alloc, typename BlockOutputIterator>
    void to_block_range(const dynamic_bitset<Block, Alloc>& b, BlockOutputIterator result)
    作用:將 bitset 中的二進制位一次一個 block 地寫入迭代器 result 中。第一個 block 寫入代表 bitset 中位置區間 [0,bits_per_block) 內的二進制位,第二個 block 寫入區間 [bits_pre_block,2*bits_per_block) 內的二進制位,並依此類推。對於每一個寫入的 block bval,二進制位 (bval >> i) & 1 對應於 bitset 中位置 (b * bits_per_block + i) 上的二進制位。
    要求:類型 BlockOutputIterator 必須是一個 Output Iterator 的原型,而它的 value_type 必須和 Block 的類型相同。此外,輸出區間的大小必須大於或等於 b.num_blocks()
    template <typename BlockIterator, typename Block, typename Alloc>
    void from_block_range(BlockIterator first,
    BlockIterator last, const dynamic_bitset<Block, Alloc>& b)
    作用:從迭代器區間讀 blocks 到 bitset 中。
    要求:類型 BlockIterator 必須是一個 Input Iterator 的原型,而它的 value_type 必須和 Block 的類型相同。輸出區間的大小必須小於或等於 b.num_blocks()
    template <typename Char, typename Traits, typename Block, typename Alloc>
    basic_ostream<Char, Traits>&
    operator<<(basic_ostream<Char, Traits>& os, const dynamic_bitset<Block, Alloc>& b)
    作用:向流 os 中插入 b 的一個字面表示(高位在前)。粗略地說,輸出和以下操作相同
    std::basic_string<Char, Traits> s;
    boost::to_string(x, s):
    os << s;
    只不過 stream inserter(流插入器)會考慮將地區信息注入 os,而 boost::to_string() 不會這樣做。更加精確的規範,按照 "as if" 規則給出:首先,對於 bitset b 中每一個合法的位置 i,讓我們放入:character_of(b[i)]) = b[i]? os.widen('1') : os.widen('0'); 再讓 s 成為一個 std::basic_string<Char, Traits> 對象,長度為 b.size(),並且,對於每一個 [0, b.size()) 中的 is[i]character_of(b[i])。那麼,輸出,對 os 的影響和異常行為和輸出對像 sos 中相同(相同的寬度,相同的異常掩碼,相同的填充,相同的 setstate() 邏輯)。
    返回:os
    拋出:如果向流中寫入時發生問題,拋出 std::ios_base::failure
    template <typename Char, typename Traits, typename Block, typename Alloc>
    std::basic_istream<Char,Traits>&
    operator>>(std::basic_istream<Char,Traits>& is, dynamic_bitset<Block, Alloc>& b)
    作用:從一個輸入流中提取一個 dynamic_bitset

    定義:

    Tris 的 traits_type。那麼:
    1. 對於一個從 is 中提取的(非 eof)字符 c,當且僅當 Tr::eq(c, is.widen('0')) 或 Tr::eq(c, is.widen('1')) 為 true 時,則 c 是一個 bitset digit
    2. 如果 c 是一個 bitset digit,當 Tr::eq(c, is.widen('0')) 為 true 時,它所對應的二進制位值為 0,否則為 1。
    函數一開始構造一個 sentry 對像 k,就好像 k 通過 typename std::basic_istream<Char, Traits>::sentry k(is) 構造。如果 bool(k) 為 true,它就調用 b.clear(),然後嘗試從 is 中提取字符。對於每一個是 bitset digit 的字符 c,相應的二進制位的值附加在 b 的 less significant 末尾(附加有可能拋出異常 - gps)。如果 is.width() 大於 0 且小於 b.max_size(),那麼附加的二進制位的最大值 nis.width(),否則 n = b.max_size()。除非提取器通過一個異常退出,否則,字符的提取(以及相應的二進制位的附加)直到下面某一情況發生才會停止:

    如果沒有導致函數退出的異常,則無論實際提取了多少個字符,is.width(0) 都會被調用。sentry 對像 k 被銷毀。

    如果函數沒有提取到字符 [???],它就會調用 is.setstate(std::ios::failbit),這有可能拋出 std::ios_base::failure
    ------
    拋出:如果內存耗盡會發生分配錯誤(如果 Allocator=std::allocator,則為 std::bad_alloc)。如果從流中讀入出現問題,會拋出 std::ios_base::failure

    Exception guarantees(異常保證)

    所有 dynamic_bitset 函數至少提供基本異常保證。

    Changes from previous version(s)(版本變化)

    Boost 1.37.0 的變化

    Boost 1.31.0 以來的變化

    技術的和輔助的變化 全面提高

    有幾個用於成員和非成員函數以及內嵌類 reference 的優化。

    See also(參見)

    std::bitset, std::vector,

    Acknowledgements(感謝)

    我們衷心感謝 Boost 社群投入時間來審查和接受這個庫。由於來自 Boost 成員的建議,這個庫變得比以前更好。我們特別要感謝 Matt Marcus 承擔了審查管理者的任務。而且,專門的感謝送給 James Kanze,他對國際化的幫助無法估量。


    Copyright c 2001 Jeremy Siek, Indiana University (jsiek@osl.iu.edu)
    Chuck Allison, Senior Editor, C/C++ Users Journal (cda@freshsources.com)
    Copyright c 2003-2004 Gennaro Prota