Question

using c++ std’s unordered_map i want to map an integer triplet to a single integer, i usually don’t use hash tables(didn’t know they were so cool), but i don’t know the right approach in this case, using the default hashing function should i map the triplets directly (something like < < int,int >,int >->int)

std::unordered_map <std::make_pair <make_pair <int,int>,int>,int> hash;

or maybe use a function to map the triplet to a single value and the use that value with the default function?

int mapping(int a, int b, int c){
}

std::unordered_map <int,int> hash;

both approaches work but i’d like to know wich one is the most efficient one. thank you

Answer 1

First off, you would use std::tuple<int, int, int> as the key type.

Next, you need a way to hash a tuple given that you can hash each element. There is a function called hash_combine in Boost that does that, but for reasons unclear to me, that one was not included in the standard. Anyway, here it goes:

#include <tuple>
#include <utility>

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

template <class Tuple, std::size_t Index = std::tuple_size<Tuple>::value - 1>
struct tuple_hash_impl
{
    static inline void apply(std::size_t & seed, Tuple const & tuple)
    {
        tuple_hash_impl<Tuple, Index - 1>::apply(seed, tuple);
        hash_combine(seed, std::get<Index>(tuple));
    }
};

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

namespace std
{
    template<typename S, typename T> struct hash<pair<S, T>>
    {
        inline size_t operator()(const pair<S, T> & v) const
        {
            size_t seed = 0;
            ::hash_combine(seed, v.first);
            ::hash_combine(seed, v.second);
            return seed;
        }
    };

    template<typename ...Args> struct hash<tuple<Args...>>
    {
        inline size_t operator()(const tuple<Args...> & v) const
        {
            size_t seed = 0;
            tuple_hash_impl<tuple<Args...>>::apply(seed, v);
            return seed;
        }
    };
}