Namespaces
Variants

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

From cppreference.net
C++
Containers library
std::inplace_vector
Member types
Member functions
Non-member functions
operator== operator<=>

constexpr friend bool operator == ( const std:: inplace_vector < T, N > & lhs,
const std:: inplace_vector < T, N > & rhs ) ;
(1) (depuis 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) (depuis C++26)

Compare le contenu de deux std::inplace_vector s.

1) Vérifie si le contenu de lhs et rhs sont égaux, c'est-à-dire qu'ils ont le même nombre d'éléments et que chaque élément dans lhs est égal à l'élément correspondant dans rhs à la même position.
2) Compare lexicographiquement le contenu de lhs et rhs . La comparaison est effectuée comme en appelant
std:: lexicographical_compare_three_way ( lhs. begin ( ) , lhs. end ( ) ,
rhs. begin ( ) , rhs. end ( ) , synth - three - way ) ; .
Le type de retour est le type de retour de synth-three-way (c'est-à-dire, synth-three-way-result  < T > ).
Au moins une des conditions suivantes doit être satisfaite :
  • T modélise three_way_comparable .
  • < est défini pour les valeurs de type (éventuellement qualifié const) T , et < est une relation d'ordre total.
Sinon, le comportement est indéfini.

Les opérateurs < , <= , > , >= et != sont synthétisés respectivement à partir de operator <=> et operator == .

Table des matières

Paramètres

lhs, rhs - std::inplace_vector s dont le contenu doit être comparé
-
T doit satisfaire aux exigences de EqualityComparable pour utiliser les surcharges (1).

Valeur de retour

1) true si le contenu des std::inplace_vector s sont égaux, false sinon.
2) L'ordre relatif de la première paire d'éléments non équivalents dans lhs et rhs s'il existe de tels éléments, lhs. size ( ) <=> rhs. size ( ) sinon.

Complexité

1) Constant si lhs et rhs sont de tailles différentes, sinon linéaire par rapport à la taille du std::inplace_vector .
2) Linéaire par rapport à la taille du std::inplace_vector .

Notes

Les opérateurs relationnels sont définis en termes de synth-three-way , qui utilise operator <=> si possible, ou operator < sinon.

Notamment, si l'élément ne fournit pas lui-même operator <=> , mais est implicitement convertible en un type comparable à trois voies, cette conversion sera utilisée à la place de operator < .

Exemple

Exécuter ce code 
#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
    (""
        "Comparer des conteneurs égaux :" &&
        (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 &&
        "Comparer des conteneurs non égaux :" &&
        (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 &&
    "");
}