Question

根据cppreference.com，std::shared_ptr提供了一整套相对运算符（==，！=，＆lt;，...），但未指定比较的语义。我假设他们将底层原始指针与引用的对象进行比较，并且std :: weak_ptr和std :: unique_ptr也是如此。

出于某些目的，我更愿意让相对运算符根据比较引用的对象（而不是指向它们的指针）来对智能指针进行排序。这已经是我做了很多事情，但是我自己的“哑指针”除了相对运算符之外，其行为大部分都像原始指针。我也想用标准的C ++ 11智能指针做同样的事情。所以......

从C ++ 11智能指针（shared_ptr，weak_ptr和unique_ptr）继承并覆盖相对运算符是否可以？
我需要注意哪些偷偷摸摸的问题？例如，我需要实现或使用using来确保其正常工作吗？
对于最终的懒惰，是否有可以自动为我执行此操作的库模板？

我希望这是“当然你可以做到这一点，白痴！”有点事情，但我有点不确定，因为标准库中有一些类（至少像std::map这样的容器），你不应该继承它们。

Answer 1

首先，正如其他人已经指出的那样，继承不是可行的方法。但是，不是接受的答案建议的复杂的包装器，我会做一些更简单的事情：为你自己的类型实现你自己的比较器：

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

magic ，根本不是魔术，是Argument Dependent Lookup（又名.Koening Lookup或ADL）。当编译器遇到函数调用时，它会将参数的名称空间添加到lookup中。如果对象是模板的实例化，则编译器还将添加用于实例化模板的类型的名称空间。所以在：

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<（标准中不存在）和朋友。对于mytype函数，它也会在friend内查找......依此类推。但最后它会找到合适的。

Answer 2

一般来说，继承任何析构函数不动态的东西是不安全的。它可以并且通常完成，你只需要非常小心。我只使用合成，而不是继承指针，特别是因为成员数量相对较少。您可以为此

创建模板类

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时尝试复制。

Answer 3

从任何支持赋值和复制构造的类继承是危险的，因为可能会将派生类实例意外地分配给基类变量，从而将派生类实例减半。这会影响大多数课程，并且几乎不可能防止，因此在课程用户复制实例时需要警惕。

因此，用作基础的类通常不应支持复制。当需要复制时，他们应该提供类似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;
          });

从C ++ 11智能指针继承并覆盖相对运算符是否可以？

3 个答案: