C++

参考

<memory>

类模板
<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>>;
基于所有者的less比较操作
此类定义了函数对象，它们对 shared_ptr 和/或 weak_ptr 对象执行基于所有者的比较。

这是 less（或 operator<）的替代品，用于对这些类型进行排序，当排序需要基于它们的所拥有的指针而不是它们的存储的指针（这是 operator< 比较的内容）时使用。

一个 shared_ptr 对象的存储的指针（即，它 解引用到的指针）可能与其所拥有的指针（即，在对象销毁时被删除的指针）不同，如果该 shared_ptr 对象是一个别名（由别名构造的对象及其副本）。

由...执行的比较owner_less::operator()依赖于 shared_ptr 或 weak_ptr 的成员函数 owner_before。owner_less定义了一个接口，该接口模仿了 binary_function，并带有额外的重载。其实现行为与
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);}
};


模板参数

Ptr
被管理的指针的类型，根据所拥有的资源进行排序，并作为成员类型别名first_argument_type和second_argument_type.
T
被管理的指针类型所指向的对象的类型。

成员类型

以下别名是owner_less.

成员类型定义说明
result_typebool操作的结果
first_argument_typePtr第一个参数的类型
second_argument_typePtr第二个参数的类型

成员函数

operator()
返回值true如果第一个参数在基于其所拥有的指针的严格弱序中被认为在第二个参数之前。
该函数使用 shared_ptr::owner_before 和/或 weak_ptr::owner_before 来确定此顺序。

示例

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

输出
value_based.size() is 2
owner_based.size() is 1


另见

shared_ptr::owner_before
基于所有者的排序 (public member function template)
weak_ptr::owner_before
基于所有者的排序 (public member function template)