构造函数

#include <bitset>
#include <string>
#include <iostream>
#include <climits>
int main() {
    // 空构造函数
    std::bitset<8> b1; // [0,0,0,0,0,0,0,0]
    // unsigned long long 构造函数
    std::bitset<8> b2(42);          // [0,0,1,0,1,0,1,0]
    std::bitset<70> bl(ULLONG_MAX); // [0,0,0,0,0,0,1,1,1,...,1,1,1] in C++11
    std::bitset<8> bs(0xfff0);      // [1,1,1,1,0,0,0,0]
    // string 构造函数: 用 std::basic_string str 中的字符构造 bitset 。能提供可选的起始位置 pos 和长度 n
    std::string bit_string = "110010";
    std::bitset<8> b3(bit_string);       // [0,0,1,1,0,0,1,0]
    std::bitset<8> b4(bit_string, 2);    // [0,0,0,0,0,0,1,0]
    std::bitset<8> b5(bit_string, 2, 3); // [0,0,0,0,0,0,0,1]
    // 使用自定义零/一数字的 string 构造函数
    std::string alpha_bit_string = "aBaaBBaB";
    std::bitset<8> b6(alpha_bit_string, 0, alpha_bit_string.size(),'a', 'B');         // [0,1,0,0,1,1,0,1]
    // 使用自定义数字的 char* 构造函数
    std::bitset<8> b7("XXXXYYYY", 8, 'X', 'Y'); // [0,0,0,0,1,1,1,1]
    std::cout << b1 << "\nb2:" <<  b2 << "\nbl:" <<  bl << "\nbs:" << bs << '\n'
              << "b3:"<< b3 << "\nb4:" << b4<< "\nb5:" << b5 << "\nb6:" << b6 << '\n';
}

operator[]

作用：访问位于位置 pos 的位

// bitset::operator[]
#include <iostream>       // std::cout
#include <bitset>         // std::bitset
int main ()
{
  std::bitset<4> foo;
  foo[1]=1;             // 0010
  foo[2]=foo[1];        // 0110
  std::cout << "foo: " << foo << '\n';
  return 0;
}
//Output:
//foo: 0110

test

作用：

返回pos位置的元素是否被设置，或者是否为1。返回值为true，或false。

不同于 operator[] ，它进行边界检查，且若 pos 不对应 bitset 中的合法位置则抛出 std::out_of_range 。

#include <iostream>
#include <bitset>
int main() 
{
    std::bitset<10> b1("1111010000");
    size_t idx = 0;
    while (idx < b1.size() && !b1.test(idx)) {
      ++idx;
    }
    if (idx < b1.size()) {
        std::cout << "first set bit at index " << idx << '\n';
    } else {
        std::cout << "no set bits\n";
    }
}

// bitset::test
#include <iostream>       // std::cout
#include <string>         // std::string
#include <cstddef>        // std::size_t
#include <bitset>         // std::bitset
int main ()
{
  std::bitset<5> foo (std::string("01011"));
  std::cout << "foo contains:\n";
  std::cout << std::boolalpha;
  for (std::size_t i=0; i<foo.size(); ++i)
    std::cout << foo.test(i) << '\n';
  return 0;
}
//Output:
//foo contains:
//true
//true
//false
//true
//false

all, any, none

检查是否全部、任一或无位被设为 true 。

1) 检查是否全部位被设为 true 。

2) 检查是否任一位被设为 true 。

3) 检查是否无位被设为 true

#include <iostream>
#include <bitset>
int main()
{
    std::bitset<4> b1("0000");
    std::bitset<4> b2("0101");
    std::bitset<4> b3("1111");
    std::cout << "bitset\t" << "all\t" << "any\t" << "none\n";
    std::cout << b1 << '\t' << b1.all() << '\t' << b1.any() << '\t' << b1.none() << '\n';
    std::cout << b2 << '\t' << b2.all() << '\t' << b2.any() << '\t' << b2.none() << '\n';
    std::cout << b3 << '\t' << b3.all() << '\t' << b3.any() << '\t' << b3.none() << '\n';
}

count

统计bitset中被设置的bits的个数，也就是bitset中值为1的元素个数。

// bitset::count
#include <iostream>       // std::cout
#include <string>         // std::string
#include <bitset>         // std::bitset
int main ()
{
  std::bitset<8> foo (std::string("10110011"));
  std::cout << foo << " has ";
  std::cout << foo.count() << " ones and ";
  std::cout << (foo.size()-foo.count()) << " zeros.\n";
  return 0;
}
//Output:
//10110011 has 5 ones and 3 zeros.

size()

返回bitset中元素总个数。即通常意义上bitset的大小。示例代码如下：

// bitset::size
#include <iostream>       // std::cout
#include <bitset>         // std::bitset
int main ()
{
  std::bitset<8> foo;
  std::bitset<4> bar;
  std::cout << "foo.size() is " << foo.size() << '\n';
  std::cout << "bar.size() is " << bar.size() << '\n';
  return 0;
}
//Output:
//foo.size() is 8
//bar.size() is 4

&=,|=,^=,~

进行二进制与、或、异或及非。

1) 设置位为 *this 与 other 的位的对应对上二进制与的结果。

2) 设置位为 *this 与 other 的位的对应对上二进制或的结果。

3) 设置位为 *this 与 other 的位的对应对上二进制异或的结果。

4) 返回翻转所有位的 *this 的临时副本（二进制非）。

注意 &= 、 |= 、和 ^= 仅对拥有相同大小 N 的 bitset 定义。

#include <iostream>
#include <string>
#include <bitset>
int main()
{
    std::bitset<16> dest;
    std::string pattern_str = "1001";
    std::bitset<16> pattern(pattern_str);
    for (size_t i = 0, ie = dest.size()/pattern_str.size(); i != ie; ++i) {
        dest <<= pattern_str.size();
        dest |= pattern;
    }
    std::cout << dest << '\n';
}

operator&,|,^

进行二个 bitset lhs 和 rhs 间的二进制与、或及异或。

1) 返回含 lhs 和 rhs 的位对应对上的二进制与结果的 bitset<N> 。

2) 返回含 lhs 和 rhs 的位对应对上的二进制或结果的 bitset<N> 。

3) 返回含 lhs 和 rhs 的位对应对上的二进制异或结果的 bitset<N> 。

#include <bitset>
#include <iostream>
int main()
{
    std::bitset<4> b1("0110");
    std::bitset<4> b2("0011");
    std::cout << "b1 & b2: " << (b1 & b2) << '\n';
    std::cout << "b1 | b2: " << (b1 | b2) << '\n';
    std::cout << "b1 ^ b2: " << (b1 ^ b2) << '\n';
}

" class="reference-link">

<<,<<=,>>,>>=

进行二进制左移和二进制右移。移入零。

#include <iostream>
#include <bitset>
int main()
{
    std::bitset<8> b("01110010");
    std::cout << "initial value: " << b << '\n';
    while (b.any()) {
        while (!b.test(0)) {
            b >>= 1;
        }
        std::cout << b << '\n';
        b >>= 1;
    }
}

<<,>>

从字符流插入或释出 bitset

#include <bitset>
#include <iostream>
#include <sstream>
int main()
{
    std::string bit_string = "001101";
    std::istringstream bit_stream(bit_string);
    std::bitset<3> b1;
    bit_stream >> b1; // 读取 "001" ，流仍保有 "101"
    std::cout << b1 << '\n';
    std::bitset<8> b2;
    bit_stream >> b2; // 读取 "101" ，产出 8 位集为 "00000101"
    std::cout << b2 << '\n';
}
//001
//00000101

set

设定bitset中某一个元素或者所有元素为1.

#include <iostream>
#include <bitset>
int main()
{
    std::bitset<8> b;
    for (size_t i = 1; i < b.size(); i += 2) {
        b.set(i);
    }
    std::cout << b << '\n';
}
// 10101010

reset()

将bitset中某一个元素或者所有元素重置为0

// bitset::reset
#include <iostream>       // std::cout
#include <string>         // std::string
#include <bitset>         // std::bitset
int main ()
{
  std::bitset<4> foo (std::string("1011"));
  std::cout << foo.reset(1) << '\n';    // 1001
  std::cout << foo.reset() << '\n';     // 0000
  return 0;
}
//Output:
//1001
//0000

flip()

反转一个bitset

// bitset::flip
#include <iostream>       // std::cout
#include <string>         // std::string
#include <bitset>         // std::bitset
int main ()
{
  std::bitset<4> foo (std::string("0001"));
  std::cout << foo.flip(2) << '\n';     // 0101
  std::cout << foo.flip() << '\n';      // 1010
  return 0;
}
//Output:
//0101
//1010

to_string

转换 bitset 的内容为 string

#include <iostream>
#include <bitset>
int main()
{
    std::bitset<8> b(42);
    std::cout << b.to_string() << '\n'
              << b.to_string('*') << '\n'
              << b.to_string('O', 'X') << '\n';
}

to_ulong、to_ullong

将bitset转换成一个unsigned_long类型的数

// bitset::to_ulong
#include <iostream>       // std::cout
#include <bitset>         // std::bitset
int main ()
{
  std::bitset<4> foo;     // foo: 0000
  foo.set();              // foo: 1111
  std::cout << foo << " as an integer is: " << foo.to_ulong() << '\n';
  return 0;
}
//Output:
//1111 as an integer is: 15
#include <iostream>
#include <bitset>
#include <limits>
int main()
{
    std::bitset<std::numeric_limits<unsigned long long>::digits> b(
        0x123456789abcdef0LL
    );
    std::cout << b << "  " << std::hex << b.to_ullong() << '\n';
    b.flip();
    std::cout << b << "  " << b.to_ullong() << '\n';
}

std::hash (std::bitset)

std::hash 对 std::bitset 的模板特化允许用户获得 std::bitset 类型的对象的哈希

#include <iostream>
#include <bitset>
#include <functional>
int main()
{
    std::bitset<4> b1(1);
    std::bitset<4> b2(2);
    std::bitset<4> b3(b2);
    std::hash<std::bitset<4>> hash_fn;
    size_t h1 = hash_fn(b1);
    size_t h2 = hash_fn(b2);
    size_t h3 = hash_fn(b3);
    std::cout << h1 << '\n';
    std::cout << h2 << '\n';
    std::cout << h3 << '\n';
}