Namensräume
Varianten
Aktionen

std::owner_less

Von cppreference.com
< cpp‎ | memory
 
C++
 
Speicherverwaltungsbibliothek
(nur Exposition*)
Algorithmen für uninitialisierten Speicher
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++17)
(C++17)
(C++17)
(C++20)
Beschränkte uninitialisierte
Speicher-Algorithmen
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20) 
(C++20)
C-Bibliothek

Allocatoren
(C++11)
(C++23)
(C++11)
(C++11)
(C++20)
(C++20)
(C++20) 
(C++11)
(C++17)
Speicherressourcen
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
Unterstützung für Garbage Collection
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
Uninitialisierter Speicher
(bis C++20*)
(bis C++20*)
(bis C++20*)
Explizites Lebenszeitmanagement
(C++23)(C++23)
 
Definiert in Header <memory>
(1)
template< class T >
struct owner_less; /* undefiniert */
 (seit C++11)
(bis C++17)
template< class T = void >
struct owner_less; /* undefiniert */
 (seit C++17)
template< class T >
struct owner_less<std::shared_ptr<T>>;
 (2) (seit C++11)
template< class T >
struct owner_less<std::weak_ptr<T>>;
 (3) (seit C++11)
template<>
struct owner_less<void>;
 (4) (seit C++17)

Dieses Funktions-Objekt bietet inhaltsbasiertes (im Gegensatz zu wertebasiertes) gemischtes Ordering von sowohl std::weak_ptr als auch std::shared_ptr. Die Ordnung ist so, dass zwei intelligente Zeiger nur dann als äquivalent verglichen werden, wenn sie beide leer sind oder wenn sie sich den Besitz teilen, auch wenn die Werte der von get() erhaltenen Rohzeiger unterschiedlich sind (z. B. weil sie auf unterschiedliche Unterobjekte innerhalb desselben Objekts zeigen).

1) inhaltsbasiertes gemischtes Ordering ist für andere Typen als std::shared_ptr und std::weak_ptr nicht verfügbar.
2) Das inhaltsbasierte gemischte Ordering von std::shared_ptr.
Es ist das bevorzugte Vergleichsprädikat beim Erstellen von assoziativen Containern mit std::shared_ptr als Schlüssel, d. h. std::map<std::shared_ptr<T>, U, std::owner_less<std::shared_ptr<T>>>.
3) Das inhaltsbasierte gemischte Ordering von std::weak_ptr.
Es ist das bevorzugte Vergleichsprädikat beim Erstellen von assoziativen Containern mit std::weak_ptr als Schlüssel, d. h. std::map<std::weak_ptr<T>, U, std::owner_less<std::weak_ptr<T>>>.
4) Die void-Spezialisierung leitet die Parametertypen aus den Argumenten ab.

Der Standard operator< ist für schwache Zeiger nicht definiert und kann fälschlicherweise zwei geteilte Zeiger auf dasselbe Objekt als nicht-äquivalent betrachten (siehe std::shared_ptr::owner_before).

Inhalt

Spezialisierungen

Die Standardbibliothek stellt eine Spezialisierung von std::owner_less bereit, wenn T nicht angegeben ist. In diesem Fall werden die Parametertypen aus den Argumenten abgeleitet (jedes davon muss immer noch entweder ein std::shared_ptr oder ein std::weak_ptr sein).

 Funktions-Objekt, das gemischtes inhaltsbasiertes Ordering von geteilten und schwachen Zeigern bereitstellt, unabhängig vom Typ des Zielobjekts.
(Klassenvorlagenspezialisierung) [bearbeiten]
 (seit C++17)


Verschachtelte Typen

Verschachtelter Typ Definition
result_type (in C++17 veraltet) (2,3) bool
first_argument_type (in C++17 veraltet) (2) std::shared_ptr<T>
(3) std::weak_ptr<T>
second_argument_type (in C++17 veraltet) (2) std::shared_ptr<T>
(3) std::weak_ptr<T>
 (bis C++20)

[bearbeiten] Memberfunktionen

operator()
 vergleicht seine Argumente anhand von inhaltsbasierten Semantiken
(Funktion)

std::owner_less::operator()

nur Mitglied der Spezialisierung (2)
bool operator()( const std::shared_ptr<T>& lhs,
                 const std::shared_ptr<T>& rhs ) const noexcept;
 (seit C++11)
nur Mitglied der Spezialisierung (3)
bool operator()( const std::weak_ptr<T>& lhs,
                 const std::weak_ptr<T>& rhs ) const noexcept;
 (seit C++11)
Mitglied beider Vorlagenspezialisierungen
bool operator()( const std::shared_ptr<T>& lhs,
                 const std::weak_ptr<T>& rhs ) const noexcept;
 (seit C++11)
bool operator()( const std::weak_ptr<T>& lhs,
                 const std::shared_ptr<T>& rhs ) const noexcept;
 (seit C++11)

Vergleicht lhs und rhs mit inhaltsbasierter Semantik. Ruft effektiv lhs.owner_before(rhs) auf.

Die Ordnung ist eine strikte schwache Ordnungsrelation.

lhs und rhs sind nur dann äquivalent, wenn sie beide leer sind oder sich den Besitz teilen.

Parameter

lhs, rhs - geteilte Besitzzeiger zum Vergleichen

Rückgabewert

true, wenn lhs kleiner ist als rhs gemäß der inhaltsbasierten Ordnung, andernfalls false.

[bearbeiten] Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 2873 C++11 operator() war nicht als noexcept gefordert musste noexcept sein

[bearbeiten] Siehe auch

 bietet inhaltsbasiertes Ordering von geteilten Zeigern
(öffentliche Memberfunktion von std::shared_ptr<T>) [bearbeiten]
 bietet inhaltsbasiertes Ordering von schwachen Zeigern
(öffentliche Memberfunktion von std::weak_ptr<T>) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/memory/owner_less&oldid=164269"