How to extend std::tr1::hash for custom types?

Question

How do I allow the STL implementation to pick up my custom types? On MSVC, there is a class std::tr1::hash, which I can partially specialize by using

namespace std 
{
    namespace tr1 
    { 
        template <> 
        struct hash<MyType> 
        { ... };
    } 
}

but is this the recommended way? Moreover, does this work with GCC's implementation as well? For boost::hash, it's enough to provide a free function size_t hash_value (const MyType&), is there something similar for the TR1 implementation?

Answer 1

I was trying to work out the exact syntax for doing this with the unordered associative containers (also using GCC, as the OP was asking) and hit this question.

Unfortunately it didn't go down to the level of detail I wanted. By looking through the gcc headers at how they have implemented the standard hash functions I got it working. In view of the dearth of examples (at least at time of writing) on the web I thought this would be as good a place as any to post my own example (which I can confirm works with GCC):

namespace std { namespace tr1
{
   template <>
   struct hash<MyType> : public unary_function<MyType, size_t>
   {
       size_t operator()(const MyType& v) const
       {
           return /* my hash algorithm */;
       }
   };
}}

(notice there are two namespaces here - that's just my convention for collapsing nested namespaces)

Answer 2

Yes, this will also work for GCC. I'm using it in a bigger project and it works without problems. You could also provide your own custom hashing class for the TR1 containers, but it is specified that std::tr1::hash<> is the default hashing class. Specializing it for custom types seems like the natural way to extend the standard hashing functionality.

Answer 3

As you are not adding to std library namespace, but only providing the specialisations, then it is perfectly OK.

If you want to provide more generic hashing approach (for example hash for the tuples in general) then have a look at Boost Fusion. Here is a simple example, which will work for most of the cases (probably with the exception for tuple of tuples)