Namespaces
Variants

std:: owner_less

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
Défini dans l'en-tête <memory>
(1)
template < class T >
struct owner_less ; /* indéfini */
(depuis C++11)
(jusqu'à C++17)
template < class T = void >
struct owner_less ; /* indéfini */
(depuis C++17)
template < class T >
struct owner_less < std:: shared_ptr < T >> ;
(2) (depuis C++11)
template < class T >
struct owner_less < std:: weak_ptr < T >> ;
(3) (depuis C++11)
template <>
struct owner_less < void > ;
(4) (depuis C++17)

Cet objet fonction fournit un ordonnancement mixte basé sur le propriétaire (par opposition à un ordonnancement basé sur la valeur) pour std::weak_ptr et std::shared_ptr . L'ordre est tel que deux pointeurs intelligents sont équivalents seulement s'ils sont tous deux vides ou s'ils partagent la propriété, même si les valeurs des pointeurs bruts obtenus par get() sont différentes (par exemple parce qu'ils pointent vers différents sous-objets au sein du même objet).

1) L'ordonnancement mixte basé sur le propriétaire n'est pas fourni pour les types autres que std::shared_ptr et std::weak_ptr .
2) L'ordonnancement mixte basé sur le propriétaire de std::shared_ptr .
C'est le prédicat de comparaison privilégié lors de la construction de conteneurs associatifs avec std::shared_ptr comme clés, c'est-à-dire, std:: map < std:: shared_ptr < T > , U, std :: owner_less < std:: shared_ptr < T >>> .
3) L'ordonnancement mixte basé sur le propriétaire de std::weak_ptr .
C'est le prédicat de comparaison privilégié lors de la construction de conteneurs associatifs avec std::weak_ptr comme clés, c'est-à-dire, std:: map < std:: weak_ptr < T > , U, std :: owner_less < std:: weak_ptr < T >>> .
4) La spécialisation void déduit les types de paramètres à partir des arguments.

L'opérateur par défaut operator < n'est pas défini pour les pointeurs faibles, et pourrait considérer à tort deux pointeurs partagés pour le même objet comme non équivalents (voir std::shared_ptr::owner_before ).

Table des matières

Spécialisations

La bibliothèque standard fournit une spécialisation de std::owner_less lorsque T n'est pas spécifié. Dans ce cas, les types de paramètres sont déduits des arguments (chacun devant toujours être soit un std::shared_ptr soit un std::weak_ptr ).

objet fonction fournissant un ordonnancement basé sur le propriétaire de types mixtes pour les pointeurs partagés et faibles, indépendamment du type de la pointee
(spécialisation de modèle de classe)
(depuis C++17)


Types imbriqués

Type imbriqué Définition
result_type (obsolète en C++17) (2,3) bool
first_argument_type (obsolète en C++17) (2) std:: shared_ptr < T >
(3) std:: weak_ptr < T >
second_argument_type (obsolète en C++17) (2) std:: shared_ptr < T >
(3) std:: weak_ptr < T >
(jusqu'en C++20)

Fonctions membres

operator()
compare ses arguments en utilisant une sémantique basée sur le propriétaire
(fonction)

std::owner_less:: operator()

membre uniquement de la spécialisation (2)
bool operator ( ) ( const std:: shared_ptr < T > & lhs,
const std:: shared_ptr < T > & rhs ) const noexcept ;
(depuis C++11)
membre uniquement de la spécialisation (3)
bool operator ( ) ( const std:: weak_ptr < T > & lhs,
const std:: weak_ptr < T > & rhs ) const noexcept ;
(depuis C++11)
membre des deux spécialisations de modèle
bool operator ( ) ( const std:: shared_ptr < T > & lhs,
const std:: weak_ptr < T > & rhs ) const noexcept ;
(depuis C++11)
bool operator ( ) ( const std:: weak_ptr < T > & lhs,
const std:: shared_ptr < T > & rhs ) const noexcept ;
(depuis C++11)

Compare lhs et rhs en utilisant la sémantique basée sur le propriétaire. Appelle effectivement lhs. owner_before ( rhs ) .

L'ordre est une relation d'ordre faible strict.

lhs et rhs sont équivalents seulement s'ils sont tous deux vides ou partagent la propriété.

Paramètres

lhs, rhs - pointeurs à propriété partagée à comparer

Valeur de retour

true si lhs est inférieur à rhs selon l'ordre basé sur le propriétaire, false sinon.

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 Appliqué à Comportement publié Comportement corrigé
LWG 2873 C++11 operator ( ) n'était pas requis d'être noexcept requis d'être noexcept

Voir aussi

fournit un ordonnancement basé sur le propriétaire des pointeurs partagés
(fonction membre publique de std::shared_ptr<T> )
fournit un ordonnancement basé sur le propriétaire des pointeurs faibles
(fonction membre publique de std::weak_ptr<T> )