string.view.html

<cxx-clause id="string.view">
  <h1><code>string_view</code></h1>

  <p>
    The class template <code>basic_string_view</code> describes an object that can refer to a constant contiguous sequence of char-like (<cxx-ref in="cxx" to="strings.general"></cxx-ref>) 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 <code>basic_string_view</code> object is designated by <code>charT</code>.
  </p>

  <p>
    <cxx-note>The library provides implicit conversions from <code>const charT*</code> and <code>std::basic_string&lt;charT, ...></code> to <code>std::basic_string_view&lt;charT, ...></code> so that user code can accept just <code>std::basic_string_view&lt;charT></code> as a non-templated parameter wherever a sequence of characters is expected.
    User-defined types should define their own implicit conversions to <code>std::basic_string_view</code> in order to interoperate with these functions.</cxx-note>
  </p>

  <p>
    The complexity of <code>basic_string_view</code> member functions is O(1) unless otherwise specified.
  </p>

  <cxx-section id="string.view.synop">
    <h1>Header <code>&lt;experimental/string_view></code> synopsis</h1>

    <pre><code>namespace std {
  namespace experimental {
  inline namespace fundamentals_v2 {

    <cxx-ref insynopsis="" to="string.view.template"></cxx-ref>
    template&lt;class charT, class traits = char_traits&lt;charT>>
        class basic_string_view;

    <cxx-ref insynopsis="" to="string.view.comparison"></cxx-ref>
    template&lt;class charT, class traits>
    constexpr bool operator==(basic_string_view&lt;charT, traits> x,
                              basic_string_view&lt;charT, traits> y) noexcept;
    template&lt;class charT, class traits>
    constexpr bool operator!=(basic_string_view&lt;charT, traits> x,
                              basic_string_view&lt;charT, traits> y) noexcept;
    template&lt;class charT, class traits>
    constexpr bool operator&lt; (basic_string_view&lt;charT, traits> x,
                                 basic_string_view&lt;charT, traits> y) noexcept;
    template&lt;class charT, class traits>
    constexpr bool operator> (basic_string_view&lt;charT, traits> x,
                              basic_string_view&lt;charT, traits> y) noexcept;
    template&lt;class charT, class traits>
    constexpr bool operator&lt;=(basic_string_view&lt;charT, traits> x,
                                 basic_string_view&lt;charT, traits> y) noexcept;
    template&lt;class charT, class traits>
    constexpr bool operator>=(basic_string_view&lt;charT, traits> x,
                              basic_string_view&lt;charT, traits> y) noexcept;
    // <i>see below</i>, sufficient additional overloads of comparison functions

    <cxx-ref insynopsis="" to="string.view.io"></cxx-ref>
    template&lt;class charT, class traits>
      basic_ostream&lt;charT, traits>&amp;
        operator&lt;&lt;(basic_ostream&lt;charT, traits>&amp; os,
                   basic_string_view&lt;charT, traits> str);

    // basic_string_view typedef names
    typedef basic_string_view&lt;char> string_view;
    typedef basic_string_view&lt;char16_t> u16string_view;
    typedef basic_string_view&lt;char32_t> u32string_view;
    typedef basic_string_view&lt;wchar_t> wstring_view;

  }  // namespace fundamentals_v2
  }  // namespace experimental

  <cxx-ref insynopsis="" to="string.view.hash"></cxx-ref>
  template &lt;class T> struct hash;
  template &lt;> struct hash&lt;experimental::string_view>;
  template &lt;> struct hash&lt;experimental::u16string_view>;
  template &lt;> struct hash&lt;experimental::u32string_view>;
  template &lt;> struct hash&lt;experimental::wstring_view>;

}  // namespace std</code></pre>

    <p>
      The function templates defined in <cxx-ref in="cxx" to="utility.swap"></cxx-ref> and <cxx-ref in="cxx" to="iterator.range"></cxx-ref> are available when <code>&lt;experimental/string_view></code> is included.
    </p>
  </cxx-section>

  <cxx-section id="string.view.template">
    <h1>Class template <code>basic_string_view</code></h1>

    <pre><code>template&lt;class charT, class traits = char_traits&lt;charT>>
class basic_string_view {
  public:
  // types
  typedef traits traits_type;
  typedef charT value_type;
  typedef charT* pointer;
  typedef const charT* const_pointer;
  typedef charT&amp; reference;
  typedef const charT&amp; const_reference;
  typedef <var>implementation-defined</var> const_iterator; // See <cxx-ref to="string.view.iterators"></cxx-ref>
  typedef const_iterator iterator;<cxx-footnote>Because <code>basic_string_view</code> refers to a constant sequence, <code>iterator</code> and <code>const_iterator</code> are the same type.</cxx-footnote>
  typedef reverse_iterator&lt;const_iterator> const_reverse_iterator;
  typedef const_reverse_iterator reverse_iterator;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  static constexpr size_type npos = size_type(-1);

  <cxx-ref insynopsis="" to="string.view.cons"></cxx-ref>
  constexpr basic_string_view() noexcept;
  constexpr basic_string_view(const basic_string_view&amp;) noexcept = default;
  basic_string_view&amp; operator=(const basic_string_view&amp;) noexcept = default;
  template&lt;class Allocator>
  basic_string_view(const basic_string&lt;charT, traits, Allocator>&amp; str) noexcept;
  constexpr basic_string_view(const charT* str);
  constexpr basic_string_view(const charT* str, size_type len);

  <cxx-ref insynopsis="" to="string.view.iterators"></cxx-ref>
  constexpr const_iterator begin() const noexcept;
  constexpr const_iterator end() const noexcept;
  constexpr const_iterator cbegin() const noexcept;
  constexpr const_iterator cend() const noexcept;
  const_reverse_iterator rbegin() const noexcept;
  const_reverse_iterator rend() const noexcept;
  const_reverse_iterator crbegin() const noexcept;
  const_reverse_iterator crend() const noexcept;

  <cxx-ref insynopsis="" to="string.view.capacity"></cxx-ref>
  constexpr size_type size() const noexcept;
  constexpr size_type length() const noexcept;
  constexpr size_type max_size() const noexcept;
  constexpr bool empty() const noexcept;

  <cxx-ref insynopsis="" to="string.view.access"></cxx-ref>
  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;

  <cxx-ref insynopsis="" to="string.view.modifiers"></cxx-ref>
  constexpr void remove_prefix(size_type n);
  constexpr void remove_suffix(size_type n);
  constexpr void swap(basic_string_view&amp; s) noexcept;

  <cxx-ref insynopsis="" to="string.view.ops"></cxx-ref>
  template&lt;class Allocator>
  explicit operator basic_string&lt;charT, traits, Allocator>() const;
  template&lt;class Allocator = allocator&lt;charT> >
  basic_string&lt;charT, traits, Allocator> to_string(
    const Allocator&amp; a = Allocator()) const;

  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_;  // <em>exposition only</em>
  size_type     size_;  // <em>exposition only</em>
};</code></pre>

    <p>
      In every specialization <code>basic_string_view&lt;charT, traits></code>, the type <code>traits</code> shall satisfy the character traits requirements (<cxx-ref in="cxx" to="char.traits"></cxx-ref>),
      and the type <code>traits::char_type</code> shall name the same type as <code>charT</code>.
    </p>
  </cxx-section>

  <cxx-section id="string.view.cons">
    <h1><code>basic_string_view</code> constructors and assignment operators</h1>

    <cxx-function>
      <cxx-signature>constexpr basic_string_view() noexcept;</cxx-signature>

      <cxx-effects>Constructs an empty <code>basic_string_view</code>.</cxx-effects>
      <cxx-postconditions><code>size_ == 0</code> and <code>data_ == nullptr</code>.</cxx-postconditions>
    </cxx-function>

    <cxx-function>
      <cxx-signature>template&lt;class Allocator>
basic_string_view(const basic_string&lt;charT, traits, Allocator>&amp; str) noexcept;</cxx-signature>

      <cxx-effects>Constructs a <code>basic_string_view</code>, with the postconditions in <cxx-ref to="tab:string.view.ctr.1"></cxx-ref>.</cxx-effects>
      <table is="cxx-table" id="tab:string.view.ctr.1">
        <caption><code>basic_string_view(const basic_string&amp;)</code> effects</caption>
        <tr><th>Element</th><th>Value</th></tr>
        <tr><td><code>data_</code></td><td><code>str.data()</code></td></tr>
        <tr><td><code>size_</code></td><td><code>str.size()</code></td></tr>
      </table>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr basic_string_view(const charT* str);</cxx-signature>

      <cxx-requires><cxx-range begin="str" end="str + traits::length(str)"></cxx-range> is a valid range.</cxx-requires>
      <cxx-effects>Constructs a <code>basic_string_view</code>, with the postconditions
      in <cxx-ref to="tab:string.view.ctr.2"></cxx-ref>.</cxx-effects>

      <table is="cxx-table" id="tab:string.view.ctr.2"><caption><code>basic_string_view(const charT*)</code> effects</caption>
      <tr><th>Element</th><th>Value</th></tr>
      <tr><td><code>data_</code></td><td><code>str</code></td></tr>
      <tr><td><code>size_</code></td><td><code>traits::length(str)</code></td></tr>
      </table>

      <cxx-complexity>O(<code>traits::length(str)</code>)</cxx-complexity>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr basic_string_view(const charT* str, size_type len);</cxx-signature>

      <cxx-requires><cxx-range begin="str" end="str + len"></cxx-range> is a valid range.</cxx-requires>
      <cxx-effects>Constructs a <code>basic_string_view</code>, with the postconditions in <cxx-ref to="tab:string.view.ctr.3"></cxx-ref>.</cxx-effects>
      <table is="cxx-table" id="tab:string.view.ctr.3"><caption><code>basic_string_view(const charT*, size_type)</code> effects</caption>
        <tr><th>Element</th><th>Value</th></tr>
        <tr><td><code>data_</code></td><td><code>str</code></td></tr>
        <tr><td><code>size_</code></td><td><code>len</code></td></tr>
      </table>
    </cxx-function>
  </cxx-section>

  <cxx-section id="string.view.iterators">
    <h1><code>basic_string_view</code> iterator support</h1>

    <cxx-function>
      <cxx-signature>typedef <var>implementation-defined</var> const_iterator;</cxx-signature>

      <p>
        A constant random-access iterator type such that, for a <code>const_iterator it</code>, if <code>&amp;*(it+N)</code> is valid, then it is equal to <code>(&amp;*it)+N</code>.
      </p>
      <p>
        For a <code>basic_string_view str</code>, any operation that invalidates a pointer in the range <cxx-range begin="str.data()" end="str.data()+str.size()"></cxx-range> invalidates pointers, iterators, and references returned from <code>str</code>'s methods.
      </p>
      <p>
        All requirements on container iterators (<cxx-ref in="cxx" to="container.requirements"></cxx-ref>) apply to <code>basic_string_view::const_iterator</code> as well.
      </p>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr const_iterator begin() const noexcept;</cxx-signature>
      <cxx-signature>constexpr const_iterator cbegin() const noexcept;</cxx-signature>
      <cxx-returns>An iterator such that <code>&amp;*begin() == data_</code> if <code>!empty()</code>,
      or else an unspecified value such that <cxx-range begin="begin()" end="end()"></cxx-range> is a valid range.</cxx-returns>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr const_iterator end() const noexcept;</cxx-signature>
      <cxx-signature>constexpr const_iterator cend() const noexcept;</cxx-signature>

      <cxx-returns> <code>begin() + size()</code>.</cxx-returns>
    </cxx-function>

    <cxx-function>
      <cxx-signature>const_reverse_iterator rbegin() const noexcept;</cxx-signature>
      <cxx-signature>const_reverse_iterator crbegin() const noexcept;</cxx-signature>

      <cxx-returns> <code>const_reverse_iterator(end())</code>.</cxx-returns>
    </cxx-function>

    <cxx-function>
      <cxx-signature>const_reverse_iterator rend() const noexcept;</cxx-signature>
      <cxx-signature>const_reverse_iterator crend() const noexcept;</cxx-signature>

      <cxx-returns><code>const_reverse_iterator(begin())</code>.</cxx-returns>
    </cxx-function>
  </cxx-section>

  <cxx-section id="string.view.capacity">
    <h1><code>basic_string_view</code> capacity</h1>

    <cxx-function>
      <cxx-signature>constexpr size_type size() const noexcept;</cxx-signature>
      <cxx-returns><code>size_</code>.</cxx-returns>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr size_type length() const noexcept;</cxx-signature>
      <cxx-returns><code>size_</code>.</cxx-returns>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr size_type max_size() const noexcept;</cxx-signature>
      <cxx-returns>The largest possible number of char-like objects that can be referred to by a <code>basic_string_view</code>.</cxx-returns>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr bool empty() const noexcept;</cxx-signature>
      <cxx-returns><code>size_ == 0</code>.</cxx-returns>
    </cxx-function>
  </cxx-section>

  <cxx-section id="string.view.access">
    <h1><code>basic_string_view</code> element access</h1>

    <cxx-function>
      <cxx-signature>constexpr const_reference operator[](size_type pos) const;</cxx-signature>

      <cxx-requires><code>pos &lt; size()</code>.</cxx-requires>
      <cxx-returns><code>data_[pos]</code>.</cxx-returns>
      <cxx-throws>Nothing.</cxx-throws>
      <p><cxx-note>Unlike <code>basic_string::operator[]</code>,
        <code>basic_string_view::operator[](size())</code> has undefined behavior instead of returning <code>charT()</code>.</cxx-note></p>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr const_reference at(size_type pos) const;</cxx-signature>

      <cxx-throws><code>out_of_range</code> if <code>pos >= size()</code>.</cxx-throws>
      <cxx-returns><code>data_[pos]</code>.</cxx-returns>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr const_reference front() const;</cxx-signature>

      <cxx-requires><code>!empty()</code></cxx-requires>
      <cxx-returns><code>data_[0]</code>.</cxx-returns>
      <cxx-throws>Nothing.</cxx-throws>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr const_reference back() const;</cxx-signature>

      <cxx-requires><code>!empty()</code></cxx-requires>
      <cxx-returns><code>data_[size() - 1]</code>.</cxx-returns>
      <cxx-throws>Nothing.</cxx-throws>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr const_pointer data() const noexcept;</cxx-signature>

      <cxx-returns><code>data_</code>.</cxx-returns>
      <p><cxx-note>Unlike <code>basic_string::data()</code> and string literals,
      <code>data()</code> may return a pointer to a buffer that is not null-terminated.
      Therefore it is typically a mistake to pass <code>data()</code> to a routine that takes just a <code>const charT*</code> and expects a null-terminated string.</cxx-note></p>
    </cxx-function>
  </cxx-section>

  <cxx-section id="string.view.modifiers">
    <h1><code>basic_string_view</code> modifiers</h1>

    <cxx-function>
      <cxx-signature>constexpr void remove_prefix(size_type n);</cxx-signature>

      <cxx-requires><code>n &lt;= size()</code>.</cxx-requires>
      <cxx-effects>Equivalent to <code>data_ += n; size_ -= n;</code></cxx-effects>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr void remove_suffix(size_type n);</cxx-signature>

      <cxx-requires><code>n &lt;= size()</code>.</cxx-requires>
      <cxx-effects>Equivalent to <code>size_ -= n;</code></cxx-effects>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr void swap(basic_string_view&amp; s) noexcept;</cxx-signature>

      <cxx-effects>Exchanges the values of <code>*this</code> and <code>s</code>.</cxx-effects>
    </cxx-function>
  </cxx-section>

  <cxx-section id="string.view.ops">
    <h1><code>basic_string_view</code> string operations</h1>

    <cxx-function>
      <cxx-signature>template&lt;class Allocator>
explicit<cxx-footnote>This conversion is explicit to avoid accidental O(N) operations on type mismatches.</cxx-footnote> operator basic_string&lt;
    charT, traits, Allocator>() const;</cxx-signature>

      <cxx-effects>Equivalent to <code>return basic_string&lt;charT, traits, Allocator>(begin(), end());</code></cxx-effects>
      <cxx-complexity>O(<code>size()</code>)</cxx-complexity>
      <p><cxx-note>Users who want to control the allocator instance should call <code>to_string(allocator)</code>.</cxx-note></p>
    </cxx-function>

    <cxx-function>
      <cxx-signature>template&lt;class Allocator = allocator&lt;charT>>
basic_string&lt;charT, traits, Allocator> to_string(
    const Allocator&amp; a = Allocator()) const;</cxx-signature>

      <cxx-returns><code>basic_string&lt;charT, traits, Allocator>(begin(), end(), a)</code>.</cxx-returns>
      <cxx-complexity>O(<code>size()</code>)</cxx-complexity>
    </cxx-function>

    <cxx-function>
      <cxx-signature>size_type copy(charT* s, size_type n, size_type pos = 0) const;</cxx-signature>

      <p>Let <code>rlen</code> be the smaller of <code>n</code> and <code>size() - pos</code>.</p>
      <cxx-throws><code>out_of_range</code> if <code>pos > size()</code>.</cxx-throws>
      <cxx-requires><cxx-range begin="s" end="s + rlen"></cxx-range> is a valid range.</cxx-requires>
      <cxx-effects>Equivalent to <code>std::copy_n(begin() + pos, rlen, s).</code></cxx-effects>
      <cxx-returns><code>rlen</code>.</cxx-returns>
      <cxx-complexity>O(<code>rlen</code>)</cxx-complexity>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;</cxx-signature>

      <cxx-throws><code>out_of_range</code> if <code>pos > size()</code>.</cxx-throws>
      <cxx-effects>Determines the effective length <code><var>rlen</var></code> of the string to reference as the smaller of <code>n</code> and <code>size() - pos</code>.</cxx-effects>
      <cxx-returns><code>basic_string_view(data()+pos, <var>rlen</var>)</code>.</cxx-returns>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr int compare(basic_string_view str) const noexcept;</cxx-signature>

      <cxx-effects>Determines the effective length <code><var>rlen</var></code> of the strings to compare as the smaller of <code>size()</code> and <code>str.size()</code>.
        The function then compares the two strings by calling <code>traits::compare(data(), str.data(), <var>rlen</var>)</code>.</cxx-effects>
      <cxx-complexity>O(<code><var>rlen</var></code>)</cxx-complexity>
      <cxx-returns>The nonzero result if the result of the comparison is nonzero.
        Otherwise, returns a value as indicated in <cxx-ref to="tab:string.view.compare"></cxx-ref>.</cxx-returns>
      <table is="cxx-table" id="tab:string.view.compare" class="center">
        <caption><code>compare()</code> results</caption>
        <tr><th>Condition</th><th>Return Value</th></tr>
        <tr><td><code>size() &lt; str.size()</code></td><td><code>&lt; 0</code></td></tr>
        <tr><td><code>size() == str.size()</code></td><td><code>&#xA0; 0</code></td></tr>
        <tr><td><code>size() >  str.size()</code></td><td><code>> 0</code></td></tr>
      </table>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr int compare(size_type pos1, size_type n1, basic_string_view str) const;</cxx-signature>
      <cxx-effects>Equivalent to <code>return substr(pos1, n1).compare(str);</code></cxx-effects>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr int compare(size_type pos1, size_type n1, basic_string_view str,
                      size_type pos2, size_type n2) const;</cxx-signature>
      <cxx-effects>Equivalent to <code>return substr(pos1, n1).compare(str.substr(pos2, n2));</code></cxx-effects>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr int compare(const charT* s) const;</cxx-signature>
      <cxx-effects>Equivalent to <code>return compare(basic_string_view(s));</code></cxx-effects>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr int compare(size_type pos1, size_type n1, const charT* s) const;</cxx-signature>
      <cxx-effects>Equivalent to <code>return substr(pos1, n1).compare(basic_string_view(s));</code></cxx-effects>
    </cxx-function>

    <cxx-function>
      <cxx-signature>constexpr int compare(size_type pos1, size_type n1,
                      const charT* s, size_type n2) const;</cxx-signature>
      <cxx-effects>Equivalent to <code>return substr(pos1, n1).compare(basic_string_view(s, n2));</code></cxx-effects>
    </cxx-function>

    <cxx-section id="string.view.find">
      <h1>Searching <code>basic_string_view</code></h1>

      <p>This section specifies the <code>basic_string_view</code> member functions named
        <code>find</code>, <code>rfind</code>, <code>find_first_of</code>, <code>find_last_of</code>, <code>find_first_not_of</code>, and <code>find_last_not_of</code>.</p>

      <p>Member functions in this section have complexity O(<code>size() * str.size()</code>) at worst,
        although implementations are encouraged to do better.</p>

      <p>Each member function of the form</p>
      <pre><code>constexpr <var>return-type fx1</var>(const charT* s, size_type pos);</code></pre>
      <p class="cont">is equivalent to <code>return <var>fx1</var>(basic_string_view(s), pos);</code></p>

      <p>Each member function of the form</p>
      <pre><code>constexpr <var>return-type fx1</var>(const charT* s, size_type pos, size_type n);</code></pre>
      <p class="cont">is equivalent to <code>return <var>fx1</var>(basic_string_view(s, n), pos);</code></p>

      <p>Each member function of the form</p>
      <pre><code>constexpr <var>return-type fx2</var>(charT c, size_type pos);</code></pre>
      <p class="cont">is equivalent to <code>return <var>fx2</var>(basic_string_view(&amp;c, 1), pos);</code></p>

      <cxx-function>
        <cxx-signature>constexpr size_type find(basic_string_view str, size_type pos = 0) const noexcept;</cxx-signature>

        <cxx-effects>
          Determines the lowest position <code>xpos</code>, if possible, such that the following conditions obtain:
          <ul>
            <li><code>pos &lt;= xpos</code></li>
            <li><code>xpos + str.size() &lt;= size()</code></li>
            <li><code>traits::eq(at(xpos+I), str.at(I))</code> for all elements <code>I</code> of the string referenced by <code>str</code>.</li>
          </ul>
        </cxx-effects>
        <cxx-returns><code>xpos</code> if the function can determine such a value for <code>xpos</code>.
          Otherwise, returns <code>npos</code>.</cxx-returns>
        <cxx-remarks>Uses <code>traits::eq()</code>.</cxx-remarks>
      </cxx-function>

      <cxx-function>
        <cxx-signature>constexpr size_type rfind(basic_string_view str, size_type pos = npos) const noexcept;</cxx-signature>

        <cxx-effects>
          Determines the highest position <code>xpos</code>, if possible, such that the following conditions obtain:
          <ul>
            <li><code>xpos &lt;= pos</code></li>
            <li><code>xpos + str.size() &lt;= size()</code></li>
            <li><code>traits::eq(at(xpos+I), str.at(I))</code> for all elements <code>I</code> of the string referenced by <code>str</code>.</li>
          </ul>
        </cxx-effects>
        <cxx-returns><code>xpos</code> if the function can determine such a value for <code>xpos</code>.
          Otherwise, returns <code>npos</code>.</cxx-returns>
        <cxx-remarks>Uses <code>traits::eq()</code>.</cxx-remarks>
      </cxx-function>

      <cxx-function>
        <cxx-signature>constexpr size_type find_first_of(basic_string_view str, size_type pos = 0) const noexcept;</cxx-signature>

        <cxx-effects>Determines the lowest position <code>xpos</code>, if possible, such that the following conditions obtain:
          <ul>
            <li><code>pos &lt;= xpos</code></li>
            <li><code>xpos &lt; size()</code></li>
            <li><code>traits::eq(at(xpos), str.at(I))</code> for some element <code>I</code> of the string referenced by <code>str</code>.</li>
          </ul>
        </cxx-effects>
        <cxx-returns><code>xpos</code> if the function can determine such a value for <code>xpos</code>.
          Otherwise, returns <code>npos</code>.</cxx-returns>
        <cxx-remarks>Uses <code>traits::eq()</code>.</cxx-remarks>
      </cxx-function>

      <cxx-function>
        <cxx-signature>constexpr size_type find_last_of(basic_string_view str, size_type pos = npos) const noexcept;</cxx-signature>

        <cxx-effects>Determines the highest position <code>xpos</code>, if possible, such that the following conditions obtain:
          <ul>
            <li><code>xpos &lt;= pos</code></li>
            <li><code>xpos &lt; size()</code></li>
            <li><code>traits::eq(at(xpos), str.at(I))</code> for some element <code>I</code> of the string referenced by <code>str</code>.</li>
          </ul>
        </cxx-effects>
        <cxx-returns><code>xpos</code> if the function can determine such a value for <code>xpos</code>.
          Otherwise, returns <code>npos</code>.</cxx-returns>
        <cxx-remarks>Uses <code>traits::eq()</code>.</cxx-remarks>
      </cxx-function>

      <cxx-function>
        <cxx-signature>constexpr size_type find_first_not_of(basic_string_view str, size_type pos = 0) const noexcept;</cxx-signature>

        <cxx-effects>Determines the lowest position <code>xpos</code>, if possible, such that the following conditions obtain:
          <ul>
            <li><code>pos &lt;= xpos</code></li>
            <li><code>xpos &lt; size()</code></li>
            <li><code>traits::eq(at(xpos), str.at(I))</code> for no element <code>I</code> of the string referenced by <code>str</code>.</li>
          </ul>
        </cxx-effects>
        <cxx-returns><code>xpos</code> if the function can determine such a value for <code>xpos</code>. Otherwise, returns <code>npos</code>.</cxx-returns>
        <cxx-remarks>Uses <code>traits::eq()</code>.</cxx-remarks>
      </cxx-function>

      <cxx-function>
        <cxx-signature>constexpr size_type find_last_not_of(basic_string_view str, size_type pos = npos) const noexcept;</cxx-signature>

        <cxx-effects>Determines the highest position <code>xpos</code>, if possible, such that the following conditions obtain:
          <ul>
            <li><code>xpos &lt;= pos</code></li>
            <li><code>xpos &lt; size()</code></li>
            <li><code>traits::eq(at(xpos), str.at(I))</code> for no element <code>I</code> of the string referenced by <code>str</code>.</li>
          </ul>
        </cxx-effects>
        <cxx-returns><code>xpos</code> if the function can determine such a value for <code>xpos</code>.
          Otherwise, returns <code>npos</code>.</cxx-returns>
        <cxx-remarks>Uses <code>traits::eq()</code>.</cxx-remarks>
      </cxx-function>
    </cxx-section>
  </cxx-section>

  <cxx-section id="string.view.comparison">
    <h1><code>basic_string_view</code> non-member comparison functions</h1>

    <p>
      Let <code>S</code> be <code>basic_string_view&lt;charT, traits></code>, and <code>sv</code> be an instance of <code>S</code>.
      Implementations shall provide sufficient additional overloads marked <code>constexpr</code> and <code>noexcept</code>
      so that an object <code><var>t</var></code> with an implicit conversion to <code>S</code> can be compared according to <cxx-ref to="tab:string.view.comparison.overloads"></cxx-ref>.
    </p>

    <table is="cxx-table" id="tab:string.view.comparison.overloads" class="center"><caption>Additional <code>basic_string_view</code> comparison overloads</caption>
      <tr><th>Expression</th><th>Equivalent to</th></tr>
      <tr><td><code>t == sv</code></td><td><code>S(t) == sv</code></td></tr>
      <tr><td><code>sv == t</code></td><td><code>sv == S(t)</code></td></tr>
      <tr><td><code>t != sv</code></td><td><code>S(t) != sv</code></td></tr>
      <tr><td><code>sv != t</code></td><td><code>sv != S(t)</code></td></tr>
      <tr><td><code>t &lt; sv</code></td><td><code>S(t) &lt; sv</code></td></tr>
      <tr><td><code>sv &lt; t</code></td><td><code>sv &lt; S(t)</code></td></tr>
      <tr><td><code>t > sv</code></td><td><code>S(t) > sv</code></td></tr>
      <tr><td><code>sv > t</code></td><td><code>sv > S(t)</code></td></tr>
      <tr><td><code>t &lt;= sv</code></td><td><code>S(t) &lt;= sv</code></td></tr>
      <tr><td><code>sv &lt;= t</code></td><td><code>sv &lt;= S(t)</code></td></tr>
      <tr><td><code>t >= sv</code></td><td><code>S(t) >= sv</code></td></tr>
      <tr><td><code>sv >= t</code></td><td><code>sv >= S(t)</code></td></tr>
    </table>

    <cxx-example>A sample conforming implementation for operator== would be:
<pre><code>template&lt;class T> using __identity = decay_t&lt;T>;
template&lt;class charT, class traits>
constexpr bool operator==(
    basic_string_view&lt;charT, traits> lhs,
    basic_string_view&lt;charT, traits> rhs) noexcept {
  return lhs.compare(rhs) == 0;
}
template&lt;class charT, class traits>
constexpr bool operator==(
    basic_string_view&lt;charT, traits> lhs,
    __identity&lt;basic_string_view&lt;charT, traits>> rhs) noexcept {
  return lhs.compare(rhs) == 0;
}
template&lt;class charT, class traits>
constexpr bool operator==(
    __identity&lt;basic_string_view&lt;charT, traits>> lhs,
    basic_string_view&lt;charT, traits> rhs) noexcept {
  return lhs.compare(rhs) == 0;
}</code></pre>
    </cxx-example>

    <cxx-function>
      <cxx-signature>template&lt;class charT, class traits>
  constexpr bool operator==(basic_string_view&lt;charT, traits> lhs,
                            basic_string_view&lt;charT, traits> rhs) noexcept;</cxx-signature>
      <cxx-returns> <code>lhs.compare(rhs) == 0</code>.</cxx-returns>
    </cxx-function>

    <cxx-function>
      <cxx-signature>template&lt;class charT, class traits>
  constexpr bool operator!=(basic_string_view&lt;charT, traits> lhs,
                            basic_string_view&lt;charT, traits> rhs) noexcept;</cxx-signature>
      <cxx-returns> <code>lhs.compare(rhs) != 0</code>.</cxx-returns>
    </cxx-function>

    <cxx-function>
      <cxx-signature>template&lt;class charT, class traits>
  constexpr bool operator&lt; (basic_string_view&lt;charT, traits> lhs,
                            basic_string_view&lt;charT, traits> rhs) noexcept;</cxx-signature>
      <cxx-returns> <code>lhs.compare(rhs) &lt; 0</code>.</cxx-returns>
    </cxx-function>

    <cxx-function>
      <cxx-signature>template&lt;class charT, class traits>
  constexpr bool operator> (basic_string_view&lt;charT, traits> lhs,
                            basic_string_view&lt;charT, traits> rhs) noexcept;</cxx-signature>
      <cxx-returns> <code>lhs.compare(rhs) > 0</code>.</cxx-returns>
    </cxx-function>

    <cxx-function>
      <cxx-signature>template&lt;class charT, class traits>
  constexpr bool operator&lt;=(basic_string_view&lt;charT, traits> lhs,
                            basic_string_view&lt;charT, traits> rhs) noexcept;</cxx-signature>
      <cxx-returns> <code>lhs.compare(rhs) &lt;= 0</code>.</cxx-returns>
    </cxx-function>

    <cxx-function>
      <cxx-signature>template&lt;class charT, class traits>
  constexpr bool operator>=(basic_string_view&lt;charT, traits> lhs,
                            basic_string_view&lt;charT, traits> rhs) noexcept;</cxx-signature>
      <cxx-returns> <code>lhs.compare(rhs) >= 0</code>.</cxx-returns>
    </cxx-function>
  </cxx-section>

  <cxx-section id="string.view.io">
    <h1>Inserters and extractors</h1>

    <cxx-function>
      <cxx-signature>template&lt;class charT, class traits>
  basic_ostream&lt;charT, traits>&amp;
    operator&lt;&lt;(basic_ostream&lt;charT, traits>&amp; os,
               basic_string_view&lt;charT, traits> str);</cxx-signature>

      <cxx-effects>Equivalent to <code>return os &lt;&lt; str.to_string();</code></cxx-effects>
    </cxx-function>
  </cxx-section>

  <cxx-section id="string.view.hash">
    <h1>Hash support</h1>

    <cxx-function>
      <cxx-signature>template &lt;> struct hash&lt;experimental::string_view>;</cxx-signature>
      <cxx-signature>template &lt;> struct hash&lt;experimental::u16string_view>;</cxx-signature>
      <cxx-signature>template &lt;> struct hash&lt;experimental::u32string_view>;</cxx-signature>
      <cxx-signature>template &lt;> struct hash&lt;experimental::wstring_view>;</cxx-signature>
      <p>The template specializations shall meet the requirements of class template hash (<cxx-ref in="cxx" to="unord.hash"></cxx-ref>).</p>
    </cxx-function>
  </cxx-section>
</cxx-clause>