std::shared_ptr<T>::owner_before
Declarations
template< class Y >
bool owner_before( const shared_ptr<Y>& other ) const noexcept;
template< class Y >
bool owner_before( const std::weak_ptr<Y>& other ) const noexcept;
Checks whether this shared_ptr
precedes other in implementation defined owner-based (as opposed to value-based) order.
The order is such that two smart pointers compare equivalent only if they are both empty or if they both own the same object,
even if the values of the pointers obtained by get()
are different (e.g. because they point at different subobjects within the same object)
This ordering is used to make shared and weak pointers usable as keys in associative containers, typically through std::owner_less
.
Parameters
other
- the std::shared_ptr
or std::weak_ptr
to be compared
Return value
true
if *this
precedes other
, false
otherwise. Common implementations compare the addresses of the control blocks.
Example
#include <iostream>
#include <memory>
struct Foo {
int n1;
int n2;
Foo(int a, int b) : n1(a), n2(b) {}
};
int main()
{
auto p1 = std::make_shared<Foo>(1, 2);
std::shared_ptr<int> p2(p1, &p1->n1);
std::shared_ptr<int> p3(p1, &p1->n2);
std::cout
<< std::boolalpha
<< "p2 < p3 "
<< (p2 < p3) << '\n'
<< "p3 < p2 "
<< (p3 < p2) << '\n'
<< "p2.owner_before(p3) "
<< p2.owner_before(p3) << '\n'
<< "p3.owner_before(p2) "
<< p3.owner_before(p2) << '\n';
std::weak_ptr<int> w2(p2);
std::weak_ptr<int> w3(p3);
std::cout
// << "w2 < w3 " << (w2 < w3) << '\n' // won't compile
// << "w3 < w2 " << (w3 < w2) << '\n' // won't compile
<< "w2.owner_before(w3) "
<< w2.owner_before(w3) << '\n'
<< "w3.owner_before(w2) "
<< w3.owner_before(w2) << '\n';
}
p2 < p3 true
p3 < p2 false
p2.owner_before(p3) false
p3.owner_before(p2) false
w2.owner_before(w3) false
w3.owner_before(w2) false