Namespaces
Variants

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

    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
     
    Definido en el encabezado <string>
    Compara dos objetos basic_string
    		 
    template< class CharT, class Traits, class Alloc >
bool operator==( const std::basic_string<CharT,Traits,Alloc>& lhs,
                 const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(1) (noexcept desde C++11)
    (constexpr desde C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator!=( const std::basic_string<CharT,Traits,Alloc>& lhs,
                 const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(2) (hasta C++20)
    (noexcept desde C++11) 
    template< class CharT, class Traits, class Alloc >
bool operator<( const std::basic_string<CharT,Traits,Alloc>& lhs,
                const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(3) (hasta C++20)
    (noexcept desde C++11) 
    template< class CharT, class Traits, class Alloc >
bool operator<=( const std::basic_string<CharT,Traits,Alloc>& lhs,
                 const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(4) (hasta C++20)
    (noexcept desde C++11) 
    template< class CharT, class Traits, class Alloc >
bool operator>( const std::basic_string<CharT,Traits,Alloc>& lhs,
                const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(5) (hasta C++20)
    (noexcept desde C++11) 
    template< class CharT, class Traits, class Alloc >
bool operator>=( const std::basic_string<CharT,Traits,Alloc>& lhs,
                 const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(6) (hasta C++20)
    (noexcept desde C++11) 
    template< class CharT, class Traits, class Alloc >
constexpr /*comp-cat*/
    operator<=>( const std::basic_string<CharT,Traits,Alloc>& lhs,
                 const std::basic_string<CharT,Traits,Alloc>& rhs ) noexcept;
    		(7) (desde C++20)
    Compara un objeto basic_string y una matriz terminada en nulo de T
    		 
    template< class CharT, class Traits, class Alloc >
bool operator==( const std::basic_string<CharT,Traits,Alloc>& lhs,
                 const CharT* rhs );
    		(8) (constexpr desde C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator==( const CharT* lhs,
                 const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(9) (hasta C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator!=( const std::basic_string<CharT,Traits,Alloc>& lhs,
                 const CharT* rhs );
    		(10) (hasta C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator!=( const CharT* lhs,
                 const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(11) (hasta C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator<( const std::basic_string<CharT,Traits,Alloc>& lhs,
                const CharT* rhs );
    		(12) (hasta C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator<( const CharT* lhs,
                const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(13) (hasta C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator<=( const std::basic_string<CharT,Traits,Alloc>& lhs,
                 const CharT* rhs );
    		(14) (hasta C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator<=( const CharT* lhs,
                 const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(15) (hasta C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator>( const std::basic_string<CharT,Traits,Alloc>& lhs,
                const CharT* rhs );
    		(16) (hasta C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator>( const CharT* lhs,
                const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(17) (hasta C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator>=( const std::basic_string<CharT,Traits,Alloc>& lhs,
                 const CharT* rhs );
    		(18) (hasta C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator>=( const CharT* lhs,
                 const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(19) (hasta C++20) 
    template< class CharT, class Traits, class Alloc >
constexpr /*comp-cat*/
    operator<=>( const std::basic_string<CharT,Traits,Alloc>& lhs,
                 const CharT* rhs );
    		(20) (desde C++20)

    Compara el contenido de una cadena con otra cadena o una matriz terminada en nulo de CharT.

    Todas las comparaciones se realizan a través de la función miembro compare() (que a su vez se define en términos de Traits::compare()):

    • Dos cadenas son iguales si tanto el tamaño de lhs como 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_compareo std::lexicographical_compare_three_way(desde C++20).
    1-7) Compara dos objetos basic_string.
    8-20) Compara un objeto basic_string y una matriz terminada en nulo de CharT.

    El tipo de retorno de los operadores de comparación de tres vías (/*comp-cat*/) es Traits::comparison_category si ese qualified-id existe y 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 - cadenas cuyos contenidos comparar

    Valor de retorno

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

    Complejidad

    Lineal en el tamaño de las cadenas.

    Notas

    Si al menos un parámetro es de tipo std::string , std::wstring , std::u8string , std::u16string , o std::u32string , el tipo de retorno de operator<=> es std::strong_ordering .

    		(desde C++20)

    Ejemplo

    Esta sección está incompleta
    Motivo: sin ejemplo

    Informes de defectos

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

    DR Aplicado a Comportamiento publicado Comportamiento correcto
    LWG 2064 C++11 la consistencia de si las sobrecargas que toman dos basic_string son noexcept era inconsistente;
    las sobrecargas que toman un CharT* eran noexcept pero podían generar UB     		hecho consistente;
    noexcept eliminado
    LWG 3432 C++20 el tipo de retorno de operator<=> no estaba requerido ser un tipo de categoría de comparación requerido