std::weak_ptr<T>::owner_before
template< class Y > bool owner_before( const weak_ptr<Y>& other) const; | (until C++17) | |
template< class Y > bool owner_before( const weak_ptr<Y>& other) const noexcept; | (since C++17) | |
template< class Y > bool owner_before( const std::shared_ptr<Y>& other) const; | (until C++17) | |
template< class Y > bool owner_before( const std::shared_ptr<Y>& other) const noexcept; | (since C++17) |
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.
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 2942 | C++17 | weak_ptr::owner_before isn't noexcept while its shared_ptr counterpart is | made noexcept |
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';
}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
See also
|
(C++11) | provides mixed-type owner-based ordering of shared and weak pointers (class template) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/memory/weak_ptr/owner_before