Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::map
Member functions
Non-member functions
operator== operator<=>
(C++20)
(C++20)

operator!= operator< operator> operator<= operator>=
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
Défini dans l'en-tête <map>
template < class Key, class T, class Compare, class Alloc >

bool operator == ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(1) (constexpr depuis C++26)
template < class Key, class T, class Compare, class Alloc >

bool operator ! = ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(2) (jusqu'au C++20)
template < class Key, class T, class Compare, class Alloc >

bool operator < ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(3) (jusqu'au C++20)
template < class Key, class T, class Compare, class Alloc >

bool operator <= ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(4) (jusqu'en C++20)
template < class Key, class T, class Compare, class Alloc >

bool operator > ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(5) (jusqu'au C++20)
template < class Key, class T, class Compare, class Alloc >

bool operator >= ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(6) (jusqu'en C++20)
template < class Key, class T, class Compare, class Alloc >

/* voir ci-dessous */
operator <=> ( const std:: map < Key, T, Compare, Alloc > & lhs,

const std:: map < Key, T, Compare, Alloc > & rhs ) ;
(7) (depuis C++20)
(constexpr depuis C++26)

Compare le contenu de deux map s.

Soit value_type le type de valeur de map (c'est-à-dire, typename map :: value_type ):

1,2) 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.
Équivalent à :

return std:: distance ( lhs. begin ( ) , lhs. end ( ) )
== std:: distance ( rhs. begin ( ) , rhs. end ( ) )
&& std:: equal ( lhs. begin ( ) , lhs. end ( ) , rhs. begin ( ) ) ;

(jusqu'en C++14)

return std:: equal ( lhs. begin ( ) , lhs. end ( ) , rhs. begin ( ) , rhs. end ( ) ) ;

(depuis C++14)
Si value_type n'est pas EqualityComparable , le comportement est indéfini.
3-7) Compare le contenu de lhs et rhs de manière lexicographique.
3-6) Équivalent à return std:: lexicographical_compare ( lhs. begin ( ) , lhs. end ( ) ,
rhs. begin ( ) , rhs. end ( ) ) ; .
Si l'une des conditions suivantes est satisfaite, le comportement est indéfini :
7) Équivalent à return 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  < value_type > ).
Si l'une des conditions suivantes est satisfaite, le comportement est indéfini :
  • T ne modélise pas three_way_comparable .
  • operator < n'est pas défini pour les valeurs de type (éventuellement qualifié const) value_type .
  • operator < n'établit pas un ordre total .

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

(depuis C++20)

Table des matières

Paramètres

lhs, rhs - map s dont le contenu doit être comparé

Valeur de retour

Opérateur lhs et rhs
sont égaux 		lhs est
lexicographiquement supérieur 		rhs est
lexicographiquement supérieur
operator == true false
operator ! = false true
operator < false false true
operator <= true
operator > false true false
operator >= true
operator <=> une valeur égale à ​ 0 ​ une valeur supérieure à ​ 0 ​ une valeur inférieure à ​ 0 ​

Complexité

1,2) Constant si lhs et rhs sont de tailles différentes, sinon linéaire par rapport à la taille de la map .
3-7) Linéaire en fonction de la taille de la map .

Notes

Les opérateurs relationnels sont définis en termes de value_type 's operator < .

(jusqu'à C++20)

Les opérateurs relationnels ne sont pas définis. Le candidat réécrit operator <=> sera sélectionné par la résolution de surcharge.

operator <=> utilise value_type 's operator <=> si possible, ou value_type 's operator < sinon. Notamment, si le value_type 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 < .

(depuis C++20)

Ces opérateurs de comparaison non membres n'utilisent pas Compare pour comparer les éléments.

Exemple

Exécuter ce code 
#include <cassert>
#include <compare>
#include <map>
int main()
{
    std::map<int, char> a{{1, 'a'}, {2, 'b'}, {3, 'c'}};
    std::map<int, char> b{{1, 'a'}, {2, 'b'}, {3, 'c'}};
    std::map<int, char> c{{7, 'Z'}, {8, 'Y'}, {9, 'X'}, {10, 'W'}};
    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) != std::weak_ordering::less &&
        (a <=> b) != std::weak_ordering::greater &&
        (a <=> b) == std::weak_ordering::equivalent &&
        (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) == std::weak_ordering::less &&
        (a <=> c) != std::weak_ordering::equivalent &&
        (a <=> c) != std::weak_ordering::greater &&
        (a <=> c) < 0 &&
        (a <=> c) != 0 &&
        (a <=> c) <= 0 &&
    "");
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Applicable à Comportement publié Comportement corrigé
LWG 3431 C++20 operator <=> n'exigeait pas que T
modélise three_way_comparable 		exige