Boost C++ 库

...是世界上最受推崇和专业设计的 C++ 库项目之一。 — Herb Sutter 和 Andrei Alexandrescu, C++ 编码标准

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|，对应于集合运算，例如交集和并集。

概要

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;

    dynamic_bitset();

    explicit dynamic_bitset(const Allocator& alloc);

    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);

    dynamic_bitset(dynamic_bitset&& b);

    void swap(dynamic_bitset& b);

    dynamic_bitset& operator=(const dynamic_bitset& b);

    dynamic_bitset& operator=(dynamic_bitset&& b);

    allocator_type get_allocator() const;

    void resize(size_type num_bits, bool value = false);
    void clear();
    void pop_back();
    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, size_type len, bool val);
    dynamic_bitset& set(size_type n, bool val = true);
    dynamic_bitset& set();
    dynamic_bitset& reset(size_type n, size_type len);
    dynamic_bitset& reset(size_type n);
    dynamic_bitset& reset();
    dynamic_bitset& flip(size_type n, size_type len);
    dynamic_bitset& flip(size_type n);
    dynamic_bitset& flip();
    reference at(size_type n);
    bool at(size_type n) const;
    bool test(size_type n) const;
    bool test_set(size_type n, bool val = true);
    bool all() const;
    bool any() const;
    bool none() const;
    dynamic_bitset operator~() const;
    size_type count() const noexcept;

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

    unsigned long to_ulong() const;

    size_type size() const noexcept;
    size_type num_blocks() const noexcept;
    size_type max_size() const noexcept;
    bool empty() const noexcept;
    size_type capacity() const noexcept;
    void reserve(size_type num_bits);
    void shrink_to_fit();

    bool is_subset_of(const dynamic_bitset& a) const;
    bool is_proper_subset_of(const dynamic_bitset& a) const;
    bool intersects(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）。 设置 一个位是将它赋值为 1。清除 或重置 一个位是将它赋值为 0。翻转 一个位是将值更改为 1（如果它原来是 0）或更改为 0（如果它原来是 1）。每一位都有一个非负的位置。一个位集x包含x.size()个位，每个位都在范围[0,x.size())内分配了一个唯一的位置。位置 0 处的位称为最低有效位，位置size() - 1处的位称为最高有效位。当将dynamic_bitset的实例转换为或从无符号长整型n转换时，位集中位置i处的位具有与(n >> i) & 1.

示例

相同的值。示例 1（设置和读取一些位）

示例 2（从整数创建一些位集）

示例 3（执行输入/输出和一些按位运算）。

原理

dynamic_bitset不是 容器，并且不提供迭代器，原因如下

  • 具有代理引用的容器类型不能满足 C++ 标准中指定的容器要求（除非使用奇怪的迭代器语义）。std::vector<bool>具有代理引用的容器类型，并且不满足容器要求，因此导致了很多问题。一个常见的问题是，当人们尝试将std::vector<bool>中的迭代器与标准算法（例如std::search）一起使用时。该std::search要求规定迭代器必须是 前向迭代器，但是std::vector<bool>::iterator由于代理引用而无法满足此要求。根据实现的不同，这种误用可能会或可能不会导致编译错误，甚至是运行时错误。有关该问题的进一步讨论，请参阅 Scott Meyers 的《Effective STL》。因此，dynamic_bitset试图通过不假装是容器来避免这些问题。

有些人喜欢用“toggle”代替“flip”。之所以选择“flip”这个名称，是因为它是 std::bitset 中使用的名称。事实上，dynamic_bitset的大多数函数名称都是出于这个原因而选择的。

dynamic_bitset在违反先决条件时不会引发异常（如在std::bitset中那样）。而是使用assert。有关说明，请参阅 错误和异常处理指南。

头文件

类dynamic_bitset在头文件 boost/dynamic_bitset.hpp 中定义。此外，在头文件 boost/dynamic_bitset_fwd.hpp 中有dynamic_bitset的前向声明。

模板参数

参数 描述 默认值
Block 存储位的整数类型。 unsigned long
Allocator 用于所有内部内存管理的分配器类型。 std::allocator<Block>

概念模型

可赋值, 默认可构造, 可相等比较, 可小于比较。

类型要求

Block是一个无符号整数类型。Allocator满足分配器的标准要求。

公共基类

无。

嵌套类型名称

dynamic_bitset::reference

充当单个位引用的代理类。它包含一个赋值运算符、一个到bool的转换，一个operator~和一个成员函数flip。它仅作为dynamic_bitset的operator[]辅助类存在。下表描述了引用的容器类型的有效操作。假设b是dynamic_bitset, 的实例，并且i, j属于size_type并且在范围[0,b.size())内。另外，请注意，当我们写b[i]引用的容器时，我们的意思是类型内。另外，请注意，当我们写的对象，该对象是从x初始化的。变量bool.

是 表达式
语义 x = b[i]b将x.
的第 i 位赋值给 (bool)b[i]b.
返回 的第 i 位bb[i] = xx将内。另外，请注意，当我们写.
的第 i 位设置为 的值，并返回bb[i] |= xx将内。另外，请注意，当我们写.
将 的第 i 位与bb[i] |= xx将内。另外，请注意，当我们写.
的值进行或运算 b[i] &= xbb[i] |= xx将内。另外，请注意，当我们写.
将 的第 i 位进行与运算b[i] ^= x将b的第 i 位进行异或运算内。另外，请注意，当我们写.
b[i] -= x 的第 i 位b如果b将内。另外，请注意，当我们写.
x==true 的值，并返回b，则清除b将内。另外，请注意，当我们写.
的第 i 位。返回 的第 i 位与b，则清除b将内。另外，请注意，当我们写.
b[i] = b[j] b[i] &= xb，则清除b将内。另外，请注意，当我们写.
将 的第 i 位赋值为b的第 j 位的值b的第 i 位进行异或运算内。另外，请注意，当我们写.
b[i] |= b[j] 将b将x.
的第 i 位与 的第 j 位进行或运算b.
b[i] &= b[j] 将b将内。另外，请注意，当我们写. 
dynamic_bitset::const_reference
的第 i 位进行与运算bool. 
dynamic_bitset::size_type
b[i] ^= b[j]
dynamic_bitset::block_type
将Block. 
dynamic_bitset::allocator_type;
将Allocator.

公共数据成员

dynamic_bitset::bits_per_block
的第 i 位进行异或运算Blockb[i] -= b[j]如果. 
dynamic_bitset::npos
的第 j 位已设置，则清除属于.

构造函数

dynamic_bitset()
的第 i 位Allocator.
x = ~b[i] 将.
的第 i 位的相反值赋给Allocator(bool)~b[i]
返回
dynamic_bitset(const Allocator& alloc)
的第 i 位的相反值b[i].flip()翻转的第 i 位类型
x = ~b[i] 将.
size_type
dynamic_bitset(size_type num_bits,
               unsigned long value = 0,
               const Allocator& alloc = Allocator())
用于表示位集大小的无符号整数类型。bits_per_block与类型相同bits_per_block类型用于表示值（不包括任何填充位）所使用的位数。数值上等于b[i].flip()翻转的第 i 位std::numeric_limits<Block>::digits

最大值

作用： 构造一个大小为零的位集。此位集的分配器是类型为
x = ~b[i]
  • 的默认构造对象
  • 后置条件ithis->size() == 0抛出： 如果, 的默认构造函数引发异常，则不抛出任何内容。.
  • 后置条件ithis->size() == 0(默认可构造的要求。), 作用： 构造一个大小为零的位集。一个.
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。).
dynamic_bitset(const dynamic_bitset& x)
抛出： 不抛出任何异常。x作用： 从整数构造位集。前x.
Mithis->size() == 0[0,x.size()), 位初始化为.
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。).
value
dynamic_bitset(dynamic_bitset&& x)
中的相应位，所有其他位（如果有）初始化为零（其中xM = min(num_bits, std::numeric_limits<unsigned long>::digits)x）。x.
Mithis->size() == 0[0,x.size()), 位初始化为.
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。). 
template <typename BlockInputIterator>
explicit
dynamic_bitset(BlockInputIterator first, BlockInputIterator last,
               const Allocator& alloc = Allocator());
的副本用于分配内存。请注意，例如，以下内容
  • dynamic_bitset b<>( 16, 7 );将匹配来自迭代器范围的构造函数（而不是此构造函数），但是底层实现仍然会“做正确的事情”，并从值 7 构造一个 16 位的位集。后置条件unsigned longthis->size() == num_bits对于范围内的所有

    [0,M)
    // 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);

    (*this)[i] == (value >> i) & 1
    [M,num_bits)(*this)[i] == false抛出： 如果内存耗尽，则抛出分配错误（如果std::bad_alloc如果Allocator=std::allocator作用： 构造一个位集，该位集是位集的副本。此位集的分配器是中分配器的副本std::bad_alloc后置条件： 对于所有dynamic_bitset(*this)[i] == x[i]

  • (可赋值的要求。)作用： 构造一个与位集相同的位集，同时使用中的资源。此位集的分配器是从中的分配器移动的。影响如果使用类型bBlockInputIterator调用此构造函数，该类型实际上是一个整数类型，则库的行为类似于使用参数static_cast<size_type>(first), last 和 allocb调用来自整数的构造函数，顺序如此。示例注意在编写本文时（2008 年 10 月），这与 库问题 438 的建议解决方案一致。这是一个 C++03 之后的更改，目前在C++0x的工作文件中。非正式地说，关于C++03i的关键更改是删除了第二个参数上的static_cast).

要求 将匹配来自迭代器范围的构造函数（而不是此构造函数），但是底层实现仍然会“做正确的事情”，并从值 7 构造一个 16 位的位集。必须是整型类型或输入迭代器的模型，其value_type与以下类型相同Block.
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。).
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 组成的字符串构造一个 bitset。前bits_per_block位被初始化为s中对应的字符，其中M = min(s.size() - pos, n)。 请注意，s中最高的字符位置，而不是最低的，对应于最低有效位。也就是说，字符位置pos + M - 1 - i对应于位i。所以，例如，dynamic_bitset(string("1101"))等同于dynamic_bitset(13ul).
抛出： 如果内存耗尽，则抛出分配错误（对象的副本将用于后续位集操作（例如resize）以分配内存。).

析构函数

~dynamic_bitset()
效果： 释放与此 bitset 关联的内存并销毁 bitset 对象本身。
size_type

成员函数

void swap(dynamic_bitset& b);
效果： 此 bitset 和 bitset 的内容b被交换。
后置条件： 此 bitset 等于原来的b，并且b等于此 bitset 的先前版本。
size_type
dynamic_bitset& operator=(const dynamic_bitset& x)
效果： 此 bitset 成为 bitset 的副本x.
Mithis->size() == 0[0,x.size()), 位初始化为.
返回 *this.
size_type
value
dynamic_bitset& operator=(dynamic_bitset&& x)
效果： 此 bitset 变得与 bitset 相同xM = min(num_bits, std::numeric_limits<unsigned long>::digits)x.
Mithis->size() == 0[0,x.size()), 位初始化为.
返回 *this.
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。). 
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)类型相同num_bits中的所有位都设置为num_bits > size()num_bits < size()[0,num_bits)
x = ~b[i] 的默认构造对象.
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。).
void clear()
保持不变（并且其余的位被丢弃）。
size_type
void pop_back();
先决条件 效果： bitset 的大小变为零。.
!this->empty()
size_type
void push_back(bool value);
效果： 将 bitset 的大小减 1。类型相同.
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。).
void append(Block value);
效果： 将 bitset 的大小增加 1，并将新的最高有效位的值设置为类型相同效果： 将中的位附加到 bitset（附加到最高有效端）。这会将 bitset 的大小增加bits_per_blocks。让ithis->size() == 0是 bitset 的旧大小，然后对于转换时，位集中位置[0,bits_per_block)(s + i)被设置为.
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。).
template <typename BlockInputIterator>
void append(BlockInputIterator first, BlockInputIterator last);
((value >> i) & 1)
for (; first != last; ++first)
  append(*first);
效果： 此函数提供与以下代码相同的结果，但通常更有效率。将匹配来自迭代器范围的构造函数（而不是此构造函数），但是底层实现仍然会“做正确的事情”，并从值 7 构造一个 16 位的位集。要求：value_type类型必须是 输入迭代器的模型，并且Block.
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。).
dynamic_bitset& operator&=(const dynamic_bitset& rhs)
要求 必须与以下类型相同.
this->size() == rhs.size()效果： 将中的所有位与此 bitset 中的位按位进行 AND 运算。这等效于
for (size_type i = 0; i != this->size(); ++i)
  (*this)[i] = (*this)[i] & rhs[i];
返回 *this.
size_type
dynamic_bitset& operator|=(const dynamic_bitset& rhs)
要求 必须与以下类型相同.
rhs效果： 将中的所有位与此 bitset 中的位按位进行 AND 运算。这等效于
for (size_type i = 0; i != this->size(); ++i)
  (*this)[i] = (*this)[i] | rhs[i];
返回 *this.
size_type
dynamic_bitset& operator^=(const dynamic_bitset& rhs)
要求 必须与以下类型相同.
效果： 将效果： 将中的所有位与此 bitset 中的位按位进行 AND 运算。这等效于
for (size_type i = 0; i != this->size(); ++i)
  (*this)[i] = (*this)[i] ^ rhs[i];
返回 *this.
size_type
dynamic_bitset& operator-=(const dynamic_bitset& rhs)
要求 必须与以下类型相同.
中的所有位按位进行 OR 运算效果： 将效果： 将
for (size_type i = 0; i != this->size(); ++i)
  (*this)[i] = (*this)[i] && !rhs[i];
返回 *this.
size_type
dynamic_bitset& operator<<=(size_type n)
中的所有位按位进行 XOR 运算n效果： 计算此 bitset 和的集合差。这等效于bitset。
返回 *this.
size_type
dynamic_bitset& operator>>=(size_type n)
效果： 将此 bitset 中的位向左移动n位。对于 bitset 中的每个位，位置 pos 的位取位置pos - n的先前值，如果不存在这样的位，则取零。效果： 将此 bitset 中的位向右移动bitset。
返回 *this.
size_type
dynamic_bitset operator<<(size_type n) const
位。对于 bitset 中的每个位，位置*thisposn的位取位的集合差。这等效于pos + n
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。). 
dynamic_bitset operator>>(size_type n) const
位。对于 bitset 中的每个位，位置*this的先前值。n的位取位效果： 将此 bitset 中的位向右移动pos + n
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。). 
dynamic_bitset& set()
返回：
返回 *this
size_type
dynamic_bitset& flip()
的副本向左移动了
返回 *this
size_type
dynamic_bitset operator~() const
位。对于 bitset 中的每个位，位置*this位。对于返回的 bitset 中的每个位，位置 pos 的位取位置
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。). 
dynamic_bitset& reset()
的位的值，如果不存在这样的位，则取零。
返回 *this
size_type
dynamic_bitset& set(size_type n, size_type len, bool val);
先决条件 向右移动了.
效果： 将此 bitset 中的每个位设置为 1。n将效果： 反转此 bitset 中每个位的值。返回： 一个，其中所有位都被反转。效果： 清除此 bitset 中的每个位。n + len < this->size()效果： 如果，其中所有位都被反转。效果： 清除此 bitset 中的每个位。n.
返回 *this 
dynamic_bitset& set(size_type n, bool val = true)
先决条件 到.
n + len - 1nresize，其中所有位都被反转。效果： 清除此 bitset 中的每个位。n + len < this->size()（包括）之间的每个位，则将它们设置为 1。nresize，其中所有位都被反转。效果： 清除此 bitset 中的每个位。n.
返回 *this 
dynamic_bitset& reset(size_type n, size_type len);
先决条件 向右移动了.
如果是n将效果： 反转此 bitset 中每个位的值。true
返回 *this 
dynamic_bitset& reset(size_type n)
先决条件 到.
，并且如果n.
返回 *this 
dynamic_bitset& flip(size_type n, size_type len)
先决条件 向右移动了.
falsen将效果： 反转此 bitset 中每个位的值。true
返回 *this 
dynamic_bitset& flip(size_type n)
先决条件 到.
，则清除它们。n.
返回 *this 
size_type size() const
n < this->size()
size_type
size_type num_blocks() const
效果： 设置位
size_type
size_type max_size() const;
，并清除位dynamic_bitset效果： 清除索引从*this（包括）的每个位。dynamic_bitset效果： 清除位效果： 反转索引从（包括）的每个位。效果： 反转位返回： 此 bitset 中的位数。

返回： 此 bitset 中的块数。
bool empty() const;
返回 n + len < this->size()resize将, n返回： 与类型相同的对象的最大大小
size_type capacity() const;
。 请注意，如果任何*this操作导致
size_type
void reserve(size_type num_bits);
size()
超过
max_size() ，则行为未定义。.
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。). 
void shrink_to_fit();
[当 lib issue 197 关闭时，此函数的语义可能会略有变化]
超过
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。). 
size_type count() const
。 注意：不要与
size_type
bool all() const
返回 n + len < this->size()none()混淆，它的语义不同。返回：n.
size_type
bool any() const
返回 n + len < this->size()可以容纳而无需重新分配的元素总数。n.
size_type
bool none() const
返回 n + len < this->size()效果： 指示 bitset 计划更改大小的指令，以便它可以相应地管理存储分配。 在 reserve() 之后，如果发生重新分配，则 capacity() 大于或等于 reserve() 的参数； 否则等于 capacity() 的先前值。 当且仅当当前容量小于 reserve() 的参数时，才会在此处发生重新分配。n.
size_type
reference at(size_type n)
先决条件 到.
注意：它不会更改 bitset 的 size()。后置条件.
this->capacity() >= num_bits 效果： shrink_to_fit() 是一个通过删除未使用的容量来减少内存使用量的请求。返回： 此 bitset 中已设置的位数。n如果此 bitset 中的所有位都已设置或如果
bool at(size_type n) const
先决条件 到.
注意：它不会更改 bitset 的 size()。后置条件.
this->capacity() >= num_bits 效果： shrink_to_fit() 是一个通过删除未使用的容量来减少内存使用量的请求。返回： 此 bitset 中已设置的位数。n如果此 bitset 中的所有位都已设置或如果
bool test(size_type n) const
先决条件 到.
返回 n + len < this->size()size() == 0n，则返回n，否则返回n如果此 bitset 中设置了任何位，则返回
bool test_set(size_type n, bool val = true)
先决条件 到.
n + len - 1nresize，其中所有位都被反转。效果： 清除此 bitset 中的每个位。n + len < this->size()（包括）之间的每个位，则将它们设置为 1。nresize，其中所有位都被反转。效果： 清除此 bitset 中的每个位。n.
返回 n + len < this->size()，否则返回n如果未设置任何位，则返回n，否则返回n如果此 bitset 中设置了任何位，则返回
reference operator[](size_type n)
先决条件 到.
返回： 与引用的容器相同的noperator[](n)引用的容器抛出boolstd::out_of_rangeoperator[]如果该不在 bitset 的范围内。和如果是位已设置，并且是位. 
bool operator[](size_type n) const
先决条件 到.
注意：它不会更改 bitset 的 size()。为 0。. 
unsigned long to_ulong() const
如果位*this.
this->capacity() >= num_bits 的先前状态已设置，并且返回：unsigned long到位的*this。 请注意，是一个代理类，它具有赋值运算符和转换为. 
bool is_subset_of(const dynamic_bitset& a) const
要求 的功能，这允许你使用
进行赋值。 也就是说，你可以同时编写x = b[n]b[n] = xx = b[n]。 但是，在许多其他方面，代理与真正的引用类型
size_type
bool is_proper_subset_of(const dynamic_bitset& a) const
要求 的功能，这允许你使用
bool&x = b[n]b[n] = xx = b[n]不同。test(n)返回： 与
size_type
bool intersects(const dynamic_bitset& a) const
要求 的功能，这允许你使用
中的位对应的数值x = b[n]std::overflow_errorx = b[n]。 但是，在许多其他方面，代理与真正的引用类型
size_type
size_type find_first() const;
如果该值太大，无法用i表示，即如果i在>= std::numeric_limits<unsigned long>::digitsresize*this位置的任何非零位
size_type find_next(size_type pos) const;
如果该值太大，无法用ithis->size() == a.size()pos - n表示，即如果i在>= std::numeric_limits<unsigned long>::digits返回： 如果此 bitset 是 bitset
bool operator==(const dynamic_bitset& rhs) const
返回 n + len < this->size()resize必须与以下类型相同aithis->size() == 0的子集，则为 true。 也就是说，如果对于此 bitset 中设置的每个位，bitset, 中对应的位也已设置，则返回 true。 否则，此函数返回 false。返回： 如果此 bitset 是 bitsetn.
size_type
的真子集，则为 true
bool operator!=(const dynamic_bitset& rhs) const
返回 也已设置，并且如果
size_type
的真子集，则为 true
bool operator<(const dynamic_bitset& rhs) const
返回 n + len < this->size()this->count() < a.count()效果： 将。 否则，此函数返回 false。n返回： 如果此 bitset 和
size_type
相交，则为 true。 也就是说，如果此 bitset 中存在一个已设置的位，使得 bitset
bool operator>(const dynamic_bitset& rhs) const
返回 中对应的位也已设置，则返回 true
size_type
相交，则为 true。 也就是说，如果此 bitset 中存在一个已设置的位，使得 bitset
bool operator<=(const dynamic_bitset& rhs) const
返回 返回： 最低的索引
size_type
相交，则为 true。 也就是说，如果此 bitset 中存在一个已设置的位，使得 bitset
bool operator>=(const dynamic_bitset& rhs) const
返回 ，例如位
size_type
相交，则为 true。 也就是说，如果此 bitset 中存在一个已设置的位，使得 bitset

已设置，或

dynamic_bitset operator&(const dynamic_bitset& a, const dynamic_bitset& b)
要求 npos
没有开启位。x = b[n]和b.
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。). 
dynamic_bitset operator|(const dynamic_bitset& a, const dynamic_bitset& b)
要求 npos
大于x = b[n]和b.
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。). 
dynamic_bitset operator^(const dynamic_bitset& a, const dynamic_bitset& b)
要求 npos
，如果不存在这样的索引。x = b[n]和b.
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。). 
dynamic_bitset operator-(const dynamic_bitset& a, const dynamic_bitset& b)
要求 npos
并且如果对于所有x = b[n]和b.
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。). 
template <typename CharT, typename Alloc>
void to_string(const dynamic_bitset<Block, Allocator>& b,
               std::basic_string<Char,Traits,Alloc>& s)
[0,rhs.size())b(*this)[i] == rhs[i]s。 否则返回'1'（相等可比较要求。）'0'!((*this) == rhs)i如果此 bitset 在字典上小于，则返回 true，否则返回.
。 （有关字典排序的定义，请参阅 lexicographical_compare 的描述）。
（小于可比较要求。）!((*this) < rhs || (*this) == rhs)(*this) < rhs || (*this) == rhs
template <typename Block, typename Alloc, typename BlockOutputIterator>
void to_block_range(const dynamic_bitset<Block, Alloc>& b, BlockOutputIterator result)
(*this) > rhs || (*this) == rhs非成员函数a.size() == b.size()是 bitset 的旧大小，然后对于返回： 一个新的 bitset，它是 bitset的按位 AND返回： 一个新的 bitset，它是 bitset示例的按位 OR在编写本文时（2008 年 10 月），这与 库问题 438 的建议解决方案一致。这是一个 C++03 之后的更改，目前在C++0x的工作文件中。非正式地说，关于返回： 一个新的 bitset，它是 bitset
要求： 类型BlockOutputIterator必须是 输出迭代器 的模型，并且其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)
效果： 从迭代器范围读取块到 bitset 中。
要求： 类型BlockIterator必须是 输入迭代器 的模型，并且其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)
效果： 将 b 的文本表示形式插入到流中os（最高位优先）。非正式地说，输出与执行以下操作相同
std::basic_string<Char, Traits> s;
boost::to_string(x, s):
os << s;
除了流插入器会考虑注入到os，它boost::to_string()无法做到。这是一个更精确的规范，以“好像”规则给出：首先，对于 bitset 中的每个有效位置 ib让我们放置character_of(b[i]) = b[i]? os.widen('1') : os.widen('0');也让s是std::basic_string<Char, Traits>对象，长度为b.size()并且对于每个i在[0, b.size()), s[i] 是 character_of(b[i])然后，输出，对os的影响以及异常行为与输出对象相同s将os（相同的宽度，相同的异常掩码，相同的填充，相同的 setstate() 逻辑）
返回： os
this->capacity() >= num_bits 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。然后
  1. 一个 (非 eof) 字符c从效果： 清除此 bitset 中的每个位。中提取的是一个位集数字，当且仅当 Tr::eq(c, is.widen('0')) 或 Tr::eq(c, is.widen('1')) 返回 true 时。
  2. 如果 c 是一个位集数字，则它的对应位值为 0，如果 Tr::eq(c, is.widen('0')) 为 true，否则为 1。
该函数首先构造一个sentry对象k，就好像k是由typename std::basic_istream<Char, Traits>::sentry k(is)num_bitsbool(k)为 true 构造的，它会调用b.clear()然后尝试从效果： 清除此 bitset 中的每个位。中提取字符。对于每个作为位集数字的字符 c，其对应位值将附加到b的低有效端（附加可能会抛出异常）。如果is.width()大于零且小于b.max_size()则附加的最大位数n为is.width()；否则n = b.max_size()。除非提取器通过异常退出，否则会提取字符（并附加相应的位），直到发生以下任何一种情况
  • n位存储到位集中；
  • 输入序列中发生文件结束或错误；
  • 下一个可用的输入字符不是位集数字

如果没有任何异常导致函数退出，则is.width(0)被调用，无论实际提取了多少个字符。sentry 对象 k 被销毁。

如果函数没有提取任何字符[???]，它会调用 is.setstate(std::ios::failbit)，这可能会抛出异常std::ios_base::failure.
------
alloc对象的副本将用于后续位集操作（例如resize）以分配内存。）。如果从流中读取时出现问题，则会抛出std::ios_base::failure。

异常保证

所有dynamic_bitset函数都至少提供基本的异常保证。

与先前版本的更改

Boost 1.56.0 中的更改

  • 支持 C++11 移动构造函数。
  • 修复了 MSVC 2013 上的警告。
  • 支持 C++11 最小分配器。
  • 添加了 noexcept 规范。

Boost 1.37.0 中的更改

  • 从块范围构造的构造函数实现了一种“做正确的事情”的行为，类似于标准序列。

Boost 1.31.0 中的更改

  • 流提取器具有完全不同的语义：对于动态结构来说是自然的，它现在在提取期间根据需要扩展位集。新行为模仿!((*this) < rhs || (*this) == rhs)提取器，但用户应该注意一些差异；因此，请查看文档。(一个差异涉及 stream.width() > bitset.max_size() > 0 的情况。在这种情况下，dynamic_bitset的提取器永远不会尝试提取超过效果： 反转位个字符，而!((*this) < rhs || (*this) == rhs)的提取器会继续执行，并且在符合标准的实现上，最终会抛出一个length_error异常。注意：这是标准规定的 - 请特别参阅library issue 83- 但并非所有实现都符合)

    流提取器现在也“异常感知”，因为它在流上设置异常掩码时可以正常工作。

  • 添加了多个成员函数（empty(), find_first() , find_next(), get_allocator(), intersects() , 效果： 反转位 ）。
  • 从!((*this) < rhs || (*this) == rhs)构造的构造函数有一个新的参数，这个参数以前被完全遗忘了。
技术细节和细微的更改
  • 类引用的容器已被重新实现，以便 dynamic_bitset 的引用行为更像对标准容器元素的引用。特别是，现在可以保证它们不会因应用于其对应的dynamic_bitset的标准的 swap() 函数而失效。
一般改进
  • 对成员函数和非成员函数以及嵌套类进行了多次优化引用的容器.

另请参阅

std::bitset, std::vector,

致谢

我们要感谢 Boost 社区抽出时间审查并接受这个库。由于 Boost 成员的所有建议，这个库比以往任何时候都好得多。我们特别感谢 Matt Marcus 承担了评审经理的任务。此外，还要特别感谢 James Kanze 在国际化问题上提供的宝贵帮助。

版权所有 © 2001 Jeremy Siek，印第安纳大学 ([email protected])
Chuck Allison，《C/C++ 用户期刊》高级编辑 ([email protected])
版权所有 © 2003-2004, 2008 Gennaro Prota (name.surname yahoo.com)
版权所有 © 2014 Ahmed Charles ([email protected])
版权所有 © 2014 Glen Fernandes ([email protected])
版权所有 © 2014 Riccardo Marcangelo ([email protected])

根据 Boost 软件许可，版本 1.0 分发。(请参阅随附的文件 LICENSE_1_0.txt 或在 https://boost.ac.cn/LICENSE_1_0.txt 复制)