unique_ptr 向量的取消引用包装？

Question

我最近遇到了这个article；它提供了 boost 的 indirect_iterator 的基本实现，但适用于 unique_ptr 迭代器。我决定稍微调整一下文章中的示例，以便可以将其用于类成员之外的向量：

template <typename T>
using SPN = std::unique_ptr<Node<T>>;

template <class BaseIterator>
struct DReferenceIterator : BaseIterator
{
  explicit DReferenceIterator(const BaseIterator & other) : BaseIterator(other) {}
  auto & operator*() const { return *(this->BaseIterator::operator*()); }
  auto * operator->() const { return this->BaseIterator::operator*().get(); }
  auto & operator[](size_t n) const { return *(this->BaseIterator::operator[](n)); }
};

template<typename T>
auto begin_t(std::vector<SPN<T>> & v) 
{
  return DReferenceIterator<typename std::vector<SPN<T>>::iterator>(v.begin());
}

template<typename T>
auto end_t(std::vector<SPN<T>> & v) 
{
  return DReferenceIterator<typename std::vector<SPN<T>>::iterator>(v.end());
}

我可以毫无问题地使用std::find(begin_t(v), end_t(v), value)。但是，如果我尝试拨打std::sort(begin_t(v), end_t(v))，它根本不起作用。我确实在Node<T> 类中提供了operator<() 的实现，但由于某种原因，我的代码无法编译。我得到的编译错误非常广泛且难以阅读，但是，我设法提取了一些我认为导致问题的东西：

二进制=：未找到采用std::unique_ptr<Node<float>,std::default_delete<_Ty>> 类型右侧操作数的运算符（或没有可接受的转换）

此消息是否意味着std::sort() 正在尝试复制unique_ptr？在这种情况下，这是否意味着 DReferenceIterator 包装器无法按预期工作？我对 C++ 还很陌生，所以如果不是这种情况，请帮助我了解问题到底出在哪里。

Answer 1

您的DReferenceIterator 向标准库谎报它所公开的内容。这会导致您在尝试 std::sort 时看到的错误。

通过从 BaseIterator 派生，您将继承以下（以及其他）BaseIterator::value_type、BaseIterator::pointer 和 BaseIterator::reference，它们与您的 operators 的返回类型不匹配。

正确的实现应该更像

template <class BaseIterator>
struct DReferenceIterator
{
  using value_type = BaseIterator::value_type::element_type;
  using reference = value_type &;
  using pointer = value_type *;
  using difference_type = BaseIterator::difference_type
  using iterator_category = BaseIterator::iterator_category;

  explicit DReferenceIterator(const BaseIterator & other) : other(other) {}

  reference operator*() const { return **other; }
  pointer   operator->() const { return (*other).get(); }
  reference operator[](size_t n) const { return (*other)[n]; }

  DReferenceIterator& operator++() { ++other; return *this; }
  DReferenceIterator& operator--() { --other; return *this; }

  DReferenceIterator& operator+=(difference_type n) { other += n; return *this; }
  DReferenceIterator& operator-=(difference_type n) { other -= n; return *this; }
  difference_type operator-(DReferenceIterator& rhs) { return other - rhs.other; }
  bool operator<(DReferenceIterator& rhs) { return other < rhs.other; }

  // And all the other operators, in terms of those      

private: 
  BaseIterator other;
};