4

According to this, it is possible to define an equality function in a TR1 unordered_map like this:

#include <tr1/unordered_map>
using namespace std;
using namespace std::tr1;
struct foo{
    ...
    bool operator==(const foo& b) const{
        return ..;
    }
};

unordered_map<foo,int> map;

Is it possible to define the hash function the same way?

Alexandros
  • 3,044
  • 1
  • 23
  • 37

2 Answers2

12

If you want to change the default hashing (or, more often, provide hashing for a type that isn't currently supported), you provide a specialization of std::tr1::hash<T> for your key-type:

namespace std { 
namespace tr1 { 
    template<>
    struct hash<typename my_key_type> {
        std::size_t operator()(my_key_type const &key) {
            return whatever;
        }
    };
}
}

Note that specializing an existing template for a user-defined type is one of the rare cases where you specifically are allowed to write code in namespace std.

Jerry Coffin
  • 476,176
  • 80
  • 629
  • 1,111
1

The signature of the unordered_map class is this:

template<class Key,
    class Ty,
    class Hash = std::hash<Key>,
    class Pred = std::equal_to<Key>,
    class Alloc = std::allocator<std::pair<const Key, Ty> > >
    class unordered_map;

Your example works because the default Pred, std::equal_to<>, by default checks for equality using operator==. The compiler finds your foo::operator== member function and uses that.

std::hash doesn't have any specialisation which will call a member function on your class, so you can't just add a member to foo with a custom hash. You will need to specialise std::hash instead. If you want that to call a member function on foo, go ahead. You'll end up with something like this:

struct foo
{
    size_t hash() const
    {
       // hashing method here, return a size_t
    }
};

namespace std
{
    // Specialise std::hash for foo.
    template<>
    class hash< foo >
        : public unary_function< foo, size_t >
    {
    public:
        size_t operator()( const foo& f )
        {
            return f.hash();
        }
    };
}
RobH
  • 3,199
  • 1
  • 22
  • 27
  • I get a warning with this that it has a non-virtual destructor. Suggestions? – vy32 Aug 02 '13 at 23:59
  • Turns out that you don't need the subclass. – vy32 Aug 03 '13 at 00:02
  • Note that the above isn't a subclass, it is a template specialisation. The non-virtual destructor warning suggests that you've misread it as a subclass. The aim is not to subclass hash, but to provide a specialised implementation tailored to your data type. – RobH Aug 22 '13 at 14:07
  • Make the operator *const*: `operator()(foo const& f) const ...` – cdunn2001 Mar 06 '14 at 20:35