Можно ли наследовать интеллектуальные указатели C ++ 11 и переопределять относительные операторы?

В общем, наследование от чего-либо, чей деструктор не является динамическим, небезопасно. Это может быть и делается обычным образом, вам просто нужно быть очень осторожным. Вместо наследования указателей я бы просто использовал композицию, тем более что количество членов относительно невелико. Возможно, вы сможете создать для этого шаблонный класс

template<class pointer_type>
class relative_ptr {
public:
    typedef typename std::pointer_traits<pointer_type>::pointer pointer;
    typedef typename std::pointer_traits<pointer_type>::element_type element_type;
    relative_ptr():ptr() {}
    template<class U>
    relative_ptr(U&& u):ptr(std::forward<U>(u)) {}
    relative_ptr(relative_ptr<pointer>&& rhs):ptr(std::move(rhs.ptr)) {}
    relative_ptr(const relative_ptr<pointer>& rhs):ptr(std::move(rhs.ptr)) {}

    void swap (relative_ptr<pointer>& rhs) {ptr.swap(rhs.ptr);}
    pointer release() {return ptr.release();}
    void reset(pointer p = pointer()) {ptr.reset(p);}
    pointer get() const {return ptr.get();}
    element_type& operator*() const {return *ptr;}
    const pointer_type& operator->() const {return ptr;}

    friend bool operator< (const relative_ptr& khs, const relative_ptr& rhs) const 
    {return std::less<element>(*lhs,*rhs);}
    friend bool operator<=(const relative_ptr& khs, const relative_ptr& rhs) const 
    {return std::less_equal<element>(*lhs,*rhs);}
    friend bool operator> (const relative_ptr& khs, const relative_ptr& rhs) const 
    {return std::greater<element>(*lhs,*rhs);}
    friend bool operator>=(const relative_ptr& khs, const relative_ptr& rhs) const 
    {return std::greater_equal<element>(*lhs,*rhs);}
    friend bool operator==(const relative_ptr& khs, const relative_ptr& rhs) const 
    {return *lhs==*rhs;}
    friend bool operator!=(const relative_ptr& khs, const relative_ptr& rhs) const 
    {return *lhs!=*rhs;}
protected:
    pointer_type ptr;
};

Очевидно, что простота оболочки сводит вас к наименьшему общему знаменателю для интеллектуальных указателей, но что угодно. Они не совсем сложные, вы можете сделать по одному для каждого класса интеллектуальных указателей.

Я сделаю предупреждение, что мне не нравится, как работает ==, поскольку он может возвращать истину для двух указателей на разные объекты. Но как бы там ни было. Я также не тестировал код, он может не работать при выполнении определенных задач, например при попытке копирования, если он содержит unique_ptr.

Во-первых, как уже отмечали другие, наследование - это не лучший вариант. Но вместо запутанной оболочки, предложенной принятым ответом, я бы сделал что-то гораздо более простое: реализуйте свой собственный компаратор для своих собственных типов:

namespace myns {
struct mytype {
   int value;
};
bool operator<( mytype const& lhs, mytype const& rhs ) {
   return lhs.value < rhs.value;
}
bool operator<( std::shared_ptr<mytype> const & lhs, std::shared_ptr<mytype> const & rhs )
{
   // Handle the possibility that the pointers might be NULL!!!
   // ... then ...
   return *lhs < *rhs;
}
}

Магия, которая на самом деле не является магией, - это поиск, зависящий от аргумента (также известный как поиск по Кенингу или ADL). Когда компилятор встречает вызов функции, он добавляет пространство имен аргументов для поиска. Если объекты являются экземпляром шаблона, то компилятор также добавит пространства имен типов, используемых для создания экземпляра шаблона. Так в:

int main() {
   std::shared_ptr<myns::mytype> a, b;
   if ( a < b ) {                       // [1]
      std::cout << "less\n";
   } else {
      std::cout << "more\n";
   }
}

В [1], и поскольку a и b являются объектами определяемыми пользователем типами ^(*), сработает ADL, и он добавит и std, и myns в набор поиска. Затем он найдет стандартное определение operator< для std::shared_ptr, а именно:

template<class T, class U>
bool std::operator<(shared_ptr<T> const& a, shared_ptr<U> const& b) noexcept;

И он также добавит myns и добавит:

bool myns::operator<( mytype const& lhs, mytype const& rhs );

Затем, после завершения поиска, срабатывает разрешение перегрузки, и оно определяет, что myns::operator< лучше соответствует, чем std::operator< для вызова, поскольку это идеальное совпадение, и в этом случае предпочтение отдается не шаблонам. Затем он вызовет ваш собственный operator< вместо стандартного.

Это становится немного более запутанным, если ваш тип на самом деле является шаблоном, если это так, оставьте комментарий, и я расширю ответ.

^(*) Это небольшое упрощение. Поскольку operator< может быть реализован как функция-член или как бесплатная функция, компилятор будет проверять внутри std::shared_ptr<> член operator< (отсутствует в стандарте) и друзей. Он также будет искать friend функции внутри mytype ... и так далее. Но в итоге найдет нужный.

Наследование от любого класса, поддерживающего присваивание и копирование, опасно из-за риска разрезания экземпляра производного класса пополам из-за случайного присвоения его переменной базового класса. Это влияет на большинство классов и практически невозможно предотвратить, что требует бдительности со стороны пользователей класса всякий раз, когда они копируют экземпляры.

Из-за этого классы, предназначенные для работы в качестве баз, обычно не должны поддерживать копирование. Когда необходимо копирование, вместо этого они должны предоставить что-то вроде Derived* clone() const override.

Проблему, которую вы пытаетесь решить, вероятно, лучше всего решить, оставив все как есть и предоставив настраиваемые компараторы при работе с такими указателями.

std::vector<std::shared_ptr<int>> ii = …;
std::sort(begin(ii), end(ii),
          [](const std::shared_ptr<int>& a, const std::shared_ptr<int>& b) {
              return *a < *b;
          });