C/C++编程：标准库bitset

刺骨的言语ヽ痛彻心扉 2022-05-19 10:44 345阅读 0赞

作用：提供了一种抽象方法来操作位的集合

若在编译时 bitset 的大小未知，则可使用 [std::vector<bool>][std_vector_bool] 或 [boost::dynamic\_bitset][boost_dynamic_bitset]

# 构造函数 #

#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';
    }

![20210302211535192.png][]

# 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\[\]][operator] ，它进行边界检查，且若 `pos` 不对应 bitset 中的合法位置则抛出 [std::out\_of\_range][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";
        }
    }

![20210302212309322.png][]

// 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';
    }

![20210302212541783.png][]

# 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';
    }

![20210302213542954.png][]

# 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';
    }

# ![20210302220142228.png][] #

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

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

#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;
        }
    }

![20210302213951960.png][]

# <<,>> #

> 从字符流插入或释出 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';
    }

![20210302220021568.png][]

# std::hash (std::bitset) #

[std::hash][std_hash] 对 [std::bitset][std_bitset]<N> 的模板特化允许用户获得 [std::bitset][std_bitset]<N> 类型的对象的哈希

#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';
    }

![20210302220429620.png][]

[std_vector_bool]: https://zh.cppreference.com/w/cpp/container/vector_bool
[boost_dynamic_bitset]: http://www.boost.org/doc/libs/release/libs/dynamic_bitset/dynamic_bitset.html
[20210302211535192.png]: /images/20220519/8a937ef67c344d20b15edc333de50176.png
[operator]: https://zh.cppreference.com/w/cpp/utility/bitset/operator_at
[std_out_of_range]: https://zh.cppreference.com/w/cpp/error/out_of_range
[20210302212309322.png]: /images/20220519/61ab36848d65460ca6937c55f8488cbd.png
[20210302212541783.png]: /images/20220519/d1b1b8ade09241899f875432a7bcae10.png
[20210302213542954.png]: /images/20220519/f52b6cf20b3342938d2d6a476f645d7d.png
[20210302220142228.png]: /images/20220519/2ec3c5ad84fc4ed696660e759f3c6839.png
[20210302213951960.png]: /images/20220519/3a0003252f2446d5844aaf7ac75f21b0.png
[20210302220021568.png]: /images/20220519/e84d84655d3b4518aa3a0d1c4c9a5ad3.png
[std_hash]: https://zh.cppreference.com/w/cpp/utility/hash
[std_bitset]: http://zh.cppreference.com/w/cpp/utility/bitset
[20210302220429620.png]: /images/20220519/785a9e77b0864a35b872517a25828330.png