[bitset] - C++20 → C++23

Files changed (1) hide show

tmp/tmpc78g9szv/{from.md → to.md} +120 -113

tmp/tmpc78g9szv/{from.md → to.md} RENAMED Viewed

@@ -5,23 +5,23 @@
 The header `<bitset>` defines a class template and several related
 functions for representing and manipulating fixed-size sequences of
 bits.
 ``` cpp
-#include <string>
 #include <iosfwd>   // for istream[istream.syn], ostream[ostream.syn], see [iosfwd.syn]
 namespace std {
   template<size_t N> class bitset;
   // [bitset.operators], bitset operators
   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>&
@@ -29,82 +29,85 @@ namespace std {
 }
 ```
 ### Class template `bitset` <a id="template.bitset">[[template.bitset]]</a>
 ``` cpp
 namespace std {
   template<size_t N> class bitset {
   public:
     // bit reference
     class reference {
       friend class bitset;
-      reference() noexcept;
     public:
-      reference(const reference&) = default;
-      ~reference();
-      reference& operator=(bool x) noexcept; // for b[i] = x;
-      reference& operator=(const reference&) noexcept; // for b[i] = b[j];
-      bool operator~() const noexcept; // flips the bit
-      operator bool() const noexcept; // for x = b[i];
-      reference& flip() noexcept; // for b[i].flip();
     };
     // [bitset.cons], constructors
     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.members], bitset operations
-    bitset<N>& operator&=(const bitset<N>& rhs) noexcept;
-    bitset<N>& operator|=(const bitset<N>& rhs) noexcept;
-    bitset<N>& operator^=(const bitset<N>& rhs) noexcept;
-    bitset<N>& operator<<=(size_t pos) noexcept;
-    bitset<N>& operator>>=(size_t pos) noexcept;
-    bitset<N>& set() noexcept;
-    bitset<N>& set(size_t pos, bool val = true);
-    bitset<N>& reset() noexcept;
-    bitset<N>& reset(size_t pos);
-    bitset<N>  operator~() const noexcept;
-    bitset<N>& flip() noexcept;
- bitset<N>& flip(size_t pos);
     // element access
-    constexpr bool operator[](size_t pos) const;        // for b[i];
-    reference operator[](size_t pos);                   // for 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<N>& rhs) const noexcept;
-    bool test(size_t pos) const;
-    bool all() const noexcept;
-    bool any() const noexcept;
-    bool none() const noexcept;
-    bitset<N> operator<<(size_t pos) const noexcept;
-    bitset<N> operator>>(size_t pos) const noexcept;
   };
   // [bitset.hash], hash support
   template<class T> struct hash;
   template<size_t N> struct hash<bitset<N>>;
@@ -120,11 +123,11 @@ zero. Each bit has a non-negative position `pos`. When converting
 between an object of class `bitset<N>` and a value of some integral
 type, bit position `pos` corresponds to the *bit value* `1 << pos`. The
 integral value corresponding to two or more bits is the sum of their bit
 values.
-The functions described in this subclause can report three kinds of
 errors, each associated with a distinct exception:
 - an *invalid-argument* error is associated with exceptions of type
   `invalid_argument` [[invalid.argument]];
 - an *out-of-range* error is associated with exceptions of type
@@ -144,16 +147,17 @@ constexpr bitset() noexcept;
 constexpr bitset(unsigned long long val) noexcept;
 ```
 *Effects:* Initializes the first `M` bit positions to the corresponding
 bit values in `val`. `M` is the smaller of `N` and the number of bits in
-the value representation [[basic.types]] of `unsigned long long`. If
-`M < N`, the remaining bit positions are initialized to zero.
 ``` cpp
 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'),
@@ -179,11 +183,11 @@ The function uses `traits::eq` to compare the character values.
 any of the `rlen` characters in `str` beginning at position `pos` is
 other than `zero` or `one`.
 ``` cpp
 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'));
 ```
@@ -198,38 +202,38 @@ bitset(n == basic_string<charT>::npos
 ```
 #### Members <a id="bitset.members">[[bitset.members]]</a>
 ``` cpp
-bitset<N>& operator&=(const bitset<N>& rhs) noexcept;
 ```
 *Effects:* Clears each bit in `*this` for which the corresponding bit in
 `rhs` is clear, and leaves all other bits unchanged.
 *Returns:* `*this`.
 ``` cpp
-bitset<N>& operator|=(const bitset<N>& rhs) noexcept;
 ```
 *Effects:* Sets each bit in `*this` for which the corresponding bit in
 `rhs` is set, and leaves all other bits unchanged.
 *Returns:* `*this`.
 ``` cpp
-bitset<N>& operator^=(const bitset<N>& rhs) noexcept;
 ```
 *Effects:* Toggles each bit in `*this` for which the corresponding bit
 in `rhs` is set, and leaves all other bits unchanged.
 *Returns:* `*this`.
 ``` cpp
-bitset<N>& operator<<=(size_t pos) noexcept;
 ```
 *Effects:* Replaces each bit at position `I` in `*this` with a value
 determined as follows:
@@ -238,11 +242,11 @@ determined as follows:
   position `I - pos`.
 *Returns:* `*this`.
 ``` cpp
-bitset<N>& operator>>=(size_t pos) noexcept;
 ```
 *Effects:* Replaces each bit at position `I` in `*this` with a value
 determined as follows:
@@ -251,19 +255,31 @@ determined as follows:
   position `I + pos`.
 *Returns:* `*this`.
 ``` cpp
-bitset<N>& set() noexcept;
 ```
 *Effects:* Sets all bits in `*this`.
 *Returns:* `*this`.
 ``` cpp
-bitset<N>& set(size_t pos, bool val = true);
 ```
 *Effects:* Stores a new value in the bit at position `pos` in `*this`.
 If `val` is `true`, the stored value is one, otherwise it is zero.
@@ -271,67 +287,95 @@ If `val` is `true`, the stored value is one, otherwise it is zero.
 *Throws:* `out_of_range` if `pos` does not correspond to a valid bit
 position.
 ``` cpp
-bitset<N>& reset() noexcept;
 ```
 *Effects:* Resets all bits in `*this`.
 *Returns:* `*this`.
 ``` cpp
-bitset<N>& reset(size_t pos);
 ```
 *Effects:* Resets the bit at position `pos` in `*this`.
 *Returns:* `*this`.
 *Throws:* `out_of_range` if `pos` does not correspond to a valid bit
 position.
 ``` cpp
-bitset<N> operator~() const noexcept;
 ```
-*Effects:* Constructs an object `x` of class `bitset<N>` and initializes
-it with `*this`.
 *Returns:* `x.flip()`.
 ``` cpp
-bitset<N>& flip() noexcept;
 ```
 *Effects:* Toggles all bits in `*this`.
 *Returns:* `*this`.
 ``` cpp
-bitset<N>& flip(size_t pos);
 ```
 *Effects:* Toggles the bit at position `pos` in `*this`.
 *Returns:* `*this`.
 *Throws:* `out_of_range` if `pos` does not correspond to a valid bit
 position.
 ``` cpp
-unsigned long to_ulong() const;
 ```
 *Returns:* `x`.
 *Throws:* `overflow_error` if the integral value `x` corresponding to
 the bits in `*this` cannot be represented as type `unsigned long`.
 ``` cpp
-unsigned long long to_ullong() const;
 ```
 *Returns:* `x`.
 *Throws:* `overflow_error` if the integral value `x` corresponding to
@@ -339,11 +383,11 @@ the bits in `*this` cannot be represented as type `unsigned long long`.
 ``` cpp
 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;
 ```
 *Effects:* Constructs a string object of the appropriate type and
 initializes it to a string of length `N` characters. Each character is
@@ -354,11 +398,11 @@ Bit value zero becomes the character `zero`, bit value one becomes the
 character `one`.
 *Returns:* The created object.
 ``` cpp
-size_t count() const noexcept;
 ```
 *Returns:* A count of the number of bits set in `*this`.
 ``` cpp
@@ -366,84 +410,44 @@ constexpr size_t size() const noexcept;
 ```
 *Returns:* `N`.
 ``` cpp
-bool operator==(const bitset<N>& rhs) const noexcept;
 ```
 *Returns:* `true` if the value of each bit in `*this` equals the value
 of the corresponding bit in `rhs`.
 ``` cpp
-bool test(size_t pos) const;
 ```
 *Returns:* `true` if the bit at position `pos` in `*this` has the value
 one.
 *Throws:* `out_of_range` if `pos` does not correspond to a valid bit
 position.
 ``` cpp
-bool all() const noexcept;
 ```
 *Returns:* `count() == size()`.
 ``` cpp
-bool any() const noexcept;
 ```
 *Returns:* `count() != 0`.
 ``` cpp
-bool none() const noexcept;
 ```
 *Returns:* `count() == 0`.
-``` cpp
-bitset<N> operator<<(size_t pos) const noexcept;
-```
-*Returns:* `bitset<N>(*this) <<= pos`.
-``` cpp
-bitset<N> operator>>(size_t pos) const noexcept;
-```
-*Returns:* `bitset<N>(*this) >>= pos`.
-``` cpp
-constexpr bool operator[](size_t pos) const;
-```
-*Preconditions:* `pos` is valid.
-*Returns:* `true` if the bit at position `pos` in `*this` has the value
-one, otherwise `false`.
-*Throws:* Nothing.
-``` cpp
-bitset<N>::reference operator[](size_t pos);
-```
-*Preconditions:* `pos` is valid.
-*Returns:* An object of type `bitset<N>::reference` such that
-`(*this)[pos] == this->test(pos)`, and such that `(*this)[pos] = val` is
-equivalent to `this->set(pos, val)`.
-*Throws:* Nothing.
-*Remarks:* For the purpose of determining the presence of a data
-race [[intro.multithread]], any access or update through the resulting
-reference potentially accesses or modifies, respectively, the entire
-underlying bitset.
 ### `bitset` hash support <a id="bitset.hash">[[bitset.hash]]</a>
 ``` cpp
 template<size_t N> struct hash<bitset<N>>;
 ```
@@ -451,23 +455,26 @@ template<size_t N> struct hash<bitset<N>>;
 The specialization is enabled [[unord.hash]].
 ### `bitset` operators <a id="bitset.operators">[[bitset.operators]]</a>
 ``` cpp
-bitset<N> operator&(const bitset<N>& lhs, const bitset<N>& rhs) noexcept;
 ```
 *Returns:* `bitset<N>(lhs) &= rhs`.
 ``` cpp
-bitset<N> operator|(const bitset<N>& lhs, const bitset<N>& rhs) noexcept;
 ```
 *Returns:* `bitset<N>(lhs) |= rhs`.
 ``` cpp
-bitset<N> operator^(const bitset<N>& lhs, const bitset<N>& rhs) noexcept;
 ```
 *Returns:* `bitset<N>(lhs) ^= rhs`.
 ``` cpp
@@ -487,13 +494,13 @@ the following occurs:
 - `N` characters have been extracted and stored;
 - end-of-file occurs on the input sequence;
 - the next input character is neither `is.widen(’0’)` nor
   `is.widen(’1’)` (in which case the input character is not extracted).
-If `N > 0` and no characters are stored in `str`, calls
-`is.setstate(ios_base::failbit)` (which may throw `ios_base::failure`
-[[iostate.flags]]).
 *Returns:* `is`.
 ``` cpp
 template<class charT, class traits, size_t N>

 The header `<bitset>` defines a class template and several related
 functions for representing and manipulating fixed-size sequences of
 bits.
 ``` cpp
+#include <string>   // see [string.syn]
 #include <iosfwd>   // for istream[istream.syn], ostream[ostream.syn], see [iosfwd.syn]
 namespace std {
   template<size_t N> class bitset;
   // [bitset.operators], bitset operators
   template<size_t N>
+ constexpr bitset<N> operator&(const bitset<N>&, const bitset<N>&) noexcept;
   template<size_t N>
+ constexpr bitset<N> operator|(const bitset<N>&, const bitset<N>&) noexcept;
   template<size_t N>
+ constexpr 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>&
 }
 ```
 ### Class template `bitset` <a id="template.bitset">[[template.bitset]]</a>
+#### General <a id="template.bitset.general">[[template.bitset.general]]</a>
 ``` cpp
 namespace std {
   template<size_t N> class bitset {
   public:
     // bit reference
     class reference {
       friend class bitset;
+ constexpr reference() noexcept;
     public:
+ constexpr reference(const reference&) = default;
+ constexpr ~reference();
+ constexpr reference& operator=(bool x) noexcept; // for b[i] = x;
+ constexpr reference& operator=(const reference&) noexcept; // for b[i] = b[j];
+ constexpr bool operator~() const noexcept; // flips the bit
+ constexpr operator bool() const noexcept; // for x = b[i];
+ constexpr reference& flip() noexcept; // for b[i].flip();
     };
     // [bitset.cons], constructors
     constexpr bitset() noexcept;
     constexpr bitset(unsigned long long val) noexcept;
     template<class charT, class traits, class Allocator>
+ constexpr 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>
+ constexpr 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.members], bitset operations
+ constexpr bitset& operator&=(const bitset& rhs) noexcept;
+ constexpr bitset& operator|=(const bitset& rhs) noexcept;
+ constexpr bitset& operator^=(const bitset& rhs) noexcept;
+ constexpr bitset& operator<<=(size_t pos) noexcept;
+ constexpr bitset& operator>>=(size_t pos) noexcept;
+ constexpr bitset  operator<<(size_t pos) const noexcept;
+ constexpr bitset  operator>>(size_t pos) const noexcept;
+ constexpr bitset& set() noexcept;
+ constexpr bitset& set(size_t pos, bool val = true);
+ constexpr bitset& reset() noexcept;
+ constexpr bitset& reset(size_t pos);
+ constexpr bitset  operator~() const noexcept;
+    constexpr bitset& flip() noexcept;
+    constexpr bitset& flip(size_t pos);
     // element access
+    constexpr bool operator[](size_t pos) const;
+ constexpr reference operator[](size_t pos);
+ constexpr unsigned long to_ulong() const;
+ constexpr unsigned long long to_ullong() const;
     template<class charT = char,
              class traits = char_traits<charT>,
              class Allocator = allocator<charT>>
+ constexpr basic_string<charT, traits, Allocator>
         to_string(charT zero = charT('0'), charT one = charT('1')) const;
+ // observers
+    constexpr size_t count() const noexcept;
     constexpr size_t size() const noexcept;
+ constexpr bool operator==(const bitset& rhs) const noexcept;
+ constexpr bool test(size_t pos) const;
+ constexpr bool all() const noexcept;
+ constexpr bool any() const noexcept;
+ constexpr bool none() const noexcept;
   };
   // [bitset.hash], hash support
   template<class T> struct hash;
   template<size_t N> struct hash<bitset<N>>;
 between an object of class `bitset<N>` and a value of some integral
 type, bit position `pos` corresponds to the *bit value* `1 << pos`. The
 integral value corresponding to two or more bits is the sum of their bit
 values.
+The functions described in [[template.bitset]] can report three kinds of
 errors, each associated with a distinct exception:
 - an *invalid-argument* error is associated with exceptions of type
   `invalid_argument` [[invalid.argument]];
 - an *out-of-range* error is associated with exceptions of type
 constexpr bitset(unsigned long long val) noexcept;
 ```
 *Effects:* Initializes the first `M` bit positions to the corresponding
 bit values in `val`. `M` is the smaller of `N` and the number of bits in
+the value representation [[term.object.representation]] of
+`unsigned long long`. If `M < N`, the remaining bit positions are
+initialized to zero.
 ``` cpp
 template<class charT, class traits, class Allocator>
+ constexpr 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'),
 any of the `rlen` characters in `str` beginning at position `pos` is
 other than `zero` or `one`.
 ``` cpp
 template<class charT>
+ constexpr explicit bitset(
     const charT* str,
     typename basic_string<charT>::size_type n = basic_string<charT>::npos,
     charT zero = charT('0'),
     charT one = charT('1'));
 ```
 ```
 #### Members <a id="bitset.members">[[bitset.members]]</a>
 ``` cpp
+constexpr bitset& operator&=(const bitset& rhs) noexcept;
 ```
 *Effects:* Clears each bit in `*this` for which the corresponding bit in
 `rhs` is clear, and leaves all other bits unchanged.
 *Returns:* `*this`.
 ``` cpp
+constexpr bitset& operator|=(const bitset& rhs) noexcept;
 ```
 *Effects:* Sets each bit in `*this` for which the corresponding bit in
 `rhs` is set, and leaves all other bits unchanged.
 *Returns:* `*this`.
 ``` cpp
+constexpr bitset& operator^=(const bitset& rhs) noexcept;
 ```
 *Effects:* Toggles each bit in `*this` for which the corresponding bit
 in `rhs` is set, and leaves all other bits unchanged.
 *Returns:* `*this`.
 ``` cpp
+constexpr bitset& operator<<=(size_t pos) noexcept;
 ```
 *Effects:* Replaces each bit at position `I` in `*this` with a value
 determined as follows:
   position `I - pos`.
 *Returns:* `*this`.
 ``` cpp
+constexpr bitset& operator>>=(size_t pos) noexcept;
 ```
 *Effects:* Replaces each bit at position `I` in `*this` with a value
 determined as follows:
   position `I + pos`.
 *Returns:* `*this`.
 ``` cpp
+constexpr bitset operator<<(size_t pos) const noexcept;
+```
+*Returns:* `bitset(*this) <<= pos`.
+``` cpp
+constexpr bitset operator>>(size_t pos) const noexcept;
+```
+*Returns:* `bitset(*this) >>= pos`.
+``` cpp
+constexpr bitset& set() noexcept;
 ```
 *Effects:* Sets all bits in `*this`.
 *Returns:* `*this`.
 ``` cpp
+constexpr bitset& set(size_t pos, bool val = true);
 ```
 *Effects:* Stores a new value in the bit at position `pos` in `*this`.
 If `val` is `true`, the stored value is one, otherwise it is zero.
 *Throws:* `out_of_range` if `pos` does not correspond to a valid bit
 position.
 ``` cpp
+constexpr bitset& reset() noexcept;
 ```
 *Effects:* Resets all bits in `*this`.
 *Returns:* `*this`.
 ``` cpp
+constexpr bitset& reset(size_t pos);
 ```
 *Effects:* Resets the bit at position `pos` in `*this`.
 *Returns:* `*this`.
 *Throws:* `out_of_range` if `pos` does not correspond to a valid bit
 position.
 ``` cpp
+constexpr bitset operator~() const noexcept;
 ```
+*Effects:* Constructs an object `x` of class `bitset` and initializes it
+with `*this`.
 *Returns:* `x.flip()`.
 ``` cpp
+constexpr bitset& flip() noexcept;
 ```
 *Effects:* Toggles all bits in `*this`.
 *Returns:* `*this`.
 ``` cpp
+constexpr bitset& flip(size_t pos);
 ```
 *Effects:* Toggles the bit at position `pos` in `*this`.
 *Returns:* `*this`.
 *Throws:* `out_of_range` if `pos` does not correspond to a valid bit
 position.
 ``` cpp
+constexpr bool operator[](size_t pos) const;
+```
+*Preconditions:* `pos` is valid.
+*Returns:* `true` if the bit at position `pos` in `*this` has the value
+one, otherwise `false`.
+*Throws:* Nothing.
+``` cpp
+constexpr bitset::reference operator[](size_t pos);
+```
+*Preconditions:* `pos` is valid.
+*Returns:* An object of type `bitset::reference` such that
+`(*this)[pos] == this->test(pos)`, and such that `(*this)[pos] = val` is
+equivalent to `this->set(pos, val)`.
+*Throws:* Nothing.
+*Remarks:* For the purpose of determining the presence of a data
+race [[intro.multithread]], any access or update through the resulting
+reference potentially accesses or modifies, respectively, the entire
+underlying bitset.
+``` cpp
+constexpr unsigned long to_ulong() const;
 ```
 *Returns:* `x`.
 *Throws:* `overflow_error` if the integral value `x` corresponding to
 the bits in `*this` cannot be represented as type `unsigned long`.
 ``` cpp
+constexpr unsigned long long to_ullong() const;
 ```
 *Returns:* `x`.
 *Throws:* `overflow_error` if the integral value `x` corresponding to
 ``` cpp
 template<class charT = char,
          class traits = char_traits<charT>,
          class Allocator = allocator<charT>>
+ constexpr basic_string<charT, traits, Allocator>
     to_string(charT zero = charT('0'), charT one = charT('1')) const;
 ```
 *Effects:* Constructs a string object of the appropriate type and
 initializes it to a string of length `N` characters. Each character is
 character `one`.
 *Returns:* The created object.
 ``` cpp
+constexpr size_t count() const noexcept;
 ```
 *Returns:* A count of the number of bits set in `*this`.
 ``` cpp
 ```
 *Returns:* `N`.
 ``` cpp
+constexpr bool operator==(const bitset& rhs) const noexcept;
 ```
 *Returns:* `true` if the value of each bit in `*this` equals the value
 of the corresponding bit in `rhs`.
 ``` cpp
+constexpr bool test(size_t pos) const;
 ```
 *Returns:* `true` if the bit at position `pos` in `*this` has the value
 one.
 *Throws:* `out_of_range` if `pos` does not correspond to a valid bit
 position.
 ``` cpp
+constexpr bool all() const noexcept;
 ```
 *Returns:* `count() == size()`.
 ``` cpp
+constexpr bool any() const noexcept;
 ```
 *Returns:* `count() != 0`.
 ``` cpp
+constexpr bool none() const noexcept;
 ```
 *Returns:* `count() == 0`.
 ### `bitset` hash support <a id="bitset.hash">[[bitset.hash]]</a>
 ``` cpp
 template<size_t N> struct hash<bitset<N>>;
 ```
 The specialization is enabled [[unord.hash]].
 ### `bitset` operators <a id="bitset.operators">[[bitset.operators]]</a>
 ``` cpp
+template<size_t N>
+  constexpr bitset<N> operator&(const bitset<N>& lhs, const bitset<N>& rhs) noexcept;
 ```
 *Returns:* `bitset<N>(lhs) &= rhs`.
 ``` cpp
+template<size_t N>
+  constexpr bitset<N> operator|(const bitset<N>& lhs, const bitset<N>& rhs) noexcept;
 ```
 *Returns:* `bitset<N>(lhs) |= rhs`.
 ``` cpp
+template<size_t N>
+  constexpr bitset<N> operator^(const bitset<N>& lhs, const bitset<N>& rhs) noexcept;
 ```
 *Returns:* `bitset<N>(lhs) ^= rhs`.
 ``` cpp
 - `N` characters have been extracted and stored;
 - end-of-file occurs on the input sequence;
 - the next input character is neither `is.widen(’0’)` nor
   `is.widen(’1’)` (in which case the input character is not extracted).
+If `N > 0` and no characters are stored in `str`, `ios_base::failbit` is
+set in the input function’s local error state before `setstate` is
+called.
 *Returns:* `is`.
 ``` cpp
 template<class charT, class traits, size_t N>

Diff to HTML by rtfpessoa