[bitset] - C++14 → C++17

Files changed (1) hide show

tmp/tmpvq_fkmrl/{from.md → to.md} +527 -0

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

	@@ -0,0 +1,527 @@

+## Bitsets <a id="bitset">[[bitset]]</a>
+### Header `<bitset>` synopsis <a id="bitset.syn">[[bitset.syn]]</a>
+``` 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>&
+      operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
+}
+```
+The header `<bitset>` defines a class template and several related
+functions for representing and manipulating fixed-size sequences of
+bits.
+### 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() noexcept;
+      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 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>>;
+}
+```
+The class template `bitset<N>` describes an object that can store a
+sequence consisting of a fixed number of bits, `N`.
+Each bit represents either the value zero (reset) or one (set). To
+*toggle* a bit is to change the value zero to one, or the value one to
+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
+  `out_of_range` ([[out.of.range]]);
+- an *overflow* error is associated with exceptions of type
+  `overflow_error` ([[overflow.error]]).
+#### `bitset` constructors <a id="bitset.cons">[[bitset.cons]]</a>
+``` cpp
+constexpr bitset() noexcept;
+```
+*Effects:* Constructs an object of class `bitset<N>`, initializing all
+bits to zero.
+``` cpp
+constexpr bitset(unsigned long long val) noexcept;
+```
+*Effects:* Constructs an object of class `bitset<N>`, initializing 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'), charT one = charT('1'));
+```
+*Throws:* `out_of_range` if `pos > str.size()` or `invalid_argument` if
+an invalid character is found (see below).
+*Effects:* Determines the effective length `rlen` of the initializing
+string as the smaller of `n` and `str.size() - pos`.
+The function then throws
+`invalid_argument` if any of the `rlen` characters in `str` beginning at
+position `pos` is other than `zero` or `one`. The function uses
+`traits::eq()` to compare the character values.
+Otherwise, the function constructs an object of class `bitset<N>`,
+initializing the first `M` bit positions to values determined from the
+corresponding characters in the string `str`. `M` is the smaller of `N`
+and `rlen`.
+An element of the constructed object has value zero if the corresponding
+character in `str`, beginning at position `pos`, is `zero`. Otherwise,
+the element has the value one. Character position `pos + M - 1`
+corresponds to bit position zero. Subsequent decreasing character
+positions correspond to increasing bit positions.
+If `M < N`, remaining bit positions are initialized to zero.
+``` 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'));
+```
+*Effects:* Constructs an object of class `bitset<N>` as if by:
+``` cpp
+bitset(
+  n == basic_string<charT>::npos
+    ? basic_string<charT>(str)
+    : basic_string<charT>(str, n),
+  0, n, zero, one)
+```
+#### `bitset` 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:
+- If `I < pos`, the new value is zero;
+- If `I >= pos`, the new value is the previous value of the bit at
+  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:
+- If `pos >= N - I`, the new value is zero;
+- If `pos < N - I`, the new value is the previous value of the bit at
+  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);
+```
+*Throws:* `out_of_range` if `pos` does not correspond to a valid bit
+position.
+*Effects:* Stores a new value in the bit at position `pos` in `*this`.
+If `val` is nonzero, the stored value is one, otherwise it is zero.
+*Returns:* `*this`.
+``` cpp
+bitset<N>& reset() noexcept;
+```
+*Effects:* Resets all bits in `*this`.
+*Returns:* `*this`.
+``` cpp
+bitset<N>& reset(size_t pos);
+```
+*Throws:* `out_of_range` if `pos` does not correspond to a valid bit
+position.
+*Effects:* Resets the bit at position `pos` in `*this`.
+*Returns:* `*this`.
+``` 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);
+```
+*Throws:* `out_of_range` if `pos` does not correspond to a valid bit
+position.
+*Effects:* Toggles the bit at position `pos` in `*this`.
+*Returns:* `*this`.
+``` cpp
+unsigned long to_ulong() const;
+```
+*Throws:* `overflow_error`
+if the integral value `x` corresponding to the bits in `*this` cannot be
+represented as type `unsigned long`.
+*Returns:* `x`.
+``` cpp
+unsigned long long to_ullong() const;
+```
+*Throws:* `overflow_error` if the integral value `x` corresponding to
+the bits in `*this` cannot be represented as type `unsigned long long`.
+*Returns:* `x`.
+``` 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
+determined by the value of its corresponding bit position in `*this`.
+Character position `N - 1` corresponds to bit position zero. Subsequent
+decreasing character positions correspond to increasing bit positions.
+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
+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 operator!=(const bitset<N>& rhs) const noexcept;
+```
+*Returns:* `true` if `!(*this == rhs)`.
+``` cpp
+bool test(size_t pos) const;
+```
+*Throws:* `out_of_range` if `pos` does not correspond to a valid bit
+position.
+*Returns:* `true` if the bit at position `pos` in `*this` has the value
+one.
+``` 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;
+```
+*Requires:* `pos` shall be 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);
+```
+*Requires:* `pos` shall be 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>>;
+```
+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
+template <class charT, class traits, size_t N>
+  basic_istream<charT, traits>&
+  operator>>(basic_istream<charT, traits>& is, bitset<N>& x);
+```
+A formatted input function ([[istream.formatted]]).
+*Effects:* Extracts up to `N` characters from `is`. Stores these
+characters in a temporary object `str` of type
+`basic_string<charT, traits>`, then evaluates the expression
+`x = bitset<N>(str)`. Characters are extracted and stored until any of
+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 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>
+  basic_ostream<charT, traits>&
+  operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
+```
+*Returns:*
+``` cpp
+os << x.template to_string<charT, traits, allocator<charT>>(
+  use_facet<ctype<charT>>(os.getloc()).widen('0'),
+  use_facet<ctype<charT>>(os.getloc()).widen('1'))
+```
+(see  [[ostream.formatted]]).

Diff to HTML by rtfpessoa