operator==,<=> (std::inplace_vector)

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::inplace_vector

Membertypen
Memberfunktionen
inplace_vector::inplace_vector inplace_vector::~inplace_vector    inplace_vector::operator= inplace_vector::assign inplace_vector::assign_range Größe und Kapazität inplace_vector::empty inplace_vector::size inplace_vector::max_size inplace_vector::capacity inplace_vector::resize inplace_vector::reserve inplace_vector::shrink_to_fit Iteratoren inplace_vector::begininplace_vector::cbegin inplace_vector::endinplace_vector::cend inplace_vector::rbegininplace_vector::crbegin inplace_vector::rendinplace_vector::crend	Elementzugriff inplace_vector::at inplace_vector::operator[] inplace_vector::front inplace_vector::back inplace_vector::data Modifizierer inplace_vector::clear inplace_vector::erase inplace_vector::swap inplace_vector::insert inplace_vector::insert_range inplace_vector::emplace inplace_vector::emplace_back inplace_vector::try_emplace_back inplace_vector::unchecked_emplace_back inplace_vector::push_back inplace_vector::try_push_back inplace_vector::unchecked_push_back inplace_vector::pop_back inplace_vector::append_range inplace_vector::try_append_range
Nicht-Member-Funktionen
erase(std::inplace_vector)erase_if(std::inplace_vector) swap(std::inplace_vector)	operator==operator<=>

 

constexpr friend bool operator==( const std::inplace_vector<T, N>& lhs,                                   const std::inplace_vector<T, N>& rhs );	(1)	(seit C++26)
constexpr friend synth-three-way-result<T>     operator<=> ( const std::inplace_vector<T, N>& lhs,                  const std::inplace_vector<T, N>& rhs );	(2)	(seit C++26)

Vergleicht den Inhalt zweier std::inplace_vectors.

1) Prüft, ob der Inhalt von lhs und rhs gleich ist, d.h., sie haben die gleiche Anzahl von Elementen und jedes Element in lhs vergleicht sich gleich mit dem Element in rhs an der gleichen Position.

2) Vergleicht den Inhalt von lhs und rhs lexikographisch. Der Vergleich wird so durchgeführt, als ob aufgerufen würde
std::lexicographical_compare_three_way(lhs.begin(), lhs.end(),
                                       rhs.begin(), rhs.end(), synth-three-way);.

Der Rückgabetyp ist der Rückgabetyp von synth-three-way (d. h. synth-three-way-result <T>).

Mindestens eine der folgenden Bedingungen muss erfüllt sein

• T modelliert three_way_comparable.
• < ist für Werte des Typs (möglicherweise const-qualifiziert) T definiert, und < ist eine totale Ordnungsrelation.

   Andernfalls ist das Verhalten undefiniert.

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

Parameter

lhs, rhs	-	std::inplace_vectors, deren Inhalt verglichen werden soll
- T muss die Anforderungen an EqualityComparable erfüllen, um die Überladungen (1) verwenden zu können.

Rückgabewert

1) true, wenn der Inhalt der std::inplace_vectors gleich ist, andernfalls false.

2) Die relative Reihenfolge des ersten Paares von nicht-äquivalenten Elementen in lhs und rhs, falls solche Elemente vorhanden sind, andernfalls lhs.size() <=> rhs.size().

Komplexität

1) Konstante Zeit, wenn lhs und rhs unterschiedliche Größen haben, andernfalls linear in der Größe des std::inplace_vector.

2) Linear in der Größe des std::inplace_vector.

Hinweise

Die relationalen Operatoren sind in Bezug auf synth-three-way definiert, der, wenn möglich, `operator<=>` und andernfalls `operator<` verwendet.

Insbesondere, wenn das Element selbst keinen `operator<=>` bereitstellt, aber implizit in einen dreiwertig vergleichbaren Typ konvertiert werden kann, wird diese Konvertierung anstelle von `operator<` verwendet.

Beispiel

Führen Sie diesen Code aus

#include <inplace_vector>
 
int main()
{
    constexpr std::inplace_vector<int, 4>
        a{1, 2, 3},
        b{1, 2, 3},
        c{7, 8, 9, 10};
 
    static_assert
    (""
        "Compare equal containers:" &&
        (a != b) == false &&
        (a == b) == true &&
        (a < b) == false &&
        (a <= b) == true &&
        (a > b) == false &&
        (a >= b) == true &&
        (a <=> b) >= 0 &&
        (a <=> b) <= 0 &&
        (a <=> b) == 0 &&
 
        "Compare non equal containers:" &&
        (a != c) == true &&
        (a == c) == false &&
        (a < c) == true &&
        (a <= c) == true &&
        (a > c) == false &&
        (a >= c) == false &&
        (a <=> c) < 0 &&
        (a <=> c) != 0 &&
        (a <=> c) <= 0 &&
    "");
}