20

根据cppreference.com，std::shared_ptr提供了一整套相对运算符（==、!=、<、...），但没有指定比较的语义。我假设他们将底层原始指针与引用的对象进行比较，并且 std::weak_ptr 和 std::unique_ptr 也这样做。

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

  1. 从 C++11 智能指针（shared_ptr、weak_ptr 和 unique_ptr）继承并覆盖相对运算符是否可以？

  2. 有什么我需要注意的偷偷摸摸的问题吗？例如，我需要实施或使用任何其他方法using来确保一切正常吗？

  3. 对于最终的懒惰，是否有可用的库模板可以自动为我执行此操作？

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

4

3 回答 3

11

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

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

魔术，这根本不是魔术，是 Argument Dependent Lookup（又名 Koening Lookup 或 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<for的标准定义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功能......等等。但最终它会找到正确的。

于 2012-09-22T02:39:30.883 回答
9

一般来说，从析构函数不是动态的东西继承是不安全的。它可以并且经常进行，您只需要非常小心。我不会从指针继承，而是使用组合，特别是因为成员的数量相对较少。您也许可以为此创建一个模板类

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

于 2012-09-22T00:14:18.020 回答
4

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

因此，旨在用作基础的类通常不应该支持复制。当需要复制时，他们应该提供类似的东西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;
          });
于 2012-09-22T01:35:42.140 回答