[string.view] - C++14 → C++17

Files changed (1) hide show

tmp/tmp60qb7rhi/{from.md → to.md} +760 -0

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

	@@ -0,0 +1,760 @@

+## String view classes <a id="string.view">[[string.view]]</a>
+The class template `basic_string_view` describes an object that can
+refer to a constant contiguous sequence of char-like (
+[[strings.general]]) objects with the first element of the sequence at
+position zero. In the rest of this section, the type of the char-like
+objects held in a `basic_string_view` object is designated by `charT`.
+[*Note 1*: The library provides implicit conversions from
+`const charT*` and `std::basic_string<charT, ...>` to
+`std::basic_string_view<charT, ...>` so that user code can accept just
+`std::basic_string_view<charT>` as a non-templated parameter wherever a
+sequence of characters is expected. User-defined types should define
+their own implicit conversions to `std::basic_string_view` in order to
+interoperate with these functions. — *end note*]
+The complexity of `basic_string_view` member functions is 𝑂(1) unless
+otherwise specified.
+### Header `<string_view>` synopsis <a id="string.view.synop">[[string.view.synop]]</a>
+``` cpp
+namespace std {
+  // [string.view.template], class template basic_string_view
+  template<class charT, class traits = char_traits<charT>>
+  class basic_string_view;
+  // [string.view.comparison], non-member comparison functions
+  template<class charT, class traits>
+    constexpr bool operator==(basic_string_view<charT, traits> x,
+                              basic_string_view<charT, traits> y) noexcept;
+  template<class charT, class traits>
+    constexpr bool operator!=(basic_string_view<charT, traits> x,
+                              basic_string_view<charT, traits> y) noexcept;
+  template<class charT, class traits>
+    constexpr bool operator< (basic_string_view<charT, traits> x,
+                              basic_string_view<charT, traits> y) noexcept;
+  template<class charT, class traits>
+    constexpr bool operator> (basic_string_view<charT, traits> x,
+                              basic_string_view<charT, traits> y) noexcept;
+  template<class charT, class traits>
+    constexpr bool operator<=(basic_string_view<charT, traits> x,
+                              basic_string_view<charT, traits> y) noexcept;
+  template<class charT, class traits>
+    constexpr bool operator>=(basic_string_view<charT, traits> x,
+                              basic_string_view<charT, traits> y) noexcept;
+  // see [string.view.comparison], sufficient additional overloads of comparison functions
+  // [string.view.io], inserters and extractors
+  template<class charT, class traits>
+    basic_ostream<charT, traits>&
+      operator<<(basic_ostream<charT, traits>& os,
+                 basic_string_view<charT, traits> str);
+  // basic_string_view typedef names
+  using string_view    = basic_string_view<char>;
+  using u16string_view = basic_string_view<char16_t>;
+  using u32string_view = basic_string_view<char32_t>;
+  using wstring_view   = basic_string_view<wchar_t>;
+  // [string.view.hash], hash support
+  template<class T> struct hash;
+  template<> struct hash<string_view>;
+  template<> struct hash<u16string_view>;
+  template<> struct hash<u32string_view>;
+  template<> struct hash<wstring_view>;
+  inline namespace literals {
+  inline namespace string_view_literals {
+    // [string.view.literals], suffix for basic_string_view literals
+    constexpr string_view    operator""sv(const char* str, size_t len) noexcept;
+    constexpr u16string_view operator""sv(const char16_t* str, size_t len) noexcept;
+    constexpr u32string_view operator""sv(const char32_t* str, size_t len) noexcept;
+    constexpr wstring_view   operator""sv(const wchar_t* str, size_t len) noexcept;
+  }
+  }
+}
+```
+The function templates defined in [[utility.swap]] and
+[[iterator.range]] are available when `<string_view>` is included.
+### Class template `basic_string_view` <a id="string.view.template">[[string.view.template]]</a>
+``` cpp
+template<class charT, class traits = char_traits<charT>>
+class basic_string_view {
+public:
+  // types
+  using traits_type            = traits;
+  using value_type             = charT;
+  using pointer                = value_type*;
+  using const_pointer          = const value_type*;
+  using reference              = value_type&;
+  using const_reference        = const value_type&;
+  using const_iterator         = implementation-defined  // type of basic_string_view::const_iterator; // see [string.view.iterators]
+  using iterator               = const_iterator;\footnote{Because basic_string_view refers to a constant sequence, iterator and const_iterator are the same type.}
+  using const_reverse_iterator = reverse_iterator<const_iterator>;
+  using reverse_iterator       = const_reverse_iterator;
+  using size_type              = size_t;
+  using difference_type        = ptrdiff_t;
+  static constexpr size_type npos = size_type(-1);
+  // [string.view.cons], construction and assignment
+  constexpr basic_string_view() noexcept;
+  constexpr basic_string_view(const basic_string_view&) noexcept = default;
+  constexpr basic_string_view& operator=(const basic_string_view&) noexcept = default;
+  constexpr basic_string_view(const charT* str);
+  constexpr basic_string_view(const charT* str, size_type len);
+  // [string.view.iterators], iterator support
+  constexpr const_iterator begin() const noexcept;
+  constexpr const_iterator end() const noexcept;
+  constexpr const_iterator cbegin() const noexcept;
+  constexpr const_iterator cend() const noexcept;
+  constexpr const_reverse_iterator rbegin() const noexcept;
+  constexpr const_reverse_iterator rend() const noexcept;
+  constexpr const_reverse_iterator crbegin() const noexcept;
+  constexpr const_reverse_iterator crend() const noexcept;
+  // [string.view.capacity], capacity
+  constexpr size_type size() const noexcept;
+  constexpr size_type length() const noexcept;
+  constexpr size_type max_size() const noexcept;
+  constexpr bool empty() const noexcept;
+  // [string.view.access], element access
+  constexpr const_reference operator[](size_type pos) const;
+  constexpr const_reference at(size_type pos) const;
+  constexpr const_reference front() const;
+  constexpr const_reference back() const;
+  constexpr const_pointer data() const noexcept;
+  // [string.view.modifiers], modifiers
+  constexpr void remove_prefix(size_type n);
+  constexpr void remove_suffix(size_type n);
+  constexpr void swap(basic_string_view& s) noexcept;
+  // [string.view.ops], string operations
+  size_type copy(charT* s, size_type n, size_type pos = 0) const;
+  constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
+  constexpr int compare(basic_string_view s) const noexcept;
+  constexpr int compare(size_type pos1, size_type n1, basic_string_view s) const;
+  constexpr int compare(size_type pos1, size_type n1, basic_string_view s,
+                        size_type pos2, size_type n2) const;
+  constexpr int compare(const charT* s) const;
+  constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
+  constexpr int compare(size_type pos1, size_type n1, const charT* s,
+                        size_type n2) const;
+  constexpr size_type find(basic_string_view s, size_type pos = 0) const noexcept;
+  constexpr size_type find(charT c, size_type pos = 0) const noexcept;
+  constexpr size_type find(const charT* s, size_type pos, size_type n) const;
+  constexpr size_type find(const charT* s, size_type pos = 0) const;
+  constexpr size_type rfind(basic_string_view s, size_type pos = npos) const noexcept;
+  constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
+  constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
+  constexpr size_type rfind(const charT* s, size_type pos = npos) const;
+  constexpr size_type find_first_of(basic_string_view s, size_type pos = 0) const noexcept;
+  constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
+  constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
+  constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
+  constexpr size_type find_last_of(basic_string_view s, size_type pos = npos) const noexcept;
+  constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
+  constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
+  constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
+  constexpr size_type find_first_not_of(basic_string_view s, size_type pos = 0) const noexcept;
+  constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
+  constexpr size_type find_first_not_of(const charT* s, size_type pos,
+                                        size_type n) const;
+  constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
+  constexpr size_type find_last_not_of(basic_string_view s,
+                                       size_type pos = npos) const noexcept;
+  constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
+  constexpr size_type find_last_not_of(const charT* s, size_type pos,
+                                       size_type n) const;
+  constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
+private:
+  const_pointer data_; // exposition only
+  size_type size_;     // exposition only
+};
+```
+In every specialization `basic_string_view<charT, traits>`, the type
+`traits` shall satisfy the character traits requirements (
+[[char.traits]]), and the type `traits::char_type` shall name the same
+type as `charT`.
+#### Construction and assignment <a id="string.view.cons">[[string.view.cons]]</a>
+``` cpp
+constexpr basic_string_view() noexcept;
+```
+*Effects:* Constructs an empty `basic_string_view`.
+*Postconditions:* `size_ == 0` and `data_ == nullptr`.
+``` cpp
+constexpr basic_string_view(const charT* str);
+```
+*Requires:* \[`str`, `str + traits::length(str)`) is a valid range.
+*Effects:* Constructs a `basic_string_view`, with the postconditions in
+Table  [[tab:string.view.ctr.2]].
+*Complexity:* 𝑂(`traits::length(str)`).
+``` cpp
+constexpr basic_string_view(const charT* str, size_type len);
+```
+*Requires:* \[`str`, `str + len`) is a valid range.
+*Effects:* Constructs a `basic_string_view`, with the postconditions in
+Table  [[tab:string.view.ctr.3]].
+#### Iterator support <a id="string.view.iterators">[[string.view.iterators]]</a>
+``` cpp
+using const_iterator = implementation-defined  // type of basic_string_view::const_iterator;
+```
+A type that meets the requirements of a constant random access
+iterator ([[random.access.iterators]]) and of a contiguous
+iterator ([[iterator.requirements.general]]) whose `value_type` is the
+template parameter `charT`.
+For a `basic_string_view str`, any operation that invalidates a pointer
+in the range \[`str.data()`, `str.data() + str.size()`) invalidates
+pointers, iterators, and references returned from `str`’s methods.
+All requirements on container iterators ([[container.requirements]])
+apply to `basic_string_view::const_iterator` as well.
+``` cpp
+constexpr const_iterator begin() const noexcept;
+constexpr const_iterator cbegin() const noexcept;
+```
+*Returns:* An iterator such that
+- if `!empty()`, `&*begin() == data_`,
+- otherwise, an unspecified value such that \[`begin()`, `end()`) is a
+  valid range.
+``` cpp
+constexpr const_iterator end() const noexcept;
+constexpr const_iterator cend() const noexcept;
+```
+*Returns:* `begin() + size()`.
+``` cpp
+constexpr const_reverse_iterator rbegin() const noexcept;
+constexpr const_reverse_iterator crbegin() const noexcept;
+```
+*Returns:* `const_reverse_iterator(end())`.
+``` cpp
+constexpr const_reverse_iterator rend() const noexcept;
+constexpr const_reverse_iterator crend() const noexcept;
+```
+*Returns:* `const_reverse_iterator(begin())`.
+#### Capacity <a id="string.view.capacity">[[string.view.capacity]]</a>
+``` cpp
+constexpr size_type size() const noexcept;
+```
+*Returns:* `size_`.
+``` cpp
+constexpr size_type length() const noexcept;
+```
+*Returns:* `size_`.
+``` cpp
+constexpr size_type max_size() const noexcept;
+```
+*Returns:* The largest possible number of char-like objects that can be
+referred to by a `basic_string_view`.
+``` cpp
+constexpr bool empty() const noexcept;
+```
+*Returns:* `size_ == 0`.
+#### Element access <a id="string.view.access">[[string.view.access]]</a>
+``` cpp
+constexpr const_reference operator[](size_type pos) const;
+```
+*Requires:* `pos < size()`.
+*Returns:* `data_[pos]`.
+*Throws:* Nothing.
+[*Note 1*: Unlike `basic_string::operator[]`,
+`basic_string_view::operator[](size())` has undefined behavior instead
+of returning `charT()`. — *end note*]
+``` cpp
+constexpr const_reference at(size_type pos) const;
+```
+*Throws:* `out_of_range` if `pos >= size()`.
+*Returns:* `data_[pos]`.
+``` cpp
+constexpr const_reference front() const;
+```
+*Requires:* `!empty()`.
+*Returns:* `data_[0]`.
+*Throws:* Nothing.
+``` cpp
+constexpr const_reference back() const;
+```
+*Requires:* `!empty()`.
+*Returns:* `data_[size() - 1]`.
+*Throws:* Nothing.
+``` cpp
+constexpr const_pointer data() const noexcept;
+```
+*Returns:* `data_`.
+[*Note 2*: Unlike `basic_string::data()` and string literals, `data()`
+may return a pointer to a buffer that is not null-terminated. Therefore
+it is typically a mistake to pass `data()` to a function that takes just
+a `const charT*` and expects a null-terminated string. — *end note*]
+#### Modifiers <a id="string.view.modifiers">[[string.view.modifiers]]</a>
+``` cpp
+constexpr void remove_prefix(size_type n);
+```
+*Requires:* `n <= size()`.
+*Effects:* Equivalent to: `data_ += n; size_ -= n;`
+``` cpp
+constexpr void remove_suffix(size_type n);
+```
+*Requires:* `n <= size()`.
+*Effects:* Equivalent to: `size_ -= n;`
+``` cpp
+constexpr void swap(basic_string_view& s) noexcept;
+```
+*Effects:* Exchanges the values of `*this` and `s`.
+#### String operations <a id="string.view.ops">[[string.view.ops]]</a>
+``` cpp
+size_type copy(charT* s, size_type n, size_type pos = 0) const;
+```
+Let `rlen` be the smaller of `n` and `size() - pos`.
+*Throws:* `out_of_range` if `pos > size()`.
+*Requires:* \[`s`, `s + rlen`) is a valid range.
+*Effects:* Equivalent to `traits::copy(s, data() + pos, rlen)`.
+*Returns:* `rlen`.
+*Complexity:* 𝑂(`rlen`).
+``` cpp
+constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
+```
+Let `rlen` be the smaller of `n` and `size() - pos`.
+*Throws:* `out_of_range` if `pos > size()`.
+*Effects:* Determines `rlen`, the effective length of the string to
+reference.
+*Returns:* `basic_string_view(data() + pos, rlen)`.
+``` cpp
+constexpr int compare(basic_string_view str) const noexcept;
+```
+Let `rlen` be the smaller of `size()` and `str.size()`.
+*Effects:* Determines `rlen`, the effective length of the strings to
+compare. The function then compares the two strings by calling
+`traits::compare(data(), str.data(), rlen)`.
+*Complexity:* 𝑂(`rlen`).
+*Returns:* The nonzero result if the result of the comparison is
+nonzero. Otherwise, returns a value as indicated in
+Table  [[tab:string.view.compare]].
+**Table: `compare()` results** <a id="tab:string.view.compare">[tab:string.view.compare]</a>
+| Condition              | Return Value |
+| ---------------------- | ------------ |
+| `size() < str.size()`  | `< 0`        |
+| `size() == str.size()` | `  0`        |
+| `size() > str.size()`  | `> 0`        |
+``` cpp
+constexpr int compare(size_type pos1, size_type n1, basic_string_view str) const;
+```
+*Effects:* Equivalent to: `return substr(pos1, n1).compare(str);`
+``` cpp
+constexpr int compare(size_type pos1, size_type n1, basic_string_view str,
+                      size_type pos2, size_type n2) const;
+```
+*Effects:* Equivalent to:
+`return substr(pos1, n1).compare(str.substr(pos2, n2));`
+``` cpp
+constexpr int compare(const charT* s) const;
+```
+*Effects:* Equivalent to: `return compare(basic_string_view(s));`
+``` cpp
+constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
+```
+*Effects:* Equivalent to:
+`return substr(pos1, n1).compare(basic_string_view(s));`
+``` cpp
+constexpr int compare(size_type pos1, size_type n1,
+                      const charT* s, size_type n2) const;
+```
+*Effects:* Equivalent to:
+`return substr(pos1, n1).compare(basic_string_view(s, n2));`
+#### Searching <a id="string.view.find">[[string.view.find]]</a>
+This section specifies the `basic_string_view` member functions named
+`find`, `rfind`, `find_first_of`, `find_last_of`, `find_first_not_of`,
+and `find_last_not_of`.
+Member functions in this section have complexity
+𝑂(`size() * str.size()`) at worst, although implementations are
+encouraged to do better.
+Each member function of the form
+``` cpp
+constexpr return-type F(const charT* s, size_type pos);
+```
+is equivalent to `return F(basic_string_view(s), pos);`
+Each member function of the form
+``` cpp
+constexpr return-type F(const charT* s, size_type pos, size_type n);
+```
+is equivalent to `return F(basic_string_view(s, n), pos);`
+Each member function of the form
+``` cpp
+constexpr return-type F(charT c, size_type pos);
+```
+is equivalent to `return F(basic_string_view(&c, 1), pos);`
+``` cpp
+constexpr size_type find(basic_string_view str, size_type pos = 0) const noexcept;
+```
+Let `xpos` be the lowest position, if possible, such that the following
+conditions hold:
+- `pos <= xpos`
+- `xpos + str.size() <= size()`
+- `traits::eq(at(xpos + I), str.at(I))` for all elements `I` of the
+  string referenced by `str`.
+*Effects:* Determines `xpos`.
+*Returns:* `xpos` if the function can determine such a value for `xpos`.
+Otherwise, returns `npos`.
+``` cpp
+constexpr size_type rfind(basic_string_view str, size_type pos = npos) const noexcept;
+```
+Let `xpos` be the highest position, if possible, such that the following
+conditions hold:
+- `xpos <= pos`
+- `xpos + str.size() <= size()`
+- `traits::eq(at(xpos + I), str.at(I))` for all elements `I` of the
+  string referenced by `str`.
+*Effects:* Determines `xpos`.
+*Returns:* `xpos` if the function can determine such a value for `xpos`.
+Otherwise, returns `npos`.
+``` cpp
+constexpr size_type find_first_of(basic_string_view str, size_type pos = 0) const noexcept;
+```
+Let `xpos` be the lowest position, if possible, such that the following
+conditions hold:
+- `pos <= xpos`
+- `xpos < size()`
+- `traits::eq(at(xpos), str.at(I))` for some element `I` of the string
+  referenced by `str`.
+*Effects:* Determines `xpos`.
+*Returns:* `xpos` if the function can determine such a value for `xpos`.
+Otherwise, returns `npos`.
+``` cpp
+constexpr size_type find_last_of(basic_string_view str, size_type pos = npos) const noexcept;
+```
+Let `xpos` be the highest position, if possible, such that the following
+conditions hold:
+- `xpos <= pos`
+- `xpos < size()`
+- `traits::eq(at(xpos), str.at(I))` for some element `I` of the string
+  referenced by `str`.
+*Effects:* Determines `xpos`.
+*Returns:* `xpos` if the function can determine such a value for `xpos`.
+Otherwise, returns `npos`.
+``` cpp
+constexpr size_type find_first_not_of(basic_string_view str, size_type pos = 0) const noexcept;
+```
+Let `xpos` be the lowest position, if possible, such that the following
+conditions hold:
+- `pos <= xpos`
+- `xpos < size()`
+- `traits::eq(at(xpos), str.at(I))` for no element `I` of the string
+  referenced by `str`.
+*Effects:* Determines `xpos`.
+*Returns:* `xpos` if the function can determine such a value for `xpos`.
+Otherwise, returns `npos`.
+``` cpp
+constexpr size_type find_last_not_of(basic_string_view str, size_type pos = npos) const noexcept;
+```
+Let `xpos` be the highest position, if possible, such that the following
+conditions hold:
+- `xpos <= pos`
+- `xpos < size()`
+- `traits::eq(at(xpos), str.at(I))` for no element `I` of the string
+  referenced by `str`.
+*Effects:* Determines `xpos`.
+*Returns:* `xpos` if the function can determine such a value for `xpos`.
+Otherwise, returns `npos`.
+### Non-member comparison functions <a id="string.view.comparison">[[string.view.comparison]]</a>
+Let `S` be `basic_string_view<charT, traits>`, and `sv` be an instance
+of `S`. Implementations shall provide sufficient additional overloads
+marked `constexpr` and `noexcept` so that an object `t` with an implicit
+conversion to `S` can be compared according to Table
+[[tab:string.view.comparison.overloads]].
+**Table: Additional `basic_string_view` comparison overloads** <a id="tab:string.view.comparison.overloads">[tab:string.view.comparison.overloads]</a>
+| Expression | Equivalent to |
+| ---------- | ------------- |
+| `t == sv`  | `S(t) == sv`  |
+| `sv == t`  | `sv == S(t)`  |
+| `t != sv`  | `S(t) != sv`  |
+| `sv != t`  | `sv != S(t)`  |
+| `t < sv`   | `S(t) < sv`   |
+| `sv < t`   | `sv < S(t)`   |
+| `t > sv`   | `S(t) > sv`   |
+| `sv > t`   | `sv > S(t)`   |
+| `t <= sv`  | `S(t) <= sv`  |
+| `sv <= t`  | `sv <= S(t)`  |
+| `t >= sv`  | `S(t) >= sv`  |
+| `sv >= t`  | `sv >= S(t)`  |
+[*Example 1*:
+A sample conforming implementation for `operator==` would be:
+``` cpp
+template<class T> using __identity = decay_t<T>;
+template<class charT, class traits>
+  constexpr bool operator==(basic_string_view<charT, traits> lhs,
+                            basic_string_view<charT, traits> rhs) noexcept {
+    return lhs.compare(rhs) == 0;
+  }
+template<class charT, class traits>
+  constexpr bool operator==(basic_string_view<charT, traits> lhs,
+                            __identity<basic_string_view<charT, traits>> rhs) noexcept {
+    return lhs.compare(rhs) == 0;
+  }
+template<class charT, class traits>
+  constexpr bool operator==(__identity<basic_string_view<charT, traits>> lhs,
+                            basic_string_view<charT, traits> rhs) noexcept {
+    return lhs.compare(rhs) == 0;
+  }
+```
+— *end example*]
+``` cpp
+template<class charT, class traits>
+  constexpr bool operator==(basic_string_view<charT, traits> lhs,
+                            basic_string_view<charT, traits> rhs) noexcept;
+```
+*Returns:* `lhs.compare(rhs) == 0`.
+``` cpp
+template<class charT, class traits>
+  constexpr bool operator!=(basic_string_view<charT, traits> lhs,
+                            basic_string_view<charT, traits> rhs) noexcept;
+```
+*Returns:* `lhs.compare(rhs) != 0`.
+``` cpp
+template<class charT, class traits>
+  constexpr bool operator< (basic_string_view<charT, traits> lhs,
+                            basic_string_view<charT, traits> rhs) noexcept;
+```
+*Returns:* `lhs.compare(rhs) < 0`.
+``` cpp
+template<class charT, class traits>
+  constexpr bool operator> (basic_string_view<charT, traits> lhs,
+                            basic_string_view<charT, traits> rhs) noexcept;
+```
+*Returns:* `lhs.compare(rhs) > 0`.
+``` cpp
+template<class charT, class traits>
+  constexpr bool operator<=(basic_string_view<charT, traits> lhs,
+                            basic_string_view<charT, traits> rhs) noexcept;
+```
+*Returns:* `lhs.compare(rhs) <= 0`.
+``` cpp
+template<class charT, class traits>
+  constexpr bool operator>=(basic_string_view<charT, traits> lhs,
+                            basic_string_view<charT, traits> rhs) noexcept;
+```
+*Returns:* `lhs.compare(rhs) >= 0`.
+### Inserters and extractors <a id="string.view.io">[[string.view.io]]</a>
+``` cpp
+template<class charT, class traits>
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os,
+               basic_string_view<charT, traits> str);
+```
+*Effects:* Behaves as a formatted output
+function ([[ostream.formatted.reqmts]]) of `os`. Forms a character
+sequence `seq`, initially consisting of the elements defined by the
+range \[`str.begin()`, `str.end()`). Determines padding for `seq` as
+described in  [[ostream.formatted.reqmts]]. Then inserts `seq` as if by
+calling `os.rdbuf()->sputn(seq, n)`, where `n` is the larger of
+`os.width()` and `str.size()`; then calls `os.width(0)`.
+*Returns:* `os`
+### Hash support <a id="string.view.hash">[[string.view.hash]]</a>
+``` cpp
+template<> struct hash<string_view>;
+template<> struct hash<u16string_view>;
+template<> struct hash<u32string_view>;
+template<> struct hash<wstring_view>;
+```
+The specialization is enabled ([[unord.hash]]).
+[*Note 1*: The hash value of a string view object is equal to the hash
+value of the corresponding string object
+([[basic.string.hash]]). — *end note*]
+### Suffix for `basic_string_view` literals <a id="string.view.literals">[[string.view.literals]]</a>
+``` cpp
+constexpr string_view operator""sv(const char* str, size_t len) noexcept;
+```
+*Returns:* `string_view{str, len}`.
+``` cpp
+constexpr u16string_view operator""sv(const char16_t* str, size_t len) noexcept;
+```
+*Returns:* `u16string_view{str, len}`.
+``` cpp
+constexpr u32string_view operator""sv(const char32_t* str, size_t len) noexcept;
+```
+*Returns:* `u32string_view{str, len}`.
+``` cpp
+constexpr wstring_view operator""sv(const wchar_t* str, size_t len) noexcept;
+```
+*Returns:* `wstring_view{str, len}`.

Diff to HTML by rtfpessoa