# 标准库头文件 <bitset>

< cpp‎ | header

此头文件是通用工具库的一部分。

### 包含
<string> | std::basic_string 类模板
<iosfwd> | 输入/输出库中所有类的前置声明
### 类
bitset | 实现常量长度的位数组 (类模板)
std::hash<std::bitset> (C++11) | std::bitset 的散列支持 (类模板特化)
##### 前置声明
定义于头文件 `<functional>`
hash (C++11) | 散列函数对象 (类模板)
### 函数
operator&operator|operator^ | 在 bitset 上执行二元逻辑操作 (函数)
operator<<operator>> | 执行 bitset 的流输入和输出 (函数)

### 概要

    #include <string>
    #include <iosfwd>   // 为 istream 、 ostream

    namespace std {
      template<size_t N> class bitset;

      // bitset 运算符
      template<size_t N>
        bitset<N> operator&(const bitset<N>&, const bitset<N>&) noexcept;
      template<size_t N>
        bitset<N> operator|(const bitset<N>&, const bitset<N>&) noexcept;
      template<size_t N>
        bitset<N> operator^(const bitset<N>&, const bitset<N>&) noexcept;
      template<class CharT, class Traits, size_t N>
        basic_istream<CharT, Traits>&
          operator>>(basic_istream<CharT, Traits>& is, bitset<N>& x);
      template<class CharT, class Traits, size_t N>
        basic_ostream<CharT, Traits>&
          operator<<(basic_ostream<CharT, Traits>& os, const bitset<N>& x);
    }

#### 类模板 std::bitset

    namespace std {
      template<size_t N> class bitset {
      public:
        // 位引用
        class reference {
          friend class bitset;
          reference() noexcept;

        public:
          reference(const reference&) = default;
          ~reference();
          reference& operator=(bool x) noexcept;            // 针对 b[i] = x;
          reference& operator=(const reference&) noexcept;  // 针对 b[i] = b[j];
          bool operator~() const noexcept;                  // 翻转位
          operator bool() const noexcept;                   // 针对 x = b[i];
          reference& flip() noexcept;                       // 针对 b[i].flip();
        };

        // 构造函数
        constexpr bitset() noexcept;
        constexpr bitset(unsigned long long val) noexcept;
        template<class CharT, class Traits, class Allocator>
          explicit bitset(
            const basic_string<CharT, Traits, Allocator>& str,
            typename basic_string<CharT, Traits, Allocator>::size_type pos = 0,
            typename basic_string<CharT, Traits, Allocator>::size_type n
              = basic_string<CharT, Traits, Allocator>::npos,
            CharT zero = CharT('0'),
            CharT one = CharT('1'));
        template<class CharT>
          explicit bitset(
            const charT* str,
            typename basic_string<CharT>::size_type n = basic_string<CharT>::npos,
            CharT zero = CharT('0'),
            CharT one = CharT('1'));

        // bitset 操作
        bitset& operator&=(const bitset& rhs) noexcept;
        bitset& operator|=(const bitset& rhs) noexcept;
        bitset& operator^=(const bitset& rhs) noexcept;
        bitset& operator<<=(size_t pos) noexcept;
        bitset& operator>>=(size_t pos) noexcept;
        bitset& set() noexcept;
        bitset& set(size_t pos, bool val = true);
        bitset& reset() noexcept;
        bitset& reset(size_t pos);
        bitset  operator~() const noexcept;
        bitset& flip() noexcept;
        bitset& flip(size_t pos);

        // 元素访问
        constexpr bool operator[](size_t pos) const;        // 针对 b[i];
        reference operator[](size_t pos);                   // 针对 b[i];

        unsigned long to_ulong() const;
        unsigned long long to_ullong() const;
        template<class CharT = char,
                 class Traits = char_Traits<CharT>,
                 class Allocator = allocator<CharT>>
          basic_string<CharT, Traits, Allocator>
            to_string(CharT zero = CharT('0'), CharT one = CharT('1')) const;

        size_t count() const noexcept;
        constexpr size_t size() const noexcept;
        bool operator==(const bitset& rhs) const noexcept;
        bool test(size_t pos) const;
        bool all() const noexcept;
        bool any() const noexcept;
        bool none() const noexcept;
        bitset operator<<(size_t pos) const noexcept;
        bitset operator>>(size_t pos) const noexcept;
      };

      // 散列支持
      template<class T> struct hash;
      template<size_t N> struct hash<bitset<N>>;
    }