Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Containerbibliothek
     
    std::inplace_vector
    Mitgliedstypen
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
     
    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 derselben Position.
    2) Vergleicht den Inhalt von lhs und rhs lexikografisch. Der Vergleich wird durchgeführt, als ob 
    std::lexicographical_compare_three_way(lhs.begin(), lhs.end(),
                                       rhs.begin(), rhs.end(), /*synth-three-way*/);
    aufgerufen würde. 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 <-, <=-, >-, >=- und !=-Operatoren werden aus synthetisiert von operator<=> bzw. operator==.

    Parameter

    lhs, rhs - std::inplace_vector s, deren Inhalte verglichen werden sollen
    -
    T muss die Anforderungen von EqualityComparable erfüllen, um die Überladungen (1) verwenden zu können.

    Rückgabewert

    1) true wenn die Inhalte der std::inplace_vector s gleich sind, false andernfalls.
    2) Die relative Reihenfolge des ersten Paars nicht-äquivalenter Elemente in lhs und rhs falls solche Elemente existieren, lhs. size ( ) <=> rhs. size ( ) andernfalls.

    Komplexität

    1) Konstant, falls lhs und rhs unterschiedliche Größe 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 definiert in Bezug auf synth-three-way , welches operator <=> verwendet, falls möglich, oder andernfalls operator < .

    Insbesondere, wenn das Element selbst keinen operator <=> bereitstellt, aber implizit in einen dreiweg-vergleichbaren Typ konvertierbar ist, wird diese Konvertierung anstelle von operator < verwendet.

    Beispiel

    Diesen Code ausführen
    #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 &&
    "");
}