自定义智能指针和比较运算符的多项式数

Question

假设我想实现一个智能指针 a_ptr ，它可以与其他智能指针进行比较。

然后我需要为其余的运算符实现比较运算符的所有排列：

template<class T, class U>
bool operator==(const a_ptr<T>& a, const a_ptr<U>& b)
{
    return a.get() == b.get();
}

template<class T, class U>
bool operator==(const std::shared_ptr<T>& a, const a_ptr<U>& b)
{
    return a.get() == b.get();
}

template<class T, class U>
bool operator==(const a_ptr<T>& a, const std::shared_ptr<U>& b)
{
    return a.get() == b.get();
} 

等等。

那么也许我想实现另一个智能指针 b_ptr，这将为每个比较运算符提供 6 个版本（因为我希望它也可以与 a_ptr 一起使用），显然不是易于管理。

有什么办法可以解决这个问题吗？

编辑：

我应该提到我想围绕智能指针创建包装器，在这种情况下这个问题更有意义，例如

template<typename T>
class a_ptr
{
public:
    const T* get() const {return p_.get();}
private:
    std::shared_ptr<T> p_;
};

template<typename T>
class b_ptr
{
public:
    const T* get() const {return p_.get();}
private:
    a_ptr<T> p_;
};

Answer 1

如果其中任何一个（除了比较两个 a_ptr 的那个）成立，那么您的程序就有错误。所以，就扔掉它吧。智能指针之所以聪明，是因为它负责管理其背后的内存。而且你不能让两个不同的智能指针来管理一块内存。

考虑unique_ptr 和shared_ptr。一旦拥有的智能指针被销毁，指针就会被销毁。仅当所有拥有的智能指针都被销毁时，第二个才会销毁指针。我认为很明显它会很快导致双重删除和其他有趣的事情。

Answer 2

本·沃伊特（Ben Voigt）走在正确的道路上——当然，除了我们没有概念。

template<
    typename Lhs
    , typename Rhs
    , typename = typename std::enable_if<
        /* magic */
    >::type
>
bool
operator==(Lhs const& lhs, Rhs const& rhs)
{
    return lhs.get() == rhs.get();
}

它必须位于 a_ptr 和 b_ptr 的同一命名空间中，以便 ADL 启动（因此，如果它们位于不同的命名空间中，则每个命名空间需要每个运算符的一个版本）。

魔法特性有多种发挥作用的可能性。从概念上讲，最简单的一个是拥有一个专门针对您关心的每种指针类型的特征：

template<typename T>
struct is_smart_pointer: std::false_type {};

template<typename T, typename D>
struct is_smart_pointer<std::unique_ptr<T, D>>: std::true_type {};
// and so on...

更复杂的特征将检查该类型是否支持 get 成员。实际上，我们不需要为此提供特质！

template<typename Lhs, typename Rhs>
auto operator==(Lhs const& lhs, Rhs const& rhs)
-> decltype( lhs.get() == rhs.get() )
{
    return lhs.get() == rhs.get();
}

这个简单的运算符将被 ADL 选取，但如果其中一种类型不支持 get，或者比较不起作用，则 SFINAE 本身会被排除。

Answer 3

怎么样：

template<typename T> struct you_need_a_pointer_to_do_that{} unwrap_ptr(const T&);

template<typename U> U* unwrap_ptr(U* p) { return p; }

template<typename U> U* unwrap_ptr(const a_ptr<U>& p) { return p.get(); }

template<typename U> U* unwrap_ptr(const unique_ptr<U>& p) { return p.get(); }

...

template<typename T, typename PU> auto operator<(const a_ptr<T>& a, const PU& b) -> decltype(unwrap_ptr(a) < unwrap_ptr(b)) { return unwrap_ptr(a) < unwrap_ptr(b); }

由于 SFINAE，decltype 位拒绝非指针。 unwrap_ptr 帮助器使指针访问的语法同质化，其复杂性仅与指针类型的数量成线性关系。

Answer 4

您可以只标记智能指针类型，然后实现一个通用版本，该版本至少依赖于要标记的传递参数之一：

template <typename T> struct is_my_smartpointer: std::false_type {};
template <typename T> struct is_my_smartpointer<a_ptr<T> >: std::true_type {};

template <typename S, typename T>
typename std::enable_if<is_my_smartpointer<S>::value || is_my_smartpointer<T>::value, bool>::type
operator== (S const& s, T const& t) {
    return s.get() == t.get();
}

Answer 5

您可以从现有智能指针继承自定义智能指针。这样您就根本不需要实现任何运算符。
也正如猫加加所说。您不能有两个智能指针管理一块内存。因此，如果您正在实现智能指针，您应该确保这是正确的。您应该将 operator= 设为私有，这样就无法将其复制到其他位置。

Answer 6

它可能与为智能指针编写 sfinae 特征一样困难。一旦你得到它，解决方案就非常简单了，你不需要 c++11：

#include <memory>
#include <type_traits>
#include <iostream>

namespace my {
template<class T>
class a_ptr
{
   T* t_;
public:
   typedef T element_type;
   element_type* get() const throw() { return t_; }
};

template<class T> class is_smart_ptr; // sfinae test for T::get()?

template<class T, class U>
typename std::enable_if<
   is_smart_ptr<T>::value &&
   is_smart_ptr<U>::value,
   bool
>::type
operator==(const T& a, const U& b)
{
    return a.get() == b.get();
}
}

int main()
{
   my::a_ptr<int> a;
   std::shared_ptr<int> b;
   a == b;
}

并且由于 std::shared_ptr 已经有运算符 ==，你需要将比较运算符放在同一个命名空间中，其中您的智能指针类型是。