Namespaces
Variants

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

    De es.cppreference.net
     
    C++
    Soporte del compilador
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de cadenas
     
    std::basic_string_view
    Funciones miembro
      
    Iteradores
    Capacidad
    Operaciones
    (C++26)
    (C++20)
    (C++20)
    (C++23)
     
    Definido en el encabezado <string_view> 
    template< class CharT, class Traits >
constexpr bool operator==( std::basic_string_view<CharT,Traits> lhs,
                           std::basic_string_view<CharT,Traits> rhs ) noexcept;
    		(1) (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 función miembro compare() (la cual a su vez se define 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 orden se realizan lexicográficamente – la comparación se realiza mediante una función equivalente a std::lexicographical_compare.

    La implementación proporciona suficientes sobrecargas adicionales de 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, std::weak_ordering en caso contrario. 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)

    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