Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Zeichenkettenbibliothek
     
    std::basic_string_view
    Mitgliedsfunktionen
      
    Iteratoren
    Kapazität
    Operationen
    (C++26)
    (C++20)
    (C++20)
    (C++23)
     
    Definiert in Header <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) (seit C++17)
    (bis 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;
    		(seit 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) (seit C++17)
    (bis 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) (seit C++17)
    (bis 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) (seit C++17)
    (bis 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) (seit C++17)
    (bis 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) (seit C++17)
    (bis 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) (seit C++20)

    Vergleicht zwei Ansichten.

    Alle Vergleiche erfolgen über die compare()-Mitgliedsfunktion (die selbst mittels Traits::compare() definiert ist):

    • Zwei Ansichten sind gleich, wenn sowohl die Größe von lhs als auch von rhs gleich sind und jedes Zeichen in lhs ein äquivalentes Zeichen in rhs an derselben Position hat.
    • Die Ordnungsvergleiche erfolgen lexikografisch – der Vergleich wird mittels einer Funktion durchgeführt, die std::lexicographical_compare entspricht.

    Die Implementierung stellt ausreichende zusätzliche constexpr- und noexcept-Überladungen dieser Funktionen bereit, sodass ein basic_string_view<CharT,Traits>-Objekt sv mit einem anderen Objekt t mit einer impliziten Konvertierung zu basic_string_view<CharT,Traits> verglichen werden kann, wobei die Semantik identisch zum Vergleich von sv und basic_string_view<CharT,Traits>(t) ist.

    		(bis C++20)

    Der Rückgabetyp der Dreiwegevergleichsoperatoren (/*comp-cat*/) ist Traits::comparison_category, wenn dieses qualifizierte-ID einen Typ bezeichnet, andernfalls std::weak_ordering. Wenn /*comp-cat*/ kein Vergleichskategorietyp ist, ist das Programm fehlerhaft.

    Die Operatoren <, <=, >, >= und != werden aus synthetisiert beziehungsweise operator<=> und operator==.

    		(seit C++20)

    Parameter

    lhs, rhs - zu vergleichende Views

    Rückgabewert

    1-6) true wenn der entsprechende Vergleich zutrifft, false andernfalls.
    7) static_cast < /*comp-cat*/ > ( lhs. compare ( rhs ) <=> 0 ) .

    Komplexität

    Linear in der Größe der Ansichten.

    Hinweise

    Ausreichend zusätzliche Überladungen können durch nicht abgeleiteten Kontext in einem Parametertyp implementiert werden.

    		(until C++20)

    Der Drei-Wege-Vergleichsresultattyp von std::string_view , std::wstring_view , std::u8string_view , std::u16string_view und std::u32string_view ist std::strong_ordering .

    std::type_identity_t wird für nicht abgeleiteten Kontext verwendet, was Argumente, die implizit in den String-View-Typ konvertierbar sind, mit dem String-View vergleichbar macht.

    		(since C++20)

    Beispiel

    Diesen Code ausführen 
    #include <string_view>
int main()
{
    using namespace std::literals;
    static_assert(""sv == ""sv);
    static_assert(""sv == "", "Selects an additional overload until C++20.");
    static_assert("" == ""sv, "Selects an additional overload until C++20."
                              "Uses a rewritten candidate since C++20.");
    static_assert(!(""sv != ""sv), "Uses the rewritten candidate since C++20.");
    static_assert(!(""sv != ""), "Selects an additional overload until C++20;"
                                 "Uses a rewritten candidate since C++20.");
    static_assert(!("" != ""sv), "Selects an additional overload until C++20."
                                 "Uses a rewritten candidate since C++20.");
}
    **Übersetzungserläuterungen:** - "Run this code" wurde zu "Diesen Code ausführen" übersetzt - Alle HTML-Tags, Attribute und Formatierung wurden beibehalten - Der C++ Code innerhalb der `
    ` Tags wurde nicht übersetzt
- C++-spezifische Begriffe wie "overload", "static_assert", etc. wurden nicht übersetzt
- Die Textstruktur und Anordnung wurde exakt beibehalten

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
    LWG 3432 C++20 der Rückgabetyp von operator<=> musste kein Vergleichskategorietyp sein erforderlich
    LWG 3950 C++20 redundante zusätzliche Überladungen waren weiterhin erforderlich Überladungsmengen reduziert