标准说明了以下关于从标准库中专门化模板的内容(通过 What can and can't I specialize in the std namespace? )

A program may add a template specialization for any standard library template to namespace std only if the declaration depends on a user-defined type and the specialization meets the standard library requirements for the original template and is not explicitly prohibited.

使用专门用于用户定义类的标准库类来专门化标准库模板是否合法？

例如，专门化 std::hash对于 std::shared_ptr<MyType> ？

从阅读上面的段落和链接的问题来看，听起来应该是这样，因为特化声明依赖于 MyType。 ，但是“除非明确禁止”让我有点担心。

下面的示例编译并按预期工作(AppleClang 7.3)，但它合法吗？

#include <unordered_set>
#include <memory>
#include <cassert>
#include <string>

struct MyType {
    MyType(std::string id) : id(id) {}
    std::string id;
};

namespace std {
    template<>
    struct hash<shared_ptr<MyType>> {
        size_t operator()(shared_ptr<MyType> const& mine) const {
            return hash<string>()(mine->id);
        }
    };

    template<>
    struct equal_to<shared_ptr<MyType>> {
        bool operator()(shared_ptr<MyType> const& lhs, shared_ptr<MyType> const& rhs ) const {
            return lhs->id == rhs->id;
        }
    };
}

int main() {
    std::unordered_set<std::shared_ptr<MyType>> mySet;
    auto resultA = mySet.emplace(std::make_shared<MyType>("A"));
    auto resultB = mySet.emplace(std::make_shared<MyType>("B"));
    auto resultA2 = mySet.emplace(std::make_shared<MyType>("A"));
    assert(resultA.second);
    assert(resultB.second);
    assert(!resultA2.second);
}

最佳答案

是的，这是合法的。

专攻 std::shared_ptr<int> 的合法性甚至值得怀疑在一个点上;我不知道他们是否将标准中的歧义修补为缺陷。

请注意，这是一个糟糕的全局哈希实现。首先，因为它不支持空共享指针。其次，因为一如既往地对共享指针进行哈希处理，int 值是有问题的。这甚至是危险的，因为如果指向容器中 int 的共享指针发生了 int 更改，那么您就破坏了程序。

考虑为这类情况制作自己的哈希器。

namespace notstd {
  template<class T, class=void>
  struct hasher_impl:std::hash<T>{};

  namespace adl_helper {
    template<class T>
    std::size_t hash( T const& t, ... ) {
      return ::notstd::hasher_impl<T>{}(t);
    }
  };
  namespace adl_helper2 {
    template<class T>
    std::size_t hash_helper(T const& t) {
      using ::notstd::adl_helper::hash;
      return hash(t);
    }
  }
  template<class T>
  std::size_t hash(T const& t) {
    return ::notstd::adl_helper2::hash_helper(t);
  }

  struct hasher {
    template<class T>
    std::size_t operator()(T const& t)const {
      return hash(t);
    }
  };

}

现在这允许 3 个自定义点。

首先，如果您覆盖 std::size_t hash(T const&)在包含 T 的命名空间中, 它把它捡起来。

否则，如果你专攻 notstd::hasher_impl<T, void>适合您的类型 T , 它把它捡起来。

第三，如果这两个都失败了，它会调用 std::hash<T> , 选择任何专业。

然后你可以这样做:

std::unordered_set<std::shared_ptr<MyType>, ::notstd::hasher> mySet;

并添加:

struct MyType {
  MyType(std::string id) : id(id) {}
  std::string id;
  friend std::size_t hash( MyType const& self) {
    return ::notstd::hash(self.id);
  }
  friend std::size_t hash( std::shared_ptr<MyType> const& self) {
    if (!self) return 0;
    return ::notstd::hash(*self);
  }
};

这应该给你一个关于 shared_ptr<MyType> 的智能哈希.

这保持了有人改变的危险id在 shared_ptr<MyType> 上这会破坏包含 shared_ptr<MyType> 的每个容器以非本地方式。

共享状态是魔鬼；如果您真的担心复制这些东西很昂贵，请考虑在写指针上写一个拷贝。

关于c++ - 为用户定义类型的 shared_ptr 专门化标准库函数是否合法？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/42631359/