Namespaces
Variants

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

From cppreference.net
C++
Strings library
std::basic_string_view
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Gemäß den Anweisungen wurden keine HTML-Tags oder Attribute übersetzt.)
Definiert im Header <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 ;
(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 werden über die compare() Memberfunktion durchgeführt (die selbst in Form von Traits::compare() definiert ist):

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

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

(bis C++20)

Der Rückgabetyp der Drei-Wege-Vergleichsoperatoren ( /*comp-cat*/ ) ist Traits :: comparison_category , falls dieser qualifizierte Bezeichner einen Typ bezeichnet, andernfalls std::weak_ordering . Wenn /*comp-cat*/ kein Vergleichskategorietyp ist, ist das Programm fehlerhaft.

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

(seit C++20)

Inhaltsverzeichnis

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