class template
<memory>
std::owner_less
template <class Ptr> struct owner_less;
template <class T> struct owner_less<shared_ptr<T>>;
template <class T> struct owner_less<weak_ptr<T>>;
Owner-based less-than operation
This class defines function objects that perform an owner-based comparison between shared_ptr and/or weak_ptr objects.
This is a replacement for less (or operator<) to be used for these types when sorting needs to be based on their owned pointer instead of their stored pointer (which is what is compared by operator<).
The stored pointer of a shared_ptr object (i.e., the pointer it dereferences to) may be different from the owned pointer (i.e., the pointer deleted on object destruction) if the shared_ptr object is an alias (alias-constructed objects and their copies).
The comparison performed by owner_less::operator() relies on member function owner_before of either shared_ptr or weak_ptr. owner_less is defined with an interface that mimics a binary_function, but with additional overloads. It is implemented with the same behavior as:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
template<class P> struct owner_less; // not defined
template<class T> struct owner_less <shared_ptr<T>>
{
typedef bool result_type;
typedef shared_ptr<T> first_argument_type;
typedef shared_ptr<T> second_argument_type;
bool operator() (const shared_ptr<T>& x, const shared_ptr<T>& y) const {return x.owner_before(y);}
bool operator() (const shared_ptr<T>& x, const weak_ptr<T>& y) const {return x.owner_before(y);}
bool operator() (const weak_ptr<T>& x, const shared_ptr<T>& y) const {return x.owner_before(y);}
};
template<class T> struct owner_less <weak_ptr<T>>
{
typedef bool result_type;
typedef weak_ptr<T> first_argument_type;
typedef weak_ptr<T> second_argument_type;
bool operator() (const weak_ptr<T>& x, const weak_ptr<T>& y) const {return x.owner_before(y);}
bool operator() (const shared_ptr<T>& x, const weak_ptr<T>& y) const {return x.owner_before(y);}
bool operator() (const weak_ptr<T>& x, const shared_ptr<T>& y) const {return x.owner_before(y);}
};
| |
Template parameters
- Ptr
- The type of the managed pointers to be ordered according to owned resource, aliased as member types first_argument_type and second_argument_type.
- T
- The type of object pointed by the managed pointer type.
Member types
The following aliases are member types of owner_less.
| member type | definition | notes |
|---|
| result_type | bool | The result of the operation |
| first_argument_type | Ptr | The type of the first argument |
| second_argument_type | Ptr | The type of the second argument |
Member functions
- operator()
- Returns true if the first argument is considered to go before the second argument in a strict weak ordering based on their owned pointers.
The function uses shared_ptr::owner_before and/or weak_ptr::owner_before to determine this order.
Example
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
// owner_less example
#include <iostream>
#include <memory>
#include <set>
int main ()
{
int * p = new int (10);
std::shared_ptr<int> a (new int (20));
std::shared_ptr<int> b (a,p); // alias constructor: co-owns a, points to p
// standard set container: cannot contain duplicates.
std::set < std::shared_ptr<int> > value_based; // uses std::less
std::set < std::shared_ptr<int>, std::owner_less<std::shared_ptr<int>> > owner_based;
value_based.insert (a);
value_based.insert (b); // ok, different value
owner_based.insert (a);
owner_based.insert (b); // overwrites (same owned pointer)
std::cout << "value_based.size() is " << value_based.size() << '\n';
std::cout << "owner_based.size() is " << owner_based.size() << '\n';
delete p;
return 0;
}
| |
Output:
value_based.size() is 2
owner_based.size() is 1
|