構建以元組為鍵的無序映射

Question

在帶有 Boost 的 C++ 程序中，我試圖構建一個無序映射，其鍵是雙精度元組：

typedef boost::tuples::tuple<double, double, double, double> Edge;
typedef boost::unordered_map< Edge, int > EdgeMap;

初始化地圖可以完成，但是，當我嘗試用鍵和值填充它時

EdgeMap map;
Edge key (0.0, 0.1, 1.1, 1.1);
map[key] = 1;

我遇到以下錯誤消息：

/usr/include/boost/functional/hash/extensions.hpp:176: error: no matching function for call to ‘hash_value(const boost::tuples::tuple<double, double, double, double, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>&)’

我認為這是因為我需要為元組鍵指定一個哈希函數。 我該怎么做？

編輯：

按照以下建議，我編寫了以下實現：

#include <boost/tuple/tuple.hpp>
#include <boost/unordered_map.hpp>

typedef boost::tuples::tuple<double, double, double, double> Edge;

struct ihash
    : std::unary_function<Edge, std::size_t>
{
    std::size_t operator()(Edge const& e) const
    {
        std::size_t seed = 0;
        boost::hash_combine( seed, e.get<0>() );
        boost::hash_combine( seed, e.get<1>() );
        boost::hash_combine( seed, e.get<2>() );
        boost::hash_combine( seed, e.get<3>() );
        return seed;
    }
};

struct iequal_to
    : std::binary_function<Edge, Edge, bool>
{
    bool operator()(Edge const& x, Edge const& y) const
    {
        return ( x.get<0>()==y.get<0>() &&
                 x.get<1>()==y.get<1>() &&
                 x.get<2>()==y.get<2>() &&
                 x.get<3>()==y.get<3>());
    }
};

typedef boost::unordered_map< Edge, int, ihash, iequal_to > EdgeMap;

int main() {

    EdgeMap map;
    Edge key (0.0, 0.1, 1.1, 1.1);
    map[key] = 1;

    return 0;
}

可以縮短嗎？

Answer 1

實際上，您可以完美地為boost::tuple定義一個通用哈希函數。 唯一的要求是它位於同一個命名空間中，以便 ADL 選擇它。

我實際上很驚訝他們還沒有寫一個。

namespace boost { namespace tuples {

  namespace detail {

    template <class Tuple, size_t Index = length<Tuple>::value - 1>
    struct HashValueImpl
    {
      static void apply(size_t& seed, Tuple const& tuple)
      {
        HashValueImpl<Tuple, Index-1>::apply(seed, tuple);
        boost::hash_combine(seed, tuple.get<Index>());
      }
    };

    template <class Tuple>
    struct HashValueImpl<Tuple,0>
    {
      static void apply(size_t& seed, Tuple const& tuple)
      {
        boost::hash_combine(seed, tuple.get<0>());
      }
    };
  } // namespace detail

  template <class Tuple>
  size_t hash_value(Tuple const& tuple)
  {
    size_t seed = 0;
    detail::HashValueImpl<Tuple>::apply(seed, tuple);
    return seed;
  }

} }

注意：我只是證明它是正確的，我還沒有測試過。

Answer 2

你需要一點 前台。 由於boost::tuples::tuple的底層實現，使Edge成為一個允許重載正確解析的結構。 否則，您將無法獲得匹配項

• boost::hash_value(const Edge &)
• operator==(const Edge &, const Edge &)

代碼如下：

struct Edge {
  Edge(double x1, double x2, double x3, double x4)
    : tuple(x1,x2,x3,x4) {}
  boost::tuples::tuple<double, double, double, double> tuple;
};

// XXX: less than ideal implementation!
bool operator==(const Edge &a, const Edge &b)
{
  return a.tuple.get<0>() == b.tuple.get<0>() &&
         a.tuple.get<1>() == b.tuple.get<1>() &&
         a.tuple.get<2>() == b.tuple.get<2>() &&
         a.tuple.get<3>() == b.tuple.get<3>();
}

// XXX: me too!
std::size_t hash_value(const Edge &e)
{
  std::size_t seed = 0;
  boost::hash_combine(seed, e.tuple.get<0>());
  boost::hash_combine(seed, e.tuple.get<1>());
  boost::hash_combine(seed, e.tuple.get<2>());
  boost::hash_combine(seed, e.tuple.get<3>());
  return seed;
}

typedef boost::unordered_map< Edge, int > EdgeMap;

Answer 3

一切都在文檔中......

• http://www.boost.org/doc/libs/1_38_0/doc/html/hash/custom.html
• http://www.boost.org/doc/libs/1_38_0/doc/html/hash/combine.html

你需要這樣的東西：

std::size_t hash_value(Edge const& e)
{
    std::size_t seed = 0;
    boost::hash_combine( seed, e.get<0>() );
    boost::hash_combine( seed, e.get<1>() );
    boost::hash_combine( seed, e.get<2>() );
    boost::hash_combine( seed, e.get<3>() );
    return seed;
}

...然后你可以定義：

boost::unordered_map< Edge, int, boost::hash< Edge > > EdgeMap;

...實際上這是默認值，因此它現在應該可以在沒有顯式哈希定義的情況下工作：

boost::unordered_map< Edge, int > EdgeMap;

Answer 4

你有沒有試過使用這個：

#include "boost/functional/hash.hpp"
#include <unordered_map>
#include <tuple>

using Edge = std::tuple<double, double, double, double>;

struct KeyHash {
    std::size_t operator()(const Edge & key) const {
        return boost::hash_value(key);
    }
};

using EdgeMap = std::unordered_map<Edge, int, KeyHash>;

請注意，我將std用於tuple和unordered_map 。

您可以在此編譯器資源管理器鏈接上使用甚至 lambda 來查看完整代碼。

Answer 5

來自unordered_map / unordered_set 中元組的通用散列代碼為所有 c++11 標准散列類型（字符串、整數等）元組提供了神奇的支持。

不出所料，它看起來非常像上面 Matthieu M. 的解決方案，但沒有提升依賴項。

將代碼放在頭文件中並包含它，無序的元組集將開箱即用：

#include <tuple>
namespace std{
    namespace
    {

        // Code from boost
        // Reciprocal of the golden ratio helps spread entropy
        //     and handles duplicates.
        // See Mike Seymour in magic-numbers-in-boosthash-combine:
        //     https://stackoverflow.com/questions/4948780

        template <class T>
        inline void hash_combine(std::size_t& seed, T const& v)
        {
            seed ^= hash<T>()(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
        }

        // Recursive template code derived from Matthieu M.
        template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1>
        struct HashValueImpl
        {
          static void apply(size_t& seed, Tuple const& tuple)
          {
            HashValueImpl<Tuple, Index-1>::apply(seed, tuple);
            hash_combine(seed, get<Index>(tuple));
          }
        };

        template <class Tuple>
        struct HashValueImpl<Tuple,0>
        {
          static void apply(size_t& seed, Tuple const& tuple)
          {
            hash_combine(seed, get<0>(tuple));
          }
        };
    }

    template <typename ... TT>
    struct hash<std::tuple<TT...>> 
    {
        size_t
        operator()(std::tuple<TT...> const& tt) const
        {                                              
            size_t seed = 0;                             
            HashValueImpl<std::tuple<TT...> >::apply(seed, tt);    
            return seed;                                 
        }                                              

    };
}

Answer 6

Boost 文檔提供了 所需的接口。 在不了解更多有關價值的情況下，很難說更多。 給定一個鍵對象作為輸入，它必須產生一個確定性的 size_t —— 即，它是一個純函數，其結果僅取決於輸入值，因此給出相同的輸入將始終產生相同的哈希碼。