按特征类专门化函数

Question

我正在编写一个哈希函子，用于 boost::unordered_map ，它将存储 boost::graph 边缘描述符。够简单的。然而，无向图和有向图边必须以不同的方式进行散列（至少在我的情况下，当图为无向，因此 map[(u,v)] 和 map[(v,u)] 必须指向相同的值）。我可以使用图形特征类 (boost::graph_traits::directed_category) 检测方向性，但是如何使用模板定义不同的实现呢？

下面是我到目前为止所得到的，但我不需要 if 子句。相反，我希望 EdgeHash 根据 directed_category 的值编译不同版本的 operator() 。如何才能实现这一目标？

template <typename Graph>
struct EdgeHash {
    typedef typename boost::graph_traits<Graph>::edge_descriptor Edge;
    std::size_t operator()(const Edge& e) const {
        std::size_t hash = 0;
        if(boost::is_same<boost::graph_traits<Graph>::directed_category, boost::directed_tag>::value) {
            boost::hash_combine(hash, e.m_source);
            boost::hash_combine(hash, e.m_target);
        } else {
            boost::hash_combine(hash, std::min(e.m_source, e.m_target));
            boost::hash_combine(hash, std::max(e.m_source, e.m_target));
        }
        return hash;
    }
};

Answer 1

也许在实际的 EdgeHash 类中添加一个 bool 模板参数？例如：

template <typename Graph, bool is_directed>
struct EdgeHashImpl {
    typedef typename boost::graph_traits<Graph>::edge_descriptor Edge;
    std::size_t operator()(const Edge& e) const {
        std::size_t hash = 0;
        boost::hash_combine(hash, e.m_source);
        boost::hash_combine(hash, e.m_target);
    return hash;
   }
};

template <typename Graph>
struct EdgeHashImpl <Graph, false>
{
  typedef typename boost::graph_traits<Graph>::edge_descriptor Edge;
  std::size_t operator()(const Edge& e) const {
      std::size_t hash = 0;
      boost::hash_combine(hash, std::min(e.m_source, e.m_target));
      boost::hash_combine(hash, std::max(e.m_source, e.m_target));
      return hash;
   }
};


template <typename Graph>
struct EdgeHash 
: public EdgeHashImpl
  <Graph, boost::is_same<boost::graph_traits<Graph>::directed_category, boost::directed_tag>::value)>
{};

Answer 2

将哈希放入以定向类别类型为模板的单独结构中。

template<typename Directed, typename Edge>
struct Hasher {
    static std::size_t edge_hash(const Edge& e) {
        std::size_t hash = 0;
        boost::hash_combine(hash, e.m_source);
        boost::hash_combine(hash, e.m_target);
        return hash;
    }
};

template<typename Edge>
struct Hasher<boost::directed_tag, Edge> {
    static std::size_t edge_hash(const Edge& e) {
        std::size_t hash = 0;
        boost::hash_combine(hash, std::min(e.m_source, e.m_target));
        boost::hash_combine(hash, std::max(e.m_source, e.m_target));
        return hash;
    }
};

template <typename Graph>
struct EdgeHash {
    typedef typename boost::graph_traits<Graph>::edge_descriptor Edge;
    std::size_t operator()(const Edge& e) const {
        return Hasher<
            boost::graph_traits<Graph>::directed_category,
            Edge>::edge_hash(e);
    }
};

Answer 3

使用boost::enable_if，您可以做到这一点，但是，您必须专门化该结构。例如（未经测试）

template <typename Graph, class Enable = void>
struct EdgeHash {
    typedef typename boost::graph_traits<Graph>::edge_descriptor Edge;
    std::size_t operator()(const Edge& e) const {
        std::size_t hash = 0;
        boost::hash_combine(hash, std::min(e.m_source, e.m_target));
        boost::hash_combine(hash, std::max(e.m_source, e.m_target));
        return hash;
    }
};

template <typename Graph>
struct EdgeHash<Graph, typename boost::enable_if<boost::is_same<boost::graph_traits<Graph>::directed_category, boost::directed_tag> >::type>
{
    typedef typename boost::graph_traits<Graph>::edge_descriptor Edge;
    std::size_t operator()(const Edge& e) const {
        std::size_t hash = 0;
        boost::hash_combine(hash, e.m_source);
        boost::hash_combine(hash, e.m_target);
        return hash;
    }
};