Namespaces
Variants

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

From cppreference.net
C++
Strings library
std::basic_string_view
Défini dans l'en-tête <string_view>
(1)
template < class CharT, class Traits >

constexpr bool operator == ( std:: basic_string_view < CharT,Traits > lhs,

std:: basic_string_view < CharT,Traits > rhs ) noexcept ;
(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 compare() fonction membre (qui elle-même est définie en termes de Traits::compare() ):

  • Deux vues sont égales si la taille de lhs et rhs sont égales et que 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 réalisé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 cet identifiant qualifié 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)

Table des matières

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