NAME¶

std::weak_ptr::owner_before - std::weak_ptr::owner_before

Synopsis¶

template< class Y >
bool owner_before( const weak_ptr<Y>& other ) const noexcept;
template< class Y >
bool owner_before( const std::shared_ptr<Y>& other ) const noexcept;

Checks whether this weak_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¶

// Run this code

#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';
}

Output:¶

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

Defect reports

The following behavior-changing defect reports were applied retroactively to
previously published C++ standards.

DR Applied to Behavior as published Correct behavior
LWG 2083 C++11 owner_before was not declared const declared const
LWG 2942 C++11 owner_before was not declared noexcept declared noexcept

See also¶

owner_less provides mixed-type owner-based ordering of shared and weak pointers
(C++11) (class template)