dynamic_bitset<Block, Allocator>

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

每一個二進制位代表布爾值 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 不是容器，不提供迭代器，是因為以下原因：

一個帶有 proxy reference type（代理引用類型）的容器不能履行 C++ 標準中指定的容器的需求（除非有人訴諸怪異的迭代器語義）。std::vector<bool> 有一個 proxy reference type（代理引用類型）而不能履行容器的需求，並因此導致很多問題。一個常見問題是當有人試圖將 std::vector<bool> 的迭代器用於一個諸如 std::search 這樣的標準算法時。std::search 要求迭代器必須是一個 Forward Iterator（前向迭代器），但是 std::vector<bool>::iterator 由於 proxy reference（代理引用）而不符合這個要求。根據不同的實現，由於這樣的誤用，它們可能是或不是一個編譯錯誤甚至是運行期錯誤。對這個問題的更深的討論請參見 Scott Meyers 的 Effective STL。所以 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_bitset 的 operator[] 的一個輔助類而存在。下表描述了對 reference 類型的合法的操作。假設 b 是一個 dynamic_bitset 的實例，i, j 是 size_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。

後置條件：

this->size() == num_bits
對於區間 [0,M) 中的所有 i，(*this)[i] == (value >> i) & 1。
對於區間 [M,num_bits) 中的所有 i，(*this)[i] == false。

拋出：如果內存耗盡會發生分配錯誤（如果 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 實際上是一個整數類型，那麼該庫的行為和以下調用一樣：以參數 static_cast<size_type>(first), last 和 alloc 調用由 unsigned long 進行構造的構造函數。

例子：
```
// b is constructed as if by calling the constructor
//
//   dynamic_bitset(size_type num_bits,
//                  unsigned long value = 0,
//                  const Allocator& alloc = Allocator())
//
// with arguments
//
//   static_cast<dynamic_bitset<unsigned short>::size_type>(8),
//   7,
//   Allocator()
//
dynamic_bitset<unsigned short> b(8, 7);
```
注:
在編寫本文檔時(2008年10月)，這是符合 library issue 438 建議決議的。這是一個 C++03之後 的變更，當前只在 C++0x 的工作草案中。非正式地講，對於 C++03 的關鍵變化是第二個參數去掉了 static_cast，對於何時這個模板構造函數與(size, value)的那個構造函數效果相同有更大餘地：在 C++03 中，僅當 InputIterator 為整數類型時；而對於建議決議，則當它是一個整數類型或實現可以檢測出不可能作為輸入迭代器的其它任何類型時。由於 dynamic_bitset 的原因，我們把自己限制在兩種變化中的第一個。
否則(即如果模板參數不是一個整數類型)，基於一個整數塊區間構造—在條件子句的條件之下—一個 bitset。令 *first 為整數塊 0, *++first 為整數塊 1, 等等。整數塊 b 用於初始化 dynamic_bitset 中位置為區間 [b*bits_per_block, (b+1)*bits_per_block) 的二進制位。對於每一個整數塊 b 以及值 bval, 二進制位 (bval >> i) & 1 對應於 bitset 中位置為 (b * bits_per_block + i) 的二進制位(其中 i 遍歷區間 [0, bits_per_block))。

要求：類型 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()。
作用：如果 val 為 true，則設置二進制位 n，如果 val 為 false，則清空二進制位 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()。
返回：一個引向二進制位 n 的 reference。注意，這個 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 a 和 b 按位與形成的新的 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 a 和 b 按位或形成的新的 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 a 和 b 按位異或形成的新的 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 a 和 b 的差集形成的新的 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()) 中的 i，s[i] 是 character_of(b[i])。那麼，輸出，對 os 的影響和異常行為和輸出對像 s 到 os 中相同（相同的寬度，相同的異常掩碼，相同的填充，相同的 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。

定義：

讓 Tr 是 is 的 traits_type。那麼：

對於一個從 is 中提取的（非 eof）字符 c，當且僅當 Tr::eq(c, is.widen('0')) 或 Tr::eq(c, is.widen('1')) 為 true 時，則 c 是一個 bitset digit。
如果 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()，那麼附加的二進制位的最大值 n 為 is.width()，否則 n = b.max_size()。除非提取器通過一個異常退出，否則，字符的提取（以及相應的二進制位的附加）直到下面某一情況發生才會停止：

n 個二進制位被存入 bitset；
輸入序列發生 end-of-file 或一個錯誤；
下一個可用輸入字符不是一個 bitset digit

如果沒有導致函數退出的異常，則無論實際提取了多少個字符，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 的變化

由塊區間進行構造的構造函數實現"做正確的事情"的行為，一個 la 標準序列。

Boost 1.31.0 以來的變化

流提取器具有完全不同的語義：它現在在提取過程中會根據需要擴展 bitset，對於一個動態結構來說這是很自然的。新的行為模擬了 basic_string 的提取器，但有一些用戶應該知道的區別，所以，請參考文檔。（其中一個區別涉及到 stream.width() > bitset.max_size() > 0 的情況，在實際情況中 dynamic_bitset 的提取器從來不會試圖擴展到超過 max_size() 個字符，反之，basic_string 的提取器會繼續下去，並且，在遵守標準的實現上，最終拋出一個 length_error。注意：這是標準的要求——特別是參見 library issue 83——但並非所有的實現都遵守標準）

流提取器現在也可以感知異常，在流上設置了異常掩碼的情況下可以正常地工作。
增加了幾個成員函數 (empty(), find_first(), find_next(), get_allocator(), intersects(), max_size() )。
從 basic_string 構造的構造函數有一個新的參數，以前被徹底地忘記了。

技術的和輔助的變化

類 reference 被重新實現，因此，dynamic_bitset 的引用的行為更像標準容器元素的引用。特別是，現在它可以保證：當標準庫的 swap() 函數應用于于這些引用相對應的 dynamic_bitsets 是，這些引用不會失效。

全面提高

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

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

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)（版本變化）

Boost 1.37.0 的變化

Boost 1.31.0 以來的變化

See also（參見）

Acknowledgements（感謝）