根据 cppreference.com，std::shared_ptr提供了一整套相对运算符(==，！=，<，...)，但没有指定比较的语义。我假设他们将底层原始指针与引用的对象进行比较，并且 std：：weak_ptr 和 std：：unique_ptr 也这样做。
出于某些目的，我更喜欢使用相对运算符，这些运算符根据比较引用的对象(而不是指向它们的指针)对智能指针进行排序。这已经是我经常做的事情，但是使用我自己的"哑指针"，除了相对运算符之外，它们的行为大多类似于原始指针。我也想用标准的 C++11 智能指针做同样的事情。所以。。。
-
是否可以从 C++11 智能指针(shared_ptr、weak_ptr 和 unique_ptr)继承并覆盖相对运算符？
-
有什么需要注意的偷偷摸摸的问题吗？例如，我是否需要实现或使用
using来确保一切正常运行的任何其他方法？ -
为了最终的懒惰，是否有可用的库模板可以自动为我执行此操作？
我希望这是一个"你当然可以做到，白痴！"之类的事情，但我有点不确定，因为标准库中有一些类(至少像std::map这样的容器)不应该从中继承。
一般来说，从任何析构函数不是动态的东西继承都是不安全的。它可以并且通常完成，您只需要非常小心。 我不会从指针继承，而是只使用组合，特别是因为成员的数量相对较少。 您也许可以为此创建一个模板类
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;
};
显然，包装器的简单性将您降低到智能指针的最低公分母，但无论如何。 它们并不复杂，您可以为每个智能指针类创建一个。
我将提供一个警告，指出我不喜欢==的工作方式，因为它可能会为指向不同对象的两个指针返回 true。 但无论如何。 我也没有测试过代码，它可能会在某些任务中失败，例如在包含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;
}
}
魔术，根本不是真正的魔术是参数依赖查找(又名。Koening Lookup 或 ADL)。当编译器遇到函数调用时，它将添加要查找的参数的命名空间。如果对象是模板的实例化，则编译器还将添加用于实例化模板的类型的命名空间。所以在：
int main() {
std::shared_ptr<myns::mytype> a, b;
if ( a < b ) { // [1]
std::cout << "lessn";
} else {
std::cout << "moren";
}
}
在 [1] 中，由于a和b是用户定义的对象类型(*)，ADL 将启动，它将std和myns添加到查找集中。然后，它将找到std::shared_ptroperator<的标准定义，即：
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<(标准中不存在)和友元。它还将在mytype内部查看friend功能......等等。但最后它会找到合适的。
从任何支持赋值和复制构造的类继承都是危险的，因为存在将派生类实例意外分配给基类变量而将其切成两半的风险。这会影响大多数类，并且几乎不可能阻止，因此每当类的用户复制实例时，都需要保持警惕。
因此，旨在用作基的类通常不应支持复制。当需要复制时，他们应该提供类似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;
});