Namespaces
Variants

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

From cppreference.net
C++
Strings library
std::basic_string
Constants
Non-member functions
(C++20) (C++20)
I/O
Comparison
operator== operator!= operator< operator> operator<= operator>= operator<=>
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
Numeric conversions
(C++11) (C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11)
(C++11)
(C++11)
Literals
(C++14)
Helper classes
(C++11)
Deduction guides (C++17)
Definido en el encabezado <string>
Comparar 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)
Comparar un objeto basic_string y un array terminado 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 un arreglo terminado en nulo de CharT .

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

  • Dos cadenas 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.
1-7) Compara dos objetos basic_string .
8-20) Compara un objeto basic_string y un array terminado 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 identificador calificado 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)

Contenidos

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