Namespaces
Variants

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

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Autonome 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 diagnostic
    Bibliothèque de gestion de la 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 la 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_view
    Fonctions membres
      
    Itérateurs
    Capacité
    Opérations
    (C++26)
    (C++20)
    (C++20)
    (C++23)
     
    Défini dans l'en-tête <string_view> 
    template< class CharT, class Traits >
constexpr bool operator==( std::basic_string_view<CharT,Traits> lhs,
                           std::basic_string_view<CharT,Traits> rhs ) noexcept;
    		(1) (depuis C++17)
    (jusqu'à C++20)    		 
    template< class CharT, class Traits >
constexpr bool operator==(
    std::basic_string_view<CharT,Traits> lhs,
    std::type_identity_t<std::basic_string_view<CharT,Traits>> rhs ) noexcept;
    		(depuis C++20) 
    template< class CharT, class Traits >
constexpr bool operator!=( std::basic_string_view<CharT,Traits> lhs,
                           std::basic_string_view<CharT,Traits> rhs ) noexcept;
    		(2) (depuis C++17)
    (jusqu'à C++20) 
    template< class CharT, class Traits >
constexpr bool operator<( std::basic_string_view<CharT,Traits> lhs,
                          std::basic_string_view<CharT,Traits> rhs ) noexcept;
    		(3) (depuis C++17)
    (jusqu'à C++20) 
    template< class CharT, class Traits >
constexpr bool operator<=( std::basic_string_view<CharT,Traits> lhs,
                           std::basic_string_view<CharT,Traits> rhs ) noexcept;
    		(4) (depuis C++17)
    (jusqu'à C++20) 
    template< class CharT, class Traits >
constexpr bool operator>( std::basic_string_view<CharT,Traits> lhs,
                          std::basic_string_view<CharT,Traits> rhs ) noexcept;
    		(5) (depuis C++17)
    (jusqu'à C++20) 
    template< class CharT, class Traits >
constexpr bool operator>=( std::basic_string_view<CharT,Traits> lhs,
                           std::basic_string_view<CharT,Traits> rhs ) noexcept;
    		(6) (depuis C++17)
    (jusqu'à C++20) 
    template< class CharT, class Traits >
constexpr /*comp-cat*/ operator<=>(
    std::basic_string_view<CharT,Traits> lhs,
    std::type_identity_t<std::basic_string_view<CharT,Traits>> rhs ) noexcept;
    		(7) (depuis C++20)

    Compare deux vues.

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

    • Deux vues sont égales si la taille de lhs et rhs sont toutes deux égales et si chaque caractère de 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_compare.

    L'implémentation fournit suffisamment de surcharges supplémentaires constexpr et noexcept de ces fonctions pour qu'un objet basic_string_view<CharT,Traits> sv puisse être comparé à un autre objet t avec une conversion implicite en basic_string_view<CharT,Traits>, avec une sémantique identique à la comparaison de sv et basic_string_view<CharT,Traits>(t).

    		(jusqu'à C++20)

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

    Valeur de retour

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

    Complexité

    Linéaire dans la taille des vues.

    Notes

    Des surcharges supplémentaires suffisantes peuvent être implémentées via un contexte non déduit dans un type de paramètre.

    		(until C++20)

    Le type de résultat de comparaison à trois voies de std::string_view , std::wstring_view , std::u8string_view , std::u16string_view et std::u32string_view est std::strong_ordering .

    std::type_identity_t est utilisé pour le contexte non déduit, ce qui rend les arguments implicitement convertibles au type string view comparables avec le string view.

    		(since C++20)

    Exemple

    Exécuter ce code 
    #include <string_view>
int main()
{
    using namespace std::literals;
    static_assert(""sv == ""sv);
    static_assert(""sv == "", "Sélectionne une surcharge supplémentaire jusqu'à C++20.");
    static_assert("" == ""sv, "Sélectionne une surcharge supplémentaire jusqu'à C++20."
                              "Utilise un candidat réécrit depuis C++20.");
    static_assert(!(""sv != ""sv), "Utilise le candidat réécrit depuis C++20.");
    static_assert(!(""sv != ""), "Sélectionne une surcharge supplémentaire jusqu'à C++20;"
                                 "Utilise un candidat réécrit depuis C++20.");
    static_assert(!("" != ""sv), "Sélectionne une surcharge supplémentaire jusqu'à C++20."
                                 "Utilise un candidat réécrit depuis C++20.");
}

    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 3432 C++20 le type de retour de operator<=> n'était pas requis d'être un type de catégorie de comparaison requis
    LWG 3950 C++20 des surcharges supplémentaires redondantes étaient encore requises ensembles de surcharges réduits