从C++11智能指针继承并重写相关运算符可以吗？

提问者：小点点

从C++11智能指针继承并重写相关运算符可以吗？

根据CPPreference.com，提供了一组完整的相对运算符(==，！=，<；，。。。），但没有指定比较的语义。我假设它们将底层的原始指针与被引用的对象进行比较，并且std::weak_ptr和std::unique_ptr也是这样做的。

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

有什么我需要注意的秘密问题吗？例如，有没有其他方法我需要实现或使用来确保事情正常工作？

对于懒惰的终极，有没有一个库模板可以自动为我做这件事？

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

共3个答案

匿名用户

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

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查找或ADL）。当编译器遇到函数调用时，它会将参数的命名空间添加到查找中。如果对象是模板的实例化，那么编译器还将添加用于实例化模板的类型的命名空间。所以在:

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

在[1]中，由于和是用户定义类型ADL将开始使用，并将和添加到查找集中。然后，它将找到的的标准定义，即:

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

并且它还将添加并添加:

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

然后，在查找完成后，重载解析开始执行，它将确定比更适合调用，因为它是完美匹配，在这种情况下，非模板会优先选择。然后它将调用您自己的，而不是标准的。

如果您的类型实际上是一个模板，这就变得有点复杂了，如果是，删除一个注释，我将扩展答案。

这是一个轻微的简化。因为既可以作为成员函数实现，也可以作为自由函数实现，所以编译器将在内部检查成员（标准中不存在）和朋友。它还将查看内部的函数。等等。但最终它会找到合适的。

匿名用户

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

正因为如此，打算充当基地的类通常不应该支持复制。当需要复制时，它们应该提供类似的内容。

您试图解决的问题最好的解决办法可能是保持原样，并在使用此类指针时提供自定义比较器。

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个答案

相关问题