Dereference wrapper for vector of unique_ptr? - c++11

Question

I recently came across this article; which provides a basic implementation of boost's indirect_iterator but for unique_ptr iterators. I decided to tweak the example in the article a little, so that I could use it for vectors outside class members:
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());
}
I can use std::find(begin_t(v), end_t(v), value) with no problems at all. However, if I try to call std::sort(begin_t(v), end_t(v)) it does not work at all. I did provide an implemention of operator<() in the Node<T> class, but for some reason my code does not compile. The compile error that I get is very extensive and hard to read, however, I managed to extract something that I think is causing the problem:
binary =: no operator found which takes a right-hand operand of type std::unique_ptr<Node<float>,std::default_delete<_Ty>> (or there is no acceptable conversion)
Does this message mean that std::sort() is trying to copy unique_ptr? In which case, does this mean that the DReferenceIterator wrapper does not work as intended? I'm fairly new to C++, so if this is not the case, please help me understand what exactly the problem is.

Answer 1

Your DReferenceIterator is lying to the standard library as to what it is exposing. This is causing the errors you see trying to std::sort through it.
By deriving from BaseIterator, you are inheriting the following (among others) BaseIterator::value_type, BaseIterator::pointer and BaseIterator::reference, which don't match the return types of your operators.
A correct implementation would be more like
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;
};