operator==,!=,<,<=,>,>=,<=>(std::basic_string_view)
<string_view>
constexpr bool operator==( std::basic_string_view <CharT,Traits> lhs,
(until C++20)
constexpr bool operator==(
std::basic_string_view <CharT,Traits> lhs,
constexpr bool operator!=( std::basic_string_view <CharT,Traits> lhs,
(until C++20)
constexpr bool operator<( std::basic_string_view <CharT,Traits> lhs,
(until C++20)
constexpr bool operator<=( std::basic_string_view <CharT,Traits> lhs,
(until C++20)
constexpr bool operator>( std::basic_string_view <CharT,Traits> lhs,
(until C++20)
constexpr bool operator>=( std::basic_string_view <CharT,Traits> lhs,
(until C++20)
constexpr /*comp-cat*/ operator<=>(
std::basic_string_view <CharT,Traits> lhs,
Compares two views.
All comparisons are done via the compare() member function (which itself is defined in terms of Traits::compare()):
- Two views are equal if both the size of lhs and rhs are equal and each character in lhs has an equivalent character in rhs at the same position.
- The ordering comparisons are done lexicographically – the comparison is performed by a function equivalent to std::lexicographical_compare .
The implementation provides sufficient additional constexpr and noexcept overloads of these functions so that a basic_string_view<CharT,Traits> object sv may be compared to another object t with an implicit conversion to basic_string_view<CharT,Traits>, with semantics identical to comparing sv and basic_string_view<CharT,Traits>(t).
The return type of three-way comparison operators (/*comp-cat*/) is Traits::comparison_category if that qualified-id denotes a type, std::weak_ordering otherwise. If /*comp-cat*/ is not a comparison category type, the program is ill-formed.
The <, <=, >, >=, and != operators are synthesized from operator<=> and operator== respectively.
[edit] Parameters
[edit] Return value
[edit] Complexity
Linear in the size of the views.
[edit] Notes
Sufficient additional overloads can be implemented through non-deduced context in one parameter type.
(until C++20)Three-way comparison result type of std::string_view , std::wstring_view , std::u8string_view , std::u16string_view and std::u32string_view is std::strong_ordering.
std::type_identity_t is used for non-deduced context, which makes arguments that implicitly convertible to the string view type comparable with the string view.
(since C++20)[edit] Example
#include <string_view> int main() { using namespace std::literals; static_assert(""sv == ""sv); static_assert(""sv == "", "Selects an additional overload until C++20."); static_assert("" == ""sv, "Selects an additional overload until C++20." "Uses a rewritten candidate since C++20."); static_assert(!(""sv != ""sv), "Uses the rewritten candidate since C++20."); static_assert(!(""sv != ""), "Selects an additional overload until C++20;" "Uses a rewritten candidate since C++20."); static_assert(!("" != ""sv), "Selects an additional overload until C++20." "Uses a rewritten candidate since C++20."); }
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| LWG 3432 | C++20 | the return type of operator<=> was not required to be a comparison category type
|
required |
| LWG 3950 | C++20 | redundant additional overloads were still required | overload sets reduced |