Namespaces
Variants

operator==,!=,<,<=,>,>=,<=> (std::basic_string_view)

From cppreference.net
C++
Strings library
std::basic_string_view
Definido en el encabezado <string_view>
(1)
template < class CharT, class Traits >

constexpr bool operator == ( std:: basic_string_view < CharT,Traits > lhs,

std:: basic_string_view < CharT,Traits > rhs ) noexcept ;
(desde C++17)
(hasta C++20)
template < class CharT, class Traits >

constexpr bool operator == (
std:: basic_string_view < CharT,Traits > lhs,

std:: type_identity_t < std:: basic_string_view < CharT,Traits >> rhs ) noexcept ;
(desde C++20)
template < class CharT, class Traits >

constexpr bool operator ! = ( std:: basic_string_view < CharT,Traits > lhs,

std:: basic_string_view < CharT,Traits > rhs ) noexcept ;
(2) (desde C++17)
(hasta C++20)
template < class CharT, class Traits >

constexpr bool operator < ( std:: basic_string_view < CharT,Traits > lhs,

std:: basic_string_view < CharT,Traits > rhs ) noexcept ;
(3) (desde C++17)
(hasta C++20)
template < class CharT, class Traits >

constexpr bool operator <= ( std:: basic_string_view < CharT,Traits > lhs,

std:: basic_string_view < CharT,Traits > rhs ) noexcept ;
(4) (desde C++17)
(hasta C++20)
template < class CharT, class Traits >

constexpr bool operator > ( std:: basic_string_view < CharT,Traits > lhs,

std:: basic_string_view < CharT,Traits > rhs ) noexcept ;
(5) (desde C++17)
(hasta C++20)
template < class CharT, class Traits >

constexpr bool operator >= ( std:: basic_string_view < CharT,Traits > lhs,

std:: basic_string_view < CharT,Traits > rhs ) noexcept ;
(6) (desde C++17)
(hasta C++20)
template < class CharT, class Traits >

constexpr /*comp-cat*/ operator <=> (
std:: basic_string_view < CharT,Traits > lhs,

std:: type_identity_t < std:: basic_string_view < CharT,Traits >> rhs ) noexcept ;
(7) (desde C++20)

Compara dos vistas.

Todas las comparaciones se realizan mediante la compare() función miembro (que a su vez está definida en términos de Traits::compare() ):

  • Dos vistas son iguales si tanto el tamaño de lhs como el de rhs son iguales y cada carácter en lhs tiene un carácter equivalente en rhs en la misma posición.
  • Las comparaciones de ordenación se realizan lexicográficamente – la comparación se lleva a cabo mediante una función equivalente a std::lexicographical_compare .

La implementación proporciona sobrecargas adicionales suficientes constexpr y noexcept de estas funciones para que un objeto basic_string_view<CharT,Traits> sv pueda compararse con otro objeto t con una conversión implícita a basic_string_view<CharT,Traits> , con semántica idéntica a comparar sv y basic_string_view<CharT,Traits>(t) .

(hasta C++20)

El tipo de retorno de los operadores de comparación de tres vías ( /*comp-cat*/ ) es Traits :: comparison_category si ese identificador calificado denota un tipo, de lo contrario es std::weak_ordering . Si /*comp-cat*/ no es un tipo de categoría de comparación, el programa está mal formado.

Los operadores < , <= , > , >= , y != son sintetizados a partir de operator <=> y operator == respectivamente.

(desde C++20)

Contenidos

Parámetros

lhs, rhs - vistas a comparar

Valor de retorno

1-6) true si la comparación correspondiente se cumple, false en caso contrario.
7) static_cast < /*comp-cat*/ > ( lhs. compare ( rhs ) <=> 0 ) .

Complejidad

Lineal en el tamaño de las vistas.

Notas

Se pueden implementar sobrecargas adicionales suficientes mediante contexto no deducido en un tipo de parámetro.

(until C++20)

El tipo de resultado de comparación de tres vías de std::string_view , std::wstring_view , std::u8string_view , std::u16string_view y std::u32string_view es std::strong_ordering .

std::type_identity_t se utiliza para contexto no deducido, lo que hace que los argumentos que son implícitamente convertibles al tipo string view sean comparables con el string view.

(since C++20)

Ejemplo

Ejecutar este código 
#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.");
}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 3432 C++20 el tipo de retorno de operator<=> no estaba requerido que fuera un tipo de categoría de comparación requerido
LWG 3950 C++20 aún se requerían sobrecargas adicionales redundantes conjuntos de sobrecarga reducidos