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)
Défini dans l'en-tête <string>
Comparer deux basic_string objets
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 depuis C++11)
(constexpr depuis 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) (jusqu'au C++20)
(noexcept depuis 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) (jusqu'à C++20)
(noexcept depuis 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) (jusqu'au C++20)
(noexcept depuis 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) (jusqu'à C++20)
(noexcept depuis 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) (jusqu'au C++20)
(noexcept depuis 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) (depuis C++20)
Compare un objet basic_string et un tableau terminé par un caractère nul de T
template < class CharT, class Traits, class Alloc >

bool operator == ( const std:: basic_string < CharT,Traits,Alloc > & lhs,

const CharT * rhs ) ;
(8) (constexpr depuis C++20)
template < class CharT, class Traits, class Alloc >

bool operator == ( const CharT * lhs,

const std:: basic_string < CharT,Traits,Alloc > & rhs ) ;
(9) (jusqu'au C++20)
template < class CharT, class Traits, class Alloc >

bool operator ! = ( const std:: basic_string < CharT,Traits,Alloc > & lhs,

const CharT * rhs ) ;
(10) (jusqu'au C++20)
template < class CharT, class Traits, class Alloc >

bool operator ! = ( const CharT * lhs,

const std:: basic_string < CharT,Traits,Alloc > & rhs ) ;
(11) (jusqu'au C++20)
template < class CharT, class Traits, class Alloc >

bool operator < ( const std:: basic_string < CharT,Traits,Alloc > & lhs,

const CharT * rhs ) ;
(12) (jusqu'au C++20)
template < class CharT, class Traits, class Alloc >

bool operator < ( const CharT * lhs,

const std:: basic_string < CharT,Traits,Alloc > & rhs ) ;
(13) (jusqu'au C++20)
template < class CharT, class Traits, class Alloc >

bool operator <= ( const std:: basic_string < CharT,Traits,Alloc > & lhs,

const CharT * rhs ) ;
(14) (jusqu'au C++20)
template < class CharT, class Traits, class Alloc >

bool operator <= ( const CharT * lhs,

const std:: basic_string < CharT,Traits,Alloc > & rhs ) ;
(15) (jusqu'au C++20)
template < class CharT, class Traits, class Alloc >

bool operator > ( const std:: basic_string < CharT,Traits,Alloc > & lhs,

const CharT * rhs ) ;
(16) (jusqu'au C++20)
template < class CharT, class Traits, class Alloc >

bool operator > ( const CharT * lhs,

const std:: basic_string < CharT,Traits,Alloc > & rhs ) ;
(17) (jusqu'au C++20)
template < class CharT, class Traits, class Alloc >

bool operator >= ( const std:: basic_string < CharT,Traits,Alloc > & lhs,

const CharT * rhs ) ;
(18) (jusqu'au C++20)
template < class CharT, class Traits, class Alloc >

bool operator >= ( const CharT * lhs,

const std:: basic_string < CharT,Traits,Alloc > & rhs ) ;
(19) (jusqu'au C++20)
template < class CharT, class Traits, class Alloc >

constexpr /*catégorie-de-comparaison*/
operator <=> ( const std:: basic_string < CharT,Traits,Alloc > & lhs,

const CharT * rhs ) ;
(20) (depuis C++20)

Compare le contenu d'une chaîne avec une autre chaîne ou un tableau de caractères terminé par un nul de CharT .

Toutes les comparaisons sont effectuées via la compare() fonction membre (qui elle-même est définie en termes de Traits::compare() ):

  • Deux chaînes sont égales si la taille de lhs et rhs sont égales et chaque caractère dans lhs a un caractère équivalent dans rhs à la même position.
1-7) Compare deux objets basic_string .
8-20) Compare un objet basic_string et un tableau de CharT terminé par un caractère nul.

Le type de retour des opérateurs de comparaison à trois voies ( /*comp-cat*/ ) est Traits :: comparison_category si cet identifiant qualifié existe et désigne un type, std::weak_ordering sinon. Si /*comp-cat*/ n'est pas un type de catégorie de comparaison, le programme est mal formé.

Les opérateurs < , <= , > , >= , et != sont synthétisés respectivement à partir de operator <=> et operator == .

(depuis C++20)

Table des matières

Paramètres

lhs, rhs - chaînes dont le contenu doit être comparé

Valeur de retour

1-6,8-19) true si la comparaison correspondante est vérifiée, false sinon.
7,20) static_cast < /*comp-cat*/ > ( lhs. compare ( rhs ) <=> 0 ) .

Complexité

Linéaire dans la taille des chaînes de caractères.

Notes

Si au moins un paramètre est de type std::string , std::wstring , std::u8string , std::u16string , ou std::u32string , le type de retour de operator<=> est std::strong_ordering .

(depuis C++20)

Exemple

Cette section est incomplète
Raison : aucun exemple

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 2064 C++11 la spécification noexcept des surcharges prenant deux basic_string était incohérente ;
les surcharges prenant un CharT* étaient noexcept mais pouvaient causer un comportement indéfini 		rendu cohérent ;
noexcept supprimé
LWG 3432 C++20 le type de retour de operator<=> n'était pas requis d'être un type de catégorie de comparaison requis