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

问题

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?

回答1:

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.

回答2:

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)

回答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)

回答4:

The following code snippet shows how to specialize std::tr1::unordered_map to mapping boost::const_string<char> to void* analogously with how std::string is hashed.

#include <boost/const_string/const_string.hpp>    
typedef class boost::const_string<char> csc;

namespace std
{
namespace tr1
{
template <>
struct hash<csc> {
public:
    size_t operator()(const csc & x) const {
        return std::_Hash_impl::hash(x.data(), x.size());
    }
};
}
}

typedef std::tr1::unordered_map<csc, void*> Map;
typedef Map::value_type Dual; ///< Element Type.

来源：https://stackoverflow.com/questions/647967/how-to-extend-stdtr1hash-for-custom-types

标签

c++

tr1