[ Web Proxy ]
URL:
Viewing: http://es.cppreference.com/cpp/string/basic_string/operator_cmp [Back]  [Original]
operator==,!=,<,<=,>,>=,<=>(std::basic_string) - cppreference.com
cppreference.com
Espacios de nombres
Variantes

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

    De cppreference.com
     
    C++
    Apoyo de compiladores
    Implementaciones independientes y albergadas
    Lenguaje
    Biblioteca estndar
    Encabezados de la biblioteca estndar
    Requisitos denominados
    Macros de prueba de caracterstica (C++20)
    Biblioteca de apoyo del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnsticos
    Biblioteca de gestin de memoria
    Biblioteca de metaprogramacin (C++11)
    Biblioteca de servicios generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numrica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de apoyo de concurrencia (C++11)
    Biblioteca de apoyo de ejecucin (C++26)
    Especificaciones tcnicas
    ndice de smbolos
    Bibliotecas externas
     
    Biblioteca de cadenas
     
    std::basic_string
     
    Definido en el archivo de 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) (hasta 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 ) noexcept;
    		 (desde C++11)
    (hasta C++20)
    template< class CharT, class Traits, class Alloc > constexpr bool operator==( const std::basic_string<CharT,Traits,Alloc>& lhs, const std::basic_string<CharT,Traits,Alloc>& rhs ) noexcept;
    		 (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++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 ) noexcept;
    		 (desde C++11)
    (hasta 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 );
    		 (3) (hasta 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 ) noexcept;
    		 (desde C++11)
    (hasta 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 );
    		 (4) (hasta 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 ) noexcept;
    		 (desde C++11)
    (hasta 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 );
    		 (5) (hasta 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 ) noexcept;
    		 (desde C++11)
    (hasta 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 );
    		 (6) (hasta C++14)
    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 ) noexcept;
    		 (desde C++14)
    (hasta C++20)    		 
    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 un array de T terminado en nulo
    template< class CharT, class Traits, class Alloc > bool operator==( const std::basic_string<CharT,Traits,Alloc>& lhs, const CharT* rhs );
    		 (8) (hasta C++20)
    template< class CharT, class Traits, class Alloc > constexpr bool operator==( const std::basic_string<CharT,Traits,Alloc>& lhs, const CharT* rhs );
    		 (desde C++20)
    template< class CharT, class Traits, class Alloc > bool operator==( const CharT* lhs, const std::basic_string<CharT,Traits,Alloc>& rhs );
    		 (hasta C++20)
    template< class CharT, class Traits, class Alloc > bool operator!=( const std::basic_string<CharT,Traits,Alloc>& lhs, const CharT* rhs );
    		 (9) (hasta C++20)
    template< class CharT, class Traits, class Alloc > bool operator!=( const CharT* lhs, const std::basic_string<CharT,Traits,Alloc>& rhs );
    		 (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 );
    		 (hasta C++20)
    template< class CharT, class Traits, class Alloc > bool operator<=( const std::basic_string<CharT,Traits,Alloc>& lhs, const CharT* rhs );
    		 (11) (hasta C++20)
    template< class CharT, class Traits, class Alloc > bool operator<=( const CharT* lhs, const std::basic_string<CharT,Traits,Alloc>& rhs );
    		 (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 );
    		 (hasta C++20)
    template< class CharT, class Traits, class Alloc > bool operator>=( const std::basic_string<CharT,Traits,Alloc>& lhs, const CharT* rhs );
    		 (13) (hasta C++20)
    template< class CharT, class Traits, class Alloc > bool operator>=( const CharT* lhs, const std::basic_string<CharT,Traits,Alloc>& rhs );
    		 (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 );
    		(14) (desde C++20)

    Compara el contenido de una cadena con otra cadena o un array de CharT terminado en nulo.

    Todas las comparaciones se hacen mediante la funcin miembro compare() (que en s misma se define en trminos de Traits::compare()):

    • Dos cadenas son iguales si tanto el tamao de lhs y rhs son iguales y cada carcter en lhs tiene un carcter equivalente en rhs en la misma posicin.
    • El orden de las comparaciones se hace lexicogrficamente--la comparacin se realiza por una funcin equivalente a std::lexicographical_compare o std::lexicographical_compare_three_way (desde C++20).

    El tipo de retorno de los operadores de comparacin de tres vas (/*comp-cat*/) es Traits::comparison_category si es que existe, de lo contrario, std::weak_ordering.

    		(desde C++20)
    1-7) Compara dos objetos basic_string.
    8-14) Compara un objeto basic_string y un array de CharT terminado en nulo.

    Parmetros

    lhs, rhs - Cadenas cuyo contenido hay que comparar.

    Valor de retorno

    1-6,8-13) true si se mantiene la comparacin correspondiente, de lo contrario, false.
    7,14) static_cast</*comp-cat*/>(lhs.compare(rhs) <=> 0).

    Complejidad

    Lineal en el tamao de las cadenas.

    Notas

    Si al menos un parmetro 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)

    Informes de defectos

    Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estndares de C++ publicados anteriormente.

    ID Aplicado a Comportamiento segn lo publicado Comportamiento correcto
    LWG 2064 C++11 Era inconsistente si sobrecargas que toman dos basic_strings eran noexcept;
    las sobrecargas que toman un CharT* eran noexcept     		Se hizo consistente;
    se elimin noexcept ya que puede ocurrir comportamiento indefinido.
    Web Proxy Viewer  |  New URL  |  Original Page