Построение неупорядоченной карты с кортежами в качестве ключей

Ответ 1

Вам нужно немного front matter. Из-за базовой реализации 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;

Ответ 2

Собственно, вы можете отлично определить общую хеш-функцию для 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;
  }

} }

Примечание: я только доказал это правильно, я его не тестировал.

Ответ 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;

Ответ 4

Документация Boost предоставляет необходимый интерфейс. Не зная больше о значениях, трудно сказать гораздо больше. Учитывая ключевой объект как вход, он должен произвести size_t, который является детерминированным, т.е. Является чистой функцией, где результат зависит только от входного значения, поэтому при предоставлении того же входа всегда будет выдаваться один и тот же хэш-код.

Ответ 5

Этот код из Общий хеш для кортежей в unordered_map/unordered_set обеспечивает магическую поддержку для всех С++ 11 наборов стандартных хешируемых типов (строки, int и т.д.).

Неудивительно, что он очень похож на решение 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/info/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;                                 
        }                                              

    };
}