Namespaces
Variants

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

    De fr.cppreference.net
     
    C++
    Support du compilateur
    Environnement libre et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support linguistique
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostics
    Bibliothèque de gestion mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilitaires généraux
    Bibliothèque de conteneurs
    Bibliothèque d'itérateurs
    Bibliothèque de plages (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et heure
    Bibliothèque d'entrée/sortie
    Bibliothèque du système de fichiers (C++17)
    Bibliothèque de support de concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque de chaînes
     
    std::basic_string
     
    Défini dans l'en-tête <string>
    Compare deux objets 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 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'à 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'à 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'à 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'à C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator!=( const std::basic_string<CharT,Traits,Alloc>& lhs,
                 const CharT* rhs );
    		(10) (jusqu'à C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator!=( const CharT* lhs,
                 const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(11) (jusqu'à C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator<( const std::basic_string<CharT,Traits,Alloc>& lhs,
                const CharT* rhs );
    		(12) (jusqu'à C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator<( const CharT* lhs,
                const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(13) (jusqu'à C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator<=( const std::basic_string<CharT,Traits,Alloc>& lhs,
                 const CharT* rhs );
    		(14) (jusqu'à C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator<=( const CharT* lhs,
                 const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(15) (jusqu'à C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator>( const std::basic_string<CharT,Traits,Alloc>& lhs,
                const CharT* rhs );
    		(16) (jusqu'à C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator>( const CharT* lhs,
                const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(17) (jusqu'à C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator>=( const std::basic_string<CharT,Traits,Alloc>& lhs,
                 const CharT* rhs );
    		(18) (jusqu'à C++20) 
    template< class CharT, class Traits, class Alloc >
bool operator>=( const CharT* lhs,
                 const std::basic_string<CharT,Traits,Alloc>& rhs );
    		(19) (jusqu'à 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) (depuis C++20)

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

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

    • Deux chaînes sont égales si la taille de lhs et de rhs sont égales et si chaque caractère dans lhs a un caractère équivalent dans rhs à la même position.
    • Les comparaisons d'ordre sont effectuées lexicographiquement – la comparaison est effectuée par une fonction équivalente à std::lexicographical_compareou std::lexicographical_compare_three_way(depuis C++20).
    1-7) Compare deux objets basic_string.
    8-20) Compare un objet basic_string et un tableau terminé par un caractère nul de CharT.

    Le type de retour des opérateurs de comparaison à trois voies (/*comp-cat*/) est Traits::comparison_category si ce qualified-id 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 à partir de operator<=> et operator== respectivement.

    		(depuis C++20)

    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