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

Files changed (1) hide show

tmp/tmpwqa6gs6b/{from.md → to.md} +519 -0

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

	@@ -0,0 +1,519 @@

+### 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`.

Diff to HTML by rtfpessoa